@loadbare/app 0.18.2 → 0.19.1

package/docs/comparison.md

@@ -1,55 +1,106 @@
 # Loadbare/app and current front-end frameworks
 
-> LLM-authored, not yet revised by a person.  Drafted by Claude on
-> 2026-09-16 and brought up to date with the working tree that follows
-> `@loadbare/app` 0.9.0.  Statements about other frameworks are from general
-> knowledge of those projects as of 2026 and carry no per-claim sources.
+> LLM-authored.  Final revision by Claude 2026-10-09 against 
+> release 0.18.2, factual claims checked against code.
+> Statements about other frameworks are from LLM training set
+> memory as of 2026 and carry no per-claim sources.
+>
+> Reviewed by Ken Downs Oct 9, 2026, found to be consistent with
+> other documents and conclusions reached during development.  Will
+> be left as LLM-authored, as the style is straightforward and
+> mostly free of annoying LLM idioms.
 
 This document states how `@loadbare/app` differs from the frameworks and
 libraries most used for front-end development today.  It repeats material
-from [Theory](./theory.md), [TECHREF-1.0](./TECHREF-1.0.md) and
+from [Theory](./theory.md), the [Reference](./reference/overview.md) and
 [Prior art](./prior-art.md) so that it can be read on its own.  Where this document and
 [Theory](./theory.md) disagree, Theory is authoritative.
 
