tempest-core 0.1.0__tar.gz

tempest_core-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+
+jobs:
+  gate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+      - name: Set up Python
+        run: uv python install 3.11
+      - name: Install
+        run: uv pip install --system -e ".[dev]"
+      - name: Lint
+        run: |
+          ruff check .
+          ruff format --check .
+      - name: Type-check
+        run: mypy --strict tempest_core
+      - name: Test
+        run: pytest -q

tempest_core-0.1.0/.github/workflows/docs.yml

@@ -0,0 +1,59 @@
+name: Docs
+
+# Build the bilingual MkDocs site (PT-BR default + EN-US under /en/) and deploy
+# it to GitHub Pages. The strict build is the gate — any warning fails the job.
+
+on:
+  push:
+    branches: ["main"]
+    paths:
+      - "docs/**"
+      - "mkdocs.yml"
+      - "pyproject.toml"
+      - ".github/workflows/docs.yml"
+  pull_request:
+    paths:
+      - "docs/**"
+      - "mkdocs.yml"
+      - "pyproject.toml"
+      - ".github/workflows/docs.yml"
+  workflow_dispatch:
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+      - name: Set up Python
+        run: uv python install 3.11
+      - name: Install docs dependencies
+        run: uv pip install --system -e ".[docs]"
+      - name: Build (strict — the gate)
+        run: uv run mkdocs build --strict
+      - name: Upload Pages artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: site
+
+  deploy:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

tempest_core-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,43 @@
+name: Publish
+
+# Build the sdist + wheel and upload to PyPI when a version tag is pushed.
+# Uses PyPI Trusted Publishing (OIDC) — no API token stored in the repo.
+# Configure the publisher once at https://pypi.org/manage/account/publishing/
+# (project: tempest-core, workflow: publish.yml, environment: pypi).
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+      - name: Set up Python
+        run: uv python install 3.11
+      - name: Build sdist + wheel
+        run: uv build
+      - name: Check metadata
+        run: uvx twine check dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # required for Trusted Publishing (OIDC)
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

tempest_core-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+site/

