@loadbare/app 0.5.6 → 0.7.0

package/docs/reference/data-binding.md

@@ -1,10 +1,14 @@
 # Data Binding
 
 A page binds its elements to server data with four attributes, and asks the
-server to change that data with four more. The page writes all eight into
-its HTML; the server declares which queries it answers and which operations
+server to change that data with one more. The developer writes all five into
+the HTML; the server declares which queries it answers and which operations
 it permits, and refuses anything it has not declared.
 
+One vocabulary and one containment ladder: a list holds rows, a row holds
+cells. A column is the second axis, and it is what the value of `lb-cell` or
+`lb-key` always holds.
+
 ## A page that binds data
 
 Here is a page that binds a scalar, a list, and three requests:
@@ -13,23 +17,23 @@ Here is a page that binds a scalar, a list, and three requests:
 <!-- src/pages/members.page.html -->
 <h1>Members</h1>
 
-<p lb-query="dues">Dues collected this year: <span lb-cell="total"></span></p>
+<p lb-row="dues">Dues collected this year: <span lb-cell="total"></span></p>
 
-<form lb-insert lb-query="roster">
-  <input lb-cell="name" placeholder="Name" />
-  <button type="submit">Add member</button>
-</form>
+<section lb-list="roster">
+  <form lb-action="lb-row-insert">
+    <input lb-cell="name" placeholder="Name" />
+    <button type="submit">Add member</button>
+  </form>
 
-<lb-list lb-query="roster">
   <ul>
     <template lb-key="id">
       <li>
         <lb-input lb-cell="name"></lb-input>
-        <button lb-delete>Remove</button>
+        <button lb-action="lb-row-delete">Remove</button>
       </li>
     </template>
   </ul>
