kedi-notebook 0.1.0__tar.gz

kedi_notebook-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.coverage
+.DS_Store
+.pytest_cache/
+.ruff_cache/
+.venv/
+__pycache__/
+dist/

kedi_notebook-0.1.0/LICENSE

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

kedi_notebook-0.1.0/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.5
+Name: kedi-notebook
+Version: 0.1.0
+Summary: Local interactive notebook for the Kedi Programming Language
+Project-URL: Source, https://github.com/kedi-lang/notebook
+Project-URL: Tracker, https://github.com/kedi-lang/notebook/issues
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: basedpyright<1.41,>=1.40.2
+Requires-Dist: fastapi<0.163,>=0.162.0
+Requires-Dist: kedi<0.2,>=0.1.2
+Requires-Dist: python-dotenv<2,>=1.2.4
+Requires-Dist: uvicorn<0.55,>=0.54
+Description-Content-Type: text/markdown
+
+# Kedi Notebook
+
+Kedi Notebook is the local, incremental notebook interface for the Kedi
+Programming Language. It provides editable Kedi, terminal, and Markdown cells,
+with either browser-owned Pyodide or a selected host Python interpreter.
+
+![Kedi Notebook running incremental Kedi cells](.github/assets/kedi-notebook.png)
+
+## Install and Run
+
+The notebook is currently distributed from a Kedi source checkout. Install its
+local dependencies and start it in one command from the Kedi repository root:
+
+```bash
+uv run --extra notebook kedi notebook
+```
+
+This uses the checked-out `notebook` submodule and Kedi source rather than a
+published package. For notebook development, run from the Kedi repository root
+with the notebook extra and development dependencies installed:
+
+```bash
+.venv/bin/python -m pytest notebook/tests
+```
+
+After syncing the extra, both entry points are equivalent:
+
+```bash
+kedi notebook
+kedi-notebook
+```
+
+The default address is <http://127.0.0.1:8788/notebook/>. Add one or more host
+Python installations explicitly when needed:
+
+```bash
+kedi-notebook --python /opt/homebrew/bin/python3.11
+kedi notebook --python ~/.pyenv/versions/3.12.4/bin/python --port 8899
+```
+
+Use `--host`, `--port`, `--cwd`, and `--no-open` to control local serving.
+Loopback serving requires no credentials. A non-loopback `--host` is rejected
+unless `--token` or `KEDI_NOTEBOOK_TOKEN` is set; the browser opened by the CLI
+receives that token without leaving it in the visible URL.
+
+At startup, the notebook server loads `.env` from `--cwd` without overriding
+variables already present in its process. Set `KEDI_ADAPTER_MODEL` there or use
+`> model:` in a Kedi cell before invoking a template. Calling `load_dotenv()`
+inside a host Python cell affects only that cell worker, not the server process
+that owns adapters; browser Python cannot read the host project's `.env`.
+
+When a native Pydantic AI model requires a missing provider SDK, the notebook
+installs only the provider group named by Pydantic AI, immediately before model
+construction. OpenRouter, for example, requests the `openai` group. Unused
+provider SDKs are not installed. Installation targets the notebook server's
+Python environment, keeps its existing package versions, and requires package
+index access on first use. It does not replay earlier statements in the cell.
+Provider credentials are still required. A dependency conflict or failed
+installation is shown as a cell error; specialized adapters retain their own
+installation requirements.
+
+The **Secret Manager** action in the top bar stores environment values outside
+the notebook at `~/.kedi/notebook/secrets.json`. Stored values take precedence
+over the server process and project `.env`, and the browser can list only their
+names, never their values. Add a single value or import an arbitrary `.env`
+path; relative paths resolve from `--cwd`. The store is atomically written with
+user-only file permissions and is never included in browser storage. Saving,
+importing, or deleting a value closes active sessions so the next cell starts a
+runtime with the new environment.
+
+## Runtime Model
+
+Browser mode starts one persistent Pyodide worker as the page loads. Host mode
+creates and reuses a project-specific virtual environment from the selected
+Python executable, installs Kedi into it, and starts one persistent worker from
+that environment. Kedi cells
+execute incrementally against that session; completed cells remain editable
+and rerunnable, and output is displayed under its source.
+The bundled `filesystem` module works in both modes: browser mode accesses the
+worker's temporary virtual filesystem, while host mode accesses the notebook
+working directory on disk.
+
+Every visible cell keeps its editor when focus moves elsewhere; inactive Kedi
+cells retain syntax highlighting and can be edited or run directly. The cell
+header can convert an individual cell between Kedi, Markdown, and Terminal.
+Cells never collapse implicitly. Use the eye control to hide a cell explicitly;
+the compact row remains available to show it again, and hidden state is saved
+in `.kedinb` documents and local drafts.
+
+Managed environments live under `~/.kedi/notebook/venvs` by default and have a
+stable `kedi-notebook-py...` name derived from the base interpreter and working
+directory. Set `KEDI_NOTEBOOK_ENV_HOME` to choose another root. The package
+action beside a host runtime lists installed packages and installs newline-
+separated requirement strings into the managed environment with streamed pip
+output. The environment and installed packages persist across notebook server
+runs while the directory remains available.
+
+Cells beginning with `!` are terminal cells. Host commands run in the notebook
+working directory, with `!python` and `!pip` bound to the managed environment.
+Browser mode supports `!pip install`, `!uv add`, `!pip list`, `!echo`, and
+`!pwd`. Terminal output streams into the active cell while it runs.
+
+Use the square interrupt action while a cell is running. Interrupting replaces
+the active Python worker, so the source remains rerunnable but live runtime
+state is deliberately discarded. It also cancels that session's in-flight
+Pydantic AI or LangChain model and async tool work, without cancelling another
+session. Cancellation does not roll back completed effects or forcibly stop
+arbitrary synchronous tool code running in a server thread.
+
+Embedded-Python bridge operations and terminal execution have 120-second
+timeouts; this is not a universal deadline for a complete model-backed cell.
+Package installation has a 10-minute limit. Idle sessions expire after 30 minutes.
+
+Notebook execution is non-transactional. Rerunning a cell is a new execution
+attempt against current state; it does not roll back previous side effects.
+Displayed cell numbers follow notebook order and remain unchanged across
+reruns. Adding, moving, or deleting cells recomputes affected positions.
+
+Notebook files are validated before they replace the current document. The UI
+warns before discarding unsaved changes and limits files to 5 MB, notebooks to
+1,000 cells, individual cell source to 1 MB, and retained inline output to
+200,000 characters. Output beyond that boundary is marked as truncated.
+
+Downloading asks which form to save. **Just notebook** writes cell sources,
+types, visibility, and layout without outputs or environment values. **Save
+progress** also writes retained cell outputs/results and the strict,
+pickle-free `InteractiveSession` snapshot containing the current KediEnv. It
+never includes Secret Manager or process environment values. Opening a progress
+file restores the Kedi session on the next execution. If any live value cannot
+be represented without changing its semantics, progress download is rejected
+instead of producing a partial snapshot.
+
+## Editing
+
+Kedi cells provide Tree-sitter highlighting, Kedi and embedded-Python
+completion, hover, references, rename, live diagnostics, signature help,
+definition navigation, and runtime error markers. Rename is limited to the
+active cell when its LSP context includes earlier executed cells, avoiding a
+silent partial edit. Monaco falls back to a plain multiline editor if its external assets
+cannot be loaded. Markdown cells safely render headings, paragraphs, lists,
+fenced code, blockquotes, emphasis, links, and separators; raw HTML is not
+executed.
+
+Use `Shift+Enter` to run the active cell, `Ctrl/Cmd+S` to download the notebook,
+`Ctrl/Cmd+Enter` to insert after the active cell, `Ctrl/Cmd+Shift+Enter` to
+append, `Ctrl/Cmd+Backspace` to delete, and `Ctrl/Cmd+ArrowUp/ArrowDown` to
+move a cell. Toolbar actions expose the same operations.
+
+Monaco is currently pinned on jsDelivr. Pyodide, its standard library, Micropip,
+and Pydantic are vendored in the notebook wheel, so browser Python can start
+without downloading its core runtime from a CDN. Packages installed later with
+Micropip may still need network access. Host execution remains usable through
+the fallback editor if Monaco is unavailable.