tempest_core-0.1.0/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+All notable changes to **tempest-core** are documented here. Format follows
+[Keep a Changelog](https://keepachangelog.com/); this project adheres to semantic
+versioning.
+
+## [0.1.0] — 2026-06-11
+
+First public release. The renderer-agnostic UI core shared across the tempest
+stack — extracted so consumers depend on a published package instead of vendoring
+a copy.
+
+### Added
+
+- **IR + reconciler**: `build` / `diff` (and `build_scene` / `diff_scene` for the
+  overlay layer), the `Node` / `Patch` model, and `App` state with a coalesced
+  rebuild loop.
+- **Typed style model**: `Style`, `Color`, `Edge`, gradients, shadows, borders,
+  and transitions — no CSS cascade, inline-typed.
+- **Widgets & components**: layout (Column/Row/Container/Stack), text, button,
+  inputs, checkbox, lists (LazyColumn/Row/Grid), overlays, gestures, media, plus
+  the composed component set (cards, forms, fields, tables, BR inputs, …).
+- **Cross-cutting helpers**: animation, i18n (`translate`), navigation
+  (`Route`/`NavStack`/`routes_from_path`), theme, validators (CPF/CNPJ/email/
+  phone), icons, devices.
+- No platform-coupled code (no Qt, JNI, Android, or DOM) — imports cleanly under
+  CPython, Pyodide and a headless server. Only hard dependency: `pydantic>=2`.
+
+### Notes
+
+- Gate mirrors tempestroid: ruff (E/F/I/UP/B/Q/ANN/D + google docstrings),
+  pyright strict, pytest — all green.
+- Consumed by [`tempestweb`](https://pypi.org/project/tempestweb/); tempestroid's
+  own migration onto this package is in progress.

tempest_core-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: tempest-core
+Version: 0.1.0
+Summary: Renderer-agnostic UI core (IR, reconciler, state, style, widgets) shared by tempestroid and tempestweb.
+Author-email: Mauricio Benjamin <mauricio.benjamin@reloverelations.com>
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs-static-i18n>=1.2; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.25; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# tempest-core
+
+📚 **Documentation:** [Português (Brasil)](https://mauriciobenjamin700.github.io/tempest-core/)
+· [English (US)](https://mauriciobenjamin700.github.io/tempest-core/en/) — bilingual, on GitHub Pages.
+
+**Renderer-agnostic UI core** shared across the tempest stack — the engine behind
+both [tempestroid](https://github.com/mauriciobenjamin700/tempestroid) (native
+renderers: Qt / Compose / Android) and tempestweb (DOM, WASM + server modes).
+
+It is the *one tree, many renderers* core: the IR, the reconciler (`build` /
+`diff`), the state model (`App`), the typed style model (`Style`, `Color`, `Edge`),
+the widget and component trees, plus the cross-cutting helpers (animation, i18n,
+navigation, theme, validators). It carries **no platform-coupled code** — no Qt, no
+JNI, no Android, no DOM — so it imports cleanly under CPython, Pyodide and a
+headless server. Renderers live in the consumers; this package only produces and
+diffs the tree.
+
+```python
+from tempest_core import App, Column, Text, Button, Style, build, diff
+
+old = build(Column(children=[Text(content="Count: 0", key="label")]))
+new = build(Column(children=[Text(content="Count: 1", key="label")]))
+patches = diff(old, new)          # -> [Update(set_props={"content": "Count: 1"})]
+```
+
+## Install
+
+```bash
+pip install tempest-core
+```
+
+Requires Python `>=3.11`. Only hard dependency: `pydantic>=2`.
+
+## Status
+
+Extracted from tempestroid's vendored core. **tempestweb** consumes it directly
+(no vendored copy). tempestroid's own migration to depend on this package — with
+its full Qt↔Compose conformance suite green — is the next phase.
+
+## Develop
+
+```bash
+uv sync --extra dev
+ruff check . && ruff format --check .
+mypy tempest_core
+pytest -q
+```

tempest_core-0.1.0/README.md

@@ -0,0 +1,47 @@
+# tempest-core
+
+📚 **Documentation:** [Português (Brasil)](https://mauriciobenjamin700.github.io/tempest-core/)
+· [English (US)](https://mauriciobenjamin700.github.io/tempest-core/en/) — bilingual, on GitHub Pages.
+
+**Renderer-agnostic UI core** shared across the tempest stack — the engine behind
+both [tempestroid](https://github.com/mauriciobenjamin700/tempestroid) (native
+renderers: Qt / Compose / Android) and tempestweb (DOM, WASM + server modes).
+
+It is the *one tree, many renderers* core: the IR, the reconciler (`build` /
+`diff`), the state model (`App`), the typed style model (`Style`, `Color`, `Edge`),
+the widget and component trees, plus the cross-cutting helpers (animation, i18n,
+navigation, theme, validators). It carries **no platform-coupled code** — no Qt, no
+JNI, no Android, no DOM — so it imports cleanly under CPython, Pyodide and a
+headless server. Renderers live in the consumers; this package only produces and
+diffs the tree.
+
+```python
+from tempest_core import App, Column, Text, Button, Style, build, diff
+
+old = build(Column(children=[Text(content="Count: 0", key="label")]))
+new = build(Column(children=[Text(content="Count: 1", key="label")]))
+patches = diff(old, new)          # -> [Update(set_props={"content": "Count: 1"})]
+```
+
+## Install
+
+```bash
+pip install tempest-core
+```
+
+Requires Python `>=3.11`. Only hard dependency: `pydantic>=2`.
+
+## Status
+
+Extracted from tempestroid's vendored core. **tempestweb** consumes it directly
+(no vendored copy). tempestroid's own migration to depend on this package — with
+its full Qt↔Compose conformance suite green — is the next phase.
+
+## Develop
+
+```bash
+uv sync --extra dev
+ruff check . && ruff format --check .
+mypy tempest_core
+pytest -q
+```

tempest_core-0.1.0/docs/index.en.md

@@ -0,0 +1,38 @@
+# tempest-core
+
+**The renderer-agnostic UI core** — the engine behind
+[tempestroid](https://github.com/mauriciobenjamin700/tempestroid) (native
+renderers: Qt / Compose / Android) and tempestweb (DOM, WASM + server modes). 🌩️
+
+One tree, many renderers. You describe the UI as **typed Python** and the core
+produces an immutable tree (the IR) and computes the **diff** between two trees —
+renderers just apply the patches.
+
+```python
+from tempest_core import Column, Text, build, diff
+
+old = build(Column(children=[Text(content="Count: 0", key="label")]))
+new = build(Column(children=[Text(content="Count: 1", key="label")]))
+
+diff(old, new)
+# -> [Update(set_props={"content": "Count: 1"})]
+```
+
+## What's inside
+
+| Layer | What it does |
+|---|---|
+| **IR + reconciler** | `build` / `diff` (and `build_scene` / `diff_scene` for overlays), the `Node` / `Patch` model, and `App` with a coalesced rebuild loop |
+| **Typed style** | `Style`, `Color`, `Edge`, gradients, shadows, borders, transitions — no CSS cascade, inline and typed |
+| **Widgets & components** | layout (Column/Row/Container/Stack), text, button, inputs, checkbox, lists (LazyColumn/Row/Grid), overlays, gestures, media, + composed components (cards, forms, fields, tables, BR inputs…) |
+| **Cross-cutting** | animation, i18n, navigation (`Route`/`NavStack`), theme, validators (CPF/CNPJ/email/phone), icons |
+
+!!! tip "No platform-coupled code"
+    No Qt, JNI, Android or DOM here — the core imports cleanly under CPython,
+    Pyodide and a headless server. Only hard dependency: `pydantic>=2`.
+
+## Next steps
+
+- [Installation](installation.md) — `pip install tempest-core`.
+- [Tutorial](tutorial/index.md) — build and diff your first tree.
+- [API reference](reference.md) — the public symbols.

tempest_core-0.1.0/docs/index.md

@@ -0,0 +1,38 @@
+# tempest-core
+
+**O core de UI agnóstico de renderizador** — o motor por trás do
+[tempestroid](https://github.com/mauriciobenjamin700/tempestroid) (renderizadores
+nativos: Qt / Compose / Android) e do tempestweb (DOM, modos WASM + servidor). 🌩️
+
+Uma árvore, muitos renderizadores. Você descreve a UI como **Python tipado** e o
+core produz uma árvore imutável (a IR) e calcula o **diff** entre duas árvores —
+os renderizadores só aplicam os patches.
+
+```python
+from tempest_core import Column, Text, build, diff
+
+antiga = build(Column(children=[Text(content="Contagem: 0", key="label")]))
+nova = build(Column(children=[Text(content="Contagem: 1", key="label")]))
+
+diff(antiga, nova)
+# -> [Update(set_props={"content": "Contagem: 1"})]
+```
+
+## O que tem dentro
+
+| Camada | O que faz |
+|---|---|
+| **IR + reconciliador** | `build` / `diff` (e `build_scene` / `diff_scene` para overlays), o modelo `Node` / `Patch`, e o `App` com loop de rebuild coalescido |
+| **Estilo tipado** | `Style`, `Color`, `Edge`, gradientes, sombras, bordas, transições — sem cascata CSS, inline e tipado |
+| **Widgets & componentes** | layout (Column/Row/Container/Stack), texto, botão, inputs, checkbox, listas (LazyColumn/Row/Grid), overlays, gestos, mídia, + componentes compostos (cards, forms, campos, tabelas, inputs BR…) |
+| **Transversais** | animação, i18n, navegação (`Route`/`NavStack`), tema, validadores (CPF/CNPJ/email/telefone), ícones |
+
+!!! tip "Sem código acoplado a plataforma"
+    Nada de Qt, JNI, Android ou DOM aqui — o core importa limpo sob CPython,
+    Pyodide e um servidor headless. Única dependência dura: `pydantic>=2`.
+
+## Próximos passos
+
+- [Instalação](installation.md) — `pip install tempest-core`.
+- [Tutorial](tutorial/index.md) — construa e diffe sua primeira árvore.
+- [Referência da API](reference.md) — os símbolos públicos.

tempest_core-0.1.0/docs/installation.en.md

@@ -0,0 +1,32 @@
+# Installation
+
+```bash
+pip install tempest-core
+```
+
+Requires Python `>=3.11`. The only hard dependency is `pydantic>=2`.
+
+!!! note "Who uses tempest-core"
+    You rarely install `tempest-core` on its own — it comes as a dependency of
+    **tempestweb** (web) or **tempestroid** (native). But the core is standalone:
+    you can build and diff trees with no renderer at all.
+
+## Verify
+
+```bash
+python -c "from tempest_core import App, Column, Text, build, diff; print('OK')"
+```
+
+## Develop
+
+```bash
+uv sync --extra dev
+ruff check . && ruff format --check .
+pyright tempest_core
+pytest -q
+```
+
+## Recap
+
+- `pip install tempest-core` — Python 3.11+, only needs pydantic.
+- Import everything from the top level: `from tempest_core import …`.

tempest_core-0.1.0/docs/installation.md

@@ -0,0 +1,32 @@
+# Instalação
+
+```bash
+pip install tempest-core
+```
+
+Requer Python `>=3.11`. A única dependência dura é o `pydantic>=2`.
+
+!!! note "Quem usa o tempest-core"
+    Você raramente instala o `tempest-core` sozinho — ele vem como dependência do
+    **tempestweb** (web) ou do **tempestroid** (nativo). Mas o core é autônomo:
+    dá pra construir e diffar árvores sem nenhum renderizador.
+
+## Verificar
+
+```bash
+python -c "from tempest_core import App, Column, Text, build, diff; print('OK')"
+```
+
+## Desenvolvimento
+
+```bash
+uv sync --extra dev
+ruff check . && ruff format --check .
+pyright tempest_core
+pytest -q
+```
+
+## Recapitulando
+
+- `pip install tempest-core` — Python 3.11+, só precisa de pydantic.
+- Importe tudo do nível de topo: `from tempest_core import …`.

tempest_core-0.1.0/docs/reference.en.md

@@ -0,0 +1,9 @@
+# API reference
+
+The full, auto-generated API (docstrings are in English) lives on the shared
+reference page:
+
+[Open the API reference →](../reference/){ .md-button }
+
+It documents every public symbol of `tempest_core` — `App`, `build`, `diff`,
+`Style`, the widgets and the cross-cutting helpers.

tempest_core-0.1.0/docs/reference.md

@@ -0,0 +1,8 @@
+# Referência da API
+
+Os símbolos públicos do `tempest_core`, gerados a partir das docstrings.
+
+::: tempest_core
+    options:
+      show_root_heading: false
+      heading_level: 2

tempest_core-0.1.0/docs/tutorial/index.en.md

@@ -0,0 +1,54 @@
+# Tutorial — build & diff
+
+The heart of tempest-core is two functions: **`build`** turns a widget into an
+immutable tree (the IR), and **`diff`** compares two trees and returns the minimal
+list of **patches**. A renderer applies those patches; the core never touches
+pixels.
+
+## Build a tree
+
+```python
+from tempest_core import Column, Text, build
+
+tree = build(
+    Column(
+        children=[
+            Text(content="Hello", key="greeting"),  # (1)!
+        ],
+    )
+)
+print(tree.type)        # "Column"
+print(tree.children[0].props["content"])  # "Hello"
+```
+
+1. `key` is the node's stable identity — it's how the diff matches nodes across
+   rebuilds. Give a `key` to anything that can change position or content.
+
+`build` returns an immutable `Node`: `{type, key, props, children}`.
+
+## Diff two trees
+
+```python
+from tempest_core import Column, Text, build, diff
+
+a = build(Column(children=[Text(content="Hello", key="g")]))
+b = build(Column(children=[Text(content="Bye", key="g")]))
+
+patches = diff(a, b)
+print(patches[0].model_dump(mode="json"))
+# {"path": [0], "set_props": {"content": "Bye"}, "unset_props": []}
+```
+
+The diff is **keyed and minimal**: only what changed becomes a patch. The five
+kinds are `Update`, `Insert`, `Remove`, `Reorder` and `Replace`.
+
+!!! info "Why this matters"
+    The renderer gets only the delta — it never rebuilds the whole screen. Same
+    model as React, but the tree is typed Python, no JSX.
+
+## Recap
+
+- `build(widget) -> Node` — the immutable tree.
+- `diff(old, new) -> list[Patch]` — the minimal, keyed delta.
+- Give nodes a `key` so the diff matches correctly.
+- Next: [state and rebuilds](state.md).

tempest_core-0.1.0/docs/tutorial/index.md

@@ -0,0 +1,53 @@
+# Tutorial — build & diff
+
+O coração do tempest-core são duas funções: **`build`** transforma um widget numa
+árvore imutável (a IR), e **`diff`** compara duas árvores e devolve a lista mínima
+de **patches**. Um renderizador aplica esses patches; o core nunca toca em pixels.
+
+## Construir uma árvore
+
+```python
+from tempest_core import Column, Text, build
+
+árvore = build(
+    Column(
+        children=[
+            Text(content="Olá", key="saudacao"),  # (1)!
+        ],
+    )
+)
+print(árvore.type)        # "Column"
+print(árvore.children[0].props["content"])  # "Olá"
+```
+
+1. `key` é a identidade estável do nó — é por ela que o diff casa nós entre
+   rebuilds. Dê `key` a tudo que pode mudar de posição ou conteúdo.
+
+`build` devolve um `Node` imutável: `{type, key, props, children}`.
+
+## Diffar duas árvores
+
+```python
+from tempest_core import Column, Text, build, diff
+
+a = build(Column(children=[Text(content="Olá", key="s")]))
+b = build(Column(children=[Text(content="Tchau", key="s")]))
+
+patches = diff(a, b)
+print(patches[0].model_dump(mode="json"))
+# {"path": [0], "set_props": {"content": "Tchau"}, "unset_props": []}
+```
+
+O diff é **keyed e mínimo**: só o que mudou vira patch. Os cinco tipos são
+`Update`, `Insert`, `Remove`, `Reorder` e `Replace`.
+
+!!! info "Por que isso importa"
+    O renderizador recebe só o delta — não reconstrói a tela inteira. É o mesmo
+    modelo do React, mas a árvore é Python tipado, sem JSX.
+
+## Recapitulando
+
+- `build(widget) -> Node` — a árvore imutável.
+- `diff(antiga, nova) -> list[Patch]` — o delta mínimo, keyed.
+- Dê `key` aos nós para o diff casar corretamente.
+- Próximo: [estado e rebuilds](state.md).

tempest_core-0.1.0/docs/tutorial/state.en.md

@@ -0,0 +1,52 @@
+# 2. State and rebuilds
+
+A live UI = state + a function from state to tree. The **`App`** holds the state,
+runs your `view(app)`, and on a state change rebuilds and diffs — emitting patches
+through an `apply_patches` callback.
+
+```python
+from dataclasses import dataclass
+
+from tempest_core import App, Column, Text, Widget
+
+
+@dataclass
+class State:
+    value: int = 0
+
+
+emitted = []
+
+
+def view(app: App[State]) -> Widget:
+    return Column(children=[Text(content=f"Count: {app.state.value}", key="lbl")])
+
+
+app = App(state=State(), view=view, apply_patches=emitted.append)  # (1)!
+app.start()                                   # (2)!
+app.set_state(lambda s: setattr(s, "value", 1))  # (3)!
+```
+
+1. `apply_patches` receives each tick's patch list. A renderer applies it; here we
+   just collect.
+2. `start()` builds the initial scene.
+3. `set_state` mutates state and **schedules a coalesced rebuild** — several
+   changes in one tick become a single diff.
+
+!!! note "The view is pure"
+    `view()` only **reads** `app.state` and describes the UI. Changing state is the
+    handlers' job, via `set_state`. The view never mutates anything.
+
+## Navigation is state too
+
+The `App` owns a `NavStack` (`app.nav`): `push` / `pop` / `replace` / `reset`
+change the top route and schedule a rebuild — the `view` reads `app.nav.top` and
+draws the screen. No new IR node: changing routes is just the view producing a
+different tree.
+
+## Recap
+
+- `App(state, view, apply_patches)` + `start()` starts the UI.
+- `set_state(mutator)` schedules a coalesced rebuild → diff → patches.
+- `app.nav` (`push`/`pop`/`reset`) is navigation as state.
+- Next: [styling](style.md).

tempest_core-0.1.0/docs/tutorial/state.md

@@ -0,0 +1,51 @@
+# 2. Estado e rebuilds
+
+Uma UI viva = estado + uma função do estado para a árvore. O **`App`** segura o
+estado, roda sua `view(app)` e, quando o estado muda, reconstrói e diffa — emitindo
+patches por um callback `apply_patches`.
+
+```python
+from dataclasses import dataclass
+
+from tempest_core import App, Column, Text, Widget
+
+
+@dataclass
+class Estado:
+    valor: int = 0
+
+
+patches_emitidos = []
+
+
+def view(app: App[Estado]) -> Widget:
+    return Column(children=[Text(content=f"Contagem: {app.state.valor}", key="lbl")])
+
+
+app = App(state=Estado(), view=view, apply_patches=patches_emitidos.append)  # (1)!
+app.start()                                  # (2)!
+app.set_state(lambda s: setattr(s, "valor", 1))  # (3)!
+```
+
+1. `apply_patches` recebe a lista de patches de cada tick. Um renderizador a
+   aplica; aqui só guardamos.
+2. `start()` constrói a cena inicial.
+3. `set_state` muta o estado e **agenda um rebuild coalescido** — várias mudanças
+   no mesmo tick viram um único diff.
+
+!!! note "A view é pura"
+    `view()` só **lê** `app.state` e descreve a UI. Mudar estado é trabalho dos
+    handlers, via `set_state`. A view nunca muta nada.
+
+## Navegação também é estado
+
+O `App` tem uma `NavStack` (`app.nav`): `push` / `pop` / `replace` / `reset`
+mudam a rota no topo e agendam rebuild — a `view` lê `app.nav.top` e desenha a
+tela. Sem nó de IR novo: trocar de rota é a view produzindo uma árvore diferente.
+
+## Recapitulando
+
+- `App(state, view, apply_patches)` + `start()` inicia a UI.
+- `set_state(mutator)` agenda um rebuild coalescido → diff → patches.
+- `app.nav` (`push`/`pop`/`reset`) é navegação como estado.
+- Próximo: [estilo](style.md).