-</lb-list>
+</section>
 ```
 
 The queries named here — `dues` and `roster` — and the operations the page
@@ -37,85 +41,135 @@ asks for are declared on the server; see [page files](./page-files.md).
 
 ## Binding
 
-| Attribute  | Names                                                    |
-|------------|----------------------------------------------------------|
-| `lb-query` | The query a subtree displays                             |
-| `lb-key`   | The cell that identifies a row, and a live row's own key |
-| `lb-cell`  | The cell an element displays                             |
-| `lb-value` | Where a widget receives its value                        |
-
-A binding is scoped by ancestry. An element binds to the query on its
-nearest ancestor carrying `lb-query`, and to the row on its nearest ancestor
-carrying `lb-key`. Nothing else establishes scope: an element outside every
-`lb-query` is bound to nothing and displays nothing.
+| Attribute      | Written by  | Names                                     |
+|----------------|-------------|-------------------------------------------|
+| `lb-list`      | a developer | The set of rows a subtree displays        |
+| `lb-row`       | a developer | The one row a subtree displays            |
+| `lb-key`       | a developer | The column that identifies a row          |
+| `lb-cell`      | a developer | The column an element displays            |
+| `lb-key-value` | the hub     | A live row's own key                      |
+| `lb-value`     | the hub     | The value that landed on a cell           |
+
+A binding is scoped by ancestry. Either scope attribute scopes its DOM
+children, and a nested one of either kind begins a new scope, so an element
+binds to the name on its nearest ancestor carrying one, and to the row on its
+nearest ancestor carrying `lb-key-value`. Nothing else establishes scope: an
+element outside every scope is bound to nothing and displays nothing, and a
+result never crosses into a nested scope.
+
+Which of the two a subtree writes is not a choice about display. Cardinality
+is a property of the name, so one name answers with one shape, always. A page
+that shows the roster both as a set and as a single row declares two queries,
+`rosterList` and `rosterRow`, and binds each with the attribute that matches
+what it answers with.
 
 Bind an element to a cell by putting `lb-cell` on the element that shows the
-value. The scope's own root counts as a cell if it carries one, which is how
-an `<option>` — whose content model is text — displays the value it is.
+value. Its value is a column name and never a cell name: a cell has no name
+of its own, because it is identified by its row and its column, and the row
+arrives from scope. The scope's own root counts as a cell if it carries one,
+which is how an `<option>` — whose content model is text — displays the value
+it is.
 
 Name the same query on more than one subtree to display it in more than one
 place. Every subtree gets the result.
 
-One query is the hub's rather than the server's: `lb-navigation`, landed on
-every navigation with the cells `page-label` and `page-uri`. It binds the
-same way, and the `lb-` prefix on its name is what marks it as Loadbare's —
-see [Where the page is](./chrome.md#where-the-page-is).
+One name is the hub's rather than the server's: `lb-navigation`, one row
+landed on every navigation with the columns `page-label` and `page-uri`. It binds the
+same way. Its name is reserved, as every value beginning with `lb-` is in
+every `lb-` attribute: the server refuses a page that declares a query so
+named — see [Where the page is](./chrome.md#where-the-page-is).
 
-`lb-key` holds one name in two positions. On a row template it names the
-cell that identifies a row; on a row that is showing, it carries that row's
-key value. A template is never a row, so the two never collide.
+A key has a name and a value, and they are two attributes. `lb-key` on a row
+template names the column that identifies a row: it is a property of the
+list, since a list without a fixed key column is meaningless, written where
+the rows land. `lb-key-value` on a row that is showing carries that row's
+value of it. A developer writes the first and never the second.
 
 ### Where a bound value lands
 
-A value lands on a bound element one of two ways.
+A value lands on a bound element one of three ways.
 
-| Element          | Receives the value as    |
-|------------------|--------------------------|
-| A native element | Its `textContent`        |
-| A custom element | Its `lb-value` attribute |
+| Element                                | Receives the value as             |
+|----------------------------------------|-----------------------------------|
+| A custom element                       | Its `lb-value` attribute          |
+| `<select>`, `<textarea>`, or `<input>` | Its `value`, and `lb-value`       |
+| Any other native element               | Its `textContent`, and `lb-value` |
 
-A native element has no behavior of its own, so its value is its text. A
-widget owns whatever control it wraps, so it is handed the value and renders
-it itself — see [Custom Elements](./custom-elements.md#code) for
-observing `lb-value`.
+A widget owns whatever control it wraps, so it is handed the value and
+renders it itself — see [Custom Elements](./custom-elements.md#code) for
+observing `lb-value`. A form control shows its state as its `value`, so a
+`<select>` keeps its options. Any other native element has no behavior of its
+own, so its value is its text. Checkboxes, radio buttons and file inputs
+receive nothing, not even `lb-value`, and the hub reports it to the console.
 
 Nothing an application writes ever sets `lb-value`. It is written by
-Loadbare and read by the widget it is written on.
+Loadbare and read by a widget or a stylesheet.
 
-### Rows
+### Lists
 
-A query that answers with many rows is delivered to a list widget, which
-clones its row template once per row and binds each clone to one row. A
-native element has one destination for a value and cannot acquire children,
-so a query that answers with rows must be bound to a widget that accepts
-them.
+Write `lb-list` on any element, and a `<template>` inside it carrying
+`lb-key`. The hub clones that template once per row, fills each clone, and
+reconciles what is showing against what arrived. No widget is involved, and
+none is needed.
 
-Bind the widget to the query with `lb-query`, and name the key cell on the
-`<template>` inside it with `lb-key`. See
-[The Basic Widget Library](./widgets.md) for the widgets that accept
-rows, and for `lb-group` and `lb-sort`, which a list widget reads to decide
-where a row goes.
+An array is the whole set, so it decides membership and order: a row whose
+key did not arrive is gone. A patch touches only the rows it names and leaves
+every other row's contents and position alone.
 
-## Requests
+A widget enters only where the rows need scaffolding or placement that only
+it can decide — a `<select>` that builds an `<optgroup>` per distinct value, a
+table that sections and sorts. Such a widget carries `lb-list` itself and
+implements one or both of two optional methods; see
+[Decorating a list](./custom-elements.md#decorating-a-list) and
+[The Basic Widget Library](./widgets.md).
 
-Four attributes turn an interaction into a request:
+A scope with `lb-list` and no row template displays nothing, and that is not
+an error. It is bound to the list without showing it, which is what an insert
+form naming the list it adds a row to already is.
 
-| Written                   | Asks for         | Carries                      |
-|---------------------------|------------------|------------------------------|
-| `lb-action="name"`        | The named action | `name`, and what is in scope |
-| `lb-delete`               | `tupleDelete`    | `query`, `key`               |
-| `lb-insert` on a `<form>` | `tupleInsert`    | `query`, `values`            |
-| `lb-update` on a `<form>` | `tupleUpdate`    | `query`, `key`, `values`     |
-
-The shipped `<lb-input>` widget asks for a fifth, `cellChange`, carrying
-`query`, `key`, `cell`, and `value`. It sends one when the page applies
-`data-fire-on-change` to it, and stays quiet otherwise — an input inside an
-`lb-insert` or `lb-update` form is read again by the form on submit, so a
-widget that sent on its own would write the same edit twice.
+## Requests
 
-Declare every one of these on the server. A name the page has not declared,
-and an operation a query does not permit, are refused; see
-[hooks, actions, CRUD](./page-files.md#hooks-actions-crud).
+One attribute turns an interaction into a request. `lb-action` names what the
+server is asked for: an action the page declared, or one of Loadbare's
+reserved names, which are the CRUD operations.
+
+One attribute name, one wire field, one set of values. The request field
+`action` carries this attribute's value verbatim, so nothing is translated
+between the markup and the server, and the CRUD key is the same value with
+the prefix stripped and the rest camel-cased.
+
+| Written                                   | Asks for     | Carries                       |
+|-------------------------------------------|--------------|-------------------------------|
+| `lb-action="name"`                        | That action  | The scope, and what is in it  |
+| `lb-action="lb-row-delete"`               | `rowDelete`  | `list`, `key`                 |
+| `lb-action="lb-row-insert"` on a `<form>` | `rowInsert`  | `list`, `values`              |
+| `lb-action="lb-row-update"` on a `<form>` | `rowUpdate`  | `list`, `key`, `values`       |
+| `lb-action="lb-cell-change"` on a widget  | `cellChange` | `list`, `key`, `cell`, `value`|
+
+All four operations are list operations. Each needs a key, and a key exists
+only on a live row the hub stamped inside a list, so a single-row scope is
+read-only and a declared action is the only thing it can send. An application
+that wants a writable single row declares a list that answers with one row.
+
+A name beginning with `lb-` is reserved, in `lb-action` and in either scope
+attribute alike. The server refuses a page that declares an action or a query
+so named, which is what lets a reserved name be added later without colliding
+with one an application already uses. That reservation is also the whole of
+the wire discriminant: a value beginning with `lb-` is an operation, and
+anything else is a name the page declared.
+
+The hub sends the first four from a native element on the element's own
+event: a form on submit, anything else on click. A cell change needs a
+widget to say what a change is, so only a widget sends it: the shipped
+`<lb-input>` does when it carries `lb-action="lb-cell-change"`, and stays
+quiet otherwise — an input inside an `lb-row-insert` or `lb-row-update` form is read
+again by the form on submit, so a widget that sent on its own would write
+the same edit twice.
+
+Declare every action on the server, and permit every operation on its list. A
+name the page has not declared, and an operation a list does not permit, are
+refused; see
+[requests, actions, CRUD](./page-files.md#requests-actions-crud).
 
 ### Actions
 
@@ -126,10 +180,10 @@ one of the four CRUD operations:
 <button lb-action="mailRoster">Mail the roster</button>
 ```
 
