code-sandboxes 1.9.36__tar.gz → 1.9.39__tar.gz

code_sandboxes-1.9.36/.github/workflows/build.yml → code_sandboxes-1.9.39/.github/workflows/build.yaml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       matrix:
         python-version: ['3.11', '3.12']
-    uses: ./.github/workflows/reusable-python.yml
+    uses: ./.github/workflows/reusable-python.yaml
     with:
       python-version: ${{ matrix.python-version }}
       install-extras: test,typing,datalayer

code_sandboxes-1.9.36/.github/workflows/py-code-style.yml → code_sandboxes-1.9.39/.github/workflows/py-code-style.yaml

@@ -13,8 +13,8 @@ on:
       - '.pre-commit-config.yaml'
       - 'ruff.toml'
       - '.ruff.toml'
-      - '.github/workflows/py-code-style.yml'
-      - '.github/workflows/reusable-python.yml'
+      - '.github/workflows/py-code-style.yaml'
+      - '.github/workflows/reusable-python.yaml'
   pull_request:
     branches:
       - main
@@ -27,8 +27,8 @@ on:
       - '.pre-commit-config.yaml'
       - 'ruff.toml'
       - '.ruff.toml'
-      - '.github/workflows/py-code-style.yml'
-      - '.github/workflows/reusable-python.yml'
+      - '.github/workflows/py-code-style.yaml'
+      - '.github/workflows/reusable-python.yaml'
   workflow_dispatch:
 
 concurrency:
@@ -37,7 +37,7 @@ concurrency:
 
 jobs:
   check-code-style:
-    uses: ./.github/workflows/reusable-python.yml
+    uses: ./.github/workflows/reusable-python.yaml
     with:
       python-version: '3.11'
       extra-packages: pre-commit

code_sandboxes-1.9.36/.github/workflows/py-tests.yml → code_sandboxes-1.9.39/.github/workflows/py-tests.yaml

@@ -11,8 +11,8 @@ on:
       - 'setup.py'
       - 'requirements*.txt'
       - '**/*.py'
-      - '.github/workflows/py-tests.yml'
-      - '.github/workflows/reusable-python.yml'
+      - '.github/workflows/py-tests.yaml'
+      - '.github/workflows/reusable-python.yaml'
   pull_request:
     branches:
       - main
@@ -23,8 +23,8 @@ on:
       - 'setup.py'
       - 'requirements*.txt'
       - '**/*.py'
-      - '.github/workflows/py-tests.yml'
-      - '.github/workflows/reusable-python.yml'
+      - '.github/workflows/py-tests.yaml'
+      - '.github/workflows/reusable-python.yaml'
 
   workflow_dispatch:
 
@@ -34,7 +34,7 @@ jobs:
       max-parallel: 1
       matrix:
         python-version: ['3.10', '3.11', '3.12', '3.13']
-    uses: ./.github/workflows/reusable-python.yml
+    uses: ./.github/workflows/reusable-python.yaml
     with:
       python-version: ${{ matrix.python-version }}
       install-extras: test,datalayer

code_sandboxes-1.9.36/.github/workflows/py-typing.yml → code_sandboxes-1.9.39/.github/workflows/py-typing.yaml

@@ -12,8 +12,8 @@ on:
       - 'setup.py'
       - 'mypy.ini'
       - '.mypy.ini'
-      - '.github/workflows/py-typing.yml'
-      - '.github/workflows/reusable-python.yml'
+      - '.github/workflows/py-typing.yaml'
+      - '.github/workflows/reusable-python.yaml'
   pull_request:
     branches:
       - main
@@ -25,8 +25,8 @@ on:
       - 'setup.py'
       - 'mypy.ini'
       - '.mypy.ini'
-      - '.github/workflows/py-typing.yml'
-      - '.github/workflows/reusable-python.yml'
+      - '.github/workflows/py-typing.yaml'
+      - '.github/workflows/reusable-python.yaml'
   workflow_dispatch:
 
 concurrency:
@@ -35,7 +35,7 @@ concurrency:
 
 jobs:
   type-check:
-    uses: ./.github/workflows/reusable-python.yml
+    uses: ./.github/workflows/reusable-python.yaml
     with:
       python-version: '3.12'
       install-extras: typing

code_sandboxes-1.9.39/.github/workflows/release.yaml

