golit 1.0.0__tar.gz

golit-1.0.0/.dockerignore

@@ -0,0 +1,15 @@
+# Keep the build context lean — the Dockerfile only needs pyproject/Cargo,
+# src/, python/, examples/, and README. Everything below is build output,
+# caches, or design assets the image doesn't use.
+.git
+target
+.venv
+golit_pages
+tests
+**/__pycache__
+*.pyc
+.pytest_cache
+.ruff_cache
+.mypy_cache
+*.whl
+.DS_Store

golit-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,58 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+# Cancel superseded runs on the same ref.
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  rust:
+    name: rust (fmt · clippy · test)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11" # pyo3 needs an interpreter to configure + link
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo fmt --all --check
+      - run: cargo clippy --all-targets -- -D warnings
+      - run: cargo test
+
+  python:
+    name: py${{ matrix.python-version }} (lint · type · test)
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - uses: astral-sh/setup-uv@v5
+      - name: Create the virtualenv
+        run: uv venv --python ${{ matrix.python-version }}
+      - name: Install tooling + dev deps
+        # uv pip install (never `uv sync`, which would prune the optional extras).
+        run: uv pip install maturin ruff mypy pytest pytest-asyncio httpx fakeredis
+      - name: Build the extension + install the test extras
+        # gis-terrain is omitted on purpose: WhiteboxTools downloads a binary at
+        # runtime, so its tests importorskip and skip cleanly here.
+        run: >
+          uv run maturin develop
+          -E sql,charts,gis,gis-vector-tiles,gis-raster,gis-tiles,gis-ee,vision,vision-cv,tables,redis
+      - name: Ruff
+        run: uv run ruff check .
+      - name: Mypy
+        run: uv run mypy
+      - name: Pytest
+        run: uv run pytest -q