-An action carries whatever binding is in scope at the element — `query`,
-`key`, `cell` — and nothing else. There is no argument list. A button
-carries no value, so the server computes the whole of the new state and the
-page displays only what came back.
+An action carries whatever binding is in scope at the element — `list` or
+`row`, whichever scoped it, plus `key` and `cell` — and nothing else. There is
+no argument list. A button carries no value, so the server computes the whole
+of the new state and the page displays only what came back.
 
 Write `lb-action` on a widget to have the widget decide what performing the
 action means. Loadbare turns a click into a request for a native element
@@ -139,30 +193,31 @@ on change, not on click.
 ### Deleting a row
 
 ```html
-<button lb-delete>Remove</button>
+<button lb-action="lb-row-delete">Remove</button>
 ```
 
-`lb-delete` needs no name. The row's `lb-query` and `lb-key` are already in
-scope, and they are all the server needs to know which row is meant and
-whether the query permits deleting it.
+`lb-row-delete` needs nothing declared. The row's `lb-list` and `lb-key-value`
+are already in scope, and they are all the server needs to know which row is
+meant and whether the list permits deleting it.
 
-Write `lb-delete` on a native element, the same as `lb-action`. A widget
-sends its own request.
+The hub sends it from a native element. A widget sends its own request.
 
 ### Forms
 