-Loadbare/app has not reached 1.0.  The [Blockers](./TECHREF-1.0.md#blockers)
-section of TECHREF-1.0 lists open decisions, and five of its sections are
-marked `UNEDITED`.  Anything below that describes Loadbare/app describes the
-code as it stands.
+Two kinds of difference run through it.  Most follow from Theory's three
+goals and the one decision that serves them.  Two are deliberate departures
+from HTML's own model, in navigation and on the wire, and are set out in
+[Departures](./departures.md).
+
+Loadbare/app has not reached 1.0.  Anything below that describes
+Loadbare/app describes the code as it stands.
 
 ## Contents
 
-1. [Summary](#summary)
-2. [The comparison set](#the-comparison-set)
-3. [Stated goals and scope](#stated-goals-and-scope)
-4. [Where state lives](#where-state-lives)
-5. [Rendering](#rendering)
-6. [Templates and markup](#templates-and-markup)
-7. [Components and widgets](#components-and-widgets)
-8. [Data on the wire](#data-on-the-wire)
-9. [Mutations, forms and request state](#mutations-forms-and-request-state)
-10. [Routing and navigation](#routing-and-navigation)
-11. [Build, tooling and checking](#build-tooling-and-checking)
-12. [CSS](#css)
-13. [The server](#the-server)
-14. [Performance profile](#performance-profile)
-15. [Surface area](#surface-area)
-16. [Accessibility](#accessibility)
-17. [Testing](#testing)
-18. [Release history and churn](#release-history-and-churn)
-19. [What Loadbare/app does not do](#what-loadbareapp-does-not-do)
-20. [Requirements and fit](#requirements-and-fit)
-21. [Appendix A: Matrix](#appendix-a-matrix)
-22. [Appendix B: One page, three ways](#appendix-b-one-page-three-ways)
-23. [Appendix C: Glossary of nearest equivalents](#appendix-c-glossary-of-nearest-equivalents)
+- [Loadbare/app and current front-end frameworks](#loadbareapp-and-current-front-end-frameworks)
+  - [Contents](#contents)
+  - [Summary](#summary)
+  - [The comparison set](#the-comparison-set)
+  - [Stated goals and scope](#stated-goals-and-scope)
+  - [Where state lives](#where-state-lives)
+    - [Loadbare/app](#loadbareapp)
+    - [Elsewhere](#elsewhere)
+  - [Rendering](#rendering)
+    - [Loadbare/app](#loadbareapp-1)
+    - [Elsewhere](#elsewhere-1)
+  - [Templates and markup](#templates-and-markup)
+    - [Loadbare/app](#loadbareapp-2)
+    - [Conditions](#conditions)
+  - [Components and widgets](#components-and-widgets)
+    - [Loadbare/app](#loadbareapp-3)
+    - [Using web components and other libraries](#using-web-components-and-other-libraries)
+    - [Elsewhere](#elsewhere-2)
+  - [Data on the wire](#data-on-the-wire)
+    - [Loadbare/app](#loadbareapp-4)
+    - [Elsewhere](#elsewhere-3)
+  - [Mutations, forms and request state](#mutations-forms-and-request-state)
+    - [Loadbare/app](#loadbareapp-5)
+    - [Elsewhere](#elsewhere-4)
+  - [Correctness](#correctness)
+    - [Loadbare/app](#loadbareapp-6)
+    - [Elsewhere](#elsewhere-5)
+  - [Routing and navigation](#routing-and-navigation)
+    - [Loadbare/app](#loadbareapp-7)
+    - [Elsewhere](#elsewhere-6)
+  - [Build, tooling and checking](#build-tooling-and-checking)
+    - [Loadbare/app](#loadbareapp-8)
+    - [Elsewhere](#elsewhere-7)
+  - [CSS](#css)
+    - [Loadbare/app](#loadbareapp-9)
+    - [Elsewhere](#elsewhere-8)
+  - [The server](#the-server)
+    - [Loadbare/app](#loadbareapp-10)
+    - [Elsewhere](#elsewhere-9)
+  - [Performance profile](#performance-profile)
+    - [Loadbare/app](#loadbareapp-11)
+    - [Elsewhere](#elsewhere-10)
+  - [Surface area](#surface-area)
+  - [Accessibility](#accessibility)
+    - [Loadbare/app](#loadbareapp-12)
+    - [Elsewhere](#elsewhere-11)
+  - [Testing](#testing)
+    - [Loadbare/app](#loadbareapp-13)
+    - [Elsewhere](#elsewhere-12)
+  - [Release history and churn](#release-history-and-churn)
+    - [Loadbare/app](#loadbareapp-14)
+    - [Elsewhere](#elsewhere-13)
+  - [What Loadbare/app does not do](#what-loadbareapp-does-not-do)
+    - [By decision](#by-decision)
+    - [Gaps and open items](#gaps-and-open-items)
+  - [Requirements and fit](#requirements-and-fit)
+  - [Appendix A: Matrix](#appendix-a-matrix)
+  - [Appendix B: One page, three ways](#appendix-b-one-page-three-ways)
+    - [Loadbare/app](#loadbareapp-15)
+    - [Next.js (App Router)](#nextjs-app-router)
+    - [htmx with Express](#htmx-with-express)
+  - [Appendix C: Glossary of nearest equivalents](#appendix-c-glossary-of-nearest-equivalents)
 
 ## Summary
 
-Loadbare/app is a framework for server-bound database applications.  The
-browser receives one HTML document containing every page as a `<template>`,
+Loadbare/app is a framework for server-bound database applications.  Its
+goals are correctness, performance and developer ergonomics, held at once:
+the screen shows what the database held at the last round trip, it gets
+there fast, and the correct, fast application is the easiest one to write.
+
+The browser receives one HTML document containing every page as a `<template>`,
 one script and one stylesheet.  After that, only JSON rows cross the wire.
 HTML attributes bind elements to named server queries, and one attribute,
 `lb-request`, turns a click, a change or a submit into a request.  The
-server answers every request with response items: one row, a set of rows,
+server answers every request it accepts with response items: one row, a set of rows,
 or a patch to a set of rows, each named by its query.  The browser-side
 runtime, called the hub, lands those values on the elements that name the
 query.
@@ -73,23 +124,28 @@ Blazor Server), Loadbare/app keeps no per-client process or component state
 on the server, and uses ordinary HTTP requests rather than a persistent
 connection.
 
-| Group                    | Rendering happens     | State lives                  | After first load, the wire carries |
-|--------------------------|-----------------------|------------------------------|------------------------------------|
-| Loadbare/app             | Build time, once      | Server database, and the DOM | JSON rows                          |
-| Client component         | Browser, on change    | Browser memory               | JSON (application-designed)        |
-| Meta-frameworks          | Server, then browser  | Server and browser memory    | JSON, RSC payloads, or HTML        |
-| Hypermedia               | Server, per request   | Server, and the DOM          | HTML                               |
-| Server-driven stateful   | Server, per event     | Server memory per client     | DOM diffs or HTML                  |
+Compared with all of them, Loadbare/app paints only what the server
+answered.  There is no optimistic update to roll back and no client cache to
+revalidate, and the framework, not the application, keeps a double click
+from becoming a double write.
+
+| Group                  | Rendering happens    | State lives                  | After first load, the wire carries |
+| ---------------------- | -------------------- | ---------------------------- | ---------------------------------- |
+| Loadbare/app           | Build time, once     | Server database, and the DOM | JSON rows                          |
+| Client component       | Browser, on change   | Browser memory               | JSON (application-designed)        |
+| Meta-frameworks        | Server, then browser | Server and browser memory    | JSON, RSC payloads, or HTML        |
+| Hypermedia             | Server, per request  | Server, and the DOM          | HTML                               |
+| Server-driven stateful | Server, per event    | Server memory per client     | DOM diffs or HTML                  |
 
 ## The comparison set
 
-| Group                    | Members                                          |
-|--------------------------|--------------------------------------------------|
-| Client component         | React, Vue, Angular, Svelte, Solid               |
-| Meta-frameworks          | Next.js, Nuxt, SvelteKit, React Router 7, Astro  |
-| Hypermedia               | htmx, Hotwire (Turbo and Stimulus), Unpoly       |
-| Server-driven stateful   | Phoenix LiveView, Laravel Livewire, Blazor Server|
-| Sprinkles and components | Alpine.js, Lit                                   |
+| Group                    | Members                                           |
+| ------------------------ | ------------------------------------------------- |
+| Client component         | React, Vue, Angular, Svelte, Solid                |
+| Meta-frameworks          | Next.js, Nuxt, SvelteKit, React Router 7, Astro   |
+| Hypermedia               | htmx, Hotwire (Turbo and Stimulus), Unpoly        |
+| Server-driven stateful   | Phoenix LiveView, Laravel Livewire, Blazor Server |
+| Sprinkles and components | Alpine.js, Lit                                    |
 
 React Router 7 is the continuation of Remix.  TanStack Query appears below
 where client-side server-state caching is discussed, because React
@@ -97,27 +153,35 @@ applications commonly pair it with a data API.
 
 ## Stated goals and scope
 
-Theory states two goals, in order.
-
-1. Performance.  A full round trip, from user action through durable
-   persistence to final paint, should complete in a median of 300ms.
-   Assuming roughly 200ms of wire time leaves 100ms for the database, the
-   application server and the browser together, so the framework's own
-   processing time in the browser and on the server should approach zero.
-2. Developer efficiency, defined as reducing accidental complexity (Brooks):
-   work demanded by the tools rather than by the problem.
-
-The scope follows from a hypothesis stated in Theory: in a data-oriented
-application, the set of DOM changes needed is closed and knowable, so a
-framework optimized for that set does not need the machinery required to
-support arbitrary DOM updates.
-
-Loadbare/app restricts itself to applications whose data can be sent as rows
-and sets of rows.  Theory states that the claims about accidental complexity
-are most likely to hold "when the existing stack can support an application
-that wants data to be rows and tables, or easily mapped into them and out of
-them, and the desired affordances can be easily mapped to the standard set of
-operations against that data."
+[Theory](./theory.md) states three goals, which must all hold at once.
+
+1. Correctness.  The screen has integrity with the database as of the last
+   round trip, a user's write reaches the database once, and a constraint
+   violation reaches the user intelligibly and in context.  Correctness by
+   construction is part of it: a solution that loses that integrity must be
+   hard to write.
+2. Performance.  A median round trip of 300ms from click to paint.
+   Allowing roughly 200ms for the wire leaves 100ms for the browser, the
+   application server and the database together, so the framework's own
+   share must be low double-digit milliseconds.  Theory treats performance
+   as an aspect of correctness from the user's side: a slow answer leaves
+   the user unsure whether what they see is true.
+3. Developer ergonomics.  The simplest way to write the application is the
+   one that is correct and fast, with little boilerplate.  Theory rules
+   out what it calls elegant abstractions: those whose appeal is their own
+   design rather than what they do for the user, which hide the platform
+   instead of mapping onto it and must be serviced forever.
+
+One decision serves all three: the framework speaks SQL and understands
+only two data shapes, a `row` and a set of `rows`, with insert, update and
+delete.  The vocabulary is SQL, HTML, and a few small named families every
+browser application needs, such as navigation and request status.
+
+Theory scopes out currency, the screen changing because of another user or
+another process, until it can be reconciled with correctness.
+
+Loadbare/app therefore fits applications whose data is rows, or is easily
+shaped into rows, and whose interactions map onto reading and writing them.
 
 Each of the other projects in the comparison set presents itself as a
 general-purpose tool for building web user interfaces, and none restricts the
@@ -138,13 +202,17 @@ observable, and no client cache that answers a request.
   the path, the page label and the query parms.
 - An element hidden by `lb-show` exists inside a `<template>` standing where
   it stood.
+- A form pointed at a row carries that row's key as `lb-key-value`, and a
+  row ticked by its `lb-select` checkbox carries `lb-row-selected`.
 - The hub keeps each query's last answer until the page changes, only to
   fill an element that names the query and arrives after it, such as a
-  picker in a new live row, and to place rows again when the user makes a
-  choice.  Nothing else is read from it in place of asking the server.
-- The hub keeps three pieces of state of its own: the name of the current
-  page, the user's choices for it, and, until an insert completes, the form
-  it gathered from.
+  picker in a new live row, to fill a form pointed at one of its rows, and
+  to place rows again when the user makes a choice.  Nothing else is read
+  from it in place of asking the server.
+- The hub keeps a little state of its own: the name of the current page,
+  the user's choices for it as the row of its query `lb-choices`, the live
+  row each form is pointed at, the refusals on show, and, until a request
+  completes, the form it gathered from.
 
 The server is the source of truth for everything else.  A query takes no
 argument from the browser; its only input is `ctx`, which the application
@@ -158,21 +226,21 @@ parm.
 
 ### Elsewhere
 
-| Project           | Where application state is kept                                                         |
-|-------------------|-----------------------------------------------------------------------------------------|
-| React             | Component state (`useState`, `useReducer`) in the component tree; context; external stores such as Redux or Zustand; server-state caches such as TanStack Query or SWR |
-| Vue               | Reactive proxies (`ref`, `reactive`); Pinia stores                                      |
-| Angular           | Signals, services provided through dependency injection, RxJS observables               |
-| Svelte            | Runes (`$state`, `$derived`); stores                                                    |
-| Solid             | Signals and stores                                                                      |
-| Next.js           | Server Components read data on the server; Client Components hold React state; the client router caches RSC payloads |
-| React Router 7    | Loader data held by the router in the browser; component state                          |
-| SvelteKit, Nuxt   | Load function or `useFetch` data held in the browser; component state                   |
-| htmx, Turbo       | The server, and the HTML currently in the DOM.  Turbo keeps a snapshot cache of visited pages for back navigation |
-| Phoenix LiveView  | Socket assigns in a server process per connected client                                 |
-| Livewire          | Component properties serialized into a snapshot in the page and sent back with each request |
-| Blazor Server     | Component state in server memory, per circuit                                           |
-| Alpine.js         | Reactive objects declared with `x-data`                                                 |
+| Project          | Where application state is kept                                                                                                                                        |
+| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| React            | Component state (`useState`, `useReducer`) in the component tree; context; external stores such as Redux or Zustand; server-state caches such as TanStack Query or SWR |
+| Vue              | Reactive proxies (`ref`, `reactive`); Pinia stores                                                                                                                     |
+| Angular          | Signals, services provided through dependency injection, RxJS observables                                                                                              |
+| Svelte           | Runes (`$state`, `$derived`); stores                                                                                                                                   |
+| Solid            | Signals and stores                                                                                                                                                     |
+| Next.js          | Server Components read data on the server; Client Components hold React state; the client router caches RSC payloads                                                   |
+| React Router 7   | Loader data held by the router in the browser; component state                                                                                                         |
+| SvelteKit, Nuxt  | Load function or `useFetch` data held in the browser; component state                                                                                                  |
+| htmx, Turbo      | The server, and the HTML currently in the DOM.  Turbo keeps a snapshot cache of visited pages for back navigation                                                      |
+| Phoenix LiveView | Socket assigns in a server process per connected client                                                                                                                |
+| Livewire         | Component properties serialized into a snapshot in the page and sent back with each request                                                                            |
+| Blazor Server    | Component state in server memory, per circuit                                                                                                                          |
+| Alpine.js        | Reactive objects declared with `x-data`                                                                                                                                |
 
 ## Rendering
 
@@ -185,25 +253,37 @@ browser parses that document once.
 
 At run time the hub performs a closed set of operations:
 
-| Trigger                    | Operation                                                                  |
-|----------------------------|----------------------------------------------------------------------------|
-| Navigation                 | Clone the page's `<template>` into `<main>`, land `lb-url`                 |
-| A value for a control      | Set `value`, and stamp `lb-column-value`                                   |
-| A value for another native element | Set `textContent`, and stamp `lb-column-value`                     |
-| A value for a custom element that is not a control | Stamp `lb-column-value`                            |
-| A `row` with no row template | Land it on the element itself, stamp `lb-key-value`                      |
-| A new key through a row template | Clone the row template, stamp `lb-row-live` and `lb-key-value`, fill it, insert it |
-| All rows                   | Place every row in the order given, remove rows whose keys did not arrive  |
-| A patch                    | Upsert the rows named, remove the keys named, leave other rows in place    |
-| After rows land            | Stamp `lb-query-row-count`                                                 |
-| An `lb-show` column        | Move the element into, or out of, a `<template lb-show>`                   |
-| A request starts or ends   | Set or remove `lb-request-pending` and `aria-busy`; set `lb-request-error` on failure |
-| An insert from a form succeeds | Reset the form                                                         |
+| Trigger                                              | Operation                                                                                                                                         |
+| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Navigation                                           | Clone the page's `<template>` into `<main>`, land `lb-url`, land `lb-choices` empty                                                               |
+| A value for a control                                | Set `value`, and stamp `lb-column-value`                                                                                                          |
+| A value for another native element                   | Set `textContent`, and stamp `lb-column-value`                                                                                                    |
+| A value for a custom element that is not a control   | Stamp `lb-column-value`                                                                                                                           |
+| A `row` with no row template                         | Land it on the element itself, stamp `lb-key-value`                                                                                               |
+| A `row` that is `null`                               | Land its columns as null and remove `lb-key-value`; under a row template, the row leaves                                                          |
+| A new key through a row template                     | Clone the row template, stamp `lb-row-live` and `lb-key-value`, fill it, insert it                                                                |
+| All rows                                             | Place every row by the query's order, or the user's; remove rows whose keys did not arrive                                                        |
+| A patch                                              | Upsert the rows named, remove the keys named, leave other rows in place                                                                           |
+| A group template                                     | Build a group where the order breaks, keep it while its run goes on, remove it with its last row                                                  |
+| An aggregate (`lb-count`, `lb-sum` and the rest)     | Set the element from the rows showing in its group, or in the whole list                                                                          |
+| A row changes, moves or leaves                       | Stamp `lb-row-created`, `lb-row-changed`, `lb-row-moved`, `lb-row-requested` or `lb-row-leaving`; remove a leaving row once its animations finish |
+| After rows land                                      | Stamp `lb-query-row-count`                                                                                                                        |
+| The user makes a choice                              | Land `lb-choices`, place and filter the rows already held again, tell the server                                                                  |
+| A row the user's filter does not pass                | Set `hidden` on it                                                                                                                                |
+| An `lb-show` column                                  | Move the element into, or out of, a `<template lb-show>`                                                                                          |
+| A `commandfor` button with `--lb-edit` or `--lb-new` | Fill the form from the held row, or empty it; stamp `lb-key-value` and `lb-row-editing`; open its `<dialog>`                                      |
+| An `lb-select` checkbox is ticked                    | Stamp `lb-row-selected` on its row                                                                                                                |
+| A request starts or ends                             | Set or remove `lb-request-pending` and `aria-busy`; set `lb-request-error` on failure, `lb-request-refused` and control validity on a refusal     |
+| An insert from a form succeeds                       | Reset the form                                                                                                                                    |
+| A request from a pointed form succeeds               | Let the form go: empty it, drop its key, close its `<dialog>`                                                                                     |
+| A page is entered and its queries have landed        | Focus the first element in `<main>` the user can operate                                                                                          |
+| The hub places or removes a custom element           | Call its `lbAttached` or `lbDetached`                                                                                                             |
 
 The hub finds targets with `querySelectorAll` on the attributes written in
 the HTML.  Each response item names its query, its kind and its key, so the
-markup names none of the three beyond the query.  No tree is compared with a previous tree.  A response names what
-changed, so the hub does not determine what changed.  Between interactions
+markup names none of the three beyond the query.  No tree is compared with a previous tree.  The hub matches
+rows by key, and compares a row's values with those it shows, to leave an
+unchanged row alone and stamp a changed one.  Between interactions
 the hub runs no timers, observers or polling loops.
 
 There is no server-side rendering and no hydration.  The server returns the
@@ -211,22 +291,22 @@ values its queries return, serialized as JSON.
 
 ### Elsewhere
 
-| Project          | How the DOM is produced and updated                                                   |
-|------------------|---------------------------------------------------------------------------------------|
-| React            | Components re-run on state change and return an element tree, which is reconciled against the previous tree; keys identify list items |
-| Vue              | Templates compile to render functions producing a virtual DOM; reactivity tracks which components depend on which state |
-| Angular          | Templates compile to instructions; change detection checks bindings, and signals mark views that need updating |
-| Svelte           | The compiler emits code that updates the DOM nodes bound to changed state             |
-| Solid            | JSX compiles to DOM creation code; components run once; signals update bound nodes   |
+| Project                                  | How the DOM is produced and updated                                                                                                                                     |
+| ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| React                                    | Components re-run on state change and return an element tree, which is reconciled against the previous tree; keys identify list items                                   |
+| Vue                                      | Templates compile to render functions producing a virtual DOM; reactivity tracks which components depend on which state                                                 |
+| Angular                                  | Templates compile to instructions; change detection checks bindings, and signals mark views that need updating                                                          |
+| Svelte                                   | The compiler emits code that updates the DOM nodes bound to changed state                                                                                               |
+| Solid                                    | JSX compiles to DOM creation code; components run once; signals update bound nodes                                                                                      |
 | Next.js, Nuxt, SvelteKit, React Router 7 | HTML is rendered on the server per request or at build time, then hydrated in the browser (in Next.js, the Client Components), after which the client framework renders |
-| Astro            | HTML rendered at build or request time; interactive islands are hydrated per `client:*` directive |
-| htmx             | The server renders HTML fragments per request; htmx swaps them into a target          |
-| Turbo            | The server renders pages; Turbo replaces the body, a `<turbo-frame>`, or applies Turbo Stream actions; page refreshes can morph |
-| Phoenix LiveView | The server re-renders changed parts of a template and sends diffs over a WebSocket; the client patches the DOM |
-| Livewire         | The server re-renders component HTML; the client morphs the DOM                       |
-| Blazor Server    | The server renders the component tree, computes a diff, and sends it over SignalR     |
-| Alpine.js        | Directives on server-rendered HTML update bound nodes from reactive data              |
-| Lit              | Tagged template literals update the dynamic parts of a template, by default inside a shadow root |
+| Astro                                    | HTML rendered at build or request time; interactive islands are hydrated per `client:*` directive                                                                       |
+| htmx                                     | The server renders HTML fragments per request; htmx swaps them into a target                                                                                            |
+| Turbo                                    | The server renders pages; Turbo replaces the body, a `<turbo-frame>`, or applies Turbo Stream actions; page refreshes can morph                                         |
+| Phoenix LiveView                         | The server re-renders changed parts of a template and sends diffs over a WebSocket; the client patches the DOM                                                          |
+| Livewire                                 | The server re-renders component HTML; the client morphs the DOM                                                                                                         |
+| Blazor Server                            | The server renders the component tree, computes a diff, and sends it over SignalR                                                                                       |
+| Alpine.js                                | Directives on server-rendered HTML update bound nodes from reactive data                                                                                                |
+| Lit                                      | Tagged template literals update the dynamic parts of a template, by default inside a shadow root                                                                        |
 
 ## Templates and markup
 
@@ -234,7 +314,8 @@ values its queries return, serialized as JSON.
 
 The HTML written in `.html` files is the HTML that ships, after expansion.
 Attribute values in the `lb-` namespace are names: a query name, a column
-name, or a request name.  No attribute value is an expression.
+name or a list of them, or a request name.  `lb-show` may write `!` before
+its column to reverse it.  No attribute value is an expression.
 
 There are two kinds of placeholder, and they run at different times.
 
@@ -242,20 +323,20 @@ There are two kinds of placeholder, and they run at different times.
   a whole attribute value or a whole text node.  The tag supplies it with an
   `exp-name` attribute.  An unsupplied placeholder with no default drops the
   attribute.  The value becomes permanent in the shipped HTML.
-- Run time.  Data lands through `lb-column`, `lb-query` with a row
-  `<template>`, and `lb-show`.  There is no run-time interpolation into
-  attribute values or text.
+- Run time.  Data lands through `lb-column`, the aggregate attributes,
+  `lb-query` with a row or group `<template>`, and `lb-show`.  There is no
+  run-time interpolation into attribute values or text.
 
 Interpolation inside a longer string, such as `title="Hello {{name}}"`, is
 listed as decided against in the [Roadmap](./roadmap.md#decided-against).
 
-| Task              | Loadbare/app                                  | React (JSX)                          | Vue                                  | Angular                               | Svelte                        | Alpine.js                                  |
-|-------------------|-----------------------------------------------|--------------------------------------|--------------------------------------|---------------------------------------|-------------------------------|--------------------------------------------|
-| Show a value      | `<span lb-column="name">`                     | `{row.name}`                         | `{{ row.name }}`                     | `{{ row.name }}`                      | `{row.name}`                  | `<span x-text="row.name">`                 |
-| Keyed list        | `<template>` inside `lb-query`, key from the server | `rows.map(r => <li key={r.id}>)`     | `<li v-for="r in rows" :key="r.id">` | `@for (r of rows; track r.id)`        | `{#each rows as r (r.id)}`    | `<template x-for="r in rows" :key="r.id">` |
-| Condition         | `lb-show="column"`                            | `{cond && <X />}`                    | `v-if`, `v-show`                     | `@if (cond) { }`                      | `{#if cond}`                  | `x-if`, `x-show`                           |
-| Expression in markup | Not supported                              | Any JavaScript expression            | JavaScript expressions               | Template expressions                  | JavaScript expressions        | JavaScript expressions                     |
-| Build-time constant | `exp-label="Name"` into `{{label}}`          | A prop                               | A prop                               | An input                              | A prop                        | Not applicable                             |
+| Task                 | Loadbare/app                                        | React (JSX)                      | Vue                                  | Angular                        | Svelte                     | Alpine.js                                  |
+| -------------------- | --------------------------------------------------- | -------------------------------- | ------------------------------------ | ------------------------------ | -------------------------- | ------------------------------------------ |
+| Show a value         | `<span lb-column="name">`                           | `{row.name}`                     | `{{ row.name }}`                     | `{{ row.name }}`               | `{row.name}`               | `<span x-text="row.name">`                 |
+| Keyed list           | `<template>` inside `lb-query`, key from the server | `rows.map(r => <li key={r.id}>)` | `<li v-for="r in rows" :key="r.id">` | `@for (r of rows; track r.id)` | `{#each rows as r (r.id)}` | `<template x-for="r in rows" :key="r.id">` |
+| Condition            | `lb-show="column"`                                  | `{cond && <X />}`                | `v-if`, `v-show`                     | `@if (cond) { }`               | `{#if cond}`               | `x-if`, `x-show`                           |
+| Expression in markup | Not supported                                       | Any JavaScript expression        | JavaScript expressions               | Template expressions           | JavaScript expressions     | JavaScript expressions                     |
+| Build-time constant  | `exp-label="Name"` into `{{label}}`                 | A prop                           | A prop                               | An input                       | A prop                     | Not applicable                             |
 
 In htmx and Turbo, markup for data is produced by whatever server template
 language the application uses.  LiveView uses HEEx, with `{@value}`
@@ -264,23 +345,24 @@ interpolation, `:for` and `:if`.
 ### Conditions
 
 `lb-show` names a column.  `null` and `false` are off; every other value is
-on, including the string `"false"`.  An element that is off is moved into a
+on, including the string `"false"`.  `lb-show="!column"` reverses it, so one
+column decides between two elements.  An element that is off is moved into a
 `<template lb-show="column">` standing where it stood, and moved back when the
 column turns on.  It is not rendered, focused, clicked, announced or gathered.
 Values keep landing inside the template, so the element returns current.  The
 builder ships every `lb-show` element already inside its template.
 
-| Framework                        | A false branch                                                        | State kept | Updated while hidden |
-|----------------------------------|-----------------------------------------------------------------------|------------|----------------------|
-| Loadbare/app `lb-show`           | Moved into a `<template>` in place                                    | yes        | yes                  |
-| Alpine `<template x-if>`         | Destroyed and removed; recloned on show                               | no         | no                   |
-| Knockout `if`                    | Contents re-rendered on show                                          | no         | no                   |
-| Angular `@if` / `*ngIf`          | View destroyed unless detached and reinserted by hand                 | if detached | no                  |
-| Aurelia `if.bind`                | Removed; views cached and reused by default                           | yes        | not documented       |
-| Vue `v-if` in `<KeepAlive>`      | Detached, not unmounted                                               | yes        | no                   |
-| Lit `cache()`                    | DOM kept in a `DocumentFragment`                                      | yes        | on swap-in           |
-| Polymer `dom-if`                 | `display: none`                                                       | yes        | yes                  |
-| React `<Activity mode="hidden">` | `display: none`, Effects destroyed                                    | yes        | yes, at lower priority |
+| Framework                        | A false branch                                        | State kept  | Updated while hidden   |
+| -------------------------------- | ----------------------------------------------------- | ----------- | ---------------------- |
+| Loadbare/app `lb-show`           | Moved into a `<template>` in place                    | yes         | yes                    |
+| Alpine `<template x-if>`         | Destroyed and removed; recloned on show               | no          | no                     |
+| Knockout `if`                    | Contents re-rendered on show                          | no          | no                     |
+| Angular `@if` / `*ngIf`          | View destroyed unless detached and reinserted by hand | if detached | no                     |
+| Aurelia `if.bind`                | Removed; views cached and reused by default           | yes         | not documented         |
+| Vue `v-if` in `<KeepAlive>`      | Detached, not unmounted                               | yes         | no                     |
+| Lit `cache()`                    | DOM kept in a `DocumentFragment`                      | yes         | on swap-in             |
+| Polymer `dom-if`                 | `display: none`                                       | yes         | yes                    |
+| React `<Activity mode="hidden">` | `display: none`, Effects destroyed                    | yes         | yes, at lower priority |
 
 Sources for the rows other than Loadbare/app are in
 [Prior art](./prior-art.md#conditional-rendering-elsewhere).
@@ -295,10 +377,10 @@ reference directs it to `<details>`, a stylesheet, or a widget.
 A widget is a custom element defined by one or two files sharing its tag
 name, found by the builder anywhere in the source tree:
 
-| File                    | Holds                                               |
-|-------------------------|-----------------------------------------------------|
-| `<tag-name>.html`       | Markup the tag expands into, at build time          |
-| `<tag-name>.browser.ts` | A class registered with `customElements.define`     |
+| File                    | Holds                                           |
+| ----------------------- | ----------------------------------------------- |
+| `<tag-name>.html`       | Markup the tag expands into, at build time      |
+| `<tag-name>.browser.ts` | A class registered with `customElements.define` |
 
 A tag with neither file is a build error.  A module named `<tag-name>.ts`
 without `.browser` is not bundled, and the build error names it.
@@ -322,17 +404,23 @@ without `.browser` is not bundled, and the build error names it.
   where the element sits.  An ancestor may stop the event.
 - A custom element hears the hub's lifecycle rather than the browser's:
   `lbAttached()` and `lbDetached()` once each, when the hub places and
-  removes it, `lbRowsLanded()` once rows land on it, and `lbRequestDone()`
-  when a request from inside it finishes.  The hub does the cloning,
-  matching, ordering, grouping, removal and counting.
-- Method names beginning with `lb` on a custom element are reserved.
+  removes it, `lbRowsLanded()` once rows land on it, and
+  `lbRequestDone(detail, origin)` when a request from it or from inside it
+  finishes.  The hub also dispatches a bubbling `lb-request-done` event from
+  the element that committed.  The hub does the cloning, matching, ordering,
+  filtering, grouping, removal and counting.
+- Method names beginning with `lb` on a custom element are reserved.  The
+  build refuses a script that declares one Loadbare does not call, or
+  declares `connectedCallback`, `disconnectedCallback`, `adoptedCallback` or
+  `connectedMoveCallback`.
 
 Widget libraries are npm packages listed in `imports.ts`.  The builder scans
 each listed package for `<tag>.html` and `<tag>.browser.js` files, in the
 directory named by `loadbare.widgets` in its `package.json`, or the whole
 package when that key is absent.  Only tags used in the chrome or a page are
 bundled.  `@loadbare/widgets` ships `lb-input`, `lb-select`, `lb-options`,
-`lb-table`, `lb-picker` and `lb-unknown-page`.
+`lb-picker`, `lb-table`, `lb-confirm`, `lb-form`, `lb-insert-dialog`,
+`lb-master`, `lb-checkbox`, `lb-number`, `lb-date` and `lb-unknown-page`.
 
 ### Using web components and other libraries
 
@@ -357,16 +445,16 @@ The following follow from the builder and hub code.
 
 ### Elsewhere
 
-| Project     | Unit                               | Inputs                        | Children                          | Style scope                 |
-|-------------|------------------------------------|-------------------------------|-----------------------------------|-----------------------------|
-| React       | Function returning JSX             | Props                         | `children` prop, render props     | None built in               |
-| Vue         | Single-file component (`.vue`)     | Props, emits                  | Default and named slots           | `<style scoped>` available  |
-| Angular     | Class with `@Component` decorator  | Inputs, outputs, signals      | Content projection (`ng-content`) | Emulated encapsulation by default |
-| Svelte      | `.svelte` file                     | `$props()`                    | Snippets                          | Scoped by default           |
-| Solid       | Function returning JSX, run once   | Props                         | `children`                        | None built in               |
-| Lit         | `LitElement` subclass              | Reactive properties, attributes | `<slot>` in shadow DOM          | Shadow DOM by default       |
-| Stimulus    | Controller class attached by `data-controller` | Values, targets  | Server-rendered HTML              | None                        |
-| LiveView    | Function components and LiveComponents | Assigns                   | Slots                             | None built in               |
+| Project  | Unit                                           | Inputs                          | Children                          | Style scope                       |
+| -------- | ---------------------------------------------- | ------------------------------- | --------------------------------- | --------------------------------- |
+| React    | Function returning JSX                         | Props                           | `children` prop, render props     | None built in                     |
+| Vue      | Single-file component (`.vue`)                 | Props, emits                    | Default and named slots           | `<style scoped>` available        |
+| Angular  | Class with `@Component` decorator              | Inputs, outputs, signals        | Content projection (`ng-content`) | Emulated encapsulation by default |
+| Svelte   | `.svelte` file                                 | `$props()`                      | Snippets                          | Scoped by default                 |
+| Solid    | Function returning JSX, run once               | Props                           | `children`                        | None built in                     |
+| Lit      | `LitElement` subclass                          | Reactive properties, attributes | `<slot>` in shadow DOM            | Shadow DOM by default             |
+| Stimulus | Controller class attached by `data-controller` | Values, targets                 | Server-rendered HTML              | None                              |
+| LiveView | Function components and LiveComponents         | Assigns                         | Slots                             | None built in                     |
 
 React 19 added full support for custom elements, including setting
 properties, so web components can be used in React applications directly.
@@ -383,17 +471,26 @@ the query string the browser is showing.
 - An empty body asks for the page's whole query set.  The server runs the
   page's `onPageEnter`, then every query the page declares.
 - A body carrying a request, `{ name, query, key, values }`, runs the handler
-  its name picks and then its refresh set.
-- A request without a name answers 400.  A `run` that throws answers 500.
-
-Every response has one shape: an array of response items.  Each names its
-query, the kind and key the server declared, and one of these:
-
-| Member           | Means                                                 |
-|------------------|-------------------------------------------------------|
-| `row`            | One row, for a query declared with `row()`            |
-| `rows`           | All rows, and their order, for a query declared with `rows()` |
-| `patch`          | `{ rows, drop }` for a `rows` query: upsert these, remove these keys |
+  its name picks and then its refresh set.  A request acting on selected
+  rows carries `keys` in place of `key`, and a form over a nested query
+  carries that query's rows as `rows`.
+- A handler or `onPageEnter` that returns `url()` answers with the new
+  `lb-url` row and the page loaded at the new URL, in the same response.
+- A request without a name, or a body that is not JSON, answers 400.  A body
+  over the `express.json()` limit answers 413.  A handler that throws
+  `refusal()` answers 422 with its words.  Any other `run` that throws
+  answers 500 with no message.
+
+Every successful response has one shape: an array of response items.  Each
+names its query, the kind and key the server declared, and one of these.  On a page
+load, an item for a `rows` query also carries the order and column types the
+query declared.
+
+| Member  | Means                                                                |
+| ------- | -------------------------------------------------------------------- |
+| `row`   | One row, or `null` for none, for a query declared with `row()`       |
+| `rows`  | All rows, and their order, for a query declared with `rows()`        |
+| `patch` | `{ rows, drop }` for a `rows` query: upsert these, remove these keys |
 
 A column holds one value.  A set of values is a query of its own.  A row
 never contains rows.  Master-detail is a row and rows answered under two
@@ -403,8 +500,9 @@ shown in groups by a group template.
 The application designs no endpoints, routes or serialization format.  The
 names in the markup are the keys in the page's `.queries.ts` and
 `.requests.ts` files.  The browser can reach only the queries, declared
-requests and `crud` entries a page declares; any other name answers `[]` and
-logs a server warning.
+requests and `crud` entries a page declares.  The builder refuses markup
+naming any other, and one that arrives anyway answers `[]` and logs a server
+warning.
 
 Values are not converted.  The hub hands each value to the browser as the
 query produced it.  Formatting a date or an amount is done in the query, or
@@ -413,18 +511,18 @@ by a custom element over `Intl`, such as `lb-number` and `lb-date` in
 
 ### Elsewhere
 
-| Project           | Data requests after first load                                                  |
-|-------------------|---------------------------------------------------------------------------------|
-| React, Vue, Angular, Svelte, Solid (client only) | Whatever the application designs: REST, GraphQL, tRPC, or other |
-| Next.js           | Server Functions as POST requests identified by a `Next-Action` header; navigations fetch RSC payloads |
-| React Router 7    | Loader data fetched by `.data` requests; actions posted to the route URL        |
-| SvelteKit         | Load data from `__data.json`; form actions posted to `?/actionName`             |
-| Nuxt              | Server routes under `server/api` (Nitro), fetched with `useFetch` or `$fetch`   |
-| htmx              | Any HTTP verb to any URL named in `hx-get`, `hx-post` and related attributes; HTML response |
-| Turbo             | Ordinary page and form requests; HTML responses; Turbo Stream responses        |
-| Phoenix LiveView  | Events and diffs over a WebSocket                                               |
-| Livewire          | POST requests carrying component snapshots and calls                            |
-| Blazor Server     | SignalR messages                                                                |
+| Project                                          | Data requests after first load                                                                         |
+| ------------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
+| React, Vue, Angular, Svelte, Solid (client only) | Whatever the application designs: REST, GraphQL, tRPC, or other                                        |
+| Next.js                                          | Server Functions as POST requests identified by a `Next-Action` header; navigations fetch RSC payloads |
+| React Router 7                                   | Loader data fetched by `.data` requests; actions posted to the route URL                               |
+| SvelteKit                                        | Load data from `__data.json`; form actions posted to `?/actionName`                                    |
+| Nuxt                                             | Server routes under `server/api` (Nitro), fetched with `useFetch` or `$fetch`                          |
+| htmx                                             | Any HTTP verb to any URL named in `hx-get`, `hx-post` and related attributes; HTML response            |
+| Turbo                                            | Ordinary page and form requests; HTML responses; Turbo Stream responses                                |
+| Phoenix LiveView                                 | Events and diffs over a WebSocket                                                                      |
+| Livewire                                         | POST requests carrying component snapshots and calls                                                   |
+| Blazor Server                                    | SignalR messages                                                                                       |
 
 ## Mutations, forms and request state
 
@@ -434,12 +532,12 @@ by a custom element over `Intl`, such as `lb-number` and `lb-date` in
 `lb-` is one of three requests Loadbare provides; any other name is a
 request the page declares.
 
-| `lb-request`     | Needs                    | Server key                     |
-|------------------|--------------------------|--------------------------------|
-| `lb-row-insert`  | `query`, `values`        | `crud.<query>.rowInsert`       |
-| `lb-row-update`  | `query`, `key`, `values` | `crud.<query>.rowUpdate`       |
-| `lb-row-delete`  | `query`, `key`           | `crud.<query>.rowDelete`       |
-| Any other name   | Whatever is present      | `handlers.<name>`              |
+| `lb-request`    | Needs                    | Server key               |
+| --------------- | ------------------------ | ------------------------ |
+| `lb-row-insert` | `query`, `values`        | `crud.<query>.rowInsert` |
+| `lb-row-update` | `query`, `key`, `values` | `crud.<query>.rowUpdate` |
+| `lb-row-delete` | `query`, `key`           | `crud.<query>.rowDelete` |
+| Any other name  | Whatever is present      | `handlers.<name>`        |
 
 - An element commits the way HTML says it does: a form on `submit`, a
   control on `change`, anything else on `click`.  A submit button commits
@@ -453,11 +551,24 @@ request the page declares.
   `lb-column`, a form's controls, a live row's, or the controls whose form
   owner is the element's form owner, the HTML `form` attribute included.  A
   control carrying `lb-column` and `lb-request` sends its own column alone,
-  so one `rowUpdate` answers a form and a per-field edit.
-- Every request has one shape, `{ name, query, key, values }`, and a
-  declared request receives the same fields.
+  so one `rowUpdate` answers a form and a per-field edit.  A form also
+  gathers the live rows of a query nested in its own, so a master and its
+  details are entered together.
+- Every request has one shape, `{ name, query, key, values }`, with `keys`
+  in place of `key` for selected rows and `rows` for a form's nested rows,
+  and a declared request receives the same fields.
 - The hub does not send a request Loadbare provides that lacks what the
-  table lists, and says why in the console.
+  table lists, and says why in the console.  An update or delete from a row
+  not yet entered, whose key is empty, is not sent.
+- One form edits any row of a set.  A button points it with HTML's
+  `commandfor` and one of three commands: `--lb-edit` fills the form from
+  the row the button sits in, as the hub holds it, with no round trip;
+  `--lb-new` starts it empty for an insert; `--lb-release` lets it go.
+  Inside a `<dialog>`, pointing opens the dialog and letting go closes it.
+- `<input type="checkbox" lb-select>` in a row template selects its row.  An
+  update or delete for the query that names no one row carries the selected
+  keys as `keys`, and the server runs `rowUpdate` or `rowDelete` once per
+  key.
 
 On the server, each entry has `run` and `refresh`.  `run` does the work and
 may return results, such as a `patch()`, or a new row for the URL with
@@ -466,11 +577,11 @@ over the refreshed results.
 
 The hub stamps the element that committed:
 
-| Stamp                | Means                                                      |
-|----------------------|------------------------------------------------------------|
+| Stamp                | Means                                                          |
+| -------------------- | -------------------------------------------------------------- |
 | `lb-request-pending` | The round trip is in flight; `aria-busy="true"` is set with it |
-| `lb-request-error`   | The last round trip from this element failed               |
-| `lb-request-refused` | The handler refused it, carrying its message               |
+| `lb-request-error`   | The last round trip from this element failed                   |
+| `lb-request-refused` | The handler refused it, carrying its message                   |
 
 A commit on an element carrying `lb-request-pending` is ignored.  A round
 trip has a ten-second deadline, after which it is aborted and treated as a
@@ -479,7 +590,9 @@ no message.  A handler's `refusal()` carries words for the user, shown on the
 element and on each control it names.
 
 After a successful `lb-row-insert` gathered from a form, the hub resets the
-form.  A failed insert resets nothing.
+form.  A successful request from a pointed form lets the form go, and one
+acting on selected rows clears the selection.  A failed request resets
+nothing.
 
 The browser displays only values the server returned.  There is no
 optimistic update.  Per-keystroke validation is an open question in the
@@ -487,18 +600,60 @@ roadmap.
 
 ### Elsewhere
 
-| Project          | Sending a mutation                                   | Refreshing afterward                                        | Pending state                          | Optimistic update         |
-|------------------|------------------------------------------------------|-------------------------------------------------------------|----------------------------------------|---------------------------|
-| React            | `<form action={fn}>`, event handlers                  | Application code                                            | `useActionState`, `useFormStatus`, `useTransition` | `useOptimistic`  |
-| TanStack Query   | `useMutation`                                         | `invalidateQueries` by query key                            | `isPending`                            | `onMutate`                |
-| Next.js          | Server Functions                                      | `revalidatePath`, `revalidateTag` in the function           | React hooks                            | `useOptimistic`           |
-| React Router 7   | `<Form>`, `useFetcher`, route `action`                | Loaders on the page revalidate by default; `shouldRevalidate` opts out | `useNavigation`, `fetcher.state` | Application code from pending form data |
-| SvelteKit        | Form actions in `+page.server.ts`, `use:enhance`      | `use:enhance` reruns load functions by default; `invalidate` for targeted reruns | Application code in `use:enhance` | Application code |
-| Angular          | Event bindings, `HttpClient`                          | Application code                                            | Application code                       | Application code          |
-| htmx             | `hx-post`, `hx-put`, `hx-delete` on any element       | The HTML response; `hx-swap-oob`; `HX-Trigger` response header | `htmx-request` class, `hx-indicator`, `hx-disabled-elt` | Not built in |
-| Turbo            | Forms; a successful non-GET submission redirects      | Re-render after redirect; Turbo Streams                     | `aria-busy` on the form, `data-turbo-submits-with` | Not built in |
-| Phoenix LiveView | `phx-click`, `phx-submit`, `phx-change`               | Assign changes re-render                                    | `phx-click-loading` and related classes, `phx-disable-with` | `JS` commands |
-| Livewire         | `wire:click`, `wire:submit`, `wire:model`             | Component re-render                                         | `wire:loading`                         | Not built in              |
+| Project          | Sending a mutation                               | Refreshing afterward                                                             | Pending state                                               | Optimistic update                       |
+| ---------------- | ------------------------------------------------ | -------------------------------------------------------------------------------- | ----------------------------------------------------------- | --------------------------------------- |
+| React            | `<form action={fn}>`, event handlers             | Application code                                                                 | `useActionState`, `useFormStatus`, `useTransition`          | `useOptimistic`                         |
+| TanStack Query   | `useMutation`                                    | `invalidateQueries` by query key                                                 | `isPending`                                                 | `onMutate`                              |
+| Next.js          | Server Functions                                 | `revalidatePath`, `revalidateTag` in the function                                | React hooks                                                 | `useOptimistic`                         |
+| React Router 7   | `<Form>`, `useFetcher`, route `action`           | Loaders on the page revalidate by default; `shouldRevalidate` opts out           | `useNavigation`, `fetcher.state`                            | Application code from pending form data |
+| SvelteKit        | Form actions in `+page.server.ts`, `use:enhance` | `use:enhance` reruns load functions by default; `invalidate` for targeted reruns | Application code in `use:enhance`                           | Application code                        |
+| Angular          | Event bindings, `HttpClient`                     | Application code                                                                 | Application code                                            | Application code                        |
+| htmx             | `hx-post`, `hx-put`, `hx-delete` on any element  | The HTML response; `hx-swap-oob`; `HX-Trigger` response header                   | `htmx-request` class, `hx-indicator`, `hx-disabled-elt`     | Not built in                            |
+| Turbo            | Forms; a successful non-GET submission redirects | Re-render after redirect; Turbo Streams                                          | `aria-busy` on the form, `data-turbo-submits-with`          | Not built in                            |
+| Phoenix LiveView | `phx-click`, `phx-submit`, `phx-change`          | Assign changes re-render                                                         | `phx-click-loading` and related classes, `phx-disable-with` | `JS` commands                           |
+| Livewire         | `wire:click`, `wire:submit`, `wire:model`        | Component re-render                                                              | `wire:loading`                                              | Not built in                            |
+
+## Correctness
+
+### Loadbare/app
+
+Theory leads with correctness, and most of what it asks for is built into
+the framework rather than left to the application.
+
+- The screen changes only from what the server sent.  There are no
+  optimistic updates, and no client cache answers a request in place of the
+  server.
+- Rows are matched to elements by key.  A row that is gone leaves, a row
+  that changed is filled, and a row that did not change is left alone,
+  along with anything typed into it and not yet sent.
+- An answer for a page or URL the user has already left does not land.
+- A query that answers in a shape it did not declare is left out, rather
+  than shown wrongly.
+- A write goes once: the hub takes the query and key from the document, and
+  ignores a commit on an element whose request is in flight.
+- A handler's refusal reaches the user on the controls it names.  Any other
+  server failure reaches the browser with no message in it.
+- The builder refuses unknown custom elements and `lb-` attributes a
+  developer may not write, and the server refuses at startup patterns known
+  to be wrong, and at run time any request a page did not declare.
+
+Theory's exceptions to its own rules are listed in
+[Miswarts](./miswarts.md).
+
+### Elsewhere
+
+Most of the comparison set treats correctness after a write as the
+application's to arrange, from tools the framework provides.
+
+| Group                  | What the screen shows after a write                                                              | A second click while the first is in flight  |
+| ---------------------- | ------------------------------------------------------------------------------------------------ | -------------------------------------------- |
+| Client component       | Whatever the application sets: an optimistic value, or data refetched after invalidating a cache | Application code                             |
+| Meta-frameworks        | Revalidated loader or server data; optimistic values where the application adds them             | Pending-state hooks the application uses     |
+| Hypermedia             | The HTML the server returned                                                                     | Opt-in attributes, or form handling in Turbo |
+| Server-driven stateful | The server's re-render                                                                           | Loading classes and disable attributes       |
+
+See [Mutations, forms and request state](#mutations-forms-and-request-state)
+for the mechanisms by project.
 
 ## Routing and navigation
 
@@ -525,27 +680,32 @@ roadmap.
 - A control inside `lb-query="lb-url"` carrying `lb-request="lb-row-update"`
   writes a query parm.  The hub answers that request itself: it replaces the
   history entry, or pushes one when the element carries `lb-url-push`, and
-  reloads the page's queries.  A handler moves the URL by returning
-  `url({ ... })`, and the page loads there in the same round trip.
+  reloads the page's queries.  A handler, or the page's `onPageEnter`, moves
+  the URL by returning `url({ ... })`, and the page loads there in the same
+  round trip.
 - The query string rides on every round trip, and the server hands its parms
   to `contextFor`.
+- The user's order and filters for rows already on the page are not query
+  parms.  They are choices, the row of the hub's query `lb-choices`, and
+  hold until the page changes.
 - The application must be served from the origin root.  The hub reaches
-  `/lb`, `/client.js` and `/app.css` by absolute path.
-- The hub sets `document.title` from `lb-page-label`.  It does not move focus
-  or restore scroll position on navigation.
+  `/lb` by absolute path, and the chrome links `/client.js` and `/app.css`.
+- The hub sets `document.title` from `lb-page-label`.  On entering a page,
+  once its queries have landed, it focuses the first element in `<main>` the
+  user can operate.  It does not restore scroll position on navigation.
 
 ### Elsewhere
 
-| Project          | Routes declared by                                  | Parameters                    | Layouts                     | Unknown path           |
-|------------------|-----------------------------------------------------|-------------------------------|-----------------------------|------------------------|
-| Next.js (App Router) | Directories under `app/` with `page.tsx`        | `[id]`, `[...slug]` segments  | Nested `layout.tsx`         | `not-found.tsx`, status 404 from the server |
-| Nuxt             | Files under `pages/`                                | `[id]` segments               | `layouts/`, nested routes   | Error page, status 404 |
-| SvelteKit        | Directories under `src/routes/` with `+page.svelte` | `[id]` segments               | Nested `+layout.svelte`     | `+error.svelte`, status 404 |
-| React Router 7   | Route config or file conventions                    | `:id` segments                | Nested routes with `<Outlet>` | Catch-all route      |
-| Angular          | `Routes` array                                      | `:id` segments                | Nested router outlets       | `**` wildcard route    |
-| Vue Router       | Routes array                                        | `:id` segments                | Nested `<RouterView>`       | Catch-all route        |
-| Phoenix LiveView | `live` routes in the router                         | `:id` segments, `handle_params` | Root and app layouts      | Status 404 from the server |
-| htmx, Turbo      | Server routes                                       | Server routes                 | Server templates            | Server status          |
+| Project              | Routes declared by                                  | Parameters                      | Layouts                       | Unknown path                                |
+| -------------------- | --------------------------------------------------- | ------------------------------- | ----------------------------- | ------------------------------------------- |
+| Next.js (App Router) | Directories under `app/` with `page.tsx`            | `[id]`, `[...slug]` segments    | Nested `layout.tsx`           | `not-found.tsx`, status 404 from the server |
+| Nuxt                 | Files under `pages/`                                | `[id]` segments                 | `layouts/`, nested routes     | Error page, status 404                      |
+| SvelteKit            | Directories under `src/routes/` with `+page.svelte` | `[id]` segments                 | Nested `+layout.svelte`       | `+error.svelte`, status 404                 |
+| React Router 7       | Route config or file conventions                    | `:id` segments                  | Nested routes with `<Outlet>` | Catch-all route                             |
+| Angular              | `Routes` array                                      | `:id` segments                  | Nested router outlets         | `**` wildcard route                         |
+| Vue Router           | Routes array                                        | `:id` segments                  | Nested `<RouterView>`         | Catch-all route                             |
+| Phoenix LiveView     | `live` routes in the router                         | `:id` segments, `handle_params` | Root and app layouts          | Status 404 from the server                  |
+| htmx, Turbo          | Server routes                                       | Server routes                   | Server templates              | Server status                               |
 
 A client-routed single-page application served by a catch-all route also
 answers 200 for an unknown path, as Loadbare/app does.
@@ -558,7 +718,7 @@ answers 200 for an unknown path, as Loadbare/app does.
 loadbare-app-build [--src src] [--out dist] [--watch] [--minify]
 ```
 
-- Four flags.  No configuration file.  An open blocker proposes one.
+- Four flags.  No configuration file.
 - Files are classified by name: `chrome.html`, `*.page.html`,
   `*.queries.ts`, `*.requests.ts`, `imports.ts`, `*.css`, `<tag>.html`,
   `<tag>.browser.ts`.
@@ -584,42 +744,57 @@ Checked at build time, as errors:
   containing a capital
 - slot and template errors: two slots, two templates of one name, a template
   naming a missing destination, content in a definition with no slot
-- an `lb-` attribute in markup that is not one a developer writes (`lb-query`,
-  `lb-column`, `lb-show`, `lb-request`, `lb-url-link`, `lb-url-push`,
-  `lb-url-unknown`); the rest are stamps, and script never assigns them
+- a custom element placed where the browser's parser would move its
+  definition's contents, such as a `<dialog>` inside a `<p>`
+- a widget script declaring an `lb` method Loadbare does not call, or one of
+  the browser's lifecycle callbacks
+- a chrome without exactly one `<lb-hub>` and one empty `<main>` inside it,
+  and a page carrying either
+- an `lb-` attribute in markup that is not one of the sixteen a developer
+  writes; the rest are stamps, and script never assigns them
 - an `lb-request` value beginning with `lb-` that is not one of the three
   requests Loadbare provides
 - `lb-url-link` on anything but an `<a>`, `lb-url-push` without
   `lb-request`, `lb-url-unknown` on anything but a `<dialog>` inside
   `<lb-hub>`
-- `lb-show` on a `<template>`, on a row template's root, or with no
-  `lb-query` around it
+- `lb-show` on a `<template>`, on a row template's root, with no `lb-query`
+  around it, or written `!` or `!!column`
+- `lb-group` on anything but a `<template>` holding a `<template>`, and an
+  aggregate on a `<template>` or naming no column
+- `lb-order` or `lb-filter` on an element not carrying `lb-query`, or naming
+  no column
+- `lb-select` on anything but a checkbox in a row template, or beside
+  `lb-column` or `lb-request`
+- a `command` beginning `--lb-` that is not one of the three, and one of the
+  three with no `commandfor`
+- an `lb-query` naming a query the page does not declare, an `lb-request`
+  naming a request it does not declare under `handlers`, and one of the
+  three requests for a query whose `crud` entry lacks it.  The chrome names
+  only `lb-url` and `lb-choices`.  The builder reads the declarations by
+  loading the page modules, so their import-time code runs during the build.
 - a `.queries.ts` or `.requests.ts` with no matching page
 
 Checked when the server starts: a query or declared request name beginning
-with `lb-`.
+with `lb-`, a malformed `order`, an unknown column type, and a `crud` insert,
+update or delete on a `rows` query whose `refresh` names that same query.
 
-Not checked at build time: that an `lb-query` name matches a declared query,
-that an `lb-request` matches a declared request or `crud` entry, that the
-chrome contains one `<lb-hub>` and one empty `<main>`.  The first two are a
-roadmap item; the last is listed under the builder blockers.  A language server is a
-roadmap item.
+A language server is a roadmap item.
 
 ### Elsewhere
 
-| Project          | Build and dev tooling                                   | Template type checking                        | Editor tooling                  |
-|------------------|---------------------------------------------------------|-----------------------------------------------|---------------------------------|
-| React            | Chosen by the application or its framework; Create React App was deprecated in February 2025 | TypeScript checks JSX | TypeScript language service |
-| Next.js          | Turbopack or webpack; dev server with Fast Refresh      | TypeScript; typed routes                      | TypeScript plugin               |
-| Vue, Nuxt        | Vite; dev server with HMR                               | `vue-tsc`                                     | Vue language tools (Volar)      |
-| Angular          | Angular CLI (esbuild, Vite dev server)                  | Strict template type checking in the compiler | Angular Language Service        |
-| Svelte, SvelteKit| Vite; dev server with HMR                               | `svelte-check`                                | Svelte language server          |
-| Solid            | Vite                                                    | TypeScript checks JSX                         | TypeScript language service     |
-| React Router 7   | Vite                                                    | TypeScript; generated route types             | TypeScript language service     |
-| Astro            | Vite                                                    | `astro check`                                 | Astro language tools            |
-| htmx, Alpine.js  | None required; a script tag                             | None                                          | Community extensions            |
-| Hotwire (Rails)  | Import maps or a JavaScript bundler                     | None for Turbo attributes                     | Community extensions            |
-| Phoenix          | esbuild and Tailwind through Mix                        | Compile-time warnings for declared component attributes | Elixir language server |
+| Project           | Build and dev tooling                                                                        | Template type checking                                  | Editor tooling              |
+| ----------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------- | --------------------------- |
+| React             | Chosen by the application or its framework; Create React App was deprecated in February 2025 | TypeScript checks JSX                                   | TypeScript language service |
+| Next.js           | Turbopack or webpack; dev server with Fast Refresh                                           | TypeScript; typed routes                                | TypeScript plugin           |
+| Vue, Nuxt         | Vite; dev server with HMR                                                                    | `vue-tsc`                                               | Vue language tools (Volar)  |
+| Angular           | Angular CLI (esbuild, Vite dev server)                                                       | Strict template type checking in the compiler           | Angular Language Service    |
+| Svelte, SvelteKit | Vite; dev server with HMR                                                                    | `svelte-check`                                          | Svelte language server      |
+| Solid             | Vite                                                                                         | TypeScript checks JSX                                   | TypeScript language service |
+| React Router 7    | Vite                                                                                         | TypeScript; generated route types                       | TypeScript language service |
+| Astro             | Vite                                                                                         | `astro check`                                           | Astro language tools        |
+| htmx, Alpine.js   | None required; a script tag                                                                  | None                                                    | Community extensions        |
+| Hotwire (Rails)   | Import maps or a JavaScript bundler                                                          | None for Turbo attributes                               | Community extensions        |
+| Phoenix           | esbuild and Tailwind through Mix                                                             | Compile-time warnings for declared component attributes | Elixir language server      |
 
 ## CSS
 
@@ -637,22 +812,27 @@ Nothing is scoped, renamed, added or removed.
 - Light DOM means every selector reaches every element, in the chrome and in
   widgets.
 - The hub stamps attributes a stylesheet can select on: `lb-column-value`,
-  `lb-key-value`, `lb-row-live`, `lb-request-pending`, `lb-request-error`,
-  `lb-query-row-count`.  An empty `rows` query is styled with
-  `[lb-query-row-count="0"]`.
+  `lb-key-value`, `lb-row-live`, `lb-query-row-count`, the group stamps,
+  `lb-row-editing`, `lb-row-selected`, `lb-request-pending`,
+  `lb-request-error` and `lb-request-refused`.  An empty `rows` query is
+  styled with `[lb-query-row-count="0"]`.
+- Every change the hub makes to a list is stamped: `lb-row-created`,
+  `lb-row-changed`, `lb-row-moved`, `lb-row-requested`, `lb-row-leaving` and
+  `lb-group-leaving`.  A leaving row is removed once its animations finish,
+  so an application animates rows with CSS alone.
 
 ### Elsewhere
 
-| Project     | Built-in scoping                                                          |
-|-------------|---------------------------------------------------------------------------|
-| React       | None; applications choose CSS Modules, CSS-in-JS, Tailwind, or global CSS |
-| Next.js     | CSS Modules, global CSS, Sass and Tailwind supported by the build         |
-| Vue         | `<style scoped>` adds a data attribute per component; CSS Modules         |
-| Angular     | Emulated encapsulation adds attributes per component by default; shadow DOM and none available |
-| Svelte      | Component styles scoped by a generated class by default                   |
-| Lit         | Shadow DOM scoping by default                                             |
-| htmx, Turbo, Alpine.js | None                                                           |
-| Phoenix     | None built in; Tailwind configured by default in new projects             |
+| Project                | Built-in scoping                                                                               |
+| ---------------------- | ---------------------------------------------------------------------------------------------- |
+| React                  | None; applications choose CSS Modules, CSS-in-JS, Tailwind, or global CSS                      |
+| Next.js                | CSS Modules, global CSS, Sass and Tailwind supported by the build                              |
+| Vue                    | `<style scoped>` adds a data attribute per component; CSS Modules                              |
+| Angular                | Emulated encapsulation adds attributes per component by default; shadow DOM and none available |
+| Svelte                 | Component styles scoped by a generated class by default                                        |
+| Lit                    | Shadow DOM scoping by default                                                                  |
+| htmx, Turbo, Alpine.js | None                                                                                           |
+| Phoenix                | None built in; Tailwind configured by default in new projects                                  |
 
 ## The server
 
@@ -660,8 +840,9 @@ Nothing is scoped, renamed, added or removed.
 
 Loadbare/app ships no server.  It ships:
 
-- `createHub(pages)`, an engine with no HTTP code, in `@loadbare/app/server`
-- `hubRoutes(hub, contextFor)`, an Express 5 router, in
+- `createHub(pages)`, an engine with no HTTP code, in `@loadbare/app/server`,
+  beside `row`, `rows`, `patch`, `url`, `choices` and `refusal`
+- `hubRoutes(hub, contextFor, options)`, an Express 5 router, in
   `@loadbare/app/express`.  Express is an optional peer dependency.
 - `pages.ts`, generated by the builder, which imports every page's queries
   and requests and exports `hub`
@@ -686,26 +867,28 @@ application's, placed in Express middleware and in `ctx`.
 
 A page's server half:
 
-| File                 | Exports    | Contents                                                     |
-|----------------------|------------|--------------------------------------------------------------|
-| `<name>.queries.ts`  | `queries`  | Named queries, each built with `row(key, run)` or `rows(key, run)` |
-| `<name>.requests.ts` | `requests` | `onPageEnter`, `handlers` by request name, `crud` by query name |
+| File                 | Exports    | Contents                                                                     |
+| -------------------- | ---------- | ---------------------------------------------------------------------------- |
+| `<name>.queries.ts`  | `queries`  | Named queries, each built with `row(key, run)` or `rows(key, run, options)`  |
+| `<name>.requests.ts` | `requests` | `onPageEnter`, `onChoices`, `handlers` by request name, `crud` by query name |
 
-A query's `run` is `(ctx) => Row` or `(ctx) => Row[]`.  An answer whose
-shape disagrees with its declaration is dropped with a warning.
+A query's `run` is `(ctx) => Row | null` or `(ctx) => Row[]`, synchronous or
+async.  A `rows` query's options declare its order and its column types.
+An answer whose shape disagrees with its declaration is dropped with a
+warning.
 
 A page's queries are that page's view model, computed on the server: a
 backend-for-frontend scoped to one page, whose answers are the values the
 page shows.
 
-|                  | Data layer (repository, ORM, API) | Backend-for-frontend | Loadbare/app page files |
-|------------------|-----------------------------------|----------------------|-------------------------|
-| Serves           | Any consumer                      | One client application | One page              |
-| Shaped by        | Entities                          | A client's screens   | One page's elements     |
-| Answers with     | Domain objects, independent of any UI | Data the client still turns into a view | Values as the page shows them, formatted and worded |
-| Client-side work | Mapping, state, view models, components | View models, components | None: the hub lands each column on the element that names it |
-| Keeps the rules  | Yes, in code                      | Usually not          | No: the application keeps them beneath, in its database or in code its handlers share |
-| Reused by        | Many screens                      | One application's screens | No other page      |
+|                  | Data layer (repository, ORM, API)       | Backend-for-frontend                    | Loadbare/app page files                                                               |
+| ---------------- | --------------------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------- |
+| Serves           | Any consumer                            | One client application                  | One page                                                                              |
+| Shaped by        | Entities                                | A client's screens                      | One page's elements                                                                   |
+| Answers with     | Domain objects, independent of any UI   | Data the client still turns into a view | Values as the page shows them, formatted and worded                                   |
+| Client-side work | Mapping, state, view models, components | View models, components                 | None: the hub lands each column on the element that names it                          |
+| Keeps the rules  | Yes, in code                            | Usually not                             | No: the application keeps them beneath, in its database or in code its handlers share |
+| Reused by        | Many screens                            | One application's screens               | No other page                                                                         |
 
 A typical stack runs database, ORM or repository, service, API contract,
 client store, view model, component and template.  A Loadbare/app page keeps
@@ -715,25 +898,27 @@ answer goes.  Reuse does not happen through a layer.  Two pages showing the
 same data repeat a query's shape or share a database view, and shared
 wording goes in a helper module.
 
-The data channel carries no CSRF token.  Where an options argument for
-hooks, transaction wrapping, error handling and CSRF would go is an open
-blocker.  Serving the static files from a separate origin is a roadmap item.
+The data channel carries no CSRF token.  `hubRoutes` takes an options
+object, one key per concern, whose one key today, `json`, is passed to
+`express.json()`.  Options for global hooks, transaction wrapping, error
+handling and a CSRF token are a roadmap item.  Serving the static files
+from a separate origin is a roadmap item.
 
 ### Elsewhere
 
-| Project          | Server                                                                             |
-|------------------|------------------------------------------------------------------------------------|
-| React, Vue, Angular, Svelte, Solid (client only) | None; the application supplies an API server        |
-| Next.js          | Next.js server, or adapters for hosting platforms; Middleware or Proxy; Route Handlers |
-| Nuxt             | Nitro server with presets for hosting platforms                                    |
-| SvelteKit        | Adapters (Node, static, platform-specific); hooks in `hooks.server.ts`             |
-| React Router 7   | Request handler with adapters for Node, Express and platforms                      |
-| Astro            | Static output, or server adapters                                                  |
-| htmx             | Any server that returns HTML                                                       |
-| Hotwire          | Any server; integrated with Rails                                                  |
-| Phoenix LiveView | Phoenix                                                                            |
-| Livewire         | Laravel                                                                            |
-| Blazor Server    | ASP.NET Core                                                                       |
+| Project                                          | Server                                                                                 |
+| ------------------------------------------------ | -------------------------------------------------------------------------------------- |
+| React, Vue, Angular, Svelte, Solid (client only) | None; the application supplies an API server                                           |
+| Next.js                                          | Next.js server, or adapters for hosting platforms; Middleware or Proxy; Route Handlers |
+| Nuxt                                             | Nitro server with presets for hosting platforms                                        |
+| SvelteKit                                        | Adapters (Node, static, platform-specific); hooks in `hooks.server.ts`                 |
+| React Router 7                                   | Request handler with adapters for Node, Express and platforms                          |
+| Astro                                            | Static output, or server adapters                                                      |
+| htmx                                             | Any server that returns HTML                                                           |
+| Hotwire                                          | Any server; integrated with Rails                                                      |
+| Phoenix LiveView                                 | Phoenix                                                                                |
+| Livewire                                         | Laravel                                                                                |
+| Blazor Server                                    | ASP.NET Core                                                                           |
 
 ## Performance profile
 
@@ -741,12 +926,12 @@ blocker.  Serving the static files from a separate origin is a roadmap item.
 
 First load of any path:
 
-| Request                   | Returns                                    |
-|---------------------------|--------------------------------------------|
+| Request                   | Returns                                                 |
+| ------------------------- | ------------------------------------------------------- |
 | `GET /<path>`             | `app.html`: the chrome and every page as a `<template>` |
-| `GET /client.js`          | The hub and every used widget, one bundle  |
-| `GET /app.css`            | Every stylesheet, one file                 |
-| `POST /lb/<page>?<query>` | The page's query results as JSON           |
+| `GET /client.js`          | The hub and every used widget, one bundle               |
+| `GET /app.css`            | Every stylesheet, one file                              |
+| `POST /lb/<page>?<query>` | The page's query results as JSON                        |
 
 The three static files are fixed at release and can be compressed, cached,
 and served from a CDN.  There are no per-route bundles, lazy chunks or module
@@ -754,61 +939,65 @@ waterfalls.  The page template is cloned into `<main>` before its data
 request is sent.  An optional `<body hidden>` in the chrome keeps the
 document hidden until the first page is in place.
 
-Measured on this working tree:
+Measured on 0.18.2, 2026-10-09:
 
-| Item                                           | Size         |
-|------------------------------------------------|--------------|
-| Hub source, `lb-hub.browser.ts` and `lb-apply.ts` | 929 lines, comments included |
-| Hub alone, esbuild `--minify`                  | 8,302 bytes  |
-| Hub alone, minified then `gzip -9`             | 3,377 bytes  |
+| Item                                                                 | Size                           |
+| -------------------------------------------------------------------- | ------------------------------ |
+| Hub source, `lb-hub.browser.ts`, `lb-apply.ts` and `lb-lifecycle.ts` | 3,151 lines, comments included |
+| Hub alone, with the `core/` modules it imports, esbuild `--minify`   | 31,405 bytes                   |
+| Hub alone, minified then `gzip -9`                                   | 11,596 bytes                   |
 
-Each navigation is one POST.  Each interaction is one POST whose response
-carries the refreshed and patched results.  On the server, a page's queries
+Each navigation is one POST.  Each request is one POST whose response
+carries the refreshed and patched results, and the page's load when the
+request moved the URL.  A choice re-places rows the page already holds with
+no round trip, then tells the server in a POST nothing waits on.  Pointing a
+form at a row takes no round trip.  On the server, a page's queries
 run one after another in declaration order, then the response is serialized
 as JSON.  No HTML is rendered on the server after the build.
 
 `app.html` grows with the number and size of pages, and all of it is parsed
-on first load.  Lazy loading of page templates is a roadmap item.  Theory
-states that performance measurements will be published separately; none are
-published as of this writing.
+on first load.  Lazy loading of page templates is a roadmap item.  No
+performance measurements are published as of this writing.
 
 ### Elsewhere
 
-| Project          | First load                                                        | Navigation                                     | Interaction                              |
-|------------------|-------------------------------------------------------------------|------------------------------------------------|------------------------------------------|
-| Client-only SPA  | HTML shell, framework and application bundles, often split by route; data requests | Route chunk if not loaded; data requests | State update and re-render; data requests |
-| Next.js, Nuxt, SvelteKit, React Router 7 | Server-rendered HTML, framework and route bundles, hydration | RSC payload or loader data, route chunks | Server Function or action request; revalidation |
-| Astro            | HTML; JavaScript only for hydrated islands                        | Full page load, or client router if enabled    | Island-local                             |
-| htmx             | Server-rendered HTML and the htmx script                          | Full page, or `hx-boost` body swap             | HTML fragment per request                |
-| Turbo            | Server-rendered HTML and Turbo                                    | Fetch full page HTML, replace body             | Form request and page or stream response |
-| Phoenix LiveView | Server-rendered HTML, then a WebSocket connection and mount       | `<.link patch>` and `<.link navigate>` over the socket | Event over the socket, diff back |
-| Blazor Server    | Server-rendered HTML, then a SignalR circuit                      | Over the circuit                               | Event over the circuit, diff back        |
+| Project                                  | First load                                                                         | Navigation                                             | Interaction                                     |
+| ---------------------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------ | ----------------------------------------------- |
+| Client-only SPA                          | HTML shell, framework and application bundles, often split by route; data requests | Route chunk if not loaded; data requests               | State update and re-render; data requests       |
+| Next.js, Nuxt, SvelteKit, React Router 7 | Server-rendered HTML, framework and route bundles, hydration                       | RSC payload or loader data, route chunks               | Server Function or action request; revalidation |
+| Astro                                    | HTML; JavaScript only for hydrated islands                                         | Full page load, or client router if enabled            | Island-local                                    |
+| htmx                                     | Server-rendered HTML and the htmx script                                           | Full page, or `hx-boost` body swap                     | HTML fragment per request                       |
+| Turbo                                    | Server-rendered HTML and Turbo                                                     | Fetch full page HTML, replace body                     | Form request and page or stream response        |
+| Phoenix LiveView                         | Server-rendered HTML, then a WebSocket connection and mount                        | `<.link patch>` and `<.link navigate>` over the socket | Event over the socket, diff back                |
+| Blazor Server                            | Server-rendered HTML, then a SignalR circuit                                       | Over the circuit                                       | Event over the circuit, diff back               |
 
 ## Surface area
 
-TECHREF-1.0 lists every name Loadbare/app owns in one cross-reference.
-
-| Owned                               | Count | Names                                                         |
-|-------------------------------------|-------|---------------------------------------------------------------|
-| `lb-*` attributes a developer writes | 15   | `lb-query`, `lb-column`, `lb-show`, `lb-group`, `lb-count`, `lb-sum`, `lb-avg`, `lb-min`, `lb-max`, `lb-order`, `lb-filter`, `lb-request`, `lb-url-link`, `lb-url-push`, `lb-url-unknown` |
-| `lb-*` stamps                       | 17    | `lb-column-value`, `lb-key-value`, `lb-row-live`, `lb-query-row-count`, `lb-group-live`, `lb-group-column`, `lb-group-value`, `lb-row-created`, `lb-row-changed`, `lb-row-moved`, `lb-row-requested`, `lb-row-leaving`, `lb-group-leaving`, `lb-request-pending`, `lb-request-error`, `lb-page`, `lb-page-title` |
-| `lb-*` build-time attributes        | 2     | `lb-exp-slot`, `lb-exp-template`                              |
-| Requests Loadbare provides          | 3     | `lb-row-insert`, `lb-row-update`, `lb-row-delete`             |
-| `lb*` methods on custom elements    | 4     | `lbAttached`, `lbRowsLanded`, `lbRequestDone`, `lbDetached`   |
-| Attribute namespace for expansion   | 1     | `exp-*`                                                       |
-| Reserved tags                       | 1     | `<lb-hub>`                                                    |
-| Reserved events                     | 1     | `lb-request`                                                  |
-| Queries the hub serves              | 2     | `lb-url`, with columns `lb-path`, `lb-page-label`, `lb-page-unknown`; `lb-choices`, keyed by `lb-path` |
-| Builder flags                       | 4     | `--src`, `--out`, `--watch`, `--minify`                       |
-| Reserved file names and patterns    | 8     | `chrome.html`, `imports.ts`, `*.page.html`, `*.queries.ts`, `*.requests.ts`, `<tag>.html`, `<tag>.browser.ts`, `*.css` |
-| Reserved `package.json` keys        | 1     | `loadbare.widgets`                                            |
-| Server functions                    | 7     | `row`, `rows`, `patch`, `url`, `choices`, `createHub`, `hubRoutes` |
-| Browser exports                     | 2     | `applyRow`, `applyResponse`                                   |
-
-The technical reference, TECHREF-1.0.md, is 1,181 lines.  Theory states that
-the vocabulary fits in an LLM's context window, and discloses that Anthropic
-models writing `.requests.ts` files consistently refresh a `rows` query after
-returning a patch for it.
+[Names](./reference/names.md) lists every name Loadbare/app owns in one
+cross-reference.
+
+| Owned                                | Count | Names                                                                                                                                                                                                                                                                                                                                                                       |
+| ------------------------------------ | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `lb-*` attributes a developer writes | 16    | `lb-query`, `lb-column`, `lb-show`, `lb-group`, `lb-count`, `lb-sum`, `lb-avg`, `lb-min`, `lb-max`, `lb-order`, `lb-filter`, `lb-request`, `lb-select`, `lb-url-link`, `lb-url-push`, `lb-url-unknown`                                                                                                                                                                      |
+| `lb-*` stamps                        | 20    | `lb-column-value`, `lb-key-value`, `lb-row-live`, `lb-query-row-count`, `lb-group-live`, `lb-group-column`, `lb-group-value`, `lb-row-created`, `lb-row-changed`, `lb-row-moved`, `lb-row-requested`, `lb-row-leaving`, `lb-group-leaving`, `lb-row-editing`, `lb-row-selected`, `lb-request-pending`, `lb-request-error`, `lb-request-refused`, `lb-page`, `lb-page-title` |
+| `lb-*` build-time attributes         | 2     | `lb-exp-slot`, `lb-exp-template`                                                                                                                                                                                                                                                                                                                                            |
+| Requests Loadbare provides           | 3     | `lb-row-insert`, `lb-row-update`, `lb-row-delete`                                                                                                                                                                                                                                                                                                                           |
+| Commands for `commandfor`            | 3     | `--lb-edit`, `--lb-new`, `--lb-release`                                                                                                                                                                                                                                                                                                                                     |
+| `lb*` methods on custom elements     | 4     | `lbAttached`, `lbRowsLanded`, `lbRequestDone`, `lbDetached`                                                                                                                                                                                                                                                                                                                 |
+| Attribute namespace for expansion    | 1     | `exp-*`                                                                                                                                                                                                                                                                                                                                                                     |
+| Reserved tags                        | 1     | `<lb-hub>`                                                                                                                                                                                                                                                                                                                                                                  |
+| Reserved events                      | 2     | `lb-request`, `lb-request-done`                                                                                                                                                                                                                                                                                                                                             |
+| Queries the hub serves               | 2     | `lb-url`, with columns `lb-path`, `lb-page-label`, `lb-page-unknown`; `lb-choices`, keyed by `lb-path`                                                                                                                                                                                                                                                                      |
+| Builder flags                        | 4     | `--src`, `--out`, `--watch`, `--minify`                                                                                                                                                                                                                                                                                                                                     |
+| Reserved file names and patterns     | 8     | `chrome.html`, `imports.ts`, `*.page.html`, `*.queries.ts`, `*.requests.ts`, `<tag>.html`, `<tag>.browser.ts`, `*.css`                                                                                                                                                                                                                                                      |
+| Reserved `package.json` keys         | 1     | `loadbare.widgets`                                                                                                                                                                                                                                                                                                                                                          |
+| Server functions                     | 8     | `row`, `rows`, `patch`, `url`, `choices`, `refusal`, `createHub`, `hubRoutes`                                                                                                                                                                                                                                                                                               |
+| Browser exports                      | 2     | `applyRow`, `applyResponse`                                                                                                                                                                                                                                                                                                                                                 |
+
+Theory states that the whole vocabulary fits in one technical reference,
+and so in a developer's head and in an LLM's context window.  Because SQL
+and HTML are thoroughly represented in an LLM's training, the reference
+only has to spell out the mappings between them.
 
 The other projects in the comparison set do not publish a comparable
 cross-reference, so no count is given for them here.
@@ -823,9 +1012,16 @@ cross-reference, so no count is given for them here.
 - `aria-busy="true"` is set and removed with `lb-request-pending`.
 - An element hidden by `lb-show` is inside template content, so it is not in
   the accessibility tree.
+- A row leaving the list takes `inert` until it is removed, and a row the
+  user's filter does not pass is `hidden`.
+- A refusal's message for a column goes on its control through HTML's own
+  validity, `setCustomValidity`, and the browser treats it as it treats any
+  invalid control.
 - A widget's markup is in the document and in view-source.
-- On navigation the hub sets `document.title` from the page's `<title>`.  It
-  does not move focus or announce the new page.
+- On navigation the hub sets `document.title` from the page's `<title>`.
+  On entering a page, once its queries have landed, it focuses the first
+  element in `<main>` the user can operate.  It does not announce the new
+  page.
 
 ### Elsewhere
 
@@ -846,45 +1042,46 @@ No browser test runner is installed.
 
 For an application:
 
-- A query is `{ kind, run }`, and `run(ctx)` is a function returning rows.
-- A request entry is `{ run, refresh }`, and `run(ctx, where)` is a function.
+- A query is `{ kind, key, run }`, and `run(ctx)` is a function returning a
+  row, `null` or rows.
+- A request entry is `{ run, refresh }`, and `run(ctx, request)` is a
+  function.
 - `createHub(pages)` returns an object whose methods take a page name and a
   `ctx`, with no HTTP server.
-- `applyData(root, data)` lands a response on any DOM root.
+- `applyResponse(root, items)` lands response items on any DOM root.
 - A widget is a custom element.
 
 The documentation describes no testing approach for applications.
 
 ### Elsewhere
 
-| Project          | Common testing tools                                          |
-|------------------|---------------------------------------------------------------|
-| React            | Vitest or Jest with React Testing Library; Playwright         |
-| Vue              | Vitest with Vue Test Utils; Playwright                        |
-| Angular          | TestBed with Jasmine and Karma, or Jest or Vitest; Playwright |
-| Svelte           | Vitest with Svelte Testing Library; Playwright                |
-| htmx, Turbo      | Server-side tests of HTML responses; Playwright or Capybara   |
+| Project          | Common testing tools                                              |
+| ---------------- | ----------------------------------------------------------------- |
+| React            | Vitest or Jest with React Testing Library; Playwright             |
+| Vue              | Vitest with Vue Test Utils; Playwright                            |
+| Angular          | TestBed with Jasmine and Karma, or Jest or Vitest; Playwright     |
+| Svelte           | Vitest with Svelte Testing Library; Playwright                    |
+| htmx, Turbo      | Server-side tests of HTML responses; Playwright or Capybara       |
 | Phoenix LiveView | `Phoenix.LiveViewTest`, which drives a LiveView without a browser |
 
 ## Release history and churn
 
 ### Loadbare/app
 
-Loadbare/app is at 0.9.0 and has not reached 1.0.  TECHREF-1.0 lists items
-to decide before 1.0 because they would be breaking changes afterward.
-Theory states that 1.0 is scoped so that foreseeable features can be added
-without breaking existing code.
+Loadbare/app has not reached 1.0.  Theory argues that application code should have a long shelf
+life, because each part of it is a standard or a mature tool.
 
 Application code consists of:
 
-| Part             | Standard or dependency                                  |
-|------------------|---------------------------------------------------------|
-| Pages and chrome | HTML                                                    |
-| Styles           | CSS                                                     |
-| Widgets          | Custom Elements v1 and `<template>`                     |
-| Server           | Express 5                                               |
-| Page server code | TypeScript functions taking `ctx`                       |
-| Binding          | The `lb-*` vocabulary                                   |
+| Part             | Standard or dependency              |
+| ---------------- | ----------------------------------- |
+| Pages and chrome | HTML                                |
+| Styles           | CSS                                 |
+| Widgets          | Custom Elements v1 and `<template>` |
+| Pointing a form  | HTML's `command` and `commandfor`   |
+| Server           | Express 5                           |
+| Page server code | TypeScript functions taking `ctx`   |
+| Binding          | The `lb-*` vocabulary               |
 
 The W3C HTML Templates specification was published as a Working Draft in
 2013 (see [Prior art](./prior-art.md)).  Autonomous custom elements have been
@@ -896,97 +1093,113 @@ Loadbare's history begins with Andromeda in 2003, whose data layer is now
 
 ### Elsewhere
 
-| Date           | Change                                                                    |
-|----------------|---------------------------------------------------------------------------|
-| September 2016 | Angular 2 released, incompatible with AngularJS                           |
-| February 2019  | React 16.8 introduces Hooks                                               |
-| September 2020 | Vue 3 released, with the Composition API                                  |
-| December 2021  | AngularJS support ends                                                    |
-| October 2022   | Next.js 13 introduces the App Router alongside the Pages Router           |
-| December 2023  | Vue 2 reaches end of life                                                 |
-| June 2024      | htmx 2.0 released                                                         |
-| October 2024   | Svelte 5 released, replacing reactive declarations with runes             |
-| November 2024  | React Router 7 released, absorbing Remix                                  |
-| December 2024  | React 19 released, with Actions and stable Server Components              |
-| February 2025  | Create React App deprecated                                               |
+| Date           | Change                                                          |
+| -------------- | --------------------------------------------------------------- |
+| September 2016 | Angular 2 released, incompatible with AngularJS                 |
+| February 2019  | React 16.8 introduces Hooks                                     |
+| September 2020 | Vue 3 released, with the Composition API                        |
+| December 2021  | AngularJS support ends                                          |
+| October 2022   | Next.js 13 introduces the App Router alongside the Pages Router |
+| December 2023  | Vue 2 reaches end of life                                       |
+| June 2024      | htmx 2.0 released                                               |
+| October 2024   | Svelte 5 released, replacing reactive declarations with runes   |
+| November 2024  | React Router 7 released, absorbing Remix                        |
+| December 2024  | React 19 released, with Actions and stable Server Components    |
+| February 2025  | Create React App deprecated                                     |
 
 ## What Loadbare/app does not do
 
-Each item is current behavior or an open item named in TECHREF-1.0 or the
-Roadmap.
-
-| Area                          | Status in the working tree after 0.9.0                                 |
-|-------------------------------|------------------------------------------------------------------------|
-| Nested data                   | A row never holds rows.  Trees are sent as joined rows.                 |
-| Record URLs and view parameters | A path names a page.  A record or a filter is a query parm, `/accounts?acct=23`. |
-| Query arguments from the browser | None.  Query parms reach queries through `contextFor` and `ctx`.     |
-| File inputs                   | Not landed and not gathered.                                           |
-| Data types and formatting     | No conversion.  Queries, or custom elements over `Intl`, format values. |
-| Error messages                | A handler's `refusal()` reaches the user; any other failure carries no message. |
-| Field validation              | No mechanism.  Per-keystroke validation is a roadmap question.         |
-| Optimistic updates            | None.                                                                  |
-| Concurrent writers            | No version or conflict check.  Roadmap question.                       |
-| Server push                   | None.  No WebSocket or server-sent events.                             |
-| Offline or local-first use    | None.                                                                  |
-| Server-side rendering for crawlers | None.  Every path answers the same document with status 200.      |
-| Subpath hosting               | Not possible.  The hub uses absolute paths.                            |
-| Chrome-level queries          | A widget in the chrome bound to a query requires every page to declare it.  On the roadmap. |
-| A widget receiving a whole row | Not available.  Open blocker.                                         |
-| A nested `rows` query per outer row | A nested query receives the same rows in every outer row.  A new outer row's nested query stays empty until its name lands again.  Open blocker. |
-| Configurable request deadline | Fixed at ten seconds.                                                  |
-| Internationalization          | Roadmap item.                                                          |
-| Lazy page loading             | Roadmap item.                                                          |
-| Per-widget CSS shipping       | Roadmap item.                                                          |
-| Dev server, HMR               | None.                                                                  |
-| Language server               | Roadmap item.                                                          |
-| Browser tests of the framework | Not written.                                                          |
+Some of what Loadbare/app does not do is a decision, made for one of
+Theory's goals.  The rest is a gap: open, on the roadmap, or simply not
+built.  The two are listed apart, because a reader weighing the framework
+should not mistake one for the other.
+
+### By decision
+
+| Area                               | What it does instead, and why                                                                                                        |
+| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| Nested data                        | A row never holds rows; trees are sent as joined rows.  The two-shape decision that keeps the browser code finite.                   |
+| Record URLs and view parameters    | A path names a page; a record or a filter is a query parm, `/accounts?acct=23`.  See [Departures](./departures.md).                  |
+| Query arguments from the browser   | None.  Query parms reach queries through `contextFor` and `ctx`, so the wire reaches nothing a page did not publish.  Correctness.   |
+| Data types and formatting          | No conversion.  Queries, or custom elements over `Intl`, format values.  The browser already formats; Loadbare does not do it again. |
+| Error messages                     | A handler's `refusal()` reaches the user; any other failure carries no message.  Correctness.                                        |
+| Optimistic updates                 | None.  The screen shows only what the server answered.  Correctness.                                                                 |
+| Server push                        | None.  Currency is out of scope until it is reconciled with correctness.                                                             |
+| Offline or local-first use         | None.  Loadbare/app is for server-bound applications.                                                                                |
+| Server-side rendering for crawlers | None.  Every path answers the same document with status 200.  A departure; see [Departures](./departures.md).                        |
+| Subpath hosting                    | Not possible.  A cost of the navigation departure.                                                                                   |
+
+### Gaps and open items
+
+Each is current behavior or an open item named in the
+[Reference](./reference/overview.md) or the
+[Roadmap](./roadmap.md).
+
+| Area                                | Status                                                                                                                                               |
+| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| File inputs                         | Not landed and not gathered.                                                                                                                         |
+| Field validation                    | No per-keystroke mechanism.  A handler's refusal lands on each control through the browser's own validity; validation placement is an open question. |
+| Concurrent writers                  | No version or conflict check.  Open question.                                                                                                        |
+| Chrome-level queries                | The chrome names only `lb-url` and `lb-choices`; an application query there is a build error.  On the roadmap.                                       |
+| A widget receiving a whole row      | Not available.  On the roadmap.                                                                                                                      |
+| Compound foreign keys               | A picker offers the same choices on every row; a choice restricted by another column of its row cannot be expressed.  Roadmap.                       |
+| Configurable request deadline       | Fixed at ten seconds.                                                                                                                                |
+| Internationalization                | Roadmap item.                                                                                                                                        |
+| Lazy page loading                   | Roadmap item.                                                                                                                                        |
+| Per-widget CSS shipping             | Roadmap item.                                                                                                                                        |
+| Dev server, HMR                     | None.                                                                                                                                                |
+| Language server                     | Roadmap item.                                                                                                                                        |
+| Browser tests of the framework      | Not written.                                                                                                                                         |
 
 ## Requirements and fit
 
-Theory states the fit condition: data that is, or maps readily to, rows and
-sets of rows, and affordances that map to the standard operations on that
-data.
+Theory states the fit condition: data that is rows, or can easily be shaped
+into rows, and interactions that map onto reading and writing them.  It
+does not yet fit an application that needs currency.
 
-Theory also states the strongest objection it knows of and does not dispute
-it: that the binding attributes and the required relational shape exchange
-one set of accidental complexity for another, and that the system is
-"differently accidental" from other frameworks.
+Theory also takes up the strongest objection it knows of: that the binding
+attributes and the required relational shape exchange one set of accidental
+complexity for another.  Its answer is a rule rather than a count: every
+term must be a SQL concept, an HTML one, or belong to a small named family,
+and the accidents most likely to pile up are in the mapping rules SQL does
+not dictate.
 
 The table lists requirements an application may have, and whether each
 approach provides them without additional libraries.
 
-| Requirement                                   | Loadbare/app 0.9   | Client component + API | Meta-frameworks | Hypermedia | Server-driven stateful |
-|-----------------------------------------------|--------------------|------------------------|-----------------|------------|------------------------|
-| Pages bound to relational query results       | yes                | application code       | application code | server templates | server templates |
-| No endpoint or route design                   | yes                | no                     | partly (actions, loaders) | no | partly (routes, events) |
-| No client-side state management               | yes                | no                     | no              | yes        | yes                    |
-| No build step                                 | no                 | no                     | no              | yes        | depends on stack       |
-| Server-rendered HTML for crawlers             | no                 | no                     | yes             | yes        | yes                    |
-| Route parameters and record URLs              | query parms only   | yes                    | yes             | yes        | yes                    |
-| Optimistic updates                            | no                 | yes                    | yes             | no         | partly                 |
-| Offline or local-first operation              | no                 | with libraries         | with libraries  | no         | no                     |
-| Real-time server push                         | no                 | with libraries         | with libraries  | extensions, Turbo Streams over WebSocket | yes |
-| Nested JSON documents                         | no                 | yes                    | yes             | server templates | yes              |
-| Client-only interaction (canvas, editors, drag and drop) | through custom elements | yes | yes      | through scripts | through hooks     |
-| Works while the server is unreachable         | no                 | with caching           | with caching    | no         | no                     |
-| No persistent connection                      | yes                | yes                    | yes             | yes        | no                     |
-| Server code in any language                   | no (Node, TypeScript) | yes                 | no (JavaScript, TypeScript) | yes | no (Elixir, PHP, .NET) |
-| Stable 1.0 or later                           | no                 | yes                    | yes             | yes        | yes                    |
+| Requirement                                              | Loadbare/app            | Client component + API | Meta-frameworks             | Hypermedia                               | Server-driven stateful  |
+| -------------------------------------------------------- | ----------------------- | ---------------------- | --------------------------- | ---------------------------------------- | ----------------------- |
+| Pages bound to relational query results                  | yes                     | application code       | application code            | server templates                         | server templates        |
+| No endpoint or route design                              | yes                     | no                     | partly (actions, loaders)   | no                                       | partly (routes, events) |
+| No client-side state management                          | yes                     | no                     | no                          | yes                                      | yes                     |
+| No build step                                            | no                      | no                     | no                          | yes                                      | depends on stack        |
+| Server-rendered HTML for crawlers                        | no, by design           | no                     | yes                         | yes                                      | yes                     |
+| Route parameters and record URLs                         | query parms only        | yes                    | yes                         | yes                                      | yes                     |
+| Optimistic updates                                       | no, by design           | yes                    | yes                         | no                                       | partly                  |
+| Offline or local-first operation                         | no                      | with libraries         | with libraries              | no                                       | no                      |
+| Real-time server push                                    | no, out of scope        | with libraries         | with libraries              | extensions, Turbo Streams over WebSocket | yes                     |
+| Nested JSON documents                                    | no                      | yes                    | yes                         | server templates                         | yes                     |
+| Client-only interaction (canvas, editors, drag and drop) | through custom elements | yes                    | yes                         | through scripts                          | through hooks           |
+| Works while the server is unreachable                    | no                      | with caching           | with caching                | no                                       | no                      |
+| No persistent connection                                 | yes                     | yes                    | yes                         | yes                                      | no                      |
+| Server code in any language                              | no (Node, TypeScript)   | yes                    | no (JavaScript, TypeScript) | yes                                      | no (Elixir, PHP, .NET)  |
+| Stable 1.0 or later                                      | no                      | yes                    | yes                         | yes                                      | yes                     |
 
 ## Appendix A: Matrix
 
-| Aspect               | Loadbare/app                         | Client component                | Meta-frameworks                         | Hypermedia                      | Server-driven stateful          |
-|----------------------|--------------------------------------|---------------------------------|-----------------------------------------|---------------------------------|---------------------------------|
-| State                | Server; DOM                          | Browser memory                  | Server and browser memory               | Server; DOM                     | Server memory per client        |
-| Rendering            | Build time                           | Browser                         | Server, then browser                    | Server per request              | Server per event                |
-| Markup language      | HTML with `lb-*` names               | JSX or template syntax with expressions | JSX or template syntax           | Server templates with `hx-*` or `data-turbo-*` | HEEx, Blade, Razor  |
-| Components           | Light-DOM custom elements            | Framework components            | Framework components                    | Server partials; Stimulus controllers | Server components         |
-| Wire                 | One POST endpoint, JSON rows         | Application-designed            | Framework-defined                       | HTML over HTTP                  | WebSocket or snapshot POSTs     |
-| Mutation refresh     | Declared `refresh` names; patches    | Application code or query invalidation | Revalidation                     | Response HTML                   | Re-render                       |
-| Routing              | Flat page names; query parms         | Router library                  | File-based, with parameters and layouts | Server routes                   | Server routes                   |
-| Build                | `loadbare-app-build`, esbuild        | Vite and others                 | Vite, Turbopack, others                 | None required                   | Stack-specific                  |
-| CSS                  | Concatenated, unscoped               | Varies                          | Varies, scoped options                  | None                            | None built in                   |
-| Server               | Application's Express app            | Application's API               | Framework server or adapters            | Any                             | Phoenix, Laravel, ASP.NET Core  |
+| Aspect           | Loadbare/app                      | Client component                        | Meta-frameworks                          | Hypermedia                                     | Server-driven stateful         |
+| ---------------- | --------------------------------- | --------------------------------------- | ---------------------------------------- | ---------------------------------------------- | ------------------------------ |
+| State            | Server; DOM                       | Browser memory                          | Server and browser memory                | Server; DOM                                    | Server memory per client       |
+| Rendering        | Build time                        | Browser                                 | Server, then browser                     | Server per request                             | Server per event               |
+| Markup language  | HTML with `lb-*` names            | JSX or template syntax with expressions | JSX or template syntax                   | Server templates with `hx-*` or `data-turbo-*` | HEEx, Blade, Razor             |
+| Components       | Light-DOM custom elements         | Framework components                    | Framework components                     | Server partials; Stimulus controllers          | Server components              |
+| Wire             | One POST endpoint, JSON rows      | Application-designed                    | Framework-defined                        | HTML over HTTP                                 | WebSocket or snapshot POSTs    |
+| Mutation refresh | Declared `refresh` names; patches | Application code or query invalidation  | Revalidation                             | Response HTML                                  | Re-render                      |
+| After a write    | Only the server's answer          | The application's choice                | Revalidated data; optimistic where added | The server's HTML                              | The server's re-render         |
+| Routing          | Flat page names; query parms      | Router library                          | File-based, with parameters and layouts  | Server routes                                  | Server routes                  |
+| Build            | `loadbare-app-build`, esbuild     | Vite and others                         | Vite, Turbopack, others                  | None required                                  | Stack-specific                 |
+| CSS              | Concatenated, unscoped            | Varies                                  | Varies, scoped options                   | None                                           | None built in                  |
+| Server           | Application's Express app         | Application's API                       | Framework server or adapters             | Any                                            | Phoenix, Laravel, ASP.NET Core |
 
 ## Appendix B: One page, three ways
 
@@ -1157,38 +1370,38 @@ the request is in flight.
 
 Each equivalent is approximate.
 
-| Loadbare/app                  | Nearest equivalents elsewhere                                                    |
-|-------------------------------|----------------------------------------------------------------------------------|
-| Hub                           | Client runtime; router plus data layer                                           |
-| Chrome (`chrome.html`)        | Root layout (`app/layout.tsx`, `+layout.svelte`); application shell              |
-| Page (`<name>.page.html`)     | Route component; page template                                                   |
-| Query (`row()`, `rows()`)     | Loader (React Router 7); load function (SvelteKit); data read in a Server Component |
-| `onPageEnter`                 | LiveView `mount`; code at the top of a loader                                    |
-| Declared request (`handlers`) | Route action (React Router 7); form action (SvelteKit); Server Function; LiveView `handle_event` |
-| `crud` operation              | Resource controller action (Rails); REST verb on a row                           |
-| `refresh`                     | Revalidation; `invalidateQueries`; `revalidatePath`                              |
-| `patch({ rows, drop })`       | Keyed partial update; Turbo Stream `append`/`replace`/`remove`; LiveView `stream_insert`/`stream_delete` |
-| Landing                       | Render and commit; swap; patch                                                   |
-| `lb-query`, `lb-column`       | IE4 `DATASRC` and `DATAFLD`; `v-for` and `{{ }}`; `x-for` and `x-text`         |
-| Key declared by `row()`/`rows()` | `key` (React, Vue); `track` (Angular); keyed `each` (Svelte)                  |
-| `lb-show`                     | `v-if`, `@if`, `{#if}`, `x-if`                                                   |
-| `lb-column-value`             | A prop; an observed attribute                                                    |
-| `lb-request`                  | `hx-post`; `phx-click`; `wire:click`; `<form action>`                            |
-| `lb-request` event            | `htmx:beforeRequest`; a component `emit`                                         |
-| `lb-request-pending`          | `htmx-request` class; `phx-click-loading`; `useFormStatus().pending`; `wire:loading` |
-| `lb-request-error`            | `htmx:responseError`; an error boundary                                          |
-| `lb-query-row-count`          | An empty-state conditional in a template                                         |
-| `lb-url-link`                 | `<Link>`; `hx-boost`; Turbo Drive                                                |
-| `lb-url`                      | `useLocation` and `useSearchParams`; `page.url` (SvelteKit); `$route` (Vue Router) |
-| `url()` from a handler        | A redirect after POST; `redirect()` in a Server Function                         |
-| Widget                        | Component; custom element                                                        |
-| Expansion                     | Server-side include; partial; build-time component render (Astro)                |
-| `exp-` parameter              | A prop fixed at build time                                                       |
-| `lb-exp-slot`, `lb-exp-template` | Default slot and named slots; `ng-content` with `select`                         |
-| `lbRowsLanded`                | An effect after a list renders                                                   |
-| `lbAttached`, `lbDetached`    | Mount and unmount; `onMounted` and `onUnmounted` (Vue); `onMount` and `onDestroy` (Svelte) |
-| `order`, `lb-group`           | `ORDER BY` with report-writer control breaks (`BREAK ON`, group bands)          |
-| `lb-choices`, `lb-order`, `lb-filter` | A data grid's sort and filter model                                     |
-| `ctx` / `HubContext`          | `event.locals` (SvelteKit); loader `context` (React Router 7); request-scoped dependency injection |
-| `imports.ts`                  | Installing and registering a component library                                   |
-| `pages.ts`                    | Generated route manifest                                                         |
+| Loadbare/app                          | Nearest equivalents elsewhere                                                                            |
+| ------------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| Hub                                   | Client runtime; router plus data layer                                                                   |
+| Chrome (`chrome.html`)                | Root layout (`app/layout.tsx`, `+layout.svelte`); application shell                                      |
+| Page (`<name>.page.html`)             | Route component; page template                                                                           |
+| Query (`row()`, `rows()`)             | Loader (React Router 7); load function (SvelteKit); data read in a Server Component                      |
+| `onPageEnter`                         | LiveView `mount`; code at the top of a loader                                                            |
+| Declared request (`handlers`)         | Route action (React Router 7); form action (SvelteKit); Server Function; LiveView `handle_event`         |
+| `crud` operation                      | Resource controller action (Rails); REST verb on a row                                                   |
+| `refresh`                             | Revalidation; `invalidateQueries`; `revalidatePath`                                                      |
+| `patch({ rows, drop })`               | Keyed partial update; Turbo Stream `append`/`replace`/`remove`; LiveView `stream_insert`/`stream_delete` |
+| Landing                               | Render and commit; swap; patch                                                                           |
+| `lb-query`, `lb-column`               | IE4 `DATASRC` and `DATAFLD`; `v-for` and `{{ }}`; `x-for` and `x-text`                                   |
+| Key declared by `row()`/`rows()`      | `key` (React, Vue); `track` (Angular); keyed `each` (Svelte)                                             |
+| `lb-show`                             | `v-if`, `@if`, `{#if}`, `x-if`                                                                           |
+| `lb-column-value`                     | A prop; an observed attribute                                                                            |
+| `lb-request`                          | `hx-post`; `phx-click`; `wire:click`; `<form action>`                                                    |
+| `lb-request` event                    | `htmx:beforeRequest`; a component `emit`                                                                 |
+| `lb-request-pending`                  | `htmx-request` class; `phx-click-loading`; `useFormStatus().pending`; `wire:loading`                     |
+| `lb-request-error`                    | `htmx:responseError`; an error boundary                                                                  |
+| `lb-query-row-count`                  | An empty-state conditional in a template                                                                 |
+| `lb-url-link`                         | `<Link>`; `hx-boost`; Turbo Drive                                                                        |
+| `lb-url`                              | `useLocation` and `useSearchParams`; `page.url` (SvelteKit); `$route` (Vue Router)                       |
+| `url()` from a handler                | A redirect after POST; `redirect()` in a Server Function                                                 |
+| Widget                                | Component; custom element                                                                                |
+| Expansion                             | Server-side include; partial; build-time component render (Astro)                                        |
+| `exp-` parameter                      | A prop fixed at build time                                                                               |
+| `lb-exp-slot`, `lb-exp-template`      | Default slot and named slots; `ng-content` with `select`                                                 |
+| `lbRowsLanded`                        | An effect after a list renders                                                                           |
+| `lbAttached`, `lbDetached`            | Mount and unmount; `onMounted` and `onUnmounted` (Vue); `onMount` and `onDestroy` (Svelte)               |
+| `order`, `lb-group`                   | `ORDER BY` with report-writer control breaks (`BREAK ON`, group bands)                                   |
+| `lb-choices`, `lb-order`, `lb-filter` | A data grid's sort and filter model                                                                      |
+| `ctx` / `HubContext`                  | `event.locals` (SvelteKit); loader `context` (React Router 7); request-scoped dependency injection       |
+| `imports.ts`                          | Installing and registering a component library                                                           |
+| `pages.ts`                            | Generated route manifest                                                                                 |