Experimental(refactor[chain]): rename package to chain and align names with ecosystem conventions

why: A study of naming across django, sqlalchemy, polars, datafusion, ibis,
dask, mypy, ruff, celery, prefect, dagster, requests, and pydantic surfaced
clearer conventions. `chain` is the recognized name for "compose an ordered
sequence that runs together" (celery/airflow chain(), itertools, langchain).
`aio` is never a library's own async-API name in that corpus (only third-party
driver files). `adapters` universally means GoF interface/value conversion, not
a live-backend bridge -- the loved words there are connection/engine/executor.

what:
- Rename libtmux._experimental.chainable_commands -> libtmux._experimental.chain
- Rename aio.py -> _async.py and adapters.py -> _connection.py
- Rename SessionPlanRunner/AsyncSessionPlanRunner ->
  SessionPlanExecutor/AsyncSessionPlanExecutor (dagster Executor.execute(plan),
  django MigrationExecutor, stdlib concurrent.futures.Executor precedent)
- Keep ir.py / plan.py / batch.py -- idiomatic and loved per the same study
  (mypy mypyc/ir, polars plans/ir; datafusion LogicalPlan; dask batch)
- Update all imports, tests, autodoc pages, toctree, and examples accordingly

Author: tony

…._experimental.chainable_commands.aio.md …pi/libtmux._experimental.chain._async.mddocs/experiment/api/libtmux._experimental.chainable_commands.aio.md renamed to docs/experiment/api/libtmux._experimental.chain._async.md docs/experiment/api/libtmux._experimental.chainable_commands.aio.md renamed to docs/experiment/api/libtmux._experimental.chain._async.md

@@ -1,12 +1,12 @@
-# Async - `libtmux._experimental.chainable_commands.aio`
+# Async - `libtmux._experimental.chain._async`
 
 :::{warning}
 Experimental. This API is **not** covered by version policies and can break or
 be removed between minor versions.
 :::
 
 ```{eval-rst}
-.. automodule:: libtmux._experimental.chainable_commands.aio
+.. automodule:: libtmux._experimental.chain._async
    :members:
    :undoc-members:
    :show-inheritance:

…erimental.chainable_commands.adapters.md …btmux._experimental.chain._connection.mddocs/experiment/api/libtmux._experimental.chainable_commands.adapters.md renamed to docs/experiment/api/libtmux._experimental.chain._connection.md docs/experiment/api/libtmux._experimental.chainable_commands.adapters.md renamed to docs/experiment/api/libtmux._experimental.chain._connection.md

@@ -1,12 +1,12 @@
-# Connecting to live tmux sessions - `libtmux._experimental.chainable_commands.adapters`
+# Connecting to live tmux sessions - `libtmux._experimental.chain._connection`
 
 :::{warning}
 Experimental. This API is **not** covered by version policies and can break or
 be removed between minor versions.
 :::
 
 ```{eval-rst}
-.. automodule:: libtmux._experimental.chainable_commands.adapters
+.. automodule:: libtmux._experimental.chain._connection
    :members:
    :undoc-members:
    :show-inheritance:

…_experimental.chainable_commands.plan.md …api/libtmux._experimental.chain.batch.mddocs/experiment/api/libtmux._experimental.chainable_commands.plan.md renamed to docs/experiment/api/libtmux._experimental.chain.batch.md docs/experiment/api/libtmux._experimental.chainable_commands.plan.md renamed to docs/experiment/api/libtmux._experimental.chain.batch.md

