@loadbare/app 0.12.0 → 0.14.0

package/skills/loadbare-app/references/TECHREF-1.0.md

@@ -22,38 +22,28 @@ a value is rendered by browser coercion when it lands on an HTML text
 element or a control, and by whatever the custom element does with
 `lb-column-value` when it lands on one that is not a control.
 
+Two places read a value's type today.  The [order](#order) compares values
+by their JSON type, and an [aggregate](#aggregates) reads a sum or an
+average from a JSON number or a string holding a plain decimal.
+
 We will then see if a useful solution emerges that Loadbare/app should
 handle.
 
 ### Form controls
 
-- **Checkboxes and radio buttons are not implemented.** A value does not
-  land on one and the hub does not gather one.  Landing needs a decision on
-  what counts as checked, which waits on [Data types](#data-types), and a
-  radio group is several elements answering to one column.
-
-### Run-time stamps
-
-The hub stamps `lb-query-row-count`, `lb-request-pending` and
-`lb-request-error` for a stylesheet to read.  Their consumer is CSS rather
-than code.
-
-- **Decide whether an unarrived value needs a signal.** An element whose
-  column has not landed carries no `lb-column-value`.  Recommend confirming
-  that as the signal and adding nothing.
+- **Radio buttons are not implemented.** A value does not land on one and
+  the hub does not gather one.  A radio group is several elements answering
+  to one column.
 
 ### Custom element hooks
 
 Loadbare/app owns every method name beginning with `lb` on a custom element.
 That decision is firm; what the set contains is not.
 
-- **Decide what the build does with an unknown `lb*` method.** An element
-  carrying a method beginning with `lb` that Loadbare/app does not define may
-  be an error, a warning, or ignored.
 - **Decide whether a custom element may receive a whole row.** A column
   lands one element at a time and offers no escape hatch.  An optional
-  `lbAcceptRow` would sit beside `lbPlaceRow` and `lbRowsLanded`, and this is
-  the most likely first request from a custom element author.
+  `lbAcceptRow` would sit beside `lbRowsLanded`, and this is the most likely
+  first request from a custom element author.
 
 ### Nested queries
 
@@ -77,38 +67,9 @@ But the allowed values may depend on other values in the row.
 </tbody>
 ```
 
-### Who creates and orders rows
-
-The hub creates every live row from a row template and places it in the
-query's order, unless the element holding the rows has `lbPlaceRow`, in
-which case the custom element decides where each row goes.  Custom elements
-also create rows of their own: `lb-table` clones a ghost row per section and
-builds each section's heading.  Neither side owns creation or order.
-
-- **Decide who creates rows and who orders them.** A patch cannot say where
-  a new row goes, so it lands where the host puts it: in order under
-  `lb-table` with `data-sort`, last in plain markup and in `lb-options`.
-  Whether an insert may answer with a patch therefore depends on markup the
-  server cannot see, and the server cannot refuse an insert that refreshes
-  its own query the way it refuses an update or a delete.
-- **Decide whether landing all rows moves rows already in place.** It moves
-  every row today, which takes focus from the control the user is in, and
-  `lbPlaceRow` does the same.
-
 ### The server API
 
-- **Give the chrome a way to state its own queries.** A custom element in
-  the chrome naming a query forces every page to declare that query, since
-  the page load covers one page's set.  `lb-url` shows the pattern from the
-  framework side, and an application has no equivalent.  Recommend a
-  chrome-level query set on `createHub`.
-- **State that only `createHub` implements `Hub`.** Otherwise a third call
-  breaks anyone who wrote the interface by hand.
-- **Decide the options-argument shape once.** Global hooks, transaction
-  wrapping, error handling and a CSRF token all want the same trailing
-  parameter on `createHub` and `hubRoutes`.  Build none of them, but pick
-  where they go.
-- **Land `staticRoutes`.** See NEXT.md.  It closes the last place where an
+- **Land `staticRoutes`.**  It closes the last place where an
   application hand-writes facts the builder owns.
 
 ### The builder
@@ -123,9 +84,6 @@ builds each section's heading.  Neither side owns creation or order.
   definition would let the builder ship only what survives expansion.
   Recommend deferring the mechanism and reserving the configuration key, so
   that it lands as an opt-in rather than as a silent drop.
-- **Land the remaining validations.** One `lb-hub` and one empty `<main>`.
-  Recommend landing these now, because refusing markup that used to build is
-  the kind of change 1.0 gives up.
 - **Decide whether the build validates HTML.** A page can be well formed and
   still break HTML's rules for what an element may hold, such as a `<div>`
   inside a `<p>`.  The parser rearranges it silently, the same way at build
@@ -141,9 +99,6 @@ builds each section's heading.  Neither side owns creation or order.
 None of this is surface.  It is listed here because trimming it is free
 today and breaking after 1.0.
 
-- **Drop `./build` from the exports map.** Nothing in the repository imports
-  it, and nothing outside the CLI should call `resolveElements` or
-  `clientEntrySource`.
 - **Audit what the hub does.** It appears to have routines that go beyond
   what the `lb-*` attribute namespace specifies.
 - **Keep the rest as constants.** The endpoint, `index` and the timeout are
@@ -455,9 +410,10 @@ The markup names a query and the columns it shows.  The kind and the key are
 the server's, and the markup states neither.
 
 The row template is the first `<template>` among the descendants of an
-element with `lb-query`, outside any nested `lb-query`.  A live row is an
-element the hub cloned from a row template for one row, and carries
-`lb-row-live`.
+element with `lb-query`, outside any nested `lb-query`, or, when that
+template is a [group template](#groups), the innermost template inside it.
+A live row is an element the hub cloned from a row template for one row,
+and carries `lb-row-live`.
 
 | Kind   | Row template | The hub                             |
 | ------ | ------------ | ----------------------------------- |
@@ -496,7 +452,8 @@ A query that arrives with nowhere to land is reported to the console.
 | Any other element                                | Its text content               |
 
 A control is an `<input>`, `<select>` or `<textarea>`, or a form-associated
-custom element with a `value` property that fires `change`.  A
+custom element with a `value` property that fires `change`.  A checkbox is a
+control too, by the rule below.  A
 form-associated custom element declares `static formAssociated = true`.
 
 The hub stamps `lb-column-value` with the value on every element it sets.
@@ -507,9 +464,21 @@ renders `lb-column-value` itself.
 The hub gathers from the same controls it lands on, so a value read back is
 the one that landed.
 
-An `<input>` of type `checkbox`, `radio`, or `file` receives nothing, not
-even `lb-column-value`, and the hub reports it to the console.  The hub does
-not gather one either.
+A checkbox's state is `checked`, not `value`: HTML's quirk, and so the
+hub's, so that every other part of the vocabulary treats it as any control.
+The hub checks it by the rule `lb-show` is on by: `null` and `false` are
+unchecked, and every other value is checked, with no string read.  It
+gathers `"true"` or `"false"`, so an unchecked box still says so, where a
+native form submission leaves it out.  The checkbox's own `value`
+attribute means nothing to the hub.
+
+```html
+<input type="checkbox" lb-column="active" lb-request="lb-row-update" />
+```
+
+An `<input>` of type `radio` or `file` receives nothing, not even
+`lb-column-value`, and the hub reports it to the console.  The hub does not
+gather one either.
 
 A `<select>` with no option for the value shows no selection.
 
@@ -538,14 +507,15 @@ with `[lb-row-live]`, and never with `[lb-key-value]`.
 A key is unique within a query.  Two rows with one key in the same answer,
 or two live rows showing one key, are reported on the console.
 
-All rows decide membership and order: every row is placed in the order
-given, and a live row whose key did not arrive is removed.  A patch touches
-only the rows it names and leaves every other live row's contents and
-position alone.
+All rows decide membership: a live row whose key did not arrive leaves —
+see [What happened to a row](#what-happened-to-a-row).  A patch touches only
+the rows it names, and leaves every other live row's contents alone.
 
-A new live row lands immediately before the row template, so rows
-accumulate in the order they arrive.  A custom element carrying `lb-query`
-and a row template may place them itself — see [Row hooks](#row-hooks).
+The hub places every live row by the query's [order](#order), immediately
+before the row template, or before its clone in the row's
+[group](#groups).  A row moves only when the order puts it somewhere else,
+so all rows landing again unchanged move nothing.  A live row already in the
+markup when the first answer lands is one of the query's rows.
 
 After every landing the hub stamps the element with `lb-query-row-count`,
 the number of live rows it holds.  The server answers with rows and says
@@ -560,6 +530,162 @@ sent.  It makes an empty query a stylesheet rule:
 
 A row missing its key column is reported to the console and not landed.
 
+#### Order
+
+A `rows` query's order is a rule over its columns.  The server declares it
+with the query, and the URL may carry the user's own:
+
+```ts
+accounts: rows("id", (ctx) => ctx.db.accounts(), {
+  order: "category_order,account_name",
+}),
+```
+
+An order is columns separated by commas.  A column written after `-` sorts
+descending.  The query parm `lb-order-<query>` replaces the declared order
+for that query: `/coa?lb-order-accounts=-account_name`.  With neither, rows
+show in the order the server sent them, and a patch's new rows go last.
+
+| Values               | Compare                                    |
+| -------------------- | ------------------------------------------ |
+| Two numbers          | Numerically                                |
+| Two strings          | As the user's language orders them         |
+| Two booleans         | `false` before `true`                      |
+| Two different types  | Booleans, then numbers, then strings       |
+| `null` or missing    | After everything ascending, first descending |
+
+A number sent as a string sorts as a string, so a column the order reads
+numerically arrives as a JSON number.  Rows that compare equal keep the
+order they arrived in, and a patch's new rows come after the rows already
+showing.
+
+The hub sorts the rows it has, so a control that writes the order parm
+re-sorts the page with no round trip:
+
+```html
+<div lb-query="lb-url">
+  <select lb-column="lb-order-accounts" lb-request="lb-row-update">
+    <option value="">By category</option>
+    <option value="account_name">By name</option>
+  </select>
+</div>
+```
+
+A query that pages or limits its rows decides membership by its order, so
+it reads the parm itself, from the parms `contextFor` receives, and declares
+`serverSortedByUrl: true` beside `order`.  A change of the user's order then
+loads the page again.  The hub still places the rows it receives by the same
+order, so a patch lands in its place.
+
+#### Groups
+
+A group is a run of rows sharing the order's leading term.  A group
+template is a `<template lb-group>` in the row template's place, holding the
+group's heading and exactly one nested `<template>`, which is where the
+group's contents go: the next group template, or the row template.  The nth
+group template breaks on the order's nth term, so groups nest to any depth.
+
+```html
+<table lb-query="accounts">
+  <thead><tr><th>Account</th></tr></thead>
+  <template lb-group>
+    <tbody>
+      <tr><th scope="rowgroup" lb-column="category"></th></tr>
+      <template><tr><td lb-column="account_name"></td></tr></template>
+    </tbody>
+  </template>
+</table>
+```
+
+The hub clones the group template where the order breaks and puts the
+group's contents immediately before the clone of its nested template.  The
+markup's nesting decides the shape:
+
+| The nested template is            | The group's contents land           | Example                          |
+| --------------------------------- | ----------------------------------- | -------------------------------- |
+| Inside the heading's element      | Inside it                           | `<tbody>`, `<li>`, `<details>`   |
+| Beside the heading                | After the heading, as its siblings  | A heading `<tr>` in one `<tbody>` |
+
+`<tbody>` and `<optgroup>` do not nest, so a table's levels below the first
+are heading rows beside their rows.  Content after the nested template lands
+after the group's rows, which is where a group's footer goes.
+
+A group's heading is filled from its first row, the same way a live row is
+filled, so it shows any column of the row.  The example breaks on
+`category_order` and shows `category`.  The hub fills it from no other row.
+
+The hub stamps each top-level element of a group's clone with
+`lb-group-live`, `lb-group-column`, the column it breaks on, and
+`lb-group-value`, its value there.  A row creates its group, and a group
+leaves with its last row.  Groups never move: when a change of order puts
+the groups at a level in another order, each of them is made again.
+
+A group template with no nested template is reported to the console.  More
+group templates than the order has terms show each extra level as one
+group, and are reported once.
+
+#### Aggregates
+
+An aggregate attribute sets an element from the rows of the nearest group
+around it, or of the whole list outside any group.
+
+| Attribute       | Sets the element to                           |
+| --------------- | --------------------------------------------- |
+| `lb-count`      | The number of rows                            |
+| `lb-sum="col"`  | The sum of `col`                              |
+| `lb-avg="col"`  | The average of `col`                          |
+| `lb-min="col"`  | The least value of `col`, by the [order](#order)'s comparison |
+| `lb-max="col"`  | The greatest, likewise                        |
+
+```html
+<tr><td><span lb-count></span> accounts</td><td lb-sum="balance"></td></tr>
+```
+
+It lands as a column does, with `lb-column-value`.  A sum and an average
+are exact decimals, read from JSON numbers and from strings holding a plain
+decimal, as Postgres sends `numeric`.  A sum has as many places as the most
+precise value, and an average up to two more.  `null` and empty values are
+left out, as SQL leaves them out.  Any other value is left out and reported
+once.  The hub does not format the result.
+
+An aggregate covers the rows the browser holds.  Where the true total
+matters beyond what the page shows, it is a row the server answers.
+
+#### What happened to a row
+
+Every change the hub makes to a list is one a stylesheet can see, so an
+application animates with CSS alone and the hub starts no animation.
+
+| Attribute          | On                   | Means                                              |
+| ------------------ | -------------------- | -------------------------------------------------- |
+| `lb-row-created`   | A live row           | Created when the hub last touched it               |
+| `lb-row-changed`   | A live row           | Its values changed when the hub last touched it    |
+| `lb-row-moved`     | A live row           | The order put it somewhere else when last touched  |
+| `lb-row-requested` | A live row           | `created`, `changed` or `moved` by this page's request |
+| `lb-row-leaving`   | A row on its way out | No longer live                                     |
+| `lb-group-leaving` | A group on its way out | No longer live                                   |
+
+The hub touches a row when an answer names it.  `lb-row-created`,
+`lb-row-changed` and `lb-row-moved` are cleared when it next does, and one
+applied again is removed and added as two changes, so an animation keyed to
+it plays again.  `lb-row-requested` is cleared at every landing of the
+row's query, and set only by a landing that answers a request from the page.
+
+A row or a group that leaves loses `lb-row-live` or `lb-group-live`, takes
+`lb-row-leaving` or `lb-group-leaving` and `inert`, and is removed once the
+animations running on it have finished, at once when there are none.  A
+moved row stays live and moves.  A copy of it stays behind where it was,
+leaving.
+
+```css
+[lb-row-created] { animation: arrive 200ms; }
+[lb-row-leaving] { animation: depart 200ms forwards; }
+```
+
+A row never travels between the two places, since that takes measuring, and
+measuring takes script.  Scrolling to a row is script too: a custom element
+reads `lb-row-requested` in [`lbRowsLanded`](#row-hooks).
+
 #### Displaying by condition
 
 `lb-show` names the column that decides whether an element is present.
@@ -624,9 +750,9 @@ answered side by side.  A column never holds rows.
 ```
 
 Many masters, each with its own detail, is one `rows` query of joined rows:
-each detail row carries its master's columns.  A custom element's
-`lbPlaceRow` groups them for display, as `lb-table` builds sections and
-`lb-options` builds `<optgroup>`s.
+each detail row carries its master's columns.  A [group
+template](#groups) shows each master as a group, ordered by the master's
+key first.
 
 A query nested in another query's row template receives the same rows in
 every live row.  That serves a picker offering the same choices on every
@@ -664,9 +790,13 @@ Every request has one shape, on the event and on the wire:
 { name: "lb-row-update", query: "roster", key: "42", values: { name: "Ann" } }
 { name: "lb-row-delete", query: "roster", key: "42" }
 { name: "mailRoster",    query: "roster", key: "42" }
+{ name: "lb-row-update", query: "roster", keys: ["42", "43"], values: { role: "lead" } }
+{ name: "lb-row-insert", query: "invoice", values: { memo: "May" }, rows: { lines: [{ key: "1", values: { qty: "3" } }] } }
 ```
 
-The hub sends `query`, `key` and `values` as present.
+The hub sends `query`, `key` and `values` as present, and `keys` in place of
+`key` for a request acting on the rows selected — see
+[Selecting rows](#selecting-rows).
 
 #### Committing
 
@@ -734,7 +864,8 @@ controls belong to a form that cannot wrap a `<tr>`:
 
 The hub gathers from controls only.  It skips a control whose nearest
 ancestor `lb-query` is a descendant of the live row or form, since that
-control belongs to a nested query.  An element carrying `lb-query` and
+control belongs to a nested query, except that a form gathers the rows of a
+query nested in its own — see [A form over a set of rows](#a-form-over-a-set-of-rows).  An element carrying `lb-query` and
 `lb-column` both, such as a picker, belongs to the row around it and is
 gathered.
 
@@ -748,6 +879,61 @@ ancestor `lb-query` of the element carrying `lb-request`, and takes `key`
 from that element's nearest ancestor row when that row is of the same
 query.
 
+#### A form over a set of rows
+
+A form gathers the live rows of a query nested directly in its own query,
+besides its own controls.  Each goes as its key and the values of the
+controls in it, under the nested query's name:
+
+```
+{ name: "lb-row-insert", query: "paychecks", values: { pay_date: "2026-10-02" },
+  rows: { deduction_types: [{ key: "401k", values: { amount: "50" } },
+                            { key: "dental", values: { amount: "" } }] } }
+```
+
+The form's own query is the one it carries, or else the nearest around it.
+A nested query is gathered when its nearest ancestor `lb-query` is the
+form's own, so one level only: a query nested deeper shows the same rows in
+every row around it, and its keys would repeat.  Every live row of it goes,
+whatever its values, and only controls inside a live row of it.
+
+An insert, an update and a declared request carry `rows`; a delete does
+not.  A form whose only controls are in nested rows sends for its own query,
+keyed by the row landed on it or the row it is pointed at, with empty
+`values`.  A live row gathers nothing nested.
+
+The handler for the form's query receives `rows` beside `values`, so the
+master and its details are written together.  The server checks that
+`rows` holds string keys and string values by query, and ignores a request
+whose `rows` does not.
+
+A nested query answers once for the page, as anywhere — see
+[Master-detail](#master-detail).  The form enters a new master with its
+details, or edits the master the page shows by a query parm, whose details
+the nested query reads from the same parm.  A pointed form fills its own
+controls from the row it points at, and its nested rows stay the nested
+query's answer.
+
+#### A row not yet entered
+
+A row whose key is the empty string is a new one, not yet entered.  It
+arises two ways: a `row` query answers with an empty key, as one reading
+the master's key from an empty query parm does, or `--lb-new` points a form
+(see [A form pointed at a row](#a-form-pointed-at-a-row)).  Either way the
+element carries `lb-key-value=""`.
+
+The hub sends no `key` for it, whether the key came from where the element
+sits or from a request a custom element dispatched.  An `lb-row-insert` and
+a declared request are sent without one.  An `lb-row-update` and an
+`lb-row-delete` are not sent, because nothing is on record to change, and
+nothing is reported: it is the row's state, not a mistake.  So a control
+saving its own column on `change` saves on a row on record, and on a new
+row only holds what a submit will gather.  No ancestor sees a request not
+sent, and it gets no `lb-request-done`.
+
+An update or a delete with no row around it at all has no key either, and
+is reported to the console, as any request missing what it needs is.
+
 A field the request already carries is its issuer's and is kept.  A custom
 element that dispatches its own request with `values` is not gathered over.
 
@@ -759,7 +945,8 @@ element that dispatches its own request with `values` is not gathered over.
 | `lb-row-update` | `query`, `key`, `values` | `rowUpdate`       |
 | `lb-row-delete` | `query`, `key`           | `rowDelete`       |
 
-The hub issues one of these only when it has what the table lists.  An
+`keys` stands in for `key`.  The hub issues one of these only when it has
+what the table lists.  An
 `lb-row-insert` or `lb-row-update` that gathers nothing is not issued.  A
 request that is not issued is reported to the console.
 
@@ -774,6 +961,125 @@ For a query the hub serves, the hub answers the request itself, with no
 round trip.  The hub serves `lb-url`, and answers `lb-row-update` for it —
 see [Query parms](#query-parms).
 
+#### A form pointed at a row
+
+A set of rows the user edits or adds to has one form on the page, naming
+the same query, outside every row.  A button points it with HTML's
+`commandfor`, naming the form's `id`, and `command`:
+
+| Command        | On a button                       | The hub                                   |
+| -------------- | --------------------------------- | ----------------------------------------- |
+| `--lb-edit`    | In a live row of the form's query | Fills the form from that row, keyed by it |
+| `--lb-new`     | Anywhere                          | Starts the form empty, for an insert      |
+| `--lb-release` | Anywhere                          | Lets the form go without saving           |
+
+HTML requires a custom command to begin with `--`, and fires it as a
+`command` event on the form, which the hub hears.
+
+```html
+<tbody lb-query="paychecks">
+  <template><tr>
+    <td lb-column="pay_date"></td>
+    <td><button type="button" commandfor="paycheck" command="--lb-edit">Edit</button></td>
+  </tr></template>
+</tbody>
+<button type="button" commandfor="paycheck" command="--lb-new">New</button>
+
+<dialog>
+  <form id="paycheck" lb-query="paychecks" lb-request="lb-row-update">
+    <input lb-column="pay_date" type="date" />
+    <button type="submit">Save</button>
+    <button type="submit" lb-request="lb-row-insert">Save new</button>
+    <button type="button" commandfor="paycheck" command="--lb-release">Cancel</button>
+  </form>
+</dialog>
+```
+
+Which row a form edits is interaction state, not a view, so it is not a
+query parm.  The user edits only a row they can see, so Edit fills the form
+from the row as the hub holds it, every column the query answered, with no
+round trip.  A row that must be fetched to be edited is another page, with
+that row as its master.
+
+Pointing a form first empties it: every column it names lands as null, and
+the form resets, so each control returns to its default.  Edit then lands
+the row on the form as on any element a `row` lands on, stamps the form
+`lb-key-value` with the row's key, and stamps the row `lb-row-editing`.
+Gathering then takes the key from the form.  New stamps an empty key, making
+the form [a row not yet entered](#a-row-not-yet-entered).  Both focus the
+form's first control.
+
+| The form's `lb-key-value` | The form is        |
+| ------------------------- | ------------------ |
+| A key                     | Editing that row   |
+| Empty                     | Entering a new row |
+| Absent                    | Not in use         |
+
+A stylesheet shows the form's buttons by it, such as Save while it has a
+key and Save new while the key is empty.
+
+A request from the form that succeeds lets it go, as `--lb-release` does:
+the form empties, and both stamps go.  One that fails leaves the form
+pointed, as the user had it.
+
+When the form is inside a `<dialog>`, Edit and New call `showModal()` on it,
+and letting go closes it.  The dialog closing by any of HTML's means,
+Escape, `command="close"` or `method="dialog"`, lets the form go.  A form in
+no dialog opens nothing; it is always showing, or a stylesheet shows it
+while it carries `lb-key-value`.
+
+The form names a `rows` query and holds no row template, so that query's
+answers land nothing on it, and what the user typed survives a refresh.
+
+A command the hub cannot carry out is reported to the console: Edit from
+outside a live row of the form's query, Edit for a key the hub holds no row
+for, and any command aimed at an element that is not a form carrying
+`lb-query`.
+
+#### Selecting rows
+
+A checkbox carrying `lb-select` in a row template selects the live row it
+sits in, and the hub stamps the row `lb-row-selected` while it is ticked.
+It is not a column: it carries no `lb-column` or `lb-request`, lands
+nothing, and is not gathered.
+
+A request for the query that names no one row, neither from inside one of
+its rows nor from a form pointed at one, acts on the rows selected.  When
+any `lb-select` checkbox of that query is showing, the hub adds the keys of
+those ticked as `keys`:
+
+```
+{ name: "lb-row-update", query: "transactions", keys: ["4", "9"], values: { acct: "12" } }
+```
+
+- `lb-row-update` and `lb-row-delete` are sent with `keys`, and with none
+  ticked are not sent, silently, as for [a row not yet
+  entered](#a-row-not-yet-entered).
+- A declared request is sent with `keys`, empty when none is ticked, and the
+  handler decides.
+- `lb-row-insert` adds a row, and the selection is not its.
+- With no `lb-select` checkbox of the query showing, the request is an
+  ordinary one, and carries no `keys`.
+
+The server runs the page's `rowUpdate` or `rowDelete` once for each key,
+with that key, as for each row alone, so a handler written for one row
+serves several.  It lays the patches the runs return together, and runs the
+refresh set once.  A run returning `url()` is reported and ignored, since
+several rows cannot each choose one view.  A declared request receives
+`keys` as sent.
+
+After the request succeeds, the hub clears every `lb-select` checkbox of the
+query and the stamps with them.  A failed request leaves the selection.
+
+Only a checkbox that is showing counts: one parked by `lb-show` is in
+template content, out of reach.  Parking one also clears its tick, so a
+selection never waits out of sight to return stale.
+
+Which rows are selected is interaction state, as which row a form edits is.
+A selecting mode the page keeps in the URL reaches the rows as a column the
+query computes from the parm, which `lb-show` reads, since `lb-show` reads
+from the row it sits in.
+
 #### The request event
 
 The hub dispatches every request as the bubbling `lb-request` event before
@@ -817,6 +1123,46 @@ failed one.
 The hub ignores a commit on an element carrying `lb-request-pending`, so a
 pending element is disabled in fact and a stylesheet only has to show it.
 
+#### Refusals
+
+A handler refuses a request by throwing `refusal()`, exported by
+`@loadbare/app/server`, with words written for the user: a message for the
+request as a whole, a message per column, or both.
+
+```ts
+throw refusal("That series already has paychecks entered.");
+throw refusal({ amount: "Must be more than zero" });
+throw refusal("Two fields need attention.", { amount: "…", pay_date: "…" });
+```
+
+It is thrown rather than returned, so it may come from anything the handler
+calls, and rolls back whatever the application has open as any throw does.
+`hubRoutes` answers it with status 422 and `{ refusal: { message?, columns? } }`.
+Anything else thrown is a failure, answered 500 with no body, so no stack
+or database message reaches the browser.
+
+The hub shows a refusal where it belongs:
+
+- It stamps the element that committed `lb-request-refused`, whose value is
+  the whole-request message, empty when there is none.  A stylesheet shows
+  it with `attr()`.
+- For each column, it calls `setCustomValidity(message)` on the control the
+  request gathered that column from, and `reportValidity()` on the first,
+  so the browser shows the message there and moves focus to it.  A column
+  the request gathered no such control for is reported to the console.
+- `lb-request-done` carries the refusal as `refusal`, beside `error`.
+
+A refusal is not a failure: `lb-request-error` is not stamped and nothing is
+reported.  It stands until the user edits any control the request gathered,
+a form holding them resets, or the element that committed sends again;
+then every message it put up is withdrawn at once.  While a control carries
+one, the browser holds its form's submit, as for any invalid control.
+
+A form-associated custom element takes a column's message when it defines
+`setCustomValidity` and `reportValidity`; one wrapping a native control
+passes both to it.  A request for several rows takes the whole-request
+message only.
+
 #### The round trip
 
 A request the hub sends has ten seconds to come back.  Past that the hub
@@ -825,7 +1171,8 @@ its own.  An application cannot change the deadline.
 
 A round trip fails on a server error, on a network failure, or on that
 deadline, and all three stamp `lb-request-error` on the element that issued
-the request — see [Request state](#request-state).
+the request — see [Request state](#request-state).  A refusal is not a
+failure — see [Refusals](#refusals).
 
 After a successful `lb-row-insert` gathered from a form, the hub resets the
 form, after it lands the response.  A failed insert resets nothing, so the
@@ -993,8 +1340,10 @@ names each one in the row it lands.
 
 The hub sends the query parms with every round trip, a page load and a
 request alike.  The server passes them to `contextFor` — see
-[The Express server](#the-express-server).  Nothing in Loadbare assigns a
-parm a meaning.
+[The Express server](#the-express-server).  Loadbare assigns one parm a
+meaning, `lb-order-<query>`, the user's [order](#order) for a query, and it
+reaches `contextFor` like any other.  A request that changes only order
+parms of queries the hub sorts itself makes no round trip.
 
 #### An unknown page
 
@@ -1058,6 +1407,29 @@ rowInsert: {
 - A user who has moved by the time the response arrives, to another page or
   to other query parms, keeps the URL they are on.
 
+`onPageEnter` may return `url()` the same way, to move the page before
+anything shows, as an application restoring the filters and order the user
+last had does.  The page loads at the new URL in the same round trip, and
+that load does not follow `onPageEnter` again.  A `url()` leading to the
+page and parms already in hand is ignored, so the page loads once.  When to
+restore is the application's rule, such as only when the URL carries no
+parms of its own.
+
+```ts
+// The application put the parms on ctx in contextFor.
+onPageEnter: async (ctx) => {
+  if (ctx.parms.size > 0) return;
+  const saved = await ctx.db.savedView("accounts");
+  if (saved) return url(saved);
+},
+```
+
+Saving what the user has on screen is a declared request with
+`refresh: []`, whose handler each page passes to a routine the
+application's pages share.  A custom element naming `lb-url` sees every
+change of the URL and issues it, a change of order that made no round trip
+included.
+
 The page is loaded with a second context, built by `contextFor` from the new
 parms — see [The Express server](#the-express-server).
 
@@ -1067,8 +1439,9 @@ The builder checks the chrome and every page, after expansion, and refuses
 to build on any of these:
 
 - An `lb-` attribute that is not a developer attribute: `lb-query`,
-  `lb-column`, `lb-show`, `lb-request`, `lb-url-link`, `lb-url-push`,
-  `lb-url-unknown`.  Every other `lb-` attribute is a stamp.
+  `lb-column`, `lb-show`, `lb-group`, `lb-count`, `lb-sum`, `lb-avg`,
+  `lb-min`, `lb-max`, `lb-request`, `lb-select`, `lb-url-link`,
+  `lb-url-push`, `lb-url-unknown`.  Every other `lb-` attribute is a stamp.
   `lb-exp-slot` and `lb-exp-template` are consumed by expansion and never
   reach the check.
 - `lb-request` naming a value that begins with `lb-` and is not one of the
@@ -1080,6 +1453,23 @@ to build on any of these:
 - `lb-show` on a `<template>`, on a row template's root, or with no
   `lb-query` around it.
 - `lb-show="!"` or `lb-show="!!column"`, which reverse no column.
+- `lb-select` on anything but an `<input type="checkbox">`, outside a row
+  template, or beside `lb-column` or `lb-request`.
+- A `command` beginning `--lb-` that is not one of the three
+  [commands](#a-form-pointed-at-a-row), and one of them with no
+  `commandfor`.
+- `lb-group` on anything but a `<template>`, or on one holding no
+  `<template>` for its contents.
+- An aggregate on a `<template>`, and any but `lb-count` naming no column.
+- A chrome without exactly one `<lb-hub>` and exactly one `<main>`, a
+  `<main>` outside `<lb-hub>`, or a `<main>` with anything in it but
+  whitespace.
+- A page carrying an `<lb-hub>` or a `<main>`.
+
+The builder also reads the script of every custom element it ships, other
+than `<lb-hub>`, and refuses one that declares a method, accessor or field
+whose name begins with `lb` and a capital and is not in
+[Reserved methods](#reserved-methods).
 
 `lb-column` with no ancestor row is allowed: the hub gathers from it.
 
@@ -1099,7 +1489,8 @@ where the standard landmarks go: header, nav, footer, main.
 The file is an HTML document, which must contain:
 - `<lb-hub>` inside `<body>`.  The hub can only act on its children,
   that is why it is usually nested right below `<body>`. 
-- One empty `<main>` inside `<lb-hub>`.  
+- One empty `<main>` inside `<lb-hub>`.  The builder refuses a chrome
+  without exactly one of each, and a page carrying either.
 - The script tag for `/client.js`, the javascript bundle.
 
 It may also contain:
@@ -1209,6 +1600,8 @@ The builder writes `pages.ts` into `--out` whenever any page has a
 `.queries.ts` or a `.requests.ts` file.  It imports each of them, calls
 `createHub()` once over the lot, and exports the result as `hub`.  The
 server imports that rather than maintaining the registry by hand.
+`createHub` is the only implementation of the `Hub` interface, which may
+gain members in any release; an application never implements it.
 
 ```ts
 // server.ts
@@ -1244,6 +1637,16 @@ Explaining Express is beyond the scope of this technical reference.  The
 only real requirement is that the catch-all for app.html is at the end,
 so it does not catch any other files.
 
+`hubRoutes` mounts `express.json()` on its own routes, and takes that
+function's options under `json` in an optional third argument.  The default
+limit of 100 KB refuses an oversized body with a 413 before any handler
+runs, and the server log names the option.  A page that sends a file's text
+as a value needs more:
+
+```ts
+app.use(hubRoutes(hub, contextFor, { json: { limit: "5mb" } }));
+```
+
 `hubRoutes` answers `POST /lb/<stub>`, with the query string the browser is
 showing after it, verbatim.  It hands `contextFor` that query string's parms
 as a second argument, and `contextFor` puts on the context whatever a query
@@ -1273,7 +1676,8 @@ the whole path space through unchanged.
 Each key is a query name, which the markup names with `lb-query`.
 
 A query's kind and key belong to its name.  Declare each query with
-`row(key, run)` or `rows(key, run)`, naming the key column first.  A query
+`row(key, run)` or `rows(key, run, options)`, naming the key column first.
+A `rows` query's `options` declare its [order](#order).  A query
 cannot be built without one of these functions.  Every query has a key; an
 aggregate row answers with a constant one.
 
@@ -1291,14 +1695,15 @@ export const queries: Queries = {
 ```
 
 A `row` query returns one object, and a `rows` query returns an array of
-objects in the order the page shows them.  An answer that disagrees with
+objects, which the page shows in that order when the query declares none.  An answer that disagrees with
 its declared kind is left out of the response, with a warning naming the
 query.
 
 Query names cannot begin with `lb-`, that namespace is reserved for
 Loadbare/app queries the hub serves in the browser, such as
 [`lb-url`](#the-url).  `createHub` refuses at startup a page that declares
-such a name as a query, a handler or a `crud` entry.
+such a name as a query, a handler or a `crud` entry, and a query whose order
+has a term naming no column.
 
 Every query and every handler receives `ctx`, the application's own request
 context.  The application builds it once per request and hands it to the hub,
@@ -1318,7 +1723,7 @@ It has three optional keys.
 | ------------- | --------------------- | -------------------------------------------------- |
 | `handlers`    | The request name      | The page's declared requests                       |
 | `crud`        | A query name          | The three requests Loadbare provides               |
-| `onPageEnter` | Nothing               | Runs once on entering the page, before its queries |
+| `onPageEnter` | Nothing               | Runs once on entering the page, before its queries, and may move the URL |
 
 The server resolves a declared request against `handlers`, and a request
 Loadbare provides against `crud` under the request's query.  A name with no
@@ -1340,14 +1745,13 @@ and `values`, as present.
 the refreshed ones.  That is how a delta reaches the browser: wrap it in
 `patch()`, naming the rows that arrived or changed and the keys that went.
 
-A refreshed `rows` query sends every row, and the hub places every row
-again, which moves each element and takes focus from the control the user
-is in.  An update or a delete names its row by key, and removing a row
-never reorders the rest, so its handler always knows what changed:
+A refreshed `rows` query sends every row to say what changed.  An update or
+a delete names its row by key, so its handler always knows what changed and
+answers with a patch, which the hub places by the query's [order](#order):
 `createHub` refuses at startup a `crud` `rowUpdate` or `rowDelete` on a
 `rows` query whose `refresh` names that same query.  A `row` query sends one
-row and may refresh itself.  An insert may refresh its own query; see
-[Who creates and orders rows](#who-creates-and-orders-rows).
+row and may refresh itself.  An insert may refresh its own query, since its
+key exists only once the row does.
 
 `run` may instead return `url()`, a new row for `lb-url`, naming query parms
 only the write can know, such as the key of a row it inserted.  The page
@@ -1409,11 +1813,16 @@ interface HubRequest {
   name: string;
   query?: string;
   key?: string;
+  keys?: string[];
   values?: Record<string, string>;
+  rows?: Record<string, { key: string; values: Record<string, string> }[]>;
 }
 ```
 
-Every response is an array of response items:
+A refused request is answered with status 422 and
+`{ refusal: { message?, columns? } }`, and any other failure with 500 and
+no body — see [Refusals](#refusals).  Every other response is an array of
+response items:
 
 ```ts
 interface ResponseItem {
@@ -1430,9 +1839,14 @@ A response item carries exactly one of `row`, `rows` or `patch`.  A patch
 answers a `rows` query only: rows named in `rows` are added or updated, keys
 in `drop` are removed, and every other row is left alone.
 
+A `rows` item also carries `order` and `serverSortedByUrl` when the query
+declares them.
+
 `createHub(pages)` builds the `Hub`, which has two calls, both answering
-with response items: `dataForPage(page, ctx)` for a page load, and
-`runRequest(page, request, ctx)` for a request.
+with response items: `dataForPage(page, ctx, options)` for a page load, and
+`runRequest(page, request, ctx)` for a request.  `options.parms` are the
+parms the page is loaded at, and `options.follow` false ignores a `url()`
+from `onPageEnter`; `hubRoutes` passes both.
 
 ## Custom elements
 
@@ -1468,9 +1882,9 @@ Each direction has one mechanism for each kind of message:
 
 | Direction      | What                                        | How                          | Today                                            |
 | -------------- | ------------------------------------------- | ---------------------------- | ------------------------------------------------ |
-| Hub to element | State that lasts                            | An attribute the hub stamps  | `lb-column-value`, `lb-key-value`, `lb-query-row-count`, `lb-request-pending`, `lb-request-error` |
+| Hub to element | State that lasts                            | An attribute the hub stamps  | `lb-column-value`, `lb-key-value`, `lb-query-row-count`, `lb-group-*`, `lb-row-*`, `lb-request-pending`, `lb-request-error` |
 | Hub to element | State the platform already names           | A property                   | A control's `value`                              |
-| Hub to element | Work the hub needs done now, while landing  | An optional `lb` method      | `lbPlaceRow`, `lbRowsLanded`                     |
+| Hub to element | Work the hub needs done now, while landing  | An optional `lb` method      | `lbRowsLanded`                                   |
 | Hub to element | A moment an element started                 | A bubbling event             | `lb-request-done`                                |
 | Element to hub | A moment                                    | A bubbling event             | `lb-request`, and `change`, `click` and `submit` |
 
@@ -1512,8 +1926,9 @@ renders it; its content is never replaced.
 | Shows a page                             | `constructor`, `connectedCallback`           |
 | Creates a live row, before placing it    | `constructor`                                |
 | Places a live row the first time         | `connectedCallback`                          |
-| Places it again, on every set of all rows | `disconnectedCallback`, `connectedCallback` |
-| Removes a live row                       | `disconnectedCallback`                       |
+| Moves a live row the order put elsewhere | `connectedMoveCallback` where the browser moves in place, otherwise `disconnectedCallback`, `connectedCallback` |
+| Leaves a copy of a moved row behind      | The copy's `constructor`, `connectedCallback`, and later `disconnectedCallback` |
+| Removes a live row                       | `disconnectedCallback`, once its animations end |
 | Turns `lb-show` off                      | `disconnectedCallback`, `adoptedCallback`    |
 | Turns `lb-show` on                       | `adoptedCallback`, `connectedCallback`       |
 | Turns on an element shipped absent       | `constructor`, `connectedCallback`           |
@@ -1525,19 +1940,27 @@ done once per instance goes behind a flag.
 
 ### Row hooks
 
-| Method                          | Implemented By | The hub calls it                                   |
-| ------------------------------- | -------------- | -------------------------------------------------- |
-| `lbPlaceRow(el, row, template)` | Developer      | To place a live row, detached, on its first arrival and whenever all rows decide the order |
-| `lbRowsLanded()`                | Developer      | After the rows land                                |
+| Method           | Implemented By | The hub calls it                                       |
+| ---------------- | -------------- | ------------------------------------------------------ |
+| `lbRowsLanded()` | Developer      | After the rows land, with every row placed and stamped |
 
-The hub calls both on a custom element with `lb-query` and a row template.
-Both are optional.  The `RowsHost` interface in `@loadbare/app/types`
-declares them.
+The hub calls it on a custom element with `lb-query` and a row template.
+It is optional.  The `RowsHost` interface in `@loadbare/app/types` declares
+it.  The hub places every row and builds every group itself, so a custom
+element reacts to rows and never places them.  Scrolling to the row the
+page's request created is the case:
+
+```ts
+lbRowsLanded() {
+  this.querySelector(`[${ATTR_ROW_REQUESTED}="${REQUESTED_CREATED}"]`)
+    ?.scrollIntoView({ block: "nearest" });
+}
+```
 
 A custom element the builder shipped absent under `lb-show` has not
-upgraded while its column is off, and rows that land on it then are placed
-without it.  When the column first turns on and it upgrades, the hub lands
-the query's last answer on it again, as all rows, so both hooks run.
+upgraded while its column is off.  When the column first turns on and it
+upgrades, the hub lands the query's last answer on it again, as all rows,
+so the hook runs.
 
 `applyRow(root, row)`, exported by `@loadbare/app`, fills `root` from one
 row, the same operation that fills a live row.
@@ -1617,6 +2040,7 @@ ownership of its behavior are stated separately, because they differ.
 | Namespace | Applies to                                                  | Loadbare owns                                       | Defined in                                      |
 | --------- | ----------------------------------------------------------- | --------------------------------------------------- | ----------------------------------------------- |
 | `lb-*`    | Attributes, their values, queries, columns of `lb-` queries, requests, custom elements, events | The names and their behavior | [The lb-* namespace](#the-lb--namespace)        |
+| `--lb-*`  | Values of HTML's `command` attribute                        | The names and their behavior                        | [Reserved commands](#reserved-commands)         |
 | `exp-*`   | Attributes on a custom element                              | The behavior; element file authors pick the names   | [Build time parameters](#build-time-parameters) |
 | `lb*`     | Methods on custom elements                                  | The names and their behavior                        | [Row hooks](#row-hooks)                         |
 
@@ -1633,17 +2057,26 @@ it may define tomorrow.
 | `lb-column`       | Developer     | Any element                         | [Landing](#landing)                           |
 | `lb-show`         | Developer     | Any element but a `<template>`      | [Displaying by condition](#displaying-by-condition) |
 | `lb-request`      | Developer     | Any element                         | [Requests](#requests)                         |
+| `lb-select`       | Developer     | A checkbox in a row template        | [Selecting rows](#selecting-rows)             |
 | `lb-url-link`     | Developer     | An `<a>`                            | [Links](#links)                               |
 | `lb-url-push`     | Developer     | An element with `lb-request`        | [Query parms](#query-parms)                   |
 | `lb-url-unknown`  | Developer     | A `<dialog>` inside `<lb-hub>`      | [An unknown page](#an-unknown-page)           |
+| `lb-group`        | Developer     | A `<template>` holding a `<template>` | [Groups](#groups)                           |
+| `lb-count`, `lb-sum`, `lb-avg`, `lb-min`, `lb-max` | Developer | Any element but a `<template>` | [Aggregates](#aggregates) |
 | `lb-exp-slot`     | Developer     | One element in an element file      | [Slots and templates](#slots-and-templates)   |
 | `lb-exp-template` | Developer     | An element file, and a `<template>` | [Slots and templates](#slots-and-templates)   |
 | `lb-column-value` | Hub           | Every element set from a column     | [How a column lands](#how-a-column-lands)     |
-| `lb-key-value`    | Hub           | A live row, and an element a `row` lands on | [Rows](#rows)                         |
+| `lb-key-value`    | Hub           | A live row, an element a `row` lands on, and a pointed form | [Rows](#rows), [A form pointed at a row](#a-form-pointed-at-a-row) |
+| `lb-row-editing`  | Hub           | The live row a form is pointed at   | [A form pointed at a row](#a-form-pointed-at-a-row) |
+| `lb-row-selected` | Hub           | A live row its `lb-select` checkbox ticks | [Selecting rows](#selecting-rows)       |
 | `lb-row-live`     | Hub           | A live row                          | [Rows](#rows)                                 |
 | `lb-query-row-count` | Hub        | An element with a row template      | [Rows](#rows)                                 |
+| `lb-group-live`, `lb-group-column`, `lb-group-value` | Hub | Each top-level element of a group | [Groups](#groups) |
+| `lb-row-created`, `lb-row-changed`, `lb-row-moved`, `lb-row-requested` | Hub | A live row | [What happened to a row](#what-happened-to-a-row) |
+| `lb-row-leaving`, `lb-group-leaving` | Hub | A row or a group on its way out | [What happened to a row](#what-happened-to-a-row) |
 | `lb-request-pending` | Hub        | The element that issued a request   | [Request state](#request-state)               |
 | `lb-request-error`   | Hub        | The element that issued a request   | [Request state](#request-state)               |
+| `lb-request-refused` | Hub        | The element whose request was refused | [Refusals](#refusals)                       |
 | `lb-show` on a `<template>` | Hub and builder | Where an absent element stands | [Displaying by condition](#displaying-by-condition) |
 | `lb-page`         | Builder       | A page's `<template>`               | [Page HTML](#page-html)                       |
 | `lb-page-title`   | Builder       | A page's `<template>`               | [Page HTML](#page-html)                       |
@@ -1657,6 +2090,12 @@ The builder refuses any other `lb-` attribute in markup — see
 | -------- | ----- | --------- | --------------------------------------------------------------- | ------------------- |
 | `lb-url` | `row` | `lb-path` | `lb-path`, `lb-page-label`, `lb-page-unknown`, every query parm | [The URL](#the-url) |
 
+### Reserved query parms
+
+| Parm               | Means                       | Defined in      |
+| ------------------ | --------------------------- | --------------- |
+| `lb-order-<query>` | The user's order for a query | [Order](#order) |
+
 ### Reserved request names
 
 | Request name    | Runs under `crud` | Defined in                          |
@@ -1665,6 +2104,17 @@ The builder refuses any other `lb-` attribute in markup — see
 | `lb-row-update` | `rowUpdate`       | [The request names](#the-request-names) |
 | `lb-row-delete` | `rowDelete`       | [The request names](#the-request-names) |
 
+### Reserved commands
+
+Loadbare/app owns every value of HTML's `command` attribute beginning with
+`--lb-`.
+
+| Command        | Defined in                                          |
+| -------------- | --------------------------------------------------- |
+| `--lb-edit`    | [A form pointed at a row](#a-form-pointed-at-a-row) |
+| `--lb-new`     | [A form pointed at a row](#a-form-pointed-at-a-row) |
+| `--lb-release` | [A form pointed at a row](#a-form-pointed-at-a-row) |
+
 ### Reserved tags
 
 Loadbare/app owns every tag in this table.  An application writes them and
@@ -1688,7 +2138,6 @@ Loadbare/app owns every DOM event in this table, both the name and what its
 
 | Method         | On                                                 | Defined in              |
 | -------------- | -------------------------------------------------- | ----------------------- |
-| `lbPlaceRow`   | A custom element with `lb-query` and a row template | [Row hooks](#row-hooks) |
 | `lbRowsLanded` | A custom element with `lb-query` and a row template | [Row hooks](#row-hooks) |
 
 ### Constants
@@ -1706,9 +2155,33 @@ imports them rather than writing a string.
 | `ATTR_ROW_LIVE`           | `lb-row-live`                           |
 | `LIVE_ROW`                | `[lb-row-live]`, the selector for a live row |
 | `ATTR_QUERY_ROW_COUNT`    | `lb-query-row-count`                    |
+| `ATTR_GROUP`              | `lb-group`                              |
+| `ATTR_GROUP_LIVE`         | `lb-group-live`                         |
+| `ATTR_GROUP_COLUMN`       | `lb-group-column`                       |
+| `ATTR_GROUP_VALUE`        | `lb-group-value`                        |
+| `LIVE_GROUP`              | `[lb-group-live]`, the selector for a group's element |
+| `ATTR_COUNT`, `ATTR_SUM`, `ATTR_AVG`, `ATTR_MIN`, `ATTR_MAX` | `lb-count`, `lb-sum`, `lb-avg`, `lb-min`, `lb-max` |
+| `AGGREGATES`              | All five aggregate attributes           |
+| `ORDER_PARM_PREFIX`       | `lb-order-`                             |
+| `ORDER_DESCENDING`        | `-`, written before a column in an order |
+| `ATTR_ROW_CREATED`        | `lb-row-created`                        |
+| `ATTR_ROW_CHANGED`        | `lb-row-changed`                        |
+| `ATTR_ROW_MOVED`          | `lb-row-moved`                          |
+| `ATTR_ROW_REQUESTED`      | `lb-row-requested`                      |
+| `REQUESTED_CREATED`, `REQUESTED_CHANGED`, `REQUESTED_MOVED` | `created`, `changed`, `moved` |
+| `ATTR_ROW_LEAVING`        | `lb-row-leaving`                        |
+| `ATTR_GROUP_LEAVING`      | `lb-group-leaving`                      |
+| `COMMAND_EDIT`, `COMMAND_NEW`, `COMMAND_RELEASE` | `--lb-edit`, `--lb-new`, `--lb-release` |
+| `LB_COMMANDS`             | All three commands                      |
+| `LB_COMMAND_PREFIX`       | `--lb-`                                 |
+| `ATTR_ROW_EDITING`        | `lb-row-editing`                        |
+| `ATTR_SELECT`             | `lb-select`                             |
+| `ATTR_ROW_SELECTED`       | `lb-row-selected`                       |
 | `ATTR_REQUEST`            | `lb-request`                            |
 | `ATTR_REQUEST_PENDING`    | `lb-request-pending`                    |
 | `ATTR_REQUEST_ERROR`      | `lb-request-error`                      |
+| `ATTR_REQUEST_REFUSED`    | `lb-request-refused`                    |
+| `LB_REFUSAL_STATUS`       | `422`                                   |
 | `ATTR_URL_LINK`           | `lb-url-link`                           |
 | `ATTR_URL_PUSH`           | `lb-url-push`                           |
 | `ATTR_URL_UNKNOWN`        | `lb-url-unknown`                        |
@@ -1716,7 +2189,7 @@ imports them rather than writing a string.
 | `ATTR_EXP_TEMPLATE`       | `lb-exp-template`                       |
 | `ATTR_PAGE`               | `lb-page`                               |
 | `ATTR_PAGE_TITLE`         | `lb-page-title`                         |
-| `DEVELOPER_ATTRIBUTES`    | The seven attributes a developer writes |
+| `DEVELOPER_ATTRIBUTES`    | The fourteen attributes a developer writes |
 | `LB_EVENT_NAME`           | `lb-request`                            |
 | `LB_DONE_EVENT_NAME`      | `lb-request-done`                       |
 | `SHOW_NOT`                | `!`, written before a column in `lb-show` |