kedi_notebook-0.1.0/README.md

@@ -0,0 +1,153 @@
+# Kedi Notebook
+
+Kedi Notebook is the local, incremental notebook interface for the Kedi
+Programming Language. It provides editable Kedi, terminal, and Markdown cells,
+with either browser-owned Pyodide or a selected host Python interpreter.
+
+![Kedi Notebook running incremental Kedi cells](.github/assets/kedi-notebook.png)
+
+## Install and Run
+
+The notebook is currently distributed from a Kedi source checkout. Install its
+local dependencies and start it in one command from the Kedi repository root:
+
+```bash
+uv run --extra notebook kedi notebook
+```
+
+This uses the checked-out `notebook` submodule and Kedi source rather than a
+published package. For notebook development, run from the Kedi repository root
+with the notebook extra and development dependencies installed:
+
+```bash
+.venv/bin/python -m pytest notebook/tests
+```
+
+After syncing the extra, both entry points are equivalent:
+
+```bash
+kedi notebook
+kedi-notebook
+```
+
+The default address is <http://127.0.0.1:8788/notebook/>. Add one or more host
+Python installations explicitly when needed:
+
+```bash
+kedi-notebook --python /opt/homebrew/bin/python3.11
+kedi notebook --python ~/.pyenv/versions/3.12.4/bin/python --port 8899
+```
+
+Use `--host`, `--port`, `--cwd`, and `--no-open` to control local serving.
+Loopback serving requires no credentials. A non-loopback `--host` is rejected
+unless `--token` or `KEDI_NOTEBOOK_TOKEN` is set; the browser opened by the CLI
+receives that token without leaving it in the visible URL.
+
+At startup, the notebook server loads `.env` from `--cwd` without overriding
+variables already present in its process. Set `KEDI_ADAPTER_MODEL` there or use
+`> model:` in a Kedi cell before invoking a template. Calling `load_dotenv()`
+inside a host Python cell affects only that cell worker, not the server process
+that owns adapters; browser Python cannot read the host project's `.env`.
+
+When a native Pydantic AI model requires a missing provider SDK, the notebook
+installs only the provider group named by Pydantic AI, immediately before model
+construction. OpenRouter, for example, requests the `openai` group. Unused
+provider SDKs are not installed. Installation targets the notebook server's
+Python environment, keeps its existing package versions, and requires package
+index access on first use. It does not replay earlier statements in the cell.
+Provider credentials are still required. A dependency conflict or failed
+installation is shown as a cell error; specialized adapters retain their own
+installation requirements.
+
+The **Secret Manager** action in the top bar stores environment values outside
+the notebook at `~/.kedi/notebook/secrets.json`. Stored values take precedence
+over the server process and project `.env`, and the browser can list only their
+names, never their values. Add a single value or import an arbitrary `.env`
+path; relative paths resolve from `--cwd`. The store is atomically written with
+user-only file permissions and is never included in browser storage. Saving,
+importing, or deleting a value closes active sessions so the next cell starts a
+runtime with the new environment.
+
+## Runtime Model
+
+Browser mode starts one persistent Pyodide worker as the page loads. Host mode
+creates and reuses a project-specific virtual environment from the selected
+Python executable, installs Kedi into it, and starts one persistent worker from
+that environment. Kedi cells
+execute incrementally against that session; completed cells remain editable
+and rerunnable, and output is displayed under its source.
+The bundled `filesystem` module works in both modes: browser mode accesses the
+worker's temporary virtual filesystem, while host mode accesses the notebook
+working directory on disk.
+
+Every visible cell keeps its editor when focus moves elsewhere; inactive Kedi
+cells retain syntax highlighting and can be edited or run directly. The cell
+header can convert an individual cell between Kedi, Markdown, and Terminal.
+Cells never collapse implicitly. Use the eye control to hide a cell explicitly;
+the compact row remains available to show it again, and hidden state is saved
+in `.kedinb` documents and local drafts.
+
+Managed environments live under `~/.kedi/notebook/venvs` by default and have a
+stable `kedi-notebook-py...` name derived from the base interpreter and working
+directory. Set `KEDI_NOTEBOOK_ENV_HOME` to choose another root. The package
+action beside a host runtime lists installed packages and installs newline-
+separated requirement strings into the managed environment with streamed pip
+output. The environment and installed packages persist across notebook server
+runs while the directory remains available.
+
+Cells beginning with `!` are terminal cells. Host commands run in the notebook
+working directory, with `!python` and `!pip` bound to the managed environment.
+Browser mode supports `!pip install`, `!uv add`, `!pip list`, `!echo`, and
+`!pwd`. Terminal output streams into the active cell while it runs.
+
+Use the square interrupt action while a cell is running. Interrupting replaces
+the active Python worker, so the source remains rerunnable but live runtime
+state is deliberately discarded. It also cancels that session's in-flight
+Pydantic AI or LangChain model and async tool work, without cancelling another
+session. Cancellation does not roll back completed effects or forcibly stop
+arbitrary synchronous tool code running in a server thread.
+
+Embedded-Python bridge operations and terminal execution have 120-second
+timeouts; this is not a universal deadline for a complete model-backed cell.
+Package installation has a 10-minute limit. Idle sessions expire after 30 minutes.
+
+Notebook execution is non-transactional. Rerunning a cell is a new execution
+attempt against current state; it does not roll back previous side effects.
+Displayed cell numbers follow notebook order and remain unchanged across
+reruns. Adding, moving, or deleting cells recomputes affected positions.
+
+Notebook files are validated before they replace the current document. The UI
+warns before discarding unsaved changes and limits files to 5 MB, notebooks to
+1,000 cells, individual cell source to 1 MB, and retained inline output to
+200,000 characters. Output beyond that boundary is marked as truncated.
+
+Downloading asks which form to save. **Just notebook** writes cell sources,
+types, visibility, and layout without outputs or environment values. **Save
+progress** also writes retained cell outputs/results and the strict,
+pickle-free `InteractiveSession` snapshot containing the current KediEnv. It
+never includes Secret Manager or process environment values. Opening a progress
+file restores the Kedi session on the next execution. If any live value cannot
+be represented without changing its semantics, progress download is rejected
+instead of producing a partial snapshot.
+
+## Editing
+
+Kedi cells provide Tree-sitter highlighting, Kedi and embedded-Python
+completion, hover, references, rename, live diagnostics, signature help,
+definition navigation, and runtime error markers. Rename is limited to the
+active cell when its LSP context includes earlier executed cells, avoiding a
+silent partial edit. Monaco falls back to a plain multiline editor if its external assets
+cannot be loaded. Markdown cells safely render headings, paragraphs, lists,
+fenced code, blockquotes, emphasis, links, and separators; raw HTML is not
+executed.
+
+Use `Shift+Enter` to run the active cell, `Ctrl/Cmd+S` to download the notebook,
+`Ctrl/Cmd+Enter` to insert after the active cell, `Ctrl/Cmd+Shift+Enter` to
+append, `Ctrl/Cmd+Backspace` to delete, and `Ctrl/Cmd+ArrowUp/ArrowDown` to
+move a cell. Toolbar actions expose the same operations.
+
+Monaco is currently pinned on jsDelivr. Pyodide, its standard library, Micropip,
+and Pydantic are vendored in the notebook wheel, so browser Python can start
+without downloading its core runtime from a CDN. Packages installed later with
+Micropip may still need network access. Host execution remains usable through
+the fallback editor if Monaco is unavailable.

