CI: Linux tests in the Gitea job's image, since the hosted image's zsh and fish break the shell tests

.github/workflows/ci.yml

@@ -7,7 +7,7 @@ on:
 
 jobs:
   macos:
-    runs-on: macos-latest
+    runs-on: [self-hosted, macos-arm64]
     steps:
       - uses: actions/checkout@v7
       # The runner's PATH lacks the host's rustup.
@@ -16,31 +16,32 @@ jobs:
       - run: scripts/check.sh
       - run: cargo build --locked
 
-  platforms:
+  windows:
-    strategy:
+    runs-on: [self-hosted, ely-windows]
-      fail-fast: false
+    env:
-      matrix:
+      CARGO_PROFILE_DEV_DEBUG: 0
-        os: [ubuntu-24.04, windows-latest]
+    steps:
-    runs-on: ${{ matrix.os }}
+      - uses: actions/checkout@v7
-    # Debuginfo makes the Linux link outgrow its VM's memory.
+      - run: rustup toolchain install --no-self-update
+      - run: cargo test --locked --quiet
+      - run: cargo build --locked
+
+  linux:
+    runs-on: ubuntu-24.04
+    # A clean image: the hosted one's zsh and fish setup breaks the shell tests.
+    container: docker.gitea.com/runner-images:ubuntu-24.04
     env:
       CARGO_PROFILE_DEV_DEBUG: 0
     steps:
       - uses: actions/checkout@v7
       # The job container comes without rustup.
-      - if: runner.os == 'Linux'
+      - run: |
-        run: |
           curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --no-modify-path --default-toolchain none
           echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
       - run: rustup toolchain install --no-self-update
-      # On a host runner its post step deletes the host's rustup.
+      - uses: Swatinem/rust-cache@v2
-      - if: runner.os == 'Linux'
+      # The job container runs as root, which ignores the file permissions the tests check.
-        uses: Swatinem/rust-cache@v2
+      - run: |
-      - if: runner.os != 'Linux'
-        run: cargo test --locked --quiet
-      # The Linux job container runs as root, which ignores the file permissions the tests check.
-      - if: runner.os == 'Linux'
-        run: |
           apt-get update && apt-get install -y --no-install-recommends pkg-config libwayland-dev \
             libxkbcommon-dev libxkbcommon-x11-dev libxcb1-dev libx11-xcb-dev libfontconfig-dev \
             libfreetype-dev zsh fish xvfb

.github/workflows/release.yml

@@ -7,7 +7,9 @@ on:
 jobs:
   macos:
     # The owner's login session, whose keychain holds the Developer ID identity.
-    runs-on: macos-signing
+    runs-on: [self-hosted, macos-signing]
+    permissions:
+      contents: write
     steps:
       - uses: actions/checkout@v7
       # The runner's PATH lacks the host's rustup.
@@ -26,8 +28,7 @@ jobs:
           scripts/mac-app.sh
       - name: Put the disk image on the release
         env:
-          RELEASE_API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          RELEASE_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           version=$(cargo pkgid)
           scripts/release-asset.sh "target/release/ELYTerminal-${version##*[#@]}.dmg"

AGENTS.md

@@ -5,11 +5,11 @@ ELYTerminal. A terminal on GPUI and Ely components. `PRD.md` says what it does;
 ## Stack
 
 - Rust 1.95.0, as `rust-toolchain.toml` pins it, edition 2024. One binary crate, `elyterminal`.
-- Ely (`ely-gpui-component`) from git.zacharyzhang.com, pinned by rev. gpui and gpui_platform from crates.io's `gpui-pre`, the exact version Ely pins, under their crate names through `package`.
+- Ely (`ely-gpui-component`) from github.com/ELY-Open-Source, pinned by rev. gpui and gpui_platform from crates.io's `gpui-pre`, the exact version Ely pins, under their crate names through `package`.
 - `alacritty_terminal` 0.26: grid, parser, pseudo-terminal, event loop.
 - `serde`, `serde_json`: settings. `dirs`: the config folder. `base64`, the version alacritty pulls in for OSC 52: OSC 7501's text. `log`, `env_logger`: logs to stderr. `unicode-normalization`, on macOS: Git's marks in composed form.
 - On Linux, `wayland-client`, `wayland-backend` and `wayland-protocols` (staging) ask the compositor for `ext_background_effect_v1` on gpui's own connection; `wayland-server` hosts a compositor in the tests. `x11rb` sets `_KDE_NET_WM_BLUR_BEHIND_REGION`; its test runs Xvfb.
-- On Windows, `sysinfo` reads herdr's client's arguments and variables; `windows-sys`, the version the Windows build already holds, lists processes, waits on herdr's pipe, reads the keyboard for win32-input-mode, and keeps Ely's window on the main one, which `raw-window-handle` finds.
+- On Windows, `sysinfo` reads herdr's client's arguments and variables; `windows-sys`, the version the Windows build already holds, lists processes, waits on herdr's pipe, reads the keyboard for win32-input-mode, keeps Ely's window on the main one, which `raw-window-handle` finds, and on Windows 10 reads the build and clears the main window's acrylic while it moves.
 - `resvg`, a dev dependency at the version gpui uses, renders the icon's SVG for the macOS app and the Windows `.ico`. `embed-resource`, a build dependency at the version gpui uses, puts the icon into the Windows executable.
 
 ## Commands
@@ -22,22 +22,23 @@ ELYTerminal. A terminal on GPUI and Ely components. `PRD.md` says what it does;
   - `snap` writes each child window's picture at that moment, `PNG.childN.snapK.png`, so a child that moves shows its frames;
   - `activate` and `deactivate` the app, which takes real keystrokes while active: keep the two specs adjacent. macOS may delay or refuse the activation; each `shot: typed` line says whether the app was active;
   - `to:settings` and `to:main` aim the specs after them, and the picture, at that window, which becomes the app's key window, since AppKit sends keys there; the app stays inactive, and gpui sends an inactive window no focus or blur events, so press Enter to commit a field. AppKit gives an inactive app's key that a menu item holds to the menu, and gpui sends the item's action to the main window, which an inactive app lacks: only an app-wide action runs, such as Quit, Settings or the font's size;
+  - `drop@x,y` drops the files `SHOT_DROP` names, one a line, as gpui's view hands a drop on, a move, a release and the drag's end, 120 ms apart;
   - mouse gestures handed to gpui's view, at points from the content's top-left, modifiers as for keys: `click@x,y`, `click2@`, `click3@`, `rclick@`, `mclick@`, `drag@x,y@x,y`, `move@x,y`, the steps `ldown@`, `lup@`, `ldrag@`, `rdown@`, `rup@`, `mdown@`, `mup@`, and `scrollup@x,y@lines`, `scrolldown@x,y@lines`.
 - `scripts/check.sh`: fmt, clippy `-D warnings`, tests, the 500-line rule.
 - `scripts/linux.sh ARGS` runs `cargo ARGS` on the working tree in a Linux container, the build kept in Docker volumes; `scripts/linux.sh test --locked` runs the tests as a user, not root, as CI does. The tree goes in as a tar stream, every file dated now: Colima's shared folder can show the VM a file as it was before an edit, and cargo judges by date, so a tree older than the last build would reuse that build. It needs a Docker daemon: on macOS, Colima (`colima start`).
 - `scripts/mac-app.sh` builds `target/release/ELYTerminal.app` from a release build, signed ad hoc, and `ELYTerminal-VERSION.dmg` beside it, the app next to a link to Applications. Given `SIGN_IDENTITY` and the App Store Connect key, `NOTARY_KEY` (its .p8 file), `NOTARY_KEY_ID` and `NOTARY_ISSUER`, it signs with that identity under the hardened runtime, then notarizes and staples the image, and it stops before building when one is missing or no keychain holds the identity. Its icon: `examples/icons.rs` renders `assets/icons/elyterminal-macos.svg` into an iconset, which `iconutil` packs.
 - `scripts/windows-zip.ps1`, on Windows with Visual Studio's C++ tools, builds `elyterminal.exe` with its icon and zips it as `ELYTerminal-VERSION-windows-ARCH.zip` in `target/release`. After an edit to the figure, `cargo run --example icons -- ico assets/icons/elyterminal.svg assets/icons/elyterminal.ico` renders the icon again.
 - `scripts/linux-tar.sh` builds the release in Docker on `rust:1.95.0-bookworm` and packs it with `com.zacharyzhang.elyterminal.desktop` and the icon as `ELYTerminal-VERSION-linux-ARCH.tar.gz` in `target/release`.
-- `scripts/release-asset.sh FILE` puts FILE on the Gitea release of this version, a draft too, in place of a file of its name; `RELEASE_API` and `RELEASE_TOKEN` say where and as whom. The Release workflow, `.github/workflows/release.yml`, dispatched by hand, builds the signed and notarized disk image on the `macos-signing` runner and puts it on the release.
+- `scripts/release-asset.sh FILE` puts FILE on the GitHub release of this version, a draft too, in place of a file of its name, through `gh`. The Release workflow, `.github/workflows/release.yml`, dispatched by hand, builds the signed and notarized disk image on the `macos-signing` runner and puts it on the release.
 
 ## Layout
 
 - `build.rs`: on Windows, the icon into the executable as resource 1, through `assets/icons/elyterminal.rc`. `.cargo/config.toml`: Windows builds carry the C runtime. `rust-toolchain.toml`: the toolchain rustup installs.
-- `src/main.rs`: start. `src/lib.rs`: the modules, public so tests and examples reach them. `src/app.rs`: fonts, settings, integration, then the main window, at the size the settings keep, which it keeps as it settles. `src/menus.rs`: the menu bar, the keys of Quit, the font's size and Minimize, and what they do. `src/blur.rs`: what the window shows of the desktop, from the opacity and blur settings, set as they change; `blur/macos` gives gpui's NSVisualEffectView a material that blurs; `blur/wayland` asks a Wayland compositor for blur behind the window's surface through `ext_background_effect_v1`; `blur/x11` names the window's pane in `_KDE_NET_WM_BLUR_BEHIND_REGION`. `src/workspace.rs`: the window's content, Ely's `ColumnShell` with the sessions, terminal and right columns, their toggles, the right column's Git and Files switch, the title, and the sessions' lifecycle. `src/workspace/widths.rs`: the side columns' widths, which a drag on their border sets and the settings keep once it rests. `src/workspace/events.rs`: what a session's terminal reports: title, folder, bell, the state its row shows, the program's exit; and a press on a notification a session posted. `src/sessions.rs`: a session and its row, with the mark of its status and what hover shows of it; `sessions/orb` draws the mark, 3 by 3 dots on one clock. `src/files.rs`: the Files panel, the shown session's folder as Ely's `Tree` with Git's marks. `src/git.rs`: git through its command line: Files' marks, and the Git panel's status, stage, unstage, discard, commit and log; `src/git/diff.rs` reads git's diff into Ely's stretches. `src/git/panel.rs`: the Git panel's state and actions; `src/git/panel/view.rs`: how it draws. `src/updates.rs`: checks for a newer release through `curl` and Gitea's API, at start and once a day while the settings ask, and when Settings › Terminal asks.
+- `src/main.rs`: start. `src/lib.rs`: the modules, public so tests and examples reach them. `src/app.rs`: fonts, settings, integration, then the main window, at the size the settings keep, which it keeps as it settles. `src/menus.rs`: the menu bar, the keys of Quit, the font's size and Minimize, and what they do. `src/blur.rs`: what the window shows of the desktop, from the opacity and blur settings, set as they change; `blur/macos` gives gpui's NSVisualEffectView a material that blurs; `blur/wayland` asks a Wayland compositor for blur behind the window's surface through `ext_background_effect_v1`; `blur/x11` names the window's pane in `_KDE_NET_WM_BLUR_BEHIND_REGION`. `blur/windows`, on Windows 10, clears a blurred window's acrylic while it moves or sizes. `src/workspace.rs`: the window's content, Ely's `ColumnShell` with the sessions, terminal and right columns, their toggles, the right column's Git and Files switch, the title, and the sessions' lifecycle. `src/workspace/widths.rs`: the side columns' widths, which a drag on their border sets and the settings keep once it rests. `src/workspace/rename.rs`: a session renamed in place. `src/workspace/events.rs`: what a session's terminal reports: title, folder, bell, the state its row shows, the program's exit; and a press on a notification a session posted. `src/sessions.rs`: a session and its row, with the mark of its status and what hover shows of it; `sessions/orb` draws the mark, 3 by 3 dots on one clock. `src/files.rs`: the Files panel, the shown session's folder as Ely's `Tree` with Git's marks. `src/git.rs`: git through its command line: Files' marks, and the Git panel's status, stage, unstage, discard, commit and log; `src/git/diff.rs` reads git's diff into Ely's stretches. `src/git/panel.rs`: the Git panel's state and actions; `src/git/panel/view.rs`: how it draws. `src/updates.rs`: checks for a newer release through `curl` and Gitea's API, at start and once a day while the settings ask, and when Settings › Terminal asks.
 - `src/pet.rs`: Ely, peeking over the main window's top edge from a window of her own while the settings want her, or up from its bottom edge where no room lies above it; she draws at every frame the display gives her window; `pet/rig` draws her from the icon's paths in layers of one color, each moved by a matrix of its own, as the films rig her; `pet/look` reads her mood from the sessions' marks and her pose at each moment of it, `look/curves` the timings of her moves; and `pet/macos`, `pet/windows` and `pet/x11` keep her window on the main window's edge where the platform does not.
 - `src/settings`: the model, its ranges, and `SettingsStore`, the global that loads, checks and saves `settings.json`; `window` is the settings window, `window/appearance` its Appearance page, `window/terminal` its Terminal page. `tests/fonts.rs` brings its own main: gpui builds its Mac platform only on the main thread.
 - `src/themes`: built-in terminal themes, the chrome palette each maps to, and `apply`, which dresses the app for the system's appearance; `omarchy`, on Linux, wears Omarchy 4's current theme and follows its switches.
-- `src/term`: the terminal engine. `pty` starts a program through alacritty's event loop; `tap` wraps the pty so its reader scans OSC 0, 2, 7, 9, 99, 133, 777 and 7501, the title stack's CSI 22 t and 23 t, full resets, the mouse modes and, on Windows, win32-input-mode (`tap/modes`) before the parser; `titles` keeps the title a session shows, read in the output's order; `marks` reads OSC 133's prompt marks; `status` reads OSC 7501 and keeps a terminal's records; `notify` reads OSC 9, 777 and 99, the notifications and OSC 9;4's progress, and gathers OSC 99's chunks; `reports` is the view's side of what programs report: it keeps OSC 7501's records, maps OSC 9;4, answers OSC 99's query and alive, and posts the system notifications its session posts; `prompts` turns each mark into an OSC 8 link the parser keeps in a prompt's cells, and finds the prompt to jump to; `herdr` follows herdr's focused pane and its agents' states through herdr's socket while herdr's client runs in the session, and tells the view herdr leads, so herdr opens its links: `herdr/unix` finds the client leading the pty's foreground, `herdr/windows` under the session's shell, and asks its named pipe. `unix` starts the program itself, so a failed `chdir` fails the start; Windows uses alacritty's ConPTY. `shell` writes the integration scripts at start and builds each shell's launch. `frame` reads the grid into styled rows, `boxes` turns box drawing, block elements and powerline arrows into rects and polygons (`boxes/outline` strokes curves and diagonals into polygons), `ink` resolves colors, `paint` draws rows, decorations and the cursor, `view` is the entity: pty events, metrics, blink, resize. `zoom` holds the points Bigger and Smaller add to the Size setting, unsaved. `keys` turns key events into bytes, the kitty protocol and, in `keys/legacy`, xterm's encoding, with no gpui types; `input` is the view's key listeners, the bindings that keep Tab and F6 from Ely's focus moves, and its IME handler; `mac` reads the Option side, the repeat flag and the key code of AppKit's current event, and the key's own character from the layout, as gpui reads key names; it keeps held keys repeating, and hands Command key-ups to the focused view. `win32` sends a key as Windows' own record, win32-input-mode, and finds a key's own character in Windows' layout. `mouse` encodes mouse reports, with no gpui types; `links` finds the link at a cell; `pointer` is the view's mouse listeners: selection, reports, wheel, links, copy and paste. `scrollbar` is the thumb over the history that a drag moves through it. `find` is the find box: Ely's `FindWidget`, and Ely's `find_all` over the grid's shown text.
+- `src/term`: the terminal engine. `pty` starts a program through alacritty's event loop; `tap` wraps the pty so its reader scans OSC 0, 2, 7, 9, 99, 133, 777 and 7501, the title stack's CSI 22 t and 23 t, full resets, the mouse modes and, on Windows, win32-input-mode (`tap/modes`) before the parser; `titles` keeps the title a session shows, read in the output's order; `marks` reads OSC 133's prompt marks; `status` reads OSC 7501 and keeps a terminal's records; `notify` reads OSC 9, 777 and 99, the notifications and OSC 9;4's progress, and gathers OSC 99's chunks; `reports` is the view's side of what programs report: it keeps OSC 7501's records, maps OSC 9;4, answers OSC 99's query and alive, and posts the system notifications its session posts; `prompts` turns each mark into an OSC 8 link the parser keeps in a prompt's cells, and finds the prompt to jump to; `herdr` follows herdr's focused pane and its agents' states through herdr's socket while herdr's client runs in the session, and tells the view herdr leads, so herdr opens its links: `herdr/unix` finds the client leading the pty's foreground, `herdr/windows` under the session's shell, and asks its named pipe. `unix` starts the program itself, so a failed `chdir` fails the start; Windows uses alacritty's ConPTY. `shell` writes the integration scripts at start and builds each shell's launch. `frame` reads the grid into styled rows, `boxes` turns box drawing, block elements and powerline arrows into rects and polygons (`boxes/outline` strokes curves and diagonals into polygons), `ink` resolves colors, `paint` draws rows, decorations and the cursor, `view` is the entity: pty events, metrics, blink, resize. `zoom` holds the points Bigger and Smaller add to the Size setting, unsaved. `keys` turns key events into bytes, the kitty protocol and, in `keys/legacy`, xterm's encoding, with no gpui types; `input` is the view's key listeners, the bindings that keep Tab and F6 from Ely's focus moves, and its IME handler; `mac` reads the Option side, the repeat flag and the key code of AppKit's current event, and the key's own character from the layout, as gpui reads key names; it keeps held keys repeating, and hands Command key-ups to the focused view. `win32` sends a key as Windows' own record, win32-input-mode, and finds a key's own character in Windows' layout. `mouse` encodes mouse reports, with no gpui types; `links` finds the link at a cell; `pointer` is the view's mouse listeners: selection, reports, wheel, links, copy and paste. `scrollbar` is the thumb over the history that a drag moves through it. `drop` types the paths of files dropped on the terminal. `fonts` loads the terminal's font and measures its cell. `click` turns a click on the line the shell reads into arrows to it. `find` is the find box: Ely's `FindWidget`, and Ely's `find_all` over the grid's shown text.
 - `assets/shell-integration`: ELYTerminal's own scripts (not Ghostty's, which are GPL): zsh through `ZDOTDIR`, bash through `--rcfile`, fish through `XDG_DATA_DIRS`, PowerShell through `-NoExit -Command`. Each prompt sends OSC 7 and, except in fish, whose `fish_title` stays, a title; each marks prompts and commands with OSC 133 where the shell does not.
 - `assets/fonts`: JetBrains Mono 2.304's bold and italic faces (OFL; Ely bundles regular), and Nerd Fonts 3.5.1's JetBrains Mono NF Mono Regular, which draws icons a font lacks.
 - `assets/themes`: Ghostty theme files copied verbatim from iTerm2-Color-Schemes (MIT, its `LICENSE` beside them).
@@ -86,10 +87,10 @@ ELYTerminal. A terminal on GPUI and Ely components. `PRD.md` says what it does;
 - 2026-10-15: on Wayland the window asks for `ext_background_effect_v1` beside gpui's `org_kde_kwin_blur`. A guest connection on gpui's own display binds it, takes the effect for the window's surface once, and blurs the window's pane: the surface less Ely's resize margin on each free edge of a client-drawn window, worked out each frame and sent only when it changes; it goes and comes back with Blurred and lands at the surface's next commit, which every frame makes. The guest connection reads the display only while the window opens, before gpui's loop runs, and is never dropped: a drop destroys its proxies through the display, which gpui may close first. The log names what the compositor offers, so which way blur goes: `ext_background_effect_v1`, gpui's `org_kde_kwin_blur`, or none, the desktop clear. Its test runs a `wayland-server` compositor on a socket pair.
 - 2026-10-15: on a client-drawn window, so on Linux, Ely's `ResizeBorder` paints its pane solid and shadowed under the content, which kept the desktop from showing at all. `ResizeBorder::glass`, added to Ely for this, leaves the pane to the content while the window is see-through: no ground, nor the shadow gpui draws under the box, which would tint it. So the blur covers the pane alone and the resize margin stays clear. On X11 the window names its pane in `_KDE_NET_WM_BLUR_BEHIND_REGION` (CARDINAL, 32: x, y, width, height in the window's pixels), as Ghostty names its own, and drops the property when Blurred goes; KWin reads it, other compositors pass it by. It goes over a connection of ELYTerminal's own to `$DISPLAY`, which gpui opens too: a property belongs to the window, whoever sets it. gpui's own `org_kde_kwin_blur` on KDE's Wayland still covers the whole surface, margin included, beyond ELYTerminal's reach.
 - 2026-10-15: the macOS menu bar is the PRD's: ELYTerminal (Settings…, Quit), Shell (New Session, Close Session), Edit (Copy, Paste, Select All, Find), View (Toggle Sessions, Toggle Right Panel, Bigger, Smaller, Reset Size), Window (Minimize, Zoom, then the windows macOS lists). An item shows the key bound to its action, so the menus are set after the bindings; Copy, Paste and Select All go through AppKit's `copy:`, `paste:` and `selectAll:`, as gpui's `OsAction` maps them. They are Ely's text input actions, which `forms` exports for this, and the terminal handles them too: gpui sends a menu's action to what holds focus and enables the item only where a handler waits, so one action serves the terminal, find and every field. The new keys are Ghostty's: Cmd-Q, Cmd-A, Cmd-= and Cmd-+, Cmd-minus, Cmd-0, Cmd-M. Off macOS Quit and Select All take Ctrl-Shift, since Ctrl with a letter types a control byte; the font's size takes plain Ctrl with =, +, minus and 0, which type none, as in Ghostty, Alacritty and Windows Terminal; Minimize has no key there. Bigger and Smaller move every session's font a point, inside the Size range, and Reset Size goes back to the setting; nothing saves the change, as in Ghostty. Select All runs from the first character in the history to the last on the screen, the blanks around them left out, as Ghostty's, though a space under a combining mark shows a character and counts as one; copy on select takes it, and a blank grid selects nothing.
-- 2026-10-15: CI runs on self-hosted Gitea runners, each job with what its runner must hold. macOS runs on the host, with fish and PowerShell installed, or the two shell tests fail as they should. Windows runs on the host, with rustup's `cargo` and `rustc` proxies beside `rustup` and Visual Studio's C++ tools. Ubuntu (`ubuntu-24.04`) runs as root in `docker.gitea.com/runner-images:ubuntu-24.04`, installs the libraries gpui links, and runs the tests as a user it makes, since root ignores the file modes they check; its runner serves this repository alone, in a VM of its own, so a build cannot starve other containers. The Linux and Windows jobs build without debuginfo, as `scripts/linux.sh` does: with it, linking gpui's test binaries outgrew that VM's 8 GB. The macOS and Windows jobs run on the owner's own machines, so they skip `Swatinem/rust-cache`: its post step cleans `$CARGO_HOME`, which there is the owner's own, and after every job it deleted `rustup` from `~/.cargo/bin`, leaving its proxies pointing at nothing, and pruned the shared registry; the Linux job keeps it, inside its container. A run that waits on a missing runner stays queued: cancel stale ones before a new runner registers, or it runs every one. The shell tests type a line only once the line editor reads raw keys, canonical mode off: on CI, a line typed before PowerShell's first read was echoed by the terminal and never run. Every job installs the toolchain `rust-toolchain.toml` names with `rustup toolchain install --no-self-update` and never runs `rustup default`, so the owner's machines keep their own default toolchain and rustup; the macOS job puts the host's `~/.cargo/bin` on the runner's PATH, and the Linux container installs rustup first. A toolchain file's components install only with the toolchain: one already there without them makes each cargo call try to download them, so `scripts/linux.sh` and `scripts/linux-tar.sh` add them to their images.
+- 2026-10-15: CI ran on self-hosted Gitea runners until v0.1.7, each job with what its runner must hold. macOS runs on the host, with fish and PowerShell installed, or the two shell tests fail as they should. Windows runs on the host, with rustup's `cargo` and `rustc` proxies beside `rustup` and Visual Studio's C++ tools. Ubuntu (`ubuntu-24.04`) runs as root in `docker.gitea.com/runner-images:ubuntu-24.04`, installs the libraries gpui links, and runs the tests as a user it makes, since root ignores the file modes they check; its runner serves this repository alone, in a VM of its own, so a build cannot starve other containers. The Linux and Windows jobs build without debuginfo, as `scripts/linux.sh` does: with it, linking gpui's test binaries outgrew that VM's 8 GB. The macOS and Windows jobs run on the owner's own machines, so they skip `Swatinem/rust-cache`: its post step cleans `$CARGO_HOME`, which there is the owner's own, and after every job it deleted `rustup` from `~/.cargo/bin`, leaving its proxies pointing at nothing, and pruned the shared registry; the Linux job keeps it, inside its container. A run that waits on a missing runner stays queued: cancel stale ones before a new runner registers, or it runs every one. The shell tests type a line only once the line editor reads raw keys, canonical mode off: on CI, a line typed before PowerShell's first read was echoed by the terminal and never run. Every job installs the toolchain `rust-toolchain.toml` names with `rustup toolchain install --no-self-update` and never runs `rustup default`, so the owner's machines keep their own default toolchain and rustup; the macOS job puts the host's `~/.cargo/bin` on the runner's PATH, and the Linux container installs rustup first. A toolchain file's components install only with the toolchain: one already there without them makes each cargo call try to download them, so `scripts/linux.sh` and `scripts/linux-tar.sh` add them to their images.
 - 2026-10-15: on macOS 27 gpui's `Blurred` gives its NSVisualEffectView the `Selection` material, which builds no backdrop layer, so the desktop showed through sharp. `blur/macos` sets the view to `underWindowBackground` whenever the window turns Blurred: a gaussian blur of radius 30, the radius the owner's Ghostty uses; gpui's `updateLayer` still strips the material's tint and saturation. The view's presence proved nothing, so `shot` reads the radius off its backdrop layer.
 - 2026-10-15: the icon is drawn by hand in SVG, flat, so one figure serves both forms: on macOS it stands on a night-purple rounded square on Apple's grid (824 of 1024, radius 185) with sparkles, the gradient grained so it does not band; on Windows and Linux it stands alone, as Papirus draws app icons. The app is `com.zacharyzhang.elyterminal`, after the owner's domain. A local build is signed ad hoc: it opens on the Mac that built it, and Gatekeeper asks once on any other; a release's is signed with the owner's Developer ID and notarized, so it opens on any Mac.
