buninu 0.4.21 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.5.0 - 2026-10-21
+
+- Sync jsgotty to 1.2.0:
+  * Add opt-in Kitty keyboard support for disambiguated shortcuts, including
+    Super, and press/repeat/release events. Support flags 1, 2 and 8, mode
+    queries, and independent mode stacks for normal and alternate screens;
+    legacy keyboard encoding remains the default.
+  * Recover Super state on Android WebViews that deliver Meta key events but
+    omit the modifier state. Handle Android Alt shortcuts without accent
+    dead-key conversion, including recognizable keyup-only events.
+  * Preserve Alt on arrow, Insert, PageUp and PageDown shortcuts, and encode
+    Ctrl+/ as the conventional US control character.
+  * Add a manual keyboard tester with readable, colored shortcut names and
+    raw sequences; restore keyboard and raw modes when it exits.
+  * Allow local Kitty graphics consumers to request binary image data,
+    avoiding a base64 conversion; browser clients retain base64 by default.
+- Sync bunmsh to 0.4.1: use the existing linker-aware shell launcher for the
+  awk fallback's subprocess commands instead of bypassing linker handling.
+
 ## 0.4.21 - 2026-10-15
 
 - Sync jsgotty to 1.1.16: Turn on pixel report

package/apps/bunmsh/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable user-visible changes to bunmsh are documented here.
 
+## [0.4.1] - 2026-10-13
+
+- Fixed awk bypassing linker protection
+
 ## [0.4.0] - 2026-10-13
 
 ### Added and fixed

package/apps/bunmsh/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmsh",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Cross-platform command shell for Bun JavaScript",
   "license": "MIT",
   "type": "module",

package/apps/bunmsh/src/shell.js

