From 0bf2998b6bbff41dd1db99d26c6b9c77d792f61e Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 14:26:08 -0600
Subject: [PATCH 01/28] chore: Fix .cmd() -t wrapper for integer set_option()
 values

---
 src/libtmux/pane.py   | 2 +-
 src/libtmux/window.py | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/libtmux/pane.py b/src/libtmux/pane.py
index 907b23205..c9b5b7cc2 100644
--- a/src/libtmux/pane.py
+++ b/src/libtmux/pane.py
@@ -113,7 +113,7 @@ def cmd(self, cmd: str, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
         Specifying ``('-t', 'custom-target')`` or ``('-tcustom_target')`` in
         ``args`` will override using the object's ``pane_id`` as target.
         """
-        if not any(arg.startswith("-t") for arg in args):
+        if not any("-t" in str(x) for x in args):
             args = ("-t", self.pane_id, *args)
 
         return self.server.cmd(cmd, *args, **kwargs)
diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index 8283a0903..438d6ead4 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -76,6 +76,7 @@ class Window(Obj):
        https://man.openbsd.org/tmux.1#DESCRIPTION. Accessed April 1st, 2018.
     """
 
+    default_scope: OptionScope = OptionScope.Window
     server: "Server"
 
     def refresh(self) -> None:
@@ -139,7 +140,7 @@ def cmd(self, cmd: str, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
         Specifying ``('-t', 'custom-target')`` or ``('-tcustom_target')`` in
         ``args`` will override using the object's ``window_id`` as target.
         """
-        if not any(arg.startswith("-t") for arg in args):
+        if not any("-t" in str(x) for x in args):
             args = ("-t", self.window_id, *args)
 
         return self.server.cmd(cmd, *args, **kwargs)

From a59ac3e3dd3e205f5fb79c927beb3b58c928b092 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Tue, 6 Feb 2024 05:11:35 -0600
Subject: [PATCH 02/28] chore(Window): More resilent handling of options that
 return without value

---
 src/libtmux/window.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index 438d6ead4..793ac7ccc 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -390,7 +390,10 @@ def show_window_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict"
 
         window_options: "WindowOptionDict" = {}
         for item in output:
-            key, val = shlex.split(item)
+            try:
+                key, val = shlex.split(item)
+            except ValueError:
+                logger.exception(f"Error extracting option: {item}")
             assert isinstance(key, str)
             assert isinstance(val, str)
 

From 8d0a08c42588038b1711d3794606b1d5d8f525a1 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Mon, 5 Feb 2024 15:00:51 -0600
Subject: [PATCH 03/28] feat!(Window): Set option flags

---
 src/libtmux/window.py | 43 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index 793ac7ccc..d7d5a1c05 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -327,7 +327,18 @@ def select_layout(self, layout: t.Optional[str] = None) -> "Window":
 
         return self
 
-    def set_window_option(self, option: str, value: t.Union[int, str]) -> "Window":
+    def set_window_option(
+        self,
+        option: str,
+        value: t.Union[int, str],
+        format: t.Optional[bool] = None,
+        unset: t.Optional[bool] = None,
+        unset_panes: t.Optional[bool] = None,
+        prevent_overwrite: t.Optional[bool] = None,
+        suppress_warnings: t.Optional[bool] = None,
+        append: t.Optional[bool] = None,
+        g: t.Optional[bool] = None,
+    ) -> "Window":
         """Set option for tmux window.
 
         Wraps ``$ tmux set-window-option <option> <value>``.
@@ -345,16 +356,46 @@ def set_window_option(self, option: str, value: t.Union[int, str]) -> "Window":
         :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
         :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
         """
+        flags: list[str] = []
         if isinstance(value, bool) and value:
             value = "on"
         elif isinstance(value, bool) and not value:
             value = "off"
 
+        if unset is not None and unset:
+            assert isinstance(unset, bool)
+            flags.append("-u")
+
+        if unset_panes is not None and unset_panes:
+            assert isinstance(unset_panes, bool)
+            flags.append("-U")
+
+        if format is not None and format:
+            assert isinstance(format, bool)
+            flags.append("-F")
+
+        if prevent_overwrite is not None and prevent_overwrite:
+            assert isinstance(prevent_overwrite, bool)
+            flags.append("-o")
+
+        if suppress_warnings is not None and suppress_warnings:
+            assert isinstance(suppress_warnings, bool)
+            flags.append("-q")
+
+        if append is not None and append:
+            assert isinstance(append, bool)
+            flags.append("-a")
+
+        if g is not None and g:
+            assert isinstance(g, bool)
+            flags.append("-g")
+
         cmd = self.cmd(
             "set-window-option",
             f"-t{self.session_id}:{self.window_index}",
             option,
             value,
+            *flags,
         )
 
         if isinstance(cmd.stderr, list) and len(cmd.stderr):

From 3c672083d12977d1d8351aad5248c4319a634bbd Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Mon, 5 Feb 2024 16:56:37 -0600
Subject: [PATCH 04/28] refactor!(Window): Deprecate set_window_option ->
 set_option

---
 src/libtmux/window.py | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index d7d5a1c05..a91b01981 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -331,6 +331,22 @@ def set_window_option(
         self,
         option: str,
         value: t.Union[int, str],
+    ) -> "Window":
+        """Set option for tmux window. Deprecated by :meth:`Window.set_option()`.
+
+        .. deprecated:: 0.26
+
+           Deprecated by :meth:`Window.set_option()`.
+
+        """
+        warnings.warn("Window.set_window_option() is deprecated", stacklevel=2)
+
+        return self.set_option(option=option, value=value)
+
+    def set_option(
+        self,
+        option: str,
+        value: t.Union[int, str],
         format: t.Optional[bool] = None,
         unset: t.Optional[bool] = None,
         unset_panes: t.Optional[bool] = None,
@@ -356,7 +372,7 @@ def set_window_option(
         :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
         :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
         """
-        flags: list[str] = []
+        flags: t.List[str] = []
         if isinstance(value, bool) and value:
             value = "on"
         elif isinstance(value, bool) and not value:

From 3b09a4fbfc238d9b48fd8a7dbe8826c0cef20104 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Mon, 5 Feb 2024 18:32:15 -0600
Subject: [PATCH 05/28] tests(Window): Rename test for show_window_options()

---
 tests/legacy_api/test_window.py | 2 +-
 tests/test_window.py            | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/legacy_api/test_window.py b/tests/legacy_api/test_window.py
index 924049d0f..c4db4cfe3 100644
--- a/tests/legacy_api/test_window.py
+++ b/tests/legacy_api/test_window.py
@@ -211,7 +211,7 @@ def test_show_window_options(session: Session) -> None:
     assert isinstance(options, dict)
 
 
-def test_set_show_window_options(session: Session) -> None:
+def test_set_window_and_show_window_options(session: Session) -> None:
     """Set option then Window.show_window_options(key)."""
     window = session.new_window(window_name="test_window")
 
diff --git a/tests/test_window.py b/tests/test_window.py
index 47ec07205..57e2bf57c 100644
--- a/tests/test_window.py
+++ b/tests/test_window.py
@@ -223,8 +223,8 @@ def test_show_window_options(session: Session) -> None:
     assert isinstance(options, dict)
 
 
-def test_set_show_window_options(session: Session) -> None:
-    """Set option then Window.show_window_options(key)."""
+def test_set_window_and_show_window_options(session: Session) -> None:
+    """Window.set_window_option() then Window.show_window_options(key)."""
     window = session.new_window(window_name="test_window")
 
     window.set_window_option("main-pane-height", 20)

From 773375eb89c734a519cec83e1acf87e8ab3570d7 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Mon, 5 Feb 2024 18:41:17 -0600
Subject: [PATCH 06/28] tests(Window): set_option

---
 tests/legacy_api/test_window.py | 18 +++++++++++++++++-
 tests/test_window.py            | 16 ++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/tests/legacy_api/test_window.py b/tests/legacy_api/test_window.py
index c4db4cfe3..c0d0aa88e 100644
--- a/tests/legacy_api/test_window.py
+++ b/tests/legacy_api/test_window.py
@@ -212,7 +212,7 @@ def test_show_window_options(session: Session) -> None:
 
 
 def test_set_window_and_show_window_options(session: Session) -> None:
-    """Set option then Window.show_window_options(key)."""
+    """Window.set_window_option() then Window.show_window_options(key)."""
     window = session.new_window(window_name="test_window")
 
     window.set_window_option("main-pane-height", 20)
@@ -227,6 +227,22 @@ def test_set_window_and_show_window_options(session: Session) -> None:
         assert window.show_window_option("pane-border-format") == " #P "
 
 
+def test_set_and_show_window_options(session: Session) -> None:
+    """Window.set_option() then Window.show_window_options(key)."""
+    window = session.new_window(window_name="test_window")
+
+    window.set_option("main-pane-height", 20)
+    assert window.show_window_option("main-pane-height") == 20
+
+    window.set_option("main-pane-height", 40)
+    assert window.show_window_option("main-pane-height") == 40
+    assert window.show_window_options()["main-pane-height"] == 40
+
+    if has_gte_version("2.3"):
+        window.set_option("pane-border-format", " #P ")
+        assert window.show_window_option("pane-border-format") == " #P "
+
+
 def test_empty_window_option_returns_None(session: Session) -> None:
     """Verify unset window option returns None."""
     window = session.new_window(window_name="test_window")
diff --git a/tests/test_window.py b/tests/test_window.py
index 57e2bf57c..ce42da850 100644
--- a/tests/test_window.py
+++ b/tests/test_window.py
@@ -239,6 +239,22 @@ def test_set_window_and_show_window_options(session: Session) -> None:
         assert window.show_window_option("pane-border-format") == " #P "
 
 
+def test_set_and_show_window_options(session: Session) -> None:
+    """Window.set_option() then Window.show_window_options(key)."""
+    window = session.new_window(window_name="test_window")
+
+    window.set_option("main-pane-height", 20)
+    assert window.show_window_option("main-pane-height") == 20
+
+    window.set_option("main-pane-height", 40)
+    assert window.show_window_option("main-pane-height") == 40
+    assert window.show_window_options()["main-pane-height"] == 40
+
+    if has_gte_version("2.3"):
+        window.set_option("pane-border-format", " #P ")
+        assert window.show_window_option("pane-border-format") == " #P "
+
+
 def test_empty_window_option_returns_None(session: Session) -> None:
     """Verify unset window option returns None."""
     window = session.new_window(window_name="test_window")

From 741a5829f1e0acacaffd0747ab29b28e1be6040e Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Mon, 5 Feb 2024 20:30:45 -0600
Subject: [PATCH 07/28] Window: Add show_option(), deprecate
 show_window_option()

---
 src/libtmux/window.py | 32 ++++++++++++++++++++++++++------
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index a91b01981..9154aacbb 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -347,7 +347,7 @@ def set_option(
         self,
         option: str,
         value: t.Union[int, str],
-        format: t.Optional[bool] = None,
+        _format: t.Optional[bool] = None,
         unset: t.Optional[bool] = None,
         unset_panes: t.Optional[bool] = None,
         prevent_overwrite: t.Optional[bool] = None,
@@ -386,8 +386,8 @@ def set_option(
             assert isinstance(unset_panes, bool)
             flags.append("-U")
 
-        if format is not None and format:
-            assert isinstance(format, bool)
+        if _format is not None and _format:
+            assert isinstance(_format, bool)
             flags.append("-F")
 
         if prevent_overwrite is not None and prevent_overwrite:
@@ -420,11 +420,18 @@ def set_option(
         return self
 
     def show_window_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict":
-        """Return dict of options for window.
+        """Show options for tmux window. Deprecated by :meth:`Window.show_options()`.
 
-        .. versionchanged:: 0.13.0
+        .. deprecated:: 0.26
+
+           Deprecated by :meth:`Window.show_options()`.
+
+        """
+        warnings.warn("Window.show_window_options() is deprecated", stacklevel=2)
+        return self.show_options(g=g)
 
-           ``option`` removed, use show_window_option to return an individual option.
+    def show_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict":
+        """Return a dict of options for the window.
 
         Parameters
         ----------
@@ -463,6 +470,19 @@ def show_window_option(
         self,
         option: str,
         g: bool = False,
+    ) -> t.Optional[t.Union[str, int]]:
+        """Return option for target window. Deprecated by :meth:`Window.show_option()`.
+
+        .. deprecated:: 0.26
+
+           Deprecated by :meth:`Window.show_option()`.
+
+        """
+        warnings.warn("Window.show_window_option() is deprecated", stacklevel=2)
+        return self.show_option(option=option, g=g)
+
+    def show_option(
+        self, option: str, g: bool = False
     ) -> t.Optional[t.Union[str, int]]:
         """Return option value for the target window.
 

From 2d1fa9916e176b7b07d8ab1f1947529b0d69ccce Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Tue, 6 Feb 2024 04:13:35 -0600
Subject: [PATCH 08/28] chore(Window): {set,show}-window-option ->
 {set,show}-option -w

---
 src/libtmux/window.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index 9154aacbb..2c326b3b4 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -357,7 +357,7 @@ def set_option(
     ) -> "Window":
         """Set option for tmux window.
 
-        Wraps ``$ tmux set-window-option <option> <value>``.
+        Wraps ``$ tmux set-option <option> <value>``.
 
         Parameters
         ----------
@@ -407,7 +407,8 @@ def set_option(
             flags.append("-g")
 
         cmd = self.cmd(
-            "set-window-option",
+            "set-option",
+            "-w",
             f"-t{self.session_id}:{self.window_index}",
             option,
             value,
@@ -443,7 +444,10 @@ def show_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict":
         if g:
             tmux_args += ("-g",)
 
-        tmux_args += ("show-window-options",)
+        tmux_args += (
+            "show-options",
+            "-w-",
+        )
         cmd = self.cmd(*tmux_args)
 
         output = cmd.stdout
@@ -506,7 +510,7 @@ def show_option(
 
         tmux_args += (option,)
 
-        cmd = self.cmd("show-window-options", *tmux_args)
+        cmd = self.cmd("show-options", "-w", *tmux_args)
 
         if len(cmd.stderr):
             handle_option_error(cmd.stderr[0])

From 2ff42c2397b16959e43aa1308673484650747a4a Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Tue, 6 Feb 2024 04:38:57 -0600
Subject: [PATCH 09/28] libtmux.constants: Add OptionScope and
 OPTION_SCOPE_FLAG_MAP

---
 src/libtmux/constants.py | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 src/libtmux/constants.py

diff --git a/src/libtmux/constants.py b/src/libtmux/constants.py
new file mode 100644
index 000000000..cfb9df7ff
--- /dev/null
+++ b/src/libtmux/constants.py
@@ -0,0 +1,20 @@
+"""Constant variables for libtmux."""
+import enum
+import typing as t
+
+
+class OptionScope(enum.Enum):
+    """Scope used with ``set-option`` and ``show-option(s)`` commands."""
+
+    Server = "SERVER"
+    Session = "SESSION"
+    Window = "WINDOW"
+    Pane = "PANE"
+
+
+OPTION_SCOPE_FLAG_MAP: t.Dict[OptionScope, str] = {
+    OptionScope.Server: "-s",
+    OptionScope.Session: "",
+    OptionScope.Window: "-w",
+    OptionScope.Pane: "-p",
+}

From e409d0e608e580397adcd59e41d690877d4ea900 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Tue, 6 Feb 2024 04:47:29 -0600
Subject: [PATCH 10/28] docs(CHANGES): Note updates for options

---
 CHANGES | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/CHANGES b/CHANGES
index 437f7e4a7..ce74e5aae 100644
--- a/CHANGES
+++ b/CHANGES
@@ -14,6 +14,31 @@ $ pip install --user --upgrade --pre libtmux
 
 <!-- Maintainers and contributors: Insert change notes for the next release above -->
 
+### New features
+
+- `Window.set_option()` (#516)
+
+  Learned params:
+
+  - `format` -> `-F`
+  - `unset` -> `-u`
+  - `global` -> `-g`
+  - `unset_panes` -> `-U`: Also unset other panse in windows
+  - `prevent_overwrite`: `-o`
+  - `suppress_warnings`: `-q`
+  - `append`: `-a`
+
+- `Window.show_option()` (#516)
+- `Window.show_options()` (#516)
+
+### Breaking changes
+
+#### Deprecations
+
+- Deprecated `Window.set_window_option()` in favor of `Window.set_option()` (#516)
+- Deprecated `Window.show_window_option()` in favor of `Window.show_option()` (#516)
+- Deprecated `Window.show_window_options()` in favor of `Window.show_options()` (#516)
+
 ## libtmux 0.27.0 (2024-02-07)
 
 ### Improvement

From 31059e3fbff2785b89d3c6b0f9424c1861aefe49 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Mon, 5 Feb 2024 20:43:09 -0600
Subject: [PATCH 11/28] types(common[Pane]): Add PaneOptionDict

---
 src/libtmux/common.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/libtmux/common.py b/src/libtmux/common.py
index c8bb6ccc4..778edaabe 100644
--- a/src/libtmux/common.py
+++ b/src/libtmux/common.py
@@ -32,6 +32,7 @@
 SessionDict = t.Dict[str, t.Any]
 WindowDict = t.Dict[str, t.Any]
 WindowOptionDict = t.Dict[str, t.Any]
+PaneOptionDict = t.Dict[str, t.Any]
 PaneDict = t.Dict[str, t.Any]
 
 

From 2e2fb3f8aa678a1036074519d36fbef946d34962 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Mon, 5 Feb 2024 16:30:13 -0600
Subject: [PATCH 12/28] feat(Pane): Add Pane.set_option, Pane.show_option(s)

---
 src/libtmux/pane.py | 173 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 172 insertions(+), 1 deletion(-)

diff --git a/src/libtmux/pane.py b/src/libtmux/pane.py
index c9b5b7cc2..93017a086 100644
--- a/src/libtmux/pane.py
+++ b/src/libtmux/pane.py
@@ -7,16 +7,19 @@
 """
 import dataclasses
 import logging
+import shlex
 import typing as t
 import warnings
 from typing import overload
 
-from libtmux.common import tmux_cmd
+from libtmux.common import handle_option_error, tmux_cmd
+from libtmux.constants import OPTION_SCOPE_FLAG_MAP, OptionScope
 from libtmux.neo import Obj, fetch_obj
 
 from . import exc
 
 if t.TYPE_CHECKING:
+    from .common import PaneOptionDict
     from .server import Server
     from .session import Session
     from .window import Window
@@ -326,6 +329,174 @@ def split_window(
             percent=percent,
         )
 
+    def set_option(
+        self,
+        option: str,
+        value: t.Union[int, str],
+        _format: t.Optional[bool] = None,
+        unset: t.Optional[bool] = None,
+        unset_panes: t.Optional[bool] = None,
+        prevent_overwrite: t.Optional[bool] = None,
+        suppress_warnings: t.Optional[bool] = None,
+        append: t.Optional[bool] = None,
+        g: t.Optional[bool] = None,
+        scope: t.Optional[OptionScope] = None,
+    ) -> "Pane":
+        """Set option for tmux pane.
+
+        Wraps ``$ tmux set-option -p <option> <value>``.
+
+        Parameters
+        ----------
+        option : str
+            option to set, e.g. 'aggressive-resize'
+        value : str
+            window option value. True/False will turn in 'on' and 'off',
+            also accepts string of 'on' or 'off' directly.
+
+        Raises
+        ------
+        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
+        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
+        """
+        flags: t.List[str] = []
+        if isinstance(value, bool) and value:
+            value = "on"
+        elif isinstance(value, bool) and not value:
+            value = "off"
+
+        if unset is not None and unset:
+            assert isinstance(unset, bool)
+            flags.append("-u")
+
+        if unset_panes is not None and unset_panes:
+            assert isinstance(unset_panes, bool)
+            flags.append("-U")
+
+        if _format is not None and _format:
+            assert isinstance(_format, bool)
+            flags.append("-F")
+
+        if prevent_overwrite is not None and prevent_overwrite:
+            assert isinstance(prevent_overwrite, bool)
+            flags.append("-o")
+
+        if suppress_warnings is not None and suppress_warnings:
+            assert isinstance(suppress_warnings, bool)
+            flags.append("-q")
+
+        if append is not None and append:
+            assert isinstance(append, bool)
+            flags.append("-a")
+
+        if g is not None and g:
+            assert isinstance(g, bool)
+            flags.append("-g")
+
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            flags.append(
+                OPTION_SCOPE_FLAG_MAP[scope],
+            )
+
+        cmd = self.cmd(
+            "set-option",
+            f"-t{self.pane_id}",
+            option,
+            value,
+            *flags,
+        )
+
+        if isinstance(cmd.stderr, list) and len(cmd.stderr):
+            handle_option_error(cmd.stderr[0])
+
+        return self
+
+    def show_options(
+        self,
+        g: t.Optional[bool] = False,
+        scope: t.Optional[OptionScope] = OptionScope.Pane,
+    ) -> "PaneOptionDict":
+        """Return a dict of options for the pane.
+
+        For familiarity with tmux, the option ``option`` param forwards to
+        pick a single option, forwarding to :meth:`Pane.show_option`.
+
+        Parameters
+        ----------
+        g : str, optional
+            Pass ``-g`` flag for global variable, default False.
+        """
+        tmux_args: t.Tuple[str, ...] = ()
+
+        if g:
+            tmux_args += ("-g",)
+
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
+
+        cmd = self.cmd("show-pane-options", *tmux_args)
+
+        output = cmd.stdout
+
+        pane_options: "PaneOptionDict" = {}
+        for item in output:
+            key, val = shlex.split(item)
+            assert isinstance(key, str)
+            assert isinstance(val, str)
+
+            if isinstance(val, str) and val.isdigit():
+                pane_options[key] = int(val)
+
+        return pane_options
+
+    def show_option(
+        self,
+        option: str,
+        g: bool = False,
+        scope: t.Optional[OptionScope] = OptionScope.Pane,
+    ) -> t.Optional[t.Union[str, int]]:
+        """Return a list of options for the pane.
+
+        todo: test and return True/False for on/off string
+
+        Parameters
+        ----------
+        option : str
+        g : bool, optional
+            Pass ``-g`` flag, global. Default False.
+
+        Raises
+        ------
+        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
+        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
+        """
+        tmux_args: t.Tuple[t.Union[str, int], ...] = ()
+
+        if g:
+            tmux_args += ("-g",)
+
+        tmux_args += (option,)
+
+        cmd = self.cmd("show-options", *tmux_args)
+
+        if len(cmd.stderr):
+            handle_option_error(cmd.stderr[0])
+
+        pane_options_output = cmd.stdout
+
+        if not len(pane_options_output):
+            return None
+
+        value_raw = next(shlex.split(item) for item in pane_options_output)
+
+        value: t.Union[str, int] = (
+            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
+        )
+
+        return value
+
     """
     Commands (helpers)
     """

From 15065cbed6c4771adfe7401dfa18952fbbefe9f1 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Tue, 6 Feb 2024 04:43:43 -0600
Subject: [PATCH 13/28] feat(Window): scope param for Window.{set,show}_option

---
 src/libtmux/window.py | 102 +++++++++++++++++++++++++++++++++++++-----
 1 file changed, 90 insertions(+), 12 deletions(-)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index 2c326b3b4..cd4736f2e 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -13,6 +13,7 @@
 
 from libtmux._internal.query_list import QueryList
 from libtmux.common import has_gte_version, tmux_cmd
+from libtmux.constants import OPTION_SCOPE_FLAG_MAP, OptionScope
 from libtmux.neo import Obj, fetch_obj, fetch_objs
 from libtmux.pane import Pane
 
@@ -354,6 +355,7 @@ def set_option(
         suppress_warnings: t.Optional[bool] = None,
         append: t.Optional[bool] = None,
         g: t.Optional[bool] = None,
+        scope: t.Optional[OptionScope] = None,
     ) -> "Window":
         """Set option for tmux window.
 
@@ -406,13 +408,18 @@ def set_option(
             assert isinstance(g, bool)
             flags.append("-g")
 
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            flags.append(
+                OPTION_SCOPE_FLAG_MAP[scope],
+            )
+
         cmd = self.cmd(
             "set-option",
-            "-w",
             f"-t{self.session_id}:{self.window_index}",
+            *flags,
             option,
             value,
-            *flags,
         )
 
         if isinstance(cmd.stderr, list) and len(cmd.stderr):
@@ -429,9 +436,52 @@ def show_window_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict"
 
         """
         warnings.warn("Window.show_window_options() is deprecated", stacklevel=2)
-        return self.show_options(g=g)
+        return self.show_options(
+            g=g,
+            scope=OptionScope.Window,
+        )
 
-    def show_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict":
+    @t.overload
+    def show_options(
+        self,
+        g: t.Optional[bool],
+        scope: t.Optional[OptionScope],
+        include_hooks: t.Optional[bool],
+        include_parents: t.Optional[bool],
+        values_only: t.Literal[True],
+    ) -> t.List[str]:
+        ...
+
+    @t.overload
+    def show_options(
+        self,
+        g: t.Optional[bool],
+        scope: t.Optional[OptionScope],
+        include_hooks: t.Optional[bool],
+        include_parents: t.Optional[bool],
+        values_only: t.Literal[None] = None,
+    ) -> "WindowOptionDict":
+        ...
+
+    @t.overload
+    def show_options(
+        self,
+        g: t.Optional[bool] = None,
+        scope: t.Optional[OptionScope] = None,
+        include_hooks: t.Optional[bool] = None,
+        include_parents: t.Optional[bool] = None,
+        values_only: t.Literal[False] = False,
+    ) -> "WindowOptionDict":
+        ...
+
+    def show_options(
+        self,
+        g: t.Optional[bool] = False,
+        scope: t.Optional[OptionScope] = OptionScope.Window,
+        include_hooks: t.Optional[bool] = None,
+        include_parents: t.Optional[bool] = None,
+        values_only: t.Optional[bool] = False,
+    ) -> t.Union["WindowOptionDict", t.List[str]]:
         """Return a dict of options for the window.
 
         Parameters
@@ -444,11 +494,20 @@ def show_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict":
         if g:
             tmux_args += ("-g",)
 
-        tmux_args += (
-            "show-options",
-            "-w-",
-        )
-        cmd = self.cmd(*tmux_args)
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
+
+        if include_parents is not None and include_parents:
+            tmux_args += ("-A",)
+
+        if include_hooks is not None and include_hooks:
+            tmux_args += ("-H",)
+
+        if values_only is not None and values_only:
+            tmux_args += ("-v",)
+
+        cmd = self.cmd("show-options", *tmux_args)
 
         output = cmd.stdout
 
@@ -483,10 +542,19 @@ def show_window_option(
 
         """
         warnings.warn("Window.show_window_option() is deprecated", stacklevel=2)
-        return self.show_option(option=option, g=g)
+        return self.show_option(
+            option=option,
+            g=g,
+            scope=OptionScope.Window,
+        )
 
     def show_option(
-        self, option: str, g: bool = False
+        self,
+        option: str,
+        g: bool = False,
+        scope: t.Optional[OptionScope] = OptionScope.Window,
+        include_hooks: t.Optional[bool] = None,
+        include_parents: t.Optional[bool] = None,
     ) -> t.Optional[t.Union[str, int]]:
         """Return option value for the target window.
 
@@ -508,9 +576,19 @@ def show_option(
         if g:
             tmux_args += ("-g",)
 
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
+
+        if include_parents is not None and include_parents:
+            tmux_args += ("-A",)
+
+        if include_hooks is not None and include_hooks:
+            tmux_args += ("-H",)
+
         tmux_args += (option,)
 
-        cmd = self.cmd("show-options", "-w", *tmux_args)
+        cmd = self.cmd("show-options", *tmux_args)
 
         if len(cmd.stderr):
             handle_option_error(cmd.stderr[0])

From 797b54809b477653416b6285153ef2dca765ab55 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Tue, 6 Feb 2024 05:12:48 -0600
Subject: [PATCH 14/28] tests(Window): show_options w/ scope

---
 tests/test_window.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/tests/test_window.py b/tests/test_window.py
index ce42da850..f303789ba 100644
--- a/tests/test_window.py
+++ b/tests/test_window.py
@@ -9,6 +9,7 @@
 from libtmux import exc
 from libtmux._internal.query_list import ObjectDoesNotExist
 from libtmux.common import has_gte_version, has_lt_version
+from libtmux.constants import OptionScope
 from libtmux.pane import Pane
 from libtmux.server import Server
 from libtmux.session import Session
@@ -222,6 +223,27 @@ def test_show_window_options(session: Session) -> None:
     options = window.show_window_options()
     assert isinstance(options, dict)
 
+    options_2 = window.show_options()
+    assert isinstance(options_2, dict)
+
+    pane_options = window.show_options(scope=OptionScope.Pane)
+    assert isinstance(pane_options, dict)
+
+    pane_options_global = window.show_options(scope=OptionScope.Pane, g=True)
+    assert isinstance(pane_options_global, dict)
+
+    window_options = window.show_options(scope=OptionScope.Window)
+    assert isinstance(window_options, dict)
+
+    window_options_global = window.show_options(scope=OptionScope.Window, g=True)
+    assert isinstance(window_options_global, dict)
+
+    server_options = window.show_options(scope=OptionScope.Server)
+    assert isinstance(server_options, dict)
+
+    server_options_global = window.show_options(scope=OptionScope.Server, g=True)
+    assert isinstance(server_options_global, dict)
+
 
 def test_set_window_and_show_window_options(session: Session) -> None:
     """Window.set_window_option() then Window.show_window_options(key)."""

From b130540c82815b9f92121e6ad52e655d1f59fa00 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Tue, 6 Feb 2024 05:46:33 -0600
Subject: [PATCH 15/28] tests: show_window_option() -> show_option()

---
 tests/legacy_api/test_window.py | 12 ++++++------
 tests/test_window.py            | 10 +++++-----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/tests/legacy_api/test_window.py b/tests/legacy_api/test_window.py
index c0d0aa88e..ccb03a6c9 100644
--- a/tests/legacy_api/test_window.py
+++ b/tests/legacy_api/test_window.py
@@ -227,20 +227,20 @@ def test_set_window_and_show_window_options(session: Session) -> None:
         assert window.show_window_option("pane-border-format") == " #P "
 
 
-def test_set_and_show_window_options(session: Session) -> None:
-    """Window.set_option() then Window.show_window_options(key)."""
+def test_set_and_show_options(session: Session) -> None:
+    """Window.set_option() then Window.show_options(key)."""
     window = session.new_window(window_name="test_window")
 
     window.set_option("main-pane-height", 20)
-    assert window.show_window_option("main-pane-height") == 20
+    assert window.show_option("main-pane-height") == 20
 
     window.set_option("main-pane-height", 40)
-    assert window.show_window_option("main-pane-height") == 40
-    assert window.show_window_options()["main-pane-height"] == 40
+    assert window.show_option("main-pane-height") == 40
+    assert window.show_options()["main-pane-height"] == 40
 
     if has_gte_version("2.3"):
         window.set_option("pane-border-format", " #P ")
-        assert window.show_window_option("pane-border-format") == " #P "
+        assert window.show_option("pane-border-format") == " #P "
 
 
 def test_empty_window_option_returns_None(session: Session) -> None:
diff --git a/tests/test_window.py b/tests/test_window.py
index f303789ba..a7fdcbfe7 100644
--- a/tests/test_window.py
+++ b/tests/test_window.py
@@ -262,19 +262,19 @@ def test_set_window_and_show_window_options(session: Session) -> None:
 
 
 def test_set_and_show_window_options(session: Session) -> None:
-    """Window.set_option() then Window.show_window_options(key)."""
+    """Window.set_option() then Window.show_options(key)."""
     window = session.new_window(window_name="test_window")
 
     window.set_option("main-pane-height", 20)
-    assert window.show_window_option("main-pane-height") == 20
+    assert window.show_option("main-pane-height") == 20
 
     window.set_option("main-pane-height", 40)
-    assert window.show_window_option("main-pane-height") == 40
-    assert window.show_window_options()["main-pane-height"] == 40
+    assert window.show_option("main-pane-height") == 40
+    assert window.show_options()["main-pane-height"] == 40
 
     if has_gte_version("2.3"):
         window.set_option("pane-border-format", " #P ")
-        assert window.show_window_option("pane-border-format") == " #P "
+        assert window.show_option("pane-border-format") == " #P "
 
 
 def test_empty_window_option_returns_None(session: Session) -> None:

From f15839da87594342d8c0b4877bf9ca1f31f5aa09 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 12:09:00 -0600
Subject: [PATCH 16/28] common: Add OptionMixin

---
 src/libtmux/common.py | 107 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/src/libtmux/common.py b/src/libtmux/common.py
index 778edaabe..9484c77a3 100644
--- a/src/libtmux/common.py
+++ b/src/libtmux/common.py
@@ -13,6 +13,8 @@
 import typing as t
 from typing import Dict, Optional, Union
 
+from libtmux.constants import OPTION_SCOPE_FLAG_MAP, OptionScope
+
 from . import exc
 from ._compat import LooseVersion, console_to_str, str_from_console
 
@@ -36,6 +38,111 @@
 PaneDict = t.Dict[str, t.Any]
 
 
+class CmdProtocol(t.Protocol):
+    """Command protocol for tmux command."""
+
+    def __call__(self, cmd: str, *args: t.Any, **kwargs: t.Any) -> "tmux_cmd":
+        """Wrap tmux_cmd."""
+        ...
+
+
+class CmdMixin:
+    """Command mixin for tmux command."""
+
+    cmd: CmdProtocol
+
+
+class OptionMixin(CmdMixin):
+    """Mixin for manager session and server level environment variables in tmux."""
+
+    default_scope: OptionScope
+
+    def __init__(self, default_scope: OptionScope) -> None:
+        self.default_scope = default_scope
+
+    def set_option(
+        self,
+        option: str,
+        value: t.Union[int, str],
+        _format: t.Optional[bool] = None,
+        unset: t.Optional[bool] = None,
+        unset_panes: t.Optional[bool] = None,
+        prevent_overwrite: t.Optional[bool] = None,
+        suppress_warnings: t.Optional[bool] = None,
+        append: t.Optional[bool] = None,
+        g: t.Optional[bool] = None,
+        scope: t.Optional[OptionScope] = None,
+    ) -> "t.Self":
+        """Set option for tmux window.
+
+        Wraps ``$ tmux set-option <option> <value>``.
+
+        Parameters
+        ----------
+        option : str
+            option to set, e.g. 'aggressive-resize'
+        value : str
+            window option value. True/False will turn in 'on' and 'off',
+            also accepts string of 'on' or 'off' directly.
+
+        Raises
+        ------
+        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
+        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
+        """
+        flags: t.List[str] = []
+        if isinstance(value, bool) and value:
+            value = "on"
+        elif isinstance(value, bool) and not value:
+            value = "off"
+
+        if unset is not None and unset:
+            assert isinstance(unset, bool)
+            flags.append("-u")
+
+        if unset_panes is not None and unset_panes:
+            assert isinstance(unset_panes, bool)
+            flags.append("-U")
+
+        if _format is not None and _format:
+            assert isinstance(_format, bool)
+            flags.append("-F")
+
+        if prevent_overwrite is not None and prevent_overwrite:
+            assert isinstance(prevent_overwrite, bool)
+            flags.append("-o")
+
+        if suppress_warnings is not None and suppress_warnings:
+            assert isinstance(suppress_warnings, bool)
+            flags.append("-q")
+
+        if append is not None and append:
+            assert isinstance(append, bool)
+            flags.append("-a")
+
+        if g is not None and g:
+            assert isinstance(g, bool)
+            flags.append("-g")
+
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            flags.append(
+                OPTION_SCOPE_FLAG_MAP[scope],
+            )
+
+        cmd = self.cmd(
+            "set-option",
+            *flags,
+            option,
+            value,
+        )
+
+        if isinstance(cmd.stderr, list) and len(cmd.stderr):
+            handle_option_error(cmd.stderr[0])
+
+        return self
+
+
 class EnvironmentMixin:
     """Mixin for manager session and server level environment variables in tmux."""
 

From 36f45537a3414399684702aef58a1fd751abec0b Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 12:09:32 -0600
Subject: [PATCH 17/28] Window: Use OptionMixin.set_option()

---
 src/libtmux/window.py | 87 +------------------------------------------
 1 file changed, 2 insertions(+), 85 deletions(-)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index cd4736f2e..e702f3c63 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -18,7 +18,7 @@
 from libtmux.pane import Pane
 
 from . import exc
-from .common import PaneDict, WindowOptionDict, handle_option_error
+from .common import OptionMixin, PaneDict, WindowOptionDict, handle_option_error
 from .formats import FORMAT_SEPARATOR
 
 if t.TYPE_CHECKING:
@@ -29,7 +29,7 @@
 
 
 @dataclasses.dataclass()
-class Window(Obj):
+class Window(Obj, OptionMixin):
     """:term:`tmux(1)` :term:`Window` [window_manual]_.
 
     Holds :class:`Pane` objects.
@@ -344,89 +344,6 @@ def set_window_option(
 
         return self.set_option(option=option, value=value)
 
-    def set_option(
-        self,
-        option: str,
-        value: t.Union[int, str],
-        _format: t.Optional[bool] = None,
-        unset: t.Optional[bool] = None,
-        unset_panes: t.Optional[bool] = None,
-        prevent_overwrite: t.Optional[bool] = None,
-        suppress_warnings: t.Optional[bool] = None,
-        append: t.Optional[bool] = None,
-        g: t.Optional[bool] = None,
-        scope: t.Optional[OptionScope] = None,
-    ) -> "Window":
-        """Set option for tmux window.
-
-        Wraps ``$ tmux set-option <option> <value>``.
-
-        Parameters
-        ----------
-        option : str
-            option to set, e.g. 'aggressive-resize'
-        value : str
-            window option value. True/False will turn in 'on' and 'off',
-            also accepts string of 'on' or 'off' directly.
-
-        Raises
-        ------
-        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
-        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
-        """
-        flags: t.List[str] = []
-        if isinstance(value, bool) and value:
-            value = "on"
-        elif isinstance(value, bool) and not value:
-            value = "off"
-
-        if unset is not None and unset:
-            assert isinstance(unset, bool)
-            flags.append("-u")
-
-        if unset_panes is not None and unset_panes:
-            assert isinstance(unset_panes, bool)
-            flags.append("-U")
-
-        if _format is not None and _format:
-            assert isinstance(_format, bool)
-            flags.append("-F")
-
-        if prevent_overwrite is not None and prevent_overwrite:
-            assert isinstance(prevent_overwrite, bool)
-            flags.append("-o")
-
-        if suppress_warnings is not None and suppress_warnings:
-            assert isinstance(suppress_warnings, bool)
-            flags.append("-q")
-
-        if append is not None and append:
-            assert isinstance(append, bool)
-            flags.append("-a")
-
-        if g is not None and g:
-            assert isinstance(g, bool)
-            flags.append("-g")
-
-        if scope is not None:
-            assert scope in OPTION_SCOPE_FLAG_MAP
-            flags.append(
-                OPTION_SCOPE_FLAG_MAP[scope],
-            )
-
-        cmd = self.cmd(
-            "set-option",
-            f"-t{self.session_id}:{self.window_index}",
-            *flags,
-            option,
-            value,
-        )
-
-        if isinstance(cmd.stderr, list) and len(cmd.stderr):
-            handle_option_error(cmd.stderr[0])
-
-        return self
-
     def show_window_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict":
         """Show options for tmux window. Deprecated by :meth:`Window.show_options()`.
 

From f5575fb17aeeb4017cb9e2970fff7a0a7a3cea84 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 14:37:01 -0600
Subject: [PATCH 18/28] constants: Add _DefaultScope

---
 src/libtmux/constants.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/libtmux/constants.py b/src/libtmux/constants.py
index cfb9df7ff..2a3d23181 100644
--- a/src/libtmux/constants.py
+++ b/src/libtmux/constants.py
@@ -3,6 +3,14 @@
 import typing as t
 
 
+class _DefaultScope:
+    # Sentinel value for default scope
+    ...
+
+
+DEFAULT_SCOPE: _DefaultScope = _DefaultScope()
+
+
 class OptionScope(enum.Enum):
     """Scope used with ``set-option`` and ``show-option(s)`` commands."""
 

From 5a376d6ce61e3495dcaef6ccf78bd7edb0bf44d4 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 14:37:03 -0600
Subject: [PATCH 19/28] common: _DefaultScope sentinel value

---
 src/libtmux/common.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/libtmux/common.py b/src/libtmux/common.py
index 9484c77a3..4ccdaeddb 100644
--- a/src/libtmux/common.py
+++ b/src/libtmux/common.py
@@ -13,7 +13,12 @@
 import typing as t
 from typing import Dict, Optional, Union
 
-from libtmux.constants import OPTION_SCOPE_FLAG_MAP, OptionScope
+from libtmux.constants import (
+    DEFAULT_SCOPE,
+    OPTION_SCOPE_FLAG_MAP,
+    OptionScope,
+    _DefaultScope,
+)
 
 from . import exc
 from ._compat import LooseVersion, console_to_str, str_from_console
@@ -71,7 +76,7 @@ def set_option(
         suppress_warnings: t.Optional[bool] = None,
         append: t.Optional[bool] = None,
         g: t.Optional[bool] = None,
-        scope: t.Optional[OptionScope] = None,
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = None,
     ) -> "t.Self":
         """Set option for tmux window.
 
@@ -90,6 +95,9 @@ def set_option(
         :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
         :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
         """
+        if scope is DEFAULT_SCOPE:
+            scope = self.default_scope
+
         flags: t.List[str] = []
         if isinstance(value, bool) and value:
             value = "on"
@@ -124,7 +132,7 @@ def set_option(
             assert isinstance(g, bool)
             flags.append("-g")
 
-        if scope is not None:
+        if scope is not None and not isinstance(scope, _DefaultScope):
             assert scope in OPTION_SCOPE_FLAG_MAP
             flags.append(
                 OPTION_SCOPE_FLAG_MAP[scope],

From cfdf62ba177e2ec7967f042785d8f23e24faf096 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 15:19:27 -0600
Subject: [PATCH 20/28] commons: OptionMixin.show_option(s)

---
 src/libtmux/common.py | 147 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 147 insertions(+)

diff --git a/src/libtmux/common.py b/src/libtmux/common.py
index 4ccdaeddb..419abaca2 100644
--- a/src/libtmux/common.py
+++ b/src/libtmux/common.py
@@ -7,6 +7,7 @@
 """
 import logging
 import re
+import shlex
 import shutil
 import subprocess
 import sys
@@ -150,6 +151,152 @@ def set_option(
 
         return self
 
+    @t.overload
+    def show_options(
+        self,
+        g: t.Optional[bool],
+        scope: t.Optional[OptionScope],
+        include_hooks: t.Optional[bool],
+        include_parents: t.Optional[bool],
+        values_only: t.Literal[True],
+    ) -> t.List[str]:
+        ...
+
+    @t.overload
+    def show_options(
+        self,
+        g: t.Optional[bool],
+        scope: t.Optional[OptionScope],
+        include_hooks: t.Optional[bool],
+        include_parents: t.Optional[bool],
+        values_only: t.Literal[None] = None,
+    ) -> "WindowOptionDict":
+        ...
+
+    @t.overload
+    def show_options(
+        self,
+        g: t.Optional[bool] = None,
+        scope: t.Optional[OptionScope] = None,
+        include_hooks: t.Optional[bool] = None,
+        include_parents: t.Optional[bool] = None,
+        values_only: t.Literal[False] = False,
+    ) -> "WindowOptionDict":
+        ...
+
+    def show_options(
+        self,
+        g: t.Optional[bool] = False,
+        scope: t.Optional[OptionScope] = OptionScope.Window,
+        include_hooks: t.Optional[bool] = None,
+        include_parents: t.Optional[bool] = None,
+        values_only: t.Optional[bool] = False,
+    ) -> t.Union["WindowOptionDict", t.List[str]]:
+        """Return a dict of options for the window.
+
+        Parameters
+        ----------
+        g : str, optional
+            Pass ``-g`` flag for global variable, default False.
+        """
+        tmux_args: t.Tuple[str, ...] = ()
+
+        if g:
+            tmux_args += ("-g",)
+
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
+
+        if include_parents is not None and include_parents:
+            tmux_args += ("-A",)
+
+        if include_hooks is not None and include_hooks:
+            tmux_args += ("-H",)
+
+        if values_only is not None and values_only:
+            tmux_args += ("-v",)
+
+        cmd = self.cmd("show-options", *tmux_args)
+
+        output = cmd.stdout
+
+        # The shlex.split function splits the args at spaces, while also
+        # retaining quoted sub-strings.
+        #   shlex.split('this is "a test"') => ['this', 'is', 'a test']
+
+        window_options: "WindowOptionDict" = {}
+        for item in output:
+            try:
+                key, val = shlex.split(item)
+            except ValueError:
+                logger.exception(f"Error extracting option: {item}")
+            assert isinstance(key, str)
+            assert isinstance(val, str)
+
+            if isinstance(val, str) and val.isdigit():
+                window_options[key] = int(val)
+
+        return window_options
+
+    def show_option(
+        self,
+        option: str,
+        g: bool = False,
+        scope: t.Optional[OptionScope] = OptionScope.Window,
+        include_hooks: t.Optional[bool] = None,
+        include_parents: t.Optional[bool] = None,
+    ) -> t.Optional[t.Union[str, int]]:
+        """Return option value for the target window.
+
+        todo: test and return True/False for on/off string
+
+        Parameters
+        ----------
+        option : str
+        g : bool, optional
+            Pass ``-g`` flag, global. Default False.
+
+        Raises
+        ------
+        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
+        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
+        """
+        tmux_args: t.Tuple[t.Union[str, int], ...] = ()
+
+        if g:
+            tmux_args += ("-g",)
+
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
+
+        if include_parents is not None and include_parents:
+            tmux_args += ("-A",)
+
+        if include_hooks is not None and include_hooks:
+            tmux_args += ("-H",)
+
+        tmux_args += (option,)
+
+        cmd = self.cmd("show-options", *tmux_args)
+
+        if len(cmd.stderr):
+            handle_option_error(cmd.stderr[0])
+
+        window_options_output = cmd.stdout
+
+        if not len(window_options_output):
+            return None
+
+        value_raw = next(shlex.split(item) for item in window_options_output)
+
+        value: t.Union[str, int] = (
+            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
+        )
+
+        return value
+
 
 class EnvironmentMixin:
     """Mixin for manager session and server level environment variables in tmux."""

From e55c478f25f934bc328d6ebdfff65a89edccd818 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 15:19:47 -0600
Subject: [PATCH 21/28] Window: Use OptionMixin for show_option(s)

---
 src/libtmux/window.py | 152 +-----------------------------------------
 1 file changed, 2 insertions(+), 150 deletions(-)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index e702f3c63..3bbe4a9c0 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -13,12 +13,12 @@
 
 from libtmux._internal.query_list import QueryList
 from libtmux.common import has_gte_version, tmux_cmd
-from libtmux.constants import OPTION_SCOPE_FLAG_MAP, OptionScope
+from libtmux.constants import OptionScope
 from libtmux.neo import Obj, fetch_obj, fetch_objs
 from libtmux.pane import Pane
 
 from . import exc
-from .common import OptionMixin, PaneDict, WindowOptionDict, handle_option_error
+from .common import OptionMixin, PaneDict, WindowOptionDict
 from .formats import FORMAT_SEPARATOR
 
 if t.TYPE_CHECKING:
@@ -358,94 +358,6 @@ def show_window_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict"
             scope=OptionScope.Window,
         )
 
-    @t.overload
-    def show_options(
-        self,
-        g: t.Optional[bool],
-        scope: t.Optional[OptionScope],
-        include_hooks: t.Optional[bool],
-        include_parents: t.Optional[bool],
-        values_only: t.Literal[True],
-    ) -> t.List[str]:
-        ...
-
-    @t.overload
-    def show_options(
-        self,
-        g: t.Optional[bool],
-        scope: t.Optional[OptionScope],
-        include_hooks: t.Optional[bool],
-        include_parents: t.Optional[bool],
-        values_only: t.Literal[None] = None,
-    ) -> "WindowOptionDict":
-        ...
-
-    @t.overload
-    def show_options(
-        self,
-        g: t.Optional[bool] = None,
-        scope: t.Optional[OptionScope] = None,
-        include_hooks: t.Optional[bool] = None,
-        include_parents: t.Optional[bool] = None,
-        values_only: t.Literal[False] = False,
-    ) -> "WindowOptionDict":
-        ...
-
-    def show_options(
-        self,
-        g: t.Optional[bool] = False,
-        scope: t.Optional[OptionScope] = OptionScope.Window,
-        include_hooks: t.Optional[bool] = None,
-        include_parents: t.Optional[bool] = None,
-        values_only: t.Optional[bool] = False,
-    ) -> t.Union["WindowOptionDict", t.List[str]]:
-        """Return a dict of options for the window.
-
-        Parameters
-        ----------
-        g : str, optional
-            Pass ``-g`` flag for global variable, default False.
-        """
-        tmux_args: t.Tuple[str, ...] = ()
-
-        if g:
-            tmux_args += ("-g",)
-
-        if scope is not None:
-            assert scope in OPTION_SCOPE_FLAG_MAP
-            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
-
-        if include_parents is not None and include_parents:
-            tmux_args += ("-A",)
-
-        if include_hooks is not None and include_hooks:
-            tmux_args += ("-H",)
-
-        if values_only is not None and values_only:
-            tmux_args += ("-v",)
-
-        cmd = self.cmd("show-options", *tmux_args)
-
-        output = cmd.stdout
-
-        # The shlex.split function splits the args at spaces, while also
-        # retaining quoted sub-strings.
-        #   shlex.split('this is "a test"') => ['this', 'is', 'a test']
-
-        window_options: "WindowOptionDict" = {}
-        for item in output:
-            try:
-                key, val = shlex.split(item)
-            except ValueError:
-                logger.exception(f"Error extracting option: {item}")
-            assert isinstance(key, str)
-            assert isinstance(val, str)
-
-            if isinstance(val, str) and val.isdigit():
-                window_options[key] = int(val)
-
-        return window_options
-
     def show_window_option(
         self,
         option: str,
@@ -465,64 +377,6 @@ def show_window_option(
             scope=OptionScope.Window,
         )
 
-    def show_option(
-        self,
-        option: str,
-        g: bool = False,
-        scope: t.Optional[OptionScope] = OptionScope.Window,
-        include_hooks: t.Optional[bool] = None,
-        include_parents: t.Optional[bool] = None,
-    ) -> t.Optional[t.Union[str, int]]:
-        """Return option value for the target window.
-
-        todo: test and return True/False for on/off string
-
-        Parameters
-        ----------
-        option : str
-        g : bool, optional
-            Pass ``-g`` flag, global. Default False.
-
-        Raises
-        ------
-        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
-        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
-        """
-        tmux_args: t.Tuple[t.Union[str, int], ...] = ()
-
-        if g:
-            tmux_args += ("-g",)
-
-        if scope is not None:
-            assert scope in OPTION_SCOPE_FLAG_MAP
-            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
-
-        if include_parents is not None and include_parents:
-            tmux_args += ("-A",)
-
-        if include_hooks is not None and include_hooks:
-            tmux_args += ("-H",)
-
-        tmux_args += (option,)
-
-        cmd = self.cmd("show-options", *tmux_args)
-
-        if len(cmd.stderr):
-            handle_option_error(cmd.stderr[0])
-
-        window_options_output = cmd.stdout
-
-        if not len(window_options_output):
-            return None
-
-        value_raw = next(shlex.split(item) for item in window_options_output)
-
-        value: t.Union[str, int] = (
-            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
-        )
-
-        return value
-
     def rename_window(self, new_name: str) -> "Window":
         """Rename window.
 
@@ -541,8 +395,6 @@ def rename_window(self, new_name: str) -> "Window":
         >>> window.rename_window('New name')
         Window(@1 1:New name, Session($1 ...))
         """
-        import shlex
-
         lex = shlex.shlex(new_name)
         lex.escape = " "
         lex.whitespace_split = False

From 448315ddfbbc83cf166301d060f36176a06c6309 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 15:45:16 -0600
Subject: [PATCH 22/28] !squash common

---
 src/libtmux/common.py | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/libtmux/common.py b/src/libtmux/common.py
index 419abaca2..1d0064220 100644
--- a/src/libtmux/common.py
+++ b/src/libtmux/common.py
@@ -77,7 +77,7 @@ def set_option(
         suppress_warnings: t.Optional[bool] = None,
         append: t.Optional[bool] = None,
         g: t.Optional[bool] = None,
-        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = None,
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = DEFAULT_SCOPE,
     ) -> "t.Self":
         """Set option for tmux window.
 
@@ -155,7 +155,7 @@ def set_option(
     def show_options(
         self,
         g: t.Optional[bool],
-        scope: t.Optional[OptionScope],
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]],
         include_hooks: t.Optional[bool],
         include_parents: t.Optional[bool],
         values_only: t.Literal[True],
@@ -166,7 +166,7 @@ def show_options(
     def show_options(
         self,
         g: t.Optional[bool],
-        scope: t.Optional[OptionScope],
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]],
         include_hooks: t.Optional[bool],
         include_parents: t.Optional[bool],
         values_only: t.Literal[None] = None,
@@ -177,7 +177,7 @@ def show_options(
     def show_options(
         self,
         g: t.Optional[bool] = None,
-        scope: t.Optional[OptionScope] = None,
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = DEFAULT_SCOPE,
         include_hooks: t.Optional[bool] = None,
         include_parents: t.Optional[bool] = None,
         values_only: t.Literal[False] = False,
@@ -187,7 +187,7 @@ def show_options(
     def show_options(
         self,
         g: t.Optional[bool] = False,
-        scope: t.Optional[OptionScope] = OptionScope.Window,
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = DEFAULT_SCOPE,
         include_hooks: t.Optional[bool] = None,
         include_parents: t.Optional[bool] = None,
         values_only: t.Optional[bool] = False,
@@ -199,12 +199,15 @@ def show_options(
         g : str, optional
             Pass ``-g`` flag for global variable, default False.
         """
+        if scope is DEFAULT_SCOPE:
+            scope = self.default_scope
+
         tmux_args: t.Tuple[str, ...] = ()
 
         if g:
             tmux_args += ("-g",)
 
-        if scope is not None:
+        if scope is not None and not isinstance(scope, _DefaultScope):
             assert scope in OPTION_SCOPE_FLAG_MAP
             tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
 
@@ -243,7 +246,7 @@ def show_option(
         self,
         option: str,
         g: bool = False,
-        scope: t.Optional[OptionScope] = OptionScope.Window,
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = DEFAULT_SCOPE,
         include_hooks: t.Optional[bool] = None,
         include_parents: t.Optional[bool] = None,
     ) -> t.Optional[t.Union[str, int]]:
@@ -262,12 +265,15 @@ def show_option(
         :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
         :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
         """
+        if scope is DEFAULT_SCOPE:
+            scope = self.default_scope
+
         tmux_args: t.Tuple[t.Union[str, int], ...] = ()
 
         if g:
             tmux_args += ("-g",)
 
-        if scope is not None:
+        if scope is not None and not isinstance(scope, _DefaultScope):
             assert scope in OPTION_SCOPE_FLAG_MAP
             tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
 

From 656b0644ded2ef1f3414edbf332562df56d3b124 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 16:00:27 -0600
Subject: [PATCH 23/28] !squash test: Use OptionMixin

---
 src/libtmux/session.py | 156 ++---------------------------------------
 1 file changed, 4 insertions(+), 152 deletions(-)

diff --git a/src/libtmux/session.py b/src/libtmux/session.py
index 9ea495779..64617e5fe 100644
--- a/src/libtmux/session.py
+++ b/src/libtmux/session.py
@@ -11,7 +11,8 @@
 import warnings
 
 from libtmux._internal.query_list import QueryList
-from libtmux.common import tmux_cmd
+from libtmux.common import OptionMixin, tmux_cmd
+from libtmux.constants import OptionScope
 from libtmux.formats import FORMAT_SEPARATOR
 from libtmux.neo import Obj, fetch_obj, fetch_objs
 from libtmux.pane import Pane
@@ -21,7 +22,6 @@
 from .common import (
     EnvironmentMixin,
     WindowDict,
-    handle_option_error,
     has_gte_version,
     has_version,
     session_check_name,
@@ -35,7 +35,7 @@
 
 
 @dataclasses.dataclass()
-class Session(Obj, EnvironmentMixin):
+class Session(Obj, EnvironmentMixin, OptionMixin):
     """:term:`tmux(1)` :term:`Session` [session_manual]_.
 
     Holds :class:`Window` objects.
@@ -71,6 +71,7 @@ class Session(Obj, EnvironmentMixin):
        https://man.openbsd.org/tmux.1#DESCRIPTION. Accessed April 1st, 2018.
     """
 
+    default_scope: OptionScope = OptionScope.Session
     server: "Server"
 
     def refresh(self) -> None:
@@ -170,155 +171,6 @@ def cmd(self, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
     Commands (tmux-like)
     """
 
-    def set_option(
-        self,
-        option: str,
-        value: t.Union[str, int],
-        _global: bool = False,
-    ) -> "Session":
-        """Set option ``$ tmux set-option <option> <value>``.
-
-        Parameters
-        ----------
-        option : str
-            the window option. such as 'default-shell'.
-        value : str, int, or bool
-            True/False will turn in 'on' and 'off'. You can also enter 'on' or
-            'off' directly.
-        _global : bool, optional
-            check for option globally across all servers (-g)
-
-        Raises
-        ------
-        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
-        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
-
-        Notes
-        -----
-        .. todo::
-
-            Needs tests
-        """
-        if isinstance(value, bool) and value:
-            value = "on"
-        elif isinstance(value, bool) and not value:
-            value = "off"
-
-        tmux_args: t.Tuple[t.Union[str, int], ...] = ()
-
-        if _global:
-            tmux_args += ("-g",)
-
-        assert isinstance(option, str)
-        assert isinstance(value, (str, int))
-
-        tmux_args += (
-            option,
-            value,
-        )
-
-        proc = self.cmd("set-option", *tmux_args)
-
-        if isinstance(proc.stderr, list) and len(proc.stderr):
-            handle_option_error(proc.stderr[0])
-
-        return self
-
-    def show_options(
-        self,
-        _global: t.Optional[bool] = False,
-    ) -> t.Dict[str, t.Union[str, int]]:
-        """Return dict of options for the session.
-
-        Parameters
-        ----------
-        _global : bool, optional
-            Pass ``-g`` flag for global variable (server-wide)
-
-        Returns
-        -------
-        :py:obj:`dict`
-
-        Notes
-        -----
-        Uses ``_global`` for keyword name instead of ``global`` to avoid
-        colliding with reserved keyword.
-        """
-        tmux_args: t.Tuple[str, ...] = ()
-
-        if _global:
-            tmux_args += ("-g",)
-
-        tmux_args += ("show-options",)
-        session_output = self.cmd(*tmux_args).stdout
-
-        session_options: t.Dict[str, t.Union[str, int]] = {}
-        for item in session_output:
-            key, val = item.split(" ", maxsplit=1)
-            assert isinstance(key, str)
-            assert isinstance(val, str)
-
-            if isinstance(val, str) and val.isdigit():
-                session_options[key] = int(val)
-
-        return session_options
-
-    def show_option(
-        self,
-        option: str,
-        _global: bool = False,
-    ) -> t.Optional[t.Union[str, int, bool]]:
-        """Return option value for the target session.
-
-        Parameters
-        ----------
-        option : str
-            option name
-        _global : bool, optional
-            use global option scope, same as ``-g``
-
-        Returns
-        -------
-        str, int, or bool
-
-        Raises
-        ------
-        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
-        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
-
-        Notes
-        -----
-        Uses ``_global`` for keyword name instead of ``global`` to avoid
-        colliding with reserved keyword.
-
-        Test and return True/False for on/off string.
-        """
-        tmux_args: t.Tuple[str, ...] = ()
-
-        if _global:
-            tmux_args += ("-g",)
-
-        tmux_args += (option,)
-
-        cmd = self.cmd("show-options", *tmux_args)
-
-        if isinstance(cmd.stderr, list) and len(cmd.stderr):
-            handle_option_error(cmd.stderr[0])
-
-        if not len(cmd.stdout):
-            return None
-
-        value_raw: t.List[str] = next(item.split(" ") for item in cmd.stdout)
-
-        assert isinstance(value_raw[0], str)
-        assert isinstance(value_raw[1], str)
-
-        value: t.Union[str, int] = (
-            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
-        )
-
-        return value
-
     def select_window(self, target_window: t.Union[str, int]) -> "Window":
         """Select window, return selected window.
 

From 4475c4c4775e5c3ec55318b2558ea98737e397f1 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 16:00:34 -0600
Subject: [PATCH 24/28] !squash test window fix

---
 tests/test_window.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_window.py b/tests/test_window.py
index a7fdcbfe7..da80eadbe 100644
--- a/tests/test_window.py
+++ b/tests/test_window.py
@@ -184,7 +184,7 @@ def test_window_rename(
     window_name_before = "test"
     window_name_after = "ha ha ha fjewlkjflwef"
 
-    session.set_option("automatic-rename", "off")
+    session.set_option("automatic-rename", "off", scope=None)
     window = session.new_window(window_name=window_name_before, attach=True)
 
     assert window == session.attached_window

From 674699a3f28afddce578f46f9df73849431a816c Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 17:50:03 -0600
Subject: [PATCH 25/28] !squash default session

---
 src/libtmux/session.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libtmux/session.py b/src/libtmux/session.py
index 64617e5fe..bf8eab5c0 100644
--- a/src/libtmux/session.py
+++ b/src/libtmux/session.py
@@ -71,7 +71,7 @@ class Session(Obj, EnvironmentMixin, OptionMixin):
        https://man.openbsd.org/tmux.1#DESCRIPTION. Accessed April 1st, 2018.
     """
 
-    default_scope: OptionScope = OptionScope.Session
+    default_scope: OptionScope | None = None
     server: "Server"
 
     def refresh(self) -> None:

From 961b8cebc6ef008236546aef9a7a5e6e0b6b2a2c Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 17:50:18 -0600
Subject: [PATCH 26/28] !squash window default

---
 src/libtmux/window.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index 3bbe4a9c0..ba4a98adb 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -77,7 +77,7 @@ class Window(Obj, OptionMixin):
        https://man.openbsd.org/tmux.1#DESCRIPTION. Accessed April 1st, 2018.
     """
 
-    default_scope: OptionScope = OptionScope.Window
+    default_scope: OptionScope | None = None
     server: "Server"
 
     def refresh(self) -> None:

From 3a41eda178e845f4e605f3b3ea1f98f3b15faa84 Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Wed, 7 Feb 2024 17:50:23 -0600
Subject: [PATCH 27/28] !squash default common

---
 src/libtmux/common.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libtmux/common.py b/src/libtmux/common.py
index 1d0064220..e52189978 100644
--- a/src/libtmux/common.py
+++ b/src/libtmux/common.py
@@ -61,7 +61,7 @@ class CmdMixin:
 class OptionMixin(CmdMixin):
     """Mixin for manager session and server level environment variables in tmux."""
 
-    default_scope: OptionScope
+    default_scope: OptionScope | None
 
     def __init__(self, default_scope: OptionScope) -> None:
         self.default_scope = default_scope

From 66ff00d23d3b469c117068610337690bfdacb2fd Mon Sep 17 00:00:00 2001
From: Tony Narlock <tony@git-pull.com>
Date: Thu, 8 Feb 2024 06:16:10 -0600
Subject: [PATCH 28/28] !squash wip for later, typed validations

---
 src/libtmux/window.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index ba4a98adb..3b2960d30 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -28,6 +28,13 @@
 logger = logging.getLogger(__name__)
 
 
+@dataclasses.dataclass()
+class WindowOptions:
+    aggressive_resize: t.Optional[bool]
+    automatic_rename: t.Optional[bool]
+    automatic_rename_format: t.Optional[str]
+
+
 @dataclasses.dataclass()
 class Window(Obj, OptionMixin):
     """:term:`tmux(1)` :term:`Window` [window_manual]_.
@@ -144,6 +151,8 @@ def cmd(self, cmd: str, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
         if not any("-t" in str(x) for x in args):
             args = ("-t", self.window_id, *args)
 
+        print(cmd, args, kwargs)
+
         return self.server.cmd(cmd, *args, **kwargs)
 
     """