@@ -1,12 +1,12 @@
-# Expressions - `libtmux._experimental.chainable_commands.plan`
+# Chainability - `libtmux._experimental.chain.batch`
 
 :::{warning}
 Experimental. This API is **not** covered by version policies and can break or
 be removed between minor versions.
 :::
 
 ```{eval-rst}
-.. automodule:: libtmux._experimental.chainable_commands.plan
+.. automodule:: libtmux._experimental.chain.batch
    :members:
    :undoc-members:
    :show-inheritance:

…experimental.chainable_commands.batch.md …nt/api/libtmux._experimental.chain.ir.mddocs/experiment/api/libtmux._experimental.chainable_commands.batch.md renamed to docs/experiment/api/libtmux._experimental.chain.ir.md docs/experiment/api/libtmux._experimental.chainable_commands.batch.md renamed to docs/experiment/api/libtmux._experimental.chain.ir.md

@@ -1,12 +1,12 @@
-# Chainability - `libtmux._experimental.chainable_commands.batch`
+# Intermediate representation - `libtmux._experimental.chain.ir`
 
 :::{warning}
 Experimental. This API is **not** covered by version policies and can break or
 be removed between minor versions.
 :::
 
 ```{eval-rst}
-.. automodule:: libtmux._experimental.chainable_commands.batch
+.. automodule:: libtmux._experimental.chain.ir
    :members:
    :undoc-members:
    :show-inheritance:

…x._experimental.chainable_commands.ir.md …/api/libtmux._experimental.chain.plan.mddocs/experiment/api/libtmux._experimental.chainable_commands.ir.md renamed to docs/experiment/api/libtmux._experimental.chain.plan.md docs/experiment/api/libtmux._experimental.chainable_commands.ir.md renamed to docs/experiment/api/libtmux._experimental.chain.plan.md