@@ -3236,7 +3236,7 @@ async function runAwkFallback(argv, state, input) {
         try {
           const file=resolvePath(directory,"state.json");
           writeFileSync(file,pipelineBuiltinState(state).env[PIPELINE_STATE_ENV],{mode:0o600});
-          const p=Bun.spawnSync([process.execPath,BUNMSH_ENTRY,"-c",command],{
+          const p=Bun.spawnSync(pipelineCompoundArgv(command),{
             cwd:nativePath(state.cwd),env:{...externalEnvironment(state),[PIPELINE_STATE_ENV]:`@file:${file}`},
             stdin:bytes(text),stdout:"pipe",stderr:"pipe"});
           if(p.error)throw p.error;

package/apps/jsgotty/README.en.md

@@ -3,6 +3,11 @@
 [中文 README](README.md)
 
 ## News
+
+### 2026/10/21
+
+- Added [Kitty keyboard](#kitty-keyboard) support for distinct modifier combinations, including Super, and press/repeat/release events.
+
 ### 2026/08/16
 - Fixed the disconnected-screen `Reconnect` button not being clickable in WebGL mode.
 - The `Reconnect` UI now stays above the WebGL canvas and receives mouse and touch events correctly; Kitty image handling no longer intercepts right-click / long-press for entering a reconnect token or PID.
@@ -238,6 +243,41 @@ The `jsgotty` server has two connection modes:
 - On disconnect, the overlay provides a `Reconnect` button for immediate manual retry.
 - Right-click / long-press on that button lets you enter a custom reconnect token or PID.
 
+## Kitty keyboard
+
+The web terminal supports the shortcut-related parts of the [Kitty keyboard protocol](https://sw.kovidgoyal.net/kitty/keyboard-protocol/), separately from Kitty graphics. Legacy keyboard encoding remains the default. A terminal application can opt in:
+
+```sh
+printf '\033[>11u'  # 1: disambiguation + 2: repeat/release + 8: all keys
+printf '\033[<u'    # restore the previous mode when the application exits
+```
+
+The receiving application must decode these sequences and restore the mode in its exit/finally handler; do not leave an ordinary shell in this mode. Negotiation supports `CSI ? u`, `CSI = flags ; mode u`, push and pop. Normal and alternate screens have independent stacks, limited to 32 entries. Reconnection, full reset and soft reset clear the state. Use flag `1` for unambiguous shortcuts, or `11` for modifier keys and press/repeat/release reporting.
+
+DOM Meta maps to Kitty **Super (bit 8)**, not the separate Meta bit (32). Super+X is `CSI 120;9u`; Ctrl+Shift+Super+X is `CSI 120;14u`. Release events add `:3` when enabled.
+
+Supported flags are **1, 2 and 8**; alternate keys (4) and associated text (16) are not implemented or reflected in the negotiated flags. IME composition/text commits and paste retain their existing paths; physical keys and releases cannot be inferred from committed text. Letters, digits, punctuation, navigation, Tab/Enter, function keys, keypad keys and standard Kitty media keys retain distinct modifiers. OS/browser-reserved shortcuts may never reach the page. Keys without standard Kitty codes, such as brightness and microphone mute, are not assigned private encodings.
+
+This implements **jsgotty → PTY** encoding. Controlling Hyprland/Omarchy still requires Casty or another receiver to enable/decode Kitty keyboard and forward Super and release events. It does not complete the remote desktop input chain or change the mouse protocol.
+
+Reload the jsgotty page after updating. Run the manual tester inside its terminal:
+
+```sh
+bun tests/manual/kitty-keyboard.js
+```
+
+It prints negotiated flags, raw sequences, modifiers and event types, exits after 60 seconds or unmodified Escape/q/Ctrl-C, and restores the previous keyboard/raw modes. An optional real bundled-xterm test uses an already installed browser:
+
+```sh
+CHROMIUM_HEADLESS=/path/to/chromium-headless-shell node --test tests/kitty-keyboard-browser.test.js
+```
+
+## Android Keyboards
+
+For Android WebViews that deliver Meta down/up but lose `metaKey`, jsgotty tracks both Meta keys inside its own input handler. Blur or page hiding clears held state and sends releases for reported keys when event reporting is enabled.
+
+In the Android terminal, Alt with letters, digits, punctuation, or space sends terminal Alt sequences based on physical key positions (US layout, including Shift), bypassing accent dead-key handling. Alt-E/I/N/U therefore no longer compose characters such as é, ê, ñ, and ü; input methods and paste remain available. When WebView omits `code`, recognized legacy `keyCode` values provide a fallback. Dead keys delivered only as `keyup` send the shortcut on release, without duplicating a previously handled `keydown`. Active composition, Ctrl, Meta, AltGr, and unidentified keys retain their existing handling. This applies only inside the jsgotty terminal and does not modify Android system keyboard settings.
+
 ## Tested platforms
 - Windows x64: Windows 11
 - Linux x64: CachyOS

package/apps/jsgotty/README.md

@@ -3,6 +3,11 @@
 [English README](README.en.md)
 
 ## News
+
+### 2026/10/21
+
+- 新增 [Kitty keyboard](#kitty-keyboard) 支援，可區分 Super 等修飾鍵組合，並回報按下、重複與放開事件。
+
 ### 2026/08/16
 - 修正 WebGL 模式下斷線畫面的 `Reconnect` 按鈕無法點擊。
 - `Reconnect` 介面現在會正確位於 WebGL canvas 上方並接收滑鼠與觸控事件；右鍵／長按輸入 reconnect token 或 PID 也不會被 Kitty 圖片事件攔截。
@@ -238,6 +243,41 @@ bun gotty.js --client -k <token|pid> [target]
 - 斷線時會提供 `Reconnect` 按鈕，可手動立即重試。
 - 該按鈕右鍵/長按可輸入自訂 reconnect token 或 PID。
 
+## Kitty keyboard
+
+網頁終端現在支援 [Kitty keyboard protocol](https://sw.kovidgoyal.net/kitty/keyboard-protocol/) 的快捷鍵相關功能，與 Kitty 圖片協定分開。預設仍是原本的鍵盤編碼；由終端內的程式選擇開啟：
+
+```sh
+printf '\033[>11u'  # 1：消除歧義 + 2：重複／放開事件 + 8：回報所有按鍵
+printf '\033[<u'    # 程式退出時還原上一層模式
+```
+
+程式必須能解析新編碼，並在 finally／退出處理中還原模式，不建議直接在一般 shell 長期開啟。支援 `CSI ? u` 查詢、`CSI = flags ; mode u` 設定／加上／移除旗標、`CSI > flags u` push 與 `CSI < count u` pop。主畫面與 alternate screen 各有獨立堆疊（上限 32 層）；重連、完整重設或 soft reset 會清除狀態。只需要無歧義快捷鍵時可用旗標 `1`；需要獨立修飾鍵及所有按鍵的 down/repeat/up 時使用 `11`。
+
+網頁的 Meta 對應 Kitty 的 **Super（bit 8）**，不是協定中的另一個 Meta（bit 32）。例如 Super+X 是 `CSI 120;9u`，Ctrl+Shift+Super+X 是 `CSI 120;14u`；啟用事件回報後，放開會帶 `:3`。
+
+目前支援旗標 **1、2、8**；尚未實作替代鍵位（4）與附帶文字（16），查詢只回報實際啟用的旗標。IME 組字／文字提交與貼上保留既有路徑，不保證能回報實體按鍵或放開事件。字母、數字、標點、方向鍵、Tab、Enter、功能鍵、數字鍵盤與有標準 Kitty 編碼的媒體鍵可區分修飾組合；系統／瀏覽器先攔截的快捷鍵不會到達網頁，亮度、麥克風靜音等沒有標準 Kitty 鍵碼的鍵也不會擅自編成私有序列。
+
+這完成的是 **jsgotty → PTY** 的鍵盤編碼。要操作 Hyprland／Omarchy，Casty 或其他接收程式仍須啟用、解析 Kitty keyboard 並轉送 Super 與放開事件；此項改動不代表整條遠端桌面輸入鏈已完成，也不改變滑鼠協定。
+
+在 jsgotty 終端內手動確認（60 秒後自動退出，或按未修飾的 Esc／q／Ctrl+C）：
+
+```sh
+bun tests/manual/kitty-keyboard.js
+```
+
+測試會印出協商結果、原始序列、修飾鍵及 press/repeat/release；結束時還原鍵盤模式與 raw mode。更新後請重新載入 jsgotty 網頁。可用既有 Chromium 執行真正 xterm 前端測試，不會自動安裝瀏覽器：
+
+```sh
+CHROMIUM_HEADLESS=/path/to/chromium-headless-shell node --test tests/kitty-keyboard-browser.test.js
+```
+
+## Android 鍵盤
+
+Android WebView 若有 `Meta` down/up 卻漏掉 `metaKey`，jsgotty 會在自己的輸入處理中追蹤左右 Meta 並還原 Super。失焦或頁面隱藏時清除按住狀態；已送出的按鍵在事件回報模式下會補送放開。
+
+Android 終端的 Alt＋字母、數字、標點及空白會依實體按鍵位置（美式配置，支援 Shift）送出終端 Alt 序列，不進入重音死鍵流程。因此 Alt-E/I/N/U 等組合不再用來輸入 é、ê、ñ、ü；仍可使用輸入法或貼上。若 WebView 省略 `code`，會回退使用可辨識的 `keyCode`；若死鍵只送出 `keyup`，則在放開時補送一次，避免與已處理的 `keydown` 重複。正在組字、Ctrl、Meta、AltGr，以及無法辨識按鍵的事件維持原本處理。此規則只作用於 jsgotty 終端，不修改 Android 的系統鍵盤配置。
+
 ## Tested platforms 已測試作業系統
 - Windows x64: Windows 11
 - Linux x64: CachyOS

package/apps/jsgotty/gotty.js

@@ -1001,7 +1001,9 @@ class CursorStateTracker {
 }
 
 class KittyGraphicsParser {
-  constructor() {
+  constructor({ binaryData = false } = {}) {
+    // Local renderers can consume bytes directly; browser clients retain base64.
+    this.binaryData = binaryData;
     this.pending = Buffer.alloc(0);
     this.transfers = new Map();
     this.images = new Map();
@@ -1220,7 +1222,7 @@ class KittyGraphicsParser {
       width: Number.parseInt(existing.control.s || "0", 10),
       height: Number.parseInt(existing.control.v || "0", 10),
       mime: existing.control.U || existing.control.mime || null,
-      data: binary.toString("base64")
+      data: this.binaryData ? binary : binary.toString("base64")
     };
 
     this.images.set(imageId, image);

package/apps/jsgotty/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "jsgotty",
-  "version": "1.1.16",
+  "version": "1.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "jsgotty",
-      "version": "1.1.16",
+      "version": "1.2.0",
       "dependencies": {
         "node-addon-api": "^7.1.1",
         "ws": "^8.18.3"

package/apps/jsgotty/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgotty",
-  "version": "1.1.16",
+  "version": "1.2.0",
   "description": "Share your terminal as a web application: A JavaScript rewrite of GoTTY",
   "license": "MIT",
   "bin": {

package/apps/jsgotty/static/index.html

@@ -30,6 +30,7 @@
   <script src="./js/windows_bridge.js"></script>
   <script src="./js/zmodem.js"></script>
   <script src="./js/xterm-addon-unicode11.js"></script>
+  <script src="./js/kitty-keyboard.js"></script>
   <script src="./js/gotty.js"></script>
 
 

package/apps/jsgotty/static/js/gotty.js

@@ -12543,6 +12543,12 @@
 	                toTerminal: (e) => this.term.write(e),
 	                toServer: (e) => this.sendInput(e),
 	              })),
+              (this.kittyKeyboard = new globalThis.GoTTYKittyKeyboard.KittyKeyboard(this.term, {
+                android: /Android/i.test(navigator.userAgent),
+              })),
+              this.term.attachCustomKeyEventHandler((event) =>
+                this.kittyKeyboard.handle(event) && this.handleAndroidAltKey(event),
+              ),
 	              this.setPreferences(t),
 	              (() => {
 	                try {
@@ -12594,12 +12600,73 @@
                     ));
               }),
               this.term.open(e),
+              this.kittyKeyboard.attach(this.term.textarea),
+              this.term.textarea?.addEventListener("blur", () => {
+                this.androidAltDownKeys?.clear();
+              }),
               this.term.focus(),
               this.resizeListener(),
               window.addEventListener("resize", () => {
                 this.resizeListener();
               }));
           }
+          // Android can translate physical Alt shortcuts into accent dead keys.
+          // Resolve printable physical keys before xterm's composition handling.
+          handleAndroidAltKey(event) {
+            if (!/Android/i.test(navigator.userAgent)) return true;
+            let code = event.code;
+            // Some Android IMEs omit code and swallow the dead-key keydown,
+            // but still deliver keyup with a usable legacy keyCode.
+            if (!code) {
+              if (event.keyCode >= 65 && event.keyCode <= 90)
+                code = "Key" + String.fromCharCode(event.keyCode);
+              else if (event.keyCode >= 48 && event.keyCode <= 57)
+                code = "Digit" + String.fromCharCode(event.keyCode);
+              else code = {
+                32: "Space", 186: "Semicolon", 187: "Equal", 188: "Comma",
+                189: "Minus", 190: "Period", 191: "Slash", 192: "Backquote",
+                219: "BracketLeft", 220: "Backslash", 221: "BracketRight", 222: "Quote",
+              }[event.keyCode];
+            }
+            this.androidAltDownKeys ??= new Set();
+            const alreadySent = event.type === "keyup" && this.androidAltDownKeys.delete(code);
+            if (
+              !["keydown", "keypress", "keyup"].includes(event.type) ||
+              !event.altKey || event.ctrlKey || event.metaKey ||
+              event.isComposing || event.getModifierState?.("AltGraph") ||
+              (event.type === "keyup" && event.key !== "Dead")
+            ) return true;
+
+            let character;
+            if (/^Key[A-Z]$/.test(code)) {
+              const letter = code.slice(3);
+              character = event.shiftKey ? letter : letter.toLowerCase();
+            } else if (/^Digit[0-9]$/.test(code)) {
+              const digit = code.slice(5);
+              character = event.shiftKey ? ")!@#$%^&*("[Number(digit)] : digit;
+            } else {
+              const punctuation = {
+                Backquote: ["`", "~"], Minus: ["-", "_"], Equal: ["=", "+"],
+                BracketLeft: ["[", "{"], BracketRight: ["]", "}"],
+                Backslash: ["\\", "|"], Semicolon: [";", ":"], Quote: ["'", '"'],
+                Comma: [",", "<"], Period: [".", ">"], Slash: ["/", "?"],
+                Space: [" ", " "],
+              };
+              character = Object.hasOwn(punctuation, code)
+                ? punctuation[code][event.shiftKey ? 1 : 0]
+                : undefined;
+            }
+            if (character === undefined) return true;
+            event.preventDefault();
+            event.stopPropagation();
+            if (event.type === "keydown") {
+              this.androidAltDownKeys.add(code);
+              this.term.input("\x1b" + character, true);
+            } else if (event.type === "keyup" && !alreadySent) {
+              this.term.input("\x1b" + character, true);
+            }
+            return false;
+          }
           info() {
             return { columns: this.term.cols, rows: this.term.rows };
           }
@@ -12610,6 +12677,7 @@
             return this.message;
           }
           setDisconnected(e) {
+            if (e) this.kittyKeyboard.reset();
             this.disconnected = !!e;
           }
           setReconnectAction(e) {
@@ -12721,9 +12789,11 @@
             this.term.blur();
           }
           reset() {
+            this.kittyKeyboard.reset();
             (this.removeMessage(), this.term.clear());
           }
           close() {
+            this.kittyKeyboard.dispose();
             (window.removeEventListener("resize", this.resizeListener),
               this.term.dispose());
           }
@@ -26746,39 +26816,32 @@
                         case 37:
                           if (e.metaKey) break;
                           a
-                            ? ((o.key = r.C0.ESC + "[1;" + (a + 1) + "D"),
-                              o.key === r.C0.ESC + "[1;3D" &&
-                                (o.key = r.C0.ESC + (i ? "b" : "[1;5D")))
+                            ? (o.key = r.C0.ESC + "[1;" + (a + 1) + "D")
                             : (o.key = t ? r.C0.ESC + "OD" : r.C0.ESC + "[D");
                           break;
                         case 39:
                           if (e.metaKey) break;
                           a
-                            ? ((o.key = r.C0.ESC + "[1;" + (a + 1) + "C"),
-                              o.key === r.C0.ESC + "[1;3C" &&
-                                (o.key = r.C0.ESC + (i ? "f" : "[1;5C")))
+                            ? (o.key = r.C0.ESC + "[1;" + (a + 1) + "C")
                             : (o.key = t ? r.C0.ESC + "OC" : r.C0.ESC + "[C");
                           break;
                         case 38:
                           if (e.metaKey) break;
                           a
-                            ? ((o.key = r.C0.ESC + "[1;" + (a + 1) + "A"),
-                              i ||
-                                o.key !== r.C0.ESC + "[1;3A" ||
-                                (o.key = r.C0.ESC + "[1;5A"))
+                            ? (o.key = r.C0.ESC + "[1;" + (a + 1) + "A")
                             : (o.key = t ? r.C0.ESC + "OA" : r.C0.ESC + "[A");
                           break;
                         case 40:
                           if (e.metaKey) break;
                           a
-                            ? ((o.key = r.C0.ESC + "[1;" + (a + 1) + "B"),
-                              i ||
-                                o.key !== r.C0.ESC + "[1;3B" ||
-                                (o.key = r.C0.ESC + "[1;5B"))
+                            ? (o.key = r.C0.ESC + "[1;" + (a + 1) + "B")
                             : (o.key = t ? r.C0.ESC + "OB" : r.C0.ESC + "[B");
                           break;
                         case 45:
-                          e.shiftKey || e.ctrlKey || (o.key = r.C0.ESC + "[2~");
+                          e.shiftKey || e.ctrlKey ||
+                            (o.key = e.altKey
+                              ? r.C0.ESC + "[2;" + (a + 1) + "~"
+                              : r.C0.ESC + "[2~");
                           break;
                         case 46:
                           o.key = a
@@ -26802,14 +26865,14 @@
                         case 33:
                           e.shiftKey
                             ? (o.type = 2)
-                            : e.ctrlKey
+                            : e.ctrlKey || e.altKey
                               ? (o.key = r.C0.ESC + "[5;" + (a + 1) + "~")
                               : (o.key = r.C0.ESC + "[5~");
                           break;
                         case 34:
                           e.shiftKey
                             ? (o.type = 3)
-                            : e.ctrlKey
+                            : e.ctrlKey || e.altKey
                               ? (o.key = r.C0.ESC + "[6;" + (a + 1) + "~")
                               : (o.key = r.C0.ESC + "[6~");
                           break;
@@ -26927,6 +26990,8 @@
                                     ))
                                   : 56 === e.keyCode
                                     ? (o.key = r.C0.DEL)
+                                    : "/" === e.key
+                                      ? (o.key = r.C0.US)
                                     : 219 === e.keyCode
                                       ? (o.key = r.C0.ESC)
                                       : 220 === e.keyCode

package/apps/jsgotty/static/js/kitty-keyboard.js

@@ -0,0 +1,193 @@
+// Kitty keyboard transport for the shipped xterm wrapper (no build step).
+// Spec: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+(function (root) {
+  'use strict';
+  // Supported progressive enhancements: disambiguation, event types, all keys.
+  // Do not advertise alternate-layout/text reporting until those are implemented.
+  const SUPPORTED = 1 | 2 | 8;
+  const functional = {
+    Escape:[27,'u'], Enter:[13,'u'], Tab:[9,'u'], Backspace:[127,'u'],
+    Insert:[2,'~'], Delete:[3,'~'], ArrowLeft:[1,'D'], ArrowRight:[1,'C'],
+    ArrowUp:[1,'A'], ArrowDown:[1,'B'], PageUp:[5,'~'], PageDown:[6,'~'],
+    Home:[1,'H'], End:[1,'F'], CapsLock:[57358,'u'], ScrollLock:[57359,'u'],
+    NumLock:[57360,'u'], PrintScreen:[57361,'u'], Pause:[57362,'u'], ContextMenu:[57363,'u'],
+    MediaPlay:[57428,'u'], MediaPause:[57429,'u'], MediaPlayPause:[57430,'u'],
+    MediaStop:[57432,'u'], MediaFastForward:[57433,'u'], MediaRewind:[57434,'u'],
+    MediaTrackNext:[57435,'u'], MediaTrackPrevious:[57436,'u'], MediaRecord:[57437,'u'],
+    AudioVolumeDown:[57438,'u'], AudioVolumeUp:[57439,'u'], AudioVolumeMute:[57440,'u'],
+  };
+  [11,12,13,14,15,17,18,19,20,21,23,24].forEach((n,i) => functional['F'+(i+1)] = [n,'~']);
+  for (let i=13;i<=35;i++) functional['F'+i] = [57376+i-13,'u'];
+  const punctuation = {
+    Backquote:['`','~'], Minus:['-','_'], Equal:['=','+'], BracketLeft:['[','{'],
+    BracketRight:[']','}'], Backslash:['\\','|'], Semicolon:[';',':'], Quote:["'",'"'],
+    Comma:[',','<'], Period:['.','>'], Slash:['/','?'], Space:[' ',' '],
+  };
+  const modifiers = {Shift:[1,57441], Control:[4,57442], Alt:[2,57443], Meta:[8,57444],
+    OS:[8,57444], Super:[8,57444], Hyper:[16,57445], AltGraph:[0,57453]};
+  const has = (object,key) => Object.prototype.hasOwnProperty.call(object,key);
+  const lock = (e,name) => Boolean(e.getModifierState?.(name));
+  function physicalCode(e) {
+    if (e.code && e.code !== 'Unidentified') return e.code;
+    if (e.keyCode>=65 && e.keyCode<=90) return 'Key'+String.fromCharCode(e.keyCode);
+    if (e.keyCode>=48 && e.keyCode<=57) return 'Digit'+String.fromCharCode(e.keyCode);
+    return ({32:'Space',186:'Semicolon',187:'Equal',188:'Comma',189:'Minus',190:'Period',
+      191:'Slash',192:'Backquote',219:'BracketLeft',220:'Backslash',221:'BracketRight',222:'Quote'})[e.keyCode] || '';
+  }
+  function baseCharacter(e, android) {
+    const code=physicalCode(e);
+    // Android's Alt accent conversion must not turn an E/I/N/U shortcut into a dead key.
+    const recover=android && e.altKey && !lock(e,'AltGraph');
+    if (recover || ([...e.key || ''].length===1 && e.key.codePointAt(0)<32)) {
+      if (/^Key[A-Z]$/.test(code)) return code.slice(3).toLowerCase();
+      if (/^Digit[0-9]$/.test(code)) return code.slice(5);
+      if (has(punctuation,code)) return punctuation[code][0];
+    }
+    if ([...e.key || ''].length!==1) return null;
+    if (e.shiftKey) {
+      if (has(punctuation,code) && punctuation[code][1]===e.key) return punctuation[code][0];
+      if (/^Digit[0-9]$/.test(code) && ')!@#$%^&*('[Number(code.slice(5))]===e.key) return code.slice(5);
+    }
+    const lower=e.key.toLowerCase();
+    return [...lower].length===1 ? lower : e.key;
+  }
+  function keyDefinition(e, flags, android) {
+    if (has(modifiers,e.key)) {
+      const [bit,left]=modifiers[e.key];
+      const right=e.location===2 || /Right$/.test(e.code || '');
+      return {number:left+(right && e.key!=='AltGraph'?6:0),suffix:'u',modifier:bit};
+    }
+    if ((flags & 9) && (e.location===3 || /^Numpad/.test(e.code || ''))) {
+      const numpad={NumpadDecimal:57409,NumpadDivide:57410,NumpadMultiply:57411,
+        NumpadSubtract:57412,NumpadAdd:57413,NumpadEnter:57414,NumpadEqual:57415,
+        NumpadComma:57416};
+      const nav={ArrowLeft:57417,ArrowRight:57418,ArrowUp:57419,ArrowDown:57420,
+        PageUp:57421,PageDown:57422,Home:57423,End:57424,Insert:57425,Delete:57426,Clear:57427};
+      const number=has(nav,e.key)?nav[e.key]:/^Numpad[0-9]$/.test(e.code || '')
+        ?57399+Number(e.code.slice(6)):numpad[e.code];
+      if (number) return {number,suffix:'u'};
+    }
+    if (has(functional,e.key)) {
+      const [number,suffix]=functional[e.key];
+      return {number,suffix,recovery:['Enter','Tab','Backspace'].includes(e.key)};
+    }
+    const ch=baseCharacter(e,android);
+    return ch===null?null:{number:ch.codePointAt(0),suffix:'u',text:true};
+  }
+  class KittyKeyboard {
+    constructor(term, {android=false}={}) {
+      this.term=term; this.android=android; this.disposables=[];
+      this.metaKeys=new Set(); this.down=new Map(); this.suppressed=new Set(); this.reset();
+      const register=(prefix,fn) => this.disposables.push(term.parser.registerCsiHandler({prefix,final:'u'},p=>{fn(p);return true;}));
+      const value=(p,i,fallback=0) => Number.isInteger(p[i])?p[i]:fallback;
+      register('?',()=>term.input(`\x1b[?${this.flags}u`,false));
+      register('>',p=>{const s=this.state;s.stack.push(s.flags);if(s.stack.length>32)s.stack.shift();s.flags=value(p,0)&SUPPORTED;});
+      register('<',p=>{const s=this.state;let count=Math.min(value(p,0)||1,33);while(count--)s.flags=s.stack.pop()??0;});
+      register('=',p=>{const s=this.state,f=value(p,0)&SUPPORTED,m=value(p,1)||1;if(m===1)s.flags=f;else if(m===2)s.flags|=f;else if(m===3)s.flags&=~f;});
+      this.disposables.push(term.parser.registerEscHandler({final:'c'},()=>{this.reset();return false;}));
+      this.disposables.push(term.parser.registerCsiHandler({intermediates:'!',final:'p'},()=>{this.reset();return false;}));
+    }
+    get state() { return this.states[this.term.buffer.active.type==='alternate'?'alternate':'normal']; }
+    get flags() { return this.state.flags; }
+    reset() {
+      this.states={normal:{flags:0,stack:[]},alternate:{flags:0,stack:[]}};
+      this.clearHeld(false);
+    }
+    clearHeld(report=true) {
+      // Release keys reported to the client before losing focus, avoiding stuck remote keys.
+      if (report && (this.flags & 2)) for (const key of this.down.values()) {
+        if(key.reported) this.term.input(this.sequence(key.def,0,3),true);
+      }
+      this.metaKeys.clear();this.down.clear();this.suppressed.clear();this.suppressKeypress=false;
+    }
+    attach(element) {
+      const doc=element.ownerDocument, win=doc.defaultView;
+      const blur=()=>this.clearHeld();
+      const visibility=()=>{if(doc.hidden)this.clearHeld();};
+      element.addEventListener('blur',blur);win.addEventListener('blur',blur);
+      doc.addEventListener('visibilitychange',visibility);
+      this.disposables.push({dispose:()=>{element.removeEventListener('blur',blur);win.removeEventListener('blur',blur);doc.removeEventListener('visibilitychange',visibility);}});
+    }
+    dispose() {this.clearHeld(false);for(const d of this.disposables)d.dispose();}
+    sequence(def,bits,type) {
+      const event=(this.flags&2) && type!==1?':'+type:'';
+      const mods=bits+1;
+      if(def.suffix!=='u' && mods===1 && !event)
+        return '\x1b['+(def.number===1?'':def.number)+def.suffix;
+      return `\x1b[${def.number}${mods!==1||event?';'+mods+event:''}${def.suffix}`;
+    }
+    handle(event) {
+      if (!['keydown','keyup','keypress'].includes(event.type)) return true;
+      const identity=physicalCode(event)||event.key;
+      const metaKey=['Meta','OS','Super'].includes(event.key);
+      if(this.android && metaKey) {
+        if(event.type==='keydown')this.metaKeys.add(event.code||String(event.location||0));
+        if(event.type==='keyup')this.metaKeys.delete(event.code||String(event.location||0));
+      }
+      // Patch only this terminal's Android event, preserving the native DOM event.
+      if(this.android && this.metaKeys.size && !event.metaKey) {
+        const original=event.getModifierState?.bind(event);
+        Object.defineProperties(event,{
+          metaKey:{configurable:true,value:true},
+          getModifierState:{configurable:true,value:name=>name==='Meta'||Boolean(original?.(name))},
+        });
+      }
+      if(!this.flags || this.term.options.disableStdin) return true;
+      const consume=()=>{event.preventDefault();event.stopPropagation();return false;};
+      if(event.type==='keypress')return this.suppressKeypress?consume():true;
+      let previous=this.down.get(identity);
+      if(event.type==='keyup') {
+        // Some Android IMEs emit only the release of an Alt dead key. Recover
+        // that chord here too, never falling back to legacy ESC text in Kitty mode.
+        if(!previous && this.android && event.altKey && event.key==='Dead' &&
+           !event.isComposing && !lock(event,'AltGraph') && (this.flags&9)) {
+          const def=keyDefinition(event,this.flags,this.android);
+          if(def) {
+            this.term.input(this.sequence(def,this.bits(event),1),true);
+            previous={def,reported:true};this.suppressed.add(identity);
+          }
+        }
+        this.down.delete(identity);
+        const suppressed=this.suppressed.delete(identity);
+        this.suppressKeypress=false;
+        if(previous?.reported && (this.flags&2)) {
+          let bits=this.bits(event);
+          if(previous.def.modifier && ![...this.down.values()].some(k=>k.def.modifier===previous.def.modifier)) bits &= ~previous.def.modifier;
+          if(metaKey && this.metaKeys.size) bits|=8;
+          this.term.input(this.sequence(previous.def,bits,3),true);
+        }
+        return suppressed?consume():true;
+      }
+      this.suppressKeypress=false;
+      if(event.isComposing || event.keyCode===229 && event.key==='Unidentified')return true;
+      if(event.key==='Dead' && !(this.android && event.altKey && !lock(event,'AltGraph')))return true;
+      const def=keyDefinition(event,this.flags,this.android);
+      if(!def)return true;
+      let bits=this.bits(event);
+      if(def.modifier!==undefined) {
+        if(!(this.flags&8))return true;
+        bits|=def.modifier;
+      }
+      const all=Boolean(this.flags&8);
+      // Enter/Tab/Backspace remain recovery keys unless modified or report-all is requested.
+      if(!all && def.recovery && !(bits&~192))return true;
+      const shortcut=Boolean(bits&62);
+      if(def.text && !all && !(this.flags&1 && shortcut))return true;
+      // With only event reporting requested, leave legacy printable shortcuts untouched.
+      if(def.text && !all && !(this.flags&1))return true;
+      const type=event.repeat?2:1;
+      this.down.set(identity,{def,reported:!(def.recovery && !all)});this.suppressed.add(identity);this.suppressKeypress=true;
+      this.term.input(this.sequence(def,bits,type),true);
+      return consume();
+    }
+    bits(e) {
+      const altgr=lock(e,'AltGraph');
+      return (e.shiftKey?1:0)|(!altgr&&e.altKey?2:0)|(!altgr&&e.ctrlKey?4:0)|
+        (e.metaKey || this.android&&this.metaKeys.size?8:0)|
+        (lock(e,'Hyper')?16:0)|(lock(e,'CapsLock')?64:0)|(lock(e,'NumLock')?128:0);
+    }
+  }
+  const api={KittyKeyboard,SUPPORTED};
+  if(typeof module==='object' && module.exports)module.exports=api;
+  else root.GoTTYKittyKeyboard=api;
+})(globalThis);

package/apps/jsgotty/tests/android-alt.test.js

@@ -0,0 +1,115 @@
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const fs = require('node:fs');
+const vm = require('node:vm');
+const path = require('node:path');
+
+// Exercise the shipped bundle's wrapper method, without a DOM or new dependencies.
+const bundle = fs.readFileSync(path.join(__dirname, '../static/js/gotty.js'), 'utf8');
+const start = bundle.indexOf('          handleAndroidAltKey(event) {');
+assert.ok(start >= 0);
+const end = bundle.indexOf('          info() {', start);
+assert.ok(end > start);
+const method = bundle.slice(start, end);
+function setup(userAgent = 'Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 wv') {
+  const handler = vm.runInNewContext(`({${method}}).handleAndroidAltKey`, {
+    navigator: { userAgent },
+  });
+  const sent = [];
+  const target = { term: { input: (text, userInput) => sent.push([text, userInput]) } };
+  function dispatch(overrides = {}) {
+    const event = {
+      type: 'keydown', code: 'KeyE', key: 'Dead', keyCode: 69,
+      altKey: true, ctrlKey: false, metaKey: false, shiftKey: false,
+      isComposing: false, getModifierState: () => false,
+      prevented: false, stopped: false,
+      preventDefault() { this.prevented = true; },
+      stopPropagation() { this.stopped = true; },
+      ...overrides,
+    };
+    return { result: handler.call(target, event), event };
+  }
+  return { sent, dispatch };
+}
+
+test('Android accent shortcuts emit one ESC sequence; keypress/keyup do not duplicate it', () => {
+  for (const letter of ['E', 'I', 'N', 'U']) {
+    for (const keyCode of [letter.charCodeAt(0), 229]) {
+      const { sent, dispatch } = setup();
+      const { event, result } = dispatch({ code: `Key${letter}`, keyCode });
+      assert.equal(result, false);
+      assert.equal(event.prevented, true);
+      assert.equal(event.stopped, true);
+      dispatch({ type: 'keypress', code: `Key${letter}`, keyCode });
+      dispatch({ type: 'keyup', code: `Key${letter}`, keyCode });
+      assert.deepEqual(sent, [[`\x1b${letter.toLowerCase()}`, true]]);
+      // No dead-key state is retained in this handler for the next ordinary key.
+      assert.equal(dispatch({ altKey: false, key: 'e' }).result, true);
+      assert.equal(sent.length, 1);
+    }
+  }
+});
+
+test('all printable physical Alt keys bypass dead-key handling, including Shift and repeat', () => {
+  const { sent, dispatch } = setup();
+  for (const [code, shiftKey, expected] of [
+    ['KeyA', false, 'a'], ['KeyE', true, 'E'], ['Digit0', false, '0'],
+    ['Digit1', true, '!'], ['Digit0', true, ')'], ['Quote', false, "'"],
+    ['Backquote', true, '~'], ['Backslash', false, '\\'], ['Space', false, ' '],
+  ]) {
+    dispatch({ code, shiftKey, key: 'Dead' });
+    assert.deepEqual(sent.at(-1), [`\x1b${expected}`, true]);
+  }
+  dispatch({ code: 'KeyE', key: 'é', repeat: true });
+  assert.deepEqual(sent.at(-1), ['\x1be', true]);
+});
+
+test('composition, AltGr, other modifiers, and unmapped keys retain existing handling', () => {
+  for (const overrides of [
+    { isComposing: true, keyCode: 229 }, { getModifierState: key => key === 'AltGraph' },
+    { altKey: false }, { ctrlKey: true }, { metaKey: true },
+    { code: '', keyCode: 229 }, { code: 'ArrowLeft' }, { code: 'Enter' },
+    { code: 'Unidentified', keyCode: 229 }, { code: 'toString' },
+    { type: 'keyup', key: 'e' },
+  ]) {
+    const { sent, dispatch } = setup();
+    const { result, event } = dispatch(overrides);
+    assert.equal(result, true);
+    assert.equal(event.prevented, false);
+    assert.deepEqual(sent, []);
+  }
+});
+
+test('non-Android browsers retain existing Alt/dead-key handling', () => {
+  for (const ua of ['Mozilla/5.0 (X11; Linux x86_64)', 'Mozilla/5.0 (Macintosh)', 'Windows']) {
+    const { sent, dispatch } = setup(ua);
+    assert.equal(dispatch().result, true);
+    assert.deepEqual(sent, []);
+  }
+});
+
+// Replay the actual Android 16 WebView trace: no letter keydown and empty code.
+test('Android keyup-only dead keys use legacy keyCode, and ordinary IME input stays untouched', () => {
+  const { sent, dispatch } = setup();
+  for (const keyCode of [69, 78, 85, 73]) {
+    dispatch({ type: 'keydown', code: '', key: 'Alt', keyCode: 18 });
+    assert.equal(dispatch({ type: 'keyup', code: '', key: 'Dead', keyCode }).result, false);
+    dispatch({ type: 'keyup', code: '', key: 'Alt', keyCode: 18 });
+  }
+  assert.deepEqual(sent, ['e', 'n', 'u', 'i'].map(c => ['\x1b' + c, true]));
+  assert.equal(dispatch({ code: '', key: 'Unidentified', keyCode: 229, altKey: false }).result, true);
+  assert.equal(sent.length, 4);
+});
+
+test('legacy keydown plus dead keyup emits once, even with different code availability', () => {
+  for (const [downCode, upCode] of [['', ''], ['KeyE', ''], ['', 'KeyE']]) {
+    const { sent, dispatch } = setup();
+    dispatch({ code: downCode, keyCode: 69 });
+    dispatch({ type: 'keypress', code: downCode, keyCode: 69 });
+    dispatch({ type: 'keyup', code: upCode, keyCode: 69 });
+    assert.deepEqual(sent, [['\x1be', true]]);
+    // The next keyup-only shortcut must not be suppressed by the preceding press.
+    dispatch({ type: 'keyup', code: '', keyCode: 69 });
+    assert.equal(sent.length, 2);
+  }
+});

package/apps/jsgotty/tests/arrow-modifiers.test.js

@@ -0,0 +1,80 @@
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+
+// Exercise the keyboard encoder shipped in the frontend bundle.
+const bundle = fs.readFileSync(path.join(__dirname, '../static/js/gotty.js'), 'utf8');
+const marker = 't.evaluateKeyboardEvent = function (e, t, i, n) {';
+const start = bundle.indexOf(marker);
+assert.ok(start >= 0);
+const end = bundle.indexOf('\n                  },\n                  482:', start);
+assert.ok(end > start);
+const source = bundle.slice(start + 't.evaluateKeyboardEvent = '.length, end).trim().replace(/;$/, '');
+const evaluate = vm.runInNewContext(`(${source})`, { r: { C0: { ESC: '\x1b', US: '\x1f' } }, s: {} });
+const arrows = [[37, 'D'], [38, 'A'], [39, 'C'], [40, 'B']];
+
+for (const isMac of [false, true]) {
+  test(`arrow modifiers stay distinct (isMac=${isMac})`, () => {
+    for (const [keyCode, suffix] of arrows) {
+      for (const applicationCursorMode of [false, true]) {
+        const sequences = new Set();
+        for (let mask = 0; mask < 8; mask++) {
+          const result = evaluate({
+            keyCode, metaKey: false,
+            shiftKey: Boolean(mask & 1), altKey: Boolean(mask & 2), ctrlKey: Boolean(mask & 4),
+          }, applicationCursorMode, isMac, false);
+          const expected = mask
+            ? `\x1b[1;${mask + 1}${suffix}`
+            : `\x1b${applicationCursorMode ? 'O' : '['}${suffix}`;
+          assert.equal(result.key, expected);
+          sequences.add(result.key);
+        }
+        assert.equal(sequences.size, 8);
+      }
+    }
+  });
+}
+
+test('Alt Insert/PageUp/PageDown keep Alt while preserving existing shortcuts', () => {
+  for (const isMac of [false, true]) {
+    const encode = (keyCode, modifiers = {}) => evaluate({
+      keyCode, shiftKey: false, altKey: false, ctrlKey: false, metaKey: false,
+      ...modifiers,
+    }, false, isMac, false);
+    for (const [keyCode, parameter] of [[45, 2], [33, 5], [34, 6]]) {
+      assert.equal(encode(keyCode).key, `\x1b[${parameter}~`);
+      assert.equal(encode(keyCode, { altKey: true }).key, `\x1b[${parameter};3~`);
+    }
+    for (const [keyCode, parameter, scrollType] of [[33, 5, 2], [34, 6, 3]]) {
+      assert.equal(encode(keyCode, { ctrlKey: true }).key, `\x1b[${parameter};5~`);
+      assert.equal(encode(keyCode, { ctrlKey: true, altKey: true }).key, `\x1b[${parameter};7~`);
+      for (const ctrlKey of [false, true]) {
+        for (const altKey of [false, true]) {
+          const result = encode(keyCode, { shiftKey: true, ctrlKey, altKey });
+          assert.equal(result.type, scrollType);
+          assert.equal(result.key, undefined);
+        }
+      }
+    }
+    for (const modifiers of [
+      { ctrlKey: true }, { shiftKey: true }, { ctrlKey: true, shiftKey: true },
+      { ctrlKey: true, altKey: true }, { shiftKey: true, altKey: true },
+    ]) assert.equal(encode(45, modifiers).key, undefined);
+  }
+});
+
+
+test('Ctrl slash sends US like Ctrl underscore, including alternate layout keyCodes', () => {
+  for (const isMac of [false, true]) {
+    for (const keyCode of [191, 226]) {
+      const result = evaluate({ key: '/', keyCode, ctrlKey: true,
+        shiftKey: false, altKey: false, metaKey: false }, false, isMac, false);
+      assert.equal(result.key, '\x1f');
+    }
+    const plain = evaluate({ key: '/', keyCode: 191, ctrlKey: false,
+      shiftKey: false, altKey: false, metaKey: false }, false, isMac, false);
+    assert.equal(plain.key, '/');
+  }
+});

package/apps/jsgotty/tests/kitty-keyboard-browser.test.js

@@ -0,0 +1,53 @@
+// Opt-in real bundled-xterm integration; no browser/dependency downloads.
+// CHROMIUM_HEADLESS=/path/to/chromium-headless-shell node --test tests/kitty-keyboard-browser.test.js
+const test=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const path=require('node:path');
+const http=require('node:http');
+const {spawn}=require('node:child_process');
+const {once}=require('node:events');
+const WebSocket=require('ws');
+const root=path.join(__dirname,'../static');
+test('shipped xterm parses Kitty modes and delivers one encoded DOM event per key', {skip:!process.env.CHROMIUM_HEADLESS,timeout:60000},async()=>{
+ const bundle=fs.readFileSync(path.join(root,'js/gotty.js'),'utf8').replace('(i.nc = void 0));','(i.nc = void 0)); window.TestGoTTYXterm = i(634).GoTTYXterm;');
+ const server=http.createServer((req,res)=>{
+  if(req.url==='/bundle.js'){res.setHeader('Content-Type','text/javascript');res.end(bundle);}
+  else if(req.url==='/keyboard.js'){res.setHeader('Content-Type','text/javascript');res.end(fs.readFileSync(path.join(root,'js/kitty-keyboard.js')));}
+  else res.end('<!doctype html><div id="fixture" style="width:800px;height:600px"></div><script src="/keyboard.js"></script><script src="/bundle.js"></script><script>window.wrapper=new TestGoTTYXterm(document.getElementById("fixture"));window.sent=[];wrapper.onInput(b=>sent.push(new TextDecoder().decode(b)));wrapper.kittyKeyboard.android=true;</script>');
+ });
+ server.listen(0,'127.0.0.1');await once(server,'listening');
+ const child=spawn(process.env.CHROMIUM_HEADLESS,['--no-sandbox','--disable-gpu','--remote-debugging-port=0','http://127.0.0.1:'+server.address().port],{detached:true,stdio:['ignore','ignore','pipe']});
+ let ws;
+ try{
+  const endpoint=await new Promise((resolve,reject)=>{let log='';const timer=setTimeout(()=>reject(Error('Browser startup timeout: '+log)),15000);child.on('error',reject);child.on('exit',code=>{clearTimeout(timer);reject(Error('Browser exited '+code+': '+log));});child.stderr.on('data',b=>{log+=b;const m=log.match(/DevTools listening on (ws:\/\/[^\s]+)/);if(m){clearTimeout(timer);resolve(m[1]);}});});
+  const u=new URL(endpoint);let tab;
+  for(let i=0;i<50;i++){tab=(await (await fetch('http://'+u.host+'/json/list')).json()).find(x=>x.type==='page');if(tab)break;await new Promise(r=>setTimeout(r,100));}
+  ws=new WebSocket(tab.webSocketDebuggerUrl);await once(ws,'open');let id=0;const pending=new Map();ws.on('message',data=>{const m=JSON.parse(data);if(pending.has(m.id)){const {resolve,reject}=pending.get(m.id);pending.delete(m.id);m.error?reject(m.error):resolve(m.result);}});
+  const call=(method,params)=>new Promise((resolve,reject)=>{pending.set(++id,{resolve,reject});ws.send(JSON.stringify({id,method,params}));});
+  for(let i=0;i<50;i++){const r=await call('Runtime.evaluate',{expression:'Boolean(window.wrapper)',returnByValue:true});if(r.result.value)break;await new Promise(r=>setTimeout(r,100));}
+  const result=await call('Runtime.evaluate',{awaitPromise:true,returnByValue:true,expression:`(async()=>{
+   const term=wrapper.term, kb=wrapper.kittyKeyboard;
+   const write=s=>new Promise(r=>term.write(s,r));
+   const equal=(a,b)=>{if(JSON.stringify(a)!==JSON.stringify(b))throw Error(JSON.stringify({actual:a,expected:b}));};
+   const key=(type,key,code,mods={})=>term.textarea.dispatchEvent(new KeyboardEvent(type,{key,code,bubbles:true,cancelable:true,...mods}));
+   await write('\\x1b[?u');equal(sent.splice(0),['\\x1b[?0u']);
+   // Split escape sequence across writes: only the parser may enable the mode.
+   await write('\\x1b[>');await write('11u');equal(kb.flags,11);
+   key('keydown','Meta','MetaLeft');key('keydown','x','KeyX',{ctrlKey:true,shiftKey:true});
+   key('keypress','x','KeyX',{ctrlKey:true,shiftKey:true});key('keyup','x','KeyX',{ctrlKey:true,shiftKey:true});key('keyup','Meta','MetaLeft');
+   equal(sent.splice(0),['\\x1b[57444;9u','\\x1b[120;14u','\\x1b[120;14:3u','\\x1b[57444;1:3u']);
+   await write('\\x1b[?1049h');equal(kb.flags,0);await write('\\x1b[>1u');equal(kb.flags,1);
+   await write('\\x1b[?1049l');equal(kb.flags,11);
+   await write('\\x1b[<u');equal(kb.flags,0);
+   key('keydown','c','KeyC',{ctrlKey:true,keyCode:67});key('keyup','c','KeyC',{ctrlKey:true,keyCode:67});equal(sent.splice(0),['\\x03']);
+   await write('\\x1b[>11u');await write('\\x1bc');equal(kb.flags,0);
+   await write('\\x1b[?u');equal(sent.splice(0),['\\x1b[?0u']);
+   wrapper.close();return 'ok';
+  })()`});
+  assert.equal(result.exceptionDetails,undefined,JSON.stringify(result.exceptionDetails));assert.equal(result.result.value,'ok');
+ }finally{
+  ws?.close();if(child.pid){try{process.kill(-child.pid,'SIGTERM');}catch{}}
+  server.closeAllConnections();await new Promise(r=>server.close(r));
+ }
+});

package/apps/jsgotty/tests/kitty-keyboard.test.js

@@ -0,0 +1,102 @@
+const test=require('node:test');
+const assert=require('node:assert/strict');
+const {KittyKeyboard,SUPPORTED}=require('../static/js/kitty-keyboard.js');
+function setup(android=true) {
+  const handlers=new Map(),sent=[];
+  const term={parser:{registerCsiHandler:(id,fn)=>{handlers.set((id.prefix||id.intermediates||'')+id.final,fn);return {dispose(){}};},registerEscHandler:(id,fn)=>{handlers.set('ESC'+id.final,fn);return {dispose(){}};}},buffer:{active:{type:'normal'}},options:{},input:(s,user)=>sent.push([s,user])};
+  const keyboard=new KittyKeyboard(term,{android});
+  const mode=(prefix,params=[])=>handlers.get(prefix+'u')(params);
+  const event=(options={})=>({type:'keydown',key:'a',code:'KeyA',keyCode:65,location:0,repeat:false,ctrlKey:false,altKey:false,shiftKey:false,metaKey:false,getModifierState:()=>false,preventDefault(){this.prevented=true;},stopPropagation(){},...options});
+  const send=options=>{const e=event(options);return {e,result:keyboard.handle(e)};};
+  return {keyboard,term,sent,handlers,mode,send,event};
+}
+test('negotiation, bit operations, bounded stacks, separate screens and reset',()=>{
+ const t=setup();t.mode('?');assert.deepEqual(t.sent.pop(),['\x1b[?0u',false]);
+ t.mode('>',[11]);t.mode('>',[1]);t.mode('<');assert.equal(t.keyboard.flags,11);
+ t.mode('=',[2,3]);assert.equal(t.keyboard.flags,9);t.mode('=',[2,2]);assert.equal(t.keyboard.flags,11);
+ t.term.buffer.active.type='alternate';assert.equal(t.keyboard.flags,0);t.mode('>',[3]);
+ t.term.buffer.active.type='normal';assert.equal(t.keyboard.flags,11);
+ for(let i=0;i<100;i++)t.mode('>',[1]);assert.equal(t.keyboard.state.stack.length,32);
+ t.mode('<',[99999]);assert.equal(t.keyboard.flags,0);
+ t.mode('=',[31]);assert.equal(t.keyboard.flags,SUPPORTED);t.mode('=',[0]);assert.equal(t.keyboard.flags,0);
+ t.handlers.get('ESCc')();t.term.buffer.active.type='alternate';assert.equal(t.keyboard.flags,0);
+});
+test('all sixteen Shift/Alt/Ctrl/Super combinations stay distinct for all letters and navigation',()=>{
+ for(const key of [...'abcdefghijklmnopqrstuvwxyz','ArrowLeft','ArrowRight','ArrowUp','ArrowDown','Tab','Enter','Backspace','Insert','PageUp','PageDown','F1','F12','PrintScreen']) {
+  const seen=new Set();
+  for(let mask=0;mask<16;mask++) {
+   const t=setup();t.mode('>',[11]);t.send({key,code:key.length===1?'Key'+key.toUpperCase():key,shiftKey:!!(mask&1),altKey:!!(mask&2),ctrlKey:!!(mask&4),metaKey:!!(mask&8)});
+   assert.equal(t.sent.length,1,`${key} ${mask}`);seen.add(t.sent[0][0]);
+  }
+  assert.equal(seen.size,16,key);
+ }
+});
+test('Android Meta pair repairs missing metaKey, including keyup and combinations',()=>{
+ const t=setup();t.mode('>',[11]);
+ t.send({key:'Meta',code:'',keyCode:91});
+ assert.deepEqual(t.sent.pop(),['\x1b[57444;9u',true]);
+ const {e}=t.send({key:'x',code:'',keyCode:88,ctrlKey:true,shiftKey:true});
+ assert.equal(e.metaKey,true);assert.equal(e.getModifierState('Meta'),true);
+ assert.deepEqual(t.sent.pop(),['\x1b[120;14u',true]);
+ t.send({type:'keyup',key:'x',code:'',keyCode:88,ctrlKey:true,shiftKey:true});assert.equal(t.sent.pop()[0],'\x1b[120;14:3u');
+ t.send({type:'keyup',key:'Meta',code:'',keyCode:91});assert.equal(t.sent.pop()[0],'\x1b[57444;1:3u');
+ t.send({key:'x',code:'KeyX'});assert.equal(t.sent.pop()[0],'\x1b[120u');
+});
+test('both Meta keys, repeats and focus cleanup do not leave modifiers held',()=>{
+ const t=setup();t.mode('>',[11]);
+ t.send({key:'Meta',code:'MetaLeft',location:1});t.send({key:'Meta',code:'MetaRight',location:2});
+ t.send({type:'keyup',key:'Meta',code:'MetaLeft',location:1});assert.equal(t.sent.at(-1)[0],'\x1b[57444;9:3u');
+ t.send({repeat:true});assert.equal(t.sent.at(-1)[0],'\x1b[97;9:2u');
+ t.keyboard.clearHeld();assert.equal(t.keyboard.metaKeys.size,0);
+ t.send();assert.equal(t.sent.at(-1)[0],'\x1b[97u');
+});
+test('legacy remains unchanged; disabling mode restores text and ordinary controls',()=>{
+ const t=setup();assert.equal(t.send({ctrlKey:true}).result,true);assert.equal(t.sent.length,0);
+ t.mode('>',[1]);assert.equal(t.send().result,true);
+ for(const key of ['Tab','Enter','Backspace'])assert.equal(t.send({key,code:key}).result,true);
+ t.send({ctrlKey:true,key:'i',code:'KeyI'});assert.equal(t.sent.pop()[0],'\x1b[105;5u');
+ t.send({ctrlKey:true,shiftKey:true,key:'I',code:'KeyI'});assert.equal(t.sent.pop()[0],'\x1b[105;6u');
+ t.mode('<');assert.equal(t.send({ctrlKey:true}).result,true);
+});
+test('printable keys in disambiguation mode do not generate release events',()=>{
+ const t=setup();t.mode('>',[3]);t.send();t.send({type:'keyup'});assert.equal(t.sent.length,0);
+ t.send({ctrlKey:true});t.send({type:'keyup',ctrlKey:true});assert.deepEqual(t.sent.map(s=>s[0]),['\x1b[97;5u','\x1b[97;5:3u']);
+});
+test('dead Alt keys recover before encoding; regular composition is untouched',()=>{
+ const t=setup();t.mode('>',[11]);
+ for(const k of 'ENUI'){t.send({key:'Dead',code:'Key'+k,altKey:true});assert.equal(t.sent.pop()[0],`\x1b[${k.toLowerCase().charCodeAt(0)};3u`);}
+ assert.equal(t.send({isComposing:true,key:'Process'}).result,true);
+ assert.equal(t.send({key:'Dead',altKey:false}).result,true);
+});
+test('AltGr is not encoded as Ctrl+Alt; non-Latin layout key values are preserved',()=>{
+ const t=setup();t.mode('>',[11]);
+ t.send({key:'€',code:'KeyE',ctrlKey:true,altKey:true,getModifierState:k=>k==='AltGraph'});assert.equal(t.sent.pop()[0],'\x1b[8364u');
+ t.send({key:'ф',code:'KeyA',ctrlKey:true});assert.equal(t.sent.pop()[0],'\x1b[1092;5u');
+});
+test('keypad, media and lock modifiers have dedicated encodings',()=>{
+ const t=setup();t.mode('>',[11]);
+ t.send({key:'Enter',code:'NumpadEnter',location:3});assert.equal(t.sent.pop()[0],'\x1b[57414u');
+ t.send({key:'AudioVolumeUp',code:'AudioVolumeUp'});assert.equal(t.sent.pop()[0],'\x1b[57439u');
+ t.send({getModifierState:k=>k==='CapsLock'});assert.equal(t.sent.pop()[0],'\x1b[97;65u');
+});
+test('normal non-Android Meta and input disabled are not rewritten',()=>{
+ const t=setup(false);t.mode('>',[11]);t.send({key:'Meta',code:'MetaLeft'});const {e}=t.send();assert.equal(e.metaKey,false);
+ t.term.options.disableStdin=true;const count=t.sent.length;assert.equal(t.send({metaKey:true}).result,true);assert.equal(t.sent.length,count);
+});
+test('keypress cannot duplicate encoded keydown, but later ordinary text is not swallowed',()=>{
+ const t=setup();t.mode('>',[1]);t.send({ctrlKey:true});assert.equal(t.send({type:'keypress',ctrlKey:true}).result,false);
+ t.send({key:'b',code:'KeyB'});assert.equal(t.send({type:'keypress',key:'b',code:'KeyB'}).result,true);
+});
+test('Android release-only accent shortcuts still use Kitty encoding',()=>{
+ const t=setup();t.mode('>',[11]);t.send({type:'keyup',key:'Dead',code:'',keyCode:69,altKey:true});
+ assert.deepEqual(t.sent.map(x=>x[0]),['\x1b[101;3u','\x1b[101;3:3u']);
+});
+test('Omarchy workspace and monitor chords retain all modifiers',()=>{
+ for(const key of [...'1234567890','ArrowLeft','ArrowRight','ArrowUp','ArrowDown','Tab','Home','`']) {
+  const t=setup();t.mode('>',[11]);
+  t.send({key,code:key.length===1?'':key,metaKey:true,shiftKey:true,altKey:true});
+  assert.match(t.sent.at(-1)[0],/;12[~uABCDH]$/);
+  t.send({key,code:key.length===1?'':key,metaKey:true,shiftKey:true,ctrlKey:true});
+  assert.match(t.sent.at(-1)[0],/;14[~uABCDH]$/);
+ }
+});

package/apps/jsgotty/tests/manual/README.md

@@ -0,0 +1,20 @@
+# 鍵盤診斷（手動）
+
+此工具不由正式前端載入，也不需要修改 `static/js/gotty.js` 或安裝依賴。
+
+1. 在與 Android WebView 共用本機網路的環境啟動收集器：
+
+   ```sh
+   node tests/manual/keyboard-collector.cjs
+   # 可指定 port 與輸出檔；預設 18766、系統暫存目錄的 jsgotty-keyboard-debug.jsonl
+   ```
+
+2. 連上 jsgotty 後，透過該頁面的 DevTools Console 或 CDP `Runtime.evaluate` 執行收集器印出的 JavaScript。每次啟動會產生新 token。若要從另一台裝置連線，需要另行調整收集器位址與監聽設定。
+3. 按下要測試的組合鍵，讀取收集器顯示的 JSONL 路徑。每頁最多 2000 筆、10 分鐘；重跑載入指令即可開始新一輪。檔案採追加寫入，以 `session` 分組並依 `sequence` 排序，避免 HTTP 到達順序不同造成誤判。
+4. 停止頁面診斷：`window.stopGottyKeyboardDebug()`；或重新載入頁面。收集器按 Ctrl-C 停止。
+
+記錄內容包含原始 keydown/keypress/keyup、beforeinput/input、composition 事件、既有按鍵處理器回傳值、事件處理完成後的取消狀態，以及 xterm `onData` 的 UTF-8 位元組（前 64 bytes）。onData 是前端產生的終端資料，並非伺服器 PTY 接收確認。診斷期間只輸入測試內容，避免留下密碼或其他敏感輸入。
+
+紀錄也保留於 `window.__gottyKeyboardRecords`；傳輸失敗原因在 `window.__gottyKeyboardDeliveryError`。若無需 HTTP 收集器，可直接在 Console/CDP 執行 `keyboard-debug.js` 的內容，再呼叫 `window.startGottyKeyboardDebug()`。
+
+工具透過 `element.__gottyXterm` 尋找終端，暫時包裝 xterm 的 `_core._customKeyEventHandler`，停止時還原。因此升級 xterm 後需要再確認這個內部欄位；正式產品不依賴此診斷工具。舊的 `#keyboard-debug` 網址片段不再啟用任何診斷。

package/apps/jsgotty/tests/manual/keyboard-collector.cjs

@@ -0,0 +1,55 @@
+// Usage: node tests/manual/keyboard-collector.cjs [port] [output.jsonl]
+const http = require('node:http');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { randomBytes } = require('node:crypto');
+const port = Number(process.argv[2] || 18766);
+const file = path.resolve(process.argv[3] || path.join(os.tmpdir(), 'jsgotty-keyboard-debug.jsonl'));
+const token = randomBytes(16).toString('hex');
+const endpoint = `http://127.0.0.1:${port}/${token}`;
+const client = fs.readFileSync(path.join(__dirname, 'keyboard-debug.js'), 'utf8') +
+  `\nwindow.startGottyKeyboardDebug({endpoint:${JSON.stringify(endpoint)}});\n`;
+let count = 0;
+http.createServer((req, res) => {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+  res.setHeader('Access-Control-Allow-Private-Network', 'true');
+  res.setHeader('Cache-Control', 'no-store');
+  if (req.url !== '/' + token && req.url !== '/' + token + '/client.js') {
+    res.writeHead(404); return res.end();
+  }
+  if (req.method === 'OPTIONS') { res.writeHead(204); return res.end(); }
+  if (req.method === 'GET' && req.url.endsWith('/client.js')) {
+    res.setHeader('Content-Type', 'application/javascript');
+    return res.end(client);
+  }
+  if (req.method !== 'POST' || req.url !== '/' + token) {
+    res.writeHead(405); return res.end();
+  }
+  let body = '';
+  req.on('data', chunk => {
+    body += chunk;
+    if (body.length > 16384) req.destroy();
+  });
+  req.on('end', () => {
+    if (count >= 20000) { res.writeHead(429); return res.end(); }
+    let event;
+    try { event = JSON.parse(body); }
+    catch { res.writeHead(400); return res.end(); }
+    try {
+      fs.appendFileSync(file, JSON.stringify({receivedAt: new Date().toISOString(), event}) + '\n', {mode: 0o600});
+      count++;
+      res.writeHead(204); res.end();
+    } catch (error) {
+      console.error(error.message);
+      res.writeHead(500); res.end();
+    }
+  });
+}).listen(port, '127.0.0.1', () => {
+  console.log('Log (append): ' + file);
+  console.log('Run in the connected jsgotty page via DevTools or CDP:');
+  console.log(`fetch(${JSON.stringify(endpoint + '/client.js')}).then(r => r.text()).then(source => (0, eval)(source))`);
+  console.log('Stop browser capture: window.stopGottyKeyboardDebug()');
+});

package/apps/jsgotty/tests/manual/keyboard-debug.js

@@ -0,0 +1,74 @@
+// Manually loaded diagnostic helper. Never loaded by the production frontend.
+window.startGottyKeyboardDebug = ({ endpoint, term } = {}) => {
+  window.stopGottyKeyboardDebug?.();
+  term ??= Array.from(document.querySelectorAll("*")).find(el => el.__gottyXterm)?.__gottyXterm;
+  if (!term) throw new Error("No jsgotty xterm found; connect the terminal first.");
+  const listeners = [];
+  let stopped = false;
+  const records = [];
+  const started = Date.now();
+  const session = Math.random().toString(36).slice(2);
+  window.__gottyKeyboardRecords = records;
+  window.__gottyKeyboardDebug = (stage, details = {}) => {
+    if (stopped || records.length >= 2000 || Date.now() - started > 600000) return;
+    const record = { session, sequence: records.length, time: new Date().toISOString(), stage, ...details };
+    records.push(record);
+    console.log("[gotty-keyboard]", record);
+    if (endpoint) fetch(endpoint, {
+      method: "POST", headers: { "Content-Type": "text/plain" },
+      body: JSON.stringify(record),
+    }).catch(error => { window.__gottyKeyboardDeliveryError = String(error); });
+  };
+  window.__gottyKeyboardDebug("ready", {
+    userAgent: navigator.userAgent, platform: navigator.platform,
+    userAgentData: navigator.userAgentData?.platform,
+  });
+  for (const type of ["keydown", "keypress", "keyup", "beforeinput", "input",
+    "compositionstart", "compositionupdate", "compositionend"]) {
+    const listener = event => {
+      const details = {
+        type, key: event.key, code: event.code, keyCode: event.keyCode,
+        charCode: event.charCode, which: event.which, altKey: event.altKey,
+        ctrlKey: event.ctrlKey, metaKey: event.metaKey, shiftKey: event.shiftKey,
+        altGraph: event.getModifierState?.("AltGraph"),
+        isComposing: event.isComposing, repeat: event.repeat,
+        cancelable: event.cancelable, defaultPrevented: event.defaultPrevented,
+        inputType: event.inputType, data: event.data?.slice(0, 64),
+        target: event.target?.tagName, trusted: event.isTrusted,
+      };
+      window.__gottyKeyboardDebug("capture", details);
+      setTimeout(() => window.__gottyKeyboardDebug("after-dispatch", {
+        ...details, defaultPrevented: event.defaultPrevented,
+      }));
+    };
+    window.addEventListener(type, listener, true);
+    listeners.push([type, listener]);
+  }
+  // Preserve the existing Android handler, including its return value.
+  const previousHandler = term._core?._customKeyEventHandler;
+  if (!term._core) throw new Error("Unsupported xterm internals");
+  const handler = event => {
+    const result = previousHandler ? previousHandler.call(term._core, event) : true;
+    window.__gottyKeyboardDebug("alt-handler", {
+      type: event.type, key: event.key, code: event.code,
+      result, defaultPrevented: event.defaultPrevented,
+    });
+    return result;
+  };
+  term.attachCustomKeyEventHandler(handler);
+  const subscription = term.onData(text => {
+    const bytes = new TextEncoder().encode(text);
+    window.__gottyKeyboardDebug("terminal-data", {
+      length: bytes.length, bytes: Array.from(bytes.slice(0, 64)),
+    });
+  });
+  window.stopGottyKeyboardDebug = () => {
+    stopped = true;
+    for (const [type, listener] of listeners) window.removeEventListener(type, listener, true);
+    subscription.dispose();
+    if (term._core._customKeyEventHandler === handler)
+      term.attachCustomKeyEventHandler(previousHandler);
+  };
+  return { records, stop: window.stopGottyKeyboardDebug };
+};
+

package/apps/jsgotty/tests/manual/kitty-keyboard.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// Run inside jsgotty. Exits after 60 seconds or unmodified Escape/q/Ctrl-C.
+// Uses only built-ins and restores the prior Kitty mode and raw mode on exit.
+const input=process.stdin, output=process.stdout;
+const cyan = '\x1b[96m', reset = '\x1b[0m';
+const keyNames = {
+  9: 'tab', 13: 'enter', 27: 'esc', 32: 'space', 127: 'backspace',
+  57358: 'caps-lock', 57359: 'scroll-lock', 57360: 'num-lock',
+  57361: 'print-screen', 57362: 'pause', 57363: 'menu',
+  57409: 'kp-decimal', 57410: 'kp-divide', 57411: 'kp-multiply',
+  57412: 'kp-subtract', 57413: 'kp-add', 57414: 'kp-enter',
+  57415: 'kp-equal', 57416: 'kp-separator',
+  57417: 'kp-left', 57418: 'kp-right', 57419: 'kp-up', 57420: 'kp-down',
+  57421: 'kp-page-up', 57422: 'kp-page-down', 57423: 'kp-home',
+  57424: 'kp-end', 57425: 'kp-insert', 57426: 'kp-delete', 57427: 'kp-begin',
+  57428: 'media-play', 57429: 'media-pause', 57430: 'media-play-pause',
+  57431: 'media-reverse', 57432: 'media-stop', 57433: 'media-fast-forward',
+  57434: 'media-rewind', 57435: 'media-next', 57436: 'media-previous',
+  57437: 'media-record', 57438: 'volume-down', 57439: 'volume-up',
+  57440: 'volume-mute', 57453: 'altgr', 57454: 'iso-level5-shift',
+};
+for (let n=13; n<=35; n++) keyNames[57376+n-13] = 'f'+n;
+for (let n=0; n<=9; n++) keyNames[57399+n] = 'kp-'+n;
+const modifierKeys = ['shift', 'ctrl', 'alt', 'super', 'hyper', 'meta'];
+const modifierBits = [1, 4, 2, 8, 16, 32];
+function readableChord(key, suffix, bits) {
+  const number = Number(key.split(':')[0] || 1);
+  let name;
+  if (suffix === 'u') {
+    if (number >= 57441 && number <= 57452) {
+      const index = (number-57441)%6;
+      name = modifierKeys[index] + (number >= 57447 ? '-right' : '-left');
+      bits &= ~modifierBits[index]; // "super-left", not "super-super-left".
+    } else {
+      name = keyNames[number];
+      if (!name) name = number >= 33 && number <= 0x10ffff &&
+        !(number >= 0x7f && number <= 0x9f) &&
+        !(number >= 0xd800 && number <= 0xf8ff)
+        ? String.fromCodePoint(number) : 'key-'+number;
+    }
+  } else if (suffix === '~') {
+    name = {2:'insert', 3:'delete', 5:'page-up', 6:'page-down', 7:'home', 8:'end',
+      11:'f1', 12:'f2', 13:'f3', 14:'f4', 15:'f5', 17:'f6',
+      18:'f7', 19:'f8', 20:'f9', 21:'f10', 23:'f11', 24:'f12'}[number];
+  } else {
+    name = {A:'up', B:'down', C:'right', D:'left', E:'begin',
+      F:'end', H:'home', P:'f1', Q:'f2', S:'f4'}[suffix];
+  }
+  const modifiers = [[4,'ctrl'], [2,'alt'], [1,'shift'], [8,'super'],
+    [16,'hyper'], [32,'meta'], [64,'caps-lock'], [128,'num-lock']]
+    .filter(([bit]) => bits & bit).map(([,label]) => label);
+  return [...modifiers, name || `key-${number}${suffix}`].join('-');
+}
+if(!input.isTTY || !output.isTTY) {console.error('Run this inside an interactive jsgotty terminal.');process.exit(1);}
+const wasRaw=Boolean(input.isRaw);let closed=false,buffer='';
+const finish=()=>{if(closed)return;closed=true;clearTimeout(timer);output.write('\x1b[<u\r\nKeyboard mode restored.\r\n');input.setRawMode(wasRaw);input.pause();};
+const timer=setTimeout(finish,60000);
+process.on('SIGINT',finish);process.on('SIGTERM',finish);process.on('exit',finish);
+input.setRawMode(true);input.setEncoding('utf8');input.resume();
+output.write('Kitty keyboard test: try SUP, CTRL, ALT, SHFT + letters/arrows.\r\nEscape, q or Ctrl-C exits; automatic exit in 60 seconds.\r\n\x1b[>11u\x1b[?u');
+input.on('data',data=>{
+ if(closed)return;
+ buffer+=data;
+ while(buffer) {
+  const match=/^\x1b\[([?]?)([0-9:;]*)([u~A-Z])/.exec(buffer);
+  if(!match) {
+   if(buffer==='\x1b' || /^\x1b\[[?0-9:;]*$/.test(buffer))break;
+   const ch=[...buffer][0];buffer=buffer.slice(ch.length);output.write('legacy '+JSON.stringify(ch)+'\r\n');
+   if(ch==='q'||ch==='\x03') {finish();return;}continue;
+  }
+  buffer=buffer.slice(match[0].length);
+  if(match[1]==='?'){output.write('negotiated flags='+match[2]+' (expected 11)\r\n');continue;}
+  const [key,mod='1']=match[2].split(';');const [encoded,type='1']=mod.split(':');const bits=Number(encoded)-1;
+  const names=[[1,'Shift'],[2,'Alt'],[4,'Ctrl'],[8,'Super'],[16,'Hyper'],[32,'Meta'],[64,'CapsLock'],[128,'NumLock']].filter(([bit])=>bits&bit).map(([,name])=>name);
+  const chord = readableChord(key, match[3], bits);
+  output.write(`${cyan}${chord}${reset}  ${{1:'press',2:'repeat',3:'release'}[type]||type}  raw=${JSON.stringify(match[0])} key=${key}${match[3]} modifiers=${names.join('+')||'none'}\r\n`);
+  if(match[3]==='u' && type==='1' && ((!(bits&63)&&['27','113'].includes(key)) || ((bits&63)===4 && key==='99'))) {finish();return;}
+ }
+ if(buffer.length>4096)buffer='';
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu",
-  "version": "0.4.21",
+  "version": "0.5.0",
   "description": "Buninu is a portable, self-bootstrapping Unix-like userspace built on Bun that runs across operating systems",
   "type": "module",
   "main": "./bin/init.js",