ai-or-die 0.1.94 → 0.1.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-or-die",
-  "version": "0.1.94",
+  "version": "0.1.95",
   "description": "Universal AI coding terminal — Claude, Copilot, Gemini & more in your browser",
   "main": "src/server.js",
   "bin": {

package/src/public/app.js

@@ -692,7 +692,7 @@ class ClaudeCodeWebInterface {
                 foreground: '#f0f6fc',
                 cursor: '#ff6b00',
                 cursorAccent: '#0d1117',
-                selection: 'rgba(255, 107, 0, 0.2)',
+                selectionBackground: 'rgba(255, 107, 0, 0.2)',
                 black: '#484f58',
                 red: '#ff7b72',
                 green: '#7ee787',
@@ -741,6 +741,20 @@ class ClaudeCodeWebInterface {
 
         this.terminal.open(document.getElementById('terminal'));
 
+        // Trackpad/mouse-wheel policy: preempt xterm's alt-buffer wheel->arrow
+        // translation so scrolling doesn't hijack the Claude Code TUI. Reads the
+        // live setting via the cached `_wheelScrollMode` (default 'dontHijack').
+        if (typeof window.attachTerminalWheel === 'function') {
+            if (this._wheelHandler && this._wheelHandler.dispose) {
+                try { this._wheelHandler.dispose(); } catch (_) {}
+            }
+            this._wheelHandler = window.attachTerminalWheel(
+                this.terminal,
+                document.getElementById('terminal'),
+                () => this._wheelScrollMode || 'dontHijack'
+            );
+        }
+
         // Faithful per-tab snapshot cache for instant tab-switch repaint.
         // Guarded: if the serialize addon or the cache class failed to load
         // (e.g. CDN blocked), snapshotCache stays null and every call site is
@@ -2293,7 +2307,17 @@ class ClaudeCodeWebInterface {
                         if (restartGen !== this._socketGeneration) return;
                         this.reconnect();
                     }, restartBackoff);
-                } else if ((!event.wasClean || voiceClose.rejected) && this.reconnectAttempts < this.maxReconnectAttempts) {
+                // Reconnect decision extracted to WsReconnect.isReconnectableClose
+                // (unit-tested): abnormal close, our own heartbeat pong-timeout
+                // (code 4000 — a clean close that MUST still reconnect, or a single
+                // transient pong-timeout strands the client on "Disconnected"), or a
+                // server frame-rejection (1009/1003). Inline fallback keeps reconnect
+                // working even if the tiny module failed to load.
+                } else if (
+                    ((window.WsReconnect && window.WsReconnect.isReconnectableClose)
+                        ? window.WsReconnect.isReconnectableClose(event, voiceClose.rejected)
+                        : (!event.wasClean || event.code === 4000 || voiceClose.rejected))
+                    && this.reconnectAttempts < this.maxReconnectAttempts) {
                     this.updateStatus('Reconnecting (' + (this.reconnectAttempts + 1) + '/' + this.maxReconnectAttempts + ')...');
                     // First attempt is fast (250ms covers a server-process restart window);
                     // subsequent attempts use exponential backoff with jitter.
@@ -2315,7 +2339,11 @@ class ClaudeCodeWebInterface {
                     this.reconnectAttempts++;
                 } else {
                     this.updateStatus('Disconnected');
-                    this.showError(`Connection lost after ${this.maxReconnectAttempts} attempts.\n\nYour session data is preserved on the server.\n\u2022 Check your network connection\n\u2022 The server may have restarted \u2014 try refreshing the page`);
+                    const n = this.reconnectAttempts;
+                    const lead = n > 0
+                        ? `Connection lost after ${n} reconnect attempt${n === 1 ? '' : 's'}.`
+                        : 'Disconnected from the server.';
+                    this.showError(`${lead}\n\nYour session data is preserved on the server.\n\u2022 Check your network connection\n\u2022 The server may have restarted \u2014 try refreshing the page`);
                 }
             };
             
@@ -3573,40 +3601,30 @@ class ClaudeCodeWebInterface {
     }
 
     _loadGpuRenderer() {
+        // The Canvas renderer was removed in xterm 6.0. Mobile keeps using the
+        // reliable default DOM renderer (WebGL was historically avoided there for
+        // context-loss/memory reasons); desktop uses WebGL and falls back to the
+        // DOM renderer on failure or context loss.
         if (this.isMobile) {
-            console.log('[Renderer] Mobile detected, using Canvas renderer for reliability');
-            this._loadCanvasAddon();
+            console.log('[Renderer] Mobile detected, using DOM renderer for reliability');
             return;
         }
         if (typeof WebglAddon !== 'undefined') {
             try {
                 this.webglAddon = new WebglAddon.WebglAddon();
                 this.webglAddon.onContextLoss(() => {
-                    this.webglAddon.dispose();
+                    const addon = this.webglAddon;
                     this.webglAddon = null;
-                    this._loadCanvasAddon();
+                    try { if (addon) addon.dispose(); } catch (_) {}
+                    console.log('[Renderer] WebGL context lost, using DOM renderer');
                 });
                 this.terminal.loadAddon(this.webglAddon);
             } catch (e) {
-                console.log('[Renderer] WebGL unavailable, using Canvas renderer');
-                this._loadCanvasAddon();
-            }
-        } else {
-            console.log('[Renderer] WebGL unavailable, using Canvas renderer');
-            this._loadCanvasAddon();
-        }
-    }
-
-    _loadCanvasAddon() {
-        if (typeof CanvasAddon !== 'undefined') {
-            try {
-                this.canvasAddon = new CanvasAddon.CanvasAddon();
-                this.terminal.loadAddon(this.canvasAddon);
-            } catch (e) {
-                console.log('[Renderer] Canvas unavailable, using DOM renderer (slower)');
+                this.webglAddon = null;
+                console.log('[Renderer] WebGL unavailable, using DOM renderer');
             }
         } else {
-            console.log('[Renderer] Canvas unavailable, using DOM renderer (slower)');
+            console.log('[Renderer] WebGL unavailable, using DOM renderer');
         }
     }
 
@@ -4259,6 +4277,9 @@ class ClaudeCodeWebInterface {
         const enableSessionStickyNotes = document.getElementById('enableSessionStickyNotes');
         if (enableSessionStickyNotes) enableSessionStickyNotes.checked = settings.enableSessionStickyNotes ?? true;
 
+        const wheelScrollMode = document.getElementById('wheelScrollMode');
+        if (wheelScrollMode) wheelScrollMode.value = settings.wheelScrollMode || 'dontHijack';
+
         // Update install section
         this._updateInstallSection();
     }
@@ -4559,7 +4580,11 @@ class ClaudeCodeWebInterface {
             notifVolume: 30,
             notifDesktop: true,
             enableSessionStickyNotes: true,
-            tabSnapshotLines: 500
+            tabSnapshotLines: 500,
+            // Trackpad/mouse-wheel behaviour inside full-screen (alt-buffer) apps:
+            //   'dontHijack' - wheel does nothing there (no menu hijack in the Claude Code TUI)
+            //   'altScroll'  - wheel sends Up/Down arrows (pagers like `less` scroll)
+            wheelScrollMode: 'dontHijack'
         };
     }
 