golit-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,82 @@
+name: Release
+
+# Tagging v* builds the full wheel matrix + sdist and publishes to PyPI.
+#
+# One-time setup (no secrets needed — uses PyPI Trusted Publishing / OIDC):
+#   1. Create the project on PyPI (or let the first publish create it).
+#   2. PyPI → project → Publishing → add a GitHub Actions publisher:
+#        owner = Boadzie, repo = golit, workflow = release.yml, environment = pypi
+#   3. (Repo) Settings → Environments → create an environment named `pypi`.
+# Then: bump the version (pyproject.toml + Cargo.toml), tag `vX.Y.Z`, and push the tag.
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: read
+
+jobs:
+  wheels:
+    name: wheels (${{ matrix.platform.runner }} · ${{ matrix.platform.target }})
+    runs-on: ${{ matrix.platform.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - { runner: ubuntu-latest,  target: x86_64 }
+          - { runner: ubuntu-latest,  target: aarch64 }
+          - { runner: macos-14,       target: aarch64 } # Apple Silicon; Intel (macos-13/x86_64) dropped
+          - { runner: windows-latest, target: x64 }
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          args: --release --out dist
+          manylinux: auto # ignored off Linux; builds manylinux on Linux runners
+          sccache: "true"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.platform.runner }}-${{ matrix.platform.target }}
+          path: dist
+
+  sdist:
+    name: sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-sdist
+          path: dist
+
+  publish:
+    name: publish to PyPI + attach to the release
+    needs: [wheels, sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # PyPI Trusted Publishing (OIDC) — no API token in secrets
+      contents: write # attach the built artifacts to the GitHub Release
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          merge-multiple: true
+          path: dist
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+      - name: Attach artifacts to the GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/*

golit-1.0.0/.gitignore

@@ -0,0 +1,23 @@
+# Rust
+/target
+Cargo.lock
+
+# Python
+.venv/
+__pycache__/
+*.py[cod]
+*.so
+*.pyd
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Docs
+site/
+
+# Tooling
+.DS_Store
+golit_pages/

golit-1.0.0/.python-version

@@ -0,0 +1 @@
+3.11

golit-1.0.0/CHANGELOG.md

@@ -0,0 +1,75 @@
+# Changelog
+
+All notable changes to Golit are recorded here. The format follows
+[Keep a Changelog](https://keepachangelog.com/), and the project adheres to
+[Semantic Versioning](https://semver.org/).
+
+## [1.0.0] — 2026-06-06
+
+First stable release. Golit is a high-performance reactive **DAG** framework for Python —
+*reactive data apps that actually ship* — with a Rust kernel and a server-rendered HTMX
+transport, where update cost is proportional to the change, not the program.
+
+### Reactive core
+
+- Rust + PyO3 reactive kernel: dirty tracking, topological scheduling, memoized propagation.
+- `@app.source` / `@app.reactive` / `@app.view` — dependencies inferred from parameter names; a
+  node re-executes only when an upstream node or input changes, and unchanged outputs cascade
+  into memo hits (nothing on the wire).
+- Per-session state (worker-local Polars values) over a shared, immutable topology.
+- A larger app can be split across modules (one shared `App` instance + import-for-side-effects).
+
+### Inputs & components
+
+- Reactive input widgets: `slider`, `number`, `select`, `text`, `checkbox`, `upload`, `radio`,
+  `multiselect`, `switch`, `date`, `textarea`, `button`.
+- `golit.ui` — shadcn-styled, server-rendered builders: `card`, `columns`, `grid`, `tabs`,
+  `expander`, `accordion`, `divider`, `metric`, `scorecard`, `alert`, `badge`, `progress`,
+  `skeleton`, `spinner`, `table`, `markdown`, `code`, `json_view`, `heading`, `caption`.
+- Page layout (`golit.layout`): a sidebar/rows/tabs scaffold, validated at build time.
+
+### Rendering
+
+- A view may return a `str` (trusted markup), a Polars `DataFrame`, a DuckDB relation, a chart,
+  a map, a Great Tables `GT`, anything with `_repr_html_()`, a Matplotlib figure, or `bytes`.
+- Charts: Lets-Plot static SVG; interactive **Plotly / Altair / Bokeh / AnyChart** that hydrate
+  on load and across POST/SSE swaps; `chart_spec(lib, dict)` for the raw wire spec.
+- Tables: return a `great_tables` **`GT`** object and Golit auto-renders its self-contained HTML;
+  `ui.gt_theme` restyles it to match golit's surface. (`golit[tables]`)
+
+### Maps & GIS (`golit.gis`)
+
+- Native **MapLibre GL** maps from a GeoDataFrame; choropleths, tooltips, and DuckDB spatial SQL.
+- MVT **vector tiles** for large vector data; single-band, RGB-composite, and tiled-COG **raster**
+  maps; **WhiteboxTools** terrain analysis; **Google Earth Engine** overlays.
+
+### Realtime
+
+- **SSE** server-push channel with a pluggable pub/sub (in-memory single-node, **Redis** fleet).
+- **Live data sources** — `@app.poll(name, interval)`: external data that changes on its own (a
+  Google Sheet, an API) is fetched in the background and pushed on a content-hash change.
+- **WebSocket chat** — `@app.on_message` + `ui.chat`.
+- **Video** — server-side **MJPEG** streams (`@app.stream` + `ui.webcam`, with `shared=True`
+  fan-out) and **browser-camera** computer vision (`@app.on_frame` + `ui.camera`).
+- **Audio** — a microphone **recorder** (`@app.on_audio` + `ui.recorder`) with in-browser WAV
+  capture, inline playback, and download.
+
+### SQL
+
+- `golit.sql(query, **frames)` — in-process **DuckDB** SQL over Polars frames as a reactive node.
+  (`golit[sql]`)
+
+### Server, deployment & tooling
+
+- Litestar ASGI app via `create_app`; the `golit run app.py` CLI (uvicorn).
+- Horizontal scale: N single-worker instances behind a sticky load balancer + Redis fan-out, with
+  a `deploy/` compose stack and an automated, self-validating **cross-node fan-out verifier**.
+- Optional extras: `charts`, `sql`, `gis` / `gis-raster` / `gis-tiles` / `gis-terrain` /
+  `gis-ee` / `gis-vector-tiles`, `vision` / `vision-cv`, `tables`, `redis`.
+
+### Quality
+
+- 17 Rust + 209 Python tests; ruff + mypy clean; a benchmark harness (`bench/`) with measured
+  Golit-vs-Dash results.
+
+[1.0.0]: https://github.com/Boadzie/golit/releases/tag/v1.0.0

golit-1.0.0/Cargo.lock

@@ -0,0 +1,212 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "cc"
+version = "1.2.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "556e016178bb5662a08681bbe0f00f8e17631781a4dfc8c45e466e4b185ec27f"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "golit"
+version = "1.0.0"
+dependencies = [
+ "pyo3",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+dependencies = [
+ "once_cell",
+ "python3-dll-a",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "python3-dll-a"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d80ba7540edb18890d444c5aa8e1f1f99b1bdf26fb26ae383135325f4a36042b"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

golit-1.0.0/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "golit"
+version = "1.0.0"
+edition = "2021"
+description = "Reactive DAG kernel for Golit (dirty tracking, topological scheduling, propagation)."
+license = "Apache-2.0"
+readme = "README.md"
+
+[lib]
+name = "_golit"
+crate-type = ["cdylib", "rlib"]
+
+# NOTE: `extension-module` is intentionally NOT enabled here. maturin enables it
+# for wheel builds via [tool.maturin] features. Leaving it off lets `cargo test`
+# link libpython and run the kernel's unit tests without a wheel build.
+# `generate-import-lib` lets pyo3 synthesize the Windows python3.lib from the abi3
+# stable ABI, so Windows wheels cross-compile (cargo-xwin) without a Windows Python.
+# It's a no-op on non-Windows targets.
+[dependencies]
+pyo3 = { version = "0.23", features = ["abi3-py311", "generate-import-lib"] }
+
+[profile.release]
+lto = "thin"
+codegen-units = 1

golit-1.0.0/DEPLOYMENT.md

@@ -0,0 +1,163 @@
+# Deploying Golit
+
+Golit runs as a single process out of the box. This guide covers going wider:
+multiple workers and hosts, with the SSE push channel intact.
+
+## The one thing to understand: session state is worker-local
+
+Each client gets a server-side **session** — its own kernel graph and its current
+Polars values — kept in the worker's memory and keyed by the `golit_session`
+cookie. That locality is deliberate: it's what makes recompute cost track the
+*change*, not the program. Serializing DataFrames to a shared store on every
+interaction would throw that away.
+
+The consequence: a client's requests are cheapest when they reach the worker that
+already holds its session — the initial `GET /`, each `POST /node/...`, and the
+long-lived `GET /events` SSE stream. That's *session affinity* ("sticky sessions").
+It is the recommended default, but with Redis turned on it is no longer load-bearing
+for correctness: the **session store** persists each session's *input* state, so a
+request that lands on a worker without the live session **reconstructs** it from
+those inputs (replay + local recompute) instead of starting from defaults. Affinity
+then just keeps the in-memory session warm and avoids the same session diverging
+across two workers under round-robin.
+
+The second consequence: a server-side invalidation (a streaming source, a
+background job, a shared node) originates on one worker but must reach the worker
+holding each *affected* client's SSE connection. That's what **Redis pub/sub**
+provides — one `publish`, delivered to every worker.
+
+So horizontal scale is two pieces:
+
+| Piece | Mechanism | Without it |
+| --- | --- | --- |
+| Keep a client on one worker (recommended) | Load balancer, hashing the `golit_session` cookie | A re-routed client reconstructs from Redis-stored inputs (a cold recompute) — or, with no session store, re-renders from defaults |
+| Reach every worker on invalidation | `GOLIT_REDIS_URL` → `RedisPubSub` | SSE pushes only reach clients on the publishing worker |
+
+## Single node (default)
+
+```bash
+golit run examples/sales_explorer/app.py
+```
+
+One process, in-memory fan-out (`InMemoryPubSub`). Nothing else to configure.
+
+## Turning on Redis
+
+Set one environment variable; `create_app` selects **both** Redis backends
+automatically — `RedisPubSub` for invalidation fan-out and `RedisSessionStore` for
+durable input state (Redis is an optional dependency — install with the `redis`
+extra):
+
+```bash
+pip install "golit[redis]"
+export GOLIT_REDIS_URL=redis://localhost:6379
+golit run examples/sales_explorer/app.py
+```
+
+Programmatic override, if you'd rather not use the environment:
+
+```python
+from golit import create_app
+from golit.server import RedisPubSub, RedisSessionStore
+
+application = create_app(
+    app,
+    pubsub=RedisPubSub("redis://redis:6379"),
+    session_store=RedisSessionStore("redis://redis:6379"),
+)
+```
+
+## Horizontal scale: N instances behind a sticky load balancer
+
+The supported HA topology is **N single-worker instances**, each on its own
+port/container, behind a load balancer that pins clients by the session cookie,
+all sharing one Redis.
+
+> **Why not `uvicorn --workers N`?** uvicorn's workers share one socket with no
+> affinity — the kernel hands each connection to whichever worker is free, so a
+> client's `GET` and its `/events` stream can land on different workers, and
+> neither holds the other's session. `golit run --workers N` exists for
+> convenience and local testing and prints a warning; it is **not** the
+> production path because it can't provide affinity.
+
+### nginx
+
+Open-source nginx can hash on a cookie, which gives consistent per-session
+routing:
+
+```nginx
+upstream golit {
+    hash $cookie_golit_session consistent;   # sticky by Golit's session cookie
+    server app1:8000;
+    server app2:8000;
+    server app3:8000;
+}
+```
+
+The SSE stream also needs buffering off and a long read timeout. The full config
+is in [`deploy/nginx.conf`](deploy/nginx.conf).
+
+## Run the whole stack locally (podman or docker)
+
+[`deploy/`](deploy/) has a complete example: Redis + three single-worker replicas
++ the nginx sticky balancer.
+
+```bash
+# from the repo root
+podman compose -f deploy/docker-compose.yml up --build
+# open http://localhost:8000
+```
+
+- [`deploy/Dockerfile`](deploy/Dockerfile) — two-stage build: compile the Rust
+  kernel to an abi3 wheel, then install it (with the `redis` extra) into a slim
+  runtime.
+- [`deploy/docker-compose.yml`](deploy/docker-compose.yml) — `redis`, `app1/2/3`
+  (each `GOLIT_REDIS_URL=redis://redis:6379`), and `nginx` on port 8000.
+- [`deploy/nginx.conf`](deploy/nginx.conf) — the cookie-hash upstream.
+
+To prove affinity + fan-out: open the app, move the slider (the chart/KPI/table
+swap — that's the local worker), then have a background source publish an
+invalidation and watch it arrive over `/events` on the *other* replicas' clients.
+
+## Verify the fan-out (automated)
+
+[`deploy/verify_scaling.py`](deploy/verify_scaling.py) turns that manual check into a
+one-command, self-validating proof. It runs two single-worker nodes that share one Redis (the
+same fan-out path as two hosts: *publish → Redis → every worker's SSE*). Node **A** publishes a
+`clock` invalidation every second; node **B** does not — yet an SSE client on **B** receives
+the `node:clock` events, so they can only have crossed Redis from A. A built-in **control**
+re-runs both nodes with Redis off (isolated in-memory pub/sub) and asserts B sees *nothing*,
+proving Redis is load-bearing rather than some local artifact.
+
+```bash
+# a Redis to share (podman or docker)
+podman run -d --rm --name golit-redis -p 6379:6379 docker.io/library/redis:7-alpine
+
+GOLIT_REDIS_URL=redis://localhost:6379 python deploy/verify_scaling.py
+# -> with Redis    -> node B saw node:clock: True
+#    without Redis -> node B saw node:clock: False
+#    PASS: cross-node fan-out works, and only because of Redis
+
+podman rm -f golit-redis
+```
+
+Point `GOLIT_REDIS_URL` at a Redis the two processes can both reach and the same script proves
+the path across **separate hosts** unchanged. ([`deploy/scaling_demo/app.py`](deploy/scaling_demo/app.py)
+is the tiny clock app it drives.)
+
+## Operational notes
+
+- **Worker restart loses that worker's warm caches, not the session.** Without a
+  session store, clients re-render from defaults on the next `GET /`. With
+  `RedisSessionStore` the input state is durable, so the session reconstructs (from
+  inputs + a local recompute) on the next request to *any* worker. Either way, keep
+  `@app.source` functions cheap/idempotent — the initial render can run again.
+- **Redis never holds DataFrames.** Pub/sub carries small JSON (`node_id`,
+  `session`); the session store holds only each session's *input* map
+  (`{input_id: value}`). The derived frames stay worker-local — that's the thesis.
+- **Scaling Redis:** a single instance handles a large fan-out fine. Redis
+  pub/sub is at-most-once and not persisted — acceptable here because an
+  invalidation just asks a worker to recompute current state, which it can always
+  redo on the next interaction.
+- **Sizing:** memory is dominated by live session values (Polars frames × active
+  sessions). Scale replicas on memory, and front them with the sticky balancer.