From 7413fcbdc4ce1835f65c7552461b1d53d33ed837 Mon Sep 17 00:00:00 2001
From: Axl <bryannicholas7@gmail.com>
Date: Thu, 10 Sep 2026 23:00:06 +0700
Subject: [PATCH 1/9] Add an MCP server for AI clients, and a bytecode gadget
 finder
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

sevm mcp serves the debugger over MCP stdio as a third frontend, shaped
for a consumer that cannot scroll panes or watch them change:

- every windowed read takes offset/size and returns {items, total,
  truncated}; every navigation tool returns the same stop report (pc,
  opcode, gas, sp, location, stack top, stack delta since the previous
  stop); sevm_diff_since_last_stop reports stack pushes/pops with
  values, changed memory ranges and gas spent
- 37 tools: session lifecycle (web3.py driver scripts and .t.sol
  Foundry tests, restart with new args), navigation, windowed state
  reads, decoded storage/locals/arguments/logs, source and disassembly
  windows, breakpoints and watchpoints, Solidity evaluation against the
  paused frame, live mutation (stack/gas/memory/storage/pc), and a raw
  gdb-verb passthrough (vm.* cheatcodes, Yul, jump, reseat)
- failures return {"error": ...} dicts with the fix in the message

Both targets and a new find HEX command share a fresh find_needle
inspect op: every offset of a byte pattern in the RUNNING code, with
instruction alignment and the nearest preceding JUMPDEST — the address
an indirect jump can reach. bytes(CodeStream) iterates from the current
pc, so the op reads _raw_code_bytes to search the whole program.

Verified: full suite 802 passed; stdio JSON-RPC smoke (initialize,
tools/list, call_tool); in-memory client round trip; and a TokyoPayload
gadget hunt through the driver locating POP4/CALLDATALOAD/DELEGATECALL/
STOP gadgets in the optimized runtime.
---
 README.md                        |  24 +
 docs/commands.md                 |   1 +
 docs/mcp.md                      | 133 +++++
 pyproject.toml                   |   2 +
 src/sevm/cli.py                  |  28 +
 src/sevm/commands/help.py        |   1 +
 src/sevm/commands/inspecting.py  |  45 ++
 src/sevm/mcp_server/__init__.py  |  21 +
 src/sevm/mcp_server/driver.py    | 890 +++++++++++++++++++++++++++++++
 src/sevm/mcp_server/serialize.py | 125 +++++
 src/sevm/mcp_server/tools.py     | 318 +++++++++++
 src/sevm/session/inspect_ops.py  |  58 +-
 tests/test_commands.py           |  14 +
 tests/test_mcp_server.py         | 264 +++++++++
 uv.lock                          | 695 +++++++++++++++++++++++-
 15 files changed, 2611 insertions(+), 8 deletions(-)
 create mode 100644 docs/mcp.md
 create mode 100644 src/sevm/mcp_server/__init__.py
 create mode 100644 src/sevm/mcp_server/driver.py
 create mode 100644 src/sevm/mcp_server/serialize.py
 create mode 100644 src/sevm/mcp_server/tools.py
 create mode 100644 tests/test_mcp_server.py