@@ -4602,7 +4627,8 @@ class ClaudeCodeWebInterface {
             notifVolume: parseInt(document.getElementById('notifVolume')?.value || '30'),
             notifDesktop: document.getElementById('notifDesktop')?.checked ?? true,
             enableSessionStickyNotes: document.getElementById('enableSessionStickyNotes')?.checked ?? true,
-            tabSnapshotLines: parseInt(document.getElementById('tabSnapshotLines')?.value || '500', 10)
+            tabSnapshotLines: parseInt(document.getElementById('tabSnapshotLines')?.value || '500', 10),
+            wheelScrollMode: document.getElementById('wheelScrollMode')?.value || 'dontHijack'
         };
 
         try {
@@ -4651,6 +4677,10 @@ class ClaudeCodeWebInterface {
         this.terminal.options.cursorBlink = settings.cursorBlink ?? true;
         if (settings.scrollback) this.terminal.options.scrollback = settings.scrollback;
 
+        // Cache the wheel-scroll policy for the capture-phase wheel handler
+        // (read live per wheel event without touching localStorage each notch).
+        this._wheelScrollMode = settings.wheelScrollMode || 'dontHijack';
+
         // Push the instant-snapshot line cap to the cache (0 disables capture+paint).
         if (this.snapshotCache && settings.tabSnapshotLines !== undefined) {
             this.snapshotCache.setMaxLines(settings.tabSnapshotLines);

package/src/public/index.html

@@ -106,15 +106,19 @@
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link rel="preconnect" href="https://cdn.jsdelivr.net" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Inter:wght@400;500;600&display=swap" rel="stylesheet" media="print" onload="this.media='all'">
-    <script src="https://unpkg.com/xterm@5.3.0/lib/xterm.js"></script>
-    <script src="https://unpkg.com/xterm-addon-fit@0.8.0/lib/xterm-addon-fit.js"></script>
-    <script src="https://unpkg.com/xterm-addon-web-links@0.9.0/lib/xterm-addon-web-links.js"></script>
-    <script src="https://unpkg.com/xterm-addon-search@0.13.0/lib/xterm-addon-search.js"></script>
-    <script src="https://unpkg.com/xterm-addon-unicode11@0.6.0/lib/xterm-addon-unicode11.js"></script>
-    <script src="https://unpkg.com/xterm-addon-webgl@0.16.0/lib/xterm-addon-webgl.js"></script>
-    <script src="https://unpkg.com/xterm-addon-canvas@0.5.0/lib/xterm-addon-canvas.js"></script>
-    <script src="https://unpkg.com/xterm-addon-serialize@0.11.0/lib/xterm-addon-serialize.js"></script>
-    <link rel="stylesheet" href="https://unpkg.com/xterm@5.3.0/css/xterm.css" />
+    <!-- xterm.js self-hosted under vendor/xterm/ (not a CDN) for deterministic,
+         offline-capable, fast loads — same rationale as the self-hosted fonts.
+         Versions: xterm 6.0.0, addon-fit 0.11.0, addon-web-links 0.12.0,
+         addon-search 0.16.0, addon-unicode11 0.9.0, addon-webgl 0.19.0,
+         addon-serialize 0.14.0. -->
+    <script src="/vendor/xterm/xterm.js"></script>
+    <script src="/vendor/xterm/addon-fit.js"></script>
+    <script src="/vendor/xterm/addon-web-links.js"></script>
+    <script src="/vendor/xterm/addon-search.js"></script>
+    <script src="/vendor/xterm/addon-unicode11.js"></script>
+    <script src="/vendor/xterm/addon-webgl.js"></script>
+    <script src="/vendor/xterm/addon-serialize.js"></script>
+    <link rel="stylesheet" href="/vendor/xterm/xterm.css" />
     <!-- Monaco editor is loaded lazily on first file preview/editor open via
          file-viewer-monaco.js (see ADR-0016). Preconnect above warms the
          CDN handshake; we don't preload loader.js to avoid charging users
@@ -493,6 +497,14 @@
                                         <span class="range-value" id="terminalPaddingValue">8px</span>
                                     </span>
                                 </div>
+                                <div class="setting-group">
+                                    <label for="wheelScrollMode">Trackpad scroll in full-screen apps</label>
+                                    <select id="wheelScrollMode">
+                                        <option value="dontHijack">Don't hijack menus</option>
+                                        <option value="altScroll">Scroll (send arrows)</option>
+                                    </select>
+                                </div>
+                                <div class="setting-hint">Inside full-screen apps like the Claude Code TUI, the wheel can't both scroll and drive menus. &ldquo;Don't hijack&rdquo; stops it from jumping menus; &ldquo;Scroll&rdquo; makes it scroll pagers like <code>less</code>. Normal shell scrolling is unaffected.</div>
                             </section>
 
                             <section class="settings-pane" id="settingsPane-voice" role="tabpanel" aria-labelledby="settingsTab-voice" tabindex="0" hidden>
@@ -841,6 +853,7 @@
     <script src="clipboard-handler.js"></script>
     <script src="image-handler.js"></script>
     <script src="generic-drop-handler.js"></script>
+    <script src="terminal-wheel.js"></script>
     <script src="auth.js"></script>
     <script src="feedback-manager.js"></script>
     <!-- marked.min.js and purify.min.js lazy-loaded on first plan viewer open -->
@@ -849,6 +862,7 @@
     <script src="sticky-note-card.js"></script>
     <script src="artifact-panel.js"></script>
     <script src="heartbeat-watchdog.js"></script>
+    <script src="ws-reconnect.js"></script>
     <script src="splits.js"></script>
     <script src="icons.js"></script>
     <script src="file-viewer-monaco.js"></script>

package/src/public/service-worker.js

@@ -1,6 +1,6 @@
 // Bump this version when urlsToCache entries are added or removed.
 // Content changes to existing files are handled by the network-first fetch strategy.
-const CACHE_NAME = 'ai-or-die-v11';
+const CACHE_NAME = 'ai-or-die-v13';
 const urlsToCache = [
   '/',
   '/index.html',
@@ -49,7 +49,13 @@ const urlsToCache = [
   '/voice-handler.js',
   '/image-handler.js',
   '/input-overlay.js',
-  '/feedback-manager.js'
+  '/feedback-manager.js',
+  '/terminal-wheel.js'
+  // xterm.js is self-hosted under /vendor/xterm/ (served locally, fast) but is
+  // intentionally NOT precached on install: ~900KB of addons would bloat the
+  // install step (it churns on every fresh page load, and is pathologically slow
+  // under the WebKit-on-Windows CI runner). The runtime fetch handler caches it
+  // on first load, so offline still works after the first online visit.
 ];
 
 // Install event - cache resources

package/src/public/splits.js

@@ -69,34 +69,34 @@ class Split {
 
         this.terminal.open(terminalDiv);
 
-        // WebGL renderer with Canvas fallback
+        // Trackpad/mouse-wheel policy (same as the main terminal): preempt
+        // xterm's alt-buffer wheel->arrow translation so scrolling doesn't
+        // hijack the Claude Code TUI. Reads the app-wide setting live.
+        if (typeof window.attachTerminalWheel === 'function') {
+            this._wheelHandler = window.attachTerminalWheel(
+                this.terminal,
+                terminalDiv,
+                () => (this.app && this.app._wheelScrollMode) || 'dontHijack'
+            );
+        }
+
+        // WebGL renderer with DOM-renderer fallback. The Canvas renderer was
+        // removed in xterm 6.0, so on WebGL failure/context-loss we fall back to
+        // xterm's default DOM renderer (loading no addon).
         if (typeof WebglAddon !== 'undefined') {
             try {
                 this.webglAddon = new WebglAddon.WebglAddon();
                 this.webglAddon.onContextLoss(() => {
-                    this.webglAddon.dispose();
+                    const addon = this.webglAddon;
                     this.webglAddon = null;
-                    if (typeof CanvasAddon !== 'undefined') {
-                        try {
-                            this.canvasAddon = new CanvasAddon.CanvasAddon();
-                            this.terminal.loadAddon(this.canvasAddon);
-                        } catch (_) {}
-                    }
+                    try { if (addon) addon.dispose(); } catch (_) {}
+                    // No addon loaded -> xterm reverts to the DOM renderer.
                 });
                 this.terminal.loadAddon(this.webglAddon);
             } catch (e) {
-                if (typeof CanvasAddon !== 'undefined') {
-                    try {
-                        this.canvasAddon = new CanvasAddon.CanvasAddon();
-                        this.terminal.loadAddon(this.canvasAddon);
-                    } catch (_) {}
-                }
+                this.webglAddon = null;
+                // Falls back to the default DOM renderer.
             }
-        } else if (typeof CanvasAddon !== 'undefined') {
-            try {
-                this.canvasAddon = new CanvasAddon.CanvasAddon();
-                this.terminal.loadAddon(this.canvasAddon);
-            } catch (_) {}
         }
 
         // Re-render split terminal when fonts finish loading
@@ -152,11 +152,69 @@ class Split {
                                 caption: imageData.caption || ''
                             }));
                         }
+                    },
+                    // Non-image files pasted from a file manager route through the
+                    // generic pipeline — same bridge as the main terminal
+                    // (app.js). Without this, non-image PASTE is silently dropped
+                    // in a split pane. Fires only after the image branch declines.
+                    onFilesPaste: (files) => {
+                        if (this._genericDropHandler
+                                && typeof this._genericDropHandler.dispatchFiles === 'function') {
+                            this._genericDropHandler.dispatchFiles(files);
+                        }
                     }
                 }
             );
         }
 