-- 2026-10-15: a release is a Gitea release tagged `vVERSION` with three builds, each from its script: the macOS disk image for Apple silicon, a Windows zip and a Linux tarball for x86_64. Each window names itself `com.zacharyzhang.elyterminal` through `Window::set_app_id` as it opens: on Linux that is Wayland's app id and X11's `WM_CLASS`, which the desktop entry's name and `StartupWMClass` match, so a dock pairs the window with the icon; gpui's X11 windows read no app id from `WindowOptions`.
+- 2026-10-15: a release is a GitHub release tagged `vVERSION` with three builds, each from its script: the macOS disk image for Apple silicon, a Windows zip and a Linux tarball for x86_64. Each window names itself `com.zacharyzhang.elyterminal` through `Window::set_app_id` as it opens: on Linux that is Wayland's app id and X11's `WM_CLASS`, which the desktop entry's name and `StartupWMClass` match, so a dock pairs the window with the icon; gpui's X11 windows read no app id from `WindowOptions`.
 - 2026-10-15: on Windows a release build is a GUI program, so no console window opens beside it; a debug build keeps its console for the log. git then starts with `CREATE_NO_WINDOW`, or each call would open a console. Windows builds link the C runtime statically, so the executable needs no Visual C++ redistributable. gpui's build script embeds its manifest, PerMonitorV2 DPI awareness among it; `build.rs` adds the icon as resource 1, which gpui loads for each window, and stops the build when no resource compiler is found.
 - 2026-10-15: the Linux tarball builds on Debian 12, in `rust:1.95.0-bookworm`: a binary asks for the glibc symbol versions it was linked against, so it is linked against an old glibc, not the builder's. `scripts/linux-tar.sh` prints the glibc its build asks for, and the README names it: 2.35 for v0.1.0, which runs on Ubuntu 22.04.
 - 2026-10-15: on Windows gpui answers the system's hit test from the last frame: under the pointer, a `WindowControlArea::Drag` hitbox that nothing occludes makes it the caption, and Windows keeps the press, so no click reaches the app. In v0.1.0 every title bar control was dead so. Ely now occludes the drag region under its window buttons, which then answer as close, maximize and minimize, and under each column header's item row, whose controls get plain presses; the row stays the scroll container, and its title is a drag region of its own.
@@ -100,7 +101,7 @@ ELYTerminal. A terminal on GPUI and Ely components. `PRD.md` says what it does;
 - 2026-10-16: the main window opens at the size it was left at, which the owner asked for on macOS, Windows and Linux: `window_width` and `window_height` in the settings hold the size gpui's `window_bounds` gives 0.5 s after the bounds settle, saved through `SettingsStore::update`, which writes only a change, so a drag saves once and a move saves nothing. A maximized, full-screen or hidden window keeps the size from before; its state and size are read once they settle, since X11 marks a window maximized after its new size, gpui's X11 window then gives a maximized window's own size, and it calls a maximized window unmaximized while minimized. A window that shows again, uncovered, restored or back on its screen, is read again, so a size it took just before it hid is kept; a size it takes in the half second before it closes, or before it hides until the app quits, is lost. The window is no smaller than 100 by 100, the least the settings keep, or a smaller size the platform allows could not be kept. The window opens centered at whole points, since macOS grows a window by a point on a side whose edge falls on a half point; its place is not kept, and a kept side past the primary display's visible area shrinks to it, logged. A size outside 100 to 16384 stops the start, as any value out of range does.
 - 2026-10-16: the sessions and right columns resize by a drag on their border toward the terminal, which the owner asked for on macOS, Windows and Linux. Ely's `ShellColumn::resizable`, added to Ely for this, puts Ely's `resize_handle` on the border toward the filling column, the sessions column's right and the right column's left: the handle draws that border, a filled hairline, since gpui paints a border no wider than half its box, and the line it drew at first showed half a pixel on macOS and none on X11; it occludes the header under it, so a press there drags the border, not the window, on Windows too, where an unoccluded drag region takes the press as the caption. A drag sets off from the wider of the width drawn and the one kept: a header's parts may hold a column wider, and a window too narrow for both widths squeezes them, where a drag from the squeezed width jumped back against the pointer; a drag that has not moved sideways changes nothing, and one that comes back where it set off gives the width it had. A set width in Ely became a flex basis, so a column holds its header's own parts: at a set width under them, Windows' caption buttons ran out of the window. The widths, 160 to 960 pixels, show at once and are saved in `sessions_width` and `panel_width` through `SettingsStore::update` 0.5 s after a drag rests, as the window's size is; a drag in the half second before the window closes is lost, and a save the store refuses puts the columns back. A window too narrow for both yields the terminal its header's width, as Ely's set widths give way.
 - 2026-10-16: prompts and commands carry OSC 133 marks, which the owner asked for, read as Ghostty reads them: A or N starts a prompt, B or I ends it, C starts a command's output, and D ends the command with its status, D's first option, none when that is no number. The tap reads any program's marks before the parser, so it never sees the cursor: A's fresh line and L, which need it, are not done, and P adds nothing to A. Each session keeps the status its last command ended with. The integration marks what the shell leaves unmarked, and the user's prompt still sees the command's status. zsh: precmd reads `$?` and sends D after a command ran, preexec sends C, and a last precmd hook wraps PS1 in A and B under `prompt_percent`, which the first prompt says while it is off; it moves to the end of `precmd_functions` at each prompt, since a theme that sets PS1 in a hook of its own loads after it, and at the first prompt `sched +0` wraps it once more, since zsh runs due events after every precmd hook; that call returns the command's status, which the prompt shows, but it would reset `$pipestatus`, so it serves the first prompt alone. bash: PROMPT_COMMAND's first entry reads `$?`, which each entry resets, and its last wraps PS1. From bash 4.4 PS0 sends C and its subscript notes that a command ran, since bash prints no PS0 for an empty line, and the first entry sends D for it; both need `promptvars`, on by default. macOS's bash 3.2 has no PS0 and nothing else between reading a line and running it: its DEBUG trap runs for a key binding's command (`bind -x`) as for a typed one, with nothing to tell the two apart, runs for no line that is only a subshell, and under `extdebug` its status decides whether a command runs. So bash 3.2 sends no C, and Ghostty's automatic integration skips bash 3.2. Its D comes from PS1 once `\#`, the command number, has moved, which neither a key binding nor an empty line does; readline sends a prompt's escapes again at each redraw, so that D goes again with it, the same status. Every mark of a command rides an expansion, which `promptvars` turns on, so while it is off at start the script says so rather than mark nothing without a word. fish 4.3 marks its own prompts and commands, fish 4.0 all but B, older ones none: the script adds what the running fish lacks, around the prompt shown, and wraps it again when the user's changes. PowerShell: the prompt reads `$?` first and sets it back for the user's prompt through `Write-Error '' -ErrorAction Ignore`, which adds nothing to `$Error`. A failure ends with `$LASTEXITCODE` when a program set it during the line, since each run stores a new object, equal or not, which `[object]::ReferenceEquals` tells apart, unless the line surely ends in PowerShell: its syntax tree, read as PSReadLine hands the line over, ends in a cmdlet, as `Get-Command` resolves the name, aliases through, in a name not found, or in no command; such a line ends with 1, a cmdlet's failure under `-ErrorAction Ignore` too. A line that ends in a block, a function, a script or a call through a variable takes the code of a program it ran: only a hook on every command lookup would name the last command run, and it slowed a loop of commands by half. `$LASTEXITCODE` is read through `Get-Variable`, since strict mode refuses an unset variable and a prompt that fails falls back to `PS>`. C goes out when PSReadLine hands over a line that is not blank; without PSReadLine the script says it marks no command. herdr passes no OSC 133 on, so a session running herdr keeps the status from before it.
-- 2026-10-16: the view jumps between prompts, which the owner asked for, as Ghostty jumps: Cmd-Up and Cmd-Down, with Shift or without, on macOS, Ctrl-Shift-Up and Ctrl-Shift-Down elsewhere, scroll to the prompt that starts before or after the view's top; a prompt on the screen's last page means the bottom, which the view cannot pass, and with none there nothing moves. alacritty's rows hold no marks, and the tap, which reads before the parser, never sees the cursor, so the tap rewrites what goes to the parser: an OSC that may be a mark is held whole until it ends and read as `marks` reads it, and a prompt's start becomes an OSC 8 link of the terminal's own, its target `\x7f`, which no program names, its id `\x7f` and the prompt's number; the prompt's end closes it. The parser stamps each cell the prompt prints with the link, SGR 0 keeps it, and it rides the cells through scroll, reflow and history; a prompt starts on the first row that shows its number, blank rows within it passed. A program's own link keeps its target and takes the prompt's number in its id: one opened inside a prompt carries it, and a prompt that starts inside one opens it again with the number and gives back its own id at the prompt's end, its target kept whole as the scanner keeps it; its end inside a prompt takes the prompt's link up again. A cursor restore that brings back a link passes the rewrite by. An OSC held, a body of 4096 bytes at most as the scanner keeps it and twice that with the controls vte skips, shows nothing until it ends; controls vte runs inside an escape go on before an ESC that waits, and only an ESC from ground waits: one that ends an OSC goes on with it, so what follows runs where the parser stands. A rewrite turns a mark of 8 bytes inside a program's link into that link again, its target up to 4096 bytes, so the tap reads about 2 KB of the buffer's room at a time, which moved 3 MB through a pty as fast as larger reads. Links, Cmd-press among them, pass over the prompt's link. The tap's OSC scanner ends a body as vte does, at BEL, ESC, CAN or SUB, and skips the controls vte skips, so a mark and its link agree.
+- 2026-10-16: the view jumps between prompts, which the owner asked for, as Ghostty jumps: Cmd-Up and Cmd-Down, with Shift or without, on macOS, Ctrl-Shift-Up and Ctrl-Shift-Down elsewhere, scroll to the prompt that starts before or after the view's top; a prompt on the screen's last page means the bottom, which the view cannot pass, and with none there nothing moves. alacritty's rows hold no marks, and the tap, which reads before the parser, never sees the cursor, so the tap rewrites what goes to the parser: an OSC that may be a mark is held whole until it ends and read as `marks` reads it, and a prompt's start becomes an OSC 8 link of the terminal's own, its target `\x7f`, which no program names, its id `\x7f` and the prompt's number; the prompt's end, B, opens a link of the same target over the line typed after it, its id `\x7f`, the commands ended so far, C or D each one, and `i`, so every prompt a shell draws again on one line, as fish draws its right prompt at each key, shares its input's number; C or D closes it. macOS's bash 3.2, which sends no C, stamps a command's output as input until its D. The parser stamps each cell the prompt prints with the link, SGR 0 keeps it, and it rides the cells through scroll, reflow and history; a prompt starts on the first row that shows its number, blank rows within it passed. A program's own link keeps its target and takes the prompt's number in its id: one opened inside a prompt carries it, and a prompt that starts inside one opens it again with the number and gives back its own id at the prompt's end, its target kept whole as the scanner keeps it; its end inside a prompt takes the prompt's link up again. A cursor restore that brings back a link passes the rewrite by. An OSC held, a body of 4096 bytes at most as the scanner keeps it and twice that with the controls vte skips, shows nothing until it ends; controls vte runs inside an escape go on before an ESC that waits, and only an ESC from ground waits: one that ends an OSC goes on with it, so what follows runs where the parser stands. A rewrite turns a mark of 8 bytes inside a program's link into that link again, its target up to 4096 bytes, so the tap reads about 2 KB of the buffer's room at a time, which moved 3 MB through a pty as fast as larger reads. Links, Cmd-press among them, pass over the prompt's link. The tap's OSC scanner ends a body as vte does, at BEL, ESC, CAN or SUB, and skips the controls vte skips, so a mark and its link agree.
 - 2026-10-17: programs say what they are doing through OSC 7501, revision 0.4 of the Program Status Protocol, which the owner asked for, read as the spec reads it: pairs `key=value` joined by `:`, a malformed pair skipped, an unknown key passed by, and every pair of a known key checked, a clear's too, before the last of each key is kept. A sequence over 4096 bytes, counted from OSC through ST with the controls its body skips, a key over 16, an app over 32, an id outside its grammar or limits (128 bytes, 32 a segment, 8 levels), a title or msg over its limits, not base64, not UTF-8 or holding a control character, and a missing or unknown state each drop it whole; kind counts only with blocked, and progress, 0 to 100, only with working and blocked, each absent when unknown. Each terminal keeps its records by id, the root's empty: a report replaces its record whole, clear drops the record and those under it, or all without an id, and past 256 the record updated longest ago goes. A new prompt drops working, blocked and idle records, as kitty does, and keeps done and error; a full reset, which the tap's scanner sees as `ESC c`, through the controls, DEL and high bytes vte passes by in an escape, drops all, and DECSTR nothing. The query `OSC 7501 ; ?` is answered with every state and kind; the view writes the answer when the session hears the query, ahead of the parser's answers to what came later in the same read, so a DA1 sent after the query, as the spec suggests, comes back second, and one sent before it in the same read comes back after it.
 - 2026-10-17: programs ask for notifications through OSC 9, 777 and 99 and report progress through OSC 9;4, which the owner asked for. OSC 9 is ConEmu's command where Ghostty reads one, 9;1 to 9;12 each by its own shape, else iTerm2's notification, its text the title; OSC 777 is rxvt's `notify;title;body`, another extension logged and passed by. OSC 99 is kitty's: `k=v` pairs before the payload, a malformed pair passed by; `i`, of `[A-Za-z0-9_-+.]` alone or the sequence drops, gathers chunks while `d=0`, 32 notifications and 16384 bytes of text at most; a payload holds 2048 bytes plain or 4096 encoded at most; plain text is UTF-8 without a control character; `e=1` reads it as base64 group by group, so chunks split before encoding or after join, and it carries any UTF-8, newlines too, checked once the text is whole; a chunk that breaks a rule drops what its notification gathered; metadata holds 1024 bytes at most, and the tap keeps an OSC 99 body to 5124 bytes, room for metadata and a full payload, where other bodies stop at 4096; `p` takes title, body, close, ? and alive, and other payloads pass by; `a`, `c` and `w` are kept for posting, and `o` passes by; a lone body is the title, and one with neither passes by. The query and alive are answered as the notifications below say; an answer names the asker's id, or 0. OSC 9;4's states, remove, set, error, indeterminate and pause, read as Ghostty reads them, the progress clamped to 100, stand as the root record: set and pause working with their progress, indeterminate working without, error an error, remove none; this lasts until a program reports through OSC 7501, and again after a full reset, as the spec asks, so a mapped 9;4 never wipes a real report. The terminal posts the notifications, as below.
 - 2026-10-17: inside herdr, which passes no OSC 7501 on, herdr's agents are the session's records. The snapshot the follower asks for lists them; one in a state herdr knows, idle, working, blocked or done, is the record `herdr:PANE`, whose colon no OSC 7501 id holds, so a program's record of a name like it, `herdr/build` among them, stays its own; unknown and any state herdr adds later pass by. herdr names no kind and no progress; the app is the agent, the title its name, else the name herdr shows for it, and the message its terminal title less the spinner herdr strips, else the title its metadata sets; herdr's done is idle and not yet seen. A snapshot that lists other agents replaces them whole, so a full reset or a clear that dropped them sees them back at the next; they go when herdr leaves the foreground, and a snapshot that lands after the shell reported a folder is dropped, its agents with it. A change of their states is logged; a herdr whose snapshot lacks `agents` lists none.
@@ -114,3 +115,11 @@ ELYTerminal. A terminal on GPUI and Ely components. `PRD.md` says what it does;
 - 2026-10-19: a drag moves Ely along the edge she stands on, which the owner asked for after 0.1.5. On macOS, Windows and X11 her glue moves her window after the pointer's place on the screen, `NSEvent`'s `mouseLocation`, `GetCursorPos` and `query_pointer`, since her window moves under the pointer, so a place in it would lag; her window keeps the pointer while the button is held, inside it or not, as AppKit, gpui's `SetCapture` and X's implicit grab give it. A Wayland popup cannot move, so there she moves once let go: the settings keep the place, and the twice-a-second check opens her popup there. She moves by whole points inside the pane, and `ely_left` keeps where she stands, 140 by default, where she stood before; a narrower pane holds her at its right end, and the log names where she is let go. Under Xorg's dummy screen xdotool dragged her 200 pixels and her window followed them; under Sway nested in Xorg, whose X input gives its seat a pointer, xdotool's drag reopened her popup 200 points on. Sway's own `seat cursor` commands send no motion while their press is held, and Sway draws no popup opened before its window settled, so a probe there reopens her before it drags.
 - 2026-10-19: Settings › Terminal checks for updates, which the owner asked for after 0.1.5: under Ely, a switch, on by default, checks at start and once a day, and Check now checks at once. The check runs `curl`, as git runs through its command line, so no HTTP or TLS crate joins the build; macOS and Windows 10 ship it, and a missing curl shows as a failed check. It asks Gitea's API for the latest published release, compares its tag's three numbers with the running version, and the row says what it found; a newer one brings Download, which opens the release's page in the browser, since replacing a running, signed app is a job of its own. An automatic check that finds one posts a system notification, at most once a day, whose press opens the page. Checks run off the main thread, one at a time, each start and finding logged; a failure shows its error in the row. Under Xorg's dummy screen the start's check found 0.1.5 the latest, Check now and the switch checked again, and a build named 0.1.4 showed 0.1.5 out with Download, which opened its page.
 - 2026-10-19: the terminal shows a scrollbar, which a user asked for in issue #2 after 0.1.5: a program that tracks the mouse takes the wheel, so the wheel alone could not reach the history. A thumb rides the view's right edge, over the padding, in Ely's scrollbar sizes and colors, its thickness, its least length and the foreground at 22 and 42 percent; its length is the screen's share of the history, and its place where the view stands. A drag moves the view through the history, whatever mouse mode the program asked for; the bar covers the grid's hitbox, so the terminal sees none of its presses, and a release with no press of its own reports nothing. Ely's `Scrollbar` reads a gpui `ScrollHandle`, and the terminal's place is alacritty's display offset, so the bar is the terminal's own, drawn as Ely draws hers and dragged through gpui's drag as hers is; gpui sets a drag's anchor at its first move past the threshold, so a pointer that jumps far at once loses that jump. The alternate screen holds no history, so it shows none. Under Xorg's dummy screen, 500 lines in, a drag to the top showed the first prompt and lines 1 to 39, and with mouse tracking on, which sent the wheel to the program, the bar still scrolled.
+- 2026-10-19: a plain click on the line the shell reads moves its cursor there, which a user asked for after 0.1.6, as Ghostty's `cursor-click-to-move`: a press with no modifier, one click, let go in its own cell with no selection, while OSC 133 says the shell reads a line, B since the last A or C, and the program tracks no mouse at the release. A shell whose prompt start says `click_events=1` or `2`, as fish from 4.1 says on its own, hears a click past the prompt's last cell before the cursor, or, where no prompt cell of its own line comes before the input, as under fish's empty prompt, from the first cell of the newest line typed, known by its number, not its place, since a prompt drawn at the screen's top leaves older lines below it, down to that line's last row or the cursor's, and never on a prompt cell, itself, a left press in SGR, its row the screen's or counted from the prompt's first, as kitty and Ghostty send it, and moves its own cursor, combining marks and its own redraws included: fish moves by code point, and its redraws drop the wrap flags a count would follow. Any other shell gets Left or Right arrows, one per cell, each pressed and let go as the keyboard would, through the key encoder, so DECCKM, kitty's flags and win32-input-mode shape them; the count runs only on the cursor's line, soft wraps joined, past the prompt's cells, which the prompt's link marks, so bash 3.2, which sends no C, moves nothing once its command left the prompt's line. Cells after the last character typed count only up to the cursor, so a click past the end goes to the end; a wide character takes one arrow. Never on the alternate screen. One line only, as Ghostty's `cl=line`. A right prompt or an autosuggestion past the typed text counts as text, as in Ghostty, so a click on it may take the suggestion. The first click of a double click moves the cursor before the word selects, as in Ghostty.
+- 2026-10-19: files dropped on the terminal type their paths, which a user asked for after 0.1.6, as macOS Terminal does: each path followed by a space, the paths of one drop in its order, sent as a paste, bracketed when the program asked, and kept literal for the shell the session started, which its name says, as the integration reads it: for sh, bash, zsh, fish and any other, each character Ghostty escapes gets a backslash, and `^` and `~` too, which zsh's `extendedglob` reads; for pwsh and powershell, the default on Windows, single quotes, each single quote inside doubled, PowerShell's curly ones too, since PowerShell reads a backslash as a plain character and expands `$` inside double quotes; for cmd, double quotes, which keep `&`, `|`, `<`, `>` and `^` inert, the backslashes ending a path doubled, since a program's parser reads `\"` as a quote, as `C:\` ends, and a path holding `%`, or `!`, which cmd expands inside them under `/v:on`, stops the drop. Windows Terminal's quotes around a path with a space alone leave `$(...)` and `;` live in PowerShell. A program run inside the session, `cmd` under PowerShell among them, gets the session's own quoting. A path not in UTF-8, or holding a control character, which would act as it is typed, stops the drop, logged. gpui hands a drop to the hitbox under the pointer only while the last input was not the keyboard, and a file drag counts as no input of its own: after typing, a drop with no pointer move over the window since does nothing, and nothing in ELYTerminal sees it, which the owner chose to leave so. `shot`'s `drop@x,y` plays a drop through `Window::dispatch_event`, so AppKit's drag session itself goes untested.
+- 2026-10-19: fallback fonts, which a user asked for after 0.1.6, since the Chinese and Latin fonts people like seldom come as one: `font_fallbacks` in the settings lists installed families, tried in order for a character Font family lacks, through gpui's `Font::fallbacks`, which CoreText's cascade list, DirectWrite's fallback builder and cosmic-text's chain each honor; the system's own fallback follows the last. On Linux gpui's cosmic-text path keeps the fallback the last character took while it covers the next, so shaping clusters stay whole: with two fallbacks, a character only the second covers carries the next one, which the first covers too, into the second; macOS and Windows choose per character. The owner chose to leave that so. Each family must load as the terminal draws it, as Font family must, so a family gpui would pass over without a word stops the start or the save, the error naming `font_fallbacks`; an empty name is refused. The field is new beside `font_family`, so a settings file from before loads as it was. Settings › Appearance lists them under Family: each an Ely `FontPicker` whose pick replaces it and a button that removes it, then Add fallback, which opens an empty picker whose pick adds one, its button closing it; a refused pick shows the saved family again, as Family's does. Each row keeps an input of its own, and a removal drops the removed row's input and takes the focus away, since Ely's combobox keeps a focused input's text, and an input kept by place would show, and on Enter save, the family removed. Each picker's id is its input's entity, not its place: Ely's combobox keeps its state by id and listens to the input it first met, so a picker keyed by place, after a removal moved the inputs, wrote another row's family into its new input at the next blur. Ligatures and the bundled Nerd Font for private-use icons stand as before; the cursor preview keeps the family alone.
+- 2026-10-19: a user found the IME's candidate box jumping on Windows after 0.1.6. gpui places it, through `ImmSetCompositionWindow` and `ImmSetCandidateWindow`, only when a composition starts, at the caret the terminal reports, the grid cursor's cell from the last frame, hidden or not. On the owner's PC, WeType under powershell.exe and under a status line redrawn every 100 ms put the box at the caret in 23 compositions out of 23, so the owner closed it unreproduced. The terminal logs each caret the input method asks for, at debug, and each move of the caret, at trace, so the next report carries where the box was told to go.
+- 2026-10-19: Ely's shirt and back hair run on below the edge she holds, which a user asked for after 0.1.6, where a hop lifted her whole figure off the window and showed a gap under her collar and hands: both continue down to 340 in the icon's units, 54 below the edge at 286, past her highest lift, a hop of 31 with a press's 0.6 of one on it, so a hop shows more of her and never the gap; at rest the part below the edge lies outside her window and does not show. The shirt moves with her body, the hair with her head, as before; the hair behind her hands fills under them as she lifts.
+- 2026-10-19: a double press on a session's row renames it, which a user asked for after 0.1.6. Ely's `ListItem::editor`, added to Ely for this, draws Ely's text field in the title's place; the row's first press selects the session, as ever, and its second opens the field, holding what the session is called, selected, with the focus. Enter keeps what it holds, Escape drops it, and a blur keeps it, as Windows Terminal's tab rename does; whenever the field closes while it still holds the window's focus, the shown terminal takes it, and a press that took the focus elsewhere keeps it there. A window that goes inactive blurs the field and keeps its focus there, so a field closed by that blur, focus handed to nothing, left the terminal deaf to keys once the window came back. A press inside the open field stays the field's: the row would select its session, which takes the focus to the terminal and ends the rename. The name, its ends trimmed, stands over the program's title in the row, the terminal's header and the window's title until renamed again, a program's later titles passing under it; an empty one gives the title back to the program. It lives as long as the session, and notifications keep the program's title. Each program title, each rename and its end are logged.
+- 2026-10-19: on Windows 10 a blurred window's acrylic clears while the window moves or sizes, which a user asked for in issue #3 after 0.1.5, where dragging the window trailed the pointer by seconds: that DWM samples the acrylic again at each step of the move loop, while gpui draws through it every 10 ms, so the moves pile up; Windows 11's DWM does not, and keeps its acrylic. At start `RtlGetVersion` reads the build; below 22000 the main window's procedure is ELYTerminal's own, passing every message on to gpui's: at `WM_ENTERSIZEMOVE` a blurred window takes the accent gpui gives Transparent, a clear gradient, and at `WM_EXITSIZEMOVE` gpui's acrylic again, `SWP_FRAMECHANGED` telling DWM, both through `SetWindowCompositionAttribute` as gpui calls it. A window property marks the window blurred, set as the blur setting changes, so an opaque or clear window moves as it is; another marks it moving, from `WM_ENTERSIZEMOVE`, which Windows sends once, to `WM_EXITSIZEMOVE`, so a window blurred mid-move, which gpui gives acrylic at once, takes the clear accent again until the move ends. The log names which way the build goes and each switch. On Windows 11, with the build check raised, a drag by the terminal's header logged both switches and showed the glass clear mid-drag and blurred at rest; Windows 10 itself went untested, the fix following the issue's own trial.
+- 2026-10-20: the repo moved from Gitea to GitHub, `ELY-Open-Source/ELYTerminal`, public, at the owner's ask: history, tags v0.1.0 to v0.1.6 and their releases with every build came along. CI runs macOS on the org's self-hosted `macos-arm64` runner, Windows on `ely-windows`, and Linux on GitHub's hosted `ubuntu-24.04` inside the Gitea job's own image, `docker.gitea.com/runner-images:ubuntu-24.04`, testing as a user it makes: on the hosted image itself zsh's `compinit` stopped at insecure folders and fish's prompt tripped over its hg. Release runs on `macos-signing` and needs the repo secrets `APPLE_API_ISSUER`, `APPLE_API_KEY_ID` and `APPLE_API_KEY_P8`. The update check reads GitHub's `releases/latest`, which skips drafts and prereleases.

Cargo.lock

@@ -1701,7 +1701,7 @@ checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"
 [[package]]
 name = "ely-gpui-component"
 version = "0.1.1"