-`lb-insert` and `lb-update` both gather every `lb-cell` inside the form into
-one values map, read from the control each cell is or wraps. They differ in
-one thing: `lb-update` also carries the key of the row it is inside, and
-`lb-insert` carries none, because there is no row yet.
+A `<form>` performs its `lb-action` on submit. `lb-row-insert` and `lb-row-update`
+both gather every `lb-cell` inside the form into one values map, read from
+the control each cell is or wraps. They differ in one thing: `lb-row-update`
+also carries the key of the row it is inside, and `lb-row-insert` carries none,
+because there is no row yet. A declared name on a form sends that action on
+submit, carrying the binding and no values.
 
-Put an `lb-update` form inside the row it edits, so it has that row's key
+Put an `lb-row-update` form inside the row it edits, so it has that row's key
 from the same ancestor a delete button reads:
 
 ```html
 <template lb-key="id">
   <li>
-    <form lb-update>
+    <form lb-action="lb-row-update">
       <input lb-cell="name" />
       <button type="submit">Save</button>
     </form>
@@ -180,9 +235,33 @@ Loadbare ships static HTML and hydrates elements that are already in the
 document. There is no `if`, and none is needed: write every possibility into
 the page, and control which of them is showing.
 
-Use the standard `hidden` attribute, or CSS, and set it from a value the
-server sent. A widget that receives a value in `lb-value` is the natural
-place to do it — it is handed the current state and decides what to show:
+Every cell carries the value that landed on it as `lb-value`, so a
+stylesheet can show or hide part of a page from a value the server sent. Bind
+a column the page does not display to a hidden element:
+
+```html
+<template lb-key="id">
+  <tr>
+    <td lb-cell="name"></td>
+    <td lb-cell="locked" hidden></td>
+    <td><button lb-action="lb-row-delete">Remove</button></td>
+  </tr>
+</template>
+```
+
+```css
+tr:has([lb-cell="locked"][lb-value="true"]) button {
+  display: none;
+}
+```
+
+`lb-value` holds the string the query sent, so the query decides the spelling
+the selector matches. A stylesheet can hide a control but cannot disable one,
+and hiding is presentation: the server still refuses what a request may not
+do.
+
+Where showing a case takes more than a selector, a widget receives the value
+in `lb-value` and decides what to show:
 
 ```ts
 for (const step of steps) step.hidden = step.dataset.step !== value;
@@ -193,31 +272,34 @@ HTML.
 
 ### An empty list
 
-A list widget stamps itself with `data-rows`, the number of rows it is
+The hub stamps every list scope with `lb-row-count`, the number of rows it is
 showing. It is the one conditional a page cannot be sent, because the server
-answers with rows and says nothing about how many survived. It makes an
-empty list a stylesheet rule rather than code in every list widget:
+answers with rows and says nothing about how many survived. It makes an empty
+list a stylesheet rule rather than code anywhere:
 
 ```html
-<lb-list lb-query="roster">
+<div lb-list="roster">
   <ul>
     <template lb-key="id">
       <li lb-cell="name"></li>
     </template>
   </ul>
   <p class="roster-empty">No members yet.</p>
-</lb-list>
+</div>
 ```
 
 ```css
 .roster-empty {
   display: none;
 }
-lb-list[data-rows="0"] .roster-empty {
+[lb-row-count="0"] .roster-empty {
   display: revert;
 }
 ```
 
+The scope is a `<div>` here rather than the `<ul>`, so that the empty message
+is inside it and the same rule can reach both.
+
 ## Request state
 
 Loadbare stamps two attributes on the element a request came from — the
@@ -225,11 +307,11 @@ button, the form, or the widget itself:
 
 | Attribute         | Means                                     |
 |-------------------|-------------------------------------------|
-| `data-lb-pending` | The request is in flight                  |
-| `data-lb-error`   | The last request from this element failed |
+| `lb-pending` | The request is in flight                  |
+| `lb-error`   | The last request from this element failed |
 
-`data-lb-pending` is set when the request goes out and removed when it
-settles. `data-lb-error` is set on a failed response, a network failure, or
+`lb-pending` is set when the request goes out and removed when it
+settles. `lb-error` is set on a failed response, a network failure, or
 a timeout alike, and cleared when that element sends its next request.
 
 Neither one carries any meaning beyond the fact it states. Dim a pending

package/docs/reference/overview.md