kedi_notebook-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["hatchling==1.33.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "kedi-notebook"
+version = "0.1.0"
+description = "Local interactive notebook for the Kedi Programming Language"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = [
+    "basedpyright>=1.40.2,<1.41",
+    "fastapi>=0.162.0,<0.163",
+    "kedi>=0.1.2,<0.2",
+    "python-dotenv>=1.2.4,<2",
+    "uvicorn>=0.54,<0.55",
+]
+
+[project.urls]
+Source = "https://github.com/kedi-lang/notebook"
+Tracker = "https://github.com/kedi-lang/notebook/issues"
+
+[project.scripts]
+kedi-notebook = "kedi_notebook.server:main"
+
+[dependency-groups]
+dev = [
+    "httpx==0.28.1",
+    "playwright==1.64.1",
+    "pytest==9.2.0",
+    "pytest-cov==7.1.0",
+    "ruff==0.17.4",
+]
+
+[tool.hatch.build]
+include = [
+    "src/kedi_notebook/**/*.py",
+    "src/kedi_notebook/static/**",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/kedi_notebook"]
+
+[tool.uv.sources]
+kedi = { path = "..", editable = true }
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.coverage.run]
+branch = true
+source = ["kedi_notebook"]
+
+[tool.coverage.report]
+show_missing = true

kedi_notebook-0.1.0/src/kedi_notebook/__init__.py

@@ -0,0 +1,15 @@
+"""Local interactive notebook support for Kedi."""
+
+from .runtime import (
+    HostPython,
+    NotebookSessionManager,
+    discover_host_pythons,
+)
+from .secrets import NotebookSecretStore
+
+__all__ = [
+    "HostPython",
+    "NotebookSecretStore",
+    "NotebookSessionManager",
+    "discover_host_pythons",
+]

kedi_notebook-0.1.0/src/kedi_notebook/__main__.py

@@ -0,0 +1,4 @@
+from .server import main
+
+if __name__ == "__main__":
+    main()

kedi_notebook-0.1.0/src/kedi_notebook/bridge.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import time
+from collections import deque
+from collections.abc import Iterator, Mapping
+from threading import Condition, Lock
+from typing import Any
+from uuid import uuid4
+
+_MAX_OUTPUT_CHARS = 200_000
+
+
+class BridgeCancelled(RuntimeError):
+    pass
+
+
+class BridgeRun:
+    def __init__(self, run_id: str) -> None:
+        self.run_id = run_id
+        self.condition = Condition()
+        self.pending: deque[dict[str, Any]] = deque()
+        self.waiting: set[str] = set()
+        self.responses: dict[str, dict[str, Any]] = {}
+        self.output_events: dict[str, deque[dict[str, str]]] = {}
+        self.output_sizes: dict[str, int] = {}
+        self.done = False
+        self.cancelled = False
+        self.updated_at = time.monotonic()
+
+    def request(self, payload: Mapping[str, Any], *, timeout: float) -> Mapping[str, Any]:
+        response: Mapping[str, Any] | None = None
+        for event in self.request_events(payload, timeout=timeout):
+            if event["type"] == "response":
+                response = event["response"]
+        if response is None:
+            raise RuntimeError("Playground bridge request returned no response")
+        return response
+
+    def request_events(
+        self,
+        payload: Mapping[str, Any],
+        *,
+        timeout: float,
+    ) -> Iterator[dict[str, Any]]:
+        request_id = uuid4().hex
+        request = {"id": request_id, **dict(payload)}
+        with self.condition:
+            self._assert_open()
+            self.pending.append(request)
+            self.waiting.add(request_id)
+            self.output_events[request_id] = deque()
+            self.output_sizes[request_id] = 0
+            self.updated_at = time.monotonic()
+            self.condition.notify_all()
+        deadline = time.monotonic() + timeout
+        completed = False
+        try:
+            while True:
+                with self.condition:
+                    while not self.output_events[request_id] and request_id not in self.responses:
+                        self._assert_open()
+                        remaining = deadline - time.monotonic()
+                        if remaining <= 0:
+                            raise TimeoutError("Timed out waiting for the browser model")
+                        self.condition.wait(timeout=min(remaining, 1))
+                    if self.output_events[request_id]:
+                        event: dict[str, Any] = self.output_events[request_id].popleft()
+                    else:
+                        event = {
+                            "type": "response",
+                            "response": self.responses.pop(request_id),
+                        }
+                        completed = True
+                yield event
+                if completed:
+                    return
+        finally:
+            with self.condition:
+                self.waiting.discard(request_id)
+                self.responses.pop(request_id, None)
+                self.output_events.pop(request_id, None)
+                self.output_sizes.pop(request_id, None)
+
+    def next_request(self, *, timeout: float) -> dict[str, Any] | None:
+        with self.condition:
+            deadline = time.monotonic() + timeout
+            while not self.pending and not self.done and not self.cancelled:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    break
+                self.condition.wait(timeout=min(remaining, 1))
+            self.updated_at = time.monotonic()
+            return self.pending.popleft() if self.pending else None
+
+    def submit_response(self, request_id: str, response: Mapping[str, Any]) -> None:
+        with self.condition:
+            if request_id not in self.waiting:
+                raise ValueError("Response does not belong to an active bridge request")
+            if request_id in self.responses:
+                raise ValueError("Duplicate bridge response")
+            self.responses[request_id] = dict(response)
+            self.updated_at = time.monotonic()
+            self.condition.notify_all()
+
+    def submit_output(self, request_id: str, *, stream: str, text: str) -> None:
+        with self.condition:
+            if request_id not in self.waiting:
+                raise ValueError("Output does not belong to an active bridge request")
+            if stream not in {"stdout", "stderr"}:
+                raise ValueError("Bridge output stream must be stdout or stderr")
+            if not text:
+                return
+            remaining = _MAX_OUTPUT_CHARS - self.output_sizes[request_id]
+            if remaining <= 0:
+                return
+            text = text[:remaining]
+            self.output_sizes[request_id] += len(text)
+            self.output_events[request_id].append(
+                {"type": "output", "stream": stream, "text": text}
+            )
+            self.updated_at = time.monotonic()
+            self.condition.notify_all()
+
+    def finish(self) -> None:
+        with self.condition:
+            self.done = True
+            self.updated_at = time.monotonic()
+            self.condition.notify_all()
+
+    def cancel(self) -> None:
+        with self.condition:
+            self.cancelled = True
+            self.updated_at = time.monotonic()
+            self.condition.notify_all()
+
+    def _assert_open(self) -> None:
+        if self.cancelled:
+            raise BridgeCancelled("Playground run was cancelled")
+        if self.done:
+            raise RuntimeError("Playground bridge run is already complete")
+
+
+class BridgeManager:
+    def __init__(self) -> None:
+        self._runs: dict[str, BridgeRun] = {}
+        self._lock = Lock()
+
+    def get_or_create(self, run_id: str) -> BridgeRun:
+        with self._lock:
+            run = self._runs.get(run_id)
+            if run is None:
+                run = BridgeRun(run_id)
+                self._runs[run_id] = run
+            return run
+
+    def cancel(self, run_id: str) -> None:
+        self.get_or_create(run_id).cancel()
+
+    def cleanup(self, *, max_age: float = 600) -> None:
+        cutoff = time.monotonic() - max_age
+        with self._lock:
+            stale = [
+                run_id
+                for run_id, run in self._runs.items()
+                if run.updated_at < cutoff and (run.done or run.cancelled)
+            ]
+            for run_id in stale:
+                del self._runs[run_id]
+
+
+__all__ = ["BridgeCancelled", "BridgeManager", "BridgeRun"]