-source = "git+https://git.zacharyzhang.com/ZacharyZhang-NY/Ely-GPUI-Components.git?rev=da3fdcaf39f2fa85ce1dd9cad07c3c81cf1dd721#da3fdcaf39f2fa85ce1dd9cad07c3c81cf1dd721"
+source = "git+https://github.com/ELY-Open-Source/Ely-GPUI-Components.git?rev=7f7a715d797d8450eed4f17ae8002b5427d01d28#7f7a715d797d8450eed4f17ae8002b5427d01d28"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -1747,7 +1747,7 @@ dependencies = [
 
 [[package]]
 name = "elyterminal"
-version = "0.1.6"
+version = "0.1.7"
 dependencies = [
  "alacritty_terminal",
  "anyhow",

Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "elyterminal"
-version = "0.1.6"
+version = "0.1.7"
 edition = "2024"
 rust-version = "1.95"
 license = "MIT"
 description = "A terminal on GPUI and Ely."
-repository = "https://git.zacharyzhang.com/ZacharyZhang-NY/ELYTerminal"
+repository = "https://github.com/ELY-Open-Source/ELYTerminal"
 publish = false
 
 [dependencies]
@@ -13,7 +13,7 @@ alacritty_terminal = { version = "=0.26.0", default-features = false }
 anyhow = "1"
 base64 = "0.22"
 dirs = "7"
-ely-gpui-component = { git = "https://git.zacharyzhang.com/ZacharyZhang-NY/Ely-GPUI-Components.git", rev = "da3fdcaf39f2fa85ce1dd9cad07c3c81cf1dd721" }
+ely-gpui-component = { git = "https://github.com/ELY-Open-Source/Ely-GPUI-Components.git", rev = "7f7a715d797d8450eed4f17ae8002b5427d01d28" }
 env_logger = "0.11"
 futures = "0.3"
 gethostname = "1.1.0"
@@ -61,7 +61,7 @@ image = { version = "0.25", default-features = false, features = ["png"] }
 [target.'cfg(windows)'.dependencies]
 raw-window-handle = "0.6"
 sysinfo = { version = "0.39", default-features = false, features = ["system"] }
-windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Graphics_Gdi", "Win32_Storage_FileSystem", "Win32_System_Console", "Win32_System_Diagnostics_ToolHelp", "Win32_System_Pipes", "Win32_UI_HiDpi", "Win32_UI_Input_KeyboardAndMouse", "Win32_UI_WindowsAndMessaging"] }
+windows-sys = { version = "0.61", features = ["Wdk_System_SystemServices", "Win32_Foundation", "Win32_Graphics_Gdi", "Win32_Storage_FileSystem", "Win32_System_Console", "Win32_System_Diagnostics_ToolHelp", "Win32_System_LibraryLoader", "Win32_System_Pipes", "Win32_System_SystemInformation", "Win32_UI_HiDpi", "Win32_UI_Input_KeyboardAndMouse", "Win32_UI_WindowsAndMessaging"] }
 
 [target.'cfg(windows)'.dev-dependencies]
 windows-sys = { version = "0.61", features = ["Win32_Security", "Win32_System_IO"] }

PRD.md

@@ -16,11 +16,11 @@ Chapters run in build order. `TASKS.md` follows them line by line.
 ## 2. Foundation
 
 - One binary crate, `elyterminal`, edition 2024, Rust 1.95.
-- Ely from git.zacharyzhang.com by pinned rev. gpui, gpui_platform from crates.io `gpui-pre` at the exact version Ely pins.
+- Ely from github.com/ELY-Open-Source by pinned rev. gpui, gpui_platform from crates.io `gpui-pre` at the exact version Ely pins.
 - `alacritty_terminal` 0.26 for the grid, the parser and the pseudo-terminal, as Ely uses it.
 - Logs through `log` to stderr, `RUST_LOG` sets the level. No log setting in the app.
-- CI on Gitea Actions: macOS builds, tests and lints; Ubuntu and Windows build and test.
+- CI on GitHub Actions: macOS builds, tests and lints; Ubuntu and Windows build and test.
-- Repo `ELYTerminal` on git.zacharyzhang.com, private until v0.1.1, public since. No credential in any file or commit.
+- Repo `ELY-Open-Source/ELYTerminal` on GitHub, public; it lived on git.zacharyzhang.com until v0.1.7. No credential in any file or commit.
 
 ## 3. Settings model and storage
 
@@ -52,12 +52,14 @@ Ghostty is the bar for what the terminal does. ELYTerminal owns its engine on `a
 - Inside herdr, which passes no OSC 7501 on, herdr's agent states (idle, working, blocked, done) are the session's status records.
 - Grid: colors (named, 256, truecolor, OSC 4/10/11/12), bold, dim, italic, underline (single, double, curly, dotted, dashed), strikethrough, inverse, hidden, wide characters, combining marks.
 - Box drawing (U+2500–U+257F), block elements (U+2580–U+259F) and powerline shapes (U+E0B0–U+E0B7) painted as geometry, so lines and segments join across cells.
-- Fonts: JetBrains Mono by default, any installed font by choice; Nerd Font icons the font lacks come from a bundled Nerd Font.
+- Fonts: JetBrains Mono by default, any installed font by choice, and fallback families tried in order for a character it lacks, a Chinese font after a Latin one among them; Nerd Font icons the font lacks come from a bundled Nerd Font.
 - Cursor: block, bar, underline, hollow block; blinking per setting and per DECSCUSR; hollow when the window is not focused.
 - Keys: xterm encoding with modifiers, application cursor mode, Option as Alt on macOS, the kitty keyboard protocol as the program sets its flags; a key Shift makes a symbol of goes as its own key with Shift, the symbol its alternate, as Ghostty sends it, on macOS and Windows. On Windows keys go as win32-input-mode records while ConPTY asks, as Windows Terminal sends them. Keypad keys type their characters, as Ghostty's do with mode 1035 on by default.
 - IME: marked text drawn at the cursor; committed text sent to the program.
 - Mouse: select by character, word (double press) and line (triple press); Shift extends; mouse reporting (X10, normal, button, any; SGR and UTF-8); wheel scrolls back, or reports, or sends arrows on the alternate screen.
+- Click to move: while the shell reads a line, as its OSC 133 marks say, a plain click on that line, past its prompt, moves the shell's cursor there, as Ghostty's `cursor-click-to-move`: a shell that takes clicks, as fish does, hears the click; others get arrow keys.
 - Clipboard: copy, paste (bracketed when asked), copy on select per setting, OSC 52 writes.
+- Drop: files dropped on the terminal type their paths at the cursor, as macOS Terminal does, each kept literal for the session's shell and followed by a space.
 - Links: OSC 8 and plain URLs; Cmd-press (Ctrl-press off macOS) opens them. Inside herdr, while it takes the mouse, herdr opens them, web links only, as herdr does, whole where its pane wraps them, and underlines them while the key is held; with Shift the terminal opens what it sees.
 - Focus reporting, title (OSC 0/2), scrollback limit per setting, find in scrollback (Ely's `FindWidget`).
 - A scrollbar over the history, along the terminal's right edge: a drag on its thumb scrolls, whatever the program does with the wheel.
@@ -71,7 +73,7 @@ Ghostty is the bar for what the terminal does. ELYTerminal owns its engine on `a
 - The window opens at the size it was left at, on macOS, Windows and Linux: the size is kept in settings once it settles; a maximized or full-screen window keeps the size from before; a kept size past the screen shrinks to it; the window is no smaller than 100 by 100, the least the settings keep.
 - The title shows the active session's title, and no other text.
 - The pointer over the terminal is the arrow.
-- Ely, the icon's girl, peeks over the window's top edge from behind it, on macOS, Windows and Linux; where no room lies above the window, at the screen's top or full screen, she stands inside it at its bottom left. She moves all the time, as she does in the films: she breathes, sways and blinks, and how the sessions are doing, waiting, an error, work, a finish or calm, moves her. Nothing but her shows: no frame, line or shadow around her. A press pets her, and wakes her from a doze. A drag moves her along the edge she stands on, and she stays where she is let go. A switch in Settings, Terminal, turns her off.
+- Ely, the icon's girl, peeks over the window's top edge from behind it, on macOS, Windows and Linux; where no room lies above the window, at the screen's top or full screen, she stands inside it at its bottom left. She moves all the time, as she does in the films: she breathes, sways and blinks, and how the sessions are doing, waiting, an error, work, a finish or calm, moves her. Nothing but her shows: no frame, line or shadow around her. A hop lifts more of her from behind the edge, never her body off it. A press pets her, and wakes her from a doze. A drag moves her along the edge she stands on, and she stays where she is let go. A switch in Settings, Terminal, turns her off.
 - The title bar is transparent, as Ghostty's: the window's background, opacity and blur run under it, so it wears the terminal's color.
 - Every control in the title bar takes its own press on every platform, the window buttons Ely draws on Windows and Linux too.
 
@@ -79,6 +81,7 @@ Ghostty is the bar for what the terminal does. ELYTerminal owns its engine on `a
 
 - A list of sessions. Each row: title, then the working directory, home as `~`.
 - New session (+ and Cmd-T), close (row's ×, Cmd-W), select (press, Cmd-1…9, Ctrl-Tab and Ctrl-Shift-Tab).
+- Rename: a double press on a row's title opens a field in its place; Enter keeps the name, Escape drops it. The name shows in the row, the terminal's header and the window's title over the program's own until renamed again; an empty name gives the title back to the program.
 - A session whose program ends closes its row. The last row closing closes the window.
 - A bell in a hidden session marks its row.
 - A row shows its session's status: working, with its progress where known; waiting on the user, for a permission, a question or a login; done; error; and a mark when the last command failed. Hover shows each record's program, title and message. A hidden session that starts waiting marks its row until it is shown.
@@ -108,7 +111,7 @@ Cmd-, opens it; on Windows and Linux, which have no menu bar, so does a gear in
 - Appearance
   - Theme: a grid of previews; on Omarchy, the Omarchy theme first.
   - Separate dark theme: a switch; when on, a second grid for dark mode.
-  - Font family: a list of installed fonts. Font size. Line height. Ligatures.
+  - Font family: a list of installed fonts. Fallbacks: installed families tried in order for a character the family lacks, each added, changed or removed in a list of pickers. Font size. Line height. Ligatures.
   - Cursor: style (block, bar, underline, hollow), blink, with a live preview.
   - Background opacity: a slider. Background blur: a switch.
   - Padding: horizontal and vertical.
@@ -126,7 +129,7 @@ Cmd-, opens it; on Windows and Linux, which have no menu bar, so does a gear in
 ## 11. Background blur
 
 - macOS: gpui's `WindowBackgroundAppearance::Blurred` (NSVisualEffectView).
-- Windows: gpui's `Blurred` (acrylic accent).
+- Windows: gpui's `Blurred` (acrylic accent). On Windows 10, whose DWM drags an acrylic window seconds behind the pointer, the glass clears while the window moves or sizes and blurs again when it rests; Windows 11 keeps its acrylic throughout.
 - Wayland: gpui's `Blurred` speaks `org_kde_kwin_blur`; ELYTerminal adds `ext_background_effect_v1` on the window's surface, which GNOME 51, Plasma 6.7 and Hyprland support. Hyprland honors it only while its own blur is on, which Omarchy 4.0.4 turns off.
 - X11: ELYTerminal sets `_KDE_NET_WM_BLUR_BEHIND_REGION` (CARDINAL, 32) on the window, as Ghostty does; removes it when blur turns off.
 - A compositor with neither protocol shows transparency without blur. The app logs which path it took.
@@ -150,7 +153,7 @@ Cmd-, opens it; on Windows and Linux, which have no menu bar, so does a gear in
 
 ## 15. Release
 
-- A release on Gitea, tagged `vVERSION`, carries three builds: the macOS disk image (Apple silicon, signed with Developer ID and notarized), a Windows zip (x86_64) and a Linux tarball (x86_64).
+- A release on GitHub, tagged `vVERSION`, carries three builds: the macOS disk image (Apple silicon, signed with Developer ID and notarized), a Windows zip (x86_64) and a Linux tarball (x86_64).
 - The Windows executable carries the icon. The Linux tarball carries the icon and a desktop entry, and the window names itself after it, `com.zacharyzhang.elyterminal`, as the macOS bundle does.
 - Each build comes from its platform's script: `scripts/mac-app.sh`, `scripts/windows-zip.ps1`, `scripts/linux-tar.sh`. The macOS one runs on the signing runner, through the Release workflow.
 

README.md

@@ -4,7 +4,7 @@ A terminal for macOS, Windows and Linux, in Rust on GPUI and Ely components. Ses
 
 ## Install
 
-A release on Gitea carries three builds.
+A [release on GitHub](https://github.com/ELY-Open-Source/ELYTerminal/releases) carries three builds.
 
 - macOS 11 or later, Apple silicon: open `ELYTerminal-VERSION.dmg` and drag ELYTerminal into Applications. The app is signed with Developer ID and notarized.
 - Windows 10 or later, x86_64: unzip `ELYTerminal-VERSION-windows-x86_64.zip` and run `elyterminal.exe`. It is unsigned; if SmartScreen stops it, press More info, then Run anyway.

TASKS.md

@@ -148,4 +148,18 @@ Progress truth. Top to bottom, one at a time. A task is ticked only after its co
 
 ## 31. Release
 
-- [ ] T57 Release v0.1.6 with T55, T56 and T58: version 0.1.6; the macOS disk image, the Windows zip and the Linux tarball, each from its script; the notes list what changed.
+- [x] T57 Release v0.1.6 with T55, T56 and T58: version 0.1.6; the macOS disk image, the Windows zip and the Linux tarball, each from its script; the notes list what changed.
+
+## 32. User feedback after 0.1.6
+
+- [x] T59 A plain click on the line typed at the shell prompt moves the cursor there, which a user asked for after 0.1.6, as Ghostty's `cursor-click-to-move`: while the shell's OSC 133 marks say it reads a line, a click that does not drag sends Left or Right arrows, one per character, to the clicked cell of the cursor's line, soft wraps joined; never on the alternate screen, under mouse tracking, with a selection, or before the prompt's end.
+- [x] T66 Files dropped on the terminal type their paths, which a user asked for after 0.1.6, as macOS Terminal does: each path quoted for the shell, joined by spaces, sent as a paste, on macOS, Windows and Linux.
+- [x] T60 Fallback fonts, which a user asked for after 0.1.6: `font_fallbacks` in the settings, a list of installed families tried in order for a character Font family lacks, CJK among them; Settings › Appearance lists them under Font family, each an Ely `FontPicker` with a remove button, and an Add button; each saves only when gpui loads it.
+- [x] T61 On Windows the IME's candidate window stays at the cursor, which a user found jumping after 0.1.6: find why it moves, fix the cause, and log what the input handler tells the IME. Not reproduced on the owner's PC, so the owner closed it; the caret the IME is told is logged.
+- [x] T62 Ely's body runs on below the edge she holds, which a user asked for after 0.1.6, where a hop lifted her off the window and left a gap under her collar: her shirt continues down, hidden behind the edge, so a hop shows more of her and never a gap.
+- [x] T63 A double-click on a session's title renames it, which a user asked for after 0.1.6: the row's title turns into a field, Enter keeps the name, Escape drops it; the name shows in the row, the terminal's header and the window's title over the program's own until renamed again, and an empty name gives the title back to the program; it lives as long as the session.
+- [x] T65 Dragging the window on Windows 10 with Background blur on follows the pointer, which a user found lagging seconds behind in issue #3 after 0.1.5: find where the lag comes from in gpui's acrylic path, fix the cause on Windows 10 alone, log what changes, and reply on the issue.
+
+## 33. Release
+
+- [ ] T64 Release v0.1.7 with T59 to T63, T65 and T66: version 0.1.7; the macOS disk image, the Windows zip and the Linux tarball, each from its script; the notes list what changed in English and Chinese.

examples/shot/main.rs

@@ -5,7 +5,11 @@ fn main() {
     use std::time::Duration;
 
     use ely_gpui_component::Assets;
-    use elyterminal::{app, settings::window::SettingsWindow, term::Launch};
+    use elyterminal::{
+        app,
+        settings::window::SettingsWindow,
+        term::{Launch, Quote},
+    };
     use gpui::AnyWindowHandle;
 
     env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("elyterminal=info"))
@@ -25,6 +29,7 @@ fn main() {
         cwd: std::env::current_dir().expect("a current folder"),
         env: Vec::new(),
         reports: false,
+        quote: Quote::Posix,
     };
     gpui_platform::application()
         .with_assets(Assets)
@@ -69,6 +74,20 @@ fn main() {
                             aim = settings.expect("a settings window");
                             capture::front(number(aim, cx)).expect("the window on screen");
                         }
+                        spec if spec.starts_with("drop@") => {
+                            let paths =
+                                std::env::var("SHOT_DROP").expect("SHOT_DROP names the paths");
+                            let event = typing::drop(&spec[5..], &paths).expect("a drop");
+                            // A drag moves over frames before it lands.
+                            for step in event {
+                                aim.update(cx, |_, window, cx| window.dispatch_event(step, cx))
+                                    .expect("the window lives");
+                                cx.background_executor()
+                                    .timer(Duration::from_millis(120))
+                                    .await;
+                            }
+                            log::info!("shot: dropped {paths:?} at {}", &spec[5..]);
+                        }
                         spec => typing::post(spec, number(aim, cx)).expect("a key event"),
                     }
                     if spec.starts_with("to:") {

examples/shot/typing.rs

@@ -314,3 +314,20 @@ fn key(spec: &str, number: u32, kinds: &[u64]) -> anyhow::Result<()> {
     log::info!("shot: typed {spec}, the app {state}");
     Ok(())
 }
+
+/// A file drop of `paths`, one a line, at `at`, `x,y` from the content's top-left, as gpui's AppKit view sends it.
+pub fn drop(at: &str, paths: &str) -> anyhow::Result<[gpui::PlatformInput; 4]> {
+    use gpui::{ExternalPaths, FileDropEvent, PlatformInput, point, px};
+    let (x, y) = at
+        .split_once(',')
+        .with_context(|| format!("a point in {at}"))?;
+    let position = point(px(x.parse()?), px(y.parse()?));
+    let paths = ExternalPaths(paths.lines().map(Into::into).collect());
+    Ok([
+        FileDropEvent::Entered { position, paths },
+        FileDropEvent::Pending { position },
+        FileDropEvent::Submit { position },
+        FileDropEvent::Ended,
+    ]
+    .map(PlatformInput::FileDrop))
+}

scripts/release-asset.sh

@@ -1,32 +1,10 @@
 #!/bin/sh
-# release-asset.sh FILE: puts FILE on the Gitea release of this version, a draft too, in place of one of its name.
+# release-asset.sh FILE: puts FILE on the GitHub release of this version, a draft too, in place of one of its name.
 set -eu
 cd "$(dirname "$0")/.."
 file=$1
 [ -f "$file" ] || { echo "release-asset: no file $file" >&2; exit 1; }
-: "${RELEASE_API:?release-asset: RELEASE_API names the repository API, https://HOST/api/v1/repos/OWNER/REPO}"
-: "${RELEASE_TOKEN:?release-asset: RELEASE_TOKEN is a token that may edit the releases}"
 version=$(cargo pkgid)
 version=${version##*[#@]}
-name=$(basename "$file")
+gh release upload "v$version" "$file" --clobber -R ELY-Open-Source/ELYTerminal
-auth="Authorization: token $RELEASE_TOKEN"
+echo "release-asset: $(basename "$file") on release v$version"
-work=$(mktemp -d)
-trap 'rm -rf "$work"' EXIT
-curl -fsS -H "$auth" "$RELEASE_API/releases?limit=50" > "$work/releases.json"
-ids=$(python3 -c '
-import json, sys
-tag, name, path = sys.argv[1:]
-found = [r for r in json.load(open(path)) if r["tag_name"] == tag]
-if len(found) != 1:
-    sys.exit(f"release-asset: {len(found)} releases tagged {tag}")
-print(found[0]["id"], *(a["id"] for a in found[0]["assets"] if a["name"] == name))
-' "v$version" "$name" "$work/releases.json")
-set -- $ids
-release=$1
-shift
-for old in "$@"; do
-  curl -fsS -X DELETE -H "$auth" "$RELEASE_API/releases/$release/assets/$old"
-  echo "release-asset: removed the old $name"
-done
-curl -fsS -H "$auth" -F "attachment=@$file" "$RELEASE_API/releases/$release/assets?name=$name" > /dev/null
-echo "release-asset: $name on release $release, v$version"

src/blur.rs

@@ -6,6 +6,8 @@ use crate::settings::Settings;
 mod macos;
 #[cfg(target_os = "linux")]
 mod wayland;
+#[cfg(windows)]
+mod windows;
 #[cfg(target_os = "linux")]
 mod x11;
 
@@ -27,6 +29,8 @@ pub struct Blur {
     wayland: Option<wayland::Effect>,
     #[cfg(target_os = "linux")]
     x11: Option<x11::Effect>,
+    #[cfg(windows)]
+    moves: Option<windows::Moves>,
 }
 
 impl Blur {
@@ -37,14 +41,23 @@ impl Blur {
         if shown == WindowBackgroundAppearance::Blurred {
             macos::blur(window);
         }
-        #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+        #[cfg(windows)]
-        let _ = window;
+        let moves = windows::Moves::on(window).unwrap_or_else(|error| {
+            log::error!("{error:#}");
+            None
+        });
+        #[cfg(windows)]
+        if let Some(moves) = &moves {
+            moves.blurred(shown == WindowBackgroundAppearance::Blurred);
+        }
         Self {
             shown,
             #[cfg(target_os = "linux")]
             wayland: wayland::Effect::on(window),
             #[cfg(target_os = "linux")]
             x11: x11::Effect::on(window),
+            #[cfg(windows)]
+            moves,
         }
     }
 
@@ -66,6 +79,10 @@ impl Blur {
         if wanted == WindowBackgroundAppearance::Blurred {
             macos::blur(window);
         }
+        #[cfg(windows)]
+        if let Some(moves) = &self.moves {
+            moves.blurred(wanted == WindowBackgroundAppearance::Blurred);
+        }
     }
 
     /// Keeps a Linux compositor's blur on the window's pane while Blurred; each frame, sending only a change.

src/blur/windows.rs

@@ -0,0 +1,187 @@
+//! On Windows 10 a blurred window's acrylic clears while it moves or sizes: that DWM samples the blur again at each step, and the window trails the pointer by seconds.
+
+use std::sync::atomic::{AtomicIsize, Ordering};
+
+use anyhow::{Context as _, bail};
+use gpui::Window;
+use raw_window_handle::{HasWindowHandle, RawWindowHandle};
+use windows_sys::{
+    Wdk::System::SystemServices::RtlGetVersion,
+    Win32::{
+        Foundation::{HWND, LPARAM, LRESULT, WPARAM},
+        System::{
+            LibraryLoader::{GetModuleHandleW, GetProcAddress},
+            SystemInformation::OSVERSIONINFOW,
+        },
+        UI::WindowsAndMessaging::{
+            CallWindowProcW, GWLP_WNDPROC, GetPropW, RemovePropW, SWP_FRAMECHANGED, SWP_NOACTIVATE,
+            SWP_NOMOVE, SWP_NOSIZE, SWP_NOZORDER, SetPropW, SetWindowLongPtrW, SetWindowPos,
+            WM_ENTERSIZEMOVE, WM_EXITSIZEMOVE, WM_NCDESTROY, WNDPROC,
+        },
+    },
+    core::{BOOL, PCWSTR},
+    s, w,
+};
+
+/// Windows 11's first build, whose DWM moves an acrylic window as fast as a clear one.
+const ELEVEN: u32 = 22000;
+
+/// gpui's window procedure, which the main windows' pass every message on to.
+static GPUI: AtomicIsize = AtomicIsize::new(0);
+
+/// A window's property while it is blurred, which its moves read.
+const BLURRED: PCWSTR = w!("ElyTerminalBlurred");
+/// A window's property while it moves or sizes, which a change of its blur reads.
+const MOVING: PCWSTR = w!("ElyTerminalMoving");
+
+/// gpui's accents: acrylic for Blurred, a clear gradient for Transparent.
+const ACRYLIC: u32 = 4;
+const CLEAR: u32 = 2;
+
+/// A main window on Windows 10, whose moves clear its acrylic.
+pub struct Moves {
+    window: HWND,
+}
+
+impl Moves {
+    /// Takes the window's moves on Windows 10; none on 11 and later.
+    pub fn on(window: &Window) -> anyhow::Result<Option<Self>> {
+        let build = build()?;
+        if build >= ELEVEN {
+            log::info!("blur: Windows build {build} moves acrylic as it is");
+            return Ok(None);
+        }
+        let window = native(window)?;
+        let gpui = unsafe { SetWindowLongPtrW(window, GWLP_WNDPROC, moving as *const () as isize) };
+        anyhow::ensure!(gpui != 0, "blur: the window's procedure does not read");
+        let kept = GPUI.swap(gpui, Ordering::Relaxed);
+        anyhow::ensure!(
+            kept == 0 || kept == gpui,
+            "blur: gpui's windows have two procedures"
+        );
+        log::info!("blur: on Windows build {build} acrylic clears while the window moves");
+        Ok(Some(Self { window }))
+    }
+
+    /// Notes whether the window is blurred, as its moves read it; one blurred mid-move stays clear until the move ends.
+    pub fn blurred(&self, on: bool) {
+        if !on {
+            unsafe { RemovePropW(self.window, BLURRED) };
+            return;
+        }
+        if unsafe { SetPropW(self.window, BLURRED, 1 as _) } == 0 {
+            log::error!("blur: the window's blurred mark does not set");
+        }
+        if !unsafe { GetPropW(self.window, MOVING) }.is_null() {
+            match accent(self.window, CLEAR) {
+                Ok(()) => log::debug!("blur: blurred mid-move, the window moves clear"),
+                Err(error) => log::error!("{error:#}"),
+            }
+        }
+    }
+}
+
+/// The window's procedure: a blurred window clears its acrylic while it moves; all else is gpui's.
+unsafe extern "system" fn moving(
+    window: HWND,
+    message: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    let gpui: WNDPROC = unsafe { std::mem::transmute(GPUI.load(Ordering::Relaxed)) };
+    let blurred = !unsafe { GetPropW(window, BLURRED) }.is_null();
+    match message {
+        WM_ENTERSIZEMOVE => {
+            if unsafe { SetPropW(window, MOVING, 1 as _) } == 0 {
+                log::error!("blur: the window's moving mark does not set");
+            }
+            if blurred {
+                match accent(window, CLEAR) {
+                    Ok(()) => log::debug!("blur: the window moves clear"),
+                    Err(error) => log::error!("{error:#}"),
+                }
+            }
+        }
+        WM_EXITSIZEMOVE => {
+            unsafe { RemovePropW(window, MOVING) };
+            if blurred {
+                match accent(window, ACRYLIC) {
+                    Ok(()) => log::debug!("blur: the window rests blurred again"),
+                    Err(error) => log::error!("{error:#}"),
+                }
+                let flags =
+                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED;
+                if unsafe { SetWindowPos(window, std::ptr::null_mut(), 0, 0, 0, 0, flags) } == 0 {
+                    log::error!("blur: DWM hears of no new frame after the move");
+                }
+            }
+        }
+        WM_NCDESTROY => {
+            unsafe { RemovePropW(window, BLURRED) };
+            unsafe { RemovePropW(window, MOVING) };
+        }
+        _ => {}
+    }
+    unsafe { CallWindowProcW(gpui, window, message, wparam, lparam) }
+}
+
+#[repr(C)]
+struct AccentPolicy {
+    state: u32,
+    flags: u32,
+    color: u32,
+    animation: u32,
+}
+
+#[repr(C)]
+struct CompositionData {
+    attribute: u32,
+    data: *mut AccentPolicy,
+    size: usize,
+}
+
+/// Sets the window's accent as gpui's `set_window_composition_attribute` sets it.
+fn accent(window: HWND, state: u32) -> anyhow::Result<()> {
+    type Set = unsafe extern "system" fn(HWND, *mut CompositionData) -> BOOL;
+    let user32 = unsafe { GetModuleHandleW(w!("user32.dll")) };
+    anyhow::ensure!(!user32.is_null(), "blur: user32.dll is not loaded");
+    let found = unsafe { GetProcAddress(user32, s!("SetWindowCompositionAttribute")) }
+        .context("blur: user32.dll has no SetWindowCompositionAttribute")?;
+    let set: Set = unsafe { std::mem::transmute(found) };
+    let acrylic = state == ACRYLIC;
+    let mut policy = AccentPolicy {
+        state,
+        flags: if acrylic { 0 } else { 2 },
+        color: if acrylic { 1 << 24 } else { 0 },
+        animation: 0,
+    };
+    let mut data = CompositionData {
+        attribute: 0x13,
+        data: &mut policy,
+        size: size_of::<AccentPolicy>(),
+    };
+    anyhow::ensure!(
+        unsafe { set(window, &mut data) } != 0,
+        "blur: the window's accent {state} does not set"
+    );
+    Ok(())
+}
+
+/// The running Windows' build.
+fn build() -> anyhow::Result<u32> {
+    let mut version: OSVERSIONINFOW = unsafe { std::mem::zeroed() };
+    version.dwOSVersionInfoSize = size_of::<OSVERSIONINFOW>() as u32;
+    let status = unsafe { RtlGetVersion(&mut version) };
+    anyhow::ensure!(status == 0, "blur: RtlGetVersion fails with {status:#x}");
+    Ok(version.dwBuildNumber)
+}
+
+/// The HWND gpui made for `window`.
+fn native(window: &Window) -> anyhow::Result<HWND> {
+    let handle = HasWindowHandle::window_handle(window)
+        .map_err(|error| anyhow::anyhow!("blur: no native handle: {error:?}"))?;
+    let RawWindowHandle::Win32(win32) = handle.as_raw() else {
+        bail!("blur: not a Win32 window");
+    };
+    Ok(win32.hwnd.get() as HWND)
+}

src/pet/rig.rs

@@ -61,10 +61,10 @@ const fn part(name: &'static str, color: u32, frame: [f32; 4], bone: Bone, shape
 /// Every layer, back to front.
 #[rustfmt::skip]
 const PARTS: &[Part] = &[
-    part("hair-back", 0xEC86B5, [117.0, 45.0, 278.0, 262.0], Bone::Head, r#"<path d="M256 46C192 46 142 90 136 158C131 214 126 262 118 306L394 306C386 262 381 214 376 158C370 90 320 46 256 46Z"/>"#),
+    part("hair-back", 0xEC86B5, [117.0, 45.0, 278.0, 296.0], Bone::Head, r#"<path d="M256 46C192 46 142 90 136 158C131 214 126 262 118 306L118 340L394 340L394 306C386 262 381 214 376 158C370 90 320 46 256 46Z"/>"#),
     part("shade-back", 0xD9659A, [193.0, 199.0, 126.0, 78.0], Bone::Head, r#"<path d="M194 200C198 238 214 262 230 276L282 276C298 262 314 238 318 200Z"/>"#),
     part("neck", 0xF7CDBE, [235.0, 221.0, 42.0, 50.0], Bone::Body, r#"<path d="M236 222L276 222L276 266C268 270 244 270 236 266Z"/>"#),
-    part("collar", 0xFFFFFF, [197.0, 255.0, 118.0, 30.0], Bone::Body, r#"<path d="M198 284C204 268 222 258 238 256L256 272L274 256C290 258 308 268 314 284Z"/>"#),
+    part("collar", 0xFFFFFF, [193.0, 255.0, 126.0, 86.0], Bone::Body, r#"<path d="M198 284C204 268 222 258 238 256L256 272L274 256C290 258 308 268 314 284L318 340L194 340Z"/>"#),
     part("bow", 0xF05A97, [221.0, 247.0, 70.0, 32.0], Bone::Body, r#"<path d="M256 264C244 250 226 248 224 258C222 270 236 278 256 264ZM256 264C268 250 286 248 288 258C290 270 276 278 256 264Z"/>"#),
     part("knot", 0xD94683, [247.0, 255.0, 18.0, 18.0], Bone::Body, r#"<circle cx="256" cy="264" r="8"/>"#),
     part("skin", 0xFFE7DC, [177.0, 93.0, 158.0, 152.0], Bone::Head, concat!(r#"<path d=""#, "M178 164C178 116 212 94 256 94C300 94 334 116 334 164C334 202 312 228 284 238C274 242 264 244 256 244C248 244 238 242 228 238C200 228 178 202 178 164Z", r#""/>"#)),
@@ -270,6 +270,43 @@ mod tests {
         }
     }
 
+    #[test]
+    fn her_shirt_and_hair_run_below_the_edge_at_her_highest_hop() {
+        use super::super::look::{Mood, pose};
+        let moods = [
+            Mood::Calm,
+            Mood::Done,
+            Mood::Working,
+            Mood::Error,
+            Mood::Waiting,
+        ];
+        let mut highest = 0.0_f32;
+        for mood in moods {
+            for held in (0..130).map(|step| f64::from(step) * 0.02) {
+                for petted in [None]
+                    .into_iter()
+                    .chain((0..31).map(|step| Some(f64::from(step) * 0.02)))
+                {
+                    let pose = pose(mood, held, 10.0, petted);
+                    highest = highest.max(pose.lift + pose.bob);
+                }
+            }
+        }
+        assert!(
+            highest > 40.0,
+            "a press inside a hop lifts her {highest} units"
+        );
+        let edge = VIEW[1] + VIEW[3];
+        for name in ["collar", "hair-back"] {
+            let part = PARTS.iter().find(|part| part.name == name).expect(name);
+            let bottom = part.frame[1] + part.frame[3] - highest;
+            assert!(
+                bottom > edge,
+                "{name} ends at {bottom}, above the edge at {edge}"
+            );
+        }
+    }
+
     #[test]
     fn she_is_drawn_from_every_part_the_icon_gives_her() {
         let named = |name: &str| PARTS.iter().any(|part| part.name == name);

src/sessions.rs

@@ -5,6 +5,7 @@ use std::{
 
 use ely_gpui_component::{
     buttons::{ButtonVariant, IconButton},
+    forms::{Input, TextInput},
     lists::ListItem,
     primitives::{Icon, IconName, Tooltip},
     theme::{ActiveTheme, ControlSize, IconSize},
@@ -25,6 +26,10 @@ pub struct Session {
     pub terminal: Entity<TerminalView>,
     /// The program's title; empty while it names none.
     pub title: String,
+    /// The name the user gave it; empty leaves the title to its program.
+    pub name: String,
+    /// The field its row shows while the user renames it.
+    pub editing: Option<(Entity<TextInput>, Subscription)>,
     /// The folder it reports, else the one it started in.
     pub folder: PathBuf,
     /// Its shell has integration, or it reported a folder anyway.
@@ -39,6 +44,14 @@ pub struct Session {
 }
 
 impl Session {
+    /// What it is called: the user's name, else its program's title, else the app's name.
+    pub fn named(&self) -> &str {
+        [self.name.as_str(), self.title.as_str()]
+            .into_iter()
+            .find(|title| !title.is_empty())
+            .unwrap_or(TITLE)
+    }
+
     /// The look its mark takes from its terminal now.
     pub fn looks(&self, cx: &App) -> Option<Look> {
         let view = self.terminal.read(cx);
@@ -103,17 +116,20 @@ pub fn row(
 ) -> ListItem {
     let terminal = session.terminal.read(cx);
     let pid = terminal.pid() as usize;
-    let title = if session.title.is_empty() {
-        TITLE
-    } else {
-        &session.title
-    };
     let (select, close) = (workspace.clone(), workspace.clone());
-    let item = ListItem::new(("session", pid), title.to_string())
+    let editing = session.editing.is_some();
+    let item = ListItem::new(("session", pid), session.named().to_string())
         .description(shown(&session.folder, home))
         .selected(active)
         .strong(session.bell || session.waiting)
-        .on_click(move |_, window, cx| select.update(cx, |this, cx| this.select(index, window, cx)))
+        // A press in the field it renames with stays the field's.
+        .on_click(
+            move |event, window, cx| match (editing, event.click_count()) {
+                (true, _) => {}
+                (false, 2..) => select.update(cx, |this, cx| this.rename(index, window, cx)),
+                (false, _) => select.update(cx, |this, cx| this.select(index, window, cx)),
+            },
+        )
         .trailing(
             IconButton::new(("close-session", pid), IconName::X)
                 .variant(ButtonVariant::Ghost)
@@ -124,6 +140,10 @@ pub fn row(
                     close.update(cx, |this, cx| this.close(index, window, cx))
                 }),
         );
+    let item = match &session.editing {
+        Some((input, _)) => item.editor(editor(workspace, session, input)),
+        None => item,
+    };
     let mark = mark(session, now, cx);
     let bell = session
         .bell
@@ -141,6 +161,23 @@ pub fn row(
     )
 }
 
+/// The field a session's row renames it with; Escape drops what it holds.
+fn editor(
+    workspace: &Entity<Workspace>,
+    session: &Session,
+    input: &Entity<TextInput>,
+) -> impl IntoElement {
+    let (workspace, id) = (workspace.clone(), session.terminal.entity_id());
+    div()
+        .on_key_down(move |event, window, cx| {
+            if event.keystroke.key == "escape" {
+                cx.stop_propagation();
+                workspace.update(cx, |this, cx| this.end_rename(id, false, window, cx));
+            }
+        })
+        .child(Input::new(input).size(ControlSize::Sm))
+}
+
 /// What a mark shows: the most pressing record's state, else a failed last command.
 pub fn look(record: Option<&Record>, failed: bool) -> Option<Look> {
     Some(

src/settings/mod.rs

@@ -60,6 +60,8 @@ pub struct Settings {
     /// The theme while the system is dark; none keeps `theme`.
     pub dark_theme: Option<String>,
     pub font_family: String,
+    /// Families tried in order for a character Font family lacks.
+    pub font_fallbacks: Vec<String>,
     pub font_size: f32,
     pub line_height: f32,
     pub ligatures: bool,
@@ -97,6 +99,7 @@ impl Default for Settings {
             theme: themes::default_id().into(),
             dark_theme: None,
             font_family: "JetBrains Mono".into(),
+            font_fallbacks: Vec::new(),
             font_size: 13.0,
             line_height: 1.2,
             ligatures: true,
@@ -155,6 +158,10 @@ impl Settings {
             }
         }
         anyhow::ensure!(!self.font_family.is_empty(), "font_family is empty");
+        anyhow::ensure!(
+            !self.font_fallbacks.iter().any(String::is_empty),
+            "font_fallbacks holds an empty family"
+        );
         if !self.shell.is_empty() {
             program_path(&self.shell)?;
         }
@@ -269,6 +276,23 @@ mod tests {
         assert_eq!(error.to_string(), "panel_width is 1000, outside 160 to 960");
     }
 
+    #[test]
+    fn fallback_fonts_are_none_unless_named_and_none_is_empty() {
+        let older: Settings = serde_json::from_str(r#"{"font_family":"Menlo"}"#).expect("parses");
+        assert!(older.font_fallbacks.is_empty(), "a file from before");
+        let named: Settings =
+            serde_json::from_str(r#"{"font_fallbacks":["Kaiti SC","Noto Sans CJK SC"]}"#)
+                .expect("parses");
+        assert_eq!(named.font_fallbacks, ["Kaiti SC", "Noto Sans CJK SC"]);
+        named.validate().expect("named families pass");
+        let empty = Settings {
+            font_fallbacks: vec!["Kaiti SC".into(), String::new()],
+            ..Settings::default()
+        };
+        let error = empty.validate().expect_err("an empty family");
+        assert_eq!(error.to_string(), "font_fallbacks holds an empty family");
+    }
+
     #[test]
     fn a_shell_names_a_program_or_none() {
         let shell = |shell: &str| Settings {

src/settings/store.rs

@@ -24,7 +24,7 @@ impl SettingsStore {
         let folder = dirs::config_dir().context("settings: the platform names no config folder")?;
         let path = folder.join("ELYTerminal").join("settings.json");
         let settings = load(&path)?;
-        loads(&settings.font_family, cx)
+        fonts(&settings, cx)
             .with_context(|| format!("settings: {} holds a bad value", path.display()))?;
         cx.set_global(Self { settings, path });
         Ok(())
@@ -43,8 +43,10 @@ impl SettingsStore {
             return Ok(());
         }
         next.validate()?;
-        if next.font_family != store.settings.font_family {
+        if (&next.font_family, &next.font_fallbacks)
-            loads(&next.font_family, cx)?;
+            != (&store.settings.font_family, &store.settings.font_fallbacks)
+        {
+            fonts(&next, cx)?;
         }
         save(&store.path, &next)?;
         cx.global_mut::<Self>().settings = next;
@@ -52,9 +54,18 @@ impl SettingsStore {
     }
 }
 
-/// Checks the terminal can load `family`.
+/// Checks the terminal can load its family and each fallback; the error names the field.
-fn loads(family: &str, cx: &App) -> anyhow::Result<()> {
+fn fonts(settings: &Settings, cx: &App) -> anyhow::Result<()> {
-    crate::term::load_font(&gpui::font(family.to_string()), cx.text_system()).map(|_| ())
+    let fallbacks = settings
+        .font_fallbacks
+        .iter()
+        .map(|family| ("font_fallbacks", family));
+    for (field, family) in std::iter::once(("font_family", &settings.font_family)).chain(fallbacks)
+    {
+        crate::term::load_font(&gpui::font(family.clone()), cx.text_system())
+            .with_context(|| field.to_string())?;
+    }
+    Ok(())
 }
 
 /// The file's settings; defaults when there is no file. A file that fails to read or check is an error.

src/settings/window.rs

@@ -96,6 +96,10 @@ pub struct SettingsWindow {
     /// Refusals so far; a field keyed by it drops its draft and shows the settings again.
     drafts: usize,
     font: Entity<TextInput>,
+    /// A picker's input for each fallback family, and one for the family being added.
+    fallbacks: Vec<Entity<TextInput>>,
+    /// The empty picker that adds a fallback shows.
+    adding: bool,
     /// Whether the cursor preview shows, as it blinks.
     lit: bool,
     _typed: Subscription,
@@ -131,6 +135,8 @@ impl SettingsWindow {
             failed: None,
             drafts: 0,
             font,
+            fallbacks: Vec::new(),
+            adding: false,
             lit: true,
             _typed: typed,
             _settings: cx.observe_global::<SettingsStore>(|_, cx| cx.notify()),
@@ -285,7 +291,10 @@ fn set(
 impl Render for SettingsWindow {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let page = match self.section.as_ref() {
-            "appearance" => self.appearance(window, cx).into_any_element(),
+            "appearance" => {
+                self.grow_fallbacks(window, cx);
+                self.appearance(window, cx).into_any_element()
+            }
             "terminal" => self.terminal(cx).into_any_element(),
             other => unreachable!("settings: no section {other}"),
         };

src/settings/window/appearance.rs

@@ -1,8 +1,10 @@
 use std::ops::RangeInclusive;
 
 use ely_gpui_component::{
-    forms::{FontPicker, NumberInput, RadioCard, Slider, Switch},
+    buttons::{Button, ButtonVariant, IconButton},
+    forms::{FontPicker, NumberInput, RadioCard, Slider, Switch, TextInput},
     layout::SimpleGrid,
+    primitives::IconName,
     settings::{SettingsRow, SettingsSection},
     theme::{ActiveTheme, ControlSize, Mix, Radius, TextSize},
 };
@@ -72,8 +74,12 @@ impl SettingsWindow {
                     }
                 }
             });
+        let fallbacks = SettingsRow::new("Fallbacks")
+            .description("Tried in order for characters the family lacks")
+            .control(self.fallback_list(cx));
         let font = SettingsSection::new("Font")
             .row(SettingsRow::new("Family").control(div().w(theme.prose_width()).child(family)))
+            .row(fallbacks)
             .row(SettingsRow::new("Size").control(self.number(
                 "font_size",
                 settings.font_size,
@@ -173,6 +179,98 @@ impl SettingsWindow {
             .child(background)
     }
 
+    /// An input for each fallback picker and the one that adds a family.
+    pub(super) fn grow_fallbacks(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let wanted = SettingsStore::get(cx).font_fallbacks.len() + 1;
+        while self.fallbacks.len() < wanted {
+            let input = cx.new(|cx| TextInput::new(window, cx));
+            self.fallbacks.push(input);
+        }
+    }
+
+    /// Each fallback family, a picker that replaces it and a button that removes it, then Add or the empty picker it opens.
+    fn fallback_list(&self, cx: &Context<Self>) -> Div {
+        let this = cx.entity();
+        let families = SettingsStore::get(cx).font_fallbacks.clone();
+        let width = cx.theme().prose_width();
+        let row = |index: usize, picker: FontPicker, remove: IconButton| {
+            let tip = if index < families.len() {
+                "Remove"
+            } else {
+                "Cancel"
+            };
+            div()
+                .flex()
+                .items_start()
+                .gap_2()
+                .child(div().w(width).child(picker))
+                .child(
+                    remove
+                        .variant(ButtonVariant::Ghost)
+                        .size(ControlSize::Sm)
+                        .tooltip(tip),
+                )
+        };
+        let rows = families.iter().enumerate().map(|(index, family)| {
+            let picker = FontPicker::new(keyed(&self.fallbacks[index]), &self.fallbacks[index])
+                .selected(family.clone())
+                .on_change(pick(&this, index));
+            let remove = IconButton::new(("remove_fallback", index), IconName::X).on_click({
+                let (this, family) = (this.clone(), family.clone());
+                move |_, window, cx| {
+                    let dropped = format!("font_fallbacks drops {family:?}");
+                    let removed = set(&this, dropped, cx, |settings| {
+                        settings.font_fallbacks.remove(index);
+                    });
+                    // Each input left keeps its own family, and none the dropped one.
+                    if removed {
+                        this.update(cx, |this, _| this.fallbacks.remove(index));
+                        window.blur(cx);
+                    }
+                }
+            });
+            row(index, picker, remove)
+        });
+        let next = families.len();
+        let add = if self.adding {
+            let picker = FontPicker::new(keyed(&self.fallbacks[next]), &self.fallbacks[next])
+                .on_change(pick(&this, next));
+            let cancel = IconButton::new("cancel_fallback", IconName::X).on_click({
+                let this = this.clone();
+                move |_, window, cx| {
+                    this.update(cx, |this, cx| this.leave_adding(cx));
+                    window.blur(cx);
+                }
+            });
+            row(next, picker, cancel)
+        } else {
+            let add = Button::new("add_fallback", "Add fallback")
+                .icon(IconName::Plus)
+                .size(ControlSize::Sm)
+                .on_click({
+                    let this = this.clone();
+                    move |_, _, cx| {
+                        this.update(cx, |this, cx| {
+                            this.adding = true;
+                            cx.notify();
+                        })
+                    }
+                });
+            div().child(add)
+        };
+        div().flex().flex_col().gap_2().children(rows).child(add)
+    }
+
+    /// Closes the empty picker, its text gone.
+    fn leave_adding(&mut self, cx: &mut Context<Self>) {
+        let next = SettingsStore::get(cx).font_fallbacks.len();
+        if let Some(input) = self.fallbacks.get(next) {
+            input.update(cx, |input, cx| input.set_text("", cx));
+        }
+        self.adding = false;
+        cx.notify();
+    }
+
     /// A field over `range`, by `step` to `places`, that saves each committed number through `put`; a refusal starts it again from the settings.
     fn number(
         &self,
@@ -198,6 +296,50 @@ impl SettingsWindow {
     }
 }
 
+/// A fallback picker's id, its input's: Ely's combobox keeps state by id and listens to the input it met first.
+fn keyed(input: &Entity<TextInput>) -> (&'static str, u64) {
+    ("font_fallback", input.entity_id().as_u64())
+}
+
+/// Saves the family picked at fallback `index`, past the last adds one; a refusal shows the saved family again, the list closed.
+fn pick(
+    this: &Entity<SettingsWindow>,
+    index: usize,
+) -> impl Fn(&SharedString, &mut Window, &mut App) + 'static {
+    let this = this.clone();
+    move |family, window, cx| {
+        let family = family.to_string();
+        let adds = index == SettingsStore::get(cx).font_fallbacks.len();
+        let saved = set(
+            &this,
+            format!("font_fallbacks[{index}] is {family:?}"),
+            cx,
+            |settings| {
+                if adds {
+                    settings.font_fallbacks.push(family)
+                } else {
+                    settings.font_fallbacks[index] = family
+                }
+            },
+        );
+        if adds && saved {
+            this.update(cx, |this, cx| {
+                this.adding = false;
+                cx.notify();
+            });
+        } else if !saved {
+            let shown = SettingsStore::get(cx)
+                .font_fallbacks
+                .get(index)
+                .cloned()
+                .unwrap_or_default();
+            let input = this.read(cx).fallbacks[index].clone();
+            input.update(cx, |input, cx| input.set_text(shown, cx));
+            window.blur(cx);
+        }
+    }
+}
+
 /// `fraction` in whole percents; the slider moves by them, so a saved fraction carries no float noise.
 fn percent(fraction: f32) -> f64 {
     (f64::from(fraction) * 100.).round()

src/term/click.rs

@@ -0,0 +1,187 @@
+//! A click on the line the shell reads moves its cursor there, as Ghostty's `cursor-click-to-move`: arrows, or the press itself where the shell takes clicks.
+
+use alacritty_terminal::{
+    grid::Dimensions,
+    index::{Column, Line, Point},
+    term::{
+        Term, TermMode,
+        cell::{Cell, Flags},
+    },
+};
+use gpui::Context;
+
+use super::{
+    marks::Click,
+    mouse::Tracking,
+    prompts::{Part, part, prompted, start},
+    view::TerminalView,
+};
+
+/// Where the shell stands, as its OSC 133 marks say.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Shell {
+    /// A command runs, or nothing said otherwise.
+    #[default]
+    Busy,
+    /// Its prompt draws; the line after it takes a click so.
+    Prompting(Click),
+    /// It reads a line, which takes a click so.
+    Reading(Click),
+}
+
+impl Shell {
+    /// The shell after B: it reads the line its prompt started, which takes arrows without one.
+    pub fn reads(self) -> Self {
+        match self {
+            Self::Prompting(click) | Self::Reading(click) => Self::Reading(click),
+            Self::Busy => Self::Reading(Click::Arrows),
+        }
+    }
+}
+
+/// Arrows from the cursor to `click`, right positive; none when `click` lies off the input after the cursor's prompt, soft wraps joined.
+pub fn arrows<T>(term: &Term<T>, click: Point) -> Option<i32> {
+    if term.mode().contains(TermMode::ALT_SCREEN) {
+        return None;
+    }
+    let grid = term.grid();
+    let columns = grid.columns();
+    let cursor = grid.cursor.point;
+    let wraps = |line: i32| {
+        grid[Line(line)][Column(columns - 1)]
+            .flags
+            .contains(Flags::WRAPLINE)
+    };
+    let mut first = cursor.line.0;
+    while first > grid.topmost_line().0 && wraps(first - 1) {
+        first -= 1;
+    }
+    let mut last = cursor.line.0;
+    while last < grid.bottommost_line().0 && wraps(last) {
+        last += 1;
+    }
+    if !(first..=last).contains(&click.line.0) {
+        return None;
+    }
+    let cells: Vec<&Cell> = (first..=last)
+        .flat_map(|line| (0..columns).map(move |column| &grid[Line(line)][Column(column)]))
+        .collect();
+    let at = |point: Point| (point.line.0 - first) as usize * columns + point.column.0;
+    let (here, there) = (at(cursor), at(click));
+    // Input starts past the prompt the cursor's line shows before it.
+    let start = cells[..here].iter().rposition(|cell| prompted(cell))? + 1;
+    if there < start {
+        return None;
+    }
+    let inked = |cell: &&Cell| !prompted(cell) && !matches!(cell.c, ' ' | '\t');
+    let end = cells[start..]
+        .iter()
+        .rposition(inked)
+        .map_or(here, |last| here.max(start + last + 1));
+    let mut target = there.min(end);
+    if cells[target].flags.contains(Flags::WIDE_CHAR_SPACER) {
+        target -= 1;
+    }
+    let spacer = Flags::WIDE_CHAR_SPACER | Flags::LEADING_WIDE_CHAR_SPACER;
+    let typed = |cell: &&&Cell| !prompted(cell) && !cell.flags.intersects(spacer);
+    let count = |from: usize, to: usize| cells[from..to].iter().filter(typed).count() as i32;
+    Some(if target >= here {
+        count(here, target)
+    } else {
+        -count(target, here)
+    })
+}
+
+/// The left press, SGR, a shell that takes clicks hears for `click`, its row the screen's or counted from its prompt's first, as kitty and Ghostty send it; none on a prompt, before the input or below it.
+pub fn press<T>(term: &Term<T>, click: Point, relative: bool) -> Option<Vec<u8>> {
+    if term.mode().contains(TermMode::ALT_SCREEN) {
+        return None;
+    }
+    let grid = term.grid();
+    let cell = |(line, column): (i32, usize)| &grid[Line(line)][Column(column)];
+    let cursor = (grid.cursor.point.line.0, grid.cursor.point.column.0);
+    // ponytail: scans of the rows on the way; index the terminal's own links if long histories lag.
+    let back = (grid.topmost_line().0..=grid.bottommost_line().0)
+        .rev()
+        .flat_map(|line| (0..term.columns()).rev().map(move |column| (line, column)));
+    let end = (back.clone())
+        .filter(|&at| at < cursor)
+        .find(|&at| prompted(cell(at)));
+    // The newest line typed, by its number, which only grows, its first and last cells; a shell drawing its prompts again keeps it.
+    let typed = back.filter_map(|at| match part(cell(at)) {
+        Some(Part::Input(line)) => Some((at, line)),
+        _ => None,
+    });
+    let newest = typed.fold(None, |newest, (at, line)| match newest {
+        Some((_, _, kept)) if kept > line => newest,
+        Some((_, last, kept)) if kept == line => Some((at, last, line)),
+        _ => Some((at, at, line)),
+    });
+    let input = newest.map(|(first, _, line)| (first, line));
+    let bottom = newest.map_or(cursor.0, |(_, last, _)| last.0.max(cursor.0));
+    // An older line typed between a prompt and the input leaves that prompt behind.
+    let older = |end: (i32, usize), (input, line): ((i32, usize), u32)| {
+        (end.0..=input.0)
+            .flat_map(|row| {
+                let from = if row == end.0 { end.1 + 1 } else { 0 };
+                let to = if row == input.0 {
+                    input.1
+                } else {
+                    term.columns()
+                };
+                (from..to).map(move |column| (row, column))
+            })
+            .any(|at| matches!(part(cell(at)), Some(Part::Input(other)) if other != line))
+    };
+    let at = (click.line.0, click.column.0);
+    // Input starts past the prompt's last cell before the cursor, or at its first typed cell where no prompt of its own came before it.
+    let (before, first) = match (end, input) {
+        (Some(end), Some(typed)) if typed.0 > end && older(end, typed) => (at < typed.0, typed.0.0),
+        (Some(end), _) => (at <= end, start(term, end.0)?),
+        (None, Some((input, _))) => (at < input, input.0),
+        (None, None) => return None,
+    };
+    if before || at.0 > bottom || prompted(cell(at)) {
+        return None;
+    }
+    let row = if relative { at.0 - first } else { at.0 } + 1;
+    if row < 1 {
+        return None;
+    }
+    Some(format!("\x1b[<0;{};{row}M", click.column.0 + 1).into_bytes())
+}
+
+impl TerminalView {
+    /// Moves the shell's cursor to `click` while it reads a line: arrows, each pressed and let go, or the press where the shell takes clicks.
+    pub(super) fn click_to_move(&mut self, click: Point, cx: &mut Context<Self>) {
+        let pid = self.pty.pid;
+        let Shell::Reading(takes) = self.shell else {
+            log::debug!("terminal {pid}: a click at {click:?}, no line read");
+            return;
+        };
+        if self.mouse.tracking != Tracking::Off {
+            log::debug!("terminal {pid}: a click at {click:?}, the program tracks the mouse");
+            return;
+        }
+        if takes != Click::Arrows {
+            let Some(bytes) = press(&self.pty.term.lock(), click, takes == Click::Relative) else {
+                log::debug!("terminal {pid}: a click at {click:?}, off the input");
+                return;
+            };
+            log::debug!("terminal {pid}: a click at {click:?} goes to the shell as {bytes:?}");
+            return self.input(bytes, cx);
+        }
+        let Some(count) = arrows(&self.pty.term.lock(), click) else {
+            log::debug!("terminal {pid}: a click at {click:?}, off the input");
+            return;
+        };
+        log::debug!("terminal {pid}: a click at {click:?} moves the cursor {count}");
+        let arrow = if count < 0 { "left" } else { "right" };
+        for _ in 0..count.unsigned_abs() {
+            self.tap_key(arrow, cx);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;

src/term/click/tests.rs

@@ -0,0 +1,269 @@
+use alacritty_terminal::{
+    event::VoidListener,
+    term::{Config, test::TermSize},
+    vte::ansi::Processor,
+};
+
+use super::*;
+use crate::term::prompts::Prompts;
+
+const PROMPT: &str = "\x1b]133;A\x07$ \x1b]133;B\x07";
+
+/// A terminal `columns` wide after `text` passed the prompts' rewrite, as the tap passes it.
+fn term(columns: usize, text: &str) -> Term<VoidListener> {
+    let mut term = Term::new(Config::default(), &TermSize::new(columns, 4), VoidListener);
+    let mut parser: Processor = Processor::new();
+    parser.advance(&mut term, Prompts::default().pass(text.as_bytes()));
+    term
+}
+
+fn click(line: i32, column: usize) -> Point {
+    Point::new(Line(line), Column(column))
+}
+
+#[test]
+fn a_click_on_the_typed_line_counts_the_characters_to_it() {
+    let typed = term(20, &format!("{PROMPT}echo hello"));
+    assert_eq!(arrows(&typed, click(0, 7)), Some(-5), "back to hello");
+    assert_eq!(
+        arrows(&typed, click(0, 2)),
+        Some(-10),
+        "the first character"
+    );
+    assert_eq!(
+        arrows(&typed, click(0, 12)),
+        Some(0),
+        "the cursor's own cell"
+    );
+    let moved = term(20, &format!("{PROMPT}echo hello\x1b[5D"));
+    assert_eq!(arrows(&moved, click(0, 11)), Some(4), "on to the last o");
+    assert_eq!(
+        arrows(&moved, click(0, 18)),
+        Some(5),
+        "past the end, the end"
+    );
+}
+
+#[test]
+fn a_click_off_the_input_moves_nothing() {
+    let typed = term(20, &format!("{PROMPT}ls"));
+    assert_eq!(arrows(&typed, click(0, 0)), None, "on the prompt");
+    assert_eq!(arrows(&typed, click(0, 1)), None, "on the prompt's space");
+    assert_eq!(arrows(&typed, click(2, 3)), None, "another line");
+    let ran = term(20, &format!("{PROMPT}cat\r\nhello"));
+    assert_eq!(arrows(&ran, click(1, 2)), None, "a line no prompt shows");
+    let output = term(20, "$ plain text");
+    assert_eq!(arrows(&output, click(0, 3)), None, "no marks at all");
+    let full = term(20, &format!("{PROMPT}vim\x1b[?1049h"));
+    assert_eq!(arrows(&full, click(0, 3)), None, "the alternate screen");
+}
+
+#[test]
+fn a_wide_character_takes_one_arrow() {
+    let wide = term(20, &format!("{PROMPT}中文ab"));
+    assert_eq!(arrows(&wide, click(0, 3)), Some(-4), "the right half of 中");
+    assert_eq!(arrows(&wide, click(0, 4)), Some(-3), "文");
+    assert_eq!(arrows(&wide, click(0, 7)), Some(-1), "b");
+}
+
+#[test]
+fn soft_wrapped_rows_are_one_line() {
+    let wrapped = term(10, &format!("{PROMPT}abcdefghijkl"));
+    assert_eq!(wrapped.grid().cursor.point, click(1, 4));
+    assert_eq!(arrows(&wrapped, click(0, 3)), Some(-11), "back to b");
+    let back = term(10, &format!("{PROMPT}abcdefghijkl\x1b[3D"));
+    assert_eq!(arrows(&back, click(0, 3)), Some(-8), "up to b");
+    assert_eq!(arrows(&back, click(1, 3)), Some(2), "on to l");
+}
+
+#[test]
+fn trailing_spaces_count_only_up_to_the_cursor() {
+    let spaced = term(20, &format!("{PROMPT}ls  "));
+    assert_eq!(arrows(&spaced, click(0, 15)), Some(0));
+    assert_eq!(arrows(&spaced, click(0, 4)), Some(-2));
+}
+
+#[test]
+fn a_prompt_over_two_lines_keeps_its_input_on_the_last() {
+    let two = term(20, "\x1b]133;A\x07~/src\r\n> \x1b]133;B\x07make");
+    assert_eq!(arrows(&two, click(1, 2)), Some(-4));
+    assert_eq!(arrows(&two, click(0, 3)), None, "the prompt's first line");
+}
+
+/// The press `term` sends for a click at `at`, as text.
+fn sent(term: &Term<VoidListener>, at: Point, relative: bool) -> Option<String> {
+    press(term, at, relative).map(|bytes| String::from_utf8(bytes).expect("ASCII"))
+}
+
+#[test]
+fn a_shell_that_takes_clicks_hears_the_press_where_it_landed() {
+    let marked = "\x1b]133;A;click_events=1\x07$ \x1b]133;B\x07";
+    let typed = term(20, &format!("out\r\n{marked}echo hi"));
+    assert_eq!(
+        sent(&typed, click(1, 7), false).as_deref(),
+        Some("\x1b[<0;8;2M")
+    );
+    assert_eq!(
+        sent(&typed, click(1, 7), true).as_deref(),
+        Some("\x1b[<0;8;1M")
+    );
+    assert_eq!(
+        sent(&typed, click(2, 3), true),
+        None,
+        "a row below the input"
+    );
+    assert_eq!(sent(&typed, click(0, 1), false), None, "before the prompt");
+    assert_eq!(sent(&typed, click(1, 0), false), None, "on the prompt");
+    assert_eq!(
+        sent(&typed, click(1, 1), false),
+        None,
+        "on the prompt's space"
+    );
+    let past = sent(&typed, click(1, 15), false);
+    assert_eq!(
+        past.as_deref(),
+        Some("\x1b[<0;16;2M"),
+        "past the end, the shell decides"
+    );
+    let right = term(
+        20,
+        &format!("{marked}\x1b[1;17H\x1b]133;A\x07~/a\x1b]133;B\x07\x1b[1;3Hls"),
+    );
+    assert_eq!(
+        sent(&right, click(0, 18), false),
+        None,
+        "a right prompt after the cursor"
+    );
+    assert_eq!(
+        sent(&right, click(0, 3), false).as_deref(),
+        Some("\x1b[<0;4;1M")
+    );
+    assert_eq!(sent(&right, click(0, 1), false), None, "on the left prompt");
+    let empty = term(
+        20,
+        "\x1b[1;17H\x1b]133;A;click_events=1\x07~/a\x1b]133;B\x07\x1b[1;1Hls",
+    );
+    let left = sent(&empty, click(0, 1), false);
+    assert_eq!(left.as_deref(), Some("\x1b[<0;2;1M"), "only a right prompt");
+    assert_eq!(
+        sent(&empty, click(0, 17), false),
+        None,
+        "on that right prompt"
+    );
+    let two = term(
+        20,
+        "\x1b]133;A;click_events=2\x07~/src\r\n> \x1b]133;B\x07ls",
+    );
+    let relative = sent(&two, click(1, 3), true);
+    assert_eq!(
+        relative.as_deref(),
+        Some("\x1b[<0;4;2M"),
+        "from the prompt's first row"
+    );
+    let full = term(20, &format!("{marked}vim\x1b[?1049h"));
+    assert_eq!(
+        sent(&full, click(0, 3), false),
+        None,
+        "the alternate screen"
+    );
+    let scrolled = term(20, &format!("{marked}a\r\nb\r\nc\r\nd\r\ne"));
+    assert_eq!(
+        sent(&scrolled, click(-1, 0), false),
+        None,
+        "a row in the history"
+    );
+}
+
+#[test]
+fn input_reads_the_line_its_prompt_started() {
+    assert_eq!(Shell::Busy.reads(), Shell::Reading(Click::Arrows));
+    assert_eq!(
+        Shell::Prompting(Click::Absolute).reads(),
+        Shell::Reading(Click::Absolute)
+    );
+    assert_eq!(
+        Shell::Reading(Click::Relative).reads(),
+        Shell::Reading(Click::Relative)
+    );
+}
+
+#[test]
+fn a_prompt_that_prints_nothing_starts_the_input_at_its_first_typed_cell() {
+    let empty = "\x1b]133;A;click_events=1\x07\x1b]133;B\x07";
+    let typed = term(20, &format!("echo hi\r\nhi\r\n{empty}abcdef"));
+    let at = sent(&typed, click(2, 3), false);
+    assert_eq!(at.as_deref(), Some("\x1b[<0;4;3M"), "on the d");
+    let relative = sent(&typed, click(2, 3), true);
+    assert_eq!(
+        relative.as_deref(),
+        Some("\x1b[<0;4;1M"),
+        "from the input's row"
+    );
+    assert_eq!(sent(&typed, click(1, 1), false), None, "output above");
+    assert_eq!(
+        sent(&typed, click(0, 2), false),
+        None,
+        "the line run before"
+    );
+    let moved = term(20, &format!("{empty}abcdef\x1b[6D"));
+    let back = sent(&moved, click(0, 4), false);
+    assert_eq!(
+        back.as_deref(),
+        Some("\x1b[<0;5;1M"),
+        "the cursor at the start"
+    );
+    let blank = term(20, &format!("echo hi\r\n{empty}"));
+    assert_eq!(
+        sent(&blank, click(0, 2), false),
+        None,
+        "nothing typed, nothing after"
+    );
+}
+
+#[test]
+fn a_prompt_drawn_again_after_the_typed_text_keeps_its_line() {
+    let marked = "\x1b]133;A;click_events=1\x07";
+    let right = format!("\x1b[1;17H{marked}RIGHT\x1b]133;B\x07\x1b[1;7H");
+    let repainted = term(24, &format!("{marked}\x1b]133;B\x07abcdef{right}"));
+    let at = sent(&repainted, click(0, 3), false);
+    assert_eq!(
+        at.as_deref(),
+        Some("\x1b[<0;4;1M"),
+        "fish's right prompt again"
+    );
+    assert_eq!(
+        sent(&repainted, click(0, 17), false),
+        None,
+        "on that prompt"
+    );
+    let ran = "\x1b]133;C\x07\x1b]133;D;0\x07";
+    let after = format!("$ \x1b]133;B\x07echo hi{ran}\r\nhi\r\n{marked}\x1b]133;B\x07abcdef");
+    let below = term(20, &format!("{marked}{after}"));
+    assert_eq!(sent(&below, click(1, 1), false), None, "the output between");
+    assert_eq!(
+        sent(&below, click(0, 4), false),
+        None,
+        "the line run before"
+    );
+    let typed = sent(&below, click(2, 2), true);
+    assert_eq!(
+        typed.as_deref(),
+        Some("\x1b[<0;3;1M"),
+        "from the input's own row"
+    );
+}
+
+#[test]
+fn the_newest_line_typed_is_known_by_its_number_not_its_place() {
+    let marked = "\x1b]133;A;click_events=1\x07$ \x1b]133;B\x07";
+    let ran = "\x1b]133;C\x07\x1b]133;D;0\x07";
+    let home = format!("\r\n\r\n\r\n{marked}oldlower{ran}\x1b[H{marked}abcdef");
+    let above = term(20, &home);
+    let at = sent(&above, click(0, 5), false);
+    assert_eq!(
+        at.as_deref(),
+        Some("\x1b[<0;6;1M"),
+        "the prompt at the top, old input below"
+    );
+    assert_eq!(sent(&above, click(3, 4), false), None, "the old line below");
+}

src/term/drop.rs

@@ -0,0 +1,94 @@
+//! Files dropped on the terminal type their paths, as macOS Terminal does.
+
+use std::path::PathBuf;
+
+use anyhow::Context as _;
+use gpui::{Context, ExternalPaths};
+
+use super::view::TerminalView;
+
+/// What a POSIX shell reads specially in a path: Ghostty's list, and zsh's `extendedglob` marks.
+const SPECIAL: &str = "\\ ()[]{}<>\"'`!#$&;|*?^~";
+
+/// PowerShell's single quotes, each one doubled inside a quoted string.
+const SINGLE: [char; 5] = ['\'', '\u{2018}', '\u{2019}', '\u{201a}', '\u{201b}'];
+
+/// How a session's shell reads a path typed into it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Quote {
+    /// sh, bash, zsh, fish: a backslash before each special character.
+    Posix,
+    /// Single quotes, which expand nothing.
+    PowerShell,
+    /// Double quotes, past which cmd still expands `%` and, under `/v:on`, `!`.
+    Cmd,
+}
+
+/// The text `paths` type, each followed by a space, as `quote` keeps each one literal.
+pub fn typed(paths: &[PathBuf], quote: Quote) -> anyhow::Result<String> {
+    paths
+        .iter()
+        .map(|path| {
+            let text = (path.to_str())
+                .with_context(|| format!("{} is no UTF-8 a session can type", path.display()))?;
+            anyhow::ensure!(
+                !text.chars().any(char::is_control),
+                "{text:?} holds a control character, which would act as typed"
+            );
+            let mut out = String::with_capacity(text.len() + 3);
+            match quote {
+                Quote::Posix => text.chars().for_each(|ch| {
+                    if SPECIAL.contains(ch) {
+                        out.push('\\');
+                    }
+                    out.push(ch);
+                }),
+                Quote::PowerShell => {
+                    out.push('\'');
+                    text.chars().for_each(|ch| {
+                        if SINGLE.contains(&ch) {
+                            out.push(ch);
+                        }
+                        out.push(ch);
+                    });
+                    out.push('\'');
+                }
+                Quote::Cmd => {
+                    anyhow::ensure!(
+                        !text.contains(['%', '!', '"']),
+                        "{text:?} holds %, ! or \", which cmd reads inside quotes"
+                    );
+                    // A program reads a backslash before the closing quote as a quote.
+                    let trailing = text.len() - text.trim_end_matches('\\').len();
+                    out = format!("\"{text}{}\"", "\\".repeat(trailing));
+                }
+            }
+            out.push(' ');
+            Ok(out)
+        })
+        .collect()
+}
+
+impl TerminalView {
+    /// Types the dropped paths at the cursor as a paste; a path it cannot type stops the drop.
+    pub(super) fn drop_paths(&mut self, dropped: &ExternalPaths, cx: &mut Context<Self>) {
+        let (paths, quote) = (dropped.paths(), self.pty.quote);
+        match typed(paths, quote) {
+            Ok(text) => {
+                log::info!(
+                    "terminal {}: {} paths dropped, quoted for {quote:?}",
+                    self.pty.pid,
+                    paths.len()
+                );
+                self.paste_text(&text, cx);
+            }
+            Err(error) => log::error!(
+                "terminal {}: the drop types nothing: {error:#}",
+                self.pty.pid
+            ),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;

src/term/drop/tests.rs

@@ -0,0 +1,68 @@
+use super::*;
+
+/// What `paths` type for `quote`.
+fn typed_as(quote: Quote, all: &[&str]) -> String {
+    let paths: Vec<PathBuf> = all.iter().map(PathBuf::from).collect();
+    typed(&paths, quote).unwrap()
+}
+
+#[test]
+fn a_posix_path_escapes_what_a_shell_reads_specially() {
+    let typed = |all: &[&str]| typed_as(Quote::Posix, all);
+    assert_eq!(typed(&["/tmp/a.txt"]), "/tmp/a.txt ");
+    assert_eq!(typed(&["/tmp/my file.png"]), "/tmp/my\\ file.png ");
+    assert_eq!(typed(&["/a/it's (1)&$x"]), "/a/it\\'s\\ \\(1\\)\\&\\$x ");
+    assert_eq!(
+        typed(&["/a/a^b~c#d"]),
+        "/a/a\\^b\\~c\\#d ",
+        "zsh's extendedglob"
+    );
+    assert_eq!(typed(&["/a/中文 b"]), "/a/中文\\ b ");
+    assert_eq!(
+        typed(&["/a", "/b c"]),
+        "/a /b\\ c ",
+        "each followed by a space"
+    );
+}
+
+#[test]
+fn a_powershell_path_is_single_quoted_with_its_quotes_doubled() {
+    let typed = |all: &[&str]| typed_as(Quote::PowerShell, all);
+    assert_eq!(typed(&["C:\\a.txt"]), "'C:\\a.txt' ");
+    assert_eq!(typed(&["C:\\tmp\\it's.txt"]), "'C:\\tmp\\it''s.txt' ");
+    assert_eq!(typed(&["C:\\$HOME $(1+1);x"]), "'C:\\$HOME $(1+1);x' ");
+    assert_eq!(
+        typed(&["C:\\a\u{2019}b"]),
+        "'C:\\a\u{2019}\u{2019}b' ",
+        "a curly quote"
+    );
+    assert_eq!(typed(&["/a b", "/c"]), "'/a b' '/c' ");
+}
+
+#[test]
+fn a_cmd_path_is_double_quoted_its_trailing_backslashes_doubled_and_one_cmd_expands_types_nothing()
+{
+    let typed = |all: &[&str]| typed_as(Quote::Cmd, all);
+    assert_eq!(
+        typed(&["C:\\My Files\\a&b^c.txt", "D:\\c"]),
+        "\"C:\\My Files\\a&b^c.txt\" \"D:\\c\" "
+    );
+    assert_eq!(
+        typed(&["C:\\", "D:\\clip.mp4"]),
+        "\"C:\\\\\" \"D:\\clip.mp4\" ",
+        "a root's backslash"
+    );
+    for name in ["C:\\%PATH%.txt", "C:\\!DROP!.txt"] {
+        let refused = super::typed(&[PathBuf::from(name)], Quote::Cmd);
+        assert!(refused.is_err(), "{name}: {refused:?}");
+    }
+}
+
+#[test]
+fn a_path_with_a_control_character_types_nothing() {
+    for quote in [Quote::Posix, Quote::PowerShell, Quote::Cmd] {
+        let paths = [PathBuf::from("/ok"), PathBuf::from("/tmp/a\nls")];
+        let error = typed(&paths, quote).unwrap_err();
+        assert!(error.to_string().contains("control character"), "{error}");
+    }
+}

src/term/fonts.rs

@@ -0,0 +1,80 @@
+//! The terminal's font, cell and metrics.
+
+use gpui::{
+    Font, FontFallbacks, FontFeatures, FontId, FontStyle, FontWeight, Pixels, TextSystem, Window,
+    px, size,
+};
+
+use super::{ink::Ink, paint::Look};
+use crate::settings::Settings;
+
+/// The bundled Nerd Font that draws icons any font lacks; gpui loads no font without an `m`.
+pub const ICONS: &str = "JetBrainsMono Nerd Font Mono";
+
+/// The bundled code font, the default.
+pub const MONO: &str = "JetBrains Mono";
+
+/// `font` as gpui loads it; gpui falls back to another font without a word, and loads none without an `m`.
+pub fn load_font(font: &Font, system: &TextSystem) -> anyhow::Result<FontId> {
+    let id = system.resolve_font(font);
+    let loaded = system.get_font_for_id(id);
+    anyhow::ensure!(
+        loaded.is_some_and(|loaded| loaded.family == font.family),
+        "the terminal cannot load {:?}",
+        font.family
+    );
+    Ok(id)
+}
+
+/// Font, cell and metrics at `points` on this window.
+pub(super) fn look(
+    settings: &Settings,
+    points: f32,
+    ink: &Ink,
+    window: &Window,
+) -> anyhow::Result<Look> {
+    let font = Font {
+        family: settings.font_family.clone().into(),
+        features: if settings.ligatures {
+            FontFeatures::default()
+        } else {
+            FontFeatures::disable_ligatures()
+        },
+        fallbacks: (!settings.font_fallbacks.is_empty())
+            .then(|| FontFallbacks::from_fonts(settings.font_fallbacks.clone())),
+        weight: FontWeight::NORMAL,
+        style: FontStyle::Normal,
+    };
+    let text = px(points);
+    let system = window.text_system();
+    let id = load_font(&font, system)?;
+    let advance = system
+        .advance(id, text, 'M')
+        .map_err(|error| anyhow::anyhow!("{} cannot measure M: {error}", settings.font_family))?;
+    let scale = window.scale_factor();
+    let snap = |length: Pixels| px((f32::from(length) * scale).round() / scale);
+    let cell = size(
+        snap(advance.width).max(px(1.)),
+        snap(text * settings.line_height),
+    );
+    let (ascent, descent) = (system.ascent(id, text), system.descent(id, text).abs());
+    let icons = Font {
+        family: ICONS.into(),
+        features: FontFeatures::default(),
+        ..font.clone()
+    };
+    Ok(Look {
+        font_id: id,
+        icons,
+        baseline: (cell.height - ascent - descent) / 2. + ascent,
+        descent,
+        rule: snap((text / 14.).max(px(1.))),
+        size: text,
+        cell,
+        font,
+        cursor: ink.cursor,
+        cursor_text: ink.cursor_text,
+        fg: ink.fg,
+        bg: ink.bg,
+    })
+}

src/term/input.rs

@@ -121,6 +121,18 @@ impl TerminalView {
         }
     }
 
+    /// Presses and lets go of `name` without modifiers, as the keyboard would.
+    pub(super) fn tap_key(&mut self, name: &str, cx: &mut Context<Self>) {
+        let keystroke = Keystroke {
+            modifiers: Default::default(),
+            key: name.into(),
+            key_char: None,
+        };
+        let facts = Facts::default();
+        let record = self.send(&keystroke, Action::Press, facts, false, cx) == Some(true);
+        self.send(&keystroke, Action::Release, facts, record, cx);
+    }
+
     /// Sends what `keystroke` means to the program: none when it is text the input method types, else whether it went as Windows' record; `pressed` says that of a held key's press.
     fn send(
         &mut self,
@@ -343,6 +355,11 @@ impl EntityInputHandler for TerminalView {
         _: &mut Window,
         _: &mut Context<Self>,
     ) -> Option<Bounds<Pixels>> {
+        log::debug!(
+            "terminal {}: the input method asks for the caret, {:?}",
+            self.pty.pid,
+            self.caret
+        );
         Some(self.caret)
     }
 

src/term/mac.rs

@@ -50,7 +50,7 @@ const LEFT_OPTION: u64 = 0x20;
 const RIGHT_OPTION: u64 = 0x40;
 
 /// What gpui drops from the key event AppKit is handling.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Default)]
 pub struct KeyFacts {
     pub left_option: bool,
     pub right_option: bool,

src/term/marks.rs

@@ -1,8 +1,8 @@
 /// A semantic prompt mark a program sends, OSC 133.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Mark {
-    /// A prompt starts: A, or N.
+    /// A prompt starts: A, or N, saying how its line takes a click.
-    Prompt,
+    Prompt(Click),
     /// The prompt ends and input starts: B, or I.
     Input,
     /// Input ends and the command's output starts: C.
@@ -11,6 +11,17 @@ pub enum Mark {
     Done(Option<i32>),
 }
 
+/// How the line a prompt reads takes a click, as its start's `click_events` says.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Click {
+    /// Arrows the terminal counts.
+    Arrows,
+    /// A mouse press at the click's place on the screen, `click_events=1`.
+    Absolute,
+    /// A mouse press, its row counted from the prompt's first, `click_events=2`.
+    Relative,
+}
+
 /// The mark in an OSC 133 body past `133;`; none for one the terminal takes no action on.
 pub(crate) fn read(body: &[u8]) -> Option<Mark> {
     let shown = || String::from_utf8_lossy(body);
@@ -27,7 +38,7 @@ pub(crate) fn read(body: &[u8]) -> Option<Mark> {
         }
     };
     match letter {
-        b'A' | b'N' => Some(Mark::Prompt),
+        b'A' | b'N' => Some(Mark::Prompt(click(options))),
         b'B' | b'I' => Some(Mark::Input),
         b'C' => Some(Mark::Output),
         b'D' => Some(Mark::Done(status(options))),
@@ -43,6 +54,25 @@ pub(crate) fn read(body: &[u8]) -> Option<Mark> {
     }
 }
 
+/// How A's options say its line takes a click; arrows without `click_events`.
+fn click(options: &[u8]) -> Click {
+    let value = options
+        .split(|&byte| byte == b';')
+        .find_map(|option| option.strip_prefix(b"click_events="));
+    match value {
+        None | Some(b"0") => Click::Arrows,
+        Some(b"1") => Click::Absolute,
+        Some(b"2") => Click::Relative,
+        Some(other) => {
+            log::warn!(
+                "pty: OSC 133;A with click_events={}, no such mode, so arrows",
+                String::from_utf8_lossy(other)
+            );
+            Click::Arrows
+        }
+    }
+}
+
 /// D's status, its first option; none when the program gave none or no number.
 fn status(options: &[u8]) -> Option<i32> {
     let first = options.split(|&byte| byte == b';').next()?;
@@ -67,9 +97,18 @@ mod tests {
 
     #[test]
     fn each_mark_reads_with_its_options_as_ghostty_reads_it() {
-        assert_eq!(read(b"A"), Some(Mark::Prompt));
+        assert_eq!(read(b"A"), Some(Mark::Prompt(Click::Arrows)));
-        assert_eq!(read(b"A;click_events=1"), Some(Mark::Prompt));
+        assert_eq!(
-        assert_eq!(read(b"N;aid=7"), Some(Mark::Prompt));
+            read(b"A;click_events=1"),
+            Some(Mark::Prompt(Click::Absolute))
+        );
+        assert_eq!(
+            read(b"A;aid=3;click_events=2"),
+            Some(Mark::Prompt(Click::Relative))
+        );
+        assert_eq!(read(b"A;click_events=0"), Some(Mark::Prompt(Click::Arrows)));
+        assert_eq!(read(b"A;cl=line"), Some(Mark::Prompt(Click::Arrows)));
+        assert_eq!(read(b"N;aid=7"), Some(Mark::Prompt(Click::Arrows)));
         assert_eq!(read(b"B"), Some(Mark::Input));
         assert_eq!(read(b"I"), Some(Mark::Input));
         assert_eq!(read(b"C;cmdline_url=false"), Some(Mark::Output));

src/term/mod.rs

@@ -1,5 +1,8 @@
 mod boxes;
+mod click;
+mod drop;
 mod find;
+mod fonts;
 pub mod frame;
 mod herdr;
 pub mod ink;
@@ -28,6 +31,8 @@ mod view;
 mod win32;
 pub mod zoom;
 
+pub use drop::Quote;
+pub use fonts::{ICONS, MONO, load_font};
 pub use pty::{Events, Launch, Listener, Pty, PtyEvent, config, fit, spawn};
 pub use status::{Kind, Record, Records, State};
-pub use view::{BLINK, ICONS, MONO, TerminalEvent, TerminalView, load_font};
+pub use view::{BLINK, TerminalEvent, TerminalView};

src/term/paint.rs

@@ -54,7 +54,11 @@ pub fn grid(
                 if let Some((row, column)) = at {
                     let corner =
                         origin + point(cell.width * column as f32, cell.height * row as f32);
-                    view.caret = Bounds::new(corner, cell);
+                    let caret = Bounds::new(corner, cell);
+                    if caret != view.caret {
+                        log::trace!("terminal {}: the caret moves to {caret:?}", view.pty.pid);
+                        view.caret = caret;
+                    }
                 }
                 if view.fit(columns, lines, cx) {
                     cx.notify();

src/term/pointer.rs

@@ -28,6 +28,8 @@ pub struct Pointer {
     pub cell: Size<Pixels>,
     /// The left button is down and drawing a selection.
     selecting: bool,
+    /// A plain press's cell, until it drags off it; its release may move the shell's cursor.
+    click: Option<Cell>,
     /// Buttons whose press went to the program.
     pressed: Vec<Button>,
     /// The cell of the last report; motion inside it sends nothing.
@@ -149,6 +151,8 @@ impl TerminalView {
         if event.button != MouseButton::Left {
             return;
         }
+        let plain = event.click_count == 1 && !event.modifiers.modified();
+        self.pointer.click = plain.then_some(point);
         let pid = self.pty.pid;
         let mut term = self.pty.term.lock();
         match (
@@ -183,6 +187,9 @@ impl TerminalView {
     ) {
         let (cell, point, side) = self.cell_at(event.position);
         if self.pointer.selecting && event.pressed_button == Some(MouseButton::Left) {
+            if self.pointer.click.is_some_and(|click| click != point) {
+                self.pointer.click = None;
+            }
             if let Some(selection) = self.pty.term.lock().selection.as_mut() {
                 log::trace!("terminal {}: the selection runs to {point:?}", self.pty.pid);
                 selection.update(point, side);
@@ -207,6 +214,15 @@ impl TerminalView {
     ) {
         if event.button == MouseButton::Left {
             self.end_selection(cx);
+            let (_, point, _) = self.cell_at(event.position);
+            match self.pointer.click.take() {
+                Some(click) if click != point => log::debug!(
+                    "terminal {}: a press at {click:?} let go at {point:?}",
+                    self.pty.pid
+                ),
+                Some(click) if self.selected().is_none() => self.click_to_move(click, cx),
+                _ => {}
+            }
         }
         if let Some(released) = button(event.button) {
             let (cell, ..) = self.cell_at(event.position);
@@ -217,6 +233,7 @@ impl TerminalView {
     /// Ends the mouse's gesture as releases would: a hidden terminal hears none.
     pub fn let_go(&mut self, cx: &mut Context<Self>) {
         self.end_selection(cx);
+        self.pointer.click = None;
         for held in self.pointer.pressed.clone() {
             log::debug!("terminal {}: hidden with {held:?} down", self.pty.pid);
             let cell = self
@@ -361,6 +378,11 @@ impl TerminalView {
             log::debug!("terminal {}: no text to paste", self.pty.pid);
             return;
         };
+        self.paste_text(&text, cx);
+    }
+
+    /// `text` to the program as a paste, bracketed when it asked.
+    pub(super) fn paste_text(&mut self, text: &str, cx: &mut Context<Self>) {
         let bracketed = self
             .pty
             .term
@@ -373,7 +395,7 @@ impl TerminalView {
             text.chars().count(),
             if bracketed { ", bracketed" } else { "" }
         );
-        self.input(keys::paste(&text, bracketed), cx);
+        self.input(keys::paste(text, bracketed), cx);
     }
 }
 

src/term/prompts.rs

@@ -13,6 +13,24 @@ pub(crate) const LINK: &str = "\u{7f}";
 /// What a link's id starts with when it carries a prompt's number: the prompt's own link, or a program's inside it.
 const NUMBERED: char = '\u{7f}';
 
+/// What ends the id of a link on the line typed after a prompt.
+const TYPED: char = 'i';
+
+/// What the terminal's own link stamps: a prompt's cells, by its number, or the line typed after it, OSC 133 B to C, by the commands ended before it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Part {
+    Prompt(u32),
+    Input(u32),
+}
+
+/// How a mark moves the link: a prompt starts, its input starts, or the command ends it.
+#[derive(Debug, PartialEq)]
+enum Edge {
+    Prompt,
+    Input,
+    End,
+}
+
 /// What ends a prompt's link.
 const CLOSE: &[u8] = b"\x1b]8;;\x07";
 
@@ -53,12 +71,14 @@ pub(crate) struct Prompts {
     overflow: bool,
     /// The held OSC's ESC has gone on: it ended the OSC before.
     sent: bool,
-    /// The prompt open now, from its start mark to its end.
+    /// The prompt or input open now, from its mark to the next.
-    prompt: Option<u32>,
+    open: Option<Part>,
     /// The target of a program's link open now, to open it again with a prompt's number and without.
     target: Option<Vec<u8>>,
     /// The last prompt's number.
     count: u32,
+    /// Commands ended, C or D, so every prompt a shell draws again on one line shares its input's number.
+    ended: u32,
     /// What goes to the parser from the last read.
     out: Vec<u8>,
 }
@@ -116,7 +136,7 @@ impl Prompts {
             (State::Escape { .. }, _) => {
                 // A full reset clears the link the parser writes with.
                 if byte == b'c' {
-                    (self.prompt, self.target) = (None, None);
+                    (self.open, self.target) = (None, None);
                 }
                 self.held.push(byte);
                 self.release();
@@ -175,7 +195,7 @@ impl Prompts {
             let length = self.body.len().min(prefix.len());
             self.body[..length] == prefix[..length]
         };
-        !self.overflow && (fits(b"133;") || (self.prompt.is_some() && fits(b"8;")))
+        !self.overflow && (fits(b"133;") || (self.open.is_some() && fits(b"8;")))
     }
 
     fn release(&mut self) {
@@ -186,27 +206,31 @@ impl Prompts {
     fn end(&mut self, end: Option<u8>) -> bool {
         let rewrite = if self.overflow {
             None
-        } else if let Some(opens) = self.body.strip_prefix(b"133;").and_then(mark) {
+        } else if let Some(edge) = self.body.strip_prefix(b"133;").and_then(mark) {
-            if opens {
+            // A prompt or input inside a program's link carries its number on that link.
+            let target = self.target.as_deref().unwrap_or(LINK.as_bytes());
+            match (edge, self.open) {
+                (Edge::Prompt, _) => {
                     self.count = self.count.wrapping_add(1);
-                self.prompt = Some(self.count);
+                    self.open = Some(Part::Prompt(self.count));
-                // A prompt inside a program's link carries its number on that link.
+                    Some(link(Part::Prompt(self.count), target))
-                Some(match &self.target {
+                }
-                    Some(target) => link(self.count, target),
+                (Edge::Input, Some(Part::Prompt(_))) => {
-                    None => link(self.count, LINK.as_bytes()),
+                    self.open = Some(Part::Input(self.ended));
-                })
+                    Some(link(Part::Input(self.ended), target))
-            } else {
+                }
-                match (self.prompt.take(), &self.target) {
+                (Edge::Input, _) => None,
-                    (Some(_), Some(target)) => Some(plain(target)),
+                (Edge::End, open) => {
-                    (Some(_), None) => Some(CLOSE.to_vec()),
+                    self.ended = self.ended.wrapping_add(1);
-                    (None, _) => None,
+                    self.open = None;
+                    open.map(|_| self.target.as_deref().map_or_else(|| CLOSE.to_vec(), plain))
                 }
             }
         } else if let Some((opens, target)) = user(&self.body) {
             self.target = opens.then(|| target.to_vec());
-            // Inside a prompt a program's link carries the prompt's number; its end takes the prompt's link up again.
+            // Inside a prompt or input a program's link carries its number; its end takes the terminal's link up again.
             let target = if opens { target } else { LINK.as_bytes() };
-            self.prompt.map(|number| link(number, target))
+            self.open.map(|part| link(part, target))
         } else {
             None
         };
@@ -232,15 +256,16 @@ impl Prompts {
     }
 }
 
-/// Whether a mark's body opens a prompt or ends one, as `marks::read` reads its letter; none for neither.
+/// How a mark's body moves the link, as `marks::read` reads its letter; none for no mark.
-fn mark(body: &[u8]) -> Option<bool> {
+fn mark(body: &[u8]) -> Option<Edge> {
     let (&letter, rest) = body.split_first()?;
     if !rest.is_empty() && rest[0] != b';' {
         return None;
     }
     match letter {
-        b'A' | b'N' => Some(true),
+        b'A' | b'N' => Some(Edge::Prompt),
-        b'B' | b'I' | b'C' | b'D' => Some(false),
+        b'B' | b'I' => Some(Edge::Input),
+        b'C' | b'D' => Some(Edge::End),
         _ => None,
     }
 }
@@ -255,9 +280,13 @@ fn user(body: &[u8]) -> Option<(bool, &[u8])> {
     Some((opens, target))
 }
 
-/// A link to `target` whose id carries prompt `number`.
+/// A link to `target` whose id carries `part`'s prompt number.
-fn link(number: u32, target: &[u8]) -> Vec<u8> {
+fn link(part: Part, target: &[u8]) -> Vec<u8> {
-    let mut link = format!("\x1b]8;id={NUMBERED}{number};").into_bytes();
+    let id = match part {
+        Part::Prompt(number) => format!("{NUMBERED}{number}"),
+        Part::Input(number) => format!("{NUMBERED}{number}{TYPED}"),
+    };
+    let mut link = format!("\x1b]8;id={id};").into_bytes();
     link.extend_from_slice(target);
     link.push(0x07);
     link
@@ -271,34 +300,55 @@ fn plain(target: &[u8]) -> Vec<u8> {
     link
 }
 
-/// The number of the prompt `row` shows, as a link's id carries it.
+/// The prompt or input `cell` belongs to, as its link's id says.
-fn prompt(row: &Row<Cell>) -> Option<u32> {
+pub(super) fn part(cell: &Cell) -> Option<Part> {
-    row.into_iter().find_map(|cell| {
     let link = cell.hyperlink()?;
-        link.id().strip_prefix(NUMBERED)?.parse().ok()
+    let number = link.id().strip_prefix(NUMBERED)?;
+    match number.strip_suffix(TYPED) {
+        Some(typed) => typed.parse().ok().map(Part::Input),
+        None => number.parse().ok().map(Part::Prompt),
+    }
+}
+
+/// Whether `cell` belongs to a prompt.
+pub(super) fn prompted(cell: &Cell) -> bool {
+    matches!(part(cell), Some(Part::Prompt(_)))
+}
+
+/// The number of the prompt `row` shows.
+fn prompt(row: &Row<Cell>) -> Option<u32> {
+    row.into_iter().find_map(|cell| match part(cell) {
+        Some(Part::Prompt(number)) => Some(number),
+        _ => None,
     })
 }
 
+/// The first row of the nearest prompt at or above `line`, blank rows within it passed.
+pub(super) fn start<T>(term: &Term<T>, line: i32) -> Option<i32> {
+    let first = term.topmost_line().0;
+    let number = |line: i32| prompt(&term.grid()[Line(line)]);
+    // ponytail: a scan of the rows on the way; index prompt rows if long histories lag.
+    let (found, own) = (first..=line)
+        .rev()
+        .find_map(|line| number(line).map(|own| (line, own)))?;
+    let mut start = found;
+    for above in (first..found).rev() {
+        match number(above) {
+            Some(other) if other != own => break,
+            Some(_) => start = above,
+            None => {}
+        }
+    }
+    Some(start)
+}
+
 /// The display offset that puts the prompt before or after the view's top at the top, as Ghostty jumps.
 pub fn jump<T>(term: &Term<T>, up: bool) -> Option<usize> {
     let top = -(term.grid().display_offset() as i32);
     let (first, last) = (term.topmost_line().0, term.bottommost_line().0);
     let number = |line: i32| prompt(&term.grid()[Line(line)]);
-    // ponytail: a scan of the rows on the way; index prompt rows if long histories lag.
     let found = if up {
-        // The nearest prompt above the view's top, then its first row, blank rows within it passed.
+        start(term, top - 1)?
-        let (line, own) = (first..top)
-            .rev()
-            .find_map(|line| number(line).map(|own| (line, own)))?;
-        let mut start = line;
-        for above in (first..line).rev() {
-            match number(above) {
-                Some(other) if other != own => break,
-                Some(_) => start = above,
-                None => {}
-            }
-        }
-        start
     } else {
         // The prompt at or above the view's top may go on below it; the next one starts.
         let here = (first..=top).rev().find_map(number);

src/term/prompts/tests.rs

@@ -40,7 +40,12 @@ fn target_of(term: &Term<VoidListener>, line: i32, column: usize) -> Option<Stri
 fn a_mark_becomes_its_prompt_s_numbered_link() {
     assert_eq!(
         passed(&[b"\x1b]133;A\x07$ \x1b]133;B\x1b\\x"]),
-        b"\x1b]8;id=\x7f1;\x7f\x07$ \x1b]8;;\x07\x1b\\x"
+        b"\x1b]8;id=\x7f1;\x7f\x07$ \x1b]8;id=\x7f0i;\x7f\x07\x1b\\x"
+    );
+    assert_eq!(
+        passed(&[b"\x1b]133;A\x07$ \x1b]133;B\x07ls\x1b]133;C\x07out"]),
+        b"\x1b]8;id=\x7f1;\x7f\x07$ \x1b]8;id=\x7f0i;\x7f\x07ls\x1b]8;;\x07out",
+        "the input runs from B to C"
     );
     assert_eq!(
         passed(&[b"\x1b]133;A;k=i\x07\x1b]133;D;1\x18"]),
@@ -63,7 +68,11 @@ fn the_rewrite_reads_a_mark_as_the_session_hears_it() {
         "A", "A;k=i", "N", "B", "I", "C;x", "D;1", "D;abc", "D", "", "AB", "L", "P;k=i", "Q", "a",
     ];
     for body in bodies {
-        let heard = marks::read(body.as_bytes()).map(|mark| mark == Mark::Prompt);
+        let heard = marks::read(body.as_bytes()).map(|mark| match mark {
+            Mark::Prompt(_) => Edge::Prompt,
+            Mark::Input => Edge::Input,
+            Mark::Output | Mark::Done(_) => Edge::End,
+        });
         assert_eq!(mark(body.as_bytes()), heard, "{body}");
     }
 }
@@ -154,14 +163,11 @@ fn a_program_s_link_inside_a_prompt_carries_its_number() {
         &open.grid()[Line(0)][Column(1)],
         &open.grid()[Line(0)][Column(2)],
     );
-    assert!(
+    assert_eq!(part(z), Some(Part::Input(0)), "the input inside it");
-        z.hyperlink()
-            .is_some_and(|link| !link.id().starts_with(NUMBERED))
-    );
     assert_eq!(
         target_of(&open, 0, 2).as_deref(),
         Some("file:///x"),
-        "its own again past the prompt"
+        "its own target past the prompt"
     );
     assert!(
         y.hyperlink()
@@ -178,16 +184,12 @@ fn a_long_target_numbers_a_prompt_in_either_order() {
     for bytes in [before, inside] {
         let term = parsed(bytes.as_bytes(), 8, 2);
         let row = &term.grid()[Line(0)];
-        let numbered = |column: usize| {
-            row[Column(column)]
-                .hyperlink()
-                .is_some_and(|link| link.id().starts_with(NUMBERED))
-        };
         assert_eq!(prompt(row), Some(1), "{bytes:?}");
         assert!(
-            numbered(1) && !numbered(2),
+            prompted(&row[Column(1)]) && !prompted(&row[Column(2)]),
             "the prompt's cell alone: {bytes:?}"
         );
+        assert_eq!(part(&row[Column(2)]), Some(Part::Input(0)), "{bytes:?}");
         assert_eq!(target_of(&term, 0, 2).as_deref(), Some(target.as_str()));
     }
 }
@@ -215,7 +217,7 @@ fn controls_after_an_osc_s_closing_escape_run_where_vte_runs_them() {
 fn del_and_high_bytes_in_an_escape_go_on_after_it() {
     assert_eq!(
         passed(&[b"\x1b\x7f]133;A\x07$\x1b\xff", b"]133;B\x07"]),
-        b"\x1b\x7f]8;id=\x7f1;\x7f\x07$\x1b\xff]8;;\x07"
+        b"\x1b\x7f]8;id=\x7f1;\x7f\x07$\x1b\xff]8;id=\x7f0i;\x7f\x07"
     );
 }
 
@@ -228,7 +230,7 @@ fn controls_vte_runs_inside_an_escape_go_on_before_the_link() {
 }
 
 #[test]
-fn a_prompt_s_cells_carry_its_link_through_sgr_0_and_its_input_none() {
+fn a_prompt_s_cells_carry_its_link_through_sgr_0_and_its_input_its_own() {
     let term = parsed(
         b"x\r\n\x1b]133;A\x07\x1b[31m$\x1b[0m \x1b]133;B\x07ls",
         8,
@@ -237,7 +239,17 @@ fn a_prompt_s_cells_carry_its_link_through_sgr_0_and_its_input_none() {
     assert_eq!(prompt(&term.grid()[Line(0)]), None);
     assert_eq!(prompt(&term.grid()[Line(1)]), Some(1));
     assert_eq!(target_of(&term, 1, 1).as_deref(), Some(LINK));
-    assert_eq!(target_of(&term, 1, 2), None, "input");
+    assert_eq!(
+        part(&term.grid()[Line(1)][Column(2)]),
+        Some(Part::Input(0)),
+        "input"
+    );
+    let ran = parsed(
+        b"\x1b]133;A\x07$\x1b]133;B\x07ls\x1b]133;C\x07\r\nout",
+        8,
+        2,
+    );
+    assert_eq!(target_of(&ran, 1, 0), None, "output");
 }
 
 #[test]
@@ -329,3 +341,33 @@ fn a_prompt_keeps_its_start_through_a_resize() {
     let top = term.topmost_line().0 + first.expect("prompt 1") as i32;
     assert_eq!(offset as i32, -top);
 }
+
+#[test]
+fn input_carries_the_commands_ended_before_it() {
+    let line = b"\x1b]133;A\x07$\x1b]133;B\x07ab\x1b]133;A\x07R\x1b]133;B\x07c";
+    let term = parsed(line, 8, 2);
+    let at = |column: usize| part(&term.grid()[Line(0)][Column(column)]);
+    assert_eq!(
+        (at(0), at(1), at(3)),
+        (
+            Some(Part::Prompt(1)),
+            Some(Part::Input(0)),
+            Some(Part::Prompt(2))
+        )
+    );
+    assert_eq!(
+        at(4),
+        Some(Part::Input(0)),
+        "a prompt drawn again keeps the line"
+    );
+    let next = parsed(
+        b"\x1b]133;A\x07$\x1b]133;B\x07a\x1b]133;C\x07\x1b]133;D\x07\x1b]133;A\x07$\x1b]133;B\x07b",
+        8,
+        2,
+    );
+    assert_eq!(
+        part(&next.grid()[Line(0)][Column(3)]),
+        Some(Part::Input(2)),
+        "C and D each end it"
+    );
+}

src/term/pty.rs

@@ -11,7 +11,7 @@ use alacritty_terminal::{
 };
 use futures::channel::mpsc::{UnboundedReceiver, UnboundedSender, unbounded};
 
-use super::{marks::Mark, mouse::MouseMode, notify::Ask, status::Status, tap::Tapped};
+use super::{drop::Quote, marks::Mark, mouse::MouseMode, notify::Ask, status::Status, tap::Tapped};
 use crate::settings::{CursorStyle, Settings};
 
 /// What a session hears from its pty.
@@ -61,12 +61,15 @@ pub struct Launch {
     pub env: Vec<(String, String)>,
     /// Shell integration makes it report its folder.
     pub reports: bool,
+    /// How its shell reads a path dropped on it.
+    pub quote: Quote,
 }
 
 /// A running program on a pseudo-terminal and the grid it draws into.
 pub struct Pty {
     pub term: Arc<FairMutex<Term<Listener>>>,
     pub pid: u32,
+    pub quote: Quote,
     notifier: Notifier,
     #[cfg(unix)]
     master: std::fs::File,
@@ -152,6 +155,7 @@ pub fn spawn(
         Pty {
             term,
             pid,
+            quote: launch.quote,
             notifier,
             #[cfg(unix)]
             master,

src/term/pty/tests.rs

@@ -5,6 +5,7 @@ use alacritty_terminal::{
 use futures::StreamExt;
 
 use super::*;
+use crate::term::{drop::Quote, marks::Click};
 use crate::term::{
     notify::Ask,
     status::{Record, State},
@@ -34,6 +35,7 @@ fn run(script: &str, size: (usize, usize)) -> Ran {
         cwd: std::env::temp_dir(),
         env: vec![("ELY".into(), "ok".into())],
         reports: false,
+        quote: Quote::Posix,
     };
     let (pty, mut events) =
         spawn(&launch, size, (8, 16), config(&Settings::default())).expect("sh starts");
@@ -115,7 +117,12 @@ fn osc_133_reaches_the_session_as_marks() {
         "printf '\\033]133;A\\007>\\033]133;B\\007\\033]133;C\\033\\\\x\\033]133;D;3\\007'",
         (40, 4),
     );
-    let marks = [Mark::Prompt, Mark::Input, Mark::Output, Mark::Done(Some(3))];
+    let marks = [
+        Mark::Prompt(Click::Arrows),
+        Mark::Input,
+        Mark::Output,
+        Mark::Done(Some(3)),
+    ];
     assert_eq!(ran.marks, marks);
     assert_eq!(ran.text, ">x");
     assert_eq!(ran.prompt, [0], "the prompt's cell, not the output's");
@@ -235,6 +242,7 @@ fn the_foreground_is_the_program_s_own_group() {
         cwd: std::env::temp_dir(),
         env: Vec::new(),
         reports: false,
+        quote: Quote::Posix,
     };
     let (pty, _events) =
         spawn(&launch, (20, 4), (8, 16), config(&Settings::default())).expect("sh starts");
@@ -264,6 +272,7 @@ fn close_after_ready(script: &str, reaped: &str) {
         cwd: std::env::temp_dir(),
         env: Vec::new(),
         reports: false,
+        quote: Quote::Posix,
     };
     let (pty, mut events) =
         spawn(&launch, (20, 4), (8, 16), config(&Settings::default())).expect("sh starts");
@@ -310,6 +319,7 @@ fn a_missing_folder_stops_the_start() {
         cwd: "/nonexistent/ely".into(),
         env: Vec::new(),
         reports: false,
+        quote: Quote::Posix,
     };
     let error = spawn(&launch, (20, 4), (8, 16), config(&Settings::default()))
         .err()
@@ -328,6 +338,7 @@ fn a_folder_that_cannot_be_entered_stops_the_start() {
         cwd: folder.clone(),
         env: Vec::new(),
         reports: false,
+        quote: Quote::Posix,
     };
     let started = spawn(&launch, (20, 4), (8, 16), config(&Settings::default()));
     std::fs::set_permissions(&folder, std::fs::Permissions::from_mode(0o700)).expect("700");

src/term/shell.rs

@@ -7,7 +7,7 @@ use std::{
 use anyhow::Context as _;
 use gpui::{App, Global};
 
-use super::pty::Launch;
+use super::{drop::Quote, pty::Launch};
 
 /// Each script, by its path under the integration folder.
 const SCRIPTS: [(&str, &str); 4] = [
@@ -89,6 +89,11 @@ pub fn launch(shell: &str, cwd: PathBuf, dir: &Path) -> anyhow::Result<Launch> {
         cwd,
         env: Vec::new(),
         reports: true,
+        quote: match name.as_str() {
+            "pwsh" | "powershell" => Quote::PowerShell,
+            "cmd" => Quote::Cmd,
+            _ => Quote::Posix,
+        },
     };
     let script = |name: &str| dir.join(name).display().to_string();
     match name.as_str() {

src/term/shell/tests.rs

@@ -9,7 +9,11 @@ use futures::channel::mpsc::TryRecvError;
 use super::*;
 use crate::{
     settings::Settings,
-    term::{Events, Pty, PtyEvent, config, marks::Mark, spawn},
+    term::{
+        Events, Pty, PtyEvent, config,
+        marks::{Click, Mark},
+        spawn,
+    },
 };
 
 /// A folder name with a space, a percent, a bell and a newline.
@@ -146,9 +150,9 @@ impl Run {
 
     /// The prompt's folder, the script loaded by `probe`, then a cd into the inner folder.
     fn walk(&mut self, probe: &str) {
-        let first = [Mark::Prompt, Mark::Input];
+        let first = [Mark::Prompt(Click::Arrows), Mark::Input];
         self.until("the first prompt's marks", |run| {
-            run.marks.starts_with(&first)
+            run.marks.len() >= 2 && ends_like(&run.marks[..2], &first)
         });
         let start = self.start.clone();
         self.send(probe);
@@ -173,7 +177,7 @@ impl Run {
         let from = self.marks.len();
         self.send(line);
         self.until(&format!("the marks of {line}"), |run| {
-            run.marks[from..].ends_with(marks)
+            ends_like(&run.marks[from..], marks)
         });
     }
 
@@ -222,11 +226,22 @@ fn ended(status: i32) -> [Mark; 4] {
     [
         Mark::Output,
         Mark::Done(Some(status)),
-        Mark::Prompt,
+        Mark::Prompt(Click::Arrows),
         Mark::Input,
     ]
 }
 
+/// Whether `heard` ends as `wanted` does, a prompt's way of taking a click aside: fish from 4.1 takes clicks itself.
+fn ends_like(heard: &[Mark], wanted: &[Mark]) -> bool {
+    let Some(start) = heard.len().checked_sub(wanted.len()) else {
+        return false;
+    };
+    heard[start..].iter().zip(wanted).all(|pair| match pair {
+        (Mark::Prompt(_), Mark::Prompt(_)) => true,
+        (heard, wanted) => heard == wanted,
+    })
+}
+
 #[test]
 fn the_scripts_install_once_and_mend_a_changed_one() {
     let dir = folder("install");
@@ -289,7 +304,8 @@ fn zsh_says_why_it_marks_no_prompt_without_prompt_percent() {
     run.send("false");
     let ended = [Mark::Output, Mark::Done(Some(1))];
     run.until("the command's marks", |run| run.marks.ends_with(&ended));
-    assert!(!run.marks.contains(&Mark::Prompt), "{:?}", run.marks);
+    let prompted = run.marks.iter().any(|mark| matches!(mark, Mark::Prompt(_)));
+    assert!(!prompted, "{:?}", run.marks);
     run.finish();
 }
 
@@ -349,7 +365,7 @@ fn bash_says_why_it_marks_no_command_without_promptvars() {
         run.shows("ELYTerminal: bash marks no command while promptvars is off")
     });
     run.walk("declare -F _ely_prompt >/dev/null && echo ELY-LOAD''ED");
-    run.ends("false", &[Mark::Prompt, Mark::Input]);
+    run.ends("false", &[Mark::Prompt(Click::Arrows), Mark::Input]);
     run.finish();
 }
 
@@ -421,3 +437,24 @@ fn an_unknown_shell_starts_without_integration() {
     assert_eq!(launch.program, Some(("/bin/sh".into(), Vec::new())));
     assert!(launch.env.is_empty());
 }
+
+#[test]
+fn each_shell_reads_a_dropped_path_its_own_way() {
+    use std::os::unix::fs::PermissionsExt;
+    let dir = folder("quote");
+    for (name, quote) in [
+        ("zsh", Quote::Posix),
+        ("fish", Quote::Posix),
+        ("pwsh", Quote::PowerShell),
+        ("powershell", Quote::PowerShell),
+        ("cmd", Quote::Cmd),
+        ("other", Quote::Posix),
+    ] {
+        let program = dir.join(name);
+        fs::write(&program, "").expect("a program");
+        fs::set_permissions(&program, fs::Permissions::from_mode(0o755)).expect("its mode");
+        let shell = program.to_str().expect("utf-8");
+        let launch = launch(shell, PathBuf::from("/"), &dir).expect("a launch");
+        assert_eq!(launch.quote, quote, "{name}");
+    }
+}

src/term/view.rs

@@ -12,19 +12,20 @@ use ely_gpui_component::{
 };
 use futures::StreamExt;
 use gpui::{
-    Bounds, Context, EventEmitter, FocusHandle, Focusable, Font, FontFeatures, FontId, FontStyle,
+    Bounds, Context, EventEmitter, ExternalPaths, FocusHandle, Focusable, IntoElement, MouseButton,
-    FontWeight, IntoElement, MouseButton, ParentElement, Pixels, Render, Styled, Subscription,
+    ParentElement, Pixels, Render, Styled, Subscription, Task, Window, div, prelude::*, px,
-    Task, TextSystem, Window, div, prelude::*, px, size,
 };
 
 use super::{
+    click::Shell,
     find::Finder,
+    fonts::look,
     frame::frame,
     ink::Ink,
     input::{self, Find, Held, NextPrompt, PreviousPrompt},
     marks::Mark,
     mouse::MouseMode,
-    paint::{self, Look},
+    paint,
     pointer::Pointer,
     pty::{Events, Pty, PtyEvent, config, fit},
     reports::Notices,
@@ -32,16 +33,7 @@ use super::{
     status::{Records, State},
     zoom,
 };
-use crate::{
+use crate::{settings::SettingsStore, themes};
-    settings::{Settings, SettingsStore},
-    themes,
-};
-
-/// The bundled Nerd Font that draws icons any font lacks; gpui loads no font without an `m`.
-pub const ICONS: &str = "JetBrainsMono Nerd Font Mono";
-
-/// The bundled code font, the default.
-pub const MONO: &str = "JetBrains Mono";
 
 /// How long the cursor shows, then hides, while it blinks.
 pub const BLINK: Duration = Duration::from_millis(600);
@@ -85,6 +77,8 @@ pub struct TerminalView {
     pub(super) ended: Option<i32>,
     /// A command started, as OSC 133 C says, since the last one ended.
     pub(super) ran: bool,
+    /// Where the shell stands, as its OSC 133 marks say.
+    pub(super) shell: Shell,
     /// The system notifications it posted.
     pub(super) notices: Notices,
     /// The program's title; empty while it names none.
@@ -146,6 +140,7 @@ impl TerminalView {
             records: Records::default(),
             ended: None,
             ran: false,
+            shell: Shell::Busy,
             notices: Notices::default(),
             title: String::new(),
             front: true,
@@ -273,12 +268,13 @@ impl TerminalView {
                 PtyEvent::Win32(on) => self.win32 = on,
                 PtyEvent::Mark(Mark::Done(status)) => self.finished(status, cx),
                 // A new prompt ends what was working, waiting or idle; done and error stay.
-                PtyEvent::Mark(Mark::Prompt) => {
+                PtyEvent::Mark(Mark::Prompt(click)) => {
+                    self.shell = Shell::Prompting(click);
                     self.records.prompt();
                     self.restate(cx);
                 }
-                PtyEvent::Mark(Mark::Output) => self.ran = true,
+                PtyEvent::Mark(Mark::Output) => (self.ran, self.shell) = (true, Shell::Busy),
-                PtyEvent::Mark(_) => {}
+                PtyEvent::Mark(Mark::Input) => self.shell = self.shell.reads(),
                 PtyEvent::Status(status) => {
                     self.status(status);
                     self.restate(cx);
@@ -344,65 +340,6 @@ impl TerminalView {
     }
 }
 
-/// `font` as gpui loads it; gpui falls back to another font without a word, and loads none without an `m`.
-pub fn load_font(font: &Font, system: &TextSystem) -> anyhow::Result<FontId> {
-    let id = system.resolve_font(font);
-    let loaded = system.get_font_for_id(id);
-    anyhow::ensure!(
-        loaded.is_some_and(|loaded| loaded.family == font.family),
-        "font_family is {:?}, which the terminal cannot load",
-        font.family
-    );
-    Ok(id)
-}
-
-/// Font, cell and metrics at `points` on this window.
-fn look(settings: &Settings, points: f32, ink: &Ink, window: &Window) -> anyhow::Result<Look> {
-    let font = Font {
-        family: settings.font_family.clone().into(),
-        features: if settings.ligatures {
-            FontFeatures::default()
-        } else {
-            FontFeatures::disable_ligatures()
-        },
-        fallbacks: None,
-        weight: FontWeight::NORMAL,
-        style: FontStyle::Normal,
-    };
-    let text = px(points);
-    let system = window.text_system();
-    let id = load_font(&font, system)?;
-    let advance = system
-        .advance(id, text, 'M')
-        .map_err(|error| anyhow::anyhow!("{} cannot measure M: {error}", settings.font_family))?;
-    let scale = window.scale_factor();
-    let snap = |length: Pixels| px((f32::from(length) * scale).round() / scale);
-    let cell = size(
-        snap(advance.width).max(px(1.)),
-        snap(text * settings.line_height),
-    );
-    let (ascent, descent) = (system.ascent(id, text), system.descent(id, text).abs());
-    let icons = Font {
-        family: ICONS.into(),
-        features: FontFeatures::default(),
-        ..font.clone()
-    };
-    Ok(Look {
-        font_id: id,
-        icons,
-        baseline: (cell.height - ascent - descent) / 2. + ascent,
-        descent,
-        rule: snap((text / 14.).max(px(1.))),
-        size: text,
-        cell,
-        font,
-        cursor: ink.cursor,
-        cursor_text: ink.cursor_text,
-        fg: ink.fg,
-        bg: ink.bg,
-    })
-}
-
 impl Render for TerminalView {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let settings = SettingsStore::get(cx).clone();
@@ -449,6 +386,7 @@ impl Render for TerminalView {
             .on_any_mouse_down(cx.listener(Self::mouse_down))
             .on_mouse_move(cx.listener(Self::mouse_move))
             .on_scroll_wheel(cx.listener(Self::wheel))
+            .on_drop(cx.listener(|view, paths: &ExternalPaths, _, cx| view.drop_paths(paths, cx)))
             .size_full()
             .px(px(settings.padding_x))
             .py(px(settings.padding_y))

src/updates.rs

@@ -1,4 +1,4 @@
-//! Checks for a newer release through curl and Gitea's API: at start and once a day while the settings ask, and whenever Settings asks at once.
+//! Checks for a newer release through curl and GitHub's API: at start and once a day while the settings ask, and whenever Settings asks at once.
 
 use std::{
     process::{Command, Stdio},
@@ -12,8 +12,7 @@ use serde::Deserialize;
 use crate::{settings::SettingsStore, workspace::TITLE};
 
 /// The latest published release.
-const LATEST: &str =
+const LATEST: &str = "https://api.github.com/repos/ELY-Open-Source/ELYTerminal/releases/latest";
-    "https://git.zacharyzhang.com/api/v1/repos/ZacharyZhang-NY/ELYTerminal/releases/latest";
 /// How long an automatic check waits for the next.
 const DAY: Duration = Duration::from_secs(24 * 60 * 60);
 /// The tag a newer release's notification carries.
@@ -115,7 +114,7 @@ pub fn pressed(tag: &str, cx: &mut App) -> bool {
     true
 }
 
-/// The latest release, which curl fetches from Gitea's API.
+/// The latest release, which curl fetches from GitHub's API.
 fn latest() -> anyhow::Result<Release> {
     let mut command = Command::new("curl");
     #[cfg(windows)]
@@ -198,8 +197,8 @@ mod tests {
     }
 
     #[test]
-    fn gitea_s_release_reads() {
+    fn github_s_release_reads() {
-        let body = r#"{"id":213,"tag_name":"v0.1.5","name":"ELYTerminal 0.1.5","html_url":"https://git.zacharyzhang.com/ZacharyZhang-NY/ELYTerminal/releases/tag/v0.1.5","draft":false,"assets":[]}"#;
+        let body = r#"{"id":213,"tag_name":"v0.1.5","name":"ELYTerminal 0.1.5","html_url":"https://github.com/ELY-Open-Source/ELYTerminal/releases/tag/v0.1.5","draft":false,"assets":[]}"#;
         let release: Release = serde_json::from_str(body).expect("a release");
         assert_eq!(release.tag_name, "v0.1.5");
         assert!(release.html_url.ends_with("/releases/tag/v0.1.5"));

src/workspace.rs

@@ -29,6 +29,7 @@ use crate::{
 };
 
 mod events;
+mod rename;
 mod widths;
 
 use widths::{Dragged, Side};
@@ -156,6 +157,8 @@ impl Workspace {
         self.sessions.push(Session {
             terminal,
             title: String::new(),
+            name: String::new(),
+            editing: None,
             folder: launch.cwd,
             reports: launch.reports,
             bell: false,
@@ -268,13 +271,9 @@ impl Workspace {
         &self.sessions
     }
 
-    /// The shown session's title, or the app's name while its program names none.
+    /// What the shown session is called.
     fn title(&self) -> &str {
-        self.sessions
+        self.sessions.get(self.active).map_or(TITLE, Session::named)
-            .get(self.active)
-            .map(|session| session.title.as_str())
-            .filter(|title| !title.is_empty())
-            .unwrap_or(TITLE)
     }
 
     fn retitle(&self, window: &mut Window) {

src/workspace/events.rs

@@ -21,7 +21,10 @@ impl Workspace {
         };
         let session = &mut self.sessions[index];
         match event {
-            TerminalEvent::Title(title) => session.title.clone_from(title),
+            TerminalEvent::Title(title) => {
+                log::debug!("app: session {}'s program names it {title:?}", index + 1);
+                session.title.clone_from(title);
+            }
             TerminalEvent::Folder(folder) => {
                 session.folder.clone_from(folder);
                 session.reports = true;

src/workspace/rename.rs

@@ -0,0 +1,77 @@
+//! A session renamed in place, as a double-click on its row asks.
+
+use ely_gpui_component::forms::{InputEvent, TextInput};
+use gpui::{AppContext, Context, EntityId, Focusable, Window};
+
+use super::Workspace;
+
+impl Workspace {
+    /// Opens a field over session `index`'s title, what it is called selected.
+    pub fn rename(&mut self, index: usize, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(session) = self.sessions.get(index) else {
+            return;
+        };
+        if session.editing.is_some() {
+            return;
+        }
+        let named = session.named().to_string();
+        let id = session.terminal.entity_id();
+        let input = cx.new(|cx| {
+            let mut input = TextInput::new(window, cx);
+            input.set_text(named.clone(), cx);
+            input.select(0..named.len(), cx);
+            input
+        });
+        let events = cx.subscribe_in(
+            &input,
+            window,
+            move |this, _, event, window, cx| match event {
+                InputEvent::Submit | InputEvent::Blur => this.end_rename(id, true, window, cx),
+                InputEvent::Changed | InputEvent::Focus => {}
+            },
+        );
+        window.focus(&input.focus_handle(cx), cx);
+        log::debug!("app: session {} is renamed in place", index + 1);
+        self.sessions[index].editing = Some((input, events));
+        cx.notify();
+    }
+
+    /// Closes the field renaming the session `id` names, `keep`ing what it holds or not; a focus it still holds goes to the shown terminal.
+    pub fn end_rename(
+        &mut self,
+        id: EntityId,
+        keep: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(session) = self
+            .sessions
+            .iter_mut()
+            .find(|session| session.terminal.entity_id() == id)
+        else {
+            log::debug!("app: the session renamed is gone");
+            return;
+        };
+        let Some((input, _)) = session.editing.take() else {
+            return;
+        };
+        let pid = session.terminal.read(cx).pid();
+        // A window that goes inactive blurs the field yet keeps its focus there.
+        let held = input.focus_handle(cx).is_focused(window);
+        if !keep {
+            log::debug!("app: session {pid} keeps its name");
+        } else {
+            session.name = input.read(cx).text().trim().to_string();
+            if session.name.is_empty() {
+                log::info!("app: session {pid} takes its program's title again");
+            } else {
+                log::info!("app: session {pid} is named {:?}", session.name);
+            }
+        }
+        if held && let Some(shown) = self.sessions.get(self.active) {
+            window.focus(&shown.terminal.focus_handle(cx), cx);
+        }
+        self.retitle(window);
+        cx.notify();
+    }
+}

tasks/acceptance.md

@@ -23,7 +23,7 @@ What no check reached: no real KWin drew the blur; of Wayland desktops, only Hyp
 | Ely by pinned rev; gpui and gpui_platform from `gpui-pre` at Ely's version | T01 | `Cargo.toml`: Ely `a2cb531`, `gpui-pre` `=0.3.8` | Pass |
 | `alacritty_terminal` 0.26 | T04 | `=0.26.0` | Pass |
 | Logs through `log` to stderr, `RUST_LOG` sets the level, no log setting | T01 | `src/main.rs`; no such field in `Settings` | Pass |
-| CI on Gitea Actions: macOS builds, tests and lints; Ubuntu and Windows build and test | T01, T23 | `.github/workflows/ci.yml`; run 926 on `65bb4d3`, see the CI notes | Pass |
+| CI on GitHub Actions: macOS builds, tests and lints; Ubuntu and Windows build and test | T01, T23 | `.github/workflows/ci.yml`; run 926 on `65bb4d3`, see the CI notes | Pass |
 | The repo, private until v0.1.1 and public since; no credential in any file or commit | T01, T26 | T22's review scanned the tree and its 398 reachable objects: 0 hits; T23's scans for the Gitea token and the runners' SSH details: 0 hits; before the owner made it public, a scan of all 91 commits' contents and messages found no token, SSH password, gateway, port, SSH user or private key | Pass |
 
 ## 3. Settings model and storage
@@ -63,6 +63,8 @@ What no check reached: no real KWin drew the blur; of Wayland desktops, only Hyp
 | Colors, styles, five underlines, wide characters, combining marks | T06 | `term::frame`, `term::ink`, `term::paint` tests | Pass |
 | Box drawing, blocks and powerline shapes as geometry | T07 | `term::boxes` tests | Pass |
 | JetBrains Mono, any installed font, Nerd Font icons | T06, T17 | `tests/fonts.rs` | Pass |
+| Rename: a double press on a row's title opens a field; Enter keeps the name, Escape drops it, a blur keeps it; the name shows in the row, the header and the window's title over the program's own; an empty one gives the title back | T63 | Ely test: `ListItem::editor` draws its field in the row, above the description; on macOS `shot` over a program titled `prog`: a double press on the row opened a field holding `prog`, selected; `Build box` and Enter showed it in the row, the header and the window's title, `app: session … is named "Build box"`, and the focus came back to the terminal; the program's later title `prog2`, logged four seconds after, left the window's title `Build box`; Escape logged `keeps its name` and left `prog2`; a blur from a press on the terminal while the app was active kept `Blurred`; emptied, the field gave the title back, `takes its program's title again`; a second session's rename named that row alone; round 1 of T63's review found that leaving the app mid-rename closed the field while the window's focus still pointed at it, so back in the app the terminal heard no key until pressed: the terminal now takes a focus the field still holds as it closes, and after the same steps `a` reached the program at once, as it did after Enter, Escape and a blur by a press on the terminal | Pass |
+| Fallback fonts: installed families tried in order for a character the family lacks, listed under Family in Settings › Appearance | T60 | `settings` test: a file without `font_fallbacks` loads with none, named families keep their order, and an empty one is refused; on macOS with Menlo and `"font_fallbacks": ["Kaiti SC"]` the terminal drew `中文字体 終端` in Kaiti and Latin in Menlo, where without it the system drew them in PingFang; a fallback gpui cannot load, `No Such Font`, stopped the start with `font_fallbacks: the terminal cannot load "No Such Font"`, and an empty one with `font_fallbacks holds an empty family`; in Settings › Appearance, Add fallback opened an empty picker, picking Kaiti SC saved `["Kaiti SC"]` and the terminal took it at once, the row's X saved `[]`, and Apple Color Emoji, which gpui loads no font for, was refused and nothing saved; round 1 of T60's review found that removing the row whose input held the focus left the removed family in it, and Enter saved it over the next: a removal drops that row's input and the focus, so after removing Kaiti SC from `[Kaiti SC, Songti SC, PingFang SC]` with its input focused the rows showed Songti SC and PingFang SC and Enter saved nothing new; round 2 found the pickers keyed by place, so after that removal a blur wrote PingFang SC into the first row and Enter saved it twice: each picker is keyed by its input, and the same removal, a click, the app activated and deactivated, and Enter, which in the build before saved `[PingFang SC, PingFang SC]`, kept `[Songti SC, PingFang SC]`; on Linux, gpui's cosmic-text path carries a character a second fallback took into the next, as AGENTS records | Pass |
 | Cursor shapes, blink by setting and DECSCUSR, hollow unfocused | T06 | T06 review | Pass |
 | xterm keys, cursor mode, Option as Alt, kitty protocol, keypad; a shifted symbol as its own key with Shift on macOS and Windows; win32-input-mode on Windows | T08, T44 | `term::keys` tests, `kitty_reports_the_key_shift_turned_into_a_symbol` red at `CSI 123;13u` before the fix; on macOS herdr 0.9.5, its `[keys]` `previous_workspace = "cmd+shift+ctrl+["` and `next_workspace = "cmd+shift+ctrl+]"`, run by `shot` in a fresh HOME: before, ⌘⇧⌃] sent `CSI 125;13u` and herdr stayed on its workspace; after, `CSI 93:125;14u` moved it to the next and ⌘⇧⌃[, `CSI 91:123;14u`, back; `term::win32` and `term::tap` tests on Windows | Pass |
 | IME: marked text at the cursor, commits to the program | T08 | T08 review | Pass |
@@ -71,6 +73,10 @@ What no check reached: no real KWin drew the blur; of Wayland desktops, only Hyp
 | OSC 8 and plain links on Cmd-press, Ctrl-press off macOS; inside herdr, herdr opens them whole | T09, T45 | `term::links` tests; on macOS with real herdr 0.9.5 and a stand-in `open` on its PATH, Cmd-press on a URL herdr wraps, on its wrapped tail, on an OSC 8 link and on a URL over three rows opened the whole URL and the OSC 8 target, where before the app opened `.../ELYTermin` and nothing; Cmd-hover underlined the long URL across its rows; outside herdr the app opened the URL itself; an OSC 8 link whose label holds `file:///etc/hosts` and whose target is a web page opened the page through herdr, which keeps the target from the terminal while it takes the mouse; Shift-Cmd-press on a plain `file:///etc/hosts` inside herdr the app opened itself, caught by an `NSWorkspace` stand-in | Pass |
 | Focus reporting, title, scrollback limit, find | T10 | `term::find` tests; round 3 failed at the cap, its fix stands on a red-green test | Pass |
 | A scrollbar over the history: a drag on its thumb scrolls, whatever the program does with the wheel | T58 | `term::scrollbar` test: the thumb's share and place follow the history and the view's offset, and a place past either end of the track holds at it; under Xorg's dummy screen, after `seq 1 500`, the thumb stood at the bottom right, a drag to the top showed the first prompt and lines 1 to 39, and one back down lines 220 to 259; with mouse tracking on, the wheel went to the program as reports and did not scroll, while a drag on the thumb showed lines 245 to 284 | Pass |
+| Windows 10: dragging a blurred window follows the pointer, its acrylic clear while it moves | T65 | on the owner's Windows 11 PC (build 26300) the release path logged `blur: Windows build 26300 moves acrylic as it is`; a probe build with the build check raised logged `acrylic clears while the window moves`, and a drag by the terminal's header moved the window 180 by 90 pixels, logged `the window moves clear` and `the window rests blurred again`, and pictured clear glass mid-drag and acrylic at rest; round 1 of T65's review found that blur turned on mid-move, which gpui sets as acrylic at once, kept acrylic for the rest of the move: a moving mark now clears it again, and the reviewer's replay of the procedure and the blur's changes against recorded Win32 calls passed its 9 cases, a blur turned on and on again mid-move among them; the drag on the PC logged both switches again; Windows 10 went untested | Pass |
+| IME on Windows: the candidate box at the caret | T61 | on the owner's Windows 11 PC at 150%, WeType under powershell.exe: 23 compositions, on one line, on lines below, begun again at once after a commit, and under a status line redrawn every 100 ms, each logged `the input method asks for the caret` at the cursor's cell and drew the box under it; the user's jump did not reproduce and the owner closed it | Closed |
+| Drop: files dropped on the terminal type their paths at the cursor, kept literal for the session's shell, each followed by a space | T66 | `term::drop` tests: a POSIX path escapes what a shell reads specially, spaces, quotes, parentheses, `&`, `$`, `^`, `~` and `#` among them, CJK kept, each path followed by a space; a PowerShell path is single-quoted with its quotes doubled, curly ones too; a cmd path is double-quoted, and one holding `%` types nothing; a path with a control character types nothing; `term::shell` test: zsh, fish and other shells take POSIX quoting, pwsh and powershell PowerShell's, cmd cmd's; round 1 of T66's review found Windows' quotes around a spaced path alone leaving `$(...)` and `;` live in PowerShell, and `^` unescaped under zsh's `extendedglob`: the formatter, extracted, typed 22 hard names that zsh with and without `extendedglob`, bash with `extglob`, fish and PowerShell each read back exactly, `it's`, `$HOME`, `$(1+1)`, `a;Write-Output(42)` and curly quotes among them, and cmd on the owner's PC echoed `&`, `|`, `<`, `>` and `^` inside its quotes back as text while it expanded `%PATH%`; round 2 found cmd's `/v:on` expanding `!` inside quotes, and `"C:\"` read by a program as one argument with the next: a `!` now stops a cmd drop, and the backslashes ending a path are doubled, so node, run from a cmd batch line on the owner's PC, received `C:\`, `D:\clip.mp4`, `C:\My Files\a&b^c.txt`, `C:\x|y<z>(1).txt`, `C:\dir with space\` and `C:\tmp\a;b,c=d.txt` exactly; on macOS `shot` dropped `/tmp/my file.png`, `/Users/x/it's (1).txt` and `/a/中文 b` on zsh after a pointer move, and the log read `3 paths dropped` and `pastes 53 characters, bracketed`; without the move, after typing, gpui passed the drop by, as AGENTS records | Pass |
+| Click to move: a plain click on the line the shell reads, past its prompt, moves its cursor there, the press itself to a shell that takes clicks, else arrows | T59 | `term::marks` test: A's `click_events=1` and `2` read as a press at the screen's row or counted from the prompt; `term::click` tests: a shell that takes clicks hears an SGR left press at the clicked cell, a row below the prompt too, none before the prompt, in the history or on the alternate screen; B reads the line its prompt started; a click on the typed line counts the characters to it, left or right, past the end means the end, a wide character takes one arrow, soft-wrapped rows are one line, trailing spaces count up to the cursor, and a click on the prompt, another line, a line no prompt shows, output without marks or the alternate screen moves nothing; on macOS `shot` ran zsh with a marked prompt: after `echo hello` a click on the `h` logged `moves the cursor -5`, and `X` typed then ran `echo Xhello`; a drag sent nothing, and clicks on the prompt and on output logged `off the input`; round 1 of T59's review found fish 4.9 a code point per Left, so a count put `X` inside `é`, and its redraw dropped the wrap flag a count followed: with fish's own `click_events=1` the press goes to fish, which then typed `echo Xéabc`, and a second click on the redrawn wrapped line put `Y` at row 2, column 3; zsh still counted 4 arrows; a press let go in another cell and one whose program turned on tracking before the release sent nothing; round 2 found a click on fish's `$` sent to fish, which moved its cursor to the start: a press now goes only past the prompt's last cell before the cursor and never on a prompt cell, so clicks on `$` and its space logged `off the input` and `X` still ended `echo helloX`; round 3 found that a prompt whose only cells lie after the cursor, fish's empty left prompt beside a marked right one, crashed the press: with no prompt cell before the cursor the input starts at the prompt's first row, and a click on `o` there put `X` at `echXo`; round 3 found that a prompt that prints nothing left no cells to find the input by, so clicks on fish's typed line did nothing: B now stamps the typed line with a link of its own, numbered by the commands ended, so fish's empty prompt gave `abcXdef`, with a plain or no right prompt too, a click on the output above moved nothing, and fish's right prompt drawn again at each key kept the typed line's number, `echXo`; `term::prompts` test: input carries the commands ended before it, through a prompt drawn again; `term::click` tests: a prompt that prints nothing starts the input at its first typed cell, the output and the line run before refused; round 4 found the newest typed line taken by its place: after `printf '\e[H'` fish drew its prompt at the top over older lines, and a click on its typed line did nothing; the newest line is now the one of the highest number, and a press goes no lower than its last row or the cursor's, so that click gave `abcXdef`, the reviewer's scene sent `ESC[<0;6;1M`, and a click on the older text below moved nothing, where fish had moved its cursor | Pass |
 | A bell makes no sound; the row marks it | T10, T12 | T12 review | Pass |
 
 ## 6. Main window and layout
@@ -86,6 +92,7 @@ What no check reached: no real KWin drew the blur; of Wayland desktops, only Hyp
 | The title bar is transparent | T11, T19 | T19 review | Pass |
 | Every title bar control takes its press, Ely's window buttons on Windows and Linux too | T26 | Ely `cdc5ce8`: `window_controls_occlude_what_lies_under` (each style; before, the box under Windows' caption buttons took the press), `a_wobbling_press_on_a_slot_moves_no_window` (before, the window moved), `a_wobbling_press_on_a_column_title_moves_the_window`; on the owner's PC, window messages asked the app for Windows' hit test along the title bar: v0.1.0 answered caption from end to end, T26's build answers client over the toggles and +, caption over the titles, min, max and close over Ely's buttons, and a press on close closed the app; the owner, given v0.1.1's build and these controls to click, reported it works on Windows | Pass |
 | Ely peeks over the window's top edge from behind it, or stands inside at its bottom left where no room lies above it; her face follows the sessions; a press pets her and wakes her from a doze; nothing but her shows; a drag moves her along her edge | T46, T48, T49, T51, T52, T53, T55 | `pet::look` tests: the most pressing mark sets her mood; she moves in every mood, weeks into one too; she blinks on her own, twice at times, her eyes opening as an act begins; calm glances, then dozes with zs; a finish cheers her with a hop; work runs her eyes along the lines and taps her fingers; a wait widens her eyes and hops her twice a round; an error shakes her and runs a drop down; a press winks with a rising heart; she rises from behind the edge; a change of act eases her from her last pose, her brows easing and the marks she leaves fading; `pet` tests: a mood that changes inside a wink, an old finish cleared mid-glance and a second press mid-hop each ease her from where she was, where round 1 of T49's review found her drop 12 points; `pet::rig` tests: every layer of the icon's paths parses and stays in its box, and every mark has its layer; on macOS `shot`'s snaps, 40 in 10 s while calm, caught her breathing, blinking and glancing, and two a second apart in each mood caught her reading along, rocking her mark, fretting with her drop, cheering, and easing back to calm; `pet::x11` test under Xvfb: her window stands on the pane, just above the window manager's frame, and unmaps and maps with the main window; on macOS `shot` found her the main window's child, 112 by 124 points on its top edge 140 in, a capture of the screen showed her over the edge, and OSC 7501 reports gave her surprise, worry, eyes down and a cheer; a press on her window left the main window key and every key typed before and after it reached the program; switched off and on during an error she came back worried; on a 100-point window she stood at its left edge, and moved, resized and minimized she followed it; on Windows the `pet::windows` test, red before T48, finds the framed popup Windows makes, 1898 by 1481, bare in her own box, 168 by 185 at 150%, on the pane's top edge, and no size until her window takes the place posted to it; `pet::windows` tests, red before T48's second round: with the main window at 1, 1.5 or 2 and hers at 1, 1.25 or 1.5, her height is her own and her bottom the pane's top, where it fell 62 pixels into the terminal, and at a new DPI gpui takes the rect Windows suggests, then her box comes back on her corner, or Windows' rect stands where that box would lie on a display of another DPI; two displays side by side at 144 and 96 DPI, simulated, settle her after one change, where a corner kept always, red before T48's third round, changed her DPI back and forth; and two places piled up before either ran drain on the last corner in her DPI's size, where a keep whose DPI had passed, red before T48's fourth change, set it back and forth, and where a place sized when it was posted left her 112 by 123 at 144 DPI, red before its fifth; on a Windows 11 VM at 150%, with the main window 49 pixels from the screen's top, 0.1.4 opened her 2326 by 1654 with a caption, drawn at its bottom over the terminal, and a press inside the terminal went to her; T48's build opened her 168 by 185 without one, on the edge, the press went to the terminal, one beside her box to the program behind, and one on her to her; with the window mid-screen she showed whole on its edge; T51: `pet` tests: she stands on the top edge while her box fits above the pane, 123.4 points, else the bottom; on macOS 0.1.4 opened her, over a window under the menu bar, at 1081 to 1205, inside its top, as the owner saw, and T51 at its bottom edge, 92, 140 in, and over a centered window still on its top edge, 1028; the `pet::windows` tests on the owner's PC put her on the top edge 400 pixels down the work area and on the bottom edge at its top, and there the release build stood her on the top edge of a centered window, on the bottom edge of one moved to the work area's top and of a maximized one, 210 pixels in at 150%, and on the top edge again once it came back; the `pet::x11` test under Xvfb puts her on the bottom edge once `_NET_WORKAREA` leaves no room; on WSLg's X11 she stood over a window with room and inside one as tall as the screen; on WSLg's Wayland, Weston, her popup stood on the pane's top edge and, once the window was maximized, opened again on its bottom edge, at its bottom left; under Xorg with two monitors she moved to the bottom edge of a window at the lower one's top, 112x123+240+1277, and of one held mostly by a staggered monitor at its top, 112x123+1240+877; under headless Sway her anchor went (140, 0) on the top edge, then (140, 999), (140, 799) and (140, 999) on the bottom edge as the window went full screen and the output 800 and 1000 high, and full screen at the same size moved her too; T52: the `pet::look` test wakes her from a doze 400 s into calm with a preLine truncated
+| Ely's hop lifts more of her from behind the edge, never her body off it | T62 | `pet::rig` test: over every mood, 2.6 s of each and a press at each point of a hop, her highest lift, above 40 units, leaves the shirt and back hair below the edge; red with the shapes before; on macOS 24 snaps of her window waiting on the user, two hops a round, found the bottom row of her box opaque across its middle in every one, the highest 14 pixels from its top, where the build before, at the same height, showed that row clear across its width | Pass |
 
 ## 7. Sessions panel
 
@@ -162,16 +169,16 @@ What no check reached: no real KWin drew the blur; of Wayland desktops, only Hyp
 |---|---|---|---|
 | The icon: Ely, a girl with long pink hair, holding a terminal | T24 | `assets/icons`, drawn at 16 to 1024 px and legible at 32; the owner saw it | Pass |
 | macOS: the rounded square; Windows and Linux: the figure alone, flat | T24 | `elyterminal-macos.svg` on Apple's grid; `elyterminal.svg`, which the Linux tarball carries and the Windows `.ico` renders | Pass |
-| `scripts/mac-app.sh` builds the app, signed ad hoc, or for a release with Developer ID and notarized, and its disk image | T24, T26, T31, T41, T43, T47, T50, T54 | its run: `codesign --verify --strict` passes on the app and on its copy in the image; the `.icns` holds 16 to 1024 px; the image verifies and mounts with the app beside Applications; LaunchServices opens the app as `com.zacharyzhang.elyterminal`; for v0.1.1 the Release workflow (run 959) ran it on `macos-signing`: notarization Accepted, the ticket stapled, and on this Mac the downloaded image and its app pass `codesign --verify --strict` under the Developer ID and Gatekeeper's `accepted, source=Notarized Developer ID`; the owner opened it; for v0.1.2 the Release workflow (run 1001) ran it again: the downloaded image's stapled ticket validates and Gatekeeper accepts it as `Notarized Developer ID`, and its app, version 0.1.2, passes `codesign --verify --strict --deep` under the Developer ID with the hardened runtime and is accepted the same way; for v0.1.3 the Release workflow (run 1157) ran it again, and its image and app, version 0.1.3, check the same way, as does the image rebuilt for T43 (run 1181); for v0.1.4 the Release workflow (run 1216) ran it again, and its image and app, version 0.1.4, for macOS 11.0 or later, check the same way, as does the image rebuilt for T50 (run 1256); without the key the script stops before building; v0.1.5's disk image, from the Release workflow (run 1312) at `0119776`: its stapled ticket validates, Gatekeeper accepts the image and the app inside as notarized Developer ID, the app passes `codesign --verify --strict --deep` and reads 0.1.5, macOS 11.0, arm64, beside a link to Applications | Pass |
+| `scripts/mac-app.sh` builds the app, signed ad hoc, or for a release with Developer ID and notarized, and its disk image | T24, T26, T31, T41, T43, T47, T50, T54, T57 | its run: `codesign --verify --strict` passes on the app and on its copy in the image; the `.icns` holds 16 to 1024 px; the image verifies and mounts with the app beside Applications; LaunchServices opens the app as `com.zacharyzhang.elyterminal`; for v0.1.1 the Release workflow (run 959) ran it on `macos-signing`: notarization Accepted, the ticket stapled, and on this Mac the downloaded image and its app pass `codesign --verify --strict` under the Developer ID and Gatekeeper's `accepted, source=Notarized Developer ID`; the owner opened it; for v0.1.2 the Release workflow (run 1001) ran it again: the downloaded image's stapled ticket validates and Gatekeeper accepts it as `Notarized Developer ID`, and its app, version 0.1.2, passes `codesign --verify --strict --deep` under the Developer ID with the hardened runtime and is accepted the same way; for v0.1.3 the Release workflow (run 1157) ran it again, and its image and app, version 0.1.3, check the same way, as does the image rebuilt for T43 (run 1181); for v0.1.4 the Release workflow (run 1216) ran it again, and its image and app, version 0.1.4, for macOS 11.0 or later, check the same way, as does the image rebuilt for T50 (run 1256); without the key the script stops before building; v0.1.5's disk image, from the Release workflow (run 1312) at `0119776`: its stapled ticket validates, Gatekeeper accepts the image and the app inside as notarized Developer ID, the app passes `codesign --verify --strict --deep` and reads 0.1.5, macOS 11.0, arm64, beside a link to Applications; v0.1.6's disk image, from the Release workflow (run 1343) at `8a9941b`: its stapled ticket validates, Gatekeeper accepts the image and the app inside as notarized Developer ID, the app passes `codesign --verify --strict --deep` and reads 0.1.6, macOS 11.0, arm64 | Pass |
 
 ## 15. Release
 
 | PRD line | Task | Evidence | Status |
 |---|---|---|---|
-| A Gitea release, `vVERSION`, with the macOS disk image, a Windows zip and a Linux tarball | T25, T26, T27, T31, T41, T43, T47, T50, T54 | `v0.1.5` at `0119776`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1312), signed and notarized; published once CI run 1311 on that commit passed on macOS, Ubuntu and Windows; each file downloaded back anonymously matches the SHA-256 in the release notes; each binary holds T51's `Ely moves to the pane's` and the failed glue's line, the disk image T53's `her panel drops its titled frame` and the tarball the monitors' line; the downloaded app, run with a HOME of its own, logged her panel going borderless, 0x8081 to 0x80, and Ely on the pane's top edge; the tag names `0119776`. `v0.1.4` rebuilt for T50, at `a54f4ff`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1256), signed and notarized, each in place of the first build of its name, once CI run 1253 passed on macOS, Ubuntu and Windows on `a9be8ab`, which `a54f4ff` follows with `TASKS.md` and `tasks/reviews.md` alone; the tag moved from `2d9180e` to `a54f4ff`, and the release's target with it; the notes give the new SHA-256, add T48's fix and T49's motion, and say the builds were replaced; each file downloaded back anonymously matches its SHA-256, each binary holds the rig's log line and none the old faces' string, and the tag's source archive holds `src/pet/rig.rs` and no `src/pet/faces.rs`. The first `v0.1.4` builds, at `2d9180e`: the zip from its script on the owner's Windows VM, the tarball from its script on the owner's PC under Omarchy, the disk image from the Release workflow (run 1216), signed and notarized; published once CI run 1215 on that commit passed on macOS, Ubuntu and Windows; each file downloaded back anonymously matches the SHA-256 in the release notes, each binary holds Ely's log line, and the tag named `2d9180e`. `v0.1.3` rebuilt for T43, at `eb96109`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1181), signed and notarized, each in place of the first build of its name, once CI run 1180 on that commit passed on macOS, Ubuntu and Windows; the tag moved from `7569f00` to `eb96109`, and the release's target with it; the notes give the new SHA-256 and say the builds were replaced; each file downloaded back anonymously matches its SHA-256, each binary holds the moving marks' log line and none the old ring's element id, and the tag's source archive holds `src/sessions/orb.rs`. The first `v0.1.3` builds, at `7569f00`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1157), signed and notarized; published once CI run 1156 on that commit passed on macOS, Ubuntu and Windows; each file downloaded back anonymously matches the SHA-256 in the release notes, and the tag named `7569f00`. `v0.1.2` at `4364802`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1001), signed and notarized; published once CI run 1000 on that commit passed on macOS, Ubuntu and Windows; each file downloaded back anonymously matches the SHA-256 in the release notes, and the tag names `4364802`. `v0.1.1` at `43ea5b1`: the zip from its script on the owner's PC, the disk image from the Release workflow, signed and notarized; the Linux tarball, rebuilt for T27 from `aae7fba` by its script on the owner's PC under Omarchy, took the first one's place, and the notes say so; each downloaded back anonymously, once the repository was public, matches the SHA-256 in the release notes. `v0.1.0` at `0075667`, its three files built from that commit by their scripts and checked again: the disk image verifies and its app passes `codesign --verify --strict`; the zip's executable has the icon and no C runtime DLL; the tarball opens its window on Ubuntu 22.04; each file downloaded back matches the SHA-256 in the release notes | Pass |
+| A GitHub release, `vVERSION`, with the macOS disk image, a Windows zip and a Linux tarball | T25, T26, T27, T31, T41, T43, T47, T50, T54, T57 | `v0.1.6` at `8a9941b`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1343), signed and notarized; a first build at `9e185ea`, held back when the owner asked for the scrollbar, was replaced on the draft file by file and never published; published once CI run 1342 on `8a9941b` passed on macOS, Ubuntu and Windows; each file downloaded back anonymously matches the SHA-256 in the release notes; each binary holds the drag's, the update check's and the scrollbar's lines; the tag names `8a9941b`. `v0.1.5` at `0119776`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1312), signed and notarized; published once CI run 1311 on that commit passed on macOS, Ubuntu and Windows; each file downloaded back anonymously matches the SHA-256 in the release notes; each binary holds T51's `Ely moves to the pane's` and the failed glue's line, the disk image T53's `her panel drops its titled frame` and the tarball the monitors' line; the downloaded app, run with a HOME of its own, logged her panel going borderless, 0x8081 to 0x80, and Ely on the pane's top edge; the tag names `0119776`. `v0.1.4` rebuilt for T50, at `a54f4ff`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1256), signed and notarized, each in place of the first build of its name, once CI run 1253 passed on macOS, Ubuntu and Windows on `a9be8ab`, which `a54f4ff` follows with `TASKS.md` and `tasks/reviews.md` alone; the tag moved from `2d9180e` to `a54f4ff`, and the release's target with it; the notes give the new SHA-256, add T48's fix and T49's motion, and say the builds were replaced; each file downloaded back anonymously matches its SHA-256, each binary holds the rig's log line and none the old faces' string, and the tag's source archive holds `src/pet/rig.rs` and no `src/pet/faces.rs`. The first `v0.1.4` builds, at `2d9180e`: the zip from its script on the owner's Windows VM, the tarball from its script on the owner's PC under Omarchy, the disk image from the Release workflow (run 1216), signed and notarized; published once CI run 1215 on that commit passed on macOS, Ubuntu and Windows; each file downloaded back anonymously matches the SHA-256 in the release notes, each binary holds Ely's log line, and the tag named `2d9180e`. `v0.1.3` rebuilt for T43, at `eb96109`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1181), signed and notarized, each in place of the first build of its name, once CI run 1180 on that commit passed on macOS, Ubuntu and Windows; the tag moved from `7569f00` to `eb96109`, and the release's target with it; the notes give the new SHA-256 and say the builds were replaced; each file downloaded back anonymously matches its SHA-256, each binary holds the moving marks' log line and none the old ring's element id, and the tag's source archive holds `src/sessions/orb.rs`. The first `v0.1.3` builds, at `7569f00`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1157), signed and notarized; published once CI run 1156 on that commit passed on macOS, Ubuntu and Windows; each file downloaded back anonymously matches the SHA-256 in the release notes, and the tag named `7569f00`. `v0.1.2` at `4364802`: the zip and the tarball from their scripts on the owner's PC and its WSL, the disk image from the Release workflow (run 1001), signed and notarized; published once CI run 1000 on that commit passed on macOS, Ubuntu and Windows; each file downloaded back anonymously matches the SHA-256 in the release notes, and the tag names `4364802`. `v0.1.1` at `43ea5b1`: the zip from its script on the owner's PC, the disk image from the Release workflow, signed and notarized; the Linux tarball, rebuilt for T27 from `aae7fba` by its script on the owner's PC under Omarchy, took the first one's place, and the notes say so; each downloaded back anonymously, once the repository was public, matches the SHA-256 in the release notes. `v0.1.0` at `0075667`, its three files built from that commit by their scripts and checked again: the disk image verifies and its app passes `codesign --verify --strict`; the zip's executable has the icon and no C runtime DLL; the tarball opens its window on Ubuntu 22.04; each file downloaded back matches the SHA-256 in the release notes | Pass |
-| The Windows executable carries the icon | T25, T31, T41, T47, T50, T54 | its resources: icon group 1 with the seven images of `elyterminal.ico`, 16 to 256 px, and gpui's manifest (PerMonitorV2); a GUI program, importing no C runtime DLL; on a Windows 11 VM the first 0.1.4 executable, running, showed it in the taskbar; v0.1.2's, v0.1.3's and v0.1.4's executables the same, T50's rebuild with icon and manifest byte for byte the first's; v0.1.5's executable a GUI program importing no C runtime DLL, its seven icon images, icon group 1 and manifest byte for byte 0.1.4's | Pass |
+| The Windows executable carries the icon | T25, T31, T41, T47, T50, T54, T57 | its resources: icon group 1 with the seven images of `elyterminal.ico`, 16 to 256 px, and gpui's manifest (PerMonitorV2); a GUI program, importing no C runtime DLL; on a Windows 11 VM the first 0.1.4 executable, running, showed it in the taskbar; v0.1.2's, v0.1.3's and v0.1.4's executables the same, T50's rebuild with icon and manifest byte for byte the first's; v0.1.5's executable a GUI program importing no C runtime DLL, its seven icon images, icon group 1 and manifest byte for byte 0.1.4's; v0.1.6's executable the same, its icon images, icon group and manifest byte for byte 0.1.5's | Pass |
-| The Linux tarball carries the icon and a desktop entry; the window names itself `com.zacharyzhang.elyterminal` | T25, T27, T41, T47, T50, T54 | on Ubuntu 22.04: `desktop-file-validate` reports nothing, every library resolves, glibc 2.35; under Xvfb `WM_CLASS` reads `com.zacharyzhang.elyterminal` twice, and under headless sway the window's `app_id` reads the same; v0.1.2's passes the same checks on Ubuntu 22.04, run in the owner's WSL, `WM_CLASS` too; T27's rebuild passes the same checks on Ubuntu 22.04, whose llvmpipe (LLVM 15) leaves the window black in a capture, the first tarball's too, while Debian 13's paints it; v0.1.3's holds the same three files, its desktop entry names `com.zacharyzhang.elyterminal`, and its binary asks for glibc 2.35 at most; v0.1.4's the same, T50's rebuild too; v0.1.5's holds the same three files, its desktop entry and icon byte for byte 0.1.4's, and its binary asks for glibc 2.35 at most | Pass |
+| The Linux tarball carries the icon and a desktop entry; the window names itself `com.zacharyzhang.elyterminal` | T25, T27, T41, T47, T50, T54, T57 | on Ubuntu 22.04: `desktop-file-validate` reports nothing, every library resolves, glibc 2.35; under Xvfb `WM_CLASS` reads `com.zacharyzhang.elyterminal` twice, and under headless sway the window's `app_id` reads the same; v0.1.2's passes the same checks on Ubuntu 22.04, run in the owner's WSL, `WM_CLASS` too; T27's rebuild passes the same checks on Ubuntu 22.04, whose llvmpipe (LLVM 15) leaves the window black in a capture, the first tarball's too, while Debian 13's paints it; v0.1.3's holds the same three files, its desktop entry names `com.zacharyzhang.elyterminal`, and its binary asks for glibc 2.35 at most; v0.1.4's the same, T50's rebuild too; v0.1.5's holds the same three files, its desktop entry and icon byte for byte 0.1.4's, and its binary asks for glibc 2.35 at most; v0.1.6's holds the same three files, its desktop entry and icon byte for byte 0.1.5's, and its binary asks for glibc 2.35 at most | Pass |
-| Each build comes from its script | T25, T27, T31, T41, T43, T47, T50, T54 | `scripts/mac-app.sh` on macOS, `scripts/windows-zip.ps1` on the owner's Windows PC, `scripts/linux-tar.sh` in the owner's WSL, and for T27 on the owner's PC under Omarchy; v0.1.2's and v0.1.3's three the same way, and v0.1.3's again for T43, the disk image's on `macos-signing`; v0.1.4's zip on the owner's Windows VM, its tarball on the owner's PC under Omarchy, its disk image on `macos-signing`; T50's zip on the owner's PC, its tarball in the PC's WSL, its disk image on `macos-signing`; v0.1.5's three the same way: `scripts/windows-zip.ps1` on the owner's PC, `scripts/linux-tar.sh` in its WSL, `scripts/mac-app.sh` in the Release workflow on `macos-signing` | Pass |
+| Each build comes from its script | T25, T27, T31, T41, T43, T47, T50, T54, T57 | `scripts/mac-app.sh` on macOS, `scripts/windows-zip.ps1` on the owner's Windows PC, `scripts/linux-tar.sh` in the owner's WSL, and for T27 on the owner's PC under Omarchy; v0.1.2's and v0.1.3's three the same way, and v0.1.3's again for T43, the disk image's on `macos-signing`; v0.1.4's zip on the owner's Windows VM, its tarball on the owner's PC under Omarchy, its disk image on `macos-signing`; T50's zip on the owner's PC, its tarball in the PC's WSL, its disk image on `macos-signing`; v0.1.5's three the same way: `scripts/windows-zip.ps1` on the owner's PC, `scripts/linux-tar.sh` in its WSL, `scripts/mac-app.sh` in the Release workflow on `macos-signing`; v0.1.6's three the same way, rebuilt from `8a9941b` with T58 in place of a first build from `9e185ea` that was never published | Pass |
 
 ## CI notes
 

tasks/reviews.md

@@ -284,3 +284,45 @@ Each task gets at most three codex rounds. Each round: the commit, the verdict,
 ## T58
 
 - No review: the owner asked for it at once, in 0.1.6, without one. Checked by scripts/check.sh (244 tests), Linux tests (251) and clippy, Windows gnu clippy, and under Xorg's dummy screen drags of the thumb through 500 lines, with mouse tracking on as well.
+
+## T57
+
+- No review: the owner asked for 0.1.6 without one. v0.1.6 published at 8a9941b once CI run 1342 passed on macOS, Ubuntu and Windows; its disk image from Release run 1343, notarized, its zip and tarball from their scripts on the owner's PC and its WSL; a first build at 9e185ea, held back for the scrollbar, was replaced on the draft and never published; each file downloaded back anonymously matches its SHA-256 in the notes.
+
+## T59
+
+- Round 1, 82cfe91: FAIL. fish 4.9 moves a code point per Left, so a counted click put `X` inside `é`; fish's redraw dropped the wrap flag of a long line, so a second click on its next row moved nothing; a press let go in another cell still moved the cursor; a program that turned on mouse tracking while the button was down still got arrows. Fixed in 0c55d41: OSC 133 A's `click_events`, which fish sends on its own, makes the click go to the shell as an SGR press, as kitty and Ghostty send it; the release must land in the press's cell, and the program must track no mouse at the release.
+- Round 2, 0c55d41: FAIL. The four findings of round 1 replayed fixed, and zsh, bash, the prompt jump and the shell tests held; but a click on fish's `$` went to fish as a press, and fish moved its cursor to the start, where T59 asks for clicks past the prompt. Fixed in e74ea74: the press goes only past the prompt's last cell before the cursor, and never on a prompt cell.
+- Round 3, e74ea74 and 9fa68b2: a first run found that fish's empty left prompt beside a right prompt carrying its own marks panicked in `click::press`, then stopped without a verdict when Codex's content filter cut it off; 9fa68b2 fixed the panic. A second run, at 9fa68b2: FAIL. Every earlier finding replayed fixed and the panic gone, but a prompt that prints nothing, fish's empty left prompt with a plain or no right prompt, left no cells to find the input by, so clicks on the typed line did nothing. The owner chose a fix and a fourth round over leaving it documented. Fixed in 84364ce: OSC 133 B stamps the line typed after a prompt with a link of its own, numbered by the commands ended, which every prompt drawn again on that line shares, so the input starts at its first typed cell where no prompt cell of its line comes before it.
+- Round 4, 84364ce: FAIL. Round 3's finding replayed fixed, every earlier one held, and the rewrite passed 5,291 split reads, 15 pty replays, Cmd-press in prompt, input and output, bash 3.2, find, select all and copy; but the newest typed line was taken by its place, lowest on the screen, so after `printf '\e[H'` fish's prompt at the top over older lines took no click. Fixed in 28d7615: the newest line is the one of the highest number, and a press goes no lower than its last row or the cursor's, where fish moved its cursor for a click on older text below. Round 4 was the last the owner allowed.
+- Round 5, 28d7615, which the owner allowed: PASS. fish's prompt drawn at the top over older lines took its click, `abcXdef`, and a click on the older text below did nothing; every earlier finding replayed fixed; zsh and bash arrows, the prompt jump, Cmd-press in prompt, input and output, bash 3.2, find, select all and copy held; 5,291 split reads and 15 pty replays of the rewrite matched; check.sh passed with 256 tests. Windows' win32-input-mode and Linux's native clicks went unexercised.
+
+## T66
+
+- Round 1, 545fb46: FAIL. On Windows a path went bare, or in double quotes when it held a space, so PowerShell expanded `$HOME` and `$(1+1)`, broke on `it's`, and ran `a;Write-Output(42)` as two statements, and cmd kept `&` live; and `^` went unescaped, so zsh with `extendedglob` read a dropped `a^b` as a glob and passed four files. zsh, bash and fish read 317 paths back exactly, controls and bad UTF-8 stopped the drop, and selection, click to move, mouse reports and the scrollbar held after a drop. Fixed in 887378a: a path stays literal for the shell the session started, by its name: backslashes for POSIX shells, `^` and `~` among them; single quotes with their quotes doubled for PowerShell; double quotes for cmd, which refuses a `%`.
+- Round 2, 887378a: FAIL. PowerShell read 384 hard names back exactly and a real pwsh session logged its quoting; zsh with `extendedglob`, bash and fish read 376; but cmd, from its docs and parsers, expands `!NAME!` inside quotes under `/v:on`, and `"C:\"` reads to a program as a quote, joining the next path. Fixed in 5660562: a `!` stops a cmd drop, and the backslashes ending a path are doubled; node, run from a cmd batch line on the owner's PC, received six hard paths exactly, `C:\` among them.
+- Round 3, 5660562: PASS. A `!` anywhere in a cmd drop stops it with no byte sent, and doubled trailing backslashes keep `C:\` and the next path apart under MSVCRT and UCRT parsing; 1,062 cmd paths, UNC and runs of up to 32 backslashes among them, kept their contents, order and bounds; zsh, zsh with `extendedglob`, bash and fish read 376 paths back exactly and PowerShell 384; check.sh passed with 261 tests. Windows' own cmd and ConPTY were checked only through the owner's PC run.
+
+## T60
+
+- Round 1, cb32f00: FAIL. On macOS the order, bold, italic, ligatures, icons, old files, refusals, add, change and cancel all held; but removing the row whose input held the focus left the removed family in it, and Enter saved it over the next family; and on Linux gpui's cosmic-text path carries the fallback a character took into the next while it covers it, so `क中` drew 中 in the second fallback. Fixed in 5f8ea89: a removal drops that row's input and the focus; the Linux path is gpui's, kept for its shaping clusters, and the owner chose to record it.
+- Round 2, 5f8ea89: FAIL. Round 1's removal case and removals first, middle, last, in sequence, then adds and cancels held, and the Linux record was true; but the pickers were keyed by place, so after a removal moved the inputs, the picker state of the second row, listening to the input now first, wrote PingFang SC into it at a blur, and Enter saved `[PingFang SC, PingFang SC]`. Fixed in 5d131e5: each picker is keyed by its input's entity.
+- Round 3, 5d131e5: PASS. Each picker keyed by its input kept round 2's case at `[Songti SC, PingFang SC]` through a removal, a focus cycle and Enter; drafts blurred after removals first, middle, last and among duplicates came back to the right family; a sequence of removals and adds through five focus cycles, and a cancel, re-add and removal through three, saved what the screen showed; a refused pick restored the saved list; check.sh passed with 262 tests. Windows and Linux windows went unexercised.
+
+## T61
+
+- No review: the owner closed it once it did not reproduce. On the owner's Windows 11 PC (26H2, 150%), with WeType and powershell.exe, 23 compositions put the candidate box at the caret: three on one line, then one on each of three lines below, fifteen committed and begun again at once, the caret stepping 4 cells each time, and eight under a status line redrawn every 100 ms with the cursor hidden; each caret the IME asked for matched the cursor. Microsoft Pinyin went untested.
+
+## T62
+
+- Round 1, 760f054: PASS. 24 poses rendered by gpui beside the build before, rest, breath, tilts, hops, a press in a hop, typing, a shake, the doze, waking and rising, kept her outline above the shoulders and joined the shirt and hair to the edge in every hop; 3,244,407 poses sampled, head bob, tilt and the rotated hair's corners counted, left the shirt 4.4 and the hair 1.3 units below the edge at her highest, 52.7 units; on macOS 48 snaps at the top and bottom edges and 52 through presses dispatched to her window kept her bottom row opaque; check.sh passed with 263 tests. Windows, X11 and Wayland went by their source.
+
+## T63
+
+- Round 1, 3085a94: FAIL. Presses, Enter, Escape, a blur by a press, other rows, closes, retitles, a full reset, long and Unicode names held, and Ely's `ListItem::editor` left other rows as they were; but leaving the app mid-rename blurred the field while the window's focus still pointed at it, the field went, and back in the app the terminal heard no key until pressed. Fixed in ca3809b: a field that closes while it still holds the focus gives it to the shown terminal; a press that took it elsewhere keeps it there.
+- Round 2, ca3809b: PASS. Back in the app after leaving it mid-rename, `a` reached the program with no press first; 18 scenarios held: Enter, Escape, a blur by a press, presses inside the field, switching and opening sessions, renaming two rows, closing the other session, the renamed one or by Cmd-W, Settings' fields and the Git summary keeping their focus, a triple press, a name of spaces and a later program title; check.sh passed with 263 tests. Windows and Linux windows went unexercised.
+
+## T65
+
+- Round 1, 1384ef5: FAIL. Moves and sizes, clear and opaque windows, changes at rest, blur turned off mid-move, per-window marks, destruction, the Windows 11 boundary and the structure layouts held in a replay against recorded Win32 calls; but blur turned on mid-move, which gpui sets as acrylic at once, kept acrylic for the rest of the move, since Windows sends `WM_ENTERSIZEMOVE` once. Fixed in 0a30760: a moving mark from `WM_ENTERSIZEMOVE` to `WM_EXITSIZEMOVE`, and a window blurred while it holds the mark takes the clear accent again.
+- Round 2, 0a30760: PASS. The build before failed its two mid-move cases and the fix passed them; 46,875 sequences of six actions from opaque, clear and blurred starts, settings, moves, ends, destruction and a second window among them, kept the accent, both marks and the frame refreshes as a model says; check.sh and the Windows type check passed. Windows 10 itself went untested.