+        // Generic (non-image) file drop — mirror of the main terminal wiring
+        // in app.js. WITHOUT this, a split pane attaches only the image
+        // handler, whose drop listener preventDefaults every drop and then
+        // silently returns for anything that isn't an accepted image — so
+        // dropping a PDF (or any non-image file) on a split does nothing.
+        // Runs in capture phase so it preempts xterm's own drop handling;
+        // image MIMEs delegate to the image preview via onImageDrop, everything
+        // else uploads to <session cwd>/.claude-attachments/ and injects
+        // `@<absolute-path>` as bracketed paste.
+        //
+        // Session scoping is load-bearing: use THIS split's sessionId-scoped
+        // working dir + THIS split's socket, never the foregrounded session's
+        // (same wrong-session hazard the link-provider comment above warns of).
+        if (window.genericDropHandler) {
+            this._genericDropHandler = window.genericDropHandler.attachGenericDropHandler({
+                containerEl: terminalContainer,
+                getWorkingDir: () => (this.app && typeof this.app.getSessionWorkingDir === 'function'
+                    ? this.app.getSessionWorkingDir(this.sessionId) : null),
+                getAuthToken: () => (window.authManager && window.authManager.getToken
+                    ? window.authManager.getToken() : null),
+                onImageDrop: () => {
+                    // Intentionally a no-op: for an image-only drop the generic
+                    // handler returns WITHOUT stopPropagation (see the "defer to
+                    // image-handler.js entirely" branch in generic-drop-handler.js),
+                    // so this split's own image handler onDrop still fires and
+                    // shows the preview. Calling showImagePreview here too would
+                    // stack a SECOND identical modal. (Mixed image+non-image drops
+                    // do stopPropagation, so the image partition of a mixed drop is
+                    // not previewed — a rare edge; drop images on their own.)
+                },
+                injectAtPath: (atPath) => {
+                    if (!atPath) return;
+                    let normalized = attachClipboardHandler.normalizeLineEndings(atPath + ' ');
+                    if (this.terminal && this.terminal.modes && this.terminal.modes.bracketedPasteMode) {
+                        normalized = attachClipboardHandler.wrapBracketedPaste(normalized);
+                    }
+                    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                        this.socket.send(JSON.stringify({ type: 'input', data: normalized }));
+                    }
+                },
+                onError: (basename, msg) => {
+                    if (window.feedback && typeof window.feedback.error === 'function') {
+                        window.feedback.error(basename + ': ' + msg);
+                    }
+                },
+            });
+        }
+
         // Setup terminal input handler
         this.terminal.onData((data) => {
             if (this.socket && this.socket.readyState === WebSocket.OPEN) {
@@ -424,6 +482,11 @@ class Split {
 
     destroy() {
         this.disconnect();
+        // Tear down drop/paste handlers (listeners + any in-flight uploads)
+        // before disposing the terminal so nothing fires against a dead pane.
+        try { if (this._genericDropHandler && this._genericDropHandler.destroy) this._genericDropHandler.destroy(); } catch (_) {}
+        try { if (this._imageHandler && this._imageHandler.destroy) this._imageHandler.destroy(); } catch (_) {}
+        try { if (this._wheelHandler && this._wheelHandler.dispose) this._wheelHandler.dispose(); } catch (_) {}
         if (this.terminal) {
             this.terminal.dispose();
         }

package/src/public/terminal-wheel.js

@@ -0,0 +1,188 @@
+/**
+ * terminal-wheel.js — trackpad / mouse-wheel policy for xterm terminals.
+ *
+ * Problem it fixes: when a full-screen app is on the ALTERNATE screen buffer
+ * (the Claude Code TUI, `less`, `vim`, ...), xterm.js unconditionally converts
+ * every wheel notch into cursor Up/Down key bytes (ESC O A / ESC O B, or the
+ * CSI form) and cancels native scroll. Inside the Claude Code TUI those arrows
+ * jump menus/history instead of scrolling — so the trackpad "presses the
+ * up/down buttons" rather than scrolling.
+ *
+ * There is no xterm option to disable this. On xterm >= 5.4 we use the official
+ * `attachCustomWheelEventHandler` (returning false cancels xterm's own wheel
+ * processing — both the scrollback scroll and the alt-buffer arrow translation).
+ * On older xterm we fall back to a CAPTURE-PHASE wheel listener installed on an
+ * ANCESTOR of `.xterm`, which fires BEFORE xterm's own wheel listener so
+ * stopImmediatePropagation() there preempts the translation. Either way the
+ * decision is identical (decideWheelAction).
+ *
+ * Behaviour (see decideWheelAction):
+ *   - Normal buffer            -> passthrough (xterm scrolls scrollback natively)
+ *   - Alt buffer + mouse mode  -> passthrough (xterm reports wheel as mouse events)
+ *   - Alt buffer, no mouse     -> governed by the user's `wheelScrollMode`:
+ *        'dontHijack' (default): suppress   -> no arrows, no menu hijack
+ *        'altScroll'           : passthrough -> xterm sends arrows (pagers scroll)
+ *   - An app that explicitly sets DEC private mode 1007 (alternate scroll mode)
+ *     overrides the default for that app: 1007h -> passthrough, 1007l -> suppress.
+ *
+ * Honest note: in the alt buffer the Claude Code TUI and a pager are otherwise
+ * indistinguishable (both alt-screen, no mouse, no 1007), so the toggle is the
+ * real control; the default is tuned for the Claude-Code-primary workflow.
+ */
+(function () {
+  'use strict';
+
+  /**
+   * Pure decision function (exported for unit tests).
+   * @param {object} terminal  xterm Terminal (needs .buffer.active.type and .modes)
+   * @param {string} mode      'dontHijack' | 'altScroll'
+   * @param {('on'|'off'|null)} force1007  explicit DEC 1007 state, overrides `mode`
+   * @returns {'passthrough'|'suppress'}
+   */
+  function decideWheelAction(terminal, mode, force1007) {
+    try {
+      var active = terminal && terminal.buffer && terminal.buffer.active;
+      var isAlt = !!(active && active.type === 'alternate');
+      // Normal buffer: never interfere — xterm scrolls the scrollback natively.
+      if (!isAlt) return 'passthrough';
+
+      // Alt buffer but the app enabled mouse tracking: let xterm report the wheel
+      // as mouse events so mouse-aware apps keep scrolling.
+      var modes = terminal.modes || {};
+      if (modes.mouseTrackingMode && modes.mouseTrackingMode !== 'none') {
+        return 'passthrough';
+      }
+
+      // An app's explicit DEC 1007 wins over the user's wheelScrollMode:
+      // 1007h forces passthrough even under dontHijack; 1007l forces suppress
+      // even under altScroll (the app explicitly opted out of alternate scroll).
+      if (force1007 === 'on') return 'passthrough';
+      if (force1007 === 'off') return 'suppress';
+
+      // Ambiguous alt-buffer case: user setting decides.
+      if (mode === 'altScroll') return 'passthrough';
+      return 'suppress'; // 'dontHijack' default
+    } catch (_) {
+      // Never break scrolling on an unexpected terminal shape.
+      return 'passthrough';
+    }
+  }
+
+  /**
+   * Attach the wheel policy to a terminal.
+   * @param {object} terminal      xterm Terminal instance
+   * @param {HTMLElement} containerEl  an ANCESTOR of the `.xterm` element (the element passed to terminal.open())
+   * @param {function(): string} getMode  returns the current 'wheelScrollMode'
+   * @returns {{dispose: function}} handle whose dispose() removes the listener + parser hooks
+   */
+  function attachTerminalWheel(terminal, containerEl, getMode) {
+    if (!terminal) {
+      return { dispose: function () {} };
+    }
+
+    // Track explicit DEC private mode 1007 (alternate scroll mode). xterm does
+    // not expose 1007, so we observe the control sequences via the parser. We
+    // ALWAYS return false so the sequence still flows to xterm's own handlers
+    // (xterm ignores 1007, but returning true would swallow every other
+    // DEC-private set/reset — cursor, alt buffer, mouse, bracketed paste).
+    //
+    // CRITICAL: the flag is per-alt-screen-app, not per-session. Entering OR
+    // leaving the alt buffer (1049/1047/47) and a full reset (RIS, ESC c) clear
+    // it, so a stale 1007 from a previous app (e.g. tmux) can't hijack the next
+    // one (e.g. the Claude Code TUI).
+    var alt1007 = null; // null = the current alt-screen app never set it
+    var disposers = [];
+    try {
+      var parser = terminal.parser;
+      if (parser && typeof parser.registerCsiHandler === 'function') {
+        var scan = function (value) {
+          return function (params) {
+            try {
+              var toggleAlt = false, set1007 = false;
+              for (var i = 0; i < params.length; i++) {
+                var p = params[i];
+                if (p === 1007) set1007 = true;
+                else if (p === 1049 || p === 1047 || p === 47) toggleAlt = true;
+              }
+              if (toggleAlt) alt1007 = null; // alt-buffer enter/exit resets the per-app preference
+              if (set1007) alt1007 = value;  // explicit 1007 wins
+            } catch (_) {}
+            return false; // never consume
+          };
+        };
+        disposers.push(parser.registerCsiHandler({ prefix: '?', final: 'h' }, scan('on')));
+        disposers.push(parser.registerCsiHandler({ prefix: '?', final: 'l' }, scan('off')));
+      }
+      if (parser && typeof parser.registerEscHandler === 'function') {
+        // RIS (ESC c) — full terminal reset clears the 1007 preference too.
+        disposers.push(parser.registerEscHandler({ final: 'c' }, function () { alt1007 = null; return false; }));
+      }
+    } catch (_) {
+      // Parser API differences: degrade gracefully to setting-only behaviour.
+    }
+
+    var decide = function () {
+      var mode = 'dontHijack';
+      try {
+        var m = typeof getMode === 'function' ? getMode() : null;
+        if (m) mode = m;
+      } catch (_) {}
+      return decideWheelAction(terminal, mode, alt1007);
+    };
+
+    var disposeParser = function () {
+      for (var i = 0; i < disposers.length; i++) {
+        try { if (disposers[i] && disposers[i].dispose) disposers[i].dispose(); } catch (_) {}
+      }
+      disposers = [];
+    };
+
+    // Preferred (xterm >= 5.4): the official custom wheel handler. Returning
+    // false cancels xterm's own wheel processing. Re-attaching replaces the
+    // handler (naturally idempotent), and terminal.dispose() tears it down.
+    if (typeof terminal.attachCustomWheelEventHandler === 'function') {
+      terminal.attachCustomWheelEventHandler(function () {
+        return decide() !== 'suppress';
+      });
+      return {
+        dispose: function () {
+          try { terminal.attachCustomWheelEventHandler(function () { return true; }); } catch (_) {}
+          disposeParser();
+        }
+      };
+    }
+
+    // Fallback (older xterm without the API): capture-phase listener on an
+    // ancestor of `.xterm` preempts xterm's own wheel listener.
+    if (!containerEl || typeof containerEl.addEventListener !== 'function') {
+      disposeParser();
+      return { dispose: function () {} };
+    }
+    var onWheel = function (ev) {
+      if (decide() === 'suppress') {
+        ev.preventDefault();
+        ev.stopImmediatePropagation();
+      }
+      // 'passthrough' -> do nothing; xterm's own wheel listener runs next.
+    };
+    // passive:false because we may preventDefault().
+    containerEl.addEventListener('wheel', onWheel, { capture: true, passive: false });
+
+    return {
+      dispose: function () {
+        try { containerEl.removeEventListener('wheel', onWheel, { capture: true }); } catch (_) {}
+        disposeParser();
+      }
+    };
+  }
+
+  var api = { attachTerminalWheel: attachTerminalWheel, decideWheelAction: decideWheelAction };
+
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = api;
+  }
+  if (typeof window !== 'undefined') {
+    window.attachTerminalWheel = attachTerminalWheel;
+    window.terminalWheel = api;
+  }
+})();

package/src/public/vendor/xterm/addon-fit.js

@@ -0,0 +1,2 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.FitAddon=t():e.FitAddon=t()}(globalThis,(()=>(()=>{"use strict";var e={};return(()=>{var t=e;Object.defineProperty(t,"__esModule",{value:!0}),t.FitAddon=void 0,t.FitAddon=class{activate(e){this._terminal=e}dispose(){}fit(){const e=this.proposeDimensions();if(!e||!this._terminal||isNaN(e.cols)||isNaN(e.rows))return;const t=this._terminal._core;this._terminal.rows===e.rows&&this._terminal.cols===e.cols||(t._renderService.clear(),this._terminal.resize(e.cols,e.rows))}proposeDimensions(){if(!this._terminal)return;if(!this._terminal.element||!this._terminal.element.parentElement)return;const e=this._terminal._core._renderService.dimensions;if(0===e.css.cell.width||0===e.css.cell.height)return;const t=0===this._terminal.options.scrollback?0:this._terminal.options.overviewRuler?.width||14,r=window.getComputedStyle(this._terminal.element.parentElement),i=parseInt(r.getPropertyValue("height")),o=Math.max(0,parseInt(r.getPropertyValue("width"))),s=window.getComputedStyle(this._terminal.element),n=i-(parseInt(s.getPropertyValue("padding-top"))+parseInt(s.getPropertyValue("padding-bottom"))),l=o-(parseInt(s.getPropertyValue("padding-right"))+parseInt(s.getPropertyValue("padding-left")))-t;return{cols:Math.max(2,Math.floor(l/e.css.cell.width)),rows:Math.max(1,Math.floor(n/e.css.cell.height))}}}})(),e})()));
+//# sourceMappingURL=addon-fit.js.map