@@ -0,0 +1,105 @@
+# Copyright (c) 2023-2026 Datalayer, Inc.
+# Distributed under the terms of the BSD 3-Clause License.
+
+# Publishes the release a tag names to PyPI, with no stored token: PyPI
+# trusts this workflow file (OIDC trusted publishing, through the `pypi`
+# environment). The tag must name the version in code_sandboxes/__version__.py; a
+# version already published is skipped. See RELEASE.md.
+
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    outputs:
+      python: ${{ steps.plan.outputs.python }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Check the tag names the version the package carries
+        run: |
+          set -euo pipefail
+          tag="${GITHUB_REF_NAME#v}"
+          version="$(python -c "import re;print(re.search(r'__version__\s*=\s*[\"\']([^\"\']+)', open('code_sandboxes/__version__.py').read())[1])")"
+          echo "tag=$tag version=$version"
+          test "$tag" = "$version"
+
+      - name: Find whether it is published yet
+        id: plan
+        run: |
+          set -euo pipefail
+          version="${GITHUB_REF_NAME#v}"
+          status="$(curl -sL -o /dev/null -w '%{http_code}' "https://pypi.org/pypi/code-sandboxes/$version/json")"
+          if [ "$status" = "200" ]; then
+            echo "PyPI: code-sandboxes $version is already published, skipping"
+            echo "python=" >> "$GITHUB_OUTPUT"
+          else
+            echo "PyPI: code-sandboxes $version will be published"
+            echo "python=yes" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Build
+        if: steps.plan.outputs.python != ''
+        run: |
+          set -euo pipefail
+          python -m pip install --upgrade pip build
+          python -m build --sdist --wheel --outdir dist .
+          ls -la dist
+
+      - uses: actions/upload-artifact@v4
+        if: steps.plan.outputs.python != ''
+        with:
+          name: python
+          path: dist/*
+
+  pypi:
+    needs: build
+    if: needs.build.outputs.python != ''
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: python
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
+
+  release:
+    name: GitHub release
+    needs: [build, pypi]
+    if: always() && needs.build.result == 'success' && needs.pypi.result != 'failure'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Create the release with generated notes
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          gh release view "$GITHUB_REF_NAME" >/dev/null 2>&1 && exit 0
+          gh release create "$GITHUB_REF_NAME" --title "Release $version" --generate-notes \
+            --notes "- [PyPI code-sandboxes](https://pypi.org/project/code-sandboxes/$version/)"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{code_sandboxes-1.9.36 → code_sandboxes-1.9.39}/CHANGELOG.md

@@ -8,6 +8,49 @@
 
 ## Unreleased
 
+## 1.9.39
+
+- The GitHub workflow files are all `.yaml` now (`build`, `py-tests`,
+  `py-code-style`, `py-typing`, `reusable-python`, `environments-live`), the
+  spelling `release.yaml` already had; the reusable workflow's callers and
+  the contributing page follow.
+- **Marimo reactivity through the Jupyter-shaped API** (#37). `run_code`
+  names its cell through the execution context (`Context(id=...)`; the same
+  id replaces the cell) and the result says what happened: `cell_id`, and
+  `reactions` — every cell re-run because of it, each a `Reaction` with its
+  code and its own `ExecutionResult`. `CodeSandboxClient.execute`,
+  `execute_code` and `execute_code_streaming` take `cell_id`; a reply carries
+  the reactions under `marimo` with their own Jupyter-shaped outputs;
+  `execute_interactive` emits them after the cell's own, each message tagged
+  `metadata.marimo = {cell_id, reaction}`; the stream tags every event with
+  `marimo_cell_id`. The client passes `run_cell`, `register_cell`,
+  `remove_cell`, `plan`, `graph` and `cells` through to a reactive sandbox and
+  says so with `reactive`. The `marimo_reactions` extra attribute is replaced
+  by the typed `reactions` field. Nothing changes on the wire.
+
+## 1.9.38
+
+- **The environments line and main are one branch again**: everything
+  released from `feat/env-custom` as 1.9.13 through 1.9.37 (custom
+  environments: resolve, build, attest, sign, the egress proxy, conda
+  artifacts, the contract's working directory) is on `main`, rebased onto
+  the marimo sandbox. The `1.9.13` entry below is what PyPI's 1.9.13 shipped;
+  main's own "1.9.13: the marimo sandbox" never reached PyPI (the version was
+  taken) and is this release instead:
+- **`marimo` sandbox** (#34, #35): a Jupyter server sandbox whose kernel also
+  holds Marimo's dataflow graph. `run_cell(cell_id, code)` runs a cell, then
+  the cells that depend on what it defined, in dependency order; a failing
+  cell stops the reaction. `register_cell`, `remove_cell`, `plan`, `graph`
+  and `cells` expose the graph; `run_code` keeps working, each call a cell of
+  its own, with the re-run cell ids on the result as `marimo_reactions`. The
+  graph is Marimo's own (`marimo._runtime.dataflow`), installed into the
+  kernel by one execute request and asked over the Jupyter protocol; marimo
+  is pip-installed into a kernel that lacks it unless `install_marimo=False`.
+  `get_manager("marimo")` is the `jupyter-server` manager under the marimo
+  variant. The same helper source drives jupyter-react's `variant="marimo"`.
+- Releases are cut by a `v*` tag now (`.github/workflows/release.yaml`,
+  trusted publishing); see RELEASE.md.
+
 ## 1.9.18
 
 - **A lock no longer carries a wall clock, so the build cache can hit**
@@ -314,7 +357,7 @@
   that `stop()` skipped entirely, orphaned for good. Fixed identically in
   `daytona_sandbox.py`, `modal_sandbox.py` and `e2b_sandbox.py`.
 - **A nightly live matrix for the three managed builders**
-  (`.github/workflows/environments-live.yml`, PLAN_ENV.md E2-11). Builds a
+  (`.github/workflows/environments-live.yaml`, PLAN_ENV.md E2-11). Builds a
   real artifact on each real provider from a real, hash-verified lock,
   launches a sandbox from it, and runs the formal core tier — opening (or
   commenting on) an issue naming the provider and the check on a genuine

{code_sandboxes-1.9.36 → code_sandboxes-1.9.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code_sandboxes
-Version: 1.9.36
+Version: 1.9.39
 Project-URL: Home, https://github.com/datalayer/code-sandboxes
 Author-email: Datalayer <info@datalayer.io>
 License: BSD 3-Clause License
@@ -59,7 +59,7 @@ Requires-Dist: kaggle>=1.6; extra == 'all'
 Requires-Dist: modal>=1.5.2; extra == 'all'
 Requires-Dist: pydantic-monty; extra == 'all'
 Provides-Extra: bridge
-Requires-Dist: datalayer-core>=1.1.65; extra == 'bridge'
+Requires-Dist: datalayer-core>=1.2.12; extra == 'bridge'
 Requires-Dist: fusepy>=3.0; extra == 'bridge'
 Requires-Dist: websockets>=12; extra == 'bridge'
 Provides-Extra: cloudflare
@@ -67,7 +67,7 @@ Requires-Dist: httpx>=0.27; extra == 'cloudflare'
 Provides-Extra: coreweave
 Requires-Dist: cwsandbox>=1.6; extra == 'coreweave'
 Provides-Extra: datalayer
-Requires-Dist: agent-runtimes>=1.0.16; extra == 'datalayer'
+Requires-Dist: agent-runtimes>=1.3.13; extra == 'datalayer'
 Provides-Extra: daytona
 Requires-Dist: daytona>=0.205.1; extra == 'daytona'
 Provides-Extra: docker
@@ -127,6 +127,7 @@ Canonical variant names:
 - `google-colab`
 - `jupyter-server`
 - `kaggle`
+- `marimo`
 - `modal`
 - `monty`
 

{code_sandboxes-1.9.36 → code_sandboxes-1.9.39}/README.md

@@ -25,6 +25,7 @@ Canonical variant names:
 - `google-colab`
 - `jupyter-server`
 - `kaggle`
+- `marimo`
 - `modal`
 - `monty`
 

code_sandboxes-1.9.39/RELEASE.md

@@ -0,0 +1,35 @@
+<!--
+  ~ Copyright (c) 2023-2026 Datalayer, Inc.
+  ~
+  ~ BSD 3-Clause License
+-->
+
+# Making a release
+
+A tag releases `code-sandboxes` to PyPI, with no stored token: PyPI trusts
+`.github/workflows/release.yaml` through OIDC (trusted publishing, GitHub
+environment `pypi`). The version lives in `code_sandboxes/__version__.py`, which
+hatch reads too.
+
+## Steps
+
+1. Bump `__version__` on a branch and open a pull request.
+
+1. Merge, then tag the merge commit and push the tag:
+
+   ```bash
+   git checkout main && git pull
+   git tag vX.Y.Z
+   git push origin vX.Y.Z
+   ```
+
+1. The `Release` workflow checks that the tag names the version, builds the
+   wheel and the sdist, publishes them unless PyPI already has that version,
+   and creates a GitHub release with generated notes.
+
+## Trusted publishing
+
+PyPI project `code-sandboxes`: owner `datalayer`, repository `code-sandboxes`, workflow
+`release.yaml`, environment `pypi`. The registry matches the repository,
+the workflow filename and the environment exactly; renaming any of them
+means re-registering.

{code_sandboxes-1.9.36 → code_sandboxes-1.9.39}/code_sandboxes/__init__.py

@@ -14,6 +14,7 @@ sandboxes (in-process execution):
 Remote sandboxes (out-of-process execution via Jupyter kernel protocol):
     - DockerSandbox: Docker container based, good isolation
     - JupyterServerSandbox: Jupyter Server with persistent kernel state
+    - MarimoSandbox: a Jupyter Server kernel holding Marimo's reactive cell graph
     - DatalayerSandbox: Cloud-based Datalayer runtime, full isolation
     - GoogleColabSandbox: Google Colab runtime, connects to an assigned kernel
     - KaggleSandbox: Kaggle runtime, connects to an interactive notebook kernel
@@ -156,6 +157,8 @@ from .manage import (
     get_manager,
     manageable_variants,
 )
+from .marimo_cells import CellReply, CellsRun, MarimoCells
+from .marimo_sandbox import CellRun, MarimoRun, MarimoSandbox
 from .modal_sandbox import ModalSandbox
 from .models import (
     CodeError,
@@ -168,6 +171,7 @@ from .models import (
     MIMEType,
     OutputHandler,
     OutputMessage,
+    Reaction,
     ResourceConfig,
     Result,
     SandboxConfig,
@@ -202,6 +206,9 @@ __all__ = [
     "RUNTIMES_API_PREFIX",
     "BuildEntry",
     "BuiltArtifact",
+    "CellReply",
+    "CellRun",
+    "CellsRun",
     "CloudflareSandbox",
     "CodeError",
     "CodeExecutionOutcome",
@@ -240,6 +247,9 @@ __all__ = [
     "Logs",
     "MIMEType",
     "ManifestLocation",
+    "MarimoCells",
+    "MarimoRun",
+    "MarimoSandbox",
     "MaterializeEntry",
     "ModalSandbox",
     "MontySandbox",
@@ -248,6 +258,7 @@ __all__ = [
     "PreparedAttachment",
     "ProcessHandle",
     "ProviderRequirement",
+    "Reaction",
     "ResourceConfig",
     "Result",
     "Sandbox",

{code_sandboxes-1.9.36 → code_sandboxes-1.9.39}/code_sandboxes/__version__.py

@@ -3,4 +3,4 @@
 
 """Code Sandboxes."""
 
-__version__ = "1.9.36"
+__version__ = "1.9.39"

{code_sandboxes-1.9.36 → code_sandboxes-1.9.39}/code_sandboxes/base.py

@@ -534,6 +534,7 @@ class Sandbox(ABC):
                 - "eval": Simple Python exec() based, minimal isolation
                 - "docker": Docker container based (requires Docker)
                 - "jupyter-server": Jupyter Server with persistent kernel state
+                - "marimo": Jupyter Server whose kernel holds Marimo's reactive cell graph
                 - "datalayer": Cloud-based Datalayer runtime (default)
             config: Optional full configuration object (overrides individual params).
             timeout: Default timeout for code execution in seconds.
@@ -623,6 +624,10 @@ class Sandbox(ABC):
             from .jupyter_server_sandbox import JupyterServerSandbox
 
             sandbox = JupyterServerSandbox(config=config, **kwargs)
+        elif variant_value == "marimo":
+            from .marimo_sandbox import MarimoSandbox
+
+            sandbox = MarimoSandbox(config=config, **kwargs)
         elif variant_value == "datalayer":
             from .datalayer_sandbox import DatalayerSandbox
 
@@ -721,6 +726,10 @@ class Sandbox(ABC):
             from .jupyter_server_sandbox import JupyterServerSandbox
 
             return JupyterServerSandbox.list_environments()
+        if variant_value == "marimo":
+            from .marimo_sandbox import MarimoSandbox
+
+            return MarimoSandbox.list_environments()
         if variant_value == "monty":
             from .monty_sandbox import MontySandbox
 

{code_sandboxes-1.9.36 → code_sandboxes-1.9.39}/code_sandboxes/cli.py

@@ -41,6 +41,7 @@ _SUPPORTED_RUN_VARIANTS = frozenset(
         "google-colab",
         "jupyter-server",
         "kaggle",
+        "marimo",
         "modal",
         "monty",
     }

{code_sandboxes-1.9.36 → code_sandboxes-1.9.39}/code_sandboxes/client.py

@@ -60,6 +60,7 @@ from .contents import (
 from .filesystem import FileInfo, SandboxFilesystem
 from .models import (
     CodeError,
+    Context,
     ExecutionResult,
     OutputMessage,
     Result,
@@ -114,11 +115,32 @@ def execution_result_to_reply(execution: ExecutionResult) -> dict[str, Any]:
             }
         )
 
-    return {
+    reply: dict[str, Any] = {
         "execution_count": execution.execution_count,
         "outputs": outputs,
         "status": "ok" if execution.success else "error",
     }
+    if execution.cell_id is not None or execution.reactions:
+        # A reactive sandbox (Marimo): which cell this was, and what else
+        # ran because of it, each with its own Jupyter-shaped outputs — so a
+        # caller that only reads replies still sees every changed cell.
+        reply["marimo"] = {
+            "cell_id": execution.cell_id,
+            "reactions": [
+                {
+                    "cell_id": reaction.cell_id,
+                    "code": reaction.code,
+                    # The same predicate as the reply's own status: a reaction
+                    # that was interrupted, failed in the infrastructure or
+                    # exited non-zero is not "ok" either.
+                    "status": "ok" if reaction.result.success else "error",
+                    "execution_count": reaction.result.execution_count,
+                    "outputs": execution_result_to_reply(reaction.result)["outputs"],
+                }
+                for reaction in execution.reactions
+            ],
+        }
+    return reply
 
 
 @dataclass
@@ -405,19 +427,33 @@ class CodeSandboxClient:
         else:
             self.close()
 
+    def _cell_kwargs(self, cell_id: str | None) -> dict[str, Any]:
+        """The execution context that names a cell, only when one was named.
+
+        Passed as a keyword only then: a sandbox with no notion of cells —
+        every variant but Marimo, and any subclass someone wrote against the
+        older signatures — is called exactly as before.
+        """
+        return {"context": Context(id=cell_id)} if cell_id else {}
+
     def execute_code(
         self,
         code: str,
         language: str = "python",
         timeout: float | None = None,
         envs: dict[str, str] | None = None,
+        cell_id: str | None = None,
     ) -> CodeExecutionOutcome:
         """Execute code and return a normalized outcome.
 
-        The sandbox is started automatically if needed.
+        The sandbox is started automatically if needed. ``cell_id`` names the
+        cell on a reactive sandbox (Marimo): the same id again replaces the
+        cell, and the cells depending on it re-run.
         """
         self.start()
-        execution = self._sandbox.run_code(code, language=language, timeout=timeout, envs=envs)
+        execution = self._sandbox.run_code(
+            code, language=language, timeout=timeout, envs=envs, **self._cell_kwargs(cell_id)
+        )
         return CodeExecutionOutcome.from_execution_result(execution)
 
     def execute(
@@ -425,12 +461,17 @@ class CodeSandboxClient:
         code: str,
         silent: bool = False,
         timeout: float | None = None,
+        cell_id: str | None = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
-        """Execute code and return a backend-neutral Jupyter-shaped reply."""
+        """Execute code and return a backend-neutral Jupyter-shaped reply.
+
+        On a reactive sandbox the reply also carries ``marimo``: the cell this
+        ran as and the reactions, each with its own outputs.
+        """
         del silent, kwargs
         self.start()
-        execution = self._sandbox.run_code(code, timeout=timeout)
+        execution = self._sandbox.run_code(code, timeout=timeout, **self._cell_kwargs(cell_id))
         return execution_result_to_reply(execution)
 
     def execute_interactive(
@@ -457,21 +498,75 @@ class CodeSandboxClient:
         """
         reply = self.execute(code, silent=silent, timeout=timeout, **kwargs)
         if output_hook is not None:
-            for output in reply["outputs"]:
-                msg_type = output.get("output_type", "display_data")
-                output_hook(
-                    {
+            marimo = reply.get("marimo") or {}
+            # The cell's own outputs, then each reaction's: every message
+            # says which cell it belongs to, the way a kernel's IOPub
+            # messages carry their parent header.
+            batches = [(marimo.get("cell_id"), False, reply["outputs"])] + [
+                (reaction["cell_id"], True, reaction["outputs"])
+                for reaction in marimo.get("reactions", [])
+            ]
+            for cell_id, is_reaction, outputs in batches:
+                for output in outputs:
+                    msg_type = output.get("output_type", "display_data")
+                    message: dict[str, Any] = {
                         "header": {"msg_type": msg_type},
                         "msg_type": msg_type,
                         "content": output,
                     }
-                )
+                    if cell_id is not None:
+                        message["metadata"] = {
+                            "marimo": {"cell_id": cell_id, "reaction": is_reaction}
+                        }
+                    output_hook(message)
         reply["content"] = {
             "status": reply.get("status", "ok"),
             "execution_count": reply.get("execution_count"),
         }
         return reply
 
+    # -- reactivity (the Marimo variant) ------------------------------------
+
+    @property
+    def reactive(self) -> bool:
+        """Whether the sandbox keeps a cell graph and re-runs dependents."""
+        return hasattr(self._sandbox, "run_cell")
+
+    def _reactive_sandbox(self) -> Any:
+        if not self.reactive:
+            raise TypeError(
+                f"The {self.variant or 'current'} sandbox is not reactive; "
+                "cells and reactions are the marimo variant's."
+            )
+        self.start()
+        return self._sandbox
+
+    def run_cell(
+        self, cell_id: str, code: str, *, react: bool = True, timeout: float | None = None
+    ) -> Any:
+        """Run one named cell, then the cells that depend on it (`MarimoRun`)."""
+        return self._reactive_sandbox().run_cell(cell_id, code, react=react, timeout=timeout)
+
+    def register_cell(self, cell_id: str, code: str) -> dict[str, Any]:
+        """Put a cell in the graph without running it; answers its names."""
+        return self._reactive_sandbox().register_cell(cell_id, code)
+
+    def remove_cell(self, cell_id: str) -> None:
+        self._reactive_sandbox().remove_cell(cell_id)
+
+    def plan(self, cell_id: str) -> list[str]:
+        """The cells that re-run after `cell_id`, in dependency order."""
+        return self._reactive_sandbox().plan(cell_id)
+
+    def graph(self) -> dict[str, Any]:
+        """Every cell's names and neighbours, the conflicts and the cycles."""
+        return self._reactive_sandbox().graph()
+
+    @property
+    def cells(self) -> dict[str, str]:
+        """The registered cells' source, by id."""
+        return dict(self._reactive_sandbox().cells)
+
     def get_variable(self, name: str) -> Any:
         """Read a variable through the wrapped sandbox."""
         self.start()
@@ -546,18 +641,17 @@ class CodeSandboxClient:
         language: str = "python",
         timeout: float | None = None,
         envs: dict[str, str] | None = None,
+        cell_id: str | None = None,
     ) -> Iterator[StreamingItem]:
         """Execute code and stream output events.
 
         This is a thin variant-agnostic wrapper over
-        ``Sandbox.run_code_streaming``.
+        ``Sandbox.run_code_streaming``. On a reactive sandbox the reactions'
+        events follow the cell's own, each tagged with ``marimo_cell_id``.
         """
         self.start()
         yield from self._sandbox.run_code_streaming(
-            code,
-            language=language,
-            timeout=timeout,
-            envs=envs,
+            code, language=language, timeout=timeout, envs=envs, **self._cell_kwargs(cell_id)
         )
 
     async def execute_code_streaming_async(