@akiojin/gwt 9.7.0 → 9.8.0

package/README.ja.md

@@ -6,10 +6,14 @@ gwt は Git worktree の管理と、`Claude Code` / `Codex` / `Gemini` /
 ## インストール
 
 [GitHub Releases](https://github.com/akiojin/gwt/releases) からお使いの
-プラットフォーム向けバイナリをダウンロードし、`PATH` に配置してください。
+プラットフォーム向け release asset を取得してください。
 
 ### macOS
 
+- GUI 向けの主配布物: `gwt-macos-universal.dmg`
+- マウントした DMG から `GWT.app` を開くとネイティブ GUI をそのまま起動できます
+- `PATH` に `gwt` を入れたい場合は install script を使います
+
 ```bash
 curl -fsSL https://raw.githubusercontent.com/akiojin/gwt/main/installers/macos/install.sh | bash
 ```
@@ -17,12 +21,21 @@ curl -fsSL https://raw.githubusercontent.com/akiojin/gwt/main/installers/macos/i
 特定バージョンを指定する場合:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/akiojin/gwt/main/installers/macos/install.sh | bash -s -- --version 6.30.3
+curl -fsSL https://raw.githubusercontent.com/akiojin/gwt/main/installers/macos/install.sh | bash -s -- --version <version>
 ```
 
-### Windows / Linux
+### Windows
+
+- GUI 向けの主配布物: `gwt-windows-x86_64.msi`
+- portable bundle: `gwt-windows-x86_64.zip`
+- public front door は `gwt.exe` で、`gwtd.exe` は内部 runtime 用の companion binary です
 
-GitHub Releases からバイナリを取得して `PATH` に配置します。
+### Linux
+
+- portable bundle:
+  - `gwt-linux-x86_64.tar.gz`
+  - `gwt-linux-aarch64.tar.gz`
+- 展開した `gwt` / `gwtd` を `PATH` 上のディレクトリへ配置します
 
 ### アンインストール（macOS）
 
@@ -140,13 +153,13 @@ gwt issue spec <number> --section spec|plan|tasks
 ### ビルド
 
 ```bash
-cargo build -p gwt
+cargo build -p gwt --bin gwt --bin gwtd
 ```
 
 ### 実行
 
 ```bash
-cargo run -p gwt
+cargo run -p gwt --bin gwt
 ```
 
 ### macOS 向け `.app` bundle
@@ -162,6 +175,24 @@ cargo bundle -p gwt --format osx
 cargo test -p gwt-core -p gwt --all-features
 ```
 
+### Release Asset Contract
+
+```bash
+npm run test:release-assets
+```
+
+### Frontend Bundle Contract
+
+```bash
+npm run test:frontend-bundle
+```
+
+### Release Flow Checks
+
+```bash
+npm run test:release-flow
+```
+
 ### Lint
 
 ```bash

package/README.md

@@ -7,12 +7,15 @@ such as `Claude Code`, `Codex`, `Gemini`, and `OpenCode`.
 
 ## Install
 
-Download the binary for your platform from
-[GitHub Releases](https://github.com/akiojin/gwt/releases) and place it in
-your `PATH`.
+Download the release asset for your platform from
+[GitHub Releases](https://github.com/akiojin/gwt/releases).
 
 ### macOS
 
+- GUI-first installer: `gwt-macos-universal.dmg`
+- Open `GWT.app` from the mounted DMG for the native desktop launch surface
+- Use the install script when you want the `gwt` CLI front door in your `PATH`
+
 ```bash
 curl -fsSL https://raw.githubusercontent.com/akiojin/gwt/main/installers/macos/install.sh | bash
 ```
@@ -20,12 +23,21 @@ curl -fsSL https://raw.githubusercontent.com/akiojin/gwt/main/installers/macos/i
 Install a specific version:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/akiojin/gwt/main/installers/macos/install.sh | bash -s -- --version 6.30.3
+curl -fsSL https://raw.githubusercontent.com/akiojin/gwt/main/installers/macos/install.sh | bash -s -- --version <version>
 ```
 
-### Windows / Linux
+### Windows
+
+- GUI-first installer: `gwt-windows-x86_64.msi`
+- Portable bundle: `gwt-windows-x86_64.zip`
+- The public front door is `gwt.exe`; `gwtd.exe` is bundled for internal runtime use
 
-Download the binary from GitHub Releases and add it to your `PATH`.
+### Linux
+
+- Portable bundles:
+  - `gwt-linux-x86_64.tar.gz`
+  - `gwt-linux-aarch64.tar.gz`
+- Extract `gwt` and `gwtd` into a directory on your `PATH`
 
 ### Uninstall (macOS)
 
@@ -144,13 +156,13 @@ gwt issue spec <number> --section spec|plan|tasks
 ### Build
 
 ```bash
-cargo build -p gwt
+cargo build -p gwt --bin gwt --bin gwtd
 ```
 
 ### Run
 
 ```bash
-cargo run -p gwt
+cargo run -p gwt --bin gwt
 ```
 
 ### Build a macOS app bundle
@@ -166,6 +178,24 @@ cargo bundle -p gwt --format osx
 cargo test -p gwt-core -p gwt --all-features
 ```
 
+### Release Asset Contract
+
+```bash
+npm run test:release-assets
+```
+
+### Frontend Bundle Contract
+
+```bash
+npm run test:frontend-bundle
+```
+
+### Release Flow Checks
+
+```bash
+npm run test:release-flow
+```
+
 ### Lint
 
 ```bash

package/assets/release-assets.json

@@ -0,0 +1,18 @@
+{
+  "bundle_binaries": {
+    "linux": ["gwt", "gwtd"],
+    "macos": ["gwt", "gwtd"],
+    "windows": ["gwt.exe", "gwtd.exe"]
+  },
+  "portable_assets": {
+    "linux-x86_64": "gwt-linux-x86_64.tar.gz",
+    "linux-aarch64": "gwt-linux-aarch64.tar.gz",
+    "macos-x86_64": "gwt-macos-x86_64.tar.gz",
+    "macos-aarch64": "gwt-macos-arm64.tar.gz",
+    "windows-x86_64": "gwt-windows-x86_64.zip"
+  },
+  "installer_assets": {
+    "macos": "gwt-macos-universal.dmg",
+    "windows": "gwt-windows-x86_64.msi"
+  }
+}

package/docker-compose.yml

@@ -8,8 +8,8 @@ services:
       - bash-history:/root/.bash_history_dir
       - claude-config:/root/.claude
       - codex-config:/root/.codex
-      - ${HOME:?HOME must be set}/.claude:/root/.claude-host:ro
-      - ${HOME:?HOME must be set}/.codex:/root/.codex-host:ro
+      - ${HOME:-${USERPROFILE:?HOME or USERPROFILE must be set}}/.claude:/root/.claude-host:ro
+      - ${HOME:-${USERPROFILE:?HOME or USERPROFILE must be set}}/.codex:/root/.codex-host:ro
     ports:
       - ${PORT:-3000}:3000
     extra_hosts:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/gwt",
-  "version": "9.7.0",
+  "version": "9.8.0",
   "description": "Desktop GUI for Git worktree management and coding agent launch",
   "type": "module",
   "bin": {
@@ -8,9 +8,12 @@
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.cjs",
-    "dev": "cargo run -p gwt",
-    "build": "cargo build --release -p gwt",
+    "dev": "cargo run -p gwt --bin gwt",
+    "build": "cargo build --release -p gwt --bin gwt --bin gwtd",
     "test": "cargo test -p gwt-core -p gwt --all-features",
+    "test:frontend-bundle": "node --check crates/gwt/web/app.js",
+    "test:release-assets": "node scripts/test_release_assets.cjs",
+    "test:release-flow": "bash scripts/check-release-flow.sh",
     "test:all": "bash scripts/test-all.sh",
     "prepare": "test -n \"$CI\" || bunx husky install",
     "lint:skills": "bash scripts/validate-skill-frontmatter.sh",

package/scripts/check-release-flow.sh

@@ -5,6 +5,8 @@ ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 RELEASE="$ROOT/.github/workflows/release.yml"
 README_EN="$ROOT/README.md"
 README_JA="$ROOT/README.ja.md"
+INDEX_HTML="$ROOT/crates/gwt/web/index.html"
+APP_JS="$ROOT/crates/gwt/web/app.js"
 
 fail=0
 
@@ -23,6 +25,21 @@ if grep -q "release-guide" "$README_EN" "$README_JA"; then
   fail=1
 fi
 
+if ! grep -q '<script type="module" src="/app.js"></script>' "$INDEX_HTML"; then
+  echo "[FAIL] index.html no longer points at the shared /app.js frontend bundle"
+  fail=1
+fi
+
+if ! node "$ROOT/scripts/test_release_assets.cjs"; then
+  echo "[FAIL] release asset contract check failed"
+  fail=1
+fi
+
+if ! node --check "$APP_JS"; then
+  echo "[FAIL] frontend bundle syntax check failed"
+  fail=1
+fi
+
 if [ "$fail" -ne 0 ]; then
   exit 1
 fi

package/scripts/release-assets.cjs

@@ -36,6 +36,16 @@ function releaseAssetName(platform = os.platform(), arch = os.arch()) {
   throw new Error(`Unsupported platform: ${platform}-${arch}`);
 }
 
+function primaryReleaseAssetName(platform = os.platform(), arch = os.arch()) {
+  if (platform === "darwin" && (arch === "arm64" || arch === "x64")) {
+    return "gwt-macos-universal.dmg";
+  }
+  if (platform === "win32" && arch === "x64") {
+    return "gwt-windows-x86_64.msi";
+  }
+  return releaseAssetName(platform, arch);
+}
+
 function releaseAssetUrl(repo, version, platform = os.platform(), arch = os.arch()) {
   const asset = releaseAssetName(platform, arch);
   const tag = `v${version}`;
@@ -197,6 +207,7 @@ module.exports = {
   installBinaryFromArchive: installBundleFromArchive,
   installBundleFromArchive,
   installReleaseBinary,
+  primaryReleaseAssetName,
   releaseAssetName,
   releaseAssetUrl,
 };

package/scripts/test-all.sh

@@ -1,9 +1,23 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-cargo test -p gwt-core -p gwt --all-features &
+cargo_cmd="cargo"
+if ! command -v "$cargo_cmd" >/dev/null 2>&1; then
+  if command -v cargo.exe >/dev/null 2>&1; then
+    cargo_cmd="cargo.exe"
+  else
+    echo "[FAIL] cargo or cargo.exe is required on PATH" >&2
+    exit 1
+  fi
+fi
+
+"$cargo_cmd" test -p gwt-core -p gwt --all-features &
 pid_rust=$!
 
+bash scripts/check-release-flow.sh &
+pid_release_flow=$!
+
 fail=0
 wait $pid_rust || fail=1
+wait $pid_release_flow || fail=1
 exit $fail

package/scripts/test_release_assets.cjs

@@ -8,6 +8,7 @@ const {
   binaryNameForPlatform,
   bundleBinaryNamesForPlatform,
   installBundleFromArchive,
+  primaryReleaseAssetName,
   releaseAssetName,
 } = require("./release-assets.cjs");
 const postinstall = require("./postinstall.cjs");
@@ -34,6 +35,14 @@ run("release asset names match the public portable contract", () => {
   assert.equal(releaseAssetName("win32", "x64"), "gwt-windows-x86_64.zip");
 });
 
+run("primary release asset names match the GUI-first install contract", () => {
+  assert.equal(primaryReleaseAssetName("darwin", "arm64"), "gwt-macos-universal.dmg");
+  assert.equal(primaryReleaseAssetName("darwin", "x64"), "gwt-macos-universal.dmg");
+  assert.equal(primaryReleaseAssetName("linux", "arm64"), "gwt-linux-aarch64.tar.gz");
+  assert.equal(primaryReleaseAssetName("linux", "x64"), "gwt-linux-x86_64.tar.gz");
+  assert.equal(primaryReleaseAssetName("win32", "x64"), "gwt-windows-x86_64.msi");
+});
+
 run("release helper keeps platform binary names stable", () => {
   assert.equal(binaryNameForPlatform("win32"), "gwt.exe");
   assert.equal(binaryNameForPlatform("linux"), "gwt");
@@ -67,6 +76,60 @@ run("release workflow packages gwtd alongside gwt", () => {
   assert.match(workflow, /Contents\/MacOS\/gwtd/);
 });
 
+run("package scripts keep the GUI front door and release contract explicit", () => {
+  const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+  assert.equal(pkg.scripts["test:release-assets"], "node scripts/test_release_assets.cjs");
+  assert.equal(
+    pkg.scripts["test:frontend-bundle"],
+    "node --check crates/gwt/web/app.js"
+  );
+  assert.equal(pkg.scripts["test:release-flow"], "bash scripts/check-release-flow.sh");
+  assert.equal(pkg.scripts.dev, "cargo run -p gwt --bin gwt");
+  assert.equal(pkg.scripts.build, "cargo build --release -p gwt --bin gwt --bin gwtd");
+});
+
+run("test all script keeps rust tests plus frontend release checks", () => {
+  const testAll = fs.readFileSync(path.join(__dirname, "test-all.sh"), "utf8");
+  assert.match(testAll, /test -p gwt-core -p gwt --all-features/);
+  assert.match(testAll, /cargo\.exe/);
+  assert.match(testAll, /bash scripts\/check-release-flow\.sh/);
+});
+
+run("release flow helper checks the shared frontend bundle and release assets", () => {
+  const releaseFlow = fs.readFileSync(path.join(__dirname, "check-release-flow.sh"), "utf8");
+  assert.match(releaseFlow, /scripts\/test_release_assets\.cjs/);
+  assert.match(releaseFlow, /node --check \"\$APP_JS\"/);
+  assert.match(releaseFlow, /script type=\"module\" src=\"\/app\.js\"/);
+});
+
+run("CI workflows call the named frontend and release verification scripts", () => {
+  const lintWorkflow = fs.readFileSync(
+    path.join(__dirname, "..", ".github", "workflows", "lint.yml"),
+    "utf8"
+  );
+  const testWorkflow = fs.readFileSync(
+    path.join(__dirname, "..", ".github", "workflows", "test.yml"),
+    "utf8"
+  );
+
+  assert.match(lintWorkflow, /test:frontend-bundle/);
+  assert.match(lintWorkflow, /test:release-flow/);
+  assert.match(testWorkflow, /test:release-assets/);
+});
+
+run("README install guidance points to GUI-first release assets", () => {
+  const readme = fs.readFileSync(path.join(__dirname, "..", "README.md"), "utf8");
+  const readmeJa = fs.readFileSync(path.join(__dirname, "..", "README.ja.md"), "utf8");
+
+  for (const doc of [readme, readmeJa]) {
+    assert.match(doc, /gwt-macos-universal\.dmg/);
+    assert.match(doc, /gwt-windows-x86_64\.msi/);
+    assert.match(doc, /gwt-linux-x86_64\.tar\.gz/);
+    assert.match(doc, /test:frontend-bundle|node --check crates\/gwt\/web\/app\.js/);
+    assert.match(doc, /test:release-flow|bash scripts\/check-release-flow\.sh/);
+  }
+});
+
 run("portable tarball extraction installs the unix bundle", () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "gwt-release-test-"));
   const sourceDir = path.join(root, "source");
@@ -90,6 +153,10 @@ run("portable tarball extraction installs the unix bundle", () => {
 });
 
 run("portable zip extraction installs the windows bundle", () => {
+  if (process.platform !== "win32") {
+    return;
+  }
+
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "gwt-release-test-"));
   const sourceDir = path.join(root, "source");
   const binDir = path.join(root, "bin");

package/vendor/vt100/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jesse Luehrs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/vt100/src/attrs.rs

@@ -0,0 +1,144 @@
+use crate::term::BufWrite as _;
+
+/// Represents a foreground or background color for cells.
+#[derive(Eq, PartialEq, Debug, Copy, Clone, Default)]
+pub enum Color {
+    /// The default terminal color.
+    #[default]
+    Default,
+
+    /// An indexed terminal color.
+    Idx(u8),
+
+    /// An RGB terminal color. The parameters are (red, green, blue).
+    Rgb(u8, u8, u8),
+}
+
+const TEXT_MODE_INTENSITY: u8 = 0b0000_0011;
+const TEXT_MODE_BOLD: u8 = 0b0000_0001;
+const TEXT_MODE_DIM: u8 = 0b0000_0010;
+const TEXT_MODE_ITALIC: u8 = 0b0000_0100;
+const TEXT_MODE_UNDERLINE: u8 = 0b0000_1000;
+const TEXT_MODE_INVERSE: u8 = 0b0001_0000;
+
+#[derive(Default, Clone, Copy, PartialEq, Eq, Debug)]
+pub struct Attrs {
+    pub fgcolor: Color,
+    pub bgcolor: Color,
+    pub mode: u8,
+}
+
+impl Attrs {
+    pub fn bold(&self) -> bool {
+        self.mode & TEXT_MODE_BOLD != 0
+    }
+
+    pub fn dim(&self) -> bool {
+        self.mode & TEXT_MODE_DIM != 0
+    }
+
+    fn intensity(&self) -> u8 {
+        self.mode & TEXT_MODE_INTENSITY
+    }
+
+    pub fn set_bold(&mut self) {
+        self.mode &= !TEXT_MODE_INTENSITY;
+        self.mode |= TEXT_MODE_BOLD;
+    }
+
+    pub fn set_dim(&mut self) {
+        self.mode &= !TEXT_MODE_INTENSITY;
+        self.mode |= TEXT_MODE_DIM;
+    }
+
+    pub fn set_normal_intensity(&mut self) {
+        self.mode &= !TEXT_MODE_INTENSITY;
+    }
+
+    pub fn italic(&self) -> bool {
+        self.mode & TEXT_MODE_ITALIC != 0
+    }
+
+    pub fn set_italic(&mut self, italic: bool) {
+        if italic {
+            self.mode |= TEXT_MODE_ITALIC;
+        } else {
+            self.mode &= !TEXT_MODE_ITALIC;
+        }
+    }
+
+    pub fn underline(&self) -> bool {
+        self.mode & TEXT_MODE_UNDERLINE != 0
+    }
+
+    pub fn set_underline(&mut self, underline: bool) {
+        if underline {
+            self.mode |= TEXT_MODE_UNDERLINE;
+        } else {
+            self.mode &= !TEXT_MODE_UNDERLINE;
+        }
+    }
+
+    pub fn inverse(&self) -> bool {
+        self.mode & TEXT_MODE_INVERSE != 0
+    }
+
+    pub fn set_inverse(&mut self, inverse: bool) {
+        if inverse {
+            self.mode |= TEXT_MODE_INVERSE;
+        } else {
+            self.mode &= !TEXT_MODE_INVERSE;
+        }
+    }
+
+    pub fn write_escape_code_diff(
+        &self,
+        contents: &mut Vec<u8>,
+        other: &Self,
+    ) {
+        if self != other && self == &Self::default() {
+            crate::term::ClearAttrs.write_buf(contents);
+            return;
+        }
+
+        let attrs = crate::term::Attrs::default();
+
+        let attrs = if self.fgcolor == other.fgcolor {
+            attrs
+        } else {
+            attrs.fgcolor(self.fgcolor)
+        };
+        let attrs = if self.bgcolor == other.bgcolor {
+            attrs
+        } else {
+            attrs.bgcolor(self.bgcolor)
+        };
+        let attrs = if self.intensity() == other.intensity() {
+            attrs
+        } else {
+            attrs.intensity(match self.intensity() {
+                0 => crate::term::Intensity::Normal,
+                TEXT_MODE_BOLD => crate::term::Intensity::Bold,
+                TEXT_MODE_DIM => crate::term::Intensity::Dim,
+                _ => unreachable!(),
+            })
+        };
+        let attrs = if self.italic() == other.italic() {
+            attrs
+        } else {
+            attrs.italic(self.italic())
+        };
+        let attrs = if self.underline() == other.underline() {
+            attrs
+        } else {
+            attrs.underline(self.underline())
+        };
+        let attrs = if self.inverse() == other.inverse() {
+            attrs
+        } else {
+            attrs.inverse(self.inverse())
+        };
+
+        attrs.write_buf(contents);
+    }
+}

package/vendor/vt100/src/callbacks.rs

@@ -0,0 +1,69 @@
+/// This trait is used by the parser to handle extra escape sequences that
+/// don't have an impact on the terminal screen directly.
+pub trait Callbacks {
+    /// This callback is called when the terminal requests an audible bell
+    /// (typically with `^G`).
+    fn audible_bell(&mut self, _: &mut crate::Screen) {}
+    /// This callback is called when the terminal requests a visual bell
+    /// (typically with `\eg`).
+    fn visual_bell(&mut self, _: &mut crate::Screen) {}
+    /// This callback is called when the terminal requests a resize
+    /// (typically with `\e[8;<rows>;<cols>t`).
+    fn resize(&mut self, _: &mut crate::Screen, _request: (u16, u16)) {}
+    /// This callback is called when the terminal requests the window title
+    /// to be set (typically with `\e]1;<icon_name>\a`)
+    fn set_window_icon_name(
+        &mut self,
+        _: &mut crate::Screen,
+        _icon_name: &[u8],
+    ) {
+    }
+    /// This callback is called when the terminal requests the window title
+    /// to be set (typically with `\e]2;<title>\a`)
+    fn set_window_title(&mut self, _: &mut crate::Screen, _title: &[u8]) {}
+    /// This callback is called when the terminal requests data to be copied
+    /// to the system clipboard (typically with `\e]52;<ty>;<data>\a`). Note
+    /// that `data` will be encoded as base64.
+    fn copy_to_clipboard(
+        &mut self,
+        _: &mut crate::Screen,
+        _ty: &[u8],
+        _data: &[u8],
+    ) {
+    }
+    /// This callback is called when the terminal requests data to be pasted
+    /// from the system clipboard (typically with `\e]52;<ty>;?\a`).
+    fn paste_from_clipboard(&mut self, _: &mut crate::Screen, _ty: &[u8]) {}
+    /// This callback is called when the terminal receives an escape sequence
+    /// which is otherwise not implemented.
+    fn unhandled_char(&mut self, _: &mut crate::Screen, _c: char) {}
+    /// This callback is called when the terminal receives a control
+    /// character which is otherwise not implemented.
+    fn unhandled_control(&mut self, _: &mut crate::Screen, _b: u8) {}
+    /// This callback is called when the terminal receives an escape sequence
+    /// which is otherwise not implemented.
+    fn unhandled_escape(
+        &mut self,
+        _: &mut crate::Screen,
+        _i1: Option<u8>,
+        _i2: Option<u8>,
+        _b: u8,
+    ) {
+    }
+    /// This callback is called when the terminal receives a CSI sequence
+    /// (`\e[`) which is otherwise not implemented.
+    fn unhandled_csi(
+        &mut self,
+        _: &mut crate::Screen,
+        _i1: Option<u8>,
+        _i2: Option<u8>,
+        _params: &[&[u16]],
+        _c: char,
+    ) {
+    }
+    /// This callback is called when the terminal receives a OSC sequence
+    /// (`\e]`) which is otherwise not implemented.
+    fn unhandled_osc(&mut self, _: &mut crate::Screen, _params: &[&[u8]]) {}
+}
+
+impl Callbacks for () {}