diff --git a/README.md b/README.md
index 9c54eb3..e175797 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,8 @@
   - [Use Foundry cheatcodes](#use-foundry-cheatcodes)
   - [Run Yul at the prompt](#run-yul-at-the-prompt)
   - [Work without source](#work-without-source)
+  - [Find a gadget](#find-a-gadget)
+  - [Debug from an AI client (MCP)](#debug-from-an-ai-client-mcp)
   - [Compile a project](#compile-a-project)
   - [Check the environment](#check-the-environment)
 - [Reference](#reference)
@@ -549,6 +551,27 @@ When the dispatcher does test it, `info address` reports the wrapper it jumps to
 implementation's JUMPDEST behind it, which is the pc every caller converges on. See
 [docs/commands.md](docs/commands.md#selectors-and-the-dispatcher).
 
+### Find a gadget
+
+`find HEX` reports every offset in the running code where the byte pattern occurs, with
+the context a jump-oriented chain needs — instruction alignment and the nearest preceding
+JUMPDEST, the address an indirect jump can actually reach:
+
+```bash
+(sevm) find 5b50505050
+2 occurrence(s) of 5b50505050 in Counter
+  0x0184  JUMPDEST  (JUMPDEST, jump via 0x0184)
+  0x0279  5b50505050  (inside operand, jump via 0x0210)
+```
+
+### Debug from an AI client (MCP)
+
+`sevm mcp` serves the whole debugger over the Model Context Protocol (stdio) — the third
+frontend after the console and the TUI, shaped for a consumer that cannot scroll panes or
+watch them change: windowed reads with explicit truncation, a uniform stop report after
+every navigation, and a diff of what the last step changed. See
+[docs/mcp.md](docs/mcp.md) for the tool list and client configuration.
+
 ### Compile a project
 
 `sevm compile` runs the same build the debugger does and reports what it produced, which is
@@ -617,6 +640,7 @@ an `overrides` line so a stale environment variable cannot hide.
 | [docs/expressions.md](docs/expressions.md) | evaluating Solidity, reading and writing local variables |
 | [docs/assembly.md](docs/assembly.md) | Yul builtins at the prompt, what is refused and why |
 | [docs/foundry.md](docs/foundry.md) | projects, library install, the build cache, cheatcodes |
+| [docs/mcp.md](docs/mcp.md) | the MCP server for AI clients: tools, data shapes, configuration |
 
 ## Development
 
diff --git a/docs/commands.md b/docs/commands.md
index 90b2fdd..1758267 100644
--- a/docs/commands.md
+++ b/docs/commands.md
@@ -70,6 +70,7 @@ as `reverted: "..."`, `panic 0x11`, or a custom error with its arguments.
 | `ptype EXPR` | report the Solidity type |
 | `display EXPR` | re-evaluate at every stop |
 | `x/NFU ADDR` | examine memory, gdb syntax; a bare `x` continues past the last dump, format reused |
+| `find HEX` | every offset in the running code where the byte pattern occurs, with instruction alignment and the nearest preceding JUMPDEST — gadget hunting |
 | `bt` / `f N` / `up` / `down` | call stack and frame selection |
 | `l` / `list` / `disas` | source listing / disassembly |
 | `info registers` | pc, gas + refund, depth, stack height, memory and calldata sizes, `msg.*`, `tx.origin`, static flag |
diff --git a/docs/mcp.md b/docs/mcp.md
new file mode 100644
index 0000000..89f273e
--- /dev/null
+++ b/docs/mcp.md
@@ -0,0 +1,133 @@
+# MCP server — sevm for AI clients
+
+`sevm mcp` runs the debugger as a [Model Context Protocol](https://modelcontextprotocol.io)
+server over stdio. It is the third frontend (after the console and the TUI), built for a
+consumer that cannot scroll a pane, watch colour, or press F5: an LLM stepping a
+transaction needs different data shapes than a human at a terminal.
+
+[back to README](../README.md)
+
+## Why the MCP surface is shaped differently
+
+| A human... | An AI client... | So the tools... |
+|---|---|---|
+| scrolls the memory pane | gets one fixed response | every windowed read takes `offset`/`words` and returns `{items, total, truncated}` — narrow the window, don't ask for more |
+| watches panes change live | only sees tool results | `sevm_diff_since_last_stop` reports stack pushes/pops, changed memory ranges and gas after each step |
+| knows where they are | must be told, every time | every navigation tool returns the same stop report (pc, opcode, gas, sp, location, stack top, stack delta) |
+| reads syntax highlighting | pays per token | output is plain JSON: full-width hex words, decimal counts, no markup |
+| restarts on a typo | cannot recover silently | failures return `{"error": "..."}` with the fix in the message |
+
+## Running it
+
+```bash
+sevm mcp                # if installed globally (uv tool install .)
+# or from a checkout:
+uv --directory /path/to/debugger run sevm mcp
+# longer targets need a longer first-stop budget:
+sevm mcp --timeout 300
+```
+
+Any MCP client that speaks stdio can connect. Generic configuration:
+
+```json
+{
+  "mcpServers": {
+    "sevm": {
+      "command": "sevm",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+or, without a global install:
+
+```json
+{
+  "mcpServers": {
+    "sevm": {
+      "command": "uv",
+      "args": ["--directory", "C:/path/to/debugger", "run", "sevm", "mcp"]
+    }
+  }
+}
+```
+
+One debug session is active at a time; starting a new target replaces it.
+
+## Tool reference
+
+### Lifecycle
+
+| Tool | Meaning |
+|---|---|
+| `sevm_start_session` | compile and start a target — a web3.py driver script (extra `args` forwarded, `@path` args read from file) or a `.t.sol` Foundry test (`match`/`match_contract` select tests). Returns the first stop report |
+| `sevm_stop_session` | dispose the session (chain state is discarded) |
+| `sevm_restart_session` | re-run from scratch: fresh chain, breakpoints kept, optional new script args |
+
+### Navigation — every tool returns the uniform stop report
+
+| Tool | Meaning |
+|---|---|
+| `sevm_continue` | run to the next breakpoint/watchpoint/error, or program end |
+| `sevm_step_opcodes` | `count` opcodes (≤1000) |
+| `sevm_step_lines` / `sevm_next_lines` | Solidity lines, into / over internal calls |
+| `sevm_finish_frame` | run to the end of the current frame |
+| `sevm_run_to` | a pc, or a location like `Bank.sol:46` / `*0x108` |
+| `sevm_get_status` | the stop report alone |
+| `sevm_diff_since_last_stop` | what the last navigation changed |
+
+### Inspection (windowed, truncation-flagged)
+
+| Tool | Meaning |
+|---|---|
+| `sevm_read_memory` | 32-byte words, region-annotated; `beyond: true` marks unallocated reads-as-zero |
+| `sevm_read_stack` | operand stack, index 0 = top |
+| `sevm_read_storage` | decoded layout by default (names, types, packed slots), or raw slots |
+| `sevm_read_calldata` | windowed; first window includes selector + signature |
+| `sevm_get_backtrace` | Solidity and EVM frames interleaved |
+| `sevm_get_locals` / `sevm_get_arguments` | decoded locals / ABI-decoded call arguments |
+| `sevm_disassemble` | rows `{pc, text, jumpdest, line}` around a pc |
+| `sevm_read_source` | numbered source window, current line flagged |
+| `sevm_get_gas_profile` | spend by opcode and by source line |
+| `sevm_get_logs` | events so far, names decoded |
+| `sevm_list_contracts` / `sevm_list_functions` | the compiled surface |
+
+### Search
+
+| Tool | Meaning |
+|---|---|
+| `sevm_find_bytes` | hex pattern in `code` (gadget hunting: pc, instruction alignment, nearest preceding JUMPDEST), `memory`, or `calldata` |
+
+### Breakpoints
+
+| Tool | Meaning |
+|---|---|
+| `sevm_set_breakpoint` | `File.sol:LINE`, `*0xPC`, or a function name; optional Solidity `condition` |
+| `sevm_set_opcode_breakpoint` | every occurrence of an opcode (`SSTORE`, `DELEGATECALL`, ...) |
+| `sevm_set_watchpoint` | storage value written/read/accessed, or `*0x40` memory |
+| `sevm_list_breakpoints` / `sevm_delete_breakpoint` | management |
+
+### Mutation and evaluation
+
+| Tool | Meaning |
+|---|---|
+| `sevm_evaluate` | real Solidity against the paused frame (state, mappings, locals, `keccak256`, `abi.encode`, units); `keep: true` keeps side effects like gdb's `call` |
+| `sevm_set_gas` | overwrite the gas meter; at an out-of-gas stop, continuing retries the failed instruction |
+| `sevm_set_stack_slot` | rewrite an operand before its opcode consumes it |
+| `sevm_write_memory` / `sevm_write_storage` | raw writes |
+| `sevm_set_pc` | move the pc (JUMPDESTs only) |
+| `sevm_command` | raw gdb-verb passthrough for everything else: `vm.*` cheatcodes, Yul, `jump`, `reseat`, `x/32xb 0x40` |
+
+## A first session
+
+```
+sevm_start_session(target="exploit.py", contracts="contracts/", optimize=true)
+sevm_find_bytes(pattern="5b50505050", scope="code")      # gadget hunt
+sevm_set_breakpoint(location="*0x1a2")                   # or "deposit", "SSTORE"
+sevm_continue()
+sevm_read_memory(offset=0x40, words=4)
+sevm_evaluate(expression="balances[msg.sender]")
+sevm_diff_since_last_stop()
+sevm_restart_session(args=["0x<new payload>"])
+```
diff --git a/pyproject.toml b/pyproject.toml
index 77930b8..3d24c47 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -47,6 +47,8 @@ dependencies = [
     "rlp>=4.0",
     "packaging>=23.0",
     "requests>=2.31",
+    "mcp>=2.2.0",
+    "anyio>=4.15.1",
 ]
 
 [project.scripts]
diff --git a/src/sevm/cli.py b/src/sevm/cli.py
index 5c28682..4ccbd08 100644
--- a/src/sevm/cli.py
+++ b/src/sevm/cli.py
@@ -168,6 +168,22 @@ def build_parser() -> argparse.ArgumentParser:
         "doctor", help="report the compiler, runtimes and caches sevm found here"
     )
 
+    mcp_cmd = sub.add_parser(
+        "mcp",
+        help="run the MCP server for AI clients (stdio transport)",
+        description=(
+            "Run sevm as a Model Context Protocol server over stdio. An MCP client "
+            "starts/steps debug sessions and reads structured, windowed state — "
+            "see docs/mcp.md for the tool list and client configuration."
+        ),
+    )
+    mcp_cmd.add_argument(
+        "--timeout",
+        type=float,
+        default=120.0,
+        help="seconds to wait for the target to reach contract code (default: 120)",
+    )
+
     return parser
 
 
@@ -522,9 +538,21 @@ def main(argv: list[str] | None = None) -> int:
         return cmd_compile(args)
     if args.command == "doctor":
         return cmd_doctor(args)
+    if args.command == "mcp":
+        return cmd_mcp(args)
     parser.print_help()
     return 1
 
 
+def cmd_mcp(args: argparse.Namespace) -> int:
+    """Serve the debugger over MCP stdio; logs go to stderr only."""
+    from .mcp_server import DebugDriver, build_server
+
+    driver = DebugDriver(timeout=args.timeout)
+    server = build_server(driver)
+    server.run()
+    return 0
+
+
 if __name__ == "__main__":
     raise SystemExit(main())
diff --git a/src/sevm/commands/help.py b/src/sevm/commands/help.py
index b1be7b7..1dbb5d8 100644
--- a/src/sevm/commands/help.py
+++ b/src/sevm/commands/help.py
@@ -43,6 +43,7 @@
   [cyan]bt[/cyan] / [cyan]f[/cyan] N / [cyan]up[/cyan] / [cyan]down[/cyan]   call stack, EVM and Solidity frames
   [cyan]l[/cyan]ist [LINE]                  source listing
   [cyan]disas[/cyan]semble            disassembly around the pc
+  [cyan]find[/cyan] HEX               offsets of a byte pattern in the running code
   [cyan]sig[/cyan] FUNC               the signature and 4-byte selector: [dim]sig withdraw[/dim]
   [cyan]copy[/cyan] [CMD]                  put a command's output on the system clipboard
   [cyan]i[/cyan]nfo TOPIC             registers, breakpoints, frame, args, locals, storage,
diff --git a/src/sevm/commands/inspecting.py b/src/sevm/commands/inspecting.py
index 05e944a..55cf50b 100644
--- a/src/sevm/commands/inspecting.py
+++ b/src/sevm/commands/inspecting.py
@@ -161,6 +161,50 @@ def cmd_backtrace(proc: CommandProcessor, args: list[str], rest: str) -> Command
     return result
 
 
+def cmd_find(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult:
+    """`find <hex>` — every offset in the running code where the byte pattern occurs.
+
+    Gadget hunting: reports whether each hit starts on an instruction boundary, and
+    the nearest preceding JUMPDEST — the address an indirect jump can actually reach.
+    """
+    proc.require_stop()
+    if not args:
+        return CommandResult(error="usage: find <hex>   e.g. find 60515255")
+    pattern = args[0].lower().removeprefix("0x")
+    if (
+        not pattern
+        or len(pattern) % 2
+        or any(c not in "0123456789abcdef" for c in pattern)
+    ):
+        return CommandResult(error=f"not a hex pattern: {args[0]!r}")
+    found = proc.inspect("find_needle", pattern)
+    hits, total = found["hits"], found["total"]
+    name = proc.snapshot.contract_name if proc.snapshot else "the running code"
+    if not hits:
+        return CommandResult().add(f"[dim]no occurrence of {pattern} in {name}[/dim]")
+    result = CommandResult().add(
+        f"[dim]{total} occurrence(s) of {pattern} in {name}[/dim]"
+    )
+    for hit in hits[:20]:
+        flags = []
+        if hit["jumpdest"]:
+            flags.append("JUMPDEST")
+        elif hit["instruction_aligned"]:
+            flags.append("aligned")
+        else:
+            flags.append("inside operand")
+        if hit["nearest_jumpdest"] is not None:
+            flags.append(f"jump via 0x{hit['nearest_jumpdest']:04x}")
+        line = f" [dim]L{hit['line']}[/dim]" if hit["line"] else ""
+        result.add(
+            f"  [cyan]0x{hit['pc']:04x}[/cyan]  {_escape(hit['text'])}"
+            f"  [dim]({', '.join(flags)})[/dim]{line}"
+        )
+    if total > len(hits):
+        result.add(f"[dim]... and {total - len(hits)} more[/dim]")
+    return result
+
+
 def cmd_frame(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult:
     snap = proc.require_stop()
     if not args:
@@ -294,4 +338,5 @@ def cmd_disassemble(proc: CommandProcessor, args: list[str], rest: str) -> Comma
     "l": cmd_list,
     "disassemble": cmd_disassemble,
     "disas": cmd_disassemble,
+    "find": cmd_find,
 }
diff --git a/src/sevm/mcp_server/__init__.py b/src/sevm/mcp_server/__init__.py
new file mode 100644
index 0000000..a3b652a
--- /dev/null
+++ b/src/sevm/mcp_server/__init__.py
@@ -0,0 +1,21 @@
+"""The MCP frontend: an AI-oriented, headless third frontend over the debugger.
+
+Where the console renders Rich markup and the TUI draws panes, this frontend
+returns structured JSON with explicit windows and truncation flags — an LLM
+cannot scroll a pane or watch colour, but it can narrow an offset. Launch with
+`sevm mcp` (stdio transport).
+
+Where things live:
+
+  driver.py     `DebugDriver`: owns the one session, mirrors `sevm run`'s wiring,
+                and remembers the previous stop for diffs
+  serialize.py  value formatting: hex words, memory windows, the stop report
+  tools.py      the tool registrations over the driver
+"""
+
+from __future__ import annotations
+
+from .driver import DebugDriver, DriverError
+from .tools import build_server
+
+__all__ = ["DebugDriver", "DriverError", "build_server"]
diff --git a/src/sevm/mcp_server/driver.py b/src/sevm/mcp_server/driver.py
new file mode 100644
index 0000000..4165a33
--- /dev/null
+++ b/src/sevm/mcp_server/driver.py
@@ -0,0 +1,890 @@
+"""The MCP frontend's session driver.
+
+The console and the TUI are thin renderers over `CommandProcessor`; this is the
+third frontend, and the only thing it draws is JSON. `DebugDriver` owns one
+debug session (single active target, replaced by the next start), mirrors the
+wiring `sevm run` does for both target kinds, and remembers the previous stop so
+it can answer "what changed?" — the question a human answers by watching panes.
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+from typing import Any
+
+from ..commands.parsing import expand_file_args
+from ..commands.processor import CommandProcessor
+from ..commands.render import _plain
+from ..compile import CompileError, compile_foundry_project, find_foundry_root
+from ..evaluate import Evaluator, make_eval_hook
+from ..frames import FrameSnapshot
+from ..session import DebugSession, Finished, SessionError, StepMode
+from .serialize import (
+    WORD,
+    backtrace_rows,
+    hex_short,
+    hex_word,
+    memory_window,
+    snapshot_report,
+    stack_entry,
+)
+
+# Caps that keep one tool call from flooding a model's context window. Every
+# truncated result says so, so the model knows to narrow its next request.
+MAX_MEMORY_WORDS = 64
+MAX_DISASM_ROWS = 128
+MAX_SOURCE_LINES = 101
+MAX_FIND_HITS = 200
+MAX_MEMORY_SCAN = 65536
+
+
+class DriverError(RuntimeError):
+    """A tool-level failure with an actionable message."""
+
+
+class DebugDriver:
+    """One live debug target at a time, driven entirely from tool calls."""
+
+    def __init__(self, timeout: float = 120.0) -> None:
+        self.timeout = timeout
+        self._lock = threading.RLock()
+        self._session: DebugSession | None = None
+        self._processor: CommandProcessor | None = None
+        self._target_path: str | None = None
+        self._target_kind: str | None = None  # "script" | "foundry"
+        self._prev_snapshot: FrameSnapshot | None = None
+        self.notices: list[str] = []
+
+    # -- lifecycle ---------------------------------------------------------
+
+    def _notice(self, message: str) -> None:
+        self.notices.append(message)
+
+    def _require(self) -> tuple[DebugSession, CommandProcessor]:
+        if self._session is None or self._processor is None:
+            raise DriverError(
+                "no active debug session; call sevm_start_session first "
+                "(script_path for a web3.py driver or a .t.sol Foundry test)"
+            )
+        return self._session, self._processor
+
+    def start(
+        self,
+        target: str,
+        args: list[str] | None = None,
+        contracts: str | None = None,
+        solc: str | None = None,
+        optimize: bool = False,
+        match: str | None = None,
+        match_contract: str | None = None,
+        timeout: float | None = None,
+    ) -> dict[str, Any]:
+        """Compile and start a debug target; replaces any existing session."""
+        with self._lock:
+            self.stop()
+            self.notices = []
+            if timeout is not None:
+                self.timeout = timeout
+            if not os.path.isfile(target):
+                raise DriverError(f"no such file: {target}")
+            self._target_path = target
+            if target.endswith(".sol"):
+                self._target_kind = "foundry"
+                return self._start_foundry(target, solc, optimize, match, match_contract)
+            self._target_kind = "script"
+            return self._start_script(target, args or [], contracts, solc, optimize)
+
+    def _start_script(
+        self,
+        script: str,
+        args: list[str],
+        contracts: str | None,
+        solc: str | None,
+        optimize: bool,
+    ) -> dict[str, Any]:
+        # Same wiring as `sevm run <script>`: the contracts dir becomes the compile
+        # root unless it sits inside a Foundry project.
+        from ..cli import _find_contracts_dir, _run_script
+        from ..foundry import prepare_project
+
+        contracts_dir = _find_contracts_dir(script, contracts)
+        if not os.path.isdir(contracts_dir):
+            raise DriverError(
+                f"no contracts directory at {contracts}; pass one via contracts="
+            )
+        contracts_dir = os.path.abspath(contracts_dir)
+        root = find_foundry_root(contracts_dir) or contracts_dir
+        source_dirs = [contracts_dir] if os.path.abspath(root) != contracts_dir else None
+        prepared = prepare_project(
+            contracts_dir,
+            assume_yes=True,
+            allow_install=True,
+            needs_forge_std=False,
+            source_dirs=source_dirs,
+        )
+        try:
+            project = compile_foundry_project(
+                prepared.root,
+                source_dirs=source_dirs,
+                solc_version=solc,
+                optimize=optimize,
+                install_missing=prepared.may_install,
+                on_notice=self._notice,
+            )
+        except CompileError as exc:
+            raise DriverError(f"compile failed: {exc}") from exc
+        expanded = expand_file_args(list(args), " ".join(args))
+        if isinstance(expanded, str):
+            raise DriverError(expanded)
+        target_fn = _run_script(script, expanded)
+        return self._wire(
+            project,
+            target_fn,
+            foundry_mode=True,
+            restart_factory=lambda argv: _run_script(script, argv),
+            restart_argv=expanded,
+        )
+
+    def _start_foundry(
+        self,
+        sol: str,
+        solc: str | None,
+        optimize: bool,
+        match: str | None,
+        match_contract: str | None,
+    ) -> dict[str, Any]:
+        from ..foundry import (
+            compile_test,
+            discover_tests,
+            make_tests_driver,
+            prepare_project,
+            select_tests,
+        )
+
+        prepared = prepare_project(sol, assume_yes=True, allow_install=True)
+        try:
+            project = compile_test(
+                sol,
+                prepared.root,
+                solc_version=solc,
+                install_missing=prepared.may_install,
+                on_notice=self._notice,
+            )
+        except CompileError as exc:
+            raise DriverError(f"compile failed: {exc}") from exc
+        targets = discover_tests(project)
+        if not targets:
+            raise DriverError("no test functions found (no-argument test*/invariant*)")
+        selected = select_tests(targets, match=match, match_contract=match_contract)
+        if not selected:
+            available = ", ".join(f"{t.contract}.{t.function}" for t in targets)
+            raise DriverError(
+                f"no test matched match={match!r} contract={match_contract!r}; "
+                f"available: {available}"
+            )
+        self._notice(
+            "debugging " + ", ".join(f"{t.contract}.{t.function}" for t in selected)
+        )
+        driver_fn = make_tests_driver(project, selected)
+        return self._wire(
+            project,
+            driver_fn,
+            foundry_mode=True,
+            stop_functions=[f"{t.contract}.{t.function}" for t in selected],
+        )
+
+    def _wire(
+        self,
+        project: Any,
+        target: Any,
+        foundry_mode: bool,
+        stop_functions: list[str] | None = None,
+        restart_factory: Any = None,
+        restart_argv: list[str] | None = None,
+    ) -> dict[str, Any]:
+        session = DebugSession(project)
+        session.foundry_mode = foundry_mode
+        evaluator = Evaluator(project)
+        session.set_eval_hook(make_eval_hook(evaluator))
+        if restart_factory is not None:
+            session.set_restart_factory(restart_factory, restart_argv or [])
+        first_fn = first_contract = None
+        for name in stop_functions or []:
+            try:
+                session.break_at_function(name)
+            except Exception:  # a miss must not sink the rest, as in cli._debug
+                continue
+            if first_contract is None:
+                first_contract, _, first_fn = name.partition(".")
+        session.start(target)
+        first = session.wait(timeout=self.timeout)
+        if first is None:
+            session.detach()
+            raise DriverError("timed out waiting for the target to reach contract code")
+        # Advance past the unavoidable constructor stop to the first test body.
+        if first_fn is not None:
+            for _ in range(64):
+                snap = session.last_snapshot
+                fn = getattr(snap, "function", None)
+                if (
+                    fn is not None
+                    and getattr(fn, "name", None) == first_fn
+                    and getattr(fn, "contract", None) == first_contract
+                ):
+                    break
+                advanced = session.resume(StepMode.RUN, count=1, timeout=self.timeout)
+                if advanced is not None:
+                    first = advanced
+                if isinstance(advanced, Finished):
+                    break
+        self._session = session
+        self._processor = CommandProcessor(session, evaluator)
+        self._prev_snapshot = None
+        return self._report(first)
+
+    def stop(self) -> dict[str, Any]:
+        with self._lock:
+            if self._session is None:
+                return {"stopped_session": False}
+            try:
+                self._session.detach()
+            except Exception:
+                self._session.uninstall()
+            self._session = None
+            self._processor = None
+            self._target_path = None
+            self._target_kind = None
+            self._prev_snapshot = None
+            return {"stopped_session": True}
+
+    def restart(self, args: list[str] | None = None) -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            argv: list[str] | None = None
+            if args:
+                expanded = expand_file_args(list(args), " ".join(args))
+                if isinstance(expanded, str):
+                    raise DriverError(expanded)
+                argv = expanded
+            self._prev_snapshot = None
+            try:
+                event = session.restart(argv=argv, timeout=self.timeout)
+            except SessionError as exc:
+                raise DriverError(str(exc)) from exc
+            return self._report(event)
+
+    def status(self) -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            return self._report(session.last_snapshot)
+
+    # -- navigation --------------------------------------------------------
+
+    def _navigate(
+        self, mode: StepMode, count: int = 1, target_pc: int | None = None
+    ) -> dict[str, Any]:
+        with self._lock:
+            session, processor = self._require()
+            prev = session.last_snapshot
+            result = processor.resume(mode, count=count, target_pc=target_pc)
+            if result.error:
+                raise DriverError(result.error)
+            self._prev_snapshot = prev
+            return self._report(result.event)
+
+    def _report(self, event: Any) -> dict[str, Any]:
+        session = self._session
+        report: dict[str, Any] = {
+            "target": self._target_path,
+            "kind": self._target_kind,
+        }
+        if self.notices:
+            report["notices"] = self.notices[-8:]
+        if event is None or isinstance(event, Finished):
+            report.update(
+                stopped=False,
+                finished=True,
+                ok=bool(getattr(event, "ok", False)),
+                exit_error=getattr(event, "error", None),
+                last_revert=getattr(session, "last_revert", None) if session else None,
+            )
+            return report
+        snap = getattr(event, "snapshot", None)
+        if snap is None:
+            snap = session.last_snapshot if session else None
+        if snap is None:
+            report.update(
+                stopped=False,
+                finished=True,
+                ok=False,
+                exit_error="no snapshot for this stop",
+            )
+            return report
+        report.update(snapshot_report(snap))
+        report["stack_delta"] = self._stack_delta(self._prev_snapshot, snap)
+        return report
+
+    @staticmethod
+    def _stack_delta(prev: FrameSnapshot | None, snap: FrameSnapshot) -> dict[str, Any]:
+        if prev is None or prev.depth != snap.depth:
+            return {"available": False}
+        old_sp, new_sp = len(prev.stack), len(snap.stack)
+        delta: dict[str, Any] = {"available": True, "from": old_sp, "to": new_sp}
+        old_values = [e.value for e in prev.stack]
+        new_values = [e.value for e in snap.stack]
+        if new_sp > old_sp:
+            delta["pushed"] = [
+                {"index": i, "hex": hex_word(v)}
+                for i, v in enumerate(reversed(new_values[old_sp:]))
+            ]
+        elif new_sp < old_sp:
+            delta["popped"] = [
+                {"index": i, "hex": hex_word(v)}
+                for i, v in enumerate(reversed(old_values[new_sp:]))
+            ]
+        return delta
+
+    def continue_execution(self) -> dict[str, Any]:
+        return self._navigate(StepMode.RUN)
+
+    def step_opcodes(self, count: int = 1) -> dict[str, Any]:
+        return self._navigate(StepMode.STEPI, count=min(max(count, 1), 1000))
+
+    def step_lines(self, count: int = 1) -> dict[str, Any]:
+        return self._navigate(StepMode.STEP, count=max(count, 1))
+
+    def next_lines(self, count: int = 1) -> dict[str, Any]:
+        return self._navigate(StepMode.NEXT, count=max(count, 1))
+
+    def finish_frame(self) -> dict[str, Any]:
+        return self._navigate(StepMode.FINISH)
+
+    def run_to(
+        self, location: str | None = None, pc: int | None = None
+    ) -> dict[str, Any]:
+        with self._lock:
+            session, processor = self._require()
+            target_pc: int | None = None
+            if pc is not None:
+                target_pc = pc
+            elif location:
+                if location.startswith("*"):
+                    target_pc = int(location[1:], 0)
+                else:
+                    snap = processor.require_stop()
+                    source_key, line = processor.parse_location(location, snap)
+                    file_id = session.file_id_for(source_key)
+                    if file_id is None:
+                        raise DriverError(f"no source file matching {source_key!r}")
+                    _snapped, pcs = session.resolve_line(file_id, line)
+                    if not pcs:
+                        raise DriverError(f"no code at {source_key}:{line}")
+                    target_pc = min(pcs)
+            else:
+                raise DriverError("run_to needs a pc or a location like 'Bank.sol:46'")
+            return self._navigate(StepMode.UNTIL, target_pc=target_pc)
+
+    # -- inspection --------------------------------------------------------
+
+    def read_memory(self, offset: int = 0, words: int = 8) -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            snap = self._require_snapshot()
+            words = max(1, min(words, MAX_MEMORY_WORDS))
+            offset = max(0, offset)
+            data = session.inspect("read_memory", offset, words * WORD)
+            return {
+                "offset": offset,
+                "words": words,
+                "memory_size": snap.memory_size,
+                "items": memory_window(bytes(data), offset, snap.memory_size),
+                "truncated": offset + words * WORD < snap.memory_size,
+            }
+
+    def _require_snapshot(self) -> FrameSnapshot:
+        session, _ = self._require()
+        snap = session.last_snapshot
+        if snap is None or session.finished:
+            raise DriverError("not stopped; nothing to inspect")
+        return snap
+
+    def read_stack(self, offset: int = 0, limit: int = 32) -> dict[str, Any]:
+        snap = self._require_snapshot()
+        limit = max(1, min(limit, 128))
+        entries = snap.stack[offset : offset + limit]
+        return {
+            "offset": offset,
+            "total": len(snap.stack),
+            "items": [stack_entry(e) for e in entries],
+            "truncated": offset + limit < len(snap.stack),
+        }
+
+    def read_calldata(self, offset: int = 0, size: int = 256) -> dict[str, Any]:
+        with self._lock:
+            _session, processor = self._require()
+            snap = self._require_snapshot()
+            size = max(1, min(size, 4096))
+            data = bytes(snap.calldata[offset : offset + size])
+            result: dict[str, Any] = {
+                "offset": offset,
+                "size": len(data),
+                "total": len(snap.calldata),
+                "hex": "0x" + data.hex() if data else "0x",
+                "truncated": offset + size < len(snap.calldata),
+            }
+            if offset == 0 and len(snap.calldata) >= 4:
+                result["selector"] = "0x" + snap.calldata[:4].hex()
+                for candidate in processor.project.artifacts.values():
+                    if snap.calldata[:4] in candidate.selectors:
+                        result["signature"] = candidate.selectors[snap.calldata[:4]]
+                        break
+            return result
+
+    def read_storage(
+        self, slots: list[int] | None = None, decode: bool = True
+    ) -> dict[str, Any]:
+        with self._lock:
+            session, processor = self._require()
+            snap = self._require_snapshot()
+            decoded_by_slot: dict[int, dict[str, Any]] = {}
+            items: list[dict[str, Any]] = []
+            if decode:
+                decoder = processor.decoder(snap.contract_name)
+                if decoder:
+
+                    def reader(slot: int) -> int:
+                        return int(session.inspect("read_storage", slot))
+
+                    for var, value in decoder.read_all(reader):
+                        row = {
+                            "slot": var.slot,
+                            "offset": var.offset,
+                            "name": var.name,
+                            "type": var.type_label,
+                            "value": value.display,
+                        }
+                        decoded_by_slot[var.slot] = row
+                        items.append(row)
+            if slots:
+                known = set(decoded_by_slot)
+                for slot in slots:
+                    slot = int(slot)
+                    if slot in known:
+                        continue
+                    raw = int(session.inspect("read_storage", slot))
+                    items.append({"slot": slot, "hex": hex_word(raw)})
+            return {"address": hex_short(snap.address), "items": items}
+
+    def get_backtrace(self) -> dict[str, Any]:
+        snap = self._require_snapshot()
+        return {"frames": backtrace_rows(snap)}
+
+    def get_locals(self) -> dict[str, Any]:
+        with self._lock:
+            _, processor = self._require()
+            rows = processor.read_locals()
+            return {"locals": rows}
+
+    def get_arguments(self) -> dict[str, Any]:
+        with self._lock:
+            session, processor = self._require()
+            snap = self._require_snapshot()
+            info = session.inspect("frame_info")
+            calldata = bytes(info["calldata"])
+            art = (
+                processor.project.artifact(snap.contract_name)
+                if snap.contract_name
+                else None
+            )
+            decoded = None
+            if art is not None:
+                from ..decode import decode_calldata
+
+                decoded = decode_calldata(art.abi, calldata)
+            if decoded is None:
+                return {"decoded": False, "calldata_hex": "0x" + calldata.hex()}
+            signature, args = decoded
+            return {
+                "decoded": True,
+                "signature": signature,
+                "args": [
+                    {"name": name, "type": type_, "value": str(value)}
+                    for type_, name, value in args
+                ],
+            }
+
+    def disassemble(
+        self, around_pc: int | None = None, before: int = 6, after: int = 18
+    ) -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            self._require_snapshot()
+            rows = session.inspect(
+                "disassembly",
+                max(1, min(before, MAX_DISASM_ROWS)),
+                max(1, min(after, MAX_DISASM_ROWS)),
+                around_pc,
+            )
+            return {"rows": rows, "note": "row.current marks the window centre"}
+
+    def read_source(
+        self,
+        file: str | None = None,
+        around_line: int | None = None,
+        context: int = 10,
+    ) -> dict[str, Any]:
+        with self._lock:
+            _, processor = self._require()
+            snap = processor.snapshot
+            source_key = file or (
+                snap.source_key
+                if snap and snap.source_key
+                else next(iter(processor.project.sources))
+            )
+            lines = processor.source_lines(source_key)
+            if not lines:
+                raise DriverError(f"no source for {source_key}")
+            centre = around_line or (snap.line if snap and snap.line else 1)
+            context = max(1, min(context, MAX_SOURCE_LINES // 2))
+            start = max(1, centre - context)
+            end = min(len(lines), centre + context)
+            items = [
+                {
+                    "line": n,
+                    "text": lines[n - 1],
+                    "current": bool(
+                        snap and snap.source_key == source_key and n == snap.line
+                    ),
+                }
+                for n in range(start, end + 1)
+            ]
+            return {
+                "file": source_key,
+                "total_lines": len(lines),
+                "items": items,
+                "truncated": start > 1 or end < len(lines),
+            }
+
+    def get_gas_profile(self, limit: int = 20) -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            by_opcode = sorted(session.gas_by_opcode.items(), key=lambda kv: -kv[1])[
+                :limit
+            ]
+            lines = []
+            for (file_id, line), gas in sorted(
+                session.gas_by_line.items(), key=lambda kv: -kv[1]
+            )[:limit]:
+                src = session.project.source_by_id(file_id)
+                name = src.key if src else f"file {file_id}"
+                try:
+                    text = src.text.split("\n")[line - 1].strip() if src else ""
+                except IndexError:
+                    text = ""
+                lines.append({"file": name, "line": line, "gas": gas, "text": text})
+            return {"by_opcode": dict(by_opcode), "by_source_line": lines}
+
+    def get_logs(self) -> dict[str, Any]:
+        with self._lock:
+            session, processor = self._require()
+            self._require_snapshot()
+            raw = session.inspect("logs")
+            from eth_utils import event_abi_to_log_topic
+
+            def event_name(topics: tuple[int, ...]) -> str | None:
+                if not topics:
+                    return None
+                topic0 = topics[0].to_bytes(32, "big")
+                for art in processor.project.artifacts.values():
+                    for entry in art.abi:
+                        if entry.get("type") != "event":
+                            continue
+                        try:
+                            event: Any = entry  # eth_utils wants an ABIEvent-typed dict
+                            if event_abi_to_log_topic(event) == topic0:
+                                return str(entry.get("name"))
+                        except Exception:
+                            continue
+                return None
+
+            items = [
+                {
+                    "address": hex_short(address),
+                    "topics": [f"0x{t:064x}" for t in topics],
+                    "data": "0x" + bytes(data).hex(),
+                    "event": event_name(topics),
+                }
+                for address, topics, data in raw
+            ]
+            return {"logs": items}
+
+    # -- symbols -----------------------------------------------------------
+
+    def list_contracts(self) -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            return {
+                "contracts": [
+                    {
+                        "name": art.name,
+                        "qualified": qualified,
+                        "runtime_size": len(art.deployed_bytecode),
+                    }
+                    for qualified, art in sorted(session.project.artifacts.items())
+                ]
+            }
+
+    def list_functions(self, contract: str | None = None) -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            snap = session.last_snapshot
+            name = contract or (snap.contract_name if snap else None)
+            art = session.project.artifact(name) if name else None
+            if art is None:
+                raise DriverError(f"no artifact named {name!r}")
+            return {
+                "contract": art.name,
+                "functions": [
+                    {"signature": sig, "selector": "0x" + sel}
+                    for sig, sel in sorted(art.method_identifiers.items())
+                ],
+            }
+
+    # -- search ------------------------------------------------------------
+
+    def find_bytes(
+        self, pattern: str, scope: str = "code", limit: int = 50
+    ) -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            snap = self._require_snapshot()
+            cleaned = pattern.lower().removeprefix("0x")
+            if (
+                not cleaned
+                or len(cleaned) % 2
+                or any(c not in "0123456789abcdef" for c in cleaned)
+            ):
+                raise DriverError(f"not a hex pattern: {pattern!r}")
+            needle = bytes.fromhex(cleaned)
+            limit = max(1, min(limit, MAX_FIND_HITS))
+            if scope == "code":
+                found = session.inspect("find_needle", cleaned, limit)
+                return {
+                    "scope": scope,
+                    "pattern": cleaned,
+                    "code_size": found["code_size"],
+                    "total": found["total"],
+                    "hits": found["hits"][:limit],
+                    "truncated": found["total"] > len(found["hits"]),
+                }
+            if scope == "calldata":
+                data = bytes(snap.calldata)
+            elif scope == "memory":
+                window = min(snap.memory_size, MAX_MEMORY_SCAN)
+                data = bytes(session.inspect("read_memory", 0, window))
+            else:
+                raise DriverError(
+                    f"scope must be code, memory or calldata, not {scope!r}"
+                )
+            hits: list[dict[str, Any]] = []
+            start = 0
+            while len(hits) < limit:
+                idx = data.find(needle, start)
+                if idx < 0:
+                    break
+                hits.append({"offset": idx})
+                start = idx + 1
+            return {
+                "scope": scope,
+                "pattern": cleaned,
+                "scanned": len(data),
+                "total": data.count(needle),
+                "hits": hits,
+                "truncated": data.count(needle) > len(hits),
+            }
+
+    # -- breakpoints, mutation, evaluation ---------------------------------
+
+    def set_breakpoint(
+        self, location: str, condition: str | None = None, temporary: bool = False
+    ) -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            spec = location.strip()
+            # break_at_line/function return (breakpoint, snapped_line); the pc and
+            # opcode forms return the breakpoint itself. Unpack to the common shape.
+            if spec.startswith("*"):
+                result: Any = session.break_at_pc(
+                    int(spec[1:], 0), temporary=temporary, condition=condition
+                )
+            elif ":" in spec:
+                source_key, line_text = spec.rsplit(":", 1)
+                file_id = session.file_id_for(source_key)
+                if file_id is None:
+                    raise DriverError(f"no source file matching {source_key!r}")
+                snapped, _pcs = session.resolve_line(file_id, int(line_text))
+                result = session.break_at_line(
+                    source_key, snapped, temporary=temporary, condition=condition
+                )
+            elif spec.replace(".", "").replace("_", "").isalnum():
+                result = session.break_at_function(
+                    spec, temporary=temporary, condition=condition
+                )
+            else:
+                raise DriverError(
+                    "location must be '*0xPC', 'File.sol:LINE', or a function name; "
+                    "opcodes go through sevm_set_opcode_breakpoint"
+                )
+            bp = result[0] if isinstance(result, tuple) else result
+            return self._breakpoint_row(bp)
+
+    def set_opcode_breakpoint(
+        self, mnemonic: str, condition: str | None = None, temporary: bool = False
+    ) -> dict[str, Any]:
+        session, _ = self._require()
+        bp = session.break_at_opcode(
+            mnemonic.upper(), temporary=temporary, condition=condition
+        )
+        return self._breakpoint_row(bp)
+
+    @staticmethod
+    def _breakpoint_row(bp: Any) -> dict[str, Any]:
+        return {
+            "id": bp.number,
+            "description": bp.describe(),
+            "temporary": bool(getattr(bp, "temporary", False)),
+            "condition": getattr(bp, "condition", None),
+        }
+
+    def list_breakpoints(self) -> dict[str, Any]:
+        session, _ = self._require()
+        rows = session.breakpoints.listing()
+        return {"breakpoints": rows}
+
+    def delete_breakpoint(self, id: int) -> dict[str, Any]:
+        session, _ = self._require()
+        removed = session.breakpoints.remove(int(id))
+        if not removed:
+            raise DriverError(f"no breakpoint {id}")
+        return {"deleted": int(id)}
+
+    def set_watchpoint(self, expression: str, mode: str = "write") -> dict[str, Any]:
+        """watch/rwatch/awatch via the command layer, which resolves the expression."""
+        _, processor = self._require()
+        verb = {"write": "watch", "read": "rwatch", "access": "awatch"}.get(mode)
+        if verb is None:
+            raise DriverError("mode must be write, read or access")
+        result = processor.execute(f"{verb} {expression}")
+        if result.error:
+            raise DriverError(result.error)
+        return {"ok": True, "lines": [_plain(line) for line in result.lines]}
+
+    def evaluate(self, expression: str, keep: bool = False) -> dict[str, Any]:
+        _, processor = self._require()
+        res = processor.evaluate(expression, keep=keep)
+        out: dict[str, Any] = {
+            "expression": res.expression,
+            "type": res.type_name,
+            "display": res.display,
+            "kept": bool(res.kept),
+            "gas_used": res.gas_used,
+        }
+        if isinstance(res.value, int):
+            out["hex"] = hex_word(res.value)
+        return out
+
+    def set_gas(self, value: int) -> dict[str, Any]:
+        session, _ = self._require()
+        result = int(session.inspect("set_gas", int(value)))
+        return {
+            "gas_remaining": result,
+            "note": (
+                "if stopped on an out-of-gas error, continue now retries the failed "
+                "instruction with this gas"
+            ),
+        }
+
+    def set_stack_slot(self, index: int, value: int) -> dict[str, Any]:
+        session, _ = self._require()
+        result = int(session.inspect("write_stack", int(index), int(value)))
+        return {"index": int(index), "value": hex_word(result)}
+
+    def write_memory(self, offset: int, hex_data: str) -> dict[str, Any]:
+        session, _ = self._require()
+        cleaned = hex_data.lower().removeprefix("0x")
+        if not cleaned or len(cleaned) % 2:
+            raise DriverError(f"not hex data: {hex_data!r}")
+        data = bytes.fromhex(cleaned)
+        session.inspect("write_memory", int(offset), data)
+        return {"offset": int(offset), "size": len(data)}
+
+    def write_storage(self, slot: int, value: int) -> dict[str, Any]:
+        session, _ = self._require()
+        result = int(session.inspect("write_storage", int(slot), int(value)))
+        return {"slot": int(slot), "value": hex_word(result)}
+
+    def set_pc(self, pc: int) -> dict[str, Any]:
+        session, _ = self._require()
+        try:
+            result = int(session.inspect("set_pc", int(pc)))
+        except SessionError as exc:
+            raise DriverError(f"{exc} (only JUMPDEST targets are reachable)") from exc
+        return {"pc": result}
+
+    def command(self, line: str) -> dict[str, Any]:
+        """Raw passthrough to the gdb verb surface, markup stripped."""
+        _, processor = self._require()
+        result = processor.execute(line)
+        return {
+            "ok": result.ok,
+            "lines": [_plain(entry).rstrip() for entry in result.lines],
+            "error": result.error,
+            "notice": result.notice,
+        }
+
+    def diff_since_last_stop(self) -> dict[str, Any]:
+        """What the last navigation changed — the AI's replacement for watching panes."""
+        with self._lock:
+            self._require()
+            snap = self._require_snapshot()
+            prev = self._prev_snapshot
+            if prev is None:
+                return {
+                    "available": False,
+                    "reason": "no previous stop recorded in this session",
+                }
+            out: dict[str, Any] = {"available": True}
+            out["stack"] = self._stack_delta(prev, snap)
+            out["gas_used"] = prev.gas_remaining - snap.gas_remaining
+            out["pc"] = {"from": prev.pc, "to": snap.pc}
+            out["depth"] = {"from": prev.depth, "to": snap.depth}
+            out["memory_size"] = {"from": prev.memory_size, "to": snap.memory_size}
+            old_mem, new_mem = bytes(prev.memory), bytes(snap.memory)
+            shared = min(len(old_mem), len(new_mem))
+            ranges: list[tuple[int, int]] = []
+            run_start = None
+            for i in range(shared):
+                changed = old_mem[i] != new_mem[i]
+                if changed and run_start is None:
+                    run_start = i
+                elif not changed and run_start is not None:
+                    ranges.append((run_start, i))
+                    run_start = None
+                    if len(ranges) >= 16:
+                        break
+            if run_start is not None and len(ranges) < 16:
+                ranges.append((run_start, shared))
+            out["memory_changed"] = [
+                {
+                    "offset": start,
+                    "length": end - start,
+                    "new_hex": "0x" + new_mem[start : min(end, start + 32)].hex(),
+                }
+                for start, end in ranges
+            ]
+            out["memory_note"] = (
+                f"compared the first {shared} bytes captured at each stop "
+                "(snapshots carry a bounded memory window)"
+            )
+            return out
diff --git a/src/sevm/mcp_server/serialize.py b/src/sevm/mcp_server/serialize.py
new file mode 100644
index 0000000..621984e
--- /dev/null
+++ b/src/sevm/mcp_server/serialize.py
@@ -0,0 +1,125 @@
+"""Value formatting for the MCP surface.
+
+An AI consumer cannot scroll a pane or eyeball colour, so every value leaves the
+debugger as a stable, markup-free primitive: full-width hex words for 32-byte
+values, decimal for counts, and explicit bounds on every windowed read. The
+helpers here are the single source of that formatting.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..commands.render import _memory_region
+from ..frames import FrameSnapshot, StackEntry
+
+WORD = 32
+
+
+def hex_word(value: int) -> str:
+    """A 32-byte EVM word as 0x + 64 hex chars — the width the model should expect."""
+    return f"0x{value & ((1 << 256) - 1):064x}"
+
+
+def hex_short(raw: bytes, width: int = 20) -> str:
+    data = bytes(raw)
+    if len(data) > width:
+        data = data[:width]
+    return "0x" + data.hex()
+
+
+def describe_wei(value: int) -> str:
+    """`1000000000000000000 (1 ether)` — exact decimal plus the human unit."""
+    if value and value % 10**18 == 0:
+        return f"{value} ({value // 10**18} ether)"
+    return str(value)
+
+
+def stack_entry(entry: StackEntry) -> dict[str, Any]:
+    return {
+        "index": entry.index,  # 0 = top of stack
+        "hex": entry.hex()
+        if callable(getattr(entry, "hex", None))
+        else hex_word(entry.value),
+        "decimal": entry.value if abs(entry.value) < 1 << 64 else None,
+    }
+
+
+def memory_window(data: bytes, offset: int, memory_size: int) -> list[dict[str, Any]]:
+    """Chunk a byte window into 32-byte words, annotated the way the TUI annotates.
+
+    `beyond` marks words past the current allocation: they read as zero (EVM
+    semantics) but nothing has been written there yet, and a model scanning a dump
+    must not mistake the two.
+    """
+    items = []
+    for i in range(0, len(data), WORD):
+        word_offset = offset + i
+        chunk = data[i : i + WORD]
+        value = int.from_bytes(chunk.ljust(WORD, b"\x00"), "big")
+        region = _memory_region(word_offset)
+        item: dict[str, Any] = {"offset": word_offset, "hex": f"0x{value:064x}"}
+        if region:
+            item["region"] = region
+        if word_offset >= memory_size:
+            item["beyond"] = True
+        items.append(item)
+    return items
+
+
+def snapshot_report(snap: FrameSnapshot, stack_top: int = 5) -> dict[str, Any]:
+    """The uniform 'where am I' dict every navigation tool returns.
+
+    Everything here comes straight off the immutable snapshot — no inspect
+    round-trip, no markup — so the shape is identical no matter which tool
+    produced the stop.
+    """
+    fn = snap.function
+    location: dict[str, Any] = {"contract": snap.contract_name}
+    if fn is not None:
+        location["function"] = fn.signature
+    if snap.has_source:
+        location["file"] = snap.source_key
+        location["line"] = snap.line
+    return {
+        "stopped": True,
+        "stop_reason": snap.stop_reason,
+        "hit_breakpoints": list(snap.hit_breakpoints),
+        "pc": snap.pc,
+        "opcode": f"0x{snap.opcode:02x}",
+        "mnemonic": snap.mnemonic,
+        "gas": {
+            "remaining": snap.gas_remaining,
+            "used": snap.gas_used,
+            "limit": snap.gas_limit,
+            "refund": snap.gas_refund,
+        },
+        "sp": len(snap.stack),
+        "depth": snap.depth,
+        "address": hex_short(snap.address),
+        "code_address": hex_short(snap.code_address),
+        "is_static": snap.is_static,
+        "step": snap.step,
+        "memory_size": snap.memory_size,
+        "calldata_size": len(snap.calldata),
+        "location": location,
+        "annotation": snap.annotation or None,
+        "stack_top": [stack_entry(e) for e in snap.stack[:stack_top]],
+    }
+
+
+def backtrace_rows(snap: FrameSnapshot) -> list[dict[str, Any]]:
+    rows = []
+    for row in snap.backtrace:
+        rows.append(
+            {
+                "index": row.index,
+                "name": row.name,
+                "kind": row.kind,  # solidity | evm
+                "file": row.source_key,
+                "line": row.line or None,
+                "pc": row.pc,
+                "detail": row.detail or None,
+            }
+        )
+    return rows
diff --git a/src/sevm/mcp_server/tools.py b/src/sevm/mcp_server/tools.py
new file mode 100644
index 0000000..28f0418
--- /dev/null
+++ b/src/sevm/mcp_server/tools.py
@@ -0,0 +1,318 @@
+"""The MCP tool surface.
+
+Every tool is a thin async wrapper that runs a driver method off the event loop
+(the session blocks by design) and returns a dict: models get structured JSON,
+and every windowed result says whether it was truncated so the next call can
+narrow itself. Errors return as `{"error": ...}` dicts rather than protocol
+errors, so the model can read and recover from them.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import anyio
+from mcp.server.mcpserver import MCPServer
+
+from .driver import DebugDriver, DriverError
+
+INSTRUCTIONS = """sevm: a gdb-style Solidity/EVM debugger running on Py-EVM.
+
+Workflow: sevm_start_session (a web3.py driver script or a .t.sol Foundry test)
+loads and compiles the target and stops at the first contract instruction.
+Then navigate (sevm_continue / sevm_step_opcodes / sevm_run_to), inspect with
+windowed reads (sevm_read_memory, sevm_disassemble, sevm_read_source), evaluate
+Solidity against the paused frame (sevm_evaluate), and mutate live state
+(sevm_write_storage, sevm_set_stack_slot, sevm_set_gas).
+
+Every navigation tool returns the same stop report (pc, opcode, gas, stack top,
+stack delta since the previous stop), so you always know where you are in one
+call. Results that can exceed your context are windowed and carry
+`truncated: true` — narrow the offset instead of asking for more.
+
+Unlike a human at a terminal you cannot scroll or watch panes: rely on
+sevm_diff_since_last_stop after each step to see what changed (stack pushes /
+pops with values, changed memory ranges, gas spent).
+"""
+
+
+def _call(driver: DebugDriver, fn: str, *args: Any, **kwargs: Any) -> dict[str, Any]:
+    try:
+        method = getattr(driver, fn)
+        return method(*args, **kwargs)
+    except DriverError as exc:
+        return {"error": str(exc)}
+    except Exception as exc:  # a bug must not kill the server
+        return {"error": f"{type(exc).__name__}: {exc}"}
+
+
+async def _run(driver: DebugDriver, fn: str, *args: Any, **kwargs: Any) -> dict[str, Any]:
+    return await anyio.to_thread.run_sync(lambda: _call(driver, fn, *args, **kwargs))
+
+
+def build_server(driver: DebugDriver | None = None) -> MCPServer:
+    driver = driver or DebugDriver()
+    server = MCPServer("sevm", instructions=INSTRUCTIONS)
+
+    # -- lifecycle ---------------------------------------------------------
+
+    @server.tool()
+    async def sevm_start_session(
+        target: str,
+        args: list[str] | None = None,
+        contracts: str | None = None,
+        solc: str | None = None,
+        optimize: bool = False,
+        match: str | None = None,
+        match_contract: str | None = None,
+        timeout: float | None = None,
+    ) -> dict:
+        """Start debugging a target and stop at the first contract instruction.
+
+        `target` is either a web3.py driver script (.py — it deploys and calls
+        contracts against an in-process chain; extra `args` are forwarded to it,
+        `@path` args are read from that file) or a Foundry test (.t.sol — use
+        `match`/`match_contract` to select tests). Replaces any existing session.
+        Returns the uniform stop report. `optimize` on = gadget-accurate bytecode
+        but coarser source stepping.
+        """
+        return await _run(
+            driver,
+            "start",
+            target,
+            args=args,
+            contracts=contracts,
+            solc=solc,
+            optimize=optimize,
+            match=match,
+            match_contract=match_contract,
+            timeout=timeout,
+        )
+
+    @server.tool()
+    async def sevm_stop_session() -> dict:
+        """Stop and dispose the active debug session (chain state is discarded)."""
+        return await _run(driver, "stop")
+
+    @server.tool()
+    async def sevm_restart_session(args: list[str] | None = None) -> dict:
+        """Re-run the target from scratch: fresh chain, breakpoints kept.
+
+        Pass `args` to replace the script's arguments (e.g. new calldata for a
+        payload-driver script; `@path` args are read from file).
+        """
+        return await _run(driver, "restart", args=args)
+
+    # -- navigation (uniform stop report) ----------------------------------
+
+    @server.tool()
+    async def sevm_continue() -> dict:
+        """Run until the next breakpoint, watchpoint, error/revert, or program end."""
+        return await _run(driver, "continue_execution")
+
+    @server.tool()
+    async def sevm_step_opcodes(count: int = 1) -> dict:
+        """Execute `count` opcodes (max 1000), stepping into calls."""
+        return await _run(driver, "step_opcodes", count)
+
+    @server.tool()
+    async def sevm_step_lines(count: int = 1) -> dict:
+        """Advance `count` Solidity source lines, stepping into internal calls."""
+        return await _run(driver, "step_lines", count)
+
+    @server.tool()
+    async def sevm_next_lines(count: int = 1) -> dict:
+        """Advance `count` Solidity lines, stepping over internal calls."""
+        return await _run(driver, "next_lines", count)
+
+    @server.tool()
+    async def sevm_finish_frame() -> dict:
+        """Run to the end of the current frame (function call or internal call)."""
+        return await _run(driver, "finish_frame")
+
+    @server.tool()
+    async def sevm_run_to(location: str | None = None, pc: int | None = None) -> dict:
+        """Run to a location: `pc` (int), or `location` like 'Bank.sol:46' / '*0x108'."""
+        return await _run(driver, "run_to", location=location, pc=pc)
+
+    @server.tool()
+    async def sevm_get_status(stack_top: int = 5) -> dict:
+        """Where am I? Full stop report: pc, opcode, gas, sp, location, stack top."""
+        return await _run(driver, "status")
+
+    @server.tool()
+    async def sevm_diff_since_last_stop() -> dict:
+        """What did the last navigation change? Stack pushes/pops with values,
+        changed memory byte-ranges, gas spent, pc move. Your replacement for
+        watching panes scroll."""
+        return await _run(driver, "diff_since_last_stop")
+
+    # -- inspection --------------------------------------------------------
+
+    @server.tool()
+    async def sevm_read_memory(offset: int = 0, words: int = 8) -> dict:
+        """Read a window of EVM memory as 32-byte words (0x + 64 hex chars each),
+        annotated with Solidity regions (scratch/free-memory-pointer/zero-slot);
+        words past the allocation carry `beyond: true`."""
+        return await _run(driver, "read_memory", offset, words)
+
+    @server.tool()
+    async def sevm_read_stack(offset: int = 0, limit: int = 32) -> dict:
+        """Read the operand stack; index 0 is the top. Hex + decimal per slot."""
+        return await _run(driver, "read_stack", offset, limit)
+
+    @server.tool()
+    async def sevm_read_storage(
+        slots: list[int] | None = None, decode: bool = True
+    ) -> dict:
+        """Read storage. By default decodes the running contract's whole layout
+        (names, types, values — packed slots included); pass `slots` for raw
+        32-byte reads of specific slots."""
+        return await _run(driver, "read_storage", slots, decode)
+
+    @server.tool()
+    async def sevm_read_calldata(offset: int = 0, size: int = 256) -> dict:
+        """Read the transaction calldata (windowed; huge payloads stay bounded).
+        The first window includes the 4-byte selector and its signature."""
+        return await _run(driver, "read_calldata", offset, size)
+
+    @server.tool()
+    async def sevm_get_backtrace() -> dict:
+        """The call stack: Solidity frames interleaved with EVM frames."""
+        return await _run(driver, "get_backtrace")
+
+    @server.tool()
+    async def sevm_get_locals() -> dict:
+        """Local variables of the selected Solidity frame, decoded."""
+        return await _run(driver, "get_locals")
+
+    @server.tool()
+    async def sevm_get_arguments() -> dict:
+        """The current external frame's call arguments, ABI-decoded."""
+        return await _run(driver, "get_arguments")
+
+    @server.tool()
+    async def sevm_disassemble(
+        around_pc: int | None = None, before: int = 6, after: int = 18
+    ) -> dict:
+        """Disassembly rows {pc, text, jumpdest, line} around a pc (default: current)."""
+        return await _run(driver, "disassemble", around_pc, before, after)
+
+    @server.tool()
+    async def sevm_read_source(
+        file: str | None = None, around_line: int | None = None, context: int = 10
+    ) -> dict:
+        """A window of Solidity source with line numbers; the current line is
+        flagged. `file` defaults to the file of the current stop."""
+        return await _run(driver, "read_source", file, around_line, context)
+
+    @server.tool()
+    async def sevm_get_gas_profile(limit: int = 20) -> dict:
+        """Gas spent so far, profiled by opcode and by source line."""
+        return await _run(driver, "get_gas_profile", limit)
+
+    @server.tool()
+    async def sevm_get_logs() -> dict:
+        """Event logs emitted so far this transaction, with decoded event names."""
+        return await _run(driver, "get_logs")
+
+    @server.tool()
+    async def sevm_list_contracts() -> dict:
+        """The compiled contracts in this session (name, runtime size)."""
+        return await _run(driver, "list_contracts")
+
+    @server.tool()
+    async def sevm_list_functions(contract: str | None = None) -> dict:
+        """External functions of a contract: signature + 4-byte selector.
+        Defaults to the running contract."""
+        return await _run(driver, "list_functions", contract)
+
+    @server.tool()
+    async def sevm_find_bytes(pattern: str, scope: str = "code", limit: int = 50) -> dict:
+        """Find a hex byte pattern (e.g. '60515255' or '0x5b50505050').
+
+        scope=code searches the running contract's bytecode for gadget hunting:
+        each hit reports its pc, whether it starts on an instruction boundary,
+        and the nearest preceding JUMPDEST (the address an indirect jump can
+        reach). scope=memory/calldata search those buffers instead."""
+        return await _run(driver, "find_bytes", pattern, scope, limit)
+
+    # -- breakpoints -------------------------------------------------------
+
+    @server.tool()
+    async def sevm_set_breakpoint(
+        location: str, condition: str | None = None, temporary: bool = False
+    ) -> dict:
+        """Break at 'File.sol:LINE', '*0xPC', a function name ('deposit' or
+        'Bank.deposit'), or use sevm_set_opcode_breakpoint for opcodes.
+        `condition` is real Solidity evaluated at the location."""
+        return await _run(driver, "set_breakpoint", location, condition, temporary)
+
+    @server.tool()
+    async def sevm_set_opcode_breakpoint(
+        mnemonic: str, condition: str | None = None, temporary: bool = False
+    ) -> dict:
+        """Break on every occurrence of an opcode, e.g. SSTORE, DELEGATECALL, JUMP."""
+        return await _run(driver, "set_opcode_breakpoint", mnemonic, condition, temporary)
+
+    @server.tool()
+    async def sevm_list_breakpoints() -> dict:
+        """All breakpoints and watchpoints with their hit counts."""
+        return await _run(driver, "list_breakpoints")
+
+    @server.tool()
+    async def sevm_delete_breakpoint(id: int) -> dict:
+        """Delete breakpoint or watchpoint number `id`."""
+        return await _run(driver, "delete_breakpoint", id)
+
+    @server.tool()
+    async def sevm_set_watchpoint(expression: str, mode: str = "write") -> dict:
+        """Break when a storage value is written ('write'), read ('read'), or
+        either ('access'). Expression: a state variable, mapping element like
+        'balances[0xabc...]', or '*0x40' for a memory word."""
+        return await _run(driver, "set_watchpoint", expression, mode)
+
+    # -- mutation & evaluation ---------------------------------------------
+
+    @server.tool()
+    async def sevm_evaluate(expression: str, keep: bool = False) -> dict:
+        """Evaluate real Solidity against the paused frame: state variables,
+        mappings, locals, internal functions, keccak256, abi.encode, units
+        ('1 ether'). Side effects are discarded unless keep=true (like gdb's
+        `call`). The most powerful inspection tool — prefer it over raw reads."""
+        return await _run(driver, "evaluate", expression, keep)
+
+    @server.tool()
+    async def sevm_set_gas(value: int) -> dict:
+        """Overwrite the gas meter. If stopped on an out-of-gas error, continuing
+        afterwards retries the failed instruction with this gas."""
+        return await _run(driver, "set_gas", value)
+
+    @server.tool()
+    async def sevm_set_stack_slot(index: int, value: int) -> dict:
+        """Rewrite a stack operand (index 0 = top) before its opcode consumes it."""
+        return await _run(driver, "set_stack_slot", index, value)
+
+    @server.tool()
+    async def sevm_write_memory(offset: int, hex_data: str) -> dict:
+        """Write bytes (hex) into EVM memory at `offset`."""
+        return await _run(driver, "write_memory", offset, hex_data)
+
+    @server.tool()
+    async def sevm_write_storage(slot: int, value: int) -> dict:
+        """Write a raw 32-byte value to a storage slot of the running contract."""
+        return await _run(driver, "write_storage", slot, value)
+
+    @server.tool()
+    async def sevm_set_pc(pc: int) -> dict:
+        """Move the program counter; JUMPDEST targets only."""
+        return await _run(driver, "set_pc", pc)
+
+    @server.tool()
+    async def sevm_command(line: str) -> dict:
+        """Raw gdb-verb passthrough for everything not first-class: `vm.deal(a, 1
+        ether)` cheatcodes, Yul like `mstore(0x80, 1)`, `jump 0x108`, `reseat`,
+        `watch`, `tbreak`, `x/32xb 0x40`... Returns plain-text lines."""
+        return await _run(driver, "command", line)
+
+    return server
diff --git a/src/sevm/session/inspect_ops.py b/src/sevm/session/inspect_ops.py
index a2137da..037ebfe 100644
--- a/src/sevm/session/inspect_ops.py
+++ b/src/sevm/session/inspect_ops.py
@@ -79,9 +79,16 @@ def _op_logs(
         ]
 
     def _op_disassembly(
-        self, frame: EvmFrame, computation: Any, before: int = 6, after: int = 18
+        self,
+        frame: EvmFrame,
+        computation: Any,
+        before: int = 6,
+        after: int = 18,
+        center: int | None = None,
     ) -> list[dict]:
-        pc = max(0, computation.code.program_counter - 1)
+        pc = (
+            center if center is not None else max(0, computation.code.program_counter - 1)
+        )
         rows = []
         for ins in frame.disassembly.window(pc, before, after):
             loc = frame.location(ins.pc)
@@ -96,6 +103,53 @@ def _op_disassembly(
             )
         return rows
 
+    def _op_find_needle(
+        self, frame: EvmFrame, computation: Any, needle_hex: str, limit: int = 200
+    ) -> dict:
+        """Every offset in the running code where the hex needle occurs.
+
+        Gadget hunting for jump-oriented payloads: the same needle can sit inside a
+        PUSH operand or at a real instruction, so each hit reports its pc, whether it
+        starts on an instruction boundary, whether it is itself a JUMPDEST, and the
+        nearest preceding JUMPDEST — the address an indirect jump can actually reach.
+        """
+        needle = bytes.fromhex(needle_hex)
+        # bytes(CodeStream) iterates from the CURRENT position, yielding a partial
+        # tail of the program; the whole thing is in _raw_code_bytes.
+        raw = getattr(computation.code, "_raw_code_bytes", None)
+        code = bytes(raw) if raw is not None else bytes(computation.code)
+        aligned_pcs = {ins.pc for ins in frame.disassembly.instructions}
+        jumpdests = sorted(frame.disassembly.jumpdests)
+        hits: list[dict] = []
+        start = 0
+        while len(hits) < limit:
+            idx = code.find(needle, start)
+            if idx < 0:
+                break
+            prev_dest = None
+            for dest in jumpdests:
+                if dest <= idx:
+                    prev_dest = dest
+                else:
+                    break
+            loc = frame.location(idx) if idx in aligned_pcs else None
+            hits.append(
+                {
+                    "pc": idx,
+                    "instruction_aligned": idx in aligned_pcs,
+                    "jumpdest": idx in frame.disassembly.jumpdests,
+                    "nearest_jumpdest": prev_dest,
+                    "text": (
+                        frame.disassembly.at(idx).render()
+                        if frame.disassembly.at(idx) is not None
+                        else code[idx : idx + len(needle)].hex()
+                    ),
+                    "line": loc.line if loc and not loc.is_generated else 0,
+                }
+            )
+            start = idx + 1
+        return {"hits": hits, "total": code.count(needle), "code_size": len(code)}
+
     def _op_locals(
         self, frame: EvmFrame, computation: Any, internal_index: int | None = None
     ) -> list[dict]:
diff --git a/tests/test_commands.py b/tests/test_commands.py
index 714bb29..01bb380 100644
--- a/tests/test_commands.py
+++ b/tests/test_commands.py
@@ -447,3 +447,17 @@ def test_an_unquoted_word_still_reaches_a_string_parameter(deposit_debugger):
     # It is not Solidity, so it falls back to the raw text rather than failing.
     assert not deposit_debugger.run("vm.label(0xcafe, cafe)").error
     assert deposit_debugger.run("vm.getLabel(0xcafe)").lines[0].endswith("cafe")
+
+
+def test_find_searches_running_code(deposit_debugger):
+    """`find HEX` reports every occurrence with gadget context (aligned/jumpdest)."""
+    dbg = deposit_debugger
+    result = dbg.run("find 6080604052")
+    assert result.ok
+    joined = "\n".join(result.lines)
+    assert "occurrence(s)" in joined
+    assert "0x0000" in joined  # the runtime prologue starts at pc 0
+    missing = dbg.run("find 5b5b5b5b5b5b")
+    assert missing.ok and "no occurrence" in "\n".join(missing.lines)
+    for bad in ("find", "find zz", "find 123"):
+        assert dbg.run(bad).error
diff --git a/tests/test_mcp_server.py b/tests/test_mcp_server.py
new file mode 100644
index 0000000..c122dd8
--- /dev/null
+++ b/tests/test_mcp_server.py
@@ -0,0 +1,264 @@
+"""The MCP frontend: the driver and its AI-shaped data, without a real client.
+
+The tool functions are thin wrappers over `DebugDriver`, so the coverage here is
+driver-level: start/step/inspect windows, the byte search, diffs, and the error
+convention (failures come back as `{"error": ...}` dicts a model can read). One
+in-memory client round-trip proves the server side speaks the protocol.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from collections.abc import Iterator
+
+import pytest
+
+from sevm.mcp_server import DebugDriver, build_server
+
+COUNTER = """\
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract Counter {
+    uint256 public count;
+    address public owner;
+
+    constructor() {
+        owner = msg.sender;
+    }
+
+    function inc() public {
+        count += 1;
+    }
+}
+"""
+
+DRIVER_SCRIPT = """\
+import os
+
+from web3 import EthereumTesterProvider, Web3
+
+from sevm.compile import compile_project
+
+CONTRACTS = os.path.join(os.path.dirname(os.path.abspath(__file__)), "contracts")
+
+
+def main():
+    project = compile_project([CONTRACTS])
+    w3 = Web3(EthereumTesterProvider())
+    w3.eth.default_account = w3.eth.accounts[0]
+    art = project.artifact("Counter")
+    factory = w3.eth.contract(abi=art.abi, bytecode=art.bytecode.hex())
+    tx = factory.constructor().transact({"gas": 3_000_000})
+    address = w3.eth.wait_for_transaction_receipt(tx)["contractAddress"]
+    counter = w3.eth.contract(address=address, abi=art.abi)
+    counter.functions.inc().transact({"gas": 300_000})
+    counter.functions.inc().transact({"gas": 300_000})
+
+
+main()
+"""
+
+
+@pytest.fixture
+def lab(tmp_path) -> Iterator[tuple[DebugDriver, str]]:
+    """A driver plus a script that deploys a Counter and increments it twice."""
+    contracts = tmp_path / "contracts"
+    contracts.mkdir()
+    (contracts / "Counter.sol").write_text(COUNTER)
+    script = tmp_path / "drive.py"
+    script.write_text(DRIVER_SCRIPT)
+    driver = DebugDriver(timeout=60.0)
+    yield driver, str(script)
+    driver.stop()
+
+
+def test_start_lands_on_a_structured_stop(lab):
+    driver, script = lab
+    report = driver.start(script)
+    assert report["stopped"] is True
+    assert report["kind"] == "script"
+    assert report["location"]["contract"] == "Counter"
+    assert report["gas"]["limit"] > 0
+    assert isinstance(report["stack_top"], list)
+    assert report["stop_reason"]
+
+
+def test_step_reports_stack_delta_and_diff(lab):
+    driver, script = lab
+    driver.start(script)
+    report = driver.step_opcodes(3)
+    assert report["stopped"] is True
+    diff = driver.diff_since_last_stop()
+    assert diff["available"] is True
+    assert diff["gas_used"] > 0
+    assert diff["pc"]["from"] != diff["pc"]["to"] or diff["gas_used"] > 0
+    # A fresh session has no previous stop to diff against until the first step.
+    assert {"pushed", "popped", "from", "to"} & set(diff["stack"])
+
+
+def test_memory_window_is_annotated_and_bounded(lab):
+    driver, script = lab
+    driver.start(script)
+    window = driver.read_memory(0x40, 2)
+    assert window["items"][0]["offset"] == 0x40
+    assert window["items"][0]["region"] == "free memory pointer"
+    assert window["items"][1]["region"] == "zero slot"
+    assert window["words"] == 2
+    big = driver.read_memory(0, 10_000)
+    assert big["words"] == 64  # hard cap holds even for absurd requests
+
+
+def test_find_bytes_locates_gadgets_in_code(lab):
+    driver, script = lab
+    driver.start(script)
+    found = driver.find_bytes("6080604052", scope="code")
+    assert found["total"] >= 1
+    first = found["hits"][0]
+    # The first stop runs the CREATION code, where the runtime prologue appears at
+    # the offset it is embedded at — the hit still reports its pc and alignment.
+    assert {"pc", "instruction_aligned", "jumpdest", "nearest_jumpdest", "text"} <= set(
+        first
+    )
+    assert found["code_size"] > 0
+    raw = driver.find_bytes("6080", scope="code", limit=5)
+    assert raw["hits"], "PUSH1 0x80 appears in every solc prologue"
+    with pytest.raises(Exception, match="hex"):
+        driver.find_bytes("zz", scope="code")
+
+
+def test_find_bytes_scopes_memory_and_calldata(lab):
+    driver, script = lab
+    driver.start(script)
+    report = driver.step_opcodes(1)
+    assert "error" not in report
+    mem = driver.find_bytes("00", scope="memory")
+    assert mem["scope"] == "memory" and mem["scanned"] > 0
+    with_scope = driver.find_bytes("00", scope="calldata")
+    assert with_scope["total"] >= 0
+    with pytest.raises(Exception, match="scope"):
+        driver.find_bytes("00", scope="nonsense")
+
+
+def test_storage_decodes_the_layout(lab):
+    driver, script = lab
+    driver.start(script)
+    storage = driver.read_storage()
+    names = {item.get("name") for item in storage["items"]}
+    assert {"count", "owner"} <= names
+    raw = driver.read_storage(slots=[0], decode=False)
+    assert raw["items"][0]["slot"] == 0
+    assert len(raw["items"][0]["hex"]) == 66  # 0x + 64
+
+
+def test_breakpoint_and_continue(lab):
+    driver, script = lab
+    driver.start(script)
+    bp = driver.set_breakpoint("inc")
+    assert bp["id"] == 1
+    report = driver.continue_execution()
+    assert report["stopped"] is True
+    assert "inc" in report["location"]["function"]
+    assert 1 in report["hit_breakpoints"]
+    listed = driver.list_breakpoints()
+    assert any("inc" in row for row in listed["breakpoints"])
+    assert driver.delete_breakpoint(1)["deleted"] == 1
+
+
+def test_restart_keeps_breakpoints(lab):
+    driver, script = lab
+    driver.start(script)
+    driver.set_breakpoint("inc")
+    driver.continue_execution()
+    report = driver.restart()
+    assert report["stopped"] is True  # fresh constructor stop
+    hit = driver.continue_execution()
+    assert 1 in hit["hit_breakpoints"]  # the breakpoint survived
+
+
+def test_evaluate_and_command_passthrough(lab):
+    driver, script = lab
+    driver.start(script)
+    result = driver.evaluate("owner == msg.sender")
+    assert result["type"].startswith("bool")
+    raw = driver.command("info registers")
+    assert raw["ok"] and any("pc" in line for line in raw["lines"])
+    assert "[" not in "".join(raw["lines"]) or "0x" in "".join(raw["lines"])
+
+
+def test_run_to_line_and_source_window(lab):
+    driver, script = lab
+    driver.start(script)
+    driver.continue_execution()  # constructor -> first inc() entry? land somewhere sourced
+    report = driver.status()
+    if report["stopped"] and report["location"].get("file"):
+        src = driver.read_source()
+        assert src["total_lines"] > 5
+        assert any(item["current"] for item in src["items"])
+
+
+def test_errors_are_structured_not_exceptions(lab):
+    """Driver methods raise; the tools layer is what converts to error dicts."""
+    driver, _script = lab
+    with pytest.raises(Exception, match="sevm_start_session"):
+        driver.status()
+    with pytest.raises(Exception, match="no such file"):
+        driver.start("C:/definitely/not/here.py")
+
+
+def test_disassemble_window(lab):
+    driver, script = lab
+    driver.start(script)
+    rows = driver.disassemble(before=2, after=4)
+    assert 3 <= len(rows["rows"]) <= 6
+    assert {"pc", "text", "jumpdest"} <= set(rows["rows"][0])
+
+
+# ==================================================================
+# protocol round-trip (in-memory client)
+# ==================================================================
+
+
+def test_client_round_trip_lists_tools_and_returns_error_dicts():
+    async def scenario() -> None:
+        import anyio
+        from mcp import ClientSession
+        from mcp.shared.memory import create_client_server_memory_streams
+
+        server = build_server(DebugDriver())
+        async with create_client_server_memory_streams() as streams:
+            client_streams, server_streams = streams
+            app = server._lowlevel_server
+
+            async def serve() -> None:
+                await app.run(
+                    server_streams[0],
+                    server_streams[1],
+                    app.create_initialization_options(),
+                )
+
+            task = asyncio.create_task(serve())
+            try:
+                with anyio.fail_after(30):
+                    async with ClientSession(
+                        client_streams[0], client_streams[1]
+                    ) as client:
+                        await client.initialize()
+                        tools = await client.list_tools()
+                        names = {t.name for t in tools.tools}
+                        assert "sevm_start_session" in names
+                        assert "sevm_find_bytes" in names
+                        res = await client.call_tool("sevm_get_status", {})
+                        # dict returns serialise as JSON text content (no output
+                        # schema is declared, so there is no structuredContent).
+                        import json
+
+                        payload = json.loads(res.content[0].text)
+                        assert "sevm_start_session" in payload.get("error", "")
+            finally:
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+
+    asyncio.run(scenario())
diff --git a/uv.lock b/uv.lock
index d1c7790..5c22553 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,13 +1,22 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.15' and implementation_name == 'cpython'",
     "python_full_version >= '3.15' and implementation_name == 'pypy'",
     "python_full_version >= '3.15' and implementation_name != 'cpython' and implementation_name != 'pypy'",
-    "python_full_version < '3.15' and implementation_name == 'cpython'",
-    "python_full_version < '3.15' and implementation_name == 'pypy'",
-    "python_full_version < '3.15' and implementation_name != 'cpython' and implementation_name != 'pypy'",
+    "python_full_version == '3.14.*' and implementation_name == 'cpython'",
+    "python_full_version >= '3.12' and python_full_version < '3.14' and implementation_name == 'cpython' and sys_platform == 'emscripten'",
+    "(python_full_version >= '3.11' and python_full_version < '3.14' and implementation_name == 'cpython' and sys_platform != 'emscripten') or (python_full_version == '3.11.*' and implementation_name == 'cpython' and sys_platform == 'emscripten')",
+    "python_full_version < '3.11' and implementation_name == 'cpython'",
+    "python_full_version == '3.14.*' and implementation_name == 'pypy'",
+    "python_full_version >= '3.12' and python_full_version < '3.14' and implementation_name == 'pypy' and sys_platform == 'emscripten'",
+    "(python_full_version >= '3.11' and python_full_version < '3.14' and implementation_name == 'pypy' and sys_platform != 'emscripten') or (python_full_version == '3.11.*' and implementation_name == 'pypy' and sys_platform == 'emscripten')",
+    "python_full_version < '3.11' and implementation_name == 'pypy'",
+    "python_full_version == '3.14.*' and implementation_name != 'cpython' and implementation_name != 'pypy'",
+    "python_full_version >= '3.12' and python_full_version < '3.14' and implementation_name != 'cpython' and implementation_name != 'pypy' and sys_platform == 'emscripten'",
+    "(python_full_version >= '3.11' and python_full_version < '3.14' and implementation_name != 'cpython' and implementation_name != 'pypy' and sys_platform != 'emscripten') or (python_full_version == '3.11.*' and implementation_name != 'cpython' and implementation_name != 'pypy' and sys_platform == 'emscripten')",
+    "python_full_version < '3.11' and implementation_name != 'cpython' and implementation_name != 'pypy'",
 ]
 
 [[package]]
@@ -191,6 +200,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" },
 ]
 
+[[package]]
+name = "anyio"
+version = "4.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.15'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" },
+]
+
 [[package]]
 name = "ast-serialize"
 version = "0.8.0"
@@ -377,6 +400,116 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
 ]
 
+[[package]]
+name = "cffi"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b6/d2/2cde336b375f55c76ca670f0be3978cc048e31e24f3b4d7ce8473150a388/cffi-2.1.1-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:baed1e86cc735622097354b9d1281406caf42ff42a886d29faa8e8d1630333be", size = 183779, upload-time = "2026-08-03T21:19:15.602Z" },
+    { url = "https://files.pythonhosted.org/packages/94/1a/4b2f7c92293ba05cbd4a9a1b28faaf0326272d9488e6354657571c48a7aa/cffi-2.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ca82be1a1d406ecfe1d25dc16cb33488e5a16bf4438c9fb590484ea29d92478b", size = 184178, upload-time = "2026-08-03T21:19:16.67Z" },
+    { url = "https://files.pythonhosted.org/packages/17/0b/ba385d8ccedf926c3cd06e8e2f327027da5afe5f0eb30f1f7bc43ac55125/cffi-2.1.1-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:42e2f76b9455f5a9a844f770bf3e200ed3da0e15f5df3db9c31fe80b04b3d004", size = 211037, upload-time = "2026-08-03T21:19:17.705Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/b9/0f2e58b2cefa33255bff36935d42b13180fe559bba82596540eb404bde7d/cffi-2.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5a59cc1c4442bc3d5c703bf720b51138d0bfc173618807c9ee2490a7541dd3d9", size = 218652, upload-time = "2026-08-03T21:19:18.735Z" },
+    { url = "https://files.pythonhosted.org/packages/37/15/180e0dab27b9312c7479003d14c9e547634b7dcb934e2cc4650e1b131a7a/cffi-2.1.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:9f8d177621de5cb38ee3e731eda45d421db093ec0739f46a5594babda7987a98", size = 205422, upload-time = "2026-08-03T21:19:19.96Z" },
+    { url = "https://files.pythonhosted.org/packages/18/d4/03026f0c850cbbaa9030750490225b4a7f4d524ea4df72c3cc740a90f4ef/cffi-2.1.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:75f80557d1389eddbd0de2681f6a390a0c5338c31ddaa821381c203fc3fd50d9", size = 205444, upload-time = "2026-08-03T21:19:21.246Z" },
+    { url = "https://files.pythonhosted.org/packages/75/77/60bebf6f818bec84210ac5b6979ce4eeadce6fbbaabc9c7ab23e506d1ce5/cffi-2.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:194cffa889098ced9976c3fc6340305e43f6303657d298da55366907c05c22d6", size = 218742, upload-time = "2026-08-03T21:19:22.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/ae/679bf47e73fd77b352171727f07de559a003f14de5d02b904a6ec1fa73ca/cffi-2.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5bb4e7ea95dcd6a014a6fef62e62467d67d8e582326443f3d68e71d6320a9fcf", size = 221054, upload-time = "2026-08-03T21:19:23.694Z" },
+    { url = "https://files.pythonhosted.org/packages/09/b8/eefc0e06913b70aa153bf74c946094a18f58fd4aff11b7f372bfdfdca050/cffi-2.1.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3d22a20b1fb1632cc72c22f95f7b0d2961c3e1c235f245ba4c606c4771035659", size = 213489, upload-time = "2026-08-03T21:19:24.922Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/13/4e56852824a03cdf68523a35686f1c28eacd4bd30a7b0a78e682e6e6e1d3/cffi-2.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:1dea0e4d7d4f11f619fe8c1d76caf49e24405b4b5743c0e3be16a500ecd930c9", size = 220241, upload-time = "2026-08-03T21:19:26.214Z" },
+    { url = "https://files.pythonhosted.org/packages/99/7f/040f9e163e4acac3ee3d85b02d00b2576e7ca980d8785f0a3a5f1a9bf7f5/cffi-2.1.1-cp310-cp310-win32.whl", hash = "sha256:7ce713ace7c0e4520535b42b77eaa742c16dab813978064913e5a3cf82973b41", size = 174578, upload-time = "2026-08-03T21:19:27.338Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/0b/644a2ec1a4eaba49c2939410bb1eb1d25b09d6d0582f5d2f95c537043725/cffi-2.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:a48d62ab9d6f4f98c983223a547af44be6ca3691074c31cecced6facd3ba2dc1", size = 185082, upload-time = "2026-08-03T21:19:28.409Z" },
+    { url = "https://files.pythonhosted.org/packages/70/d2/16d99a0c4948febc0ebd133a13b2f688ff7f8cb04da971e1128872ce0c03/cffi-2.1.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:c8d2c9fd1f2d16f780d15127abb050d13d1a76c03a4bd87d7e4980e45e511e12", size = 183838, upload-time = "2026-08-03T21:19:29.637Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/95/31b535a9f0220ae9f357de4a08d57ce89cb417653c2fd9f075f50822a388/cffi-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:398aff33cee2767e3e781d2554c54bd0dff386bb437581e0d8011fde1a942ec1", size = 184168, upload-time = "2026-08-03T21:19:30.764Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", size = 211805, upload-time = "2026-08-03T21:19:31.867Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", size = 218716, upload-time = "2026-08-03T21:19:32.896Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/92/500760486c8baab49a7a8a58ba7fc3355ec3974b454b8a09e528efde9e1d/cffi-2.1.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6e192623c49c94421616a5778fba35cf0d5a8d000650c1967ef4448ee5cdd990", size = 205569, upload-time = "2026-08-03T21:19:34.142Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/a7/a67c733254d6e7373f7822f8082d8d6beade791e0cf12a7611f376fa61c7/cffi-2.1.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a6e721d4b0e45d5b65e87534470e67b18dcd092c83f68fba09f152b9cbc061af", size = 204907, upload-time = "2026-08-03T21:19:35.174Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", size = 217807, upload-time = "2026-08-03T21:19:36.286Z" },
+    { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", size = 221252, upload-time = "2026-08-03T21:19:37.416Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", size = 214214, upload-time = "2026-08-03T21:19:38.507Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", size = 219408, upload-time = "2026-08-03T21:19:39.809Z" },
+    { url = "https://files.pythonhosted.org/packages/db/e2/7e8109f65445bdc673a7b54f02c677de462db75674220fd1335efc8eb598/cffi-2.1.1-cp311-cp311-win32.whl", hash = "sha256:f8ec5e643a9a937f64e1999eb9f75d072263751912dc5cd06d3c85f8f44be7c3", size = 174470, upload-time = "2026-08-03T21:19:41.246Z" },
+    { url = "https://files.pythonhosted.org/packages/73/c0/77ba02423c2f7d7091143c45cd49e0e6575c4c1967394bb542bd923a9b74/cffi-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:42f6930c31dc7f50732c9ae793c2786c7b6b044195967bbdde40bb9be81c4cc0", size = 185096, upload-time = "2026-08-03T21:19:42.615Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/47/9f1f85f9672ceda4984dc6c4f8824e8558992a2972c3d3c81fb8eb28d4ba/cffi-2.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:c7659f22557c5a0bc4855cd635f55edec690cc008a40768527762cb9fb263455", size = 179941, upload-time = "2026-08-03T21:19:43.747Z" },
+    { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" },
+    { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" },
+    { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" },
+    { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" },
+    { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" },
+    { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" },
+    { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" },
+    { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" },
+    { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" },
+    { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" },
+    { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" },
+    { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" },
+    { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" },
+    { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" },
+    { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" },
+    { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" },
+    { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" },
+    { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" },
+    { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" },
+    { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" },
+    { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" },
+    { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" },
+    { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", size = 184933, upload-time = "2026-08-03T21:20:50.639Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", size = 185002, upload-time = "2026-08-03T21:20:52.173Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", size = 209919, upload-time = "2026-08-03T21:20:54.783Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", size = 208529, upload-time = "2026-08-03T21:20:56.066Z" },
+    { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", hash = "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", size = 177683, upload-time = "2026-08-03T21:21:14.901Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", hash = "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", size = 187897, upload-time = "2026-08-03T21:21:16.108Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", hash = "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", size = 182935, upload-time = "2026-08-03T21:21:17.271Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", size = 188464, upload-time = "2026-08-03T21:21:01.163Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", size = 188262, upload-time = "2026-08-03T21:21:02.382Z" },
+    { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", size = 211520, upload-time = "2026-08-03T21:21:04.863Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", size = 210673, upload-time = "2026-08-03T21:21:06.223Z" },
+    { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", hash = "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", size = 182707, upload-time = "2026-08-03T21:21:11.226Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", hash = "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", size = 193772, upload-time = "2026-08-03T21:21:12.39Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", hash = "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", size = 186360, upload-time = "2026-08-03T21:21:13.636Z" },
+]
+
 [[package]]
 name = "charset-normalizer"
 version = "3.5.1"
@@ -617,12 +750,69 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
+[[package]]
+name = "cryptography"
+version = "50.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/ad/5d6702db60b1e40b41ef513b6967ff5848f307d50f8449baf1634f5908f1/cryptography-50.0.1.tar.gz", hash = "sha256:5dd9bda1c12b4162f6ff568eeb5e0ff956c28d14406e875cfe8a63a2d414ff20", size = 880381, upload-time = "2026-08-25T19:45:45.499Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/19/797e2aaac9df6a66f1550f49979dc1b1e39ecd2077501c30efa81e8d5d67/cryptography-50.0.1-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:b8f852c65863251b9e3a1b8c150ce21e59b522dbb6a7d4bc80e680d38388e986", size = 4010153, upload-time = "2026-08-25T19:44:03.155Z" },
+    { url = "https://files.pythonhosted.org/packages/90/34/9ce9a62ed9dc82ca9fd6a34445b6904af56e5f38b3eae2ed32e49c36053d/cryptography-50.0.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:53e279950892dc102c6b4e52af03ae5ea92fac572a1ddab78ca73a997f62b69f", size = 4723133, upload-time = "2026-08-25T19:44:05.461Z" },
+    { url = "https://files.pythonhosted.org/packages/57/26/e6d4fc8512a51a5f9ee7bfdbfb853bce1197087df40c9ad993ad370b846f/cryptography-50.0.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ff838d62ec1bfce4f9ba7fa16f4a7b554cd8d0c299e6be37502161a660c84eef", size = 4712478, upload-time = "2026-08-25T19:44:07.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/de/d3cdc2815697aae84126cbd6a030ca7b6b452e28a88b501b836bd3aa7a86/cryptography-50.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e74591e283fe6eb956416c929eb58262a719fe0311fd9054c62c3350ed8760d8", size = 4730726, upload-time = "2026-08-25T19:44:09.294Z" },
+    { url = "https://files.pythonhosted.org/packages/55/32/38c0d344b98c06d34b5df8946565a9c0d6dbf32c8e0730a7f05f0a3c6cab/cryptography-50.0.1-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5fe002589592ed749ce77fe0695fcbd3500dd61d7d6db5858a7544c612fa8e45", size = 5353524, upload-time = "2026-08-25T19:44:11.96Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/1b/82f0f0d8858d4432be1af790477edf62aef90324041aa07c57e57bef1af7/cryptography-50.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:51593d180cf6d179bde5c5d065bed81386b1f381656ae7d042b7ffc87a9895ad", size = 4746720, upload-time = "2026-08-25T19:44:14.051Z" },
+    { url = "https://files.pythonhosted.org/packages/29/ba/042ca458b8c64348c768284b5d23e69b92ed53d057ab779fee628564676d/cryptography-50.0.1-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:359e62deae718bce96170e223fdcb6357e4fbd3bb7a3a75f4430763532560e49", size = 4361866, upload-time = "2026-08-25T19:44:16.167Z" },
+    { url = "https://files.pythonhosted.org/packages/39/3b/e96c1ef71edef71057c7e3c3d982ce8fda554e0c52d0cc19c18845cde3eb/cryptography-50.0.1-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e2ca8fd1b6b4b82a1c4cb02841d0837e3c12336c2e24b520ab8ab3b969733d8f", size = 4730028, upload-time = "2026-08-25T19:44:18.085Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/38/45abd72ef63f2e7d0754a6cacf97bd8b69512ace7f6130d24c39ece65da2/cryptography-50.0.1-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:76de83fbd91ac49c0feaaa983d0748fd7a53176afac5fb3bf7478d244f0eb527", size = 5308405, upload-time = "2026-08-25T19:44:20.197Z" },
+    { url = "https://files.pythonhosted.org/packages/85/66/6ccca4722987ddedaa7fc9c3f4708af7431f5535666c174350830888c6b7/cryptography-50.0.1-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:51afcfceb15597cf2635068e4ac9a56b2abde622edde17f37d85fd7b5306497a", size = 4746230, upload-time = "2026-08-25T19:44:22.376Z" },
+    { url = "https://files.pythonhosted.org/packages/13/0e/b1f92e013228111413f2e6743948b80bc24dfd3c1b87ba98ceea16f5df89/cryptography-50.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:be224a65493ec5b74a158ff22a5522ce4a5ca1e543c647a3a4730d4a09e5f959", size = 4862596, upload-time = "2026-08-25T19:44:24.472Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/22/c3654cccc856e9d682817b04ac3ee79731cb09ca6f95996a95c904de2883/cryptography-50.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9ebcdd5519be9b652a46f507817a74591774fc3d6923ac364e4dfa64e36b291b", size = 5014082, upload-time = "2026-08-25T19:44:26.709Z" },
+    { url = "https://files.pythonhosted.org/packages/42/8b/cb12b1b60c91b074ca6bf0fdd59aa8f10d8bc5f73af8faece86ef0421b37/cryptography-50.0.1-cp311-abi3-win_amd64.whl", hash = "sha256:aed8db4f6d71c51efb89530e12d9464e7bf2923d46c3205dc794a2a93f8c0648", size = 3842826, upload-time = "2026-08-25T19:44:28.784Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/f0/424cb557d99aa86ac55da5e2add02e2882e44047b6264f93ade1b975a993/cryptography-50.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30a125032e5642a21ff816e021152bd4e7e94f03eff3f4b7fca41cd22bc3110f", size = 3973525, upload-time = "2026-08-25T19:44:30.7Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/72/3a2711d967977ab5fc80b782837c7e8d1ac7445e764c20c381a265c57ef3/cryptography-50.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a0b1a59e3a089064a0ec309e9428c8e3ae4e161419d20ac33600767e83fc658a", size = 4708817, upload-time = "2026-08-25T19:44:32.773Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/f2/bb1f56e10815b789df0b409a69fa4992ff3d3fef9c72747f4a6b26fed38e/cryptography-50.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8921d58f426793c5f1b47f0b59575780de9a095214958d0eb37d909593db8367", size = 4697300, upload-time = "2026-08-25T19:44:35.144Z" },
+    { url = "https://files.pythonhosted.org/packages/08/bd/ed5396be499ffcf8807a585bfe38b71a1fbdd1c342b4f9b6d0ef5162a946/cryptography-50.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a8f40ea47330e71b594a7e246898f93177c259490c63183dbaf9e571d71ed9a5", size = 4716039, upload-time = "2026-08-25T19:44:37.192Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/6e/1cf405c5c8e8df7545378048e954792f00b7f2367af8863ce8b8f3e10607/cryptography-50.0.1-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:a255449073358275b64b67d3f595f268bbef70e72b6edb65e0c70c735bf739c9", size = 5332388, upload-time = "2026-08-25T19:44:39.16Z" },
+    { url = "https://files.pythonhosted.org/packages/47/92/b4317e8c32c4f47b062f5398bd79106b220a124546f42be83bf32b761e2a/cryptography-50.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:8df2de9102026855887e4587084f6eabd80ed0f345b8ad8a7ac27ab9bf4723e0", size = 4730293, upload-time = "2026-08-25T19:44:41.298Z" },
+    { url = "https://files.pythonhosted.org/packages/39/0d/a1e7633e2c744d0f2983320a27e924ef2264c79c56e1a58d5fb0a1cfd413/cryptography-50.0.1-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:ac02b07824d4d1001bd4367599f839c19cb171924c796e52c23508ac14c2c0cc", size = 4346031, upload-time = "2026-08-25T19:44:43.245Z" },
+    { url = "https://files.pythonhosted.org/packages/88/dd/b215616f9bab3fc18510c78a4e5c9f362d77838503c363dc747c7d4f5c6f/cryptography-50.0.1-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:cbf74a81765ee67413503ca6e26dcc4f6f5a519822436cc0a1b97aab6c1b8a17", size = 4715344, upload-time = "2026-08-25T19:44:45.291Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/1b/ec3ebd31741d0e963612c4fe43caa39341b9b1e031e469820e42e4c83918/cryptography-50.0.1-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:16c5ecd954b3330ebfb6605eca4fd952da8bef376551d5cc264534e3770a9ee6", size = 5287201, upload-time = "2026-08-25T19:44:47.297Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/01/0127d11a762b31a9ee0221894f540318761783f3fdc4bc5d057698caebd5/cryptography-50.0.1-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:79bf008d1f9af6071c797ad133e39915dfee7614f18f18f4db9072eb715064a3", size = 4730023, upload-time = "2026-08-25T19:44:49.435Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b9/e7425ebfb599241a0c1d7000f1b466c3062da66c19d9525031315dff7213/cryptography-50.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:330fbb252391c596f1ae42c5754449dc924e6ad012dca8efe0d703f9f2d12ec6", size = 4847362, upload-time = "2026-08-25T19:44:51.94Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/fd/60d0ddf4defa12e482c9d5e0f554384d6e8ab25341fd15f060028fd92e6a/cryptography-50.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:42be3bb70596b3abe4ac097b75be223e8b3ab614a0e5de068e3dcc54d71d6149", size = 4999247, upload-time = "2026-08-25T19:44:53.876Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/56/bc4f2b209e766c93372cfcd59b781a0b2b59700f62a969580415b699c2b2/cryptography-50.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f74455bb086a85d5e81246412602aaa97ed095e504cd40dd261ef50be42205bf", size = 3825806, upload-time = "2026-08-25T19:44:56.209Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a9/ee16a903f13755e914d1eecc482fe64d1f10761c3960e5d8fa6837377aff/cryptography-50.0.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ca83d00d9e69cd5eb63f2e69c3a5a59e0cecae5ae14c6ae0b35830fe3b37bad0", size = 4035307, upload-time = "2026-08-25T19:44:58.305Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/a5/9ec7e81e8526c0d7a387d73386b2daed3f39e10d81a85930bd1b6bfba65c/cryptography-50.0.1-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:05ba322c4da95b262a212c345af888ef2c37c88c0509756ea00a0e6d68850f23", size = 4751900, upload-time = "2026-08-25T19:45:00.401Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/3c/0e77bd5ffcf078e9dd27d3074aad6c030d9b10d0bf69329d573c927a188c/cryptography-50.0.1-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e22dfed744bd4002e909464cb23d2f0b05c6f3113a79ef2e9864a53db737c733", size = 4738357, upload-time = "2026-08-25T19:45:02.786Z" },
+    { url = "https://files.pythonhosted.org/packages/27/3a/3c5f80daa4dcd47323c7af8a2fcb90de27a33564d4fcac69846c0972691a/cryptography-50.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4c4188f7c0cf655be5c06342b817ed0f9595b69ffa2b12026e5353eed29dea88", size = 4758474, upload-time = "2026-08-25T19:45:04.889Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/2b/214cf0cf93db9628c3c20c896b229f327f6fb1b20e4b3743d8ad3f00af8b/cryptography-50.0.1-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:2ebbfb0f1fed745e91796e3e1080a1440423fdae8ece1b995a1d80883a409054", size = 5375862, upload-time = "2026-08-25T19:45:07.163Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/51/3f9701867a46b6c1740c9b52fc4d3bed6cbdcfedcc9b6e64305c07f39cff/cryptography-50.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:407fe2b6db00939c05c0e945e9914238f2f0a430974839429dafc82b1ee6bee5", size = 4772942, upload-time = "2026-08-25T19:45:09.396Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/5c/13ea642e08e2544d0f5396122055f4820cfacb3203562197b5967125ea97/cryptography-50.0.1-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:2b34d76a652ea2b6faf777c35df230c5637842cd904e04f16230c3f9f03e4361", size = 4383347, upload-time = "2026-08-25T19:45:11.659Z" },
+    { url = "https://files.pythonhosted.org/packages/84/d5/7d1fe1cb93f91c428093ff234e128c89ba8ea61a6f26aab406081f9b996e/cryptography-50.0.1-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:01f41478cf33fc605a6a089cd56d28b45c6c0b45a1928b61797f2621a04bac71", size = 4758050, upload-time = "2026-08-25T19:45:13.745Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/04/557fc5ead96a829e0bc812a3b9dc4a52a2f27e4f7f5950da7ff27653a805/cryptography-50.0.1-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:fc3ed7ebd2a8c96f5b166de0ab9b624996bef3b07bbeb19364dfb78222c22c80", size = 5332955, upload-time = "2026-08-25T19:45:16.193Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/eb/5d7124083e8d8cda8f5b348f544b71ad6f707ad63193758ef4d8e569da02/cryptography-50.0.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9dde0a357190eb3b1da1bb9ab750e9c85cba82ca5977aa0836cbb94e92611239", size = 4772694, upload-time = "2026-08-25T19:45:18.315Z" },
+    { url = "https://files.pythonhosted.org/packages/63/8e/f1f955e0921dd2b6d22eae7e8d24a4c4b638d10735ffbf6a71f99eb0fcb8/cryptography-50.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd3718b960d0b5dd213cdf03f3bcb7000e69dda0de8b956061947ff6bcff5558", size = 4888413, upload-time = "2026-08-25T19:45:20.4Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/ab/89e2b798d2c3925f82e2bb72d5979f3d2f6da2dd22ef4a8cd8b70d920039/cryptography-50.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2a93d05e34d5f67fba6f891fe85d929999baa7195e853923ea6d7576c9e68c5e", size = 5044355, upload-time = "2026-08-25T19:45:22.353Z" },
+    { url = "https://files.pythonhosted.org/packages/99/89/87ef49ffe383ef4e147d27b7bf2088fb0b54ea409dd87b5a89442e5828a5/cryptography-50.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:55d16b1ef3ee0958d893a977b19777887e546c9954ea81b200c3301a864013f2", size = 3875429, upload-time = "2026-08-25T19:45:24.418Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/27/8d207af749c453ee17ea087340b3f2b4adef75aadd1d277b1b129bdda84e/cryptography-50.0.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9cb3cb952cf5a8abd50c782a98a89d71699715e802fe349704b47f2425b42a94", size = 3974350, upload-time = "2026-08-25T19:45:26.551Z" },
+    { url = "https://files.pythonhosted.org/packages/14/9a/6d3a4d7852e22d657438b7bf51f66102c7d71c0e1fafeec652281d0403e5/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:5fe939deeb161024a6be98229c953b6591fef1f41214497a78fe793a244c017f", size = 4698675, upload-time = "2026-08-25T19:45:28.658Z" },
+    { url = "https://files.pythonhosted.org/packages/73/35/5c3717edf9e68a0550ce04e28eab493fe545eccd81742af03f6a75fe260b/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:fb4b9672d389c738b175c4166e78310f8a70358886aacd9173ee03a85ffdc671", size = 4707410, upload-time = "2026-08-25T19:45:30.816Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/e0/e786934472e3ac4ecdecc7b129a0ca1a2a40dffdafcf2c3ea9d4397f8def/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d63ae8f6481fec907ac0f588eee8a90aefde112c633131fe540e5711ddbb5a4e", size = 4698378, upload-time = "2026-08-25T19:45:33.043Z" },
+    { url = "https://files.pythonhosted.org/packages/51/cf/5b3f53a0b74d122f023476ede40ba5d3e70d5cf475f73b899740d26a4fb2/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:804728ce710890870f3aaa344b2e161172d258d768ac139d02cfd9092d0d94e6", size = 4706889, upload-time = "2026-08-25T19:45:35.086Z" },
+    { url = "https://files.pythonhosted.org/packages/71/44/711e61f7d014be825ef79b285b047292d1bf893732ac1bc030a351fb517f/cryptography-50.0.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:693c99b49bd37d0d096e4334c10232c77248c415b98d35236094cdf96d57258b", size = 3824006, upload-time = "2026-08-25T19:45:37.281Z" },
+]
+
 [[package]]
 name = "cytoolz"
 version = "1.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "toolz" },
+    { name = "toolz", marker = "implementation_name == 'cpython'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/bd/d4/16916f3dc20a3f5455b63c35dcb260b3716f59ce27a93586804e70e431d5/cytoolz-1.1.0.tar.gz", hash = "sha256:13a7bf254c3c0d28b12e2290b82aed0f0977a4c2a2bf84854fcdc7796a29f3b0", size = 642510, upload-time = "2025-10-19T00:44:56.174Z" }
 wheels = [
@@ -934,7 +1124,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -1062,6 +1252,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
 ]
 
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
 [[package]]
 name = "hexbytes"
 version = "2.0.0"
@@ -1071,6 +1270,45 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e8/72/c7049aabd9e05efebc29b10208b11e5ae5cf819f48685ffced6abf871d10/hexbytes-2.0.0-py3-none-any.whl", hash = "sha256:5425bd7ac83cdd9791c13a5bf97cfe9b9609a304b1ef3ab146adfd50de06cf0e", size = 18866, upload-time = "2026-08-21T20:22:08.654Z" },
 ]
 
+[[package]]
+name = "httpcore2"
+version = "2.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "h11", marker = "python_full_version < '3.12' or python_full_version >= '3.14' or sys_platform != 'emscripten'" },
+    { name = "truststore", marker = "python_full_version < '3.12' or python_full_version >= '3.14' or sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/be/ad/f4f0e57345f1870f3e8cb624e058d7eca6e5a27d33bcc3311d9b618734cd/httpcore2-2.12.0.tar.gz", hash = "sha256:9293522bba0aa7c4c8e9e3f040c16575bd8868e155a77fa30c7a9085a5eae648", size = 67548, upload-time = "2026-08-18T13:22:08.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/74/d370e55600d9bcfa0d9794b0166126d49291a3d2b20c268fc98c453a4948/httpcore2-2.12.0-py3-none-any.whl", hash = "sha256:7e04258ce01013d7d615e5b910a3b27fac937d7a95038227e79652b4ba3b4ceb", size = 83074, upload-time = "2026-08-18T13:22:05.854Z" },
+]
+
+[[package]]
+name = "httpx2"
+version = "2.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio", marker = "sys_platform != 'emscripten'" },
+    { name = "httpcore2", marker = "sys_platform != 'emscripten'" },
+    { name = "httpx2-jsfetch", marker = "python_full_version >= '3.12' and sys_platform == 'emscripten'" },
+    { name = "idna" },
+    { name = "truststore", marker = "sys_platform != 'emscripten'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7f/f8/579a8b51e42e38ee32647df9f08aa25643ae788e275cc625b199829c4671/httpx2-2.12.0.tar.gz", hash = "sha256:7631fe9887a8a2275f4a2540e053aa670fcc50742864a9ae7c66e609fdcf12cf", size = 100040, upload-time = "2026-08-18T13:22:09.086Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/95/411ba65569158e862368917aaf56597f3e5fa3b91b0502919638465a08f3/httpx2-2.12.0-py3-none-any.whl", hash = "sha256:cc8b6eecb8661c146b8f89a60e97456ee086e91a784ed31ac450c3a9e613dd36", size = 95427, upload-time = "2026-08-18T13:22:06.834Z" },
+]
+
+[[package]]
+name = "httpx2-jsfetch"
+version = "1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/0e5636363151a2a1795e0a77617168b9ca438e1748ec05fc9b5687f93d64/httpx2_jsfetch-1.0.tar.gz", hash = "sha256:70a0e3eabfef7cce5ad9c629f7d01ca05e418f586646f4ddf14782e4c1454c60", size = 6872, upload-time = "2026-08-07T00:13:07.492Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/43/832f631d32e4f1211caa2ba368317739fe71f0b8530e4c9d15dc454bac2a/httpx2_jsfetch-1.0-py3-none-any.whl", hash = "sha256:cb916b707601e69a07721aabc8f3f6659be3a6893bc1ff5c6f9e02241df2da32", size = 6382, upload-time = "2026-08-07T00:13:06.567Z" },
+]
+
 [[package]]
 name = "idna"
 version = "3.19"
@@ -1101,6 +1339,34 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
 ]
 
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py", version = "0.30.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "rpds-py", version = "2026.6.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
 [[package]]
 name = "librt"
 version = "0.15.0"
@@ -1437,6 +1703,44 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
 ]
 
+[[package]]
+name = "mcp"
+version = "2.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "httpx2" },
+    { name = "jsonschema" },
+    { name = "mcp-types" },
+    { name = "opentelemetry-api" },
+    { name = "pydantic" },
+    { name = "pyjwt", extra = ["crypto"] },
+    { name = "python-multipart" },
+    { name = "pywin32", marker = "sys_platform == 'win32'" },
+    { name = "sse-starlette" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/31/ac54fb0fdd5b37de704486e288bba4fbbb463f24cfcfedbede407b854513/mcp-2.2.0.tar.gz", hash = "sha256:2dc37ecb1974becdcebdbf7561e7c15a07dbbf20ba21ba16c3593b3038b3afbd", size = 4084129, upload-time = "2026-09-07T16:06:23.439Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/ff/8e7eade68b8a28f7da0ed1085544341b51f9c935dbf6b95c76b7edfea6a0/mcp-2.2.0-py3-none-any.whl", hash = "sha256:bde982589473a060ae145e3406e9a5333fe538c97229ba841f5a7f92be004f81", size = 365656, upload-time = "2026-09-07T16:06:19.711Z" },
+]
+
+[[package]]
+name = "mcp-types"
+version = "2.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ae/91/762d7755d971aff8a28d75f7961656148edf27875c8026e6385aaab08ae7/mcp_types-2.2.0.tar.gz", hash = "sha256:d3ed53703ddd10d9c6399f29d322bb66f3f67ab41348ac8556ba23e07fedefad", size = 65892, upload-time = "2026-09-07T16:06:25.187Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/d7/6ffba5d8cd5dd9b8a19478875c50e04945314ba5074e84d749283f27f62d/mcp_types-2.2.0-py3-none-any.whl", hash = "sha256:ea476b73ee86709ab5abc9452385ed36cc05907e582355622e294595c9a04f13", size = 69106, upload-time = "2026-09-07T16:06:21.461Z" },
+]
+
 [[package]]
 name = "mdit-py-plugins"
 version = "0.6.1"
@@ -1745,6 +2049,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
 ]
 
+[[package]]
+name = "opentelemetry-api"
+version = "1.44.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ee/8b/aa9e2d8b8dfa7c946f7dec5d1f8f6ba8eca062f43509a06bdb5ce93d26c0/opentelemetry_api-1.44.0.tar.gz", hash = "sha256:67647e5e9566edcf421166fdf022b3537f818635daa852b289e34604dc6fb33a", size = 72406, upload-time = "2026-07-16T15:25:32.678Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/6f/a04e900f465ff3221ccc395522503e2d10e79fa21f2723c8e177aae1e0d1/opentelemetry_api-1.44.0-py3-none-any.whl", hash = "sha256:94b98c893a91b88657eaac1e3ba89618cdb85be6918196705354f34728b2cdef", size = 60018, upload-time = "2026-07-16T15:25:11.657Z" },
+]
+
 [[package]]
 name = "packaging"
 version = "26.3"
@@ -1968,6 +2284,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4e/37/60ccc88d918d8f1cd218e413fb6263afcde350dc259fb2ba413d9f7d1051/py_solc_x-2.0.5-py3-none-any.whl", hash = "sha256:d6c24b699a7db8f7bf731f32dcfe8c43d7ea9d181191b2a3b7cb5e60395dd449", size = 18750, upload-time = "2025-12-10T20:27:50.033Z" },
 ]
 
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
 [[package]]
 name = "pycryptodome"
 version = "3.23.0"
@@ -2143,6 +2468,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
 ]
 
+[[package]]
+name = "pyjwt"
+version = "2.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" },
+]
+
+[package.optional-dependencies]
+crypto = [
+    { name = "cryptography" },
+]
+
 [[package]]
 name = "pytest"
 version = "9.1.1"
@@ -2161,6 +2503,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
 ]
 
+[[package]]
+name = "python-multipart"
+version = "0.0.32"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e", size = 46881, upload-time = "2026-06-04T16:18:58.647Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" },
+]
+
 [[package]]
 name = "pyunormalize"
 version = "17.0.0"
@@ -2195,6 +2546,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/23/ed/4532e9388e65fa16b46776ef47ad631a64eda1631884488af707666350ed/pywin32-312-cp315-cp315-win_arm64.whl", hash = "sha256:a8597d28f267b39074aef51fa593530082b39cbe5a074226096857b1fed2dfb9", size = 6840337, upload-time = "2026-06-04T07:49:57.531Z" },
 ]
 
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py", version = "0.30.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "rpds-py", version = "2026.6.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
 [[package]]
 name = "regex"
 version = "2026.7.19"
@@ -2356,6 +2722,270 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a7/35/26ea7adca149e506bb03c50ade0c4d96cf269e6fc13a2b3f726d65905ffb/rlp-5.0.0-py3-none-any.whl", hash = "sha256:9525fb895d3a6540b7401eadd11c1b64740a5eccb82e543ac7e9735d319b0977", size = 19832, upload-time = "2026-08-21T21:48:50.355Z" },
 ]
 
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and implementation_name == 'cpython'",
+    "python_full_version < '3.11' and implementation_name == 'pypy'",
+    "python_full_version < '3.11' and implementation_name != 'cpython' and implementation_name != 'pypy'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/0c/0c411a0ec64ccb6d104dcabe0e713e05e153a9a2c3c2bd2b32ce412166fe/rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288", size = 370490, upload-time = "2025-11-30T20:21:33.256Z" },
+    { url = "https://files.pythonhosted.org/packages/19/6a/4ba3d0fb7297ebae71171822554abe48d7cab29c28b8f9f2c04b79988c05/rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00", size = 359751, upload-time = "2025-11-30T20:21:34.591Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/7c/e4933565ef7f7a0818985d87c15d9d273f1a649afa6a52ea35ad011195ea/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6", size = 389696, upload-time = "2025-11-30T20:21:36.122Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/01/6271a2511ad0815f00f7ed4390cf2567bec1d4b1da39e2c27a41e6e3b4de/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7", size = 403136, upload-time = "2025-11-30T20:21:37.728Z" },
+    { url = "https://files.pythonhosted.org/packages/55/64/c857eb7cd7541e9b4eee9d49c196e833128a55b89a9850a9c9ac33ccf897/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324", size = 524699, upload-time = "2025-11-30T20:21:38.92Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/ed/94816543404078af9ab26159c44f9e98e20fe47e2126d5d32c9d9948d10a/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df", size = 412022, upload-time = "2025-11-30T20:21:40.407Z" },
+    { url = "https://files.pythonhosted.org/packages/61/b5/707f6cf0066a6412aacc11d17920ea2e19e5b2f04081c64526eb35b5c6e7/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3", size = 390522, upload-time = "2025-11-30T20:21:42.17Z" },
+    { url = "https://files.pythonhosted.org/packages/13/4e/57a85fda37a229ff4226f8cbcf09f2a455d1ed20e802ce5b2b4a7f5ed053/rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221", size = 404579, upload-time = "2025-11-30T20:21:43.769Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/da/c9339293513ec680a721e0e16bf2bac3db6e5d7e922488de471308349bba/rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7", size = 421305, upload-time = "2025-11-30T20:21:44.994Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/be/522cb84751114f4ad9d822ff5a1aa3c98006341895d5f084779b99596e5c/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff", size = 572503, upload-time = "2025-11-30T20:21:46.91Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/9b/de879f7e7ceddc973ea6e4629e9b380213a6938a249e94b0cdbcc325bb66/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7", size = 598322, upload-time = "2025-11-30T20:21:48.709Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ac/f01fc22efec3f37d8a914fc1b2fb9bcafd56a299edbe96406f3053edea5a/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139", size = 560792, upload-time = "2025-11-30T20:21:50.024Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/da/4e2b19d0f131f35b6146425f846563d0ce036763e38913d917187307a671/rpds_py-0.30.0-cp310-cp310-win32.whl", hash = "sha256:6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464", size = 221901, upload-time = "2025-11-30T20:21:51.32Z" },
+    { url = "https://files.pythonhosted.org/packages/96/cb/156d7a5cf4f78a7cc571465d8aec7a3c447c94f6749c5123f08438bcf7bc/rpds_py-0.30.0-cp310-cp310-win_amd64.whl", hash = "sha256:1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169", size = 235823, upload-time = "2025-11-30T20:21:52.505Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425", size = 370157, upload-time = "2025-11-30T20:21:53.789Z" },
+    { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d", size = 359676, upload-time = "2025-11-30T20:21:55.475Z" },
+    { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4", size = 389938, upload-time = "2025-11-30T20:21:57.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f", size = 402932, upload-time = "2025-11-30T20:21:58.47Z" },
+    { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4", size = 525830, upload-time = "2025-11-30T20:21:59.699Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97", size = 412033, upload-time = "2025-11-30T20:22:00.991Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89", size = 390828, upload-time = "2025-11-30T20:22:02.723Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d", size = 404683, upload-time = "2025-11-30T20:22:04.367Z" },
+    { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038", size = 421583, upload-time = "2025-11-30T20:22:05.814Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7", size = 572496, upload-time = "2025-11-30T20:22:07.713Z" },
+    { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed", size = 598669, upload-time = "2025-11-30T20:22:09.312Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85", size = 561011, upload-time = "2025-11-30T20:22:11.309Z" },
+    { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c", size = 221406, upload-time = "2025-11-30T20:22:13.101Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825", size = 236024, upload-time = "2025-11-30T20:22:14.853Z" },
+    { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229", size = 229069, upload-time = "2025-11-30T20:22:16.577Z" },
+    { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" },
+    { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" },
+    { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" },
+    { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" },
+    { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" },
+    { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" },
+    { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" },
+    { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" },
+    { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" },
+    { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" },
+    { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" },
+    { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" },
+    { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" },
+    { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" },
+    { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" },
+    { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" },
+    { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" },
+    { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" },
+    { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" },
+    { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" },
+    { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" },
+    { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58", size = 372292, upload-time = "2025-11-30T20:24:16.537Z" },
+    { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a", size = 362128, upload-time = "2025-11-30T20:24:18.086Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb", size = 391542, upload-time = "2025-11-30T20:24:20.092Z" },
+    { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c", size = 404004, upload-time = "2025-11-30T20:24:22.231Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3", size = 527063, upload-time = "2025-11-30T20:24:24.302Z" },
+    { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5", size = 413099, upload-time = "2025-11-30T20:24:25.916Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738", size = 392177, upload-time = "2025-11-30T20:24:27.834Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f", size = 406015, upload-time = "2025-11-30T20:24:29.457Z" },
+    { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877", size = 423736, upload-time = "2025-11-30T20:24:31.22Z" },
+    { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a", size = 573981, upload-time = "2025-11-30T20:24:32.934Z" },
+    { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4", size = 599782, upload-time = "2025-11-30T20:24:35.169Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "2026.6.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.15' and implementation_name == 'cpython'",
+    "python_full_version >= '3.15' and implementation_name == 'pypy'",
+    "python_full_version >= '3.15' and implementation_name != 'cpython' and implementation_name != 'pypy'",
+    "python_full_version == '3.14.*' and implementation_name == 'cpython'",
+    "python_full_version >= '3.12' and python_full_version < '3.14' and implementation_name == 'cpython' and sys_platform == 'emscripten'",
+    "(python_full_version >= '3.11' and python_full_version < '3.14' and implementation_name == 'cpython' and sys_platform != 'emscripten') or (python_full_version == '3.11.*' and implementation_name == 'cpython' and sys_platform == 'emscripten')",
+    "python_full_version == '3.14.*' and implementation_name == 'pypy'",
+    "python_full_version >= '3.12' and python_full_version < '3.14' and implementation_name == 'pypy' and sys_platform == 'emscripten'",
+    "(python_full_version >= '3.11' and python_full_version < '3.14' and implementation_name == 'pypy' and sys_platform != 'emscripten') or (python_full_version == '3.11.*' and implementation_name == 'pypy' and sys_platform == 'emscripten')",
+    "python_full_version == '3.14.*' and implementation_name != 'cpython' and implementation_name != 'pypy'",
+    "python_full_version >= '3.12' and python_full_version < '3.14' and implementation_name != 'cpython' and implementation_name != 'pypy' and sys_platform == 'emscripten'",
+    "(python_full_version >= '3.11' and python_full_version < '3.14' and implementation_name != 'cpython' and implementation_name != 'pypy' and sys_platform != 'emscripten') or (python_full_version == '3.11.*' and implementation_name != 'cpython' and implementation_name != 'pypy' and sys_platform == 'emscripten')",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/2a/9618a122aeb2a169a28b03889a2995fe297588964333d4a7d67bdf46e147/rpds_py-2026.6.3.tar.gz", hash = "sha256:1cebd1337c242e4ec2293e541f712b2da849b29f48f0c293684b71c0632625d4", size = 64051, upload-time = "2026-06-30T07:17:53.009Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/1f/a2dca5ffdbf1d475ffc4e80e4d5d720ff3a00f691795910116960ee12511/rpds_py-2026.6.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7b689145a1485c335569bd056464f3243a29af7ed3871c7be31ad624ba239bc7", size = 342174, upload-time = "2026-06-30T07:14:54.821Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/dc/323d08583c0832911768663d1944f0107fcd4088704858d84b5e06d105a0/rpds_py-2026.6.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:db08f45aecde626498fb3df07bcf6d2ec040af42e859a4f5040d79c200342911", size = 345513, upload-time = "2026-06-30T07:14:56.515Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/2a/e31989834d18d2f26ec1d2774c5b1eb3331df4ea8ada525175294c94b48a/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:acc992ab27b15f852c76755eb2ab7dce86585ddadba6fa5946e58556088845b4", size = 373783, upload-time = "2026-06-30T07:14:57.736Z" },
+    { url = "https://files.pythonhosted.org/packages/87/fe/e80107ee3639585c9941c17d6a42cd65325022f656c023191fce78c324c8/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f88d653e7b3b779d71ae7454e20dcc9b6bae903f33c269db9f2be41bda3f261", size = 378316, upload-time = "2026-06-30T07:14:59.077Z" },
+    { url = "https://files.pythonhosted.org/packages/22/6f/81e3adf81acfb6fa694de2a6e4e7d8863121e3e0799e0a7725e6cf5679c4/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e52655eaf81e32593abedaa4bfe33170c8cfedf3365ed9be6e11e07f148f0278", size = 499423, upload-time = "2026-06-30T07:15:00.488Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/9a/41263969df0ce3d9af2a96d5005a288200af1989aed3354bfceb5fc0b21f/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dfcc8b909769d19db55c7cc9541eb64b9b774b1057ffffb4f1048070475bb9f9", size = 386077, upload-time = "2026-06-30T07:15:01.911Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/19/7e98f468bd50346faff5b10e5297374b443bfdddacc8e9fbc65984539597/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c1255b302953c86a486b81d330d5ee1d5bd937691ce271b6be0ef0e299eaab7", size = 371315, upload-time = "2026-06-30T07:15:03.317Z" },
+    { url = "https://files.pythonhosted.org/packages/99/3c/2b973b4d371906a134b03decfea7f5d9835a2c6d263454392e15b64b5b18/rpds_py-2026.6.3-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:8d2294a31386bfa251d8c8a39472beee17db67d4f1a6eabea665d35c9a4461c3", size = 383502, upload-time = "2026-06-30T07:15:04.627Z" },
+    { url = "https://files.pythonhosted.org/packages/98/2a/12e2799500af0a307bca76b63361c51f9fe479223561489c29eea1f2ee41/rpds_py-2026.6.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f8f23ead891a3b762f35ab3b04623da7056545b48aa60d59957e6789914545da", size = 402673, upload-time = "2026-06-30T07:15:05.856Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/e3/21e5872d165fe08be4f229e3d5ee9d90019c0bf0e5538de60dbd54009450/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:421aba32367055614287a4292b6a17f1939c9452299f7a0209c117e990b646d4", size = 549964, upload-time = "2026-06-30T07:15:07.159Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d0/5ee0fe36844297de8123bee27bc12078c1a7416ad9f1b8a8ca18d6b0c0ac/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1e5822dfc2f0d4ab7e745eaa6d85945069329beeccef965af3f3bb26058fcab6", size = 615446, upload-time = "2026-06-30T07:15:08.531Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/80/1ea5873cb683f2fbe5f21b23ea1f6d179ead19f3c5b249b7eb5dca568ef2/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:83e35b57523816c8613fd0776b40cd8bb9f596b37ddd2692eb4a6bb5ab2f8c93", size = 576975, upload-time = "2026-06-30T07:15:09.97Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/e1/90ef639217a5ddb15b7f4f61b1c33911fd044ad03c311bafdd2bcab85582/rpds_py-2026.6.3-cp311-cp311-win32.whl", hash = "sha256:de3eceba0b683bcbb1ab93da016d0270df1f9ae7be716b40214c5dafac6ea45a", size = 204453, upload-time = "2026-06-30T07:15:11.324Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/b7/b7a1695d7af36f521fb11e80d6d3adbd744f73b921859bd3c2a2c0dc706f/rpds_py-2026.6.3-cp311-cp311-win_amd64.whl", hash = "sha256:2c54a076ca4d370980ab57bc0e31df57bbe8d41340436a90ef8b1219a3cbb127", size = 223219, upload-time = "2026-06-30T07:15:12.476Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a2/145afacf796e4506062825941176ad9445c2dcf2b3b6a1f13d3030a15e19/rpds_py-2026.6.3-cp311-cp311-win_arm64.whl", hash = "sha256:168c733a7112e071bb7a66460e667edfcff06c017a3c523f7a8a8e08d0140804", size = 219137, upload-time = "2026-06-30T07:15:13.631Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/be/2e8974163072e7bab7df1a5acd54c4498e75e35d6d18b864d3a9d5dadc92/rpds_py-2026.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a0811d33247c3d6128a3001d763f2aa056bb3425204335400ac54f89eec3a0d0", size = 343691, upload-time = "2026-06-30T07:15:14.96Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/73/319dfa745dd668efe89309141ded489126461fcecd2b8f3a3cda185129b6/rpds_py-2026.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:538949e262e46caa31ac01bdb3c1e8f642622922cacbabbae6a8445d9dc33eaf", size = 338542, upload-time = "2026-06-30T07:15:16.267Z" },
+    { url = "https://files.pythonhosted.org/packages/21/63/4239893be1c4d09b709b1a8f6be4188f0870084ff547f46606b8a75f1b03/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55927d532399c2c646100ff7feb48eaa940ad70f42cd68e1328f3ded9f81ca24", size = 368180, upload-time = "2026-06-30T07:15:17.62Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/ca/9c5de382225234ceb37b1844ebdb140db12b2a278bb9efe2fcd19f6c82ce/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f56f1695bc5c0871cbc33dc0130fcf503aab0c57dcc5a6700a4f49eba4f2652e", size = 375067, upload-time = "2026-06-30T07:15:18.952Z" },
+    { url = "https://files.pythonhosted.org/packages/87/dc/863f69d1bf04ade34b7fe0d59b9fdf6f0135fe2d7cbca74f1d665589559d/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:270b293dae9058fc9fcedab50f13cebf46fb8ed1d1d54e0521a9da5d6b211975", size = 490509, upload-time = "2026-06-30T07:15:20.434Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/ef/eac16a12048b45ec7c7fa94f2be3438a5f26bf9cc8580b18a1cfd609b7f6/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:127565fead0a10943b282957bd5447804ff3160ad79f2ad2635e6d249e380680", size = 382754, upload-time = "2026-06-30T07:15:21.831Z" },
+    { url = "https://files.pythonhosted.org/packages/04/8f/d2f3f532616be4d06c316ef119683e832bd3d41e112bf3a88f4151c95b17/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecabd69db66de867690f9797f2f8fa27ba501bbc24540cbdbdc649cd15888ba6", size = 366189, upload-time = "2026-06-30T07:15:23.371Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/29/41a7b0e98a4b44cd676ab7598419623373eb43b20be68c084935c1a8cf88/rpds_py-2026.6.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:58eadac9cd119677b60e1cf8ac4052f35949d71b8a9e5556efccbe82533cf22a", size = 377750, upload-time = "2026-06-30T07:15:24.659Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/05/ecda0bec46f9a1565090bcdc941d023f6a25aff85fda28f89f8d19878152/rpds_py-2026.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7491ee23305ac3eb59e492b6945881f5cd77a6f731061a3f25b77fd40f9e99a4", size = 395576, upload-time = "2026-06-30T07:15:25.987Z" },
+    { url = "https://files.pythonhosted.org/packages/68/a8/6ed52f03ee6cb854ce78785cc9a9a672eb880e83fd7224d471f667d151f1/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c99f7e8ccb3dd6e3e4bfeac657a7b208c9bac8075f4b078c02d7404c34107fa", size = 543807, upload-time = "2026-06-30T07:15:27.356Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/d6/156c0d3eea27ba09b92562ba2364ba124c0a061b199e17eac637cd25a5e2/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:62698275682bf121181861295c9181e789030a2d516071f5b8f3c23c170cd0fc", size = 611187, upload-time = "2026-06-30T07:15:28.931Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/31/774212ed989c62f7f310220089f9b0a3fb8f40f5443d1727abd5d9f52bc9/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a214c993455f99a89aaeadc9b21241900037adc9d97203e374d75513c5911822", size = 573030, upload-time = "2026-06-30T07:15:30.553Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/50/22f73127a41f1ce4f87fe39aadfb9a126345801c274aa93ae88456249327/rpds_py-2026.6.3-cp312-cp312-win32.whl", hash = "sha256:501f9f04a588d6a09179368c57071301445191767c64e4b52a6aa9871f1ef5ed", size = 202185, upload-time = "2026-06-30T07:15:32.027Z" },
+    { url = "https://files.pythonhosted.org/packages/04/3a/f0ee4d4dde9d3b69dedf1b5f74e7a40017046d55052d173e418c6a94f960/rpds_py-2026.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:2c958bf94822e9290a40aaf2a822d4bc5c88099093e3948ad6c571eca9272e5f", size = 220394, upload-time = "2026-06-30T07:15:33.359Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/83/3382fe37f809b59f02aac04dbc4e765b480b46ee0227ed516e3bdc4d3dfc/rpds_py-2026.6.3-cp312-cp312-win_arm64.whl", hash = "sha256:22bffe6042b9bcb0822bcd1955ec00e245daf17b4344e4ed8e9551b976b63e96", size = 215753, upload-time = "2026-06-30T07:15:34.778Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/9e/b818ee580026ec578138e961027a68820c40afeb1ec8f6819b54fb99e196/rpds_py-2026.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:3cfe765c1da0072636ca06628261e0ea05688e160d5c8a03e0217c3854037223", size = 343012, upload-time = "2026-06-30T07:15:36.005Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/6b/686d9dc4359a8f163cfbbf89ee0b4e586431de22fe8248edb63a8cf50d49/rpds_py-2026.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f4d78253f6996be4901669ad25319f842f740eccf4d58e3c7f3dd39e6dde1d8f", size = 338203, upload-time = "2026-06-30T07:15:37.462Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/9b/069aa329940f8207615e091f5eedbbd40e1e15eac68a0790fd05ccdf796c/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54f45a148e28767bf343d33a684693c70e451c6f4c0e9904709a723fafbdfc1f", size = 367984, upload-time = "2026-06-30T07:15:39.008Z" },
+    { url = "https://files.pythonhosted.org/packages/14/db/34c203e4becff3703e4d3bc121842c00b8689197f398161203a880052f4e/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:842e7b070435622248c7a2c44ae53fa1440e073cc3023bc919fed570884097a7", size = 374815, upload-time = "2026-06-30T07:15:40.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/7d/8071067d2cc453d916ad836e828c943f575e8a44612537759002a1e07381/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8020133a74bd81b4572dd8e4be028a6b1ebcd70e6726edc3918008c08bee6ee6", size = 490545, upload-time = "2026-06-30T07:15:41.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/42/da06c5aa8f0484ff07f270787434204d9f4535e2f8c3b51ed402267e63c3/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdc7e35386f3847df728fbcb5e887e2d79c19e2fa1eba9e51b6621d23e3243af", size = 382828, upload-time = "2026-06-30T07:15:43.327Z" },
+    { url = "https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acac386b453c2516111b50985d60ce46e7fadb5ea71ae7b25f4c946935bf27cf", size = 365678, upload-time = "2026-06-30T07:15:44.992Z" },
+    { url = "https://files.pythonhosted.org/packages/69/9d/1d8922e1990b2a6eb532b6ff53d3e73d2b3bbffc84116c75826bee73dfc6/rpds_py-2026.6.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:425560c6fa0415f27261727bb20bd097568485e5eb0c121f1949417d1c516885", size = 377811, upload-time = "2026-06-30T07:15:46.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/3d/198dceafb4fb034a6a47347e1b0735d34e0bd4a50be4e898d408ee66cb14/rpds_py-2026.6.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a550fb4950a06dde3beb4721f5ad4b25bf4513784665b0a8522c792e2bd822a4", size = 395382, upload-time = "2026-06-30T07:15:47.955Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f1/13968e49655d40b6b19d8b9140296bbc6f1d86b3f0f6c346cf9f1adddf4b/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f4bca01b63096f606e095734dd56e74e175f94cfbf24ff3d63281cec61f7bb7", size = 543832, upload-time = "2026-06-30T07:15:49.33Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ab/289bcb1b90bd3e40a2900c561fa0e2087345ecbb094f0b870f2345142b7c/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ccffae9a092a00deb7efd545fe5e2c33c33b88e7c054337e9a74c179347d0b7d", size = 611011, upload-time = "2026-06-30T07:15:50.847Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/16/5043105e679436ccfbc8e5e0dd2d663ed18a8b8113515fd06a5e5d77c83e/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1cf01971c4f2c5553b772a542e4aaf191789cd331bc2cd4ff0e6e65ba49e1e97", size = 572431, upload-time = "2026-06-30T07:15:52.394Z" },
+    { url = "https://files.pythonhosted.org/packages/85/ed/adab103321c0a6565d5ae1c2998349bc3ee175b82ccc5ae8fc04cc413075/rpds_py-2026.6.3-cp313-cp313-win32.whl", hash = "sha256:8c3d1e9c15b9d51ca0391e13da1a25a0a4df3c58a37c9dc368e0736cf7f69df0", size = 201710, upload-time = "2026-06-30T07:15:53.894Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/a03b09668e74e5dabbf2e211f6468e1820c0552f7b0500082da31841bf7b/rpds_py-2026.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:9250a9a0a6fd4648b3f868da8d91a4c52b5811a62df58e753d50ae4454a36f80", size = 219454, upload-time = "2026-06-30T07:15:55.25Z" },
+    { url = "https://files.pythonhosted.org/packages/27/17/b8642c12930b71bc2b25831f6708ccf0f75abcd11883932ec9ce54ba3a78/rpds_py-2026.6.3-cp313-cp313-win_arm64.whl", hash = "sha256:900a67df3fd1660b035a4761c4ce73c382ea6b35f90f9863c36c6fd8bf8b09bb", size = 215063, upload-time = "2026-06-30T07:15:56.573Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/36/7fbe9dcdaf857fb3f63c2a2284b62492d95f5e8334e947e5fb6e7f68c9be/rpds_py-2026.6.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:931908d9fc855d8f74783377822be318edb6dcb19e47169dc038f9a1bf60b06e", size = 344510, upload-time = "2026-06-30T07:15:57.921Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/54/f785cc3d3f60839ca57a5af4927a9f347b07b2799c373fc20f7949f87c7e/rpds_py-2026.6.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7469697dce35be237db177d42e2a2ee26e6dcc5fc052078a6fefabd288c6edd", size = 339495, upload-time = "2026-06-30T07:15:59.238Z" },
+    { url = "https://files.pythonhosted.org/packages/63/ef/d4cdaf309e6b095b43597103cf8c0b951d6cca2acce68c474f75ec12e0c7/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcfbcf66006befb9fd2aeaa9e01feaf881b4dc330a02ba07d2322b1c11be7b5d", size = 369454, upload-time = "2026-06-30T07:16:01.021Z" },
+    { url = "https://files.pythonhosted.org/packages/96/4a/9559a68b7ee15db09d7981212e8c2e219d2a1d6d4faa0391d813c3496a36/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:847927daf4cffbd4e90e42bc890069897101edd015f956cb8721b3473372edda", size = 374583, upload-time = "2026-06-30T07:16:02.287Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/75/8964aa7d2c6e8ac43eba8eb6e6b0fdda1f46d39f2fc3e6aa9f2cb17f485d/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c1ef08a82bfe327cc156da694660f599923e2e6665b6d81c9c2d0ac9ffc8", size = 492919, upload-time = "2026-06-30T07:16:03.723Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/97/6908094ac804115e65aedfd90f1b5fee4eebebd3f6c4cfc5419939267565/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae50181a047c871561212bb97f7932a2d45fb53e947bd9b57ebad85b529cbc53", size = 383725, upload-time = "2026-06-30T07:16:05.305Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/9c/0d1fdc2e7aba23e290d603bc494e97bd205bae262ce33c6b32a69768ed5e/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc319e5a1de4b6913aac94bf6a2f9e847371e0a140a43dd4991db1a09bc2d504", size = 367255, upload-time = "2026-06-30T07:16:07.086Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/fe/f0209ca4a9ed074bc8acb44dfd0e81c3122e94c9689f5645b7973a866719/rpds_py-2026.6.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e4316bf32babbed84e691e352faf967ce2f0f024174a8643c37c94a1080374fc", size = 379060, upload-time = "2026-06-30T07:16:08.525Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/8d/f1cc54c616b9d8897de8738aac148d20afca93f68187475fe194d09a71b9/rpds_py-2026.6.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8c6e5a2f750cc71c3e3b11d71661f21d6f9bc6cebc6564b1466417a1ec03ec77", size = 395960, upload-time = "2026-06-30T07:16:09.989Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/04/aafff00f73aeca2945f734f1d483c64ab8f472d0864ab02377fd8e89c3b2/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4470ce197d4090875cf6affbf1f853338387428df97c4fb7b7106317b8214698", size = 545356, upload-time = "2026-06-30T07:16:11.816Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/cc/e229663b9e4ddac5a4acbe9085dd80a71af2a5d356b8b39d6bff233f24b0/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea964164cc9afa72d4d9b23cc28dafae93693c0a53e0b42acbff15b22c3f9ddd", size = 612319, upload-time = "2026-06-30T07:16:13.586Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/7a/8a0e6d3e6cd066af108b71b43122c3fe158dd9eb86acac626593a2582eb1/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:639c8929aa0afe81be836b04de888460d6bed38b9c54cfc18da8f6bfabf5af5d", size = 573508, upload-time = "2026-06-30T07:16:15.23Z" },
+    { url = "https://files.pythonhosted.org/packages/87/03/2a69ab618a789cf6cf85c86bb844c62d090e700ab1a2aa676b3741b6c516/rpds_py-2026.6.3-cp314-cp314-win32.whl", hash = "sha256:882076c00c0a608b131187055ddc5ae29f2e7eaf870d6168980420d58528a5c8", size = 202504, upload-time = "2026-06-30T07:16:16.893Z" },
+    { url = "https://files.pythonhosted.org/packages/85/62/a3892ba945f4e24c78f352e5de3c7620d8479f73f211406a97263d13c7d2/rpds_py-2026.6.3-cp314-cp314-win_amd64.whl", hash = "sha256:0be972be84cfcaf46c8c6edf690ca0f154ac17babf1f6a955a51579b34ad2dc5", size = 220380, upload-time = "2026-06-30T07:16:18.108Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e7/c2bd44dc831931815ad11ebb5f430b5a0a4d3caa9de837107876c30c3432/rpds_py-2026.6.3-cp314-cp314-win_arm64.whl", hash = "sha256:2a9c6f195058cb45335e8cc3802745c603d716eb96bc9625950c1aac71c0c703", size = 215976, upload-time = "2026-06-30T07:16:19.654Z" },
+    { url = "https://files.pythonhosted.org/packages/79/9c/fff7b74bce9a091ec9a012a03f9ff5f69364eaf9451060dfc4486da2ffdd/rpds_py-2026.6.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:f90938e92afda60266da758ee7d363447f7f0138c9559f9e1811629580582d90", size = 346840, upload-time = "2026-06-30T07:16:21.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/44/77bcb1168b33704908295533d27f10eb811e9e3e193e8993dc99572211d3/rpds_py-2026.6.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec829541c45bca16e61c7ae50c20501f213605beb75d1aba91a6ee37fbbb56a4", size = 340282, upload-time = "2026-06-30T07:16:22.875Z" },
+    { url = "https://files.pythonhosted.org/packages/87/3c/7a9081c7c9e645b39efe19e4ffbeccd80add246327cd9b888aecffd72317/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afd70d95892096cdb26f15a00c45907b17817577aa8d1c76b2dcc2788391f9e9", size = 370403, upload-time = "2026-06-30T07:16:24.415Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/69/af47021eb7dad6ff3396cb001c08f0f3c4d06c20253f75be6421a59fe6b7/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29dfa0533a5d4c94d4dfa1b694fcb56c9c63aad8330ffdd816fd225d0a7a162f", size = 376055, upload-time = "2026-06-30T07:16:26.111Z" },
+    { url = "https://files.pythonhosted.org/packages/81/fc/a3bcf517084396a6dd258c592567a3c011ba4557f2fde23dceaf26e74f2e/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af05d726809bff6b141be124d4c7ce998f9c9c7f30edb1f46c07aa103d540b41", size = 494419, upload-time = "2026-06-30T07:16:27.596Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/eb/13d529d1788135425c7bf207f8463458ca5d92e43f3f701365b83e9dffc1/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9826217f048f620d9a712672818bf231442c1b35d96b227a07eabd11b4bb6945", size = 384848, upload-time = "2026-06-30T07:16:29.183Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/f4/b7ac49f30013aba8f7b9566b1dd07e81de95e708c1374b7bacc5b9bc5c9c/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:536bceea4fa4acf7e1c61da2b5786304367c816c8895be71b8f537c480b0ea1f", size = 371369, upload-time = "2026-06-30T07:16:30.912Z" },
+    { url = "https://files.pythonhosted.org/packages/31/86/6260bafa622f788b07ddec0e52d810305c8b9b0b8c27f58a2ab04bf62b4f/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:bc0011654b91cc4fb2ae701bec0a0ba1e552c0714247fa7af6c59e0ccfa3a4e1", size = 379673, upload-time = "2026-06-30T07:16:32.486Z" },
+    { url = "https://files.pythonhosted.org/packages/19/c3/03f1ee79a047b48daeca157c89a18509cde22b6b951d642b9b0af1be660a/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:539d75de9e0d536c84ff18dfeb805398e58227001ce09231a26a08b9aed1ee0e", size = 397500, upload-time = "2026-06-30T07:16:34.471Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/95/8ed0cd8c377dca12aea498f119fe639fc474d1461545c39d2b5872eb1c0f/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:166cf54d9f44fc6ceb53c7860258dde44a81406646de79f8ed3234fca3b6e538", size = 545978, upload-time = "2026-06-30T07:16:36.45Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/f2/0eb57f0eaa83f8fc152a7e03de968ab77e1f00732bebc892b190c6eebde7/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:d34c20167764fbcf927194d532dd7e0c56772f0a5f943fa5ef9e9afbba8fb9db", size = 613350, upload-time = "2026-06-30T07:16:38.213Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/de/e0674bdbc3ef7634989b3f854c3f34bc1f587d36e5bfdc5c378d57034619/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea7bb13b7c9a29791f87a0387ba7d3ad3a6d783d827e4d3f27b40a0ff44495e2", size = 576486, upload-time = "2026-06-30T07:16:39.797Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/f6/21101359743cd136ada781e8210a85769578422ba460672eea0e29739200/rpds_py-2026.6.3-cp314-cp314t-win32.whl", hash = "sha256:6de4744d05bd1aa1be4ed7ea1189e3979196808008113bbbf899a460966b925e", size = 201068, upload-time = "2026-06-30T07:16:41.316Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/b2/9574d4d44f7760c2aa32d92a0a4f41698e33f5b204a0bf5c9758f52c79d5/rpds_py-2026.6.3-cp314-cp314t-win_amd64.whl", hash = "sha256:c7b9a2f8f4d8e90af72571d3d495deebdd7e3c75451f5b41719aee166e940fc2", size = 220600, upload-time = "2026-06-30T07:16:43.091Z" },
+    { url = "https://files.pythonhosted.org/packages/08/ae/f23a2697e6ee6340a578b0f136be6483657bef0c6f9497b752bb5c0964bb/rpds_py-2026.6.3-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:e059c5dde6452b44424bd1834557556c226b57781dee1227af23518459722b13", size = 344726, upload-time = "2026-06-30T07:16:44.5Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/63/e7b3a1a5358dd32c930a1062d8e15b67fd6e8922e81df9e91706d66ee5c8/rpds_py-2026.6.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2f7c26fbc5acd2522b95d4177fe4710ffd8e9b20529e703ffbf8db4d93903f05", size = 339587, upload-time = "2026-06-30T07:16:46.255Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/64/10a85681916ca55fffb91b0a211f84e34297c109243484dd6394660a8a7c/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3086b538543802f84c843911242db20447de00d8752dd0efc936dbcf02218ba", size = 369585, upload-time = "2026-06-30T07:16:48.101Z" },
+    { url = "https://files.pythonhosted.org/packages/76/c2/baf95c7c38823e12ba34407c5f5767a89e5cf2233895e56f608167ae9493/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2e5c5ee828d42cb11760761c0af6507927bec42d0ad5458f97c9203b054617", size = 375479, upload-time = "2026-06-30T07:16:49.93Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/94/0aad06c72d65101e11d33528d438cda99a39ce0da99466e156158f2541d3/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed0c1e5d10cdc7135537988c74a0188da68e2f3c30813ba3744ab1e42e0480f9", size = 492418, upload-time = "2026-06-30T07:16:51.641Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/17/de3f5a479a1f056535d7489819639d8cd591ea6281d700390b43b1abd745/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c2642a7603ec0b16ed77da4555db3b4b472341904873788327c0b0d7b95f1bb", size = 384123, upload-time = "2026-06-30T07:16:53.622Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7d/bf09bd1b145bb2671c03e1e6d1ab8651858d90d8c7dfeadd85a37a934fd8/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4320744c1ffdd95a603def63344bfab2d33edeab301c5007e7de9f9f5b3885", size = 367351, upload-time = "2026-06-30T07:16:55.241Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/ea/1bb734f314b8be319149ddee80b18bd41372bdcfbdf88d28131c0cd37719/rpds_py-2026.6.3-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:a9f4645593036b81bbdb36b9c8e0ea0d1c3fee968c4d59db0344c14087ef143a", size = 378827, upload-time = "2026-06-30T07:16:56.841Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/93/d9611e5b25e26df9a3649813ed66193ace9347a7c7fc4ab7cf70e94851c0/rpds_py-2026.6.3-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e55d236be29255554da47abe5c577637db7c24a02b8b46f0ca9524c855801868", size = 395966, upload-time = "2026-06-30T07:16:58.557Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/cb/99d77e16e5534ae1d90629bbe419ba6ee170833a6a85e3aa1cc41726fbbc/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:24e9c5386e16669b674a69c156c8eeefcb578f3b3397b713b08e6d60f3c7b187", size = 545680, upload-time = "2026-06-30T07:17:00.164Z" },
+    { url = "https://files.pythonhosted.org/packages/59/15/11a29755f790cef7a2f755e8e14f4f0c33f39489e1893a632a2eee59672b/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:c60924535c75f1566b6eb75b5c31a48a43fef04fa2d0d201acbad8a9969c6107", size = 611853, upload-time = "2026-06-30T07:17:01.962Z" },
+    { url = "https://files.pythonhosted.org/packages/68/86/0c27547e21644da938fb530f7e1a8148dd24d02db07e7a5f2567a17ce710/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:38a2fea2787428f811719ceb9114cb78964a3138838320c29ac39526c79c16ba", size = 573715, upload-time = "2026-06-30T07:17:03.693Z" },
+    { url = "https://files.pythonhosted.org/packages/29/71/4d8fcf700931815594bce892255bbd973b94efaf0fc1932b0590df18d886/rpds_py-2026.6.3-cp315-cp315-win32.whl", hash = "sha256:d483fe17f01ad64b7bf7cc38fcefff1ca9fb83f8c2b2542b68f97ffe0611b369", size = 202864, upload-time = "2026-06-30T07:17:05.746Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/62/b577562de0edbb55b2be85ce5fd09c33e386b9b13eee09833af4240fd5c4/rpds_py-2026.6.3-cp315-cp315-win_amd64.whl", hash = "sha256:67e3a721ffc5d8d2210d3671872298c4a84e4b8035cfe42ffd7cde35d772b146", size = 220430, upload-time = "2026-06-30T07:17:07.471Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/95/d6d0b2509825141eef60669a5739eec88dbc6a48053d6c92993a5704defe/rpds_py-2026.6.3-cp315-cp315-win_arm64.whl", hash = "sha256:6e84adbcf4bf841aed8116a8264b9f50b4cb3e7bd89b516122e616ac56ca269e", size = 215877, upload-time = "2026-06-30T07:17:09.008Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bf/f3ea278f0afd615c1d0f19cb69043a41526e2bb600c2b536eb192218eb27/rpds_py-2026.6.3-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ae6dd8f10bd17aad820876d24caec9efdafd80a318d16c0a48edb5e136902c6b", size = 346933, upload-time = "2026-06-30T07:17:10.762Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/29/9907bdf1c5346763cf10b7f6852aad86652168c259def904cbe0082c5864/rpds_py-2026.6.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bdbd97738551fca3917c1bd7188bec1920bb520104f28e7e1007f9ceb17b7690", size = 340274, upload-time = "2026-06-30T07:17:12.266Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/2c/8e03767b5778ef25cebf74a7a91a2c3806f8eced4c92cb7406bbe060756d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b95977e7211527ab0ba576e286d023389fbeeb32a6b7b771665d333c60e5342", size = 370763, upload-time = "2026-06-30T07:17:14.107Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/e1/df2a7e1ba2efd796af26194250b8d42c821b46592311595162af9ef0528d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15fde0e6fb0d88a60d221204873743e5d9f0b7d29165e62cd86d0413ad74ba6", size = 376467, upload-time = "2026-06-30T07:17:15.76Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/de/8a0814d1946af29cb068fb259aa8622f856df1d0bab58429448726b537f5/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a136d453475ac0fcbda502ef1e6504bd28d6d904700915d278deeab0d00fe140", size = 496689, upload-time = "2026-06-30T07:17:17.308Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f3/f19e0c852ba13694f5a79f3b719331051573cb5693feacf8a88ffffc3a71/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f826877d462181e5eb1c26a0026b8d0cab05d99844ecb6d8bf3627a2ca0c0442", size = 385340, upload-time = "2026-06-30T07:17:18.928Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/ae/7ec3a9d2d4351f99e37bcb06b6b6f954512646bfdbf9742e1de727865daf/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79486287de1730dbaff3dbd124d0ca4d2ef7f9d29bf2544f1f93c09b5bcbbd12", size = 372179, upload-time = "2026-06-30T07:17:20.539Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ac/9cee911dff2aaa9a5a8354f6610bf2e6a616de9197c5fff4f54f82585f1e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:808345f53cb952433ca2816f1604ff3515608a81784954f38d4452acfe8e61d5", size = 379993, upload-time = "2026-06-30T07:17:22.212Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6b/7c2a07ba88d1e9a936612f7a5d067467ed03d971d5a06f7d309dff044a7e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1967debc37f64f2c4dc90a7f563aec558b471966e12adcac4e1c4240496b6ebf", size = 398909, upload-time = "2026-06-30T07:17:23.66Z" },
+    { url = "https://files.pythonhosted.org/packages/97/0b/776ffcb66783637b0031f6d58d6fb55913c8b5abf00aeecd46bf933fb477/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:f0840b5b17057f7fd918b76183a4b5a0635f43e14eb2ce60dce1d4ee4707ea00", size = 546584, upload-time = "2026-06-30T07:17:25.264Z" },
+    { url = "https://files.pythonhosted.org/packages/55/33/ba3bc04d7092bd553c9b2b195624992d2cc4f3de1f380b7b93cbee67bd79/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:faa679d19a6696fd54259ad321251ad77a13e70e03dd834daa762a44fb6196ef", size = 614357, upload-time = "2026-06-30T07:17:26.888Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/71/14edf065f04630b1a8472f7653cad03f6c478bcf95ea0e6aed55451e33ea/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:23a439f31ccbeff1574e24889128821d1f7917470e830cf6544dced1c662262a", size = 576533, upload-time = "2026-06-30T07:17:28.546Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/76/65002b08596c389105720a8c0d22298b8dc25a4baf89b2ce431343c8b1de/rpds_py-2026.6.3-cp315-cp315t-win32.whl", hash = "sha256:913ca42ccad3f8cc6e292b587ae8ae49c8c823e5dce51a736252fc7c7cdfa577", size = 201204, upload-time = "2026-06-30T07:17:30.193Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/97/d855d6b3c322d1f27e26f5241c42016b56cf01377ea8ed348285f54652f0/rpds_py-2026.6.3-cp315-cp315t-win_amd64.whl", hash = "sha256:ae3d4fe8c0b9213624fdce7279d70e3b148b682ca20719ebd193a23ebfa47324", size = 220719, upload-time = "2026-06-30T07:17:31.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/9c/f0d19ac587fd0e4ab6b72cda355e9c5a6166b01ef7e064e437aef8eb9fef/rpds_py-2026.6.3-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4cf2d36a2357e4d07bb5a4f98801265327b48256867816cfd2ceb001e9754a8f", size = 349791, upload-time = "2026-06-30T07:17:33.315Z" },
+    { url = "https://files.pythonhosted.org/packages/38/c7/1d49d204c9fd2ee6c537601dc4c1ba921e03363ca576bfab94a00254ac9a/rpds_py-2026.6.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:30c6dc199b24a5e3e81d50da0f00858c5bbdb2617a750395687f4339c5818171", size = 352842, upload-time = "2026-06-30T07:17:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/e5/c0b5dc93cd0d4c06ce1f438907649514e2ea077bcd911e3154a51e96c38e/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9891e594296ab9dada6551c8e7b387b2721f27a67eecd528412e8906247a7b90", size = 382094, upload-time = "2026-06-30T07:17:36.514Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/54/ec0e907b4ca8d541112db352409bd15f871c9b243e0c92c9b5a46ae96f01/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5c2dc92304aa48a4a60443b548bb12f12e119d4b72f314015e67b9e1be97fca", size = 388662, upload-time = "2026-06-30T07:17:38.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/f4/921c22a4fd0f1c1ac13a3996ffbf0aa67951e2c8ad0d1d9574938a2932e8/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:127e08c0642d880cf32ca47ec2a4a77b901f7e2dd1ad9762adb13955d72ffcc9", size = 504896, upload-time = "2026-06-30T07:17:39.689Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/1b/a114b972cefa1ab1cdb3c7bb177cd3844a12826c507c722d3a73516dbbaf/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8bb68f03f395eb793220b45c097bd4d8c32944393da0fad8b999efac0868fc8c", size = 391545, upload-time = "2026-06-30T07:17:41.336Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/98/af9b3db77d47fcbe6c8c1f36e2c2147ec70292819e99c325f871584a1c11/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3450b693fde92133e9f51060568a4c31fcca76d5e53bbd611e689ca446517e9", size = 380059, upload-time = "2026-06-30T07:17:42.857Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/ba/0efd8668b97c1d26a61566386c636a7a7a09829e474fdf807caa15a2c844/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:5e8d07bddee435a2ff6f1920e18feff28d0bc4533e42f4bf6927fbd073312c41", size = 393235, upload-time = "2026-06-30T07:17:44.637Z" },
+    { url = "https://files.pythonhosted.org/packages/62/90/8c139ee9690f73b0829f32647de6f40d826f8f443af6fa72644f96351aac/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3a83ae6c67b7676b9878378547ca8e93ed77a580037bcbcd1d32f739e1e6089c", size = 413008, upload-time = "2026-06-30T07:17:46.225Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/97/0043896fdd7828ce09a1d9a8b06433714d0960fc4ff3fc4aa72b666b764e/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:2bfd04c19ddbd6640de0b51894d764bd2758854d5b75bd102d2ef10cb9c293a9", size = 558118, upload-time = "2026-06-30T07:17:47.759Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/02355f0e134f783a8f9814c4680a1bd311d37671577a5964ea838573ff37/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:ca6546b66be9dc4738b1b043d5ebd5488c66c578c5ff0fd0e8065313fe3afb76", size = 623138, upload-time = "2026-06-30T07:17:49.355Z" },
+    { url = "https://files.pythonhosted.org/packages/10/85/48f0abdcef5cce4e034c7a5b0ceeceba0b01bf0d942824f4bb720afe2dec/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:8e65860d238379ed982fd9ba690579b5e95af2f4840f99c772816dbe573cb826", size = 586486, upload-time = "2026-06-30T07:17:51.141Z" },
+]
+
 [[package]]
 name = "ruff"
 version = "0.16.4"
@@ -2395,12 +3025,14 @@ name = "sevm"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
+    { name = "anyio" },
     { name = "eth-abi" },
     { name = "eth-account" },
     { name = "eth-hash", extra = ["pycryptodome"] },
     { name = "eth-keys" },
     { name = "eth-tester" },
     { name = "eth-utils" },
+    { name = "mcp" },
     { name = "packaging" },
     { name = "py-evm" },
     { name = "py-solc-x" },
@@ -2422,12 +3054,14 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "anyio", specifier = ">=4.15.1" },
     { name = "eth-abi", specifier = ">=5.2" },
     { name = "eth-account", specifier = ">=0.13" },
     { name = "eth-hash", extras = ["pycryptodome"], specifier = ">=0.5.1" },
     { name = "eth-keys", specifier = ">=0.6" },
     { name = "eth-tester", specifier = ">=0.13.0b1,<0.14.0b1" },
     { name = "eth-utils", specifier = ">=5.0" },
+    { name = "mcp", specifier = ">=2.2.0" },
     { name = "packaging", specifier = ">=23.0" },
     { name = "py-evm", specifier = ">=0.12.0b2" },
     { name = "py-solc-x", specifier = ">=2.0" },
@@ -2456,6 +3090,32 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
 ]
 
+[[package]]
+name = "sse-starlette"
+version = "3.4.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "starlette" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2b/54/6767bb789b2f2fed6e0f953df949cd39dc263a384c1b65a95232598621d6/sse_starlette-3.4.11.tar.gz", hash = "sha256:1bae716c02f3e6f294be41ff333220692dae7c3cbab077c900f159676719dade", size = 34972, upload-time = "2026-09-05T12:11:04.607Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/6a/2ba3ed4a69babf3afdddf7d8314a48d87562c0a442206bbc2a1b50d5efc0/sse_starlette-3.4.11-py3-none-any.whl", hash = "sha256:c7b2244bdff016fe7f64e10075e89a3e6bbf899649cc89b0fe884b5545042453", size = 17122, upload-time = "2026-09-05T12:11:03.195Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b5/b4/205b0d5241d934e8add0c38aa924c4f9fb7330834ff11e5444db964ec3f9/starlette-1.6.0.tar.gz", hash = "sha256:d4e3ac5e546444960c710297a3c9fc3f7ebae1b7e963f3d36173b49da535be9b", size = 2716969, upload-time = "2026-08-08T18:27:57.512Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/cb/6a6a47d5b464bd08695d254f3da6e7986cc70c9fa5d778eda57538edfe56/starlette-1.6.0-py3-none-any.whl", hash = "sha256:a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c", size = 75969, upload-time = "2026-08-08T18:27:56.196Z" },
+]
+
 [[package]]
 name = "textual"
 version = "8.2.8"
@@ -2586,6 +3246,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b6/3f/40f93be1cc64b88bd475215d031fb91da29aeb5eec95af8b53a11efb71e8/trie-4.0.0-py3-none-any.whl", hash = "sha256:8727564361ca85b309f0345cc2ae09eb61de9b25da84fe6cfcf7edc3867ffe33", size = 41471, upload-time = "2026-08-22T11:55:35.403Z" },
 ]
 
+[[package]]
+name = "truststore"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" },
+]
+
 [[package]]
 name = "types-requests"
 version = "2.33.0.20260712"
@@ -2637,6 +3306,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
 ]
 
+[[package]]
+name = "uvicorn"
+version = "0.52.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click", marker = "python_full_version < '3.12' or python_full_version >= '3.14' or sys_platform != 'emscripten'" },
+    { name = "h11", marker = "python_full_version < '3.12' or python_full_version >= '3.14' or sys_platform != 'emscripten'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f2/0f/3f86e61397dd33bf2ccf28188c40db6a740658aeebbbf6e7dbc101a1f487/uvicorn-0.52.4.tar.gz", hash = "sha256:73acfee47a0b133c5de13d219492d62d8a31e935f4fe6e41a232451a15379f86", size = 100627, upload-time = "2026-08-19T06:27:41.821Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/79/4a20b54ab0491485ccd8c077db2d39187c7f12b3e15485d38a7be37c81b4/uvicorn-0.52.4-py3-none-any.whl", hash = "sha256:f86e41a149d7d05a9969337e3946a9c171c06a5d42680896daaba624aeac8da1", size = 79871, upload-time = "2026-08-19T06:27:40.36Z" },
+]
+
 [[package]]
 name = "web3"
 version = "7.16.0"

From 910b52bdeac50729e48f4133c911905902c317e1 Mon Sep 17 00:00:00 2001
From: Axl <bryannicholas7@gmail.com>
Date: Fri, 11 Sep 2026 14:45:53 +0700
Subject: [PATCH 2/9] Add checkpoints, provenance, batch experiments, parity
 checks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The AI-review package: the reviewer's top asks, built for a consumer
that needs ground truth on 'why did this operand get this value' and
cheap branching from a deep stop.

Checkpoints (snap/restore, sevm_save/restore_checkpoint): capture a
stop — per-frame stack/memory/gas/pc/logs, the py-evm journal
(state.snapshot()/revert(), the mechanism the evaluator already
exercised), cheat state, gas profiles, watchpoint baselines — then
experiment and roll everything back without re-running the prefix.
Restoring re-arms the consumed journal checkpoint so a save restores
any number of times; a skip-flag in the opcode loop cancels the stale
iteration after any pc write, which also makes jump/set $pc exact;
restoring discards later checkpoints (journal nesting) and refuses
when the frame stack changed or the program finished.

Provenance (provenance on, why N, sevm_why_stack): opt-in per-opcode
recording (before/after stacks, gas, pc) and a concrete backward
slice driven by an opcode arity table: PUSH resolves to constants,
DUP/SWAP to their copies, consumers fan in, MLOAD/SLOAD chain to the
last same-offset MSTORE/SSTORE, CALLDATALOAD names its calldata
window, survivors are frame-entry slots. A checkpoint restore
truncates the record to stay consistent.

Batch experiments (sevm_run_experiments): a list of
{set_stack, set_gas, write_memory, run_until_pc, read_stack} runs,
each from one saved base checkpoint — 32 variants for one prefix; a
run that finishes ends the batch with a named cause.

Bytecode parity (parity verb, sevm_check_parity,
start_session(reference_runtime_hex=...) hard-fail): metadata-stripped,
immutable-masked comparison reporting the first divergence.

structLog export (export, sevm_export_trace): anvil/geth
debug_traceTransaction-shaped rows from the provenance recording, to
a file or as a windowed slice.

Also: set $stack[N] = 0x... now parses hex literals directly (bare
0x literals are not valid Solidity expressions); script tracebacks
are surfaced by all three frontends and a crashed script exits 1.

Full suite 813 passed; storage-level equivalence proven for
restore-then-continue vs natural runs; TokyoPayload's FMP corruption
traces to calldata via why.
---
 README.md                       |   8 +-
 docs/commands.md                |   4 +
 docs/mcp.md                     |  17 +-
 src/sevm/cli.py                 |   8 +-
 src/sevm/commands/help.py       |   3 +
 src/sevm/commands/inspecting.py |  99 +++++++
 src/sevm/commands/mutation.py   |  59 +++-
 src/sevm/commands/processor.py  |   2 +
 src/sevm/compile/__init__.py    |   6 +-
 src/sevm/compile/model.py       |  42 ++-
 src/sevm/console.py             |  17 +-
 src/sevm/mcp_server/driver.py   | 274 +++++++++++++++++-
 src/sevm/mcp_server/tools.py    |  74 +++++
 src/sevm/session/__init__.py    |   2 +
 src/sevm/session/checkpoints.py | 193 +++++++++++++
 src/sevm/session/core.py        |  15 +
 src/sevm/session/inspect_ops.py | 101 +++++++
 src/sevm/session/patch.py       |  32 +++
 src/sevm/session/provenance.py  | 474 ++++++++++++++++++++++++++++++++
 src/sevm/session/snapshots.py   |  51 ++--
 tests/test_mcp_server.py        | 164 +++++++++++
 21 files changed, 1609 insertions(+), 36 deletions(-)
 create mode 100644 src/sevm/session/checkpoints.py
 create mode 100644 src/sevm/session/provenance.py

diff --git a/README.md b/README.md
index e175797..7a7fa74 100644
--- a/README.md
+++ b/README.md
@@ -569,8 +569,12 @@ JUMPDEST, the address an indirect jump can actually reach:
 `sevm mcp` serves the whole debugger over the Model Context Protocol (stdio) — the third
 frontend after the console and the TUI, shaped for a consumer that cannot scroll panes or
 watch them change: windowed reads with explicit truncation, a uniform stop report after
-every navigation, and a diff of what the last step changed. See
-[docs/mcp.md](docs/mcp.md) for the tool list and client configuration.
+every navigation, and a diff of what the last step changed. It also carries the
+AI-oriented machinery end to end: checkpoints (`snap`/`restore`), operand provenance
+(`why N` traces a stack slot to its entry-slot/calldata/memory origins), a batch
+experiment API that branches from one deep stop, bytecode parity checks against deployed
+runtimes, and structLog trace export. See [docs/mcp.md](docs/mcp.md) for the tool list
+and client configuration.
 
 ### Compile a project
 
diff --git a/docs/commands.md b/docs/commands.md
index 1758267..9e2d4ec 100644
--- a/docs/commands.md
+++ b/docs/commands.md
@@ -71,6 +71,9 @@ as `reverted: "..."`, `panic 0x11`, or a custom error with its arguments.
 | `display EXPR` | re-evaluate at every stop |
 | `x/NFU ADDR` | examine memory, gdb syntax; a bare `x` continues past the last dump, format reused |
 | `find HEX` | every offset in the running code where the byte pattern occurs, with instruction alignment and the nearest preceding JUMPDEST — gadget hunting |
+| `parity [Contract] 0x<hex>` | prove the compiled runtime matches the deployed bytecode; reports the first divergence, ignoring the metadata tail and immutables |
+| `provenance on\|off\|status` | opt-in per-opcode recording |
+| `why N` | trace $stack[N] back to its origins: constants, calldata, MSTORE/SSTORE chains, frame-entry slots |
 | `bt` / `f N` / `up` / `down` | call stack and frame selection |
 | `l` / `list` / `disas` | source listing / disassembly |
 | `info registers` | pc, gas + refund, depth, stack height, memory and calldata sizes, `msg.*`, `tx.origin`, static flag |
@@ -151,6 +154,7 @@ the dispatcher never tests this selector: a call carrying it lands in the fallba
 | `set var fee = 1 ether` | write a local's stack slot |
 | `set $mem[0x80] = 1` / `set $storage[0] = 0xdead` | raw writes |
 | `jump 0x108` | move the program counter, JUMPDESTs only |
+| `snap [name]` / `restore [name]` | capture a stop (frames, storage journal, bookkeeping) and roll everything back to it later, without re-running the prefix |
 | `mstore(0x80, 1)` / `asm YUL` | run inline assembly, see [assembly.md](assembly.md) |
 | `vm.deal(alice, 10 ether)` | fire a Foundry cheatcode at the current frame |
 
diff --git a/docs/mcp.md b/docs/mcp.md
index 89f273e..7131d5e 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -93,11 +93,26 @@ One debug session is active at a time; starting a new target replaces it.
 | `sevm_get_logs` | events so far, names decoded |
 | `sevm_list_contracts` / `sevm_list_functions` | the compiled surface |
 
-### Search
+### Search, checkpoints, provenance, experiments
 
 | Tool | Meaning |
 |---|---|
 | `sevm_find_bytes` | hex pattern in `code` (gadget hunting: pc, instruction alignment, nearest preceding JUMPDEST), `memory`, or `calldata` |
+| `sevm_save_checkpoint` / `sevm_restore_checkpoint` / `sevm_list_checkpoints` | capture a stop — frame state, storage journal, bookkeeping — experiment freely, roll everything back without re-running the prefix |
+| `sevm_set_provenance` / `sevm_why_stack(index)` | record every opcode and trace any stack slot back to its origins: constants, calldata windows, MSTORE→MLOAD and SSTORE→SLOAD chains, and the frame-entry slots |
+| `sevm_export_trace` | the recording as anvil/geth structLog JSON (to a file, or a windowed inline slice) |
+| `sevm_run_experiments` | branch-search from one deep stop: a list of `{set_stack, set_gas, write_memory, run_until_pc, read_stack}` experiments, each from a saved base checkpoint — 32 variants, one prefix |
+| `sevm_check_parity` | compare a compiled runtime against deployed bytecode; `sevm_start_session(reference_runtime_hex=...)` hard-fails on divergence |
+
+**Checkpoint semantics**: restoring reverts *everything* since the checkpoint
+(storage, balances, memory, stack, gas, cheat state) and discards checkpoints
+saved after the restored one; it only works while the frame stack is the one
+that was saved — finish out of calls made after the checkpoint first. After the
+program finishes, only `restart` remains.
+
+**Provenance semantics**: the slice is concrete, not symbolic — it follows
+recorded values and positions. Hand mutations (`set $stack[i]`) are not
+recorded, so ask `why` before mutating.
 
 ### Breakpoints
 
diff --git a/src/sevm/cli.py b/src/sevm/cli.py
index 4ccbd08..a855180 100644
--- a/src/sevm/cli.py
+++ b/src/sevm/cli.py
@@ -503,7 +503,7 @@ def _debug(
         for command in startup_commands:
             frontend._emit(frontend.commands.execute(command))
         frontend.run(first_event=first)
-        return 0
+        return 0 if session.exit_error is None else 1
 
     try:
         from .tui.app import SevmApp
@@ -515,16 +515,16 @@ def _debug(
         from .console import ConsoleFrontend
 
         ConsoleFrontend(session, evaluator).run(first_event=first)
-        return 0
+        return 0 if session.exit_error is None else 1
 
     app = SevmApp(
         session, evaluator, first_event=first, startup_commands=startup_commands
     )
     # Mouse on: every pane renders Textual `Content`, which the framework can
-    # select/highlight/copy (drag to select, ctrl+c to copy). `--no-mouse` hands
+    # select, highlight and copy (drag to select, ctrl+c to copy); `--no-mouse` hands
     # selection back to the terminal.
     app.run(mouse=not args.no_mouse)
-    return 0
+    return 0 if session.exit_error is None else 1
 
 
 def main(argv: list[str] | None = None) -> int:
diff --git a/src/sevm/commands/help.py b/src/sevm/commands/help.py
index 1dbb5d8..d0dbb1d 100644
--- a/src/sevm/commands/help.py
+++ b/src/sevm/commands/help.py
@@ -44,6 +44,9 @@
   [cyan]l[/cyan]ist [LINE]                  source listing
   [cyan]disas[/cyan]semble            disassembly around the pc
   [cyan]find[/cyan] HEX               offsets of a byte pattern in the running code
+  [cyan]parity[/cyan] [Contract] 0x<hex>  prove the build matches the deployed runtime
+  [cyan]provenance[/cyan] on|off      record every opcode (feeds `why`)
+  [cyan]why[/cyan] N                   what produced the value in $stack[N]
   [cyan]sig[/cyan] FUNC               the signature and 4-byte selector: [dim]sig withdraw[/dim]
   [cyan]copy[/cyan] [CMD]                  put a command's output on the system clipboard
   [cyan]i[/cyan]nfo TOPIC             registers, breakpoints, frame, args, locals, storage,
diff --git a/src/sevm/commands/inspecting.py b/src/sevm/commands/inspecting.py
index 55cf50b..47ed254 100644
--- a/src/sevm/commands/inspecting.py
+++ b/src/sevm/commands/inspecting.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import re
 from typing import TYPE_CHECKING
 
 from ..frames import FrameSnapshot
@@ -205,6 +206,101 @@ def cmd_find(proc: CommandProcessor, args: list[str], rest: str) -> CommandResul
     return result
 
 
+def cmd_provenance(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult:
+    """`provenance on|off|status` — opt-in per-opcode recording for `why`."""
+    prov = proc.session.provenance
+    if not args or args[0] not in ("on", "off", "status"):
+        return CommandResult(error="usage: provenance on|off|status")
+    if args[0] in ("on", "off"):
+        prov.enabled = args[0] == "on"
+    state = "on" if prov.enabled else "off"
+    return CommandResult().add(
+        f"[yellow]provenance recording {state}[/yellow] "
+        f"[dim]({len(prov.records)} opcode(s) recorded)[/dim]"
+    )
+
+
+def cmd_why(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult:
+    """`why N` — what produced the value in $stack[N] (0 = top).
+
+    Walks the recording newest→oldest: constants, DUP/SWAP copies, consumed
+    operands, MSTORE→MLOAD and SSTORE→SLOAD chains, calldata windows, and the
+    frame-entry slots anything else traces back to.
+    """
+    snap = proc.require_stop()
+    if not args or not args[0].lstrip("-").isdigit():
+        return CommandResult(error="usage: why <stack index, 0 = top>")
+    index = int(args[0])
+    prov = proc.session.provenance
+    if not prov.records:
+        return CommandResult(
+            error="nothing recorded; `provenance on` first, then navigate"
+        )
+    from ..session.provenance import why_stack
+
+    bottom_up = tuple(int(entry.value) for entry in reversed(snap.stack))
+    result = why_stack(prov.records, snap.depth, bottom_up, index)
+    if result.get("error"):
+        return CommandResult(error=result["error"])
+    out = CommandResult().add(
+        f"[dim]why $stack[{index}] ({len(result['origins'])} origin(s)):[/dim]"
+    )
+    for origin in result["origins"]:
+        chain = " <- ".join(f"0x{hop['pc']:04x} {hop['op']}" for hop in origin["via"][:6])
+        more = " …" if len(origin["via"]) > 6 else ""
+        out.add(
+            f"  [{origin['kind']}] {_escape(origin['detail'])}"
+            + (f" = {origin['value'][:18]}…" if origin.get("value") else "")
+            + (f"  [dim]{chain}{more}[/dim]" if chain else "")
+        )
+    return out
+
+
+def cmd_parity(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult:
+    """`parity [Contract] 0x<hex>` — prove the compiled runtime matches a deployment.
+
+    Breakpoint pcs and gadget offsets are only true for the exact bytes on chain:
+    paste the deployed runtime (explorer `cast code` output) and this reports the
+    first divergence, ignoring the metadata tail and immutable values.
+    """
+    snap = proc.require_stop()
+    hex_arg = None
+    contract = None
+    for arg in args:
+        if arg.lower().startswith("0x") and len(arg) > 2:
+            hex_arg = arg[2:]
+        elif re.fullmatch(r"[0-9a-fA-F]+", arg) and len(arg) % 2 == 0:
+            hex_arg = arg
+        else:
+            contract = arg
+    if hex_arg is None:
+        return CommandResult(error="usage: parity [Contract] 0x<deployed runtime hex>")
+    try:
+        reference = bytes.fromhex(hex_arg)
+    except ValueError:
+        return CommandResult(error=f"not hex: {hex_arg[:16]}…")
+    name = contract or snap.contract_name
+    art = proc.project.artifact(name) if name else None
+    if art is None or not art.deployed_bytecode:
+        return CommandResult(error=f"no compiled artifact for {name!r}")
+    from ..compile import compare_runtime
+
+    verdict = compare_runtime(art, reference)
+    if verdict["match"]:
+        return CommandResult().add(
+            f"[green]runtime matches {art.name}[/green] "
+            f"[dim](compiled {verdict['compiled_size']}B, reference "
+            f"{verdict['reference_size']}B; metadata/immutables ignored)[/dim]"
+        )
+    return CommandResult().add(
+        f"[bold red]runtime DIVERGES from {art.name}[/bold red] at "
+        f"0x{verdict['first_diff_offset']:04x} "
+        f"[dim](compiled {verdict['compiled_size']}B, reference "
+        f"{verdict['reference_size']}B; every pc past this point describes a "
+        f"different program — rebuild with the deployed solc/flags)[/dim]"
+    )
+
+
 def cmd_frame(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult:
     snap = proc.require_stop()
     if not args:
@@ -339,4 +435,7 @@ def cmd_disassemble(proc: CommandProcessor, args: list[str], rest: str) -> Comma
     "disassemble": cmd_disassemble,
     "disas": cmd_disassemble,
     "find": cmd_find,
+    "parity": cmd_parity,
+    "provenance": cmd_provenance,
+    "why": cmd_why,
 }
diff --git a/src/sevm/commands/mutation.py b/src/sevm/commands/mutation.py
index 5b58066..12c6707 100644
--- a/src/sevm/commands/mutation.py
+++ b/src/sevm/commands/mutation.py
@@ -29,7 +29,7 @@ def cmd_set(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult
 
     # A bare local name is a stack slot, not storage, and has to be written as one.
     if re.fullmatch(r"[A-Za-z_$][\w$]*", lhs) and proc.is_local(lhs):
-        value = int(proc.evaluate(rhs).value)
+        value = _rhs_value(proc, rhs)
         written = proc.inspect(
             "write_local", lhs, value, internal_index=proc.selected_internal
         )
@@ -51,8 +51,21 @@ def cmd_set(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult
         )
 
 
+def _rhs_value(proc: CommandProcessor, rhs: str) -> int:
+    """A decimal or 0x-hex literal parses without solc; anything else evaluates.
+
+    The fast path is not just cheaper: a bare `0x` literal of address or bytes
+    width is not a valid Solidity expression, so `set $stack[0] = 0x<address>`
+    would fail outright instead of writing the value.
+    """
+    text = rhs.strip()
+    if re.fullmatch(r"0[xX][0-9a-fA-F]+|\d+", text):
+        return _integer(text, "set")
+    return int(proc.evaluate(text).value)
+
+
 def _set_convenience(proc: CommandProcessor, lhs: str, rhs: str) -> CommandResult:
-    value = int(proc.evaluate(rhs).value)
+    value = _rhs_value(proc, rhs)
     name = lhs[1:]
     if name == "pc":
         proc.inspect("set_pc", value)
@@ -165,6 +178,46 @@ def cmd_asm(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult
     return proc.assemble(proc.substitute(source))
 
 
+# ==================================================================
+# checkpoints
+# ==================================================================
+
+
+def cmd_snap(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult:
+    """`snap [name]` — capture this stop: state, frames, journal, bookkeeping.
+
+    Restore later with `restore [name]` (default name: "last") and experiment
+    freely in between: stack/memory/storage writes, jumps, even a `continue`
+    that stops again — restore rolls all of it back without re-running the
+    script prefix.
+    """
+    proc.require_stop()
+    name = args[0] if args else "last"
+    info = proc.inspect("save_checkpoint", name)
+    return CommandResult().add(
+        f"[green]checkpoint {info['name']!r} saved[/green] "
+        f"[dim]({info['frames']} frame(s), {info['note']})[/dim]"
+    )
+
+
+def cmd_restore(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult:
+    """`restore [name]` — roll the live run back to a `snap`.
+
+    Everything since the checkpoint is undone: storage, balances, memory,
+    stack, gas, cheat state. Restoring discards checkpoints saved after the
+    restored one, and only works while the frame stack is the one that was
+    saved — a checkpoint taken before a CALL cannot be restored from inside it.
+    """
+    proc.require_stop()
+    name = args[0] if args else "last"
+    info = proc.inspect("restore_checkpoint", name)
+    dropped = f", dropped {', '.join(info['dropped'])}" if info["dropped"] else ""
+    return CommandResult(mutated=True).add(
+        f"[yellow]restored checkpoint {info['name']!r}[/yellow] "
+        f"[dim]({info['frames']} frame(s), step {info['step']}{dropped})[/dim]"
+    )
+
+
 VERBS = {
     "set": cmd_set,
     "asm": cmd_asm,
@@ -173,4 +226,6 @@ def cmd_asm(proc: CommandProcessor, args: list[str], rest: str) -> CommandResult
     "jump": cmd_jump,
     "reseat": cmd_reseat,
     "bind": cmd_bind,
+    "snap": cmd_snap,
+    "restore": cmd_restore,
 }
diff --git a/src/sevm/commands/processor.py b/src/sevm/commands/processor.py
index 1312459..1202aeb 100644
--- a/src/sevm/commands/processor.py
+++ b/src/sevm/commands/processor.py
@@ -324,6 +324,8 @@ def render_event(self, event: Any) -> CommandResult:
                 result.add("[green]program finished[/green]")
             else:
                 result.add(f"[red]program raised {event.error}[/red]")
+                if event.traceback:
+                    result.add(f"[dim]{_escape(event.traceback)}[/dim]")
             return result
         if isinstance(event, Paused):
             result.lines.extend(self.describe_stop(event.snapshot))
diff --git a/src/sevm/compile/__init__.py b/src/sevm/compile/__init__.py
index 9d9696a..c095442 100644
--- a/src/sevm/compile/__init__.py
+++ b/src/sevm/compile/__init__.py
@@ -5,7 +5,8 @@
 
 Where things live:
 
-  model.py            `SourceFile`, `Artifact`, `Project`, and bytecode identity
+  model.py            `SourceFile`, `Artifact`, `Project`, bytecode identity,
+                      and `compare_runtime` for deployed-build parity
   solc.py             calling solc, and reading .sol files in
   solcbin.py          finding or downloading a solc binary this machine can run
   wasm.py             solc's WebAssembly build, for machines no binary runs on
@@ -28,7 +29,7 @@
     resolve_dependencies,
     unresolved_prefixes,
 )
-from .model import Artifact, CompileError, Project, SourceFile
+from .model import Artifact, CompileError, Project, SourceFile, compare_runtime
 from .solc import DEFAULT_SOLC_VERSION, compile_standard, ensure_solc
 from .solcbin import platform_key
 from .versions import resolve_solc_version
@@ -44,6 +45,7 @@
     "FoundryConfig",
     "Project",
     "SourceFile",
+    "compare_runtime",
     "compile_foundry_project",
     "compile_project",
     "compile_standard",
diff --git a/src/sevm/compile/model.py b/src/sevm/compile/model.py
index 75b7fd2..ec3f7c9 100644
--- a/src/sevm/compile/model.py
+++ b/src/sevm/compile/model.py
@@ -143,6 +143,11 @@ def _strip_metadata(code: bytes) -> bytes:
 
 def _code_fingerprint(code: bytes, artifact: Artifact | None) -> bytes:
     """Metadata-stripped, immutable-masked hash of runtime code."""
+    return hashlib.sha256(_masked_body(code, artifact)).digest()
+
+
+def _masked_body(code: bytes, artifact: Artifact | None) -> bytes:
+    """The metadata-stripped, immutable-masked bytes a fingerprint hashes."""
     body = bytearray(_strip_metadata(code))
     if artifact is not None:
         for refs in artifact.immutable_references.values():
@@ -150,4 +155,39 @@ def _code_fingerprint(code: bytes, artifact: Artifact | None) -> bytes:
                 start, length = int(ref["start"]), int(ref["length"])
                 if start + length <= len(body):
                     body[start : start + length] = b"\x00" * length
-    return hashlib.sha256(bytes(body)).digest()
+    return bytes(body)
+
+
+def compare_runtime(artifact: Artifact, reference: bytes) -> dict:
+    """Compare a compiled artifact's runtime code against a reference deployment.
+
+    For debugging a *deployed* target, pc parity is only as good as the build:
+    if the compiled body diverges from the on-chain code anywhere before the
+    trailing metadata tail, every breakpoint pc and gadget offset silently
+    describes a different program. This reports the first divergence instead.
+
+    Both sides are metadata-stripped and immutable-masked, matching how
+    `artifact_for_code` identifies running code, so a differing metadata tail or
+    differing immutable values do not count as divergence.
+    """
+    compiled = _masked_body(artifact.deployed_bytecode, artifact)
+    other = _masked_body(reference, artifact)
+    if compiled == other:
+        return {
+            "match": True,
+            "difference": "none",
+            "compiled_size": len(artifact.deployed_bytecode),
+            "reference_size": len(reference),
+            "first_diff_offset": None,
+        }
+    first = next(
+        (i for i, (a, b) in enumerate(zip(compiled, other, strict=False)) if a != b),
+        min(len(compiled), len(other)),
+    )
+    return {
+        "match": False,
+        "difference": "code",
+        "compiled_size": len(artifact.deployed_bytecode),
+        "reference_size": len(reference),
+        "first_diff_offset": first,
+    }
diff --git a/src/sevm/console.py b/src/sevm/console.py
index a8471a1..40754b7 100644
--- a/src/sevm/console.py
+++ b/src/sevm/console.py
@@ -45,9 +45,20 @@ def on_first_stop(self, event) -> None:
             for line in self.commands.describe_stop(event.snapshot):
                 self.console.print(line)
         elif isinstance(event, Finished):
-            self.console.print(
-                "[yellow]the program finished without hitting the debugger[/yellow]"
-            )
+            if event.ok:
+                self.console.print(
+                    "[yellow]the program finished without hitting the debugger[/yellow]"
+                )
+            else:
+                # The script died before any EVM opcode ran; the traceback is the
+                # only diagnosis there is, so it must reach the user. Raw text,
+                # escaped: brackets in a traceback are not style tags.
+                self.console.print(
+                    f"[bold red]the program raised {escape_markup(str(event.error))}"
+                    "[/bold red]"
+                )
+                if event.traceback:
+                    self.console.print(f"[dim]{escape_markup(event.traceback)}[/dim]")
 
     def run(self, first_event=None) -> None:
         """Read-eval-print until the user quits.
diff --git a/src/sevm/mcp_server/driver.py b/src/sevm/mcp_server/driver.py
index 4165a33..c267871 100644
--- a/src/sevm/mcp_server/driver.py
+++ b/src/sevm/mcp_server/driver.py
@@ -54,6 +54,7 @@ def __init__(self, timeout: float = 120.0) -> None:
         self._target_path: str | None = None
         self._target_kind: str | None = None  # "script" | "foundry"
         self._prev_snapshot: FrameSnapshot | None = None
+        self._provenance_next = False
         self.notices: list[str] = []
 
     # -- lifecycle ---------------------------------------------------------
@@ -79,8 +80,18 @@ def start(
         match: str | None = None,
         match_contract: str | None = None,
         timeout: float | None = None,
+        reference_runtime_hex: str | None = None,
+        provenance: bool = False,
     ) -> dict[str, Any]:
-        """Compile and start a debug target; replaces any existing session."""
+        """Compile and start a debug target; replaces any existing session.
+
+        `provenance=true` records every executed opcode from the start, enabling
+        `sevm_why_stack` and `sevm_export_trace` without a second pass.
+        `reference_runtime_hex` (the deployed runtime, as an explorer or
+        `cast code` prints it) hard-fails the start when the compiled contract
+        diverges beyond the metadata tail: pcs and gadget offsets silently
+        describe a different program otherwise.
+        """
         with self._lock:
             self.stop()
             self.notices = []
@@ -89,11 +100,31 @@ def start(
             if not os.path.isfile(target):
                 raise DriverError(f"no such file: {target}")
             self._target_path = target
+            self._provenance_next = bool(provenance)
             if target.endswith(".sol"):
                 self._target_kind = "foundry"
-                return self._start_foundry(target, solc, optimize, match, match_contract)
-            self._target_kind = "script"
-            return self._start_script(target, args or [], contracts, solc, optimize)
+                report = self._start_foundry(
+                    target, solc, optimize, match, match_contract
+                )
+            else:
+                self._target_kind = "script"
+                report = self._start_script(target, args or [], contracts, solc, optimize)
+            if reference_runtime_hex:
+                verdict = self.check_parity(reference_runtime_hex)
+                if not verdict["match"]:
+                    detail = (
+                        f"first divergence at 0x{verdict['first_diff_offset']:04x} "
+                        f"(compiled {verdict['compiled_size']}B, reference "
+                        f"{verdict['reference_size']}B)"
+                    )
+                    self.stop()
+                    raise DriverError(
+                        f"bytecode parity failed for {verdict['contract']}: {detail}; "
+                        "rebuild with the deployed solc version and flags — every pc "
+                        "past the divergence describes a different program"
+                    )
+                report["parity"] = verdict
+            return report
 
     def _start_script(
         self,
@@ -217,6 +248,8 @@ def _wire(
                 continue
             if first_contract is None:
                 first_contract, _, first_fn = name.partition(".")
+        if getattr(self, "_provenance_next", False):
+            session.provenance.enabled = True
         session.start(target)
         first = session.wait(timeout=self.timeout)
         if first is None:
@@ -307,6 +340,7 @@ def _report(self, event: Any) -> dict[str, Any]:
                 finished=True,
                 ok=bool(getattr(event, "ok", False)),
                 exit_error=getattr(event, "error", None),
+                exit_traceback=getattr(event, "traceback", None),
                 last_revert=getattr(session, "last_revert", None) if session else None,
             )
             return report
@@ -651,6 +685,238 @@ def list_functions(self, contract: str | None = None) -> dict[str, Any]:
                 ],
             }
 
+    # -- checkpoints ---------------------------------------------------------
+
+    def save_checkpoint(self, name: str = "last") -> dict[str, Any]:
+        with self._lock:
+            session, _ = self._require()
+            self._require_snapshot()
+            info = session.inspect("save_checkpoint", name)
+            return info
+
+    def _restore(self, name: str) -> dict[str, Any]:
+        """Shared restore: roll back, refresh, and square the snapshot's pc.
+
+        Right after a restore the live CodeStream sits pre-read, so a refreshed
+        snapshot reports `program_counter - 1` — one below the opcode that will
+        actually run. The checkpoint's boundary pc is the truth; patch it in.
+        """
+        from dataclasses import replace as dc_replace
+
+        session, _ = self._require()
+        info = session.inspect("restore_checkpoint", name)
+        session.refresh_snapshot()
+        self._prev_snapshot = None
+        snap = session.last_snapshot
+        if snap is not None and info.get("pc") is not None:
+            session.last_snapshot = dc_replace(snap, pc=info["pc"])
+        return info
+
+    def restore_checkpoint(self, name: str = "last") -> dict[str, Any]:
+        """Roll back to a checkpoint; returns the stop report at the restored stop."""
+        with self._lock:
+            session, _ = self._require()
+            if session.finished:
+                raise DriverError(
+                    "cannot restore: the program already finished (its frames are "
+                    "gone); restart the session and re-reach the stop"
+                )
+            self._require_snapshot()
+            info = self._restore(name)
+            report = self._report(session.last_snapshot)
+            report["restore"] = info
+            return report
+
+    def list_checkpoints(self) -> dict[str, Any]:
+        session, _ = self._require()
+        return {"checkpoints": session.checkpoints.listing()}
+
+    # -- provenance & trace ---------------------------------------------------
+
+    def set_provenance(self, enabled: bool) -> dict[str, Any]:
+        """Turn per-opcode recording on/off; the switch applies from now on."""
+        with self._lock:
+            session, _ = self._require()
+            session.provenance.enabled = bool(enabled)
+            return {
+                "enabled": session.provenance.enabled,
+                "records": len(session.provenance.records),
+                "note": "why_stack and export_trace read this recording",
+            }
+
+    def why_stack(self, index_from_top: int) -> dict[str, Any]:
+        """Trace a current stack slot back through the recording to its origins."""
+        with self._lock:
+            session, _ = self._require()
+            snap = self._require_snapshot()
+            prov = session.provenance
+            if not prov.enabled and not prov.records:
+                raise DriverError(
+                    "provenance recording is off; call sevm_set_provenance(True) "
+                    "(or start the session with provenance=true) and navigate"
+                )
+            from ..session.provenance import why_stack as slice_stack
+
+            bottom_up = tuple(int(entry.value) for entry in reversed(snap.stack))
+            result = slice_stack(prov.records, snap.depth, bottom_up, int(index_from_top))
+            result["stack_index"] = int(index_from_top)
+            return result
+
+    def export_trace(
+        self,
+        path: str | None = None,
+        offset: int = 0,
+        limit: int = 500,
+    ) -> dict[str, Any]:
+        """Export the recording as anvil/geth structLog JSON (windowed, or to a file)."""
+        with self._lock:
+            session, _ = self._require()
+            prov = session.provenance
+            if not prov.records:
+                raise DriverError(
+                    "nothing recorded; enable provenance first and navigate"
+                )
+            import json
+
+            if path:
+                full = prov.structlog(0, len(prov.records))
+                with open(path, "w", encoding="utf-8") as fh:
+                    json.dump(full, fh)
+                return {
+                    "path": path,
+                    "total": full["total"],
+                    "written": len(full["structLogs"]),
+                }
+            window = prov.structlog(max(0, offset), max(1, min(limit, 2000)))
+            return window
+
+    # -- batch experiments -----------------------------------------------------
+
+    def run_experiments(
+        self, experiments: list[dict[str, Any]], base_checkpoint: str = "auto"
+    ) -> dict[str, Any]:
+        """Branch-search from one deep stop: mutate -> run -> read, per experiment.
+
+        Each experiment: {set_stack?: {index: value}, set_gas?: int,
+        write_memory?: {offset: hex}, run_until_pc?: int, continue_to_stop?: bool,
+        read_stack?: int}. The base checkpoint is saved once and restored before
+        every experiment, so 32 variants cost one prefix. An experiment that lets
+        the program finish ends the batch (restore becomes impossible); order
+        risky ones last.
+        """
+        with self._lock:
+            session, _ = self._require()
+            self._require_snapshot()
+            if not experiments:
+                raise DriverError("no experiments given")
+            if len(experiments) > 32:
+                raise DriverError("at most 32 experiments per call")
+            from sevm.session import StepMode
+
+            checkpoint_name = (
+                base_checkpoint if base_checkpoint != "auto" else "batch-base"
+            )
+            session.inspect("save_checkpoint", checkpoint_name)
+            results: list[dict[str, Any]] = []
+            aborted: str | None = None
+            try:
+                for number, experiment in enumerate(experiments):
+                    session.inspect("restore_checkpoint", checkpoint_name)
+                    session.refresh_snapshot()
+                    applied: dict[str, Any] = {}
+                    for index, value in (experiment.get("set_stack") or {}).items():
+                        session.inspect("write_stack", int(index), int(str(value), 0))
+                    if experiment.get("set_gas") is not None:
+                        session.inspect("set_gas", int(str(experiment["set_gas"]), 0))
+                    for offset, hex_data in (
+                        experiment.get("write_memory") or {}
+                    ).items():
+                        cleaned = str(hex_data).lower().removeprefix("0x")
+                        if not cleaned or len(cleaned) % 2:
+                            raise DriverError(f"not hex data: {hex_data!r}")
+                        session.inspect(
+                            "write_memory", int(offset), bytes.fromhex(cleaned)
+                        )
+                    applied = {
+                        "set_stack": experiment.get("set_stack") or {},
+                        "set_gas": experiment.get("set_gas"),
+                        "write_memory": experiment.get("write_memory") or {},
+                    }
+                    if experiment.get("run_until_pc") is not None:
+                        event = session.resume(
+                            StepMode.UNTIL,
+                            target_pc=int(experiment["run_until_pc"]),
+                            timeout=self.timeout,
+                        )
+                    else:
+                        event = session.resume(StepMode.RUN, timeout=self.timeout)
+                    if event is None:
+                        results.append({"experiment": number, "error": "timed out"})
+                        continue
+                    from ..session import Finished
+
+                    if isinstance(event, Finished):
+                        aborted = (
+                            f"experiment {number} let the program finish "
+                            f"({'ok' if event.ok else event.error}); the batch "
+                            "stopped because a finished run cannot be restored — "
+                            "restart and re-reach the stop"
+                        )
+                        break
+                    session.refresh_snapshot()
+                    self._prev_snapshot = None
+                    report = self._report(session.last_snapshot)
+                    report["experiment"] = number
+                    report["applied"] = applied
+                    if experiment.get("read_stack"):
+                        report["stack"] = self.read_stack(
+                            0, int(experiment["read_stack"])
+                        )["items"]
+                    results.append(report)
+            finally:
+                if aborted is None:
+                    try:
+                        self._restore(checkpoint_name)
+                    finally:
+                        session.checkpoints.discard_after(checkpoint_name)
+                        session.checkpoints._by_name.pop(checkpoint_name, None)
+            out: dict[str, Any] = {
+                "items": results,
+                "total": len(results),
+                "truncated": False,
+                "base_restored": aborted is None,
+            }
+            if aborted:
+                out["aborted"] = aborted
+            return out
+
+    # -- parity ------------------------------------------------------------
+
+    def check_parity(
+        self, reference_hex: str, contract: str | None = None
+    ) -> dict[str, Any]:
+        """Compare a compiled runtime against a reference deployment (explorer hex)."""
+        with self._lock:
+            _session, processor = self._require()
+            snap = self._require_snapshot()
+            cleaned = reference_hex.lower().removeprefix("0x")
+            if (
+                not cleaned
+                or len(cleaned) % 2
+                or any(c not in "0123456789abcdef" for c in cleaned)
+            ):
+                raise DriverError(f"not a hex runtime: {reference_hex[:24]!r}")
+            reference = bytes.fromhex(cleaned)
+            name = contract or snap.contract_name
+            art = processor.project.artifact(name) if name else None
+            if art is None or not art.deployed_bytecode:
+                raise DriverError(f"no compiled artifact for {name!r}")
+            from ..compile import compare_runtime
+
+            verdict = compare_runtime(art, reference)
+            verdict["contract"] = art.name
+            return verdict
+
     # -- search ------------------------------------------------------------
 
     def find_bytes(
diff --git a/src/sevm/mcp_server/tools.py b/src/sevm/mcp_server/tools.py
index 28f0418..e872d95 100644
--- a/src/sevm/mcp_server/tools.py
+++ b/src/sevm/mcp_server/tools.py
@@ -66,6 +66,8 @@ async def sevm_start_session(
         match: str | None = None,
         match_contract: str | None = None,
         timeout: float | None = None,
+        reference_runtime_hex: str | None = None,
+        provenance: bool = False,
     ) -> dict:
         """Start debugging a target and stop at the first contract instruction.
 
@@ -315,4 +317,76 @@ async def sevm_command(line: str) -> dict:
         `watch`, `tbreak`, `x/32xb 0x40`... Returns plain-text lines."""
         return await _run(driver, "command", line)
 
+    # -- checkpoints ---------------------------------------------------------
+
+    @server.tool()
+    async def sevm_save_checkpoint(name: str = "last") -> dict:
+        """Capture the current stop: frame state, storage journal, bookkeeping.
+
+        Experiment freely (mutations, jumps, even continue-and-stop); restore
+        rolls everything back without re-running the script prefix. Restoring
+        discards checkpoints saved after the restored one, and only works while
+        the frame stack is the one saved (finish out of calls made after the
+        checkpoint before restoring)."""
+        return await _run(driver, "save_checkpoint", name)
+
+    @server.tool()
+    async def sevm_restore_checkpoint(name: str = "last") -> dict:
+        """Roll the live run back to a checkpoint; returns the stop report there."""
+        return await _run(driver, "restore_checkpoint", name)
+
+    @server.tool()
+    async def sevm_list_checkpoints() -> dict:
+        """Saved checkpoints with their positions and restore counts."""
+        return await _run(driver, "list_checkpoints")
+
+    # -- provenance & trace ---------------------------------------------------
+
+    @server.tool()
+    async def sevm_set_provenance(enabled: bool) -> dict:
+        """Turn per-opcode recording on/off (feeds why_stack and export_trace)."""
+        return await _run(driver, "set_provenance", enabled)
+
+    @server.tool()
+    async def sevm_why_stack(index: int) -> dict:
+        """Why does $stack[index] hold this value? Traces it backward through the
+        recording to constants, calldata windows, MSTORE/SSTORE chains, and the
+        frame-entry slots — the question behind "which entry slot fed operand N"."""
+        return await _run(driver, "why_stack", index)
+
+    @server.tool()
+    async def sevm_export_trace(
+        path: str | None = None, offset: int = 0, limit: int = 500
+    ) -> dict:
+        """Export the recording as anvil/geth structLog JSON (the
+        debug_traceTransaction shape). `path` writes the whole trace to a file;
+        otherwise returns a windowed slice {items, total, truncated}."""
+        return await _run(driver, "export_trace", path, offset, limit)
+
+    # -- batch experiments -----------------------------------------------------
+
+    @server.tool()
+    async def sevm_run_experiments(
+        experiments: list[dict], base_checkpoint: str = "auto"
+    ) -> dict:
+        """Branch-search from one deep stop without replaying the prefix.
+
+        Saves a base checkpoint, then per experiment (max 32): restore base,
+        apply {set_stack: {index: value}, set_gas, write_memory: {offset: hex}},
+        run (run_until_pc, or continue to the next stop), and report the stop
+        with the requested stack window (read_stack: N). Returns
+        {items, total, base_restored}; order experiments that might finish the
+        program last — a finished run cannot be restored."""
+        return await _run(driver, "run_experiments", experiments, base_checkpoint)
+
+    # -- parity ----------------------------------------------------------------
+
+    @server.tool()
+    async def sevm_check_parity(reference_hex: str, contract: str | None = None) -> dict:
+        """Compare a compiled runtime against the deployed bytecode (explorer
+        hex). Ignores the metadata tail and immutable values; reports the first
+        divergence — past it, every pc and gadget offset describes a different
+        program."""
+        return await _run(driver, "check_parity", reference_hex, contract)
+
     return server
diff --git a/src/sevm/session/__init__.py b/src/sevm/session/__init__.py
index 39e6dfe..a09118b 100644
--- a/src/sevm/session/__init__.py
+++ b/src/sevm/session/__init__.py
@@ -18,6 +18,8 @@
   code.py         resolving running bytecode back to the source it came from
   patch.py        the `apply_computation` monkeypatch and its opcode loop
   stepping.py     when a step stops; when a watchpoint fires
+  checkpoints.py  named snapshots: capture a stop, experiment, restore
+  provenance.py   the opcode recorder behind `why $stack[n]` and trace export
   snapshots.py    building the `FrameSnapshot` the UI renders
   framelocals.py  recovering Solidity locals from the EVM stack
   inspect_ops.py  the reads and mutations the controller can ask for
diff --git a/src/sevm/session/checkpoints.py b/src/sevm/session/checkpoints.py
new file mode 100644
index 0000000..7ae5fc3
--- /dev/null
+++ b/src/sevm/session/checkpoints.py
@@ -0,0 +1,193 @@
+"""Named checkpoints: persist a stop, experiment freely, come back without replay.
+
+The reviewer's shape: reach a deep stop once, then try `set $stack[i] = v` +
+`jump` variants against a saved snapshot instead of re-running a 50k-step
+prefix per experiment. Three layers have to come back:
+
+  * the EVM frame state — stack, memory, gas, pc, logs — per live computation;
+  * the chain state — storage, balances, transient storage, warm/cold — through
+    py-evm's journal, the same `state.snapshot()`/`revert()` pair the evaluator
+    already exercises while parked;
+  * the debugger's own bookkeeping — cheat state, gas profiles, watchpoint
+    baselines, the Solidity frame model, the provenance record.
+
+Two hard rules, both documented on the verbs:
+
+  * RESTORE only works while the frame stack is exactly the one that was saved.
+    A checkpoint taken before a CALL cannot be restored from inside that CALL
+    (the VM thread is parked in the callee's Python frame; finish out first),
+    and after the frames returned the saved inner computations are gone.
+  * restoring discards every checkpoint saved after the restored one: py-evm's
+    journal nests checkpoints, and reverting an outer one pops the inner ones.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from typing import Any
+
+
+@dataclass
+class FrameCapture:
+    """The mutable state of one live computation at the checkpoint."""
+
+    computation_id: int
+    depth: int
+    stack: tuple[Any, ...]
+    memory: bytes
+    gas_remaining: int
+    gas_refunded: int
+    pc: int
+    logs: list[tuple]
+    # The Solidity frame model, copied: InternalFrames are small dataclasses, the
+    # FunctionInfo inside them is immutable, and `slots` needs a dict copy.
+    internal: list[Any]
+
+
+@dataclass
+class Checkpoint:
+    name: str
+    frames: list[FrameCapture]
+    journal: Any  # computation.state.snapshot(): (state_root, checkpoint)
+    step_index: int
+    gas_by_line: dict[tuple[int, int], int]
+    gas_by_opcode: dict[str, int]
+    cheats: dict[str, Any]
+    watch_baselines: dict[int, tuple[bool, Any]]
+    provenance_len: int
+    last_revert: str | None
+    note: str = ""
+    captures: int = 0  # times restored from
+
+
+def capture_frames(frames: list[Any]) -> list[FrameCapture]:
+    """Deep-capture every live frame's computation state (VM thread only)."""
+    out: list[FrameCapture] = []
+    for frame in frames:
+        computation = frame.computation
+        out.append(
+            FrameCapture(
+                computation_id=id(computation),
+                depth=frame.depth,
+                stack=tuple(computation._stack.values),
+                memory=bytes(computation._memory._bytes),
+                gas_remaining=computation._gas_meter.gas_remaining,
+                gas_refunded=computation._gas_meter.gas_refunded,
+                # The boundary pc (the opcode about to run), NOT program_counter:
+                # at a pause the stream already consumed the opcode byte, and the
+                # loop's next() must re-read from the boundary after a restore.
+                pc=max(0, computation.code.program_counter - 1),
+                logs=list(computation._log_entries),
+                internal=[replace(f, slots=dict(f.slots)) for f in frame.internal],
+            )
+        )
+    return out
+
+
+def restore_frames(frames: list[Any], captures: list[FrameCapture]) -> None:
+    """Write captured state back into the live computations (VM thread only).
+
+    Callers must have verified the frame stack matches the captures exactly.
+    """
+    for frame, capture in zip(frames, captures, strict=True):
+        computation = frame.computation
+        computation._stack.values[:] = list(capture.stack)
+        mem = computation._memory._bytes
+        if len(mem) > len(capture.memory):
+            del mem[len(capture.memory) :]
+        else:
+            mem.extend(b"\x00" * (len(capture.memory) - len(mem)))
+        mem[:] = capture.memory
+        computation._gas_meter.gas_remaining = capture.gas_remaining
+        computation._gas_meter.gas_refunded = capture.gas_refunded
+        computation.code.program_counter = capture.pc
+        computation._log_entries[:] = list(capture.logs)
+        frame.internal[:] = [replace(f, slots=dict(f.slots)) for f in capture.internal]
+
+
+def frames_match(frames: list[Any], captures: list[FrameCapture]) -> bool:
+    """True when every live computation is the very object that was captured."""
+    if len(frames) != len(captures):
+        return False
+    return all(
+        id(frame.computation) == capture.computation_id
+        for frame, capture in zip(frames, captures, strict=True)
+    )
+
+
+def capture_cheats(cheats: Any) -> dict[str, Any]:
+    prank = None
+    if cheats.prank is not None:
+        prank = replace(cheats.prank)  # frozen-ish dataclass; copy defensively
+    return {
+        "prank": prank,
+        "labels": dict(cheats.labels),
+        "console_len": len(cheats.console_lines),
+        "seed": cheats.seed,
+    }
+
+
+def restore_cheats(cheats: Any, saved: dict[str, Any]) -> None:
+    cheats.prank = saved["prank"]
+    cheats.labels.clear()
+    cheats.labels.update(saved["labels"])
+    del cheats.console_lines[saved["console_len"] :]
+    cheats.reseed(saved["seed"])
+    cheats._rng = None
+
+
+@dataclass
+class CheckpointSet:
+    """Ordered named checkpoints owned by one DebugSession.
+
+    Insertion order matters: restoring a checkpoint discards every one saved
+    after it, because the journal checkpoint it holds pops the journal
+    checkpoints nested above it.
+    """
+
+    _by_name: dict[str, Checkpoint] = field(default_factory=dict)
+
+    def save(self, checkpoint: Checkpoint) -> Checkpoint:
+        # Re-saving a name replaces it in place, keeping its original position.
+        self._by_name[checkpoint.name] = checkpoint
+        return checkpoint
+
+    def get(self, name: str) -> Checkpoint | None:
+        return self._by_name.get(name)
+
+    def latest(self) -> Checkpoint | None:
+        return next(reversed(self._by_name.values()), None)
+
+    def discard_after(self, name: str) -> list[str]:
+        """Drop every checkpoint saved after `name` (journal nesting rule)."""
+        dropped: list[str] = []
+        names = list(self._by_name)
+        position = names.index(name)
+        for later in names[position + 1 :]:
+            dropped.append(later)
+            del self._by_name[later]
+        return dropped
+
+    def clear(self) -> None:
+        self._by_name.clear()
+
+    def listing(self) -> list[dict[str, Any]]:
+        rows = []
+        for position, cp in enumerate(self._by_name.values()):
+            rows.append(
+                {
+                    "name": cp.name,
+                    "order": position,
+                    "frames": len(cp.frames),
+                    "step": cp.step_index,
+                    "restores": cp.captures,
+                    "note": cp.note,
+                }
+            )
+        return rows
+
+    def __bool__(self) -> bool:
+        return bool(self._by_name)
+
+    def __len__(self) -> int:
+        return len(self._by_name)
diff --git a/src/sevm/session/core.py b/src/sevm/session/core.py
index bfdb19f..43f353d 100644
--- a/src/sevm/session/core.py
+++ b/src/sevm/session/core.py
@@ -99,6 +99,17 @@ def __init__(
         # Set by `set $gas` while parked on an out-of-gas error; the opcode loop reads
         # it right after the pause lifts and retries the instruction instead of raising.
         self._gas_rescued = False
+        # Named checkpoints for `snap` / `restore`: capture a stop, experiment,
+        # come back without re-running the prefix.
+        from .checkpoints import CheckpointSet
+        from .provenance import Provenance
+
+        self.checkpoints = CheckpointSet()
+        self.provenance = Provenance()
+        # Set when a pc write is serviced during a pause (`jump`, `set $pc`,
+        # restore); the opcode loop reads it right after the pause lifts and
+        # skips the stale iteration for the pre-write pc.
+        self._skip_current_opcode = False
 
         self.armed = False
         self.finished = False
@@ -229,6 +240,10 @@ def restart(self, argv: list[str] | None = None, timeout: float = 120.0) -> Any:
         self.step_index = 0
         self.gas_by_line.clear()
         self.gas_by_opcode.clear()
+        # A fresh chain invalidates every journal checkpoint and frame capture.
+        self.checkpoints.clear()
+        self._skip_current_opcode = False
+        self.provenance.clear()
         # Stop policy back to the opening stop, exactly as a fresh session.
         self._mode = StepMode.STEP if self.skip_to_source else StepMode.STEPI
         self._mode_depth = 0
diff --git a/src/sevm/session/inspect_ops.py b/src/sevm/session/inspect_ops.py
index 037ebfe..5d0127d 100644
--- a/src/sevm/session/inspect_ops.py
+++ b/src/sevm/session/inspect_ops.py
@@ -279,6 +279,9 @@ def _op_set_pc(self, frame: EvmFrame, computation: Any, value: int) -> int:
         if not frame.disassembly.is_valid_jumpdest(value):
             raise ValueError(f"0x{value:x} is not a JUMPDEST; refusing to jump")
         computation.code.program_counter = value
+        # The loop still holds the yielded opcode for the OLD pc; skip it so the
+        # next instruction executed is the one just jumped to.
+        self.session._skip_current_opcode = True
         return value
 
     def _op_reseat_frame(
@@ -412,3 +415,101 @@ def _op_evaluate(
             keep=keep,
             bindings=self.session.frame_locals(frame, computation, internal_index),
         )
+
+    # -- checkpoints ----------------------------------------------------------
+
+    def _op_save_checkpoint(
+        self, frame: EvmFrame, computation: Any, name: str = "last"
+    ) -> dict:
+        """Capture this stop: frame state, journal checkpoint, session bookkeeping."""
+        from . import checkpoints as ckpt
+
+        session = self.session
+        existing = session.checkpoints.get(name)
+        if existing is not None and not ckpt.frames_match(
+            session._frames, existing.frames
+        ):
+            # Overwriting is fine only while the same frames are live; otherwise the
+            # old journal checkpoint would be orphaned on the stack.
+            return Failure(
+                f"checkpoint {name!r} was taken in a different frame stack; "
+                "save under a new name"
+            )
+        saved = ckpt.Checkpoint(
+            name=name,
+            frames=ckpt.capture_frames(session._frames),
+            journal=computation.state.snapshot(),
+            step_index=session.step_index,
+            gas_by_line=dict(session.gas_by_line),
+            gas_by_opcode=dict(session.gas_by_opcode),
+            cheats=ckpt.capture_cheats(session.cheats),
+            watch_baselines={
+                wp.number: (wp.initialised, wp.old_value)
+                for wp in session.breakpoints.active_watchpoints()
+            },
+            provenance_len=len(session.provenance.records),
+            last_revert=session.last_revert,
+            note=(
+                f"depth {frame.depth}, pc 0x{max(0, computation.code.program_counter - 1):04x}"
+            ),
+        )
+        session.checkpoints.save(saved)
+        return {"name": name, "frames": len(saved.frames), "note": saved.note}
+
+    def _op_restore_checkpoint(
+        self, frame: EvmFrame, computation: Any, name: str = "last"
+    ) -> dict:
+        """Roll the live run back to a checkpoint (VM thread, frames must match)."""
+        from . import checkpoints as ckpt
+
+        session = self.session
+        saved = session.checkpoints.get(name)
+        if saved is None:
+            latest = session.checkpoints.latest()
+            hint = f" (did you mean {latest.name!r}?)" if latest else ""
+            return Failure(f"no checkpoint named {name!r}{hint}")
+        if not ckpt.frames_match(session._frames, saved.frames):
+            return Failure(
+                f"cannot restore {name!r}: the frame stack changed since it was "
+                "taken (a call returned or a new one is live); finish/step out of "
+                "frames created after the checkpoint first, or `restart`"
+            )
+        computation.state.revert(saved.journal)
+        ckpt.restore_frames(session._frames, saved.frames)
+        # The loop is parked inside the yield for the *current* opcode, whose pc
+        # the restore just replaced; skip that stale iteration.
+        session._skip_current_opcode = True
+        # py-evm's revert CONSUMES the journal checkpoint, so a snapshot taken at
+        # the now-restored state re-arms the checkpoint: restoring twice, or
+        # continuing and coming back, keeps working. Frame writes do not journal.
+        saved.journal = computation.state.snapshot()
+        session.step_index = saved.step_index
+        session.gas_by_line.clear()
+        session.gas_by_line.update(saved.gas_by_line)
+        session.gas_by_opcode.clear()
+        session.gas_by_opcode.update(saved.gas_by_opcode)
+        ckpt.restore_cheats(session.cheats, saved.cheats)
+        for wp in session.breakpoints.active_watchpoints():
+            baseline = saved.watch_baselines.get(wp.number)
+            if baseline is not None:
+                wp.initialised, wp.old_value = baseline
+        provenance = getattr(session, "provenance", None)
+        if provenance is not None:
+            provenance.truncate(saved.provenance_len)
+        session.last_revert = saved.last_revert
+        saved.captures += 1
+        dropped = session.checkpoints.discard_after(name)
+        return {
+            "name": name,
+            "frames": len(saved.frames),
+            "dropped": dropped,
+            "step": saved.step_index,
+            # The innermost boundary pc: right after a restore the live stream
+            # sits pre-read, so a snapshot's `program_counter - 1` shows one
+            # less than the opcode that will actually run next.
+            "pc": saved.frames[-1].pc if saved.frames else None,
+            "note": saved.note,
+        }
+
+    def _op_list_checkpoints(self, frame: EvmFrame, computation: Any) -> list[dict]:
+        return self.session.checkpoints.listing()
diff --git a/src/sevm/session/patch.py b/src/sevm/session/patch.py
index 08db74b..f902b66 100644
--- a/src/sevm/session/patch.py
+++ b/src/sevm/session/patch.py
@@ -106,6 +106,14 @@ def patched(cls, state, message, transaction_context, parent_computation=None):
                         except AttributeError:
                             mnemonic = opcode_fn.__wrapped__.mnemonic  # type: ignore[attr-defined]
                         session._on_opcode(frame, computation, pc, opcode, mnemonic)
+                        # A pc write serviced during that pause (`jump`, `set $pc`,
+                        # a checkpoint restore) repositions the CodeStream, but THIS
+                        # iteration's opcode was already yielded for the old pc —
+                        # executing it would fire a stale instruction on fresh state.
+                        # Skip the iteration; the next reads the restored pc.
+                        if session._skip_current_opcode:
+                            session._skip_current_opcode = False
+                            continue
                         gas_before = computation._gas_meter.gas_remaining
                         # A failing opcode may already have popped its operands
                         # (py-evm charges some costs after the pops), so keep a copy
@@ -118,6 +126,18 @@ def patched(cls, state, message, transaction_context, parent_computation=None):
                             session._account_gas(
                                 frame, computation, pc, mnemonic, gas_before
                             )
+                            session.provenance.record(
+                                session.step_index,
+                                pc,
+                                opcode,
+                                mnemonic,
+                                frame.depth,
+                                gas_before,
+                                computation._gas_meter.gas_remaining,
+                                len(computation._memory),
+                                stack_backup,
+                                list(computation._stack.values),
+                            )
                             break
                         except VMError as error:
                             # Pause on the failing instruction with the stack, memory
@@ -140,6 +160,18 @@ def patched(cls, state, message, transaction_context, parent_computation=None):
                                 )
                                 break
                         session._account_gas(frame, computation, pc, mnemonic, gas_before)
+                        session.provenance.record(
+                            session.step_index,
+                            pc,
+                            opcode,
+                            mnemonic,
+                            frame.depth,
+                            gas_before,
+                            computation._gas_meter.gas_remaining,
+                            len(computation._memory),
+                            stack_backup,
+                            list(computation._stack.values),
+                        )
                         session._after_opcode(frame, computation, pc, mnemonic)
                     else:
                         try:
diff --git a/src/sevm/session/provenance.py b/src/sevm/session/provenance.py
new file mode 100644
index 0000000..79cc3d3
--- /dev/null
+++ b/src/sevm/session/provenance.py
@@ -0,0 +1,474 @@
+"""Operand provenance: which entry slot, constant, calldata word or memory write
+produced the value sitting in a stack slot right now.
+
+The question a JOP/gadget investigation actually asks — "why did operand N of this
+CALL get this value" — is answered with a recorder plus a backward slice:
+
+  * recording is opt-in (`provenance on`, or `provenance=true` at session start):
+    every executed opcode appends its pc, mnemonic, gas and the stack before and
+    after it. Pure appends of immutable tuples; off by default so normal
+    debugging pays nothing.
+  * `why $stack[n]` walks those records newest→oldest from the queried slot:
+    PUSH resolves to a constant, DUP/SWAP to the slot they copied, a consuming
+    opcode rewires to the operands it popped, MLOAD chains to the last MSTORE of
+    the same offset (or "memory at entry"), SLOAD likewise through SSTORE,
+    CALLDATALOAD names its calldata window. Surviving positions at the frame's
+    first record are the frame-entry slots — the reviewer's "entry slot >= N".
+
+The slice is concrete (it follows recorded values), not a symbolic executor:
+repeating values are tracked by position, and a hand mutation (`set $stack[i]`)
+is not recorded, so ask `why` before mutating, or expect the mutated slot's
+origin to be reported as unknown.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+_DUP_RE = re.compile(r"DUP(\d+)$")
+_SWAP_RE = re.compile(r"SWAP(\d+)$")
+# Opcodes whose single pushed result carries a named external origin.
+_ORIGIN_OPS = {
+    "CALLDATALOAD": "calldata",
+    "MLOAD": "memory",
+    "SLOAD": "storage",
+    "SHA3": "keccak",
+    "KECCAK256": "keccak",
+    "CALL": "call-output",
+    "CALLCODE": "call-output",
+    "DELEGATECALL": "call-output",
+    "STATICCALL": "call-output",
+    "CREATE": "create",
+    "CREATE2": "create",
+    "CODECOPY": "codecopy",
+    "EXTCODECOPY": "extcodecopy",
+    "RETURNDATACOPY": "returndatacopy",
+    "CALLDATACOPY": "calldatacopy",
+}
+
+# (pops, pushes) per mnemonic — evm.codes semantics. DUP/SWAP are handled
+# structurally (copies/permutations) and PUSH* resolve to constants, so they are
+# absent. Unknown mnemonics fall back to the height delta, which is only right
+# for net-consumers; the table keeps every balanced op (MLOAD, ADD, ...) honest.
+_ARITY: dict[str, tuple[int, int]] = {
+    "STOP": (0, 0),
+    "INVALID": (0, 0),
+    "ADD": (2, 1),
+    "SUB": (2, 1),
+    "MUL": (2, 1),
+    "DIV": (2, 1),
+    "SDIV": (2, 1),
+    "MOD": (2, 1),
+    "SMOD": (2, 1),
+    "ADDMOD": (3, 1),
+    "MULMOD": (3, 1),
+    "EXP": (2, 1),
+    "SIGNEXTEND": (2, 1),
+    "LT": (2, 1),
+    "GT": (2, 1),
+    "SLT": (2, 1),
+    "SGT": (2, 1),
+    "EQ": (2, 1),
+    "AND": (2, 1),
+    "OR": (2, 1),
+    "XOR": (2, 1),
+    "NOT": (1, 1),
+    "BYTE": (2, 1),
+    "SHL": (2, 1),
+    "SHR": (2, 1),
+    "SAR": (2, 1),
+    "KECCAK256": (2, 1),
+    "SHA3": (2, 1),
+    "ADDRESS": (0, 1),
+    "BALANCE": (1, 1),
+    "ORIGIN": (0, 1),
+    "CALLER": (0, 1),
+    "CALLVALUE": (0, 1),
+    "CALLDATASIZE": (0, 1),
+    "CODESIZE": (0, 1),
+    "GASPRICE": (0, 1),
+    "EXTCODESIZE": (1, 1),
+    "EXTCODEHASH": (1, 1),
+    "BLOCKHASH": (1, 1),
+    "COINBASE": (0, 1),
+    "TIMESTAMP": (0, 1),
+    "NUMBER": (0, 1),
+    "PREVRANDAO": (0, 1),
+    "DIFFICULTY": (0, 1),
+    "GASLIMIT": (0, 1),
+    "CHAINID": (0, 1),
+    "SELFBALANCE": (0, 1),
+    "BASEFEE": (0, 1),
+    "BLOBHASH": (1, 1),
+    "BLOBBASEFEE": (0, 1),
+    "POP": (1, 0),
+    "MLOAD": (1, 1),
+    "MSTORE": (2, 0),
+    "MSTORE8": (2, 0),
+    "SLOAD": (1, 1),
+    "SSTORE": (2, 0),
+    "TLOAD": (1, 1),
+    "TSTORE": (2, 0),
+    "JUMP": (2, 0),
+    "JUMPI": (3, 0),
+    "PC": (0, 1),
+    "MSIZE": (0, 1),
+    "GAS": (0, 1),
+    "CALLDATALOAD": (1, 1),
+    "CALLDATACOPY": (3, 0),
+    "CODECOPY": (3, 0),
+    "EXTCODECOPY": (4, 0),
+    "RETURNDATACOPY": (3, 0),
+    "MCOPY": (3, 0),
+    "RETURN": (2, 0),
+    "REVERT": (2, 0),
+    "RETURNDATASIZE": (0, 1),
+    "SELFDESTRUCT": (1, 0),
+    "CREATE": (3, 1),
+    "CALL": (7, 1),
+    "CALLCODE": (7, 1),
+    "DELEGATECALL": (6, 1),
+    "STATICCALL": (6, 1),
+    "LOG0": (2, 0),
+    "LOG1": (3, 0),
+    "LOG2": (4, 0),
+    "LOG3": (5, 0),
+    "LOG4": (6, 0),
+    "PUSH0": (0, 1),
+}
+
+MAX_FRONTIER = 64
+MAX_ORIGINS = 128
+
+
+@dataclass(frozen=True)
+class StepRecord:
+    step: int
+    pc: int
+    opcode: int
+    mnemonic: str
+    depth: int
+    gas_before: int
+    gas_remaining: int
+    mem_size: int
+    before: tuple  # stack bottom-up; values[-1] is the top, py-evm orientation
+    after: tuple
+
+
+class Provenance:
+    """The per-session recorder; the slice reads it from the controller thread."""
+
+    def __init__(self) -> None:
+        self.enabled = False
+        self.records: list[StepRecord] = []
+
+    def record(
+        self,
+        step: int,
+        pc: int,
+        opcode: int,
+        mnemonic: str,
+        depth: int,
+        gas_before: int,
+        gas_remaining: int,
+        mem_size: int,
+        before: list[Any],
+        after: list[Any],
+    ) -> None:
+        if not self.enabled:
+            return
+        self.records.append(
+            StepRecord(
+                step=step,
+                pc=pc,
+                opcode=opcode,
+                mnemonic=mnemonic,
+                depth=depth,
+                gas_before=gas_before,
+                gas_remaining=gas_remaining,
+                mem_size=mem_size,
+                before=tuple(before),
+                after=tuple(after),
+            )
+        )
+
+    def truncate(self, length: int) -> None:
+        """Drop records past a checkpoint's saved length (restore rolls time back)."""
+        del self.records[length:]
+
+    def clear(self) -> None:
+        self.records.clear()
+
+    # -- structLog export (shares the recording) ---------------------------
+
+    def structlog(self, offset: int = 0, limit: int = 500) -> dict[str, Any]:
+        """anvil/geth `debug_traceTransaction`-shaped rows, windowed."""
+        rows = [
+            {
+                "pc": hex(r.pc),
+                "op": r.mnemonic,
+                "gas": hex(r.gas_before),
+                "gasCost": hex(max(0, r.gas_before - r.gas_remaining)),
+                "depth": r.depth,
+                "stack": [
+                    _word(v)
+                    if not isinstance(v, bytes)
+                    else "0x" + v.hex().rjust(64, "0")
+                    for v in reversed(r.after)
+                ],
+                "memSize": r.mem_size,
+                "step": r.step,
+            }
+            for r in self.records[offset : offset + limit]
+        ]
+        return {
+            "structLogs": rows,
+            "total": len(self.records),
+            "offset": offset,
+            "truncated": offset + limit < len(self.records),
+        }
+
+
+# -- the backward slice -------------------------------------------------------
+
+
+@dataclass
+class _Target:
+    position: int  # bottom-up index into some record's before-stack
+    via: list[tuple[int, str]] = field(default_factory=list)  # (pc, mnemonic)
+
+
+@dataclass
+class Origin:
+    kind: str
+    detail: str = ""
+    value: str | None = None
+    via: list[tuple[int, str]] = field(default_factory=list)
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "detail": self.detail,
+            "value": self.value,
+            "via": [{"pc": pc, "op": op} for pc, op in self.via],
+        }
+
+
+def _num(value: Any) -> int:
+    """Stack values are ints or bytes; slices need them comparable as ints."""
+    if isinstance(value, (bytes, bytearray)):
+        return int.from_bytes(value, "big")
+    return int(value)
+
+
+def _word(value: Any) -> str:
+    """A 32-byte word as 0x + 64 hex chars; bytes and ints both occur on the stack."""
+    if isinstance(value, (bytes, bytearray)):
+        return "0x" + bytes(value).rjust(32, b"\x00").hex()
+    try:
+        return f"0x{int(value):064x}"
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def _frame_tail(records: list[StepRecord], depth: int) -> list[StepRecord]:
+    """The contiguous newest run of records at one depth: this frame's execution."""
+    tail: list[StepRecord] = []
+    for record in reversed(records):
+        if record.depth != depth:
+            break
+        tail.append(record)
+    tail.reverse()
+    return tail
+
+
+def _last_store(
+    tail: list[StepRecord], before_index: int, mnemonic: str, offset_value: int
+) -> tuple[int, int, int] | None:
+    """The newest record < before_index writing `mnemonic` with `offset_value`.
+
+    MSTORE/SSTORE pop (offset, value): offset second-from-top, value top of the
+    record's before-stack. Returns (record_index, offset_pos, value_pos).
+    """
+    for index in range(before_index - 1, -1, -1):
+        record = tail[index]
+        if record.mnemonic != mnemonic:
+            continue
+        height = len(record.before)
+        offset_pos, value_pos = height - 2, height - 1
+        if offset_pos < 0 or _num(record.before[offset_pos]) != offset_value:
+            continue
+        return index, offset_pos, value_pos
+    return None
+
+
+def why_stack(
+    records: list[StepRecord], depth: int, stack_bottom_up: tuple, index_from_top: int
+) -> dict[str, Any]:
+    """Trace one current stack slot back to its origins.
+
+    `stack_bottom_up` is the live stack in py-evm orientation (values[-1] is the
+    top); `index_from_top` is the gdb convention ($stack[0] = top).
+    """
+    if not records:
+        return {"origins": [{"kind": "unknown", "detail": "recording is off"}]}
+    sp = len(stack_bottom_up)
+    if not 0 <= index_from_top < sp:
+        return {"error": f"stack index {index_from_top} out of range (sp={sp})"}
+
+    tail = _frame_tail(records, depth)
+    if not tail:
+        return {"origins": [{"kind": "unknown", "detail": "no records at this depth"}]}
+
+    latest = tail[-1]
+    start_position = len(latest.after) - 1 - index_from_top
+    frontier: dict[int, _Target] = {
+        start_position: _Target(start_position, [(latest.pc, latest.mnemonic)])
+    }
+    origins: list[Origin] = []
+    entry_stack: tuple = ()
+
+    for record_index in range(len(tail) - 1, -1, -1):
+        record = tail[record_index]
+        before, after = record.before, record.after
+        height_before, height_after = len(before), len(after)
+        dup = _DUP_RE.match(record.mnemonic)
+        swap = _SWAP_RE.match(record.mnemonic)
+        if dup is None and swap is None:
+            pops, _pushes = _ARITY.get(record.mnemonic, (None, None))
+            if pops is None:
+                # Unknown mnemonic: approximate with the height delta. Right for
+                # net-consumers, wrong for balanced unknowns — the table covers
+                # every opcode that can appear in real bytecode.
+                pops = height_before - height_after if height_before > height_after else 0
+            pushed_base = height_before - pops
+        else:
+            pushed_base = height_before
+
+        next_frontier: dict[int, _Target] = {}
+        for position in sorted(frontier):
+            target = frontier[position]
+
+            if dup is not None and height_after == height_before + 1:
+                k = int(dup.group(1))
+                source = height_before - k
+                _carry(
+                    next_frontier,
+                    source if position == height_before else position,
+                    target,
+                    record,
+                )
+
+            elif swap is not None and height_after == height_before:
+                k = int(swap.group(1))
+                top, other = height_before - 1, height_before - 1 - k
+                if position == top:
+                    _carry(next_frontier, other, target, record)
+                elif position == other:
+                    _carry(next_frontier, top, target, record)
+                else:
+                    _carry(next_frontier, position, target)
+
+            elif position < pushed_base:
+                _carry(next_frontier, position, target)
+
+            else:
+                via = [(record.pc, record.mnemonic), *target.via]
+                value = after[position] if position < height_after else None
+                origin_kind = _ORIGIN_OPS.get(record.mnemonic)
+
+                if record.mnemonic.startswith("PUSH"):
+                    origins.append(Origin("constant", _word(value), _word(value), via))
+                    continue
+
+                if origin_kind in ("memory", "storage"):
+                    offset_pos = height_before - pops
+                    offset_value = (
+                        _num(before[offset_pos])
+                        if 0 <= offset_pos < height_before
+                        else -1
+                    )
+                    detail = f"{origin_kind}[{_word(offset_value)}]"
+                    store = _last_store(
+                        tail,
+                        record_index,
+                        "SSTORE" if origin_kind == "storage" else "MSTORE",
+                        offset_value,
+                    )
+                    if store is None:
+                        origins.append(
+                            Origin(f"{origin_kind}-entry", detail, _word(value), via)
+                        )
+                    else:
+                        store_index, _off, value_pos = store
+                        origins.append(
+                            Origin(
+                                origin_kind,
+                                f"{detail}, written by "
+                                f"{tail[store_index].mnemonic} at pc "
+                                f"0x{tail[store_index].pc:04x}",
+                                _word(value),
+                                via,
+                            )
+                        )
+                        # Chain through the storing record's value operand.
+                        _carry(next_frontier, value_pos, _Target(value_pos, via))
+                    if 0 <= offset_pos < height_before:
+                        _carry(next_frontier, offset_pos, _Target(offset_pos, via))
+                    continue
+
+                if origin_kind is not None:
+                    detail = f"{record.mnemonic} result"
+                    if origin_kind == "calldata":
+                        offset_pos = height_before - pops
+                        if 0 <= offset_pos < height_before:
+                            detail = f"calldata[{_word(_num(before[offset_pos]))}..+0x20]"
+                    origins.append(Origin(origin_kind, detail, _word(value), via))
+
+                for consumed_pos in range(pushed_base, height_before):
+                    _carry(next_frontier, consumed_pos, _Target(consumed_pos, via))
+
+        frontier = next_frontier
+        if record_index == 0:
+            entry_stack = before
+        if not frontier or len(origins) >= MAX_ORIGINS:
+            break
+
+    for position, target in frontier.items():
+        from_top = len(entry_stack) - 1 - position if entry_stack else position
+        origins.append(
+            Origin(
+                "entry-slot",
+                f"frame-entry stack, {from_top} from top (absolute position {position})",
+                _word(entry_stack[position])
+                if entry_stack and position < len(entry_stack)
+                else None,
+                target.via,
+            )
+        )
+
+    return {
+        "origins": [origin.as_dict() for origin in origins[:MAX_ORIGINS]],
+        "records_examined": len(tail),
+        "truncated": len(origins) > MAX_ORIGINS,
+    }
+
+
+def _carry(
+    frontier: dict[int, _Target],
+    position: int,
+    target: _Target,
+    record: StepRecord | None = None,
+) -> None:
+    if position < 0:
+        return
+    via = (
+        [(record.pc, record.mnemonic), *target.via] if record is not None else target.via
+    )
+    existing = frontier.get(position)
+    if existing is None:
+        frontier[position] = _Target(position, via)
+    # Positions already pending keep their first chain; the merge is lossy on
+    # purpose — one representative path per slot keeps the answer bounded.
diff --git a/src/sevm/session/snapshots.py b/src/sevm/session/snapshots.py
index 500cec3..62c011b 100644
--- a/src/sevm/session/snapshots.py
+++ b/src/sevm/session/snapshots.py
@@ -23,10 +23,33 @@ def live_view(session: Any, frame: EvmFrame, computation: Any) -> dict[str, Any]
 
     Shared by `_build_snapshot` and the `resnapshot` inspect op, so a refresh after a
     write produces the same fields the pause did rather than a second, drifting copy.
+    The instruction itself is included: `jump`, `set $pc` and a checkpoint restore
+    move the program counter, and a refresh that kept the pre-move pc would describe
+    the wrong instruction.
     """
     raw_stack = list(computation._stack.values)
     meter = computation._gas_meter
+    pc = max(0, computation.code.program_counter - 1)
+    raw = getattr(computation.code, "_raw_code_bytes", None)
+    code = bytes(raw) if raw is not None else bytes(computation.code)
+    opcode = code[pc] if 0 <= pc < len(code) else 0
+    opcode_fn = computation.opcodes.get(opcode)
+    if opcode_fn is not None:
+        mnemonic = getattr(opcode_fn, "mnemonic", None) or getattr(
+            getattr(opcode_fn, "__wrapped__", None), "mnemonic", "UNKNOWN"
+        )
+    else:
+        mnemonic = "UNKNOWN"
+    loc = frame.location(pc)
+    source_key = None
+    if loc is not None and not loc.is_generated:
+        src = session.project.source_by_id(loc.file_id)
+        source_key = src.key if src else None
     return {
+        "step": session.step_index,
+        "pc": pc,
+        "opcode": opcode,
+        "mnemonic": mnemonic,
         "stack": tuple(
             StackEntry(index=i, value=stack_int(v), raw=v)
             for i, v in enumerate(reversed(raw_stack))
@@ -40,6 +63,13 @@ def live_view(session: Any, frame: EvmFrame, computation: Any) -> dict[str, Any]
         # `reseat` rewrites the internal call stack, so the backtrace is a mutable field
         # too: a refresh after it must rebuild the CALL STACK, not just the VARIABLES.
         "backtrace": tuple(build_backtrace(session)),
+        "source_key": source_key,
+        "file_id": loc.file_id if loc else -1,
+        "line": loc.line if loc and not loc.is_generated else 0,
+        "col": loc.col if loc and not loc.is_generated else 0,
+        "end_line": loc.end_line if loc and not loc.is_generated else 0,
+        "jump": loc.jump if loc else "-",
+        "function": session.functions.at_location(loc),
     }
 
 
@@ -58,21 +88,15 @@ def build_snapshot(
     live = live_view(session, frame, computation)
     meter = computation._gas_meter
 
-    source_key = None
-    if loc is not None and not loc.is_generated:
-        src = session.project.source_by_id(loc.file_id)
-        source_key = src.key if src else None
-
     static_gas = None
-    opcode_obj = computation.opcodes.get(opcode)
+    opcode_obj = computation.opcodes.get(live["opcode"])
     if opcode_obj is not None:
         static_gas = getattr(opcode_obj, "gas_cost", None)
 
+    # pc/opcode/mnemonic/loc arrive as parameters for the pause-time callers but are
+    # read from the live stream inside `live_view`, so a refresh after a pc-moving
+    # mutation describes the instruction actually about to run.
     return FrameSnapshot(
-        step=session.step_index,
-        pc=pc,
-        opcode=opcode,
-        mnemonic=mnemonic,
         depth=frame.depth,
         gas_limit=meter.start_gas,
         address=frame.address,
@@ -83,13 +107,6 @@ def build_snapshot(
         calldata=frame.calldata,
         is_static=frame.is_static,
         contract_name=frame.artifact_name,
-        source_key=source_key,
-        file_id=loc.file_id if loc else -1,
-        line=loc.line if loc and not loc.is_generated else 0,
-        col=loc.col if loc and not loc.is_generated else 0,
-        end_line=loc.end_line if loc and not loc.is_generated else 0,
-        jump=loc.jump if loc else "-",
-        function=session.functions.at_location(loc),
         stop_reason=reason,
         **live,
         hit_breakpoints=tuple(hits),
diff --git a/tests/test_mcp_server.py b/tests/test_mcp_server.py
index c122dd8..5ae476f 100644
--- a/tests/test_mcp_server.py
+++ b/tests/test_mcp_server.py
@@ -10,6 +10,7 @@
 
 import asyncio
 import contextlib
+import os
 from collections.abc import Iterator
 
 import pytest
@@ -262,3 +263,166 @@ async def serve() -> None:
                     await task
 
     asyncio.run(scenario())
+
+
+# ==================================================================
+# checkpoints, provenance, parity, batch — the AI-review package
+# ==================================================================
+
+
+def test_checkpoint_roundtrip_undoes_mutations(lab):
+    driver, script = lab
+    driver.start(script)
+    driver.step_opcodes(10)
+    before_stack = driver.read_stack()["items"]
+    before_mem = driver.read_memory(0x40, 2)["items"]
+    driver.save_checkpoint("base")
+    driver.set_stack_slot(0, 0xDEADBEEF)
+    driver.write_storage(0, 42)
+    driver.write_memory(0x40, "11" * 32)
+    report = driver.restore_checkpoint("base")
+    assert report["restore"]["name"] == "base"
+    assert driver.read_stack()["items"] == before_stack
+    assert driver.read_memory(0x40, 2)["items"] == before_mem
+    assert driver.read_storage(slots=[0])["items"][0]["value"] == "0"
+
+
+def test_checkpoint_survives_steps_and_nested_discard(lab):
+    driver, script = lab
+    driver.start(script)
+    driver.step_opcodes(10)
+    pc0 = driver.status()["pc"]
+    driver.save_checkpoint("base")
+    driver.step_opcodes(2)
+    assert driver.status()["pc"] != pc0
+    driver.restore_checkpoint("base")
+    assert driver.status()["pc"] == pc0
+    driver.save_checkpoint("later")
+    driver.restore_checkpoint("base")
+    names = [c["name"] for c in driver.list_checkpoints()["checkpoints"]]
+    assert names == ["base"]  # journal nesting discards the later one
+    driver.restart()
+    assert driver.list_checkpoints()["checkpoints"] == []
+
+
+def test_restore_refused_after_finish(lab):
+    driver, script = lab
+    driver.start(script)
+    driver.step_opcodes(5)
+    driver.save_checkpoint("base")
+    result = driver.continue_execution()
+    assert result.get("finished")
+    with pytest.raises(Exception, match="finished"):
+        driver.restore_checkpoint("base")
+
+
+def test_provenance_calldata_origin(lab):
+    driver, script = lab
+    driver.start(script, provenance=True)
+    driver.set_breakpoint("inc")
+    driver.continue_execution()
+    # Stop right before a CALLDATALOAD, execute exactly it, then ask why.
+    for _ in range(200):
+        report = driver.step_opcodes(1)
+        if report.get("mnemonic") == "CALLDATALOAD":
+            driver.step_opcodes(1)
+            break
+    else:
+        pytest.fail("no CALLDATALOAD reached inside inc()")
+    why = driver.why_stack(0)
+    kinds = [origin["kind"] for origin in why["origins"]]
+    assert "calldata" in kinds
+    assert any("calldata[" in origin["detail"] for origin in why["origins"])
+
+
+def test_provenance_constant_and_truncate_on_restore(lab):
+    driver, script = lab
+    driver.start(script, provenance=True)
+    driver.step_opcodes(6)
+    records = len(driver._session.provenance.records)
+    assert records >= 6
+    why = driver.why_stack(0)
+    assert why["origins"], "PUSH results always have a constant origin"
+    driver.save_checkpoint("c")
+    driver.step_opcodes(3)
+    assert len(driver._session.provenance.records) > records
+    driver.restore_checkpoint("c")
+    assert len(driver._session.provenance.records) == records
+
+
+def test_export_trace_structlog_shape(lab):
+    driver, script = lab
+    driver.start(script, provenance=True)
+    driver.step_opcodes(10)
+    trace = driver.export_trace(limit=4)
+    assert trace["total"] >= 10
+    assert len(trace["structLogs"]) == 4
+    assert trace["truncated"] is True
+    row = trace["structLogs"][0]
+    assert {"pc", "op", "gas", "gasCost", "depth", "stack", "memSize"} <= set(row)
+    written = driver.export_trace(
+        path=os.path.join(os.path.dirname(script), "trace.json")
+    )
+    assert written["written"] == written["total"]
+
+
+def test_batch_experiments_branch_from_one_stop(lab):
+    driver, script = lab
+    driver.start(script)
+    driver.step_opcodes(10)
+    hit_pc = driver.status()["pc"]
+    batch = driver.run_experiments(
+        [
+            {"set_stack": {"0": "0x11"}, "run_until_pc": hit_pc, "read_stack": 2},
+            {"set_stack": {"0": "0x22"}, "run_until_pc": hit_pc, "read_stack": 2},
+        ]
+    )
+    assert batch["total"] == 2 and batch["base_restored"] is True
+    tops = [item["stack"][0]["hex"] for item in batch["items"]]
+    assert tops[0] != tops[1]  # each experiment saw its own mutation
+    assert driver.status()["pc"] == hit_pc  # base restored after the batch
+
+
+def test_parity_verdicts(lab):
+    from sevm.compile import compare_runtime
+
+    driver, script = lab
+    driver.start(script)
+    session = driver._session
+    art = next(a for a in session.project.artifacts.values() if a.deployed_bytecode)
+    exact = compare_runtime(art, art.deployed_bytecode)
+    assert exact["match"] is True and exact["difference"] == "none"
+    # A different metadata tail is not a divergence: strip the real one and
+    # append another valid `<cbor> <uint16 be length>` tail.
+    from sevm.compile.model import _strip_metadata
+
+    body = _strip_metadata(art.deployed_bytecode)
+    alt_meta = bytes([0xA2, 0x64, 0x69, 0x70, 0x66, 0x73])
+    tail = compare_runtime(art, body + alt_meta + len(alt_meta).to_bytes(2, "big"))
+    assert tail["match"] is True
+    # One flipped byte inside the code is, at its offset.
+    flipped = bytearray(art.deployed_bytecode)
+    flipped[10] ^= 0xFF
+    diverged = compare_runtime(art, bytes(flipped))
+    assert diverged["match"] is False
+    assert diverged["first_diff_offset"] == 10
+    # The MCP wrapper agrees on the running contract.
+    verdict = driver.check_parity("0x" + art.deployed_bytecode.hex())
+    assert verdict["match"] is True
+    assert verdict["contract"]
+
+
+def test_parity_hard_fails_session_start(lab):
+    driver, script = lab
+    session_probe = DebugDriver(timeout=60)
+    session_probe.start(script)
+    art = next(
+        a
+        for a in session_probe._session.project.artifacts.values()
+        if a.deployed_bytecode
+    )
+    flipped = bytearray(art.deployed_bytecode)
+    flipped[4] ^= 0x01
+    with pytest.raises(Exception, match="parity failed"):
+        driver.start(script, reference_runtime_hex="0x" + bytes(flipped).hex())
+    session_probe.stop()

From d45278aa63e5f3b8f1f63b363d1b78ae5722688c Mon Sep 17 00:00:00 2001
From: Bhremada Fevreano <bhremada.fka@gmail.com>
Date: Thu, 24 Sep 2026 17:37:10 +0700
Subject: [PATCH 3/9] Use pre-opcode stack order in exported traces

---
 src/sevm/session/provenance.py |  2 +-
 tests/test_mcp_server.py       | 23 +++++++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/sevm/session/provenance.py b/src/sevm/session/provenance.py
index 2bd926b..710f344 100644
--- a/src/sevm/session/provenance.py
+++ b/src/sevm/session/provenance.py
@@ -216,7 +216,7 @@ def structlog(self, offset: int = 0, limit: int = 500) -> dict[str, Any]:
                     _word(v)
                     if not isinstance(v, bytes)
                     else "0x" + v.hex().rjust(64, "0")
-                    for v in reversed(r.after)
+                    for v in r.before
                 ],
                 "memSize": r.mem_size,
                 "step": r.step,
diff --git a/tests/test_mcp_server.py b/tests/test_mcp_server.py
index 0105b80..9b5d873 100644
--- a/tests/test_mcp_server.py
+++ b/tests/test_mcp_server.py
@@ -333,6 +333,29 @@ def test_export_trace_structlog_shape(lab):
     assert written["written"] == written["total"]
 
 
+def test_structlog_stack_is_pre_opcode_and_bottom_first():
+    from sevm.session.provenance import Provenance
+
+    trace = Provenance()
+    trace.enabled = True
+    trace.record(
+        step=1,
+        pc=2,
+        opcode=1,
+        mnemonic="ADD",
+        depth=0,
+        gas_before=100,
+        gas_remaining=97,
+        mem_size=0,
+        before=[1, 2],
+        after=[3],
+    )
+    assert trace.structlog()["structLogs"][0]["stack"] == [
+        "0x" + "0" * 63 + "1",
+        "0x" + "0" * 63 + "2",
+    ]
+
+
 def test_parity_verdicts(lab):
     from sevm.compile import compare_runtime
 

From 47c9142a47639a932f18773448301db9fc49b3db Mon Sep 17 00:00:00 2001
From: Bhremada Fevreano <bhremada.fka@gmail.com>
Date: Thu, 24 Sep 2026 17:47:46 +0700
Subject: [PATCH 4/9] Report visited stops when line stepping test fails

---
 tests/test_stepping.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/test_stepping.py b/tests/test_stepping.py
index 0dd6908..a1fd4c8 100644
--- a/tests/test_stepping.py
+++ b/tests/test_stepping.py
@@ -140,13 +140,17 @@ def txfn():
     try:
         body = line_of(proj_, "total += history[i];")
         hits = 0
+        visited = [(dbg.snap.pc, dbg.snap.line, dbg.snap.stop_reason)]
         for _ in range(24):
             event = dbg.step(StepMode.NEXT)
             if isinstance(event, Finished):
                 break
+            visited.append(
+                (event.snapshot.pc, event.snapshot.line, event.snapshot.stop_reason)
+            )
             if event.snapshot.line == body:
                 hits += 1
-        assert hits >= 1, "the loop body should be reached"
+        assert hits >= 1, f"the loop body should be reached: {visited}"
     finally:
         dbg.close()
 

From ed8cf0a051e863b24e2e010747189fc587e2eb8a Mon Sep 17 00:00:00 2001
From: Bhremada Fevreano <bhremada.fka@gmail.com>
Date: Thu, 24 Sep 2026 17:57:44 +0700
Subject: [PATCH 5/9] Check stepping setup and run Rust CI independently

---
 .github/workflows/verify.yml | 7 +++++++
 tests/test_stepping.py       | 4 +++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/verify.yml b/.github/workflows/verify.yml
index 865ffac..7072f11 100644
--- a/.github/workflows/verify.yml
+++ b/.github/workflows/verify.yml
@@ -15,5 +15,12 @@ jobs:
       - run: uv run ruff check src tests examples
       - run: uv run ruff format --check src tests examples
       - run: uv run mypy src
+      - run: uv run pytest -q tests/test_stepping.py::test_loop_iterates_with_next
       - run: uv run pytest -q
+
+  rust:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7.0.1
+      - uses: dtolnay/rust-toolchain@stable
       - run: cargo test --workspace --locked
diff --git a/tests/test_stepping.py b/tests/test_stepping.py
index a1fd4c8..16460fb 100644
--- a/tests/test_stepping.py
+++ b/tests/test_stepping.py
@@ -131,7 +131,9 @@ def test_loop_iterates_with_next(bank):
     tx = contract.functions.deposit().transact(
         {"from": alice.address, "value": w3.to_wei(1, "ether"), "gas": 300_000}
     )
-    w3.eth.wait_for_transaction_receipt(tx)
+    receipt = w3.eth.wait_for_transaction_receipt(tx)
+    assert receipt.status == 1
+    assert contract.functions.history(0).call() == w3.to_wei(1, "ether")
 
     def txfn():
         contract.functions.sumHistory().call()

From 42afd62be1bfd6b5828dc5d427fb594f5817d373 Mon Sep 17 00:00:00 2001
From: Bhremada Fevreano <bhremada.fka@gmail.com>
Date: Thu, 24 Sep 2026 18:00:45 +0700
Subject: [PATCH 6/9] Trace line stepping decisions in failing regression

---
 tests/test_stepping.py | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/tests/test_stepping.py b/tests/test_stepping.py
index 16460fb..8b40101 100644
--- a/tests/test_stepping.py
+++ b/tests/test_stepping.py
@@ -134,6 +134,7 @@ def test_loop_iterates_with_next(bank):
     receipt = w3.eth.wait_for_transaction_receipt(tx)
     assert receipt.status == 1
     assert contract.functions.history(0).call() == w3.to_wei(1, "ether")
+    assert contract.functions.sumHistory().call() == w3.to_wei(1, "ether")
 
     def txfn():
         contract.functions.sumHistory().call()
@@ -143,6 +144,23 @@ def txfn():
         body = line_of(proj_, "total += history[i];")
         hits = 0
         visited = [(dbg.snap.pc, dbg.snap.line, dbg.snap.stop_reason)]
+        seen_raw = []
+        original_surface = dbg.session._should_surface
+
+        def record_surface(raw, snapshot, breakpoints):
+            if body - 2 <= snapshot.line <= body and len(seen_raw) < 60:
+                seen_raw.append(
+                    (
+                        snapshot.pc,
+                        snapshot.line,
+                        len(dbg.session.current_frame.internal),
+                        dbg.session._mode_internal,
+                        raw["reason"],
+                    )
+                )
+            return original_surface(raw, snapshot, breakpoints)
+
+        dbg.session._should_surface = record_surface
         for _ in range(24):
             event = dbg.step(StepMode.NEXT)
             if isinstance(event, Finished):
@@ -152,8 +170,9 @@ def txfn():
             )
             if event.snapshot.line == body:
                 hits += 1
-        assert hits >= 1, f"the loop body should be reached: {visited}"
+        assert hits >= 1, f"the loop body should be reached: {visited}; raw: {seen_raw}"
     finally:
+        dbg.session._should_surface = original_surface
         dbg.close()
 
 

From 8fcbb9b479dc9616c185b9e9d6be81e82187a80f Mon Sep 17 00:00:00 2001
From: Bhremada Fevreano <bhremada.fka@gmail.com>
Date: Thu, 24 Sep 2026 18:04:04 +0700
Subject: [PATCH 7/9] Inspect wrapper jump source range in stepping regression

---
 tests/test_stepping.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tests/test_stepping.py b/tests/test_stepping.py
index 8b40101..065f2f9 100644
--- a/tests/test_stepping.py
+++ b/tests/test_stepping.py
@@ -142,6 +142,9 @@ def txfn():
     dbg = Debugger(proj_, txfn)
     try:
         body = line_of(proj_, "total += history[i];")
+        jump_loc = dbg.session.current_frame.location(866)
+        jump_range = (jump_loc.entry.start, jump_loc.entry.length)
+        function_range = (dbg.snap.function.start, dbg.snap.function.length)
         hits = 0
         visited = [(dbg.snap.pc, dbg.snap.line, dbg.snap.stop_reason)]
         seen_raw = []
@@ -170,7 +173,10 @@ def record_surface(raw, snapshot, breakpoints):
             )
             if event.snapshot.line == body:
                 hits += 1
-        assert hits >= 1, f"the loop body should be reached: {visited}; raw: {seen_raw}"
+        assert hits >= 1, (
+            f"the loop body should be reached: {visited}; raw: {seen_raw}; "
+            f"jump: {jump_range}; function: {function_range}"
+        )
     finally:
         dbg.session._should_surface = original_surface
         dbg.close()

From c05d7dbc217e552bc8cbf6ae2ff3feafc13a4423 Mon Sep 17 00:00:00 2001
From: Bhremada Fevreano <bhremada.fka@gmail.com>
Date: Thu, 24 Sep 2026 18:07:57 +0700
Subject: [PATCH 8/9] Treat generated wrapper jumps as function entry

---
 src/sevm/session/revm.py | 9 +++++++--
 tests/test_stepping.py   | 5 ++++-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/sevm/session/revm.py b/src/sevm/session/revm.py
index 1e4ef72..be8a830 100644
--- a/src/sevm/session/revm.py
+++ b/src/sevm/session/revm.py
@@ -1023,11 +1023,16 @@ def _advance_internal(self, raw: dict[str, Any]) -> None:
         if (
             function is not None
             and frame.internal
-            and frame.internal[-1].function is not None
-            and function.ast_id == frame.internal[-1].function.ast_id
             and loc.entry.start == function.start
             and loc.entry.length == function.length
+            and (
+                frame.internal[-1].function is None
+                or function.ast_id == frame.internal[-1].function.ast_id
+            )
         ):
+            # The dispatcher can reach a source-mapped wrapper through a generated
+            # frame. Its jump into the actual body is an entry, not a nested call.
+            frame.internal[-1].function = function
             frame.internal[-1].entry_pc = destination
             frame.internal[-1].entry_sp = len(raw["stack"])
             return
diff --git a/tests/test_stepping.py b/tests/test_stepping.py
index 065f2f9..b40f4ee 100644
--- a/tests/test_stepping.py
+++ b/tests/test_stepping.py
@@ -145,6 +145,7 @@ def txfn():
         jump_loc = dbg.session.current_frame.location(866)
         jump_range = (jump_loc.entry.start, jump_loc.entry.length)
         function_range = (dbg.snap.function.start, dbg.snap.function.length)
+        initial_frames = [item.name for item in dbg.session.current_frame.internal]
         hits = 0
         visited = [(dbg.snap.pc, dbg.snap.line, dbg.snap.stop_reason)]
         seen_raw = []
@@ -159,6 +160,7 @@ def record_surface(raw, snapshot, breakpoints):
                         len(dbg.session.current_frame.internal),
                         dbg.session._mode_internal,
                         raw["reason"],
+                        [item.name for item in dbg.session.current_frame.internal],
                     )
                 )
             return original_surface(raw, snapshot, breakpoints)
@@ -175,7 +177,8 @@ def record_surface(raw, snapshot, breakpoints):
                 hits += 1
         assert hits >= 1, (
             f"the loop body should be reached: {visited}; raw: {seen_raw}; "
-            f"jump: {jump_range}; function: {function_range}"
+            f"jump: {jump_range}; function: {function_range}; "
+            f"initial frames: {initial_frames}"
         )
     finally:
         dbg.session._should_surface = original_surface

From 77db13a4bf6766bee2347a46c923bdbaf533cb1b Mon Sep 17 00:00:00 2001
From: Bhremada Fevreano <bhremada.fka@gmail.com>
Date: Thu, 24 Sep 2026 18:11:34 +0700
Subject: [PATCH 9/9] Reset internal frames at each REVM transaction

---
 src/sevm/session/revm.py | 13 ++++++-------
 tests/test_stepping.py   | 30 ++----------------------------
 2 files changed, 8 insertions(+), 35 deletions(-)

diff --git a/src/sevm/session/revm.py b/src/sevm/session/revm.py
index be8a830..ca5226e 100644
--- a/src/sevm/session/revm.py
+++ b/src/sevm/session/revm.py
@@ -499,7 +499,11 @@ def _require_success(self, result: dict[str, Any], what: str, artifact: Any) ->
         raise TestFailed(f"{what} reverted: {self.last_revert}")
 
     def _drive_transaction(self) -> dict[str, Any]:
+        # REVM starts a fresh EVM call stack for every transaction. A prior call's
+        # Solidity internal frames must not be reused for this transaction's pc.
+        self._frames.clear()
         self._last_raw = None
+        self._raw_snapshot = None
         self.provenance.clear()
         while True:
             event = self._chain.wait(timeout=30.0)
@@ -1023,16 +1027,11 @@ def _advance_internal(self, raw: dict[str, Any]) -> None:
         if (
             function is not None
             and frame.internal
+            and frame.internal[-1].function is not None
+            and function.ast_id == frame.internal[-1].function.ast_id
             and loc.entry.start == function.start
             and loc.entry.length == function.length
-            and (
-                frame.internal[-1].function is None
-                or function.ast_id == frame.internal[-1].function.ast_id
-            )
         ):
-            # The dispatcher can reach a source-mapped wrapper through a generated
-            # frame. Its jump into the actual body is an entry, not a nested call.
-            frame.internal[-1].function = function
             frame.internal[-1].entry_pc = destination
             frame.internal[-1].entry_sp = len(raw["stack"])
             return
diff --git a/tests/test_stepping.py b/tests/test_stepping.py
index b40f4ee..3b4b864 100644
--- a/tests/test_stepping.py
+++ b/tests/test_stepping.py
@@ -141,31 +141,10 @@ def txfn():
 
     dbg = Debugger(proj_, txfn)
     try:
+        assert dbg.snap.backtrace[0].name.startswith("Bank.sumHistory")
         body = line_of(proj_, "total += history[i];")
-        jump_loc = dbg.session.current_frame.location(866)
-        jump_range = (jump_loc.entry.start, jump_loc.entry.length)
-        function_range = (dbg.snap.function.start, dbg.snap.function.length)
-        initial_frames = [item.name for item in dbg.session.current_frame.internal]
         hits = 0
         visited = [(dbg.snap.pc, dbg.snap.line, dbg.snap.stop_reason)]
-        seen_raw = []
-        original_surface = dbg.session._should_surface
-
-        def record_surface(raw, snapshot, breakpoints):
-            if body - 2 <= snapshot.line <= body and len(seen_raw) < 60:
-                seen_raw.append(
-                    (
-                        snapshot.pc,
-                        snapshot.line,
-                        len(dbg.session.current_frame.internal),
-                        dbg.session._mode_internal,
-                        raw["reason"],
-                        [item.name for item in dbg.session.current_frame.internal],
-                    )
-                )
-            return original_surface(raw, snapshot, breakpoints)
-
-        dbg.session._should_surface = record_surface
         for _ in range(24):
             event = dbg.step(StepMode.NEXT)
             if isinstance(event, Finished):
@@ -175,13 +154,8 @@ def record_surface(raw, snapshot, breakpoints):
             )
             if event.snapshot.line == body:
                 hits += 1
-        assert hits >= 1, (
-            f"the loop body should be reached: {visited}; raw: {seen_raw}; "
-            f"jump: {jump_range}; function: {function_range}; "
-            f"initial frames: {initial_frames}"
-        )
+        assert hits >= 1, f"the loop body should be reached: {visited}"
     finally:
-        dbg.session._should_surface = original_surface
         dbg.close()