@@ -1,12 +1,12 @@
-# Intermediate representation - `libtmux._experimental.chainable_commands.ir`
+# Expressions - `libtmux._experimental.chain.plan`
 
 :::{warning}
 Experimental. This API is **not** covered by version policies and can break or
 be removed between minor versions.
 :::
 
 ```{eval-rst}
-.. automodule:: libtmux._experimental.chainable_commands.ir
+.. automodule:: libtmux._experimental.chain.plan
    :members:
    :undoc-members:
    :show-inheritance:

docs/experiment/index.md

@@ -14,70 +14,70 @@ please [file an issue](https://github.com/tmux-python/libtmux/issues).
 
 ## Chainable commands
 
-`libtmux._experimental.chainable_commands` lets you build an ordered sequence of
+`libtmux._experimental.chain` lets you build an ordered sequence of
 typed tmux commands that runs as **one** native `tmux ... \; ...` invocation,
 instead of one subprocess per command. The pieces layer up, so you can reach for
 as much or as little as you need:
 
 - **Intermediate representation** -- the typed argv layer beneath everything: a
-  {class}`~libtmux._experimental.chainable_commands.ir.CommandCall` is a single
+  {class}`~libtmux._experimental.chain.ir.CommandCall` is a single
   command, and a
-  {class}`~libtmux._experimental.chainable_commands.ir.CommandSequence` is an
+  {class}`~libtmux._experimental.chain.ir.CommandSequence` is an
   ordered group that renders to one argv (with standalone `;` separators) and
   dispatches once.
 - **Expressions** -- compose commands from a lazy, target-safe pane query. A
-  {class}`~libtmux._experimental.chainable_commands.plan.PaneQuery` resolves
+  {class}`~libtmux._experimental.chain.plan.PaneQuery` resolves
   against a pure
-  {class}`~libtmux._experimental.chainable_commands.plan.TmuxSnapshot`, maps each
+  {class}`~libtmux._experimental.chain.plan.TmuxSnapshot`, maps each
   typed row to commands, and compiles to one sequence -- so you can build and
   assert the result without touching tmux.
-- **Async** -- {mod}`~libtmux._experimental.chainable_commands.aio` mirrors the
+- **Async** -- {mod}`~libtmux._experimental.chain._async` mirrors the
   same query and dispatch API with `await`, while command construction stays
   synchronous and one expression still compiles to one invocation.
 - **Connecting to live tmux sessions** -- the bridge to a real server:
-  {func}`~libtmux._experimental.chainable_commands.adapters.snapshot_from_session`
+  {func}`~libtmux._experimental.chain._connection.snapshot_from_session`
   reads live panes, and
-  {class}`~libtmux._experimental.chainable_commands.adapters.SessionPlanRunner`
+  {class}`~libtmux._experimental.chain._connection.SessionPlanExecutor`
   (with its async counterpart
-  {class}`~libtmux._experimental.chainable_commands.adapters.AsyncSessionPlanRunner`)
+  {class}`~libtmux._experimental.chain._connection.AsyncSessionPlanExecutor`)
   resolves and runs an expression against a live {class}`~libtmux.Session` in one
   invocation.
 - **Chainability** --
-  {mod}`~libtmux._experimental.chainable_commands.batch` decides which commands
+  {mod}`~libtmux._experimental.chain.batch` decides which commands
   may share one invocation: the static
-  {attr}`~libtmux._experimental.chainable_commands.ir.CommandSpec.chainable`
+  {attr}`~libtmux._experimental.chain.ir.CommandSpec.chainable`
   flag, plus a deferred result that won't hand back output until the chain has
   run.
 
 ::::{grid} 1 2 2 2
 :gutter: 2 2 3 3
 
 :::{grid-item-card} Intermediate representation
-:link: api/libtmux._experimental.chainable_commands.ir
+:link: api/libtmux._experimental.chain.ir
 :link-type: doc
 The typed argv layer: `CommandCall`, `CommandSequence`, `CommandSpec`.
 :::
 
 :::{grid-item-card} Expressions
-:link: api/libtmux._experimental.chainable_commands.plan
+:link: api/libtmux._experimental.chain.plan
 :link-type: doc
 Build commands from a lazy, target-safe pane query.
 :::
 
 :::{grid-item-card} Async
-:link: api/libtmux._experimental.chainable_commands.aio
+:link: api/libtmux._experimental.chain._async
 :link-type: doc
 The same query and dispatch API, with `await`.
 :::
 
 :::{grid-item-card} Connecting to live tmux sessions
-:link: api/libtmux._experimental.chainable_commands.adapters
+:link: api/libtmux._experimental.chain._connection
 :link-type: doc
 Read live panes and run an expression against a real session.
 :::
 
 :::{grid-item-card} Chainability
-:link: api/libtmux._experimental.chainable_commands.batch
+:link: api/libtmux._experimental.chain.batch
 :link-type: doc
 Which commands may share one invocation.
 :::
@@ -89,7 +89,7 @@ Which commands may share one invocation.
 Compose typed calls and dispatch them as one tmux invocation:
 
 ```python