@@ -26,7 +26,7 @@ serves, and the widgets those pages are made of.
 |---------------------------------------------------------|--------------------------------|
 | [`<name>.page.html`](./page-files.md#html)              | The page's HTML                |
 | [`<name>.queries.ts`](./page-files.md#queries)          | The data the page displays     |
-| [`<name>.hooks.ts`](./page-files.md#hooks-actions-crud) | Data Channel handlers          |
+| [`<name>.requests.ts`](./page-files.md#requests-actions-crud) | Data Channel handlers          |
 | [Data Binding](./data-binding.md)                       | Connecting HTML to server data |
 
 ## Widgets

package/docs/reference/page-files.md

@@ -1,13 +1,13 @@
 # Page Files
 
 A page is a set of files sharing one base name. The application writes the
-HTML, and adds queries and hooks when the page shows data.
+HTML, and adds queries and requests when the page shows data.
 
-| File                | Holds                         |
-|---------------------|-------------------------------|
-| `<name>.page.html`  | The page's HTML               |
-| `<name>.queries.ts` | The data the page displays    |
-| `<name>.hooks.ts`   | What the page does when asked |
+| File                 | Holds                         |
+|----------------------|-------------------------------|
+| `<name>.page.html`   | The page's HTML               |
+| `<name>.queries.ts`  | The data the page displays    |
+| `<name>.requests.ts` | What the page does when asked |
 
 Name the landing page `index.page.html`. A bare `/` resolves to `index`, and
 every other path names the page of the same name.
@@ -25,12 +25,12 @@ is supplied by [chrome.html](./chrome.md).
 <h1>About</h1>
 <p>This is the about page.</p>
 
-<div lb-query="visits">
+<div lb-row="visits">
   <p>This page has been visited <span lb-cell="count"></span> times.</p>
 </div>
 ```
 
-Bind elements to data with `lb-query`, `lb-cell`, and the rest of the
+Bind elements to data with `lb-list` or `lb-row`, `lb-cell`, and the rest of the
 attribute vocabulary in [Data Binding](./data-binding.md).
 
 A page that displays no data needs no other file.
@@ -38,56 +38,64 @@ A page that displays no data needs no other file.
 ## Queries
 
 Export `queries` from `<name>.queries.ts`. Each key is a name the HTML binds
-to with `lb-query`, and each value takes the request context and returns
+to with `lb-list` or `lb-row`, and each value takes the request context and returns
 that query's result:
 
 ```ts
 // src/pages/about.queries.ts
-import { type Queries } from "@loadbare/app/server";
+import { row, type Queries } from "@loadbare/app/server";
 
 export const queries: Queries = {
-  visits: async (ctx) => ({ count: String(await ctx.db.visitCount()) }),
+  visits: row(async (ctx) => ({ count: String(await ctx.db.visitCount()) })),
 };
 ```
 
-Return every cell as a string. Format numbers, dates, and money in the query,
-so the browser displays a value it never computes.
+Declare each query with `row()` or `list()`. Cardinality is a property of the
+name rather than of any one answer, so one name answers with one shape,
+always, and `createHub` refuses an answer that disagrees. A page that needs
+the same data as one row and as a set declares two queries.
 
-Return many rows through `rows()`:
+The hub hands each cell to the browser untouched and takes no position on
+its type, so what a number, a date or a null looks like is decided here, in
+the query. Formatting it here means the browser displays a value it never
+computes.
+
+Declare a query that answers with many rows using `list()`, and return the
+array itself:
 
 ```ts
 // src/pages/directory.queries.ts
-import { rows, type Queries } from "@loadbare/app/server";
+import { list, type Queries } from "@loadbare/app/server";
 
 export const queries: Queries = {
-  directory: async (ctx) => rows(await ctx.db.directory()),
+  directory: list((ctx) => ctx.db.directory()),
 };
 ```
 
-Give every row a cell that identifies it, and name that cell with `lb-key` in
-the HTML. Return the rows in the order the page shows them.
+Give every row a column that identifies it, and name that column with
+`lb-key` in the HTML. Return the rows in the order the page shows them.
 
-Return the full result every time. Sending only what changed is a hook's job —
+Return the full result every time. Sending only what changed is a request's job —
 see [refresh and patch](#refresh-and-patch).
 
-## Hooks, actions, CRUD
+## Requests, actions, CRUD
 
-Export `hooks` from `<name>.hooks.ts`. It holds three keys, each optional:
+Export `requests` from `<name>.requests.ts`. It holds three keys, each optional:
 
-| Key         | Runs                                                 |
-|-------------|------------------------------------------------------|
-| `beforeGet` | Before the page's queries, on a request for the page |
-| `actions`   | What the page may be asked to do, by name            |
-| `crud`      | The four operations a query permits on its rows      |
+| Key           | Runs                                                 |
+|---------------|------------------------------------------------------|
+| `onPageEnter` | Before the page's queries, on entering the page      |
+| `actions`     | What the page may be asked to do, by name            |
+| `crud`        | The four operations a list permits on its rows       |
 
-### beforeGet
+### onPageEnter
 
 ```ts
-// src/pages/about.hooks.ts
-import { type Hooks } from "@loadbare/app/server";
+// src/pages/about.requests.ts
+import { type Requests } from "@loadbare/app/server";
 
-export const hooks: Hooks = {
-  beforeGet: (ctx) => ctx.db.recordVisit(),
+export const requests: Requests = {
+  onPageEnter: (ctx) => ctx.db.recordVisit(),
 };
 ```
 
@@ -99,7 +107,7 @@ Declare an action under the name the HTML gives `lb-action`. Pair what it
 does with the queries to re-run once it has:
 
 ```ts
-export const hooks: Hooks = {
+export const requests: Requests = {
   actions: {
     resetVisits: {
       run: (ctx) => ctx.db.resetVisits(),
@@ -113,29 +121,36 @@ Declare every action the page allows. A name the page does not declare is
 refused.
 
 Read where the interaction happened from `run`'s second argument, which
-carries `query`, `key`, `cell`, and `value` when the element that dispatched
-the request had them.
+carries `list` or `row`, whichever attribute scoped the element, plus `key`,
+`cell` and `value` when the element that dispatched the request had them.
 
 ### crud
 
-Declare CRUD operations under `crud`, keyed by the query they operate on. Each
-one takes the binding its trigger supplies:
+Declare CRUD operations under `crud`, keyed by the list they operate on. All
+four are list operations: each needs a key, and a key exists only on a live
+row inside a list, so a single-row scope is read-only and a declared action is
+the only thing it can send. Each operation takes the binding its trigger
+supplies:
+
+| Operation     | The page writes                          | `run` receives         |
+|---------------|------------------------------------------|------------------------|
+| `cellChange`  | `<lb-input lb-action="lb-cell-change">`  | `key`, `cell`, `value` |
+| `rowDelete` | `lb-action="lb-row-delete"`                  | `key`                  |
+| `rowInsert` | `<form lb-action="lb-row-insert">`           | `values`               |
+| `rowUpdate` | `<form lb-action="lb-row-update">`           | `key`, `values`        |
 
-| Operation     | The page writes    | `run` receives         |
-|---------------|--------------------|------------------------|
-| `cellChange`  | `<lb-input data-fire-on-change>` | `key`, `cell`, `value` |
-| `tupleDelete` | `lb-delete`        | `key`                  |
-| `tupleInsert` | `<form lb-insert>` | `values`               |
-| `tupleUpdate` | `<form lb-update>` | `key`, `values`        |
+The operation names are reserved: a name beginning with `lb-` cannot be
+declared under `actions` or as a query, and `createHub` refuses a page that
+tries.
 
 ```ts
-// src/pages/directory.hooks.ts
-import { patch, type Hooks } from "@loadbare/app/server";
+// src/pages/directory.requests.ts
+import { patch, type Requests } from "@loadbare/app/server";
 
-export const hooks: Hooks = {
+export const requests: Requests = {
   crud: {
     directory: {
-      tupleInsert: {
+      rowInsert: {
         run: async (ctx, { values }) => {
           const entry = await ctx.db.addDirectoryEntry(values);
           return { directory: patch({ rows: [entry] }) };
@@ -147,8 +162,8 @@ export const hooks: Hooks = {
 };
 ```
 
-Declare every operation the query permits. An operation a query does not
-declare is refused, and a query with no `crud` entry permits none.
+Declare every operation the list permits. An operation a list does not
+declare is refused, and a name with no `crud` entry permits none.
 
 ### refresh and patch
 
@@ -159,7 +174,7 @@ would. What `run` returns is laid over the refreshed queries:
 
 | Result                   | States                                      |
 |--------------------------|---------------------------------------------|
-| `rows([...])`            | The entire set, and its order               |
+| `[...]`                  | The entire set, and its order               |
 | `patch({ rows: [...] })` | These rows arrive or change; the rest stand |
 | `patch({ drop: [...] })` | These keys are gone; the rest stand         |