pyweb-stack 0.6.0__tar.gz → 0.6.2__tar.gz

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/CHANGELOG.md

@@ -6,6 +6,118 @@ project uses [semantic versioning](https://semver.org).
 
 ## [Unreleased]
 
+## [0.6.2]
+
+The dev loop. Saves update the open page in place with every page and
+component keeping its state, any element opens its own line in your
+editor, error pages fix themselves with AI (your assistant's model through
+MCP, or your own key), a timeline steps back through every change, and
+`pyweb dev --share` gives someone a link to try what you're building. All
+of it lives in `pyweb dev`: production output is unchanged and there is
+nothing to change in your apps. See [The dev loop](docs/35-dev-loop.md).
+
+### Added
+- **Hot reload without a page load.** A save swaps the page in place
+  through client navigation: no reload, no flash. Page variables,
+  component variables (each instance keeps its own), form fields, scroll,
+  focus and the selection stay. A stylesheet-only save swaps just that
+  stylesheet. When the page changed too much to swap, it reloads with the
+  same state, also after a compile error is fixed.
+- **Click to source.** Hold Alt to see where any element comes from;
+  Alt-click opens that line in your editor (`PYWEB_EDITOR`, else VS Code,
+  Cursor, Windsurf, Zed or Sublime Text, else a `vscode://` link) and
+  shows the **inspector**: the components around it with their live
+  variables, which you can edit.
+- **Fix with AI and Edit with AI.** Compile error pages and dev 500 pages
+  have Fix with AI; Alt+Shift-click any element to ask for a change. The
+  answer is a compiled diff of one app file: Apply writes it (refused if
+  the file changed since) and Undo puts it back (`.pyweb/history/`). It is
+  answered by the assistant connected through `pyweb mcp` when its app
+  supports MCP sampling, else `ANTHROPIC_API_KEY` or
+  `OPENAI_API_KEY`/`OPENAI_BASE_URL`, else the page offers the prompt to
+  copy. Credentials in what's sent are replaced by placeholders and put
+  back in the answer.
+- **Time-travel timeline.** The toolbar's Timeline tab records every change
+  to the page's variables with its cause (a click, typing, a server call);
+  a slider steps back through them with the page paused, and Resume
+  returns to now.
+- **`pyweb dev --share`**: a temporary public link (cloudflared, else
+  localhost.run) with a QR code. The link's token sets a cookie that every
+  request through the tunnel needs; guests get the app and hot reload, not
+  your tools.
+- **A better first five minutes.** `pyweb new` with no name asks for the
+  name, a starter and a colour preset (`--theme` without asking); `pyweb
+  dev` opens the browser, prints the network URL with a QR code for a phone
+  with `--host 0.0.0.0`, and shows a one-time Welcome panel with what to
+  try and how to connect your assistant.
+- **A faster first start.** Parse results and compiled code are cached on
+  disk (`~/.cache/pyweb`; `PYWEB_CACHE=0` turns it off): loading the saas
+  example in a fresh process went from about 340 to 210 ms.
+  `pyweb.bench --system` reports `cold_dev_ms`.
+- MCP: the `pyweb_assist_requests` tool and the `fix_errors` prompt;
+  `pyweb mcp` answers the page's AI requests through sampling.
+
+### Changed
+- `pyweb dev`'s toolbar and its `/__pyweb/dev/` endpoints answer only the
+  person running it: a request from this machine to a loopback address.
+  Visitors from the network (`--host 0.0.0.0`) or a share link get hot
+  reload only.
+- The runtime is 25 bytes bigger (gzip) for the dev hooks; nothing runs
+  in production.
+
+## [0.6.1]
+
+Better error messages, `pyweb doctor`, a `pyweb dev` that keeps your place
+when it reloads, much faster reloads and tests, and fixes found by
+installing 0.6.0 from PyPI and putting every template through every
+command. Nothing to change in your apps.
+
+### Added
+- **Better error messages.** Compile errors show the line with a caret under
+  the problem, suggest the name you meant (a prop, component, variable,
+  server function argument, kit variant or motion preset: "did you mean
+  'name'?"), and link the docs page that explains them. The CLI, the
+  `pyweb dev` overlay and the MCP tools (`frame`, `docs` fields) show the
+  same. When page code raises in `pyweb dev`, the error page starts with the
+  frames in your own files and their source lines.
+- **`pyweb dev` keeps your place when it reloads.** After a save, the page
+  comes back with its variables (a counter's count, a bound input's text),
+  unbound form fields, scroll position and focus as they were. A variable
+  whose type changed, or that was renamed, starts over; add `?fresh` to the
+  URL to start everything over. Production builds only grow by the names
+  of page variables.
+- **`pyweb doctor`** checks the project and the machine in one go: Python,
+  whether the app compiles, optional packages the app needs, the database
+  and pending migrations, Redis, secrets written in the source, changes
+  `pyweb upgrade` wants, a stale dev server link, tests, the port and the
+  editor extension, each with a fix (`--production` adds the production
+  settings, `--json` for CI). Assistants get it as the `pyweb_doctor` tool.
+- **Faster reloads and tests.** The UI kit is compiled once per process and
+  each file's Python code is reused until it changes: on the saas example a
+  `pyweb dev` reload after a save went from about 255 to 60 ms, a
+  `TestClient` from about 255 to 55 ms, and compiling from about 240 to
+  60 ms. The dev server notices a save within 0.1 s (was 0.4 s) and the
+  page asks for the new version every 0.25 s (was 0.6 s).
+  `python -m pyweb.bench --system` reports `reload_ms` and `test_client_ms`,
+  and CI's benchmark gate watches them.
+- `pyweb check` warns about kit props and motion values that won't work
+  (`<Button variant="outlin">`), as the editor already did.
+
+### Fixed
+- `pyweb check` printed the file and line twice for compile errors.
+- Components drawn as a kit button (`DialogClose`) were flagged by the
+  editor for `variant="default"`, which they support.
+- `pyweb test` with no path ran `pytest tests/`, which new apps don't have
+  (their test is `test_app.py` next to `app.pyweb`), so it failed in every
+  new project. It now runs the current folder, and accepts the app's
+  `.pyweb` file as well as a test file or folder.
+- The `pyweb_test` MCP tool given the app's `.pyweb` file (as every other
+  tool takes) found no tests; it now tests that file's folder.
+- `pyweb upgrade` says to apply pending migrations before creating the
+  `auth_sessions` one (on a fresh checkout `pyweb db diff` refused to run),
+  and notes that 0.6's `pyweb check` reports accessibility problems, which
+  `--strict` treats as failures.
+
 ## [0.6.0]
 
 Teams, installable and desktop apps, a UI kit and motion, and security by

{pyweb_stack-0.6.0/pyweb_stack.egg-info → pyweb_stack-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyweb-stack
-Version: 0.6.0
+Version: 0.6.2
 Summary: Full-stack web apps in one Python file: server-rendered pages, reactive browser UI, typed RPC.
 Author-email: MaanavKrishna <67054795+MaanavKrishna@users.noreply.github.com>
 Maintainer-email: MaanavKrishna <67054795+MaanavKrishna@users.noreply.github.com>
@@ -400,6 +400,17 @@ develop a toolbar on every page shows each request's queries and flags
 N+1 loops. [Scaling & deploying →](docs/25-scaling.md) ·
 [Logs, metrics & tracing →](docs/26-observability.md)
 
+### A dev loop that keeps up
+
+Save, and the open page changes in place: no reload, and every page and
+component keeps its state. Hold Alt and click any element to open its
+line in your editor; Alt+Shift-click to change it with AI, and error
+pages have **Fix with AI** (your assistant's model through MCP, or your
+own API key), with a diff to apply and Undo. The toolbar's timeline
+steps back through every change and what caused it, and
+`pyweb dev --share` gives someone a link to try what you're building.
+[The dev loop →](docs/35-dev-loop.md)
+
 ### Small, fast and boring to run
 
 - **Every page is server-rendered**: complete HTML on first paint, then
@@ -442,7 +453,7 @@ it runs the real PyWeb, server functions included, in your browser.
 pip install pyweb-stack
 pyweb new myapp --template saas      # saas | desktop | blank | counter | todo | blog | auth | chat | ai-chat
 cd myapp
-pyweb dev app.pyweb                  # edit app.pyweb; the page reloads on save
+pyweb dev app.pyweb                  # saves update the open page in place, state kept
 ```
 
 Then:
@@ -478,7 +489,7 @@ The [architecture overview](ARCHITECTURE.md) goes through each stage.
 
 ## Build it with AI
 
-PyWeb ships an MCP server with 29 tools, so AI assistants can do what
+PyWeb ships an MCP server with 31 tools, so AI assistants can do what
 you'd do: scaffold an app, search the docs, check each edit (errors come
 back as line numbers with fix hints), build with the UI kit and a theme,
 render pages and call server functions as any signed-in member, look at
@@ -566,7 +577,7 @@ Upgrade with `pip install -U pyweb-stack`.
 
 | Version | Highlights |
 |---|---|
-| 0.6 | Teams with roles, invitations and tenant-scoped Models (Postgres row-level security), API tokens and OpenAPI, webhooks, installable apps with Web Push, desktop windows and installers, a UI kit with themes and motion, Trusted Types, encrypted fields and a threat model, about 2.5× faster serving, Python 3.15 and free-threaded builds, a much richer MCP server |
+| 0.6 | Teams with roles, invitations and tenant-scoped Models (Postgres row-level security), API tokens and OpenAPI, webhooks, installable apps with Web Push, desktop windows and installers, a UI kit with themes and motion, Trusted Types, encrypted fields and a threat model, about 2.5× faster serving, Python 3.15 and free-threaded builds, a much richer MCP server; 0.6.1: error messages with code frames and suggestions, `pyweb doctor`, dev reloads that keep page state, 4× faster reloads and tests; 0.6.2: the dev loop (hot reload in place with component state, Alt-click to source, Fix/Edit with AI, a time-travel timeline, `pyweb dev --share`, a guided `pyweb new`) |
 | 0.5 | Models with migrations, forms, auth kit with passkeys, OAuth and an admin, row-level live updates over WebSockets on PyWeb's own server, durable jobs and schedules, `pyweb deploy` for docker, compose, k8s, fly, render and railway, logs, metrics, tracing and a dev toolbar, data-aware editor and MCP tools, the `saas` template, `pyweb upgrade` |
 | 0.4 | npm packages without Node, layouts and client-side navigation, streaming server functions and `<Markdown>` for AI apps, live queries, page head tags, `.pyweb` error pages; 0.4.1: richer MCP tools; 0.4.2: VS Code run, new-app and MCP commands; 0.4.3: fixes, security hardening, gzip and caching; 0.4.4: key rotation, session revocation, typed arguments, Redis-shared limits, `check --production` |
 | 0.3 | Hydration, live updates (SSE), multi-file apps, language server + VS Code extension, browser playground, faster rendering, screenshot/test MCP tools |

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/README.md

@@ -326,6 +326,17 @@ develop a toolbar on every page shows each request's queries and flags
 N+1 loops. [Scaling & deploying →](docs/25-scaling.md) ·
 [Logs, metrics & tracing →](docs/26-observability.md)
 
+### A dev loop that keeps up
+
+Save, and the open page changes in place: no reload, and every page and
+component keeps its state. Hold Alt and click any element to open its
+line in your editor; Alt+Shift-click to change it with AI, and error
+pages have **Fix with AI** (your assistant's model through MCP, or your
+own API key), with a diff to apply and Undo. The toolbar's timeline
+steps back through every change and what caused it, and
+`pyweb dev --share` gives someone a link to try what you're building.
+[The dev loop →](docs/35-dev-loop.md)
+
 ### Small, fast and boring to run
 
 - **Every page is server-rendered**: complete HTML on first paint, then
@@ -368,7 +379,7 @@ it runs the real PyWeb, server functions included, in your browser.
 pip install pyweb-stack
 pyweb new myapp --template saas      # saas | desktop | blank | counter | todo | blog | auth | chat | ai-chat
 cd myapp
-pyweb dev app.pyweb                  # edit app.pyweb; the page reloads on save
+pyweb dev app.pyweb                  # saves update the open page in place, state kept
 ```
 
 Then:
@@ -404,7 +415,7 @@ The [architecture overview](ARCHITECTURE.md) goes through each stage.
 
 ## Build it with AI
 
-PyWeb ships an MCP server with 29 tools, so AI assistants can do what
+PyWeb ships an MCP server with 31 tools, so AI assistants can do what
 you'd do: scaffold an app, search the docs, check each edit (errors come
 back as line numbers with fix hints), build with the UI kit and a theme,
 render pages and call server functions as any signed-in member, look at
@@ -492,7 +503,7 @@ Upgrade with `pip install -U pyweb-stack`.
 
 | Version | Highlights |
 |---|---|
-| 0.6 | Teams with roles, invitations and tenant-scoped Models (Postgres row-level security), API tokens and OpenAPI, webhooks, installable apps with Web Push, desktop windows and installers, a UI kit with themes and motion, Trusted Types, encrypted fields and a threat model, about 2.5× faster serving, Python 3.15 and free-threaded builds, a much richer MCP server |
+| 0.6 | Teams with roles, invitations and tenant-scoped Models (Postgres row-level security), API tokens and OpenAPI, webhooks, installable apps with Web Push, desktop windows and installers, a UI kit with themes and motion, Trusted Types, encrypted fields and a threat model, about 2.5× faster serving, Python 3.15 and free-threaded builds, a much richer MCP server; 0.6.1: error messages with code frames and suggestions, `pyweb doctor`, dev reloads that keep page state, 4× faster reloads and tests; 0.6.2: the dev loop (hot reload in place with component state, Alt-click to source, Fix/Edit with AI, a time-travel timeline, `pyweb dev --share`, a guided `pyweb new`) |
 | 0.5 | Models with migrations, forms, auth kit with passkeys, OAuth and an admin, row-level live updates over WebSockets on PyWeb's own server, durable jobs and schedules, `pyweb deploy` for docker, compose, k8s, fly, render and railway, logs, metrics, tracing and a dev toolbar, data-aware editor and MCP tools, the `saas` template, `pyweb upgrade` |
 | 0.4 | npm packages without Node, layouts and client-side navigation, streaming server functions and `<Markdown>` for AI apps, live queries, page head tags, `.pyweb` error pages; 0.4.1: richer MCP tools; 0.4.2: VS Code run, new-app and MCP commands; 0.4.3: fixes, security hardening, gzip and caching; 0.4.4: key rotation, session revocation, typed arguments, Redis-shared limits, `check --production` |
 | 0.3 | Hydration, live updates (SSE), multi-file apps, language server + VS Code extension, browser playground, faster rendering, screenshot/test MCP tools |

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/THREAT_MODEL.md

@@ -177,6 +177,21 @@ websites in the user's browser.
 | T | An assistant's "read-only" SQL changing data | One statement, write keywords refused (even in a CTE), a read-only transaction that is rolled back; secrets redacted | `test_dx_v5.py::test_mcp_data_tools` |
 | T | Malformed tool arguments reaching app code | Arguments are checked against each tool's schema before it runs | `test_mcp_v6.py::test_arguments_are_checked_before_the_tool_runs` |
 
+## 7d. The dev loop: sharing, AI help, open in editor
+
+`pyweb dev` only. Its tools change files, open programs and show request data, so they are for the
+person running it, on that machine: a request must come from a loopback address and name a loopback
+`Host` (a tunnel's or the LAN's requests don't), and writes must be same-origin.
+
+| | Threat | Mitigation | Proof |
+|---|---|---|---|
+| S | Someone who learns the `--share` address (or guesses the tunnel name) using the app | Every request through the tunnel needs a cookie (`HttpOnly`, `Secure`, `SameSite=Lax`) set by the printed link's random token; forged cookies are refused | `test_share.py::test_the_link_sets_a_cookie_and_nothing_else_gets_in`, `test_share.py::test_pyweb_dev_share_end_to_end` |
+| E/I | A share-link guest (or someone on the LAN) using the developer's tools: the toolbar's SQL and requests, the agent endpoints, AI fixes, opening files, saving the theme | Guests get the app and hot reload only; every `/__pyweb/dev/` endpoint but change polling answers 403 to them, and their pages carry no toolbar or tool scripts | `test_share.py::test_guests_get_the_app_and_hot_reload_only`, `test_share.py::test_you_still_get_everything_and_the_lan_gets_hot_reload`, `test_share.py::test_a_compile_error_page_for_guests_has_no_tools` |
+| T | A web page making "Fix with AI" or "Edit with AI" write to the app | Same-origin, loopback-only POSTs; the answer is compiled first, applied only on Apply, only to `.pyweb` files in the app, refused if the file changed since; the old version is kept for Undo | `test_assist.py::test_endpoints_refuse_other_sites_and_other_machines`, `test_assist.py::test_a_change_that_does_not_compile_is_refused`, `test_assist.py::test_apply_refuses_when_the_file_changed_since`, `test_assist.py::test_only_app_files_are_targets` |
+| I | Credentials in the app's source sent to a model | Known key formats and random-looking secret values are replaced by placeholders before sending and put back in the answer | `test_assist.py::test_secrets_are_replaced_before_sending_and_put_back`, `test_assist.py::test_the_connected_assistant_answers_through_mcp_sampling` |
+| E | Alt-click "open in editor" used to open arbitrary files or run commands | Only `.pyweb` files inside the app folder or the UI kit; the editor gets an argument list, never a shell; same-origin and loopback only | `test_devopen.py::test_only_app_and_kit_files_resolve`, `e2e/test_dev_inspect_browser.py::test_open_refuses_cross_site_and_outside_files` |
+| I | Dev-only markers or scripts in production pages | `data-pw-src` markers come from dev compiles only; the dev scripts are added by the dev server only | `test_devopen.py::test_other_builds_have_no_marks`, `test_trusted_types.py::test_dev_scripts_never_ship_in_built_pages` |
+
 ## 8. The release
 
 | | Threat | Mitigation | Proof |

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/docs/01-introduction.md

@@ -43,6 +43,10 @@ Around that core, PyWeb has what a product needs, in the same file:
   ([Installable apps](31-pwa-push.md), [Desktop apps](32-desktop.md))
 - **Webhooks and files**: signed webhooks in and out, and unused uploads
   cleaned up. ([Webhooks & files](33-webhooks-files.md))
+- **A dev loop that keeps up**: saves update the open page in place with
+  its state kept; Alt-click opens any element's source; Fix with AI and
+  Edit with AI; a time-travel timeline; `pyweb dev --share`.
+  ([The dev loop](35-dev-loop.md))
 - **Shipping**: `pyweb deploy` writes Docker, Compose, Kubernetes, Fly,
   Render or Railway files; logs, metrics and traces come built in.
   ([Scaling & deploying](25-scaling.md))

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/docs/02-quickstart.md

@@ -20,9 +20,14 @@ pip install "pyweb-stack[all]"     # optional: Postgres, MySQL, Redis, argon2, O
 ```bash
 pyweb new hello
 cd hello
-pyweb dev app.pyweb          # http://localhost:8000, reloads on save
+pyweb dev app.pyweb          # opens http://localhost:8000; saves update the page in place
 ```
 
+(`pyweb new` with no name asks for one, a starter and colours.) Save a
+change and the open page updates without losing its state; hold Alt and
+click anything to open its line in your editor. [The dev loop](35-dev-loop.md)
+has the rest: Fix with AI, time travel and sharing with `--share`.
+
 `pyweb new` writes `app.pyweb`, a starter test (`test_app.py`) and
 `AGENTS.md`/`CLAUDE.md` (instructions for AI coding agents). Add
 `--template saas` for a small product with teams, accounts, a database,
@@ -88,6 +93,12 @@ pyweb serve dist                               # production server with /healthz
 `dist/` contains your app source, static assets and a `Dockerfile`; see
 [Deployment](12-deployment.md).
 
+If something doesn't work and the error isn't clear, `pyweb doctor`
+checks the project and your machine (Python, the app, optional packages,
+the database and migrations, the port, your editor) and prints a fix for
+each problem; `pyweb doctor --production` also checks the production
+settings.
+
 ## Next
 
 The [tutorial](03-tutorial.md) builds a notes app with a database,
@@ -101,6 +112,7 @@ ships it. Then, depending on what you're building:
 - work that runs later or on a schedule: [Background jobs](24-jobs.md);
 - teams that share data: [Teams & organizations](30-teams.md);
 - components, a theme and animation: [UI kit & motion](34-ui-and-motion.md);
+- everything `pyweb dev` does for you: [The dev loop](35-dev-loop.md);
 - an app people install, or a desktop app: [Installable apps & push](31-pwa-push.md),
   [Desktop apps](32-desktop.md);
 - several pages with a shared header: [Layouts & navigation](19-layouts-navigation.md);

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/docs/14-cli.md

@@ -1,17 +1,30 @@
 # Command line
 
 ```text
-pyweb new NAME [--template T]        create NAME/ with app.pyweb, test_app.py, AGENTS.md, CLAUDE.md, static/;
+pyweb new [NAME] [--template T] [--theme PRESET]
+                                     create NAME/ with app.pyweb, test_app.py, AGENTS.md, CLAUDE.md, static/;
                                      T = blank | counter (default) | todo | blog | saas | auth | chat | ai-chat | desktop
-                                     (apps with a database also get migrations/0001_initial.py and a README)
-pyweb dev FILE [--port 8000] [--host 127.0.0.1] [--no-reload]
-                                     development server: recompile on save, live reload, error overlay,
-                                     the dev toolbar (requests, SQL, jobs, emails, theme and motion
-                                     editors), and background jobs in the same process; writes
+                                     (apps with a database also get migrations/0001_initial.py and a README);
+                                     PRESET = indigo | zinc | slate | rose | ocean | violet | emerald | amber
+                                     (written into App(theme=...)); with no NAME, in a terminal, it asks
+pyweb dev FILE [--port 8000] [--host 127.0.0.1] [--no-reload] [--no-open] [--share]
+                                     development server (see The dev loop): saves update the open page
+                                     in place, keeping page and component state (?fresh starts over);
+                                     Alt-click opens an element's line in your editor, Alt+Shift-click
+                                     changes it with AI, error pages have Fix with AI; the dev toolbar
+                                     (requests, SQL, jobs, emails, theme, motion, a time-travel timeline);
+                                     background jobs in the same process; opens the browser (not in CI,
+                                     over SSH or with --no-open); --host 0.0.0.0 prints the network URL
+                                     with a QR code; --share prints a temporary public link; writes
                                      .pyweb/dev.json so `pyweb mcp` can see its errors and logs
 pyweb check FILE [--production] [--strict]
                                      compile, security and accessibility checks; --production also checks
                                      the environment; --strict fails on warnings too
+pyweb doctor [FILE] [--production] [--json] [--port 8000]
+                                     is the project ready? Python, the app compiles, optional packages,
+                                     database and migrations, Redis, secrets in the source, upgrade
+                                     changes, a stale dev server link, tests, the port, the editor; a fix
+                                     for each problem (exit 1 on any failure; --json for CI)
 pyweb upgrade [FILE] [--fix]         what to change for this PyWeb version (file and line); --fix applies
                                      the safe rewrites
 pyweb inspect FILE [--security]      where every name runs and why; RPC table; findings
@@ -66,13 +79,39 @@ pyweb dts FILE.d.ts                  Python dataclasses from TypeScript declarat
 pyweb mcp                            MCP server over stdio for AI assistants (see AI assistants & MCP)
 pyweb mcp --http [--port 8765] [--token T]   the same over Streamable HTTP (127.0.0.1 only without a token)
 pyweb lsp                            language server over stdio for editors (see below)
-pyweb test [PATH]                    run pytest
+pyweb test [PATH]                    run pytest on PATH (a test file, a folder or app.pyweb's folder;
+                                     default: the current folder, where new apps keep test_app.py)
 pyweb fmt [PATH] / pyweb lint [PATH] run ruff format / ruff check (if installed)
 pyweb --version
 ```
 
 `python -m pyweb.cli ...` is equivalent to `pyweb ...`.
 
+## Error messages
+
+A compile error names the file and line, shows the line with a caret under
+the problem, suggests the name you probably meant, and links the docs page
+that explains it:
+
+```text
+error: app.pyweb:17: <Greeting> has no prop 'nme'; did you mean 'name'?
+
+  16 |         <h1>{count}</h1>
+> 17 |         <Greeting nme="x" />
+     |                   ^
+  18 |     </main>
+
+hint: Use one of the component's parameter names as the attribute.
+docs: https://maanavkrishna.github.io/PyWeb/language.html
+```
+
+The first line keeps the `file:line: message` shape, so editors and CI
+logs can jump to it. `pyweb check` also warns about kit props and motion
+values that won't work (`<Button variant="outlin">`). The `pyweb dev`
+overlay shows the same, and when page code raises, its error page starts
+with the frames in your own files and their source lines, before the full
+traceback.
+
 ## Exit codes
 
 `check` and `build` exit `1` on compile or security errors and `2` on

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/docs/16-limitations-roadmap.md

@@ -11,8 +11,9 @@ can decide up front whether they matter for your app.
 - **npm packages must ship ES modules.** CommonJS-only packages and
   packages built on Node.js modules can't run in the browser; see
   [npm packages](18-npm-packages.md).
-- **Dev reload is a full page reload.** State is not preserved across
-  edits.
+- **Time travel moves the page's state only.** The dev timeline puts the
+  page's and components' variables back; data on the server isn't
+  rolled back.
 - **SQLite is for one machine.** Several processes on one host share it
   fine, but more than one server needs Postgres or MySQL;
   `pyweb check --production` and `pyweb deploy` say so.
@@ -33,7 +34,13 @@ can decide up front whether they matter for your app.
   with Web Push, desktop windows and installers, a UI kit with themes and
   motion, Trusted Types, encrypted fields and a threat model, about 2.5×
   faster serving, Python 3.15 and free-threaded builds, and a much richer
-  MCP server.
+  MCP server. 0.6.1 added error messages with code frames and
+  suggestions, `pyweb doctor`, dev reloads that keep page state, and 4×
+  faster reloads and tests. 0.6.2 made the [dev loop](35-dev-loop.md):
+  saves update the page in place with component state kept, Alt-click
+  opens any element's source, Fix with AI and Edit with AI, a
+  time-travel timeline, `pyweb dev --share`, a faster first start and a
+  guided `pyweb new`.
 - **0.5**: production apps. Models with relations and migrations, forms
   checked in the browser and on the server, an auth kit (passwords,
   passkeys, emailed links, OAuth, two-step sign-in, an admin), row-level
@@ -64,7 +71,8 @@ Planned, roughly in order. Nothing here is promised for a date.
 1. **1.0**: the API, RPC protocol and CLI frozen under semantic versioning,
    after 0.6 has been used in production for a while.
 2. **File uploads from the playground and the admin.**
-3. **State-preserving hot reload** while developing.
+3. **Fix with AI in the editor**, from the same proposals the dev page
+   shows (diff, apply, undo), through the VS Code extension.
 
 Ideas, bug reports and pull requests are welcome; see
 [CONTRIBUTING.md](https://github.com/MaanavKrishna/PyWeb/blob/main/CONTRIBUTING.md).

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/docs/17-ai-assistants.md

@@ -70,7 +70,7 @@ tool runs. Slow tools (tests, screenshots, profiling) report progress.
 | `pyweb_guide` | The rules for writing `.pyweb` apps (or one section): what runs where, state, markup, components, server functions, the browser Python subset, and every common error with its fix. |
 | `pyweb_docs` | Searches the documentation (every page, the guide and the threat model) and returns the matching sections, or one whole page. For any "how do I..." question. |
 | `pyweb_new_app` | Creates an app from a template (`blank`, `counter`, `todo`, `blog`, `saas`, `auth`, `chat`, `ai-chat`, `desktop`) with `AGENTS.md`, `CLAUDE.md`, tests and a stylesheet; apps with a database also get their first migration. `saas` (teams, accounts, tenant Models, forms, live pages, jobs, webhooks, admin) is the best start for a product; `desktop` is a notes app for `pyweb desktop`. |
-| `pyweb_check` | Compiles the app and runs the security and accessibility checks. Returns `ok`, errors with `line`, `message` and a fix `hint`, plus pages (with their layouts, live-data variables and npm packages), signals, what's sent to the browser, JS size and the server functions. |
+| `pyweb_check` | Compiles the app and runs the security and accessibility checks. Returns `ok`, errors with `line`, `message`, a fix `hint`, a code `frame` and a `docs` link, plus pages (with their layouts, live-data variables and npm packages), signals, what's sent to the browser, JS size and the server functions. |
 | `pyweb_explain` | What your editor shows for a line: for each name, where it runs and why (or its signature or npm type), the problems on that line and, with `complete`, the completions at a column. |
 | `pyweb_inspect` | For every name: does it run in the browser or on the server, and why. |
 | `pyweb_compiled` | The JavaScript generated for a page, and its server-rendered HTML. |
@@ -106,7 +106,9 @@ tool runs. Slow tools (tests, screenshots, profiling) report progress.
 | Tool | What it does |
 |---|---|
 | `pyweb_dev` | Whether `pyweb dev` is running for this app: its URL, whether the app compiles right now (with the error and traceback), its pages and recent 500 errors. |
+| `pyweb_doctor` | Project health, as `pyweb doctor`: each check with `status` (ok, warn, fail), `detail` and a `fix`; `production=true` adds the production settings. |
 | `pyweb_logs` | The dev server's log lines (warnings, errors with tracebacks, slow queries, job failures); `since` returns only newer ones. |
+| `pyweb_assist_requests` | What the developer asked for from the page (Fix with AI on an error page, Alt+Shift-click → Edit with AI) while no AI was set up to answer: the file, the error or the element's line, and the instruction. |
 
 When `pyweb dev` starts, it writes `.pyweb/dev.json` next to the app: its
 address and a random token, readable only by you (the folder has its own
@@ -148,6 +150,7 @@ Prompts are step-by-step workflows that name the tools to use:
 | `design_pass` | Kit components, a theme and motion, reviewed in light, dark and on a phone. |
 | `fix_failing_test` | Reproduce, find the cause in the app, fix, re-run. |
 | `debug_page` | Errors, logs, requests and a profile for one page. |
+| `fix_errors` | Check, fix and test in a loop until the app compiles cleanly and the tests pass; first does what was asked from the page. |
 
 ### What a session looks like
 
@@ -171,6 +174,24 @@ Prompts are step-by-step workflows that name the tools to use:
    click around, the assistant reads the error with `pyweb_dev` and
    `pyweb_logs` and fixes it.
 
+### Fix with AI from the page (sampling)
+
+`pyweb dev` puts a **Fix with AI** button on error pages, and
+Alt+Shift-click asks for a change to any element (see
+[The dev loop](35-dev-loop.md#fix-with-ai-and-edit-with-ai)). When your
+assistant's app supports MCP **sampling** (the client lets a server ask
+its model a question, after you approve), `pyweb mcp` answers those
+requests with your assistant's own model: it notices the client offers
+sampling when it connects, finds the running `pyweb dev` through
+`.pyweb/dev.json`, and hands each request over. The page shows the
+answer as a diff to apply or discard. This works over stdio (`pyweb
+mcp`); set `PYWEB_APP` when the app file isn't `app.pyweb` in the folder
+the assistant starts in.
+
+Assistants without sampling see the same requests with
+`pyweb_assist_requests` and can do them with their own file tools; the
+`fix_errors` prompt starts there.
+
 `pyweb_render`, `pyweb_call`, `pyweb_screenshot`, `pyweb_review`,
 `pyweb_profile`, `pyweb_webhook_send`, `pyweb_jobs` and `pyweb_test` run
 your app's code, as `pyweb dev` or `pytest` would; `pyweb_packages`

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/docs/27-upgrading.md

@@ -19,6 +19,7 @@ pytest
 Apps that call `app.use_auth()` need the new `auth_sessions` table:
 
 ```bash
+pyweb db upgrade                        # apply any migrations still pending
 pyweb db diff --name auth_sessions
 pyweb db upgrade
 ```

{pyweb_stack-0.6.0 → pyweb_stack-0.6.2}/docs/29-performance.md

@@ -107,12 +107,22 @@ you use it in a browser.
 Profile against a copy of your real data. A page that's fast with ten
 rows can be slow with ten thousand.
 
+## Fast reloads and tests
+
+The UI kit is compiled once per process, and each `.pyweb` file's Python
+code is reused until the file changes. On the saas example that took a
+reload in `pyweb dev` from about 255 to 60 ms and creating a
+`TestClient` from about 255 to 55 ms; the dev server also notices a save
+within a tenth of a second. Compiled output is byte-for-byte what a fresh
+compile gives, and a test checks that.
+
 ## Benchmarks in CI
 
 `python -m pyweb.bench` reports compile time, shipped JavaScript and
 render time per page. `--system` measures the whole stack: requests per
 second over real sockets, a signed-in page with a database, start-up
-time, and live query hashing.
+time, live query hashing, and how long loading an app again takes (what
+`pyweb dev` does after a save, and what each `TestClient` does).
 
 PyWeb's CI runs `--compare` on every push and pull request. It checks out
 the commit before the change next to the new one and runs both five