->>> from libtmux._experimental.chainable_commands.ir import CommandCall
+>>> from libtmux._experimental.chain.ir import CommandCall
 >>> sequence = (
 ...     CommandCall("set-option", ("-g", "@cc_docs_a", "1"))
 ...     >> CommandCall("set-option", ("-g", "@cc_docs_b", "2"))
@@ -106,7 +106,7 @@ Build an expression from a query and compile it to one sequence -- pure, no tmux
 required:
 
 ```python
->>> from libtmux._experimental.chainable_commands.plan import (
+>>> from libtmux._experimental.chain.plan import (
 ...     PaneRef,
 ...     PaneTarget,
 ...     SessionTarget,
@@ -133,12 +133,12 @@ required:
 ```
 
 Against a live server, run the same expression in one invocation with
-{class}`~libtmux._experimental.chainable_commands.adapters.SessionPlanRunner`:
+{class}`~libtmux._experimental.chain._connection.SessionPlanExecutor`:
 
 ```python
->>> from libtmux._experimental.chainable_commands.adapters import SessionPlanRunner
->>> from libtmux._experimental.chainable_commands.plan import panes
->>> runner = SessionPlanRunner(session)
+>>> from libtmux._experimental.chain._connection import SessionPlanExecutor
+>>> from libtmux._experimental.chain.plan import panes
+>>> runner = SessionPlanExecutor(session)
 >>> live_plan = panes().filter(active=True).each(
 ...     lambda pane: pane.cmd.send_keys("echo libtmux", enter=True),
 ... )
@@ -150,8 +150,8 @@ stays synchronous; only resolution and dispatch await:
 
 ```python
 >>> import asyncio
->>> from libtmux._experimental.chainable_commands.aio import panes as async_panes
->>> from libtmux._experimental.chainable_commands.plan import (
+>>> from libtmux._experimental.chain._async import panes as async_panes
+>>> from libtmux._experimental.chain.plan import (
 ...     PaneRef,
 ...     PaneTarget,
 ...     SessionTarget,
@@ -177,9 +177,9 @@ stays synchronous; only resolution and dispatch await:
 :hidden:
 :maxdepth: 1
 
-api/libtmux._experimental.chainable_commands.ir
-api/libtmux._experimental.chainable_commands.plan
-api/libtmux._experimental.chainable_commands.aio
-api/libtmux._experimental.chainable_commands.adapters
-api/libtmux._experimental.chainable_commands.batch
+api/libtmux._experimental.chain.ir
+api/libtmux._experimental.chain.plan
+api/libtmux._experimental.chain._async
+api/libtmux._experimental.chain._connection
+api/libtmux._experimental.chain.batch
 ```

…erimental/chainable_commands/__init__.py …/libtmux/_experimental/chain/__init__.pysrc/libtmux/_experimental/chainable_commands/__init__.py renamed to src/libtmux/_experimental/chain/__init__.py src/libtmux/_experimental/chainable_commands/__init__.py renamed to src/libtmux/_experimental/chain/__init__.py

@@ -7,16 +7,16 @@
 
 The layers build on each other:
 
-- :mod:`~libtmux._experimental.chainable_commands.ir` -- the immutable argv
+- :mod:`~libtmux._experimental.chain.ir` -- the immutable argv
   intermediate representation (``CommandCall``, ``CommandSequence``).
-- :mod:`~libtmux._experimental.chainable_commands.plan` -- typed, target-safe
+- :mod:`~libtmux._experimental.chain.plan` -- typed, target-safe
   deferred query-command plans (``panes()``, ``CommandPlan``).
-- :mod:`~libtmux._experimental.chainable_commands.aio` -- an async facade over
-  the same engine (``aio.panes()``), preserving one dispatch per plan.
-- :mod:`~libtmux._experimental.chainable_commands.adapters` -- live-tmux
-  adapters (``snapshot_from_session``, ``SessionPlanRunner``,
-  ``AsyncSessionPlanRunner``).
-- :mod:`~libtmux._experimental.chainable_commands.batch` -- the chainability
+- :mod:`~libtmux._experimental.chain._async` -- an async facade over
+  the same engine (``_async.panes()``), preserving one dispatch per plan.
+- :mod:`~libtmux._experimental.chain._connection` -- live-tmux
+  connection helpers (``snapshot_from_session``, ``SessionPlanExecutor``,
+  ``AsyncSessionPlanExecutor``).
+- :mod:`~libtmux._experimental.chain.batch` -- the chainability
   contract that decides which commands may fold into one dispatch
   (``CommandSpec.chainable`` + ``DeferredCommandResult``).
 
@@ -28,19 +28,19 @@
 
 from __future__ import annotations
 
-from libtmux._experimental.chainable_commands.adapters import (
-    AsyncSessionPlanRunner,
-    SessionPlanRunner,
+from libtmux._experimental.chain._connection import (
+    AsyncSessionPlanExecutor,
+    SessionPlanExecutor,
     snapshot_from_session,
 )
-from libtmux._experimental.chainable_commands.batch import (
+from libtmux._experimental.chain.batch import (
     AutoBatchTarget,
     ChainabilityError,
     DeferredCommandResult,
     DeferredOutputUnavailable,
     is_chainable,
 )
-from libtmux._experimental.chainable_commands.ir import (
+from libtmux._experimental.chain.ir import (
     Arg,
     CommandCall,
     CommandResultLike,
@@ -49,7 +49,7 @@
     CommandSequence,
     CommandSpec,
 )
-from libtmux._experimental.chainable_commands.plan import (
+from libtmux._experimental.chain.plan import (
     CommandPlan,
     CommandValue,
     NoCommandsResolved,
@@ -65,7 +65,7 @@
 
 __all__ = [
     "Arg",
-    "AsyncSessionPlanRunner",
+    "AsyncSessionPlanExecutor",
     "AutoBatchTarget",
     "ChainabilityError",
     "CommandCall",
@@ -83,7 +83,7 @@
     "PaneRef",
     "PaneTarget",
     "PlanRunner",
-    "SessionPlanRunner",
+    "SessionPlanExecutor",
     "SessionTarget",
     "TmuxSnapshot",
     "WindowTarget",

…/_experimental/chainable_commands/aio.py src/libtmux/_experimental/chain/_async.pysrc/libtmux/_experimental/chainable_commands/aio.py renamed to src/libtmux/_experimental/chain/_async.py src/libtmux/_experimental/chainable_commands/aio.py renamed to src/libtmux/_experimental/chain/_async.py

@@ -1,10 +1,10 @@
 r"""Asyncio facade over the deferred query-command plan.
 
 This is a thin wrapper over the sync
-:mod:`~libtmux._experimental.chainable_commands.plan` engine: command
+:mod:`~libtmux._experimental.chain.plan` engine: command
 *construction* stays synchronous, and only snapshot resolution and command
 dispatch become awaitable. A plan still compiles to exactly one
-:class:`~libtmux._experimental.chainable_commands.ir.CommandSequence`, so the
+:class:`~libtmux._experimental.chain.ir.CommandSequence`, so the
 "one plan = one native ``\\;`` dispatch" guarantee is preserved -- it just runs
 without blocking the event loop, and independent plans can resolve and dispatch
 concurrently.
@@ -21,8 +21,8 @@
 import typing as t
 from dataclasses import dataclass
 
-from libtmux._experimental.chainable_commands import plan as sync_plan
-from libtmux._experimental.chainable_commands.ir import (
+from libtmux._experimental.chain import plan as sync_plan
+from libtmux._experimental.chain.ir import (
     Arg,
     CommandResultLike,
     CommandSequence,
@@ -72,7 +72,7 @@ class PaneQuery:
     Examples
     --------
     >>> import asyncio
-    >>> from libtmux._experimental.chainable_commands.plan import (
+    >>> from libtmux._experimental.chain.plan import (
     ...     PaneRef, PaneTarget, SessionTarget, TmuxSnapshot, WindowTarget,
     ... )
     >>> snapshot = TmuxSnapshot(panes=(
@@ -150,7 +150,7 @@ class CommandPlan(t.Generic[ResultT]):
     Examples
     --------
     >>> import asyncio
-    >>> from libtmux._experimental.chainable_commands.plan import (
+    >>> from libtmux._experimental.chain.plan import (
     ...     PaneRef, PaneTarget, SessionTarget, TmuxSnapshot, WindowTarget,
     ... )
     >>> snapshot = TmuxSnapshot(panes=(
@@ -179,7 +179,7 @@ async def to_sequence(self, source: AsyncSnapshotSource) -> CommandSequence:
         """Resolve the async query and compile mapped commands.
 
         Reuses the sync compile path, so a plan still produces exactly one
-        :class:`~libtmux._experimental.chainable_commands.ir.CommandSequence`.
+        :class:`~libtmux._experimental.chain.ir.CommandSequence`.
         """
         snapshot = await _resolve_snapshot(source)
         return self.query.query.flat_map(self.mapper).to_sequence(snapshot)