@loadbare/app 0.7.2 → 0.7.4

package/docs/TECHREF-1.0.md

@@ -10,8 +10,8 @@ to be true, then revise the code, docs, and tests to ensure it is true.
 We cannot declare 1.0 until we determine if these blockers can be
 added later w/o breaking changes.  If we are reasonably confident
 that they can be decided later w/o breaking changes, then we rename
-them to "Out of Scope".  Otherwise, they must be resolved before
-we declare 1.0.
+them to "Out of Scope" or move them to the roadmap.  Otherwise, 
+they must be resolved before we declare 1.0.
 
 ### Data types
 
@@ -59,6 +59,15 @@ That decision is firm; what the set contains is not.
 
 ### Lists
 
+Imagine we have an HTML `<select>` that displays a fixed list for all
+rows in a table, such as `customer_type` for a table of customers.  When
+all customers can be any customer type, our system as written today
+is fine, because all HTML `<select>` elements get the same list.
+
+But it may be that the list of allowed values is dependent on other values
+in the row.   
+
+
 - **Decide how a new row fills a nested list.** A row added to the outer
   list starts with an empty nested list, which fills only when the nested
   list's name lands again.  See [Master-detail](#master-detail) for what a
@@ -210,7 +219,7 @@ the whole of `--src` is one flat namespace, as stated in
 Three kinds of file hold HTML.
 
 | File               | Holds                                | Found in     |
-|--------------------|--------------------------------------|--------------|
+| ------------------ | ------------------------------------ | ------------ |
 | `chrome.html`      | The one HTML document                | `--src`      |
 | `<stub>.page.html` | One page's markup, as a fragment     | `--src`      |
 | `<tag-name>.html`  | One widget definition, as a fragment | Every origin |
@@ -277,13 +286,13 @@ A definition states a default with `{{name|default}}`, as in
 `{{button-label|OK}}`.  Whitespace around the name and around the default is
 discarded.  The default is a literal.
 
-| The attribute is assigned | Expansion defines  | Result                           |
-|---------------------------|--------------------|----------------------------------|
-| `exp-name="text"`         | `{{name}}`         | `text`                           |
-| `exp-name=""`             | `{{name}}`         | An empty string                  |
-| Nothing                   | `{{name|default}}` | `default`                        |
-| Nothing                   | `{{name}}`         | Nothing, and the attribute drops |
-| `exp-name`                | No `{{name}}`      | A build error                    |
+| The attribute is assigned | Expansion defines   | Result                           |
+| ------------------------- | ------------------- | -------------------------------- |
+| `exp-name="text"`         | `{{name}}`          | `text`                           |
+| `exp-name=""`             | `{{name}}`          | An empty string                  |
+| Nothing                   | `{{name\|default}}` | `default`                        |
+| Nothing                   | `{{name}}`          | Nothing, and the attribute drops |
+| `exp-name`                | No `{{name}}`       | A build error                    |
 
 Attributes without the `exp-` prefix are ignored during expansion.
 
@@ -370,20 +379,19 @@ These are build errors:
 
 ### Binding
 
----- UNEDITED ----
-
 Binding attributes determine how the hub updates the DOM, either by
 directly updating a plain HTML element or instructing 
 custom widgets to update themselves.
 
 
-| Attribute    | Assigned By | Behavior                                                                                  |
-|--------------|-------------|-------------------------------------------------------------------------------------------|
-| lb-list      | Developer   | Scopes DOM children to a named set of rows; a nested lb-list or lb-row begins a new scope |
-| lb-row       | Developer   | Scopes DOM children to one named row; a nested lb-list or lb-row begins a new scope       |
-| lb-cell      | Developer   | This DOM node displays this column of the row in scope                                    |
-| lb-key       | Developer   | Names the column that identifies a row, on the row template inside an lb-list             |
-| lb-key-value | Hub         | Stamped on a live row: that row's value of `lb-key`                                       |
+| Attribute    | Assigned By | Behavior                                                                                        |
+| ------------ | ----------- | ----------------------------------------------------------------------------------------------- |
+| lb-list      | Developer   | Scopes DOM children to a named set of rows; a nested lb-list or lb-row begins a new scope       |
+| lb-row       | Developer   | Scopes DOM children to one named row; a nested lb-list or lb-row begins a new scope             |
+| lb-cell      | Developer   | This DOM node displays this column of the row in scope                                          |
+| lb-show      | Developer   | This DOM node is present when this column of the row in scope is neither null nor false         |
+| lb-key       | Developer   | Names the column that identifies a row, on the row template inside an lb-list                   |
+| lb-key-value | Hub         | Stamped on a live row: that row's value of `lb-key`                                             |
 | lb-value     | Hub         | The value that landed on a cell; a widget updates itself from it and a stylesheet selects on it |
 
 #### How a value lands
@@ -391,11 +399,11 @@ custom widgets to update themselves.
 A cell lands one of three ways, and the element decides which.  Every cell
 that receives a value also carries it as `lb-value`.
 
-| Element                                             | Receives the value as                |
-|-----------------------------------------------------|--------------------------------------|
-| A custom element, tag hyphenated                    | Its `lb-value` attribute             |
-| `<select>`, `<textarea>`, or `<input>`              | Its `value`, and `lb-value`          |
-| Any other native element                            | Its `textContent`, and `lb-value`    |
+| Element                                | Receives the value as             |
+| -------------------------------------- | --------------------------------- |
+| A custom element, tag hyphenated       | Its `lb-value` attribute          |
+| `<select>`, `<textarea>`, or `<input>` | Its `value`, and `lb-value`       |
+| Any other native element               | Its `textContent`, and `lb-value` |
 
 A widget owns whatever control it wraps, so it is handed the value and
 renders it itself.  A form control shows its state as its `value`, so a
@@ -433,30 +441,44 @@ A widget sees `attributeChangedCallback` for an `lb-value` already present
 when it upgrades, so a widget cannot tell a first landing from a refresh,
 and does not need to.
 
-#### Displaying by value
+#### Displaying by condition
 
-A stylesheet selects on `lb-value` to show or hide part of a page according
-to a value that landed.  A column the page does not display is bound to a
-hidden element.
+`lb-show` names the column that decides whether an element is present.
+`null` and `false` are off, and every other value is on.  No string is read,
+so `"false"` is on, and a query spells a condition as a boolean or a null.
 
 ```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>
+    <td><button lb-action="lb-row-delete" lb-show="removable">Remove</button></td>
   </tr>
 </template>
 ```
 
-```css
-tr:has([lb-cell="locked"][lb-value="true"]) button { display: none; }
-```
+It binds as `lb-cell` does, to the row on the nearest scoped ancestor, and on
+an element that is itself a scope the column belongs to the row around it.  A row
+that does not carry the column leaves the element as it is.
 
-`lb-value` holds the string the query sent, so the query decides the spelling
-a selector matches.  A hidden control is out of reach, keyboard included; a
-stylesheet cannot disable one, which is a widget's job.  Hiding is
-presentation, and the server still refuses what a request may not do.
+An element that is off is moved into a `<template lb-show="column">` standing
+where it stood, and moved back out when the column turns on.  It is not
+rendered, focused, clicked, announced or gathered.  It is moved and never
+rebuilt, so a widget keeps its instance.  Landing reaches into that template,
+and nothing else does, so the element and every cell and scope inside it
+return current.  A custom element sees `disconnectedCallback` then
+`adoptedCallback` going in, and `adoptedCallback` then `connectedCallback`
+coming out, and still receives `lb-value` while it is away.
+
+The builder ships every `lb-show` element already inside its template, so
+nothing conditional shows until its row lands.  An absent element's template
+keeps its place among its siblings, and a position selector counts it.
+
+These are build errors: `lb-show` on a row template's root, with no row
+around it (outside every scope, on a scope with none around it, or in a list
+scope outside its row template), or on a `<template>`.
+
+Hiding is presentation, and the server still refuses what a request may not
+do.
 
 #### Master-detail
 
@@ -504,10 +526,10 @@ name, the same test that decides how a value lands — see
 [How a value lands](#how-a-value-lands).
 
 | lb-action      | Written on                                        |
-|----------------|---------------------------------------------------|
-| lb-row-insert  | a `<form>`, or a button by its cells, in a list   |
+| -------------- | ------------------------------------------------- |
+| lb-row-insert  | a `<form>`, or a button in a `<tr>`, in a list    |
 | lb-row-delete  | anything inside a live row                        |
-| lb-row-update  | a `<form>`, or a button by its cells, in a row    |
+| lb-row-update  | a `<form>`, or a button in a live row             |
 | lb-cell-change | a widget wrapping one control                     |
 | anything else  | must be a named routine in the page's server code |
 
@@ -520,13 +542,13 @@ dispatched it.  It reads the scope from the dispatching element before any
 ancestor sees the event, and never overwrites a field the request already
 carries.
 
-| `action`         | Filled from scope              | Required                   |
-|------------------|--------------------------------|----------------------------|
-| a declared name  | `list` or `row`, `key`, `cell` | nothing                    |
-| `lb-cell-change` | `list`, `key`, `cell`          | all three, and `value`     |
-| `lb-row-insert`  | `list`                         | `list`, and `values`       |
-| `lb-row-delete`  | `list`, `key`                  | both                       |
-| `lb-row-update`  | `list`, `key`                  | both, and `values`         |
+| `action`         | Filled from scope              | Required               |
+| ---------------- | ------------------------------ | ---------------------- |
+| a declared name  | `list` or `row`, `key`, `cell` | nothing                |
+| `lb-cell-change` | `list`, `key`, `cell`          | all three, and `value` |
+| `lb-row-insert`  | `list`                         | `list`, and `values`   |
+| `lb-row-delete`  | `list`, `key`                  | both                   |
+| `lb-row-update`  | `list`, `key`                  | both, and `values`     |
 
 An element's own `lb-list` or `lb-row` names what it displays, never where
 its request goes.  A request belongs to the scope around the element, the
@@ -534,14 +556,21 @@ way a control belongs to the form around it.  `list` or `row` comes from the
 nearest ancestor scope, `key` from the nearest live row inside that scope,
 and `cell` from the dispatching element's own `lb-cell`.
 A request missing a required field is not sent.  The hub never fills
-`value`; for `lb-row-insert` and `lb-row-update`, `values` is gathered from
-the nearest element holding an `lb-cell` with a control to read, starting at
-the dispatching element and walking up.  A `<form>` holds its own cells; a
-button in a `<tr>` for a new row, which cannot be a form, reads the row
-around it.  The walk stops at the live row the element sits in and never
-reaches the scope, whose other cells belong to other rows.  A request that
-already carries `values` keeps them, and one with no cell to read is not
-sent.  A click inside a native element that carries either operation and
+`value`.  An `lb-row-insert` or `lb-row-update` gathers the row it belongs
+to: `values` holds every `lb-cell` with a control to read in the nearest
+`<form>`, `<tr>` or live row around the dispatching element, itself
+included, inside its scope.  The cells are found the way a row lands, so a
+cell inside a scope nested in the row is that scope's and is not gathered,
+while an element carrying a scope and `lb-cell` both is the row's cell.
+This is a button's form owner: what else sits
+beside the element never changes what is sent.  A `<tr>` counts because a
+form cannot go around a table row's controls, so a new row in a table is its
+own form; a live row counts because it is the row the key names.  The scope
+itself is never the row, since its cells belong to other rows.  A request
+from an element in no form or row is not sent, and the hub reports that its
+cells belong in a `<form>`.  A request that already carries `values` keeps
+them, and one whose row has no cell to read is not sent.  A click inside a
+native element that carries either operation and
 holds cells itself is not sent, since clicking into one of its controls
 would send the row: put the action on a form or on a button.
 
@@ -617,7 +646,7 @@ other link, so leaving the application is the default and staying in it is
 the opt-in.
 
 | Attribute   | Assigned By | Behavior                                                                                |
-|-------------|-------------|-----------------------------------------------------------------------------------------|
+| ----------- | ----------- | --------------------------------------------------------------------------------------- |
 | lb-nav-link | Developer   | On an `<a>`: the hub shows the page the anchor's path names, without loading a document |
 
 The attribute takes no value.  The hub looks for the nearest ancestor 
@@ -670,7 +699,7 @@ Current page, published by the hub as a row.  Can be bound anywhere just
 like a server-produced result.
 
 | Cell         | Holds                                                               |
-|--------------|---------------------------------------------------------------------|
+| ------------ | ------------------------------------------------------------------- |
 | `page-label` | The text of the link to the current page, empty if no link names it |
 | `page-uri`   | The path as the browser has it, such as `/members`                  |
 
@@ -792,7 +821,7 @@ client script, the stylesheet, the hub's data channel, and the one HTML
 document.
 
 | Handle                       | With                |
-|------------------------------|---------------------|
+| ---------------------------- | ------------------- |
 | `/client.js`                 | `dist/client.js`    |
 | `/app.css`                   | `dist/app.css`      |
 | `hubRoutes(hub, contextFor)` | The hub's own route |
@@ -881,7 +910,7 @@ as explained in the next section.
 It has three optional keys.
 
 | Key           | Keyed by              | Answers                                            |
-|---------------|-----------------------|----------------------------------------------------|
+| ------------- | --------------------- | -------------------------------------------------- |
 | `actions`     | The `lb-action` value | Anything the page chooses to declare               |
 | `crud`        | A query name          | The four reserved `lb-action` values               |
 | `onPageEnter` | Nothing               | Runs once on entering the page, before its queries |
@@ -938,7 +967,7 @@ are one vocabulary.  All four operate on a list, because each needs a key and
 a key exists only on a live row.
 
 | `lb-action`      | Key under `crud` | `where` carries        |
-|------------------|------------------|------------------------|
+| ---------------- | ---------------- | ---------------------- |
 | `lb-cell-change` | `cellChange`     | `key`, `cell`, `value` |
 | `lb-row-delete`  | `rowDelete`      | `key`                  |
 | `lb-row-insert`  | `rowInsert`      | `values`               |
@@ -981,21 +1010,31 @@ The hub stamps these on the element that dispatched a request, which is the
 widget itself when a widget fired it.  A widget observes them and reacts; it
 must name them in `observedAttributes` to see them change.
 
-| Attribute      | Written on              | Holds                                           |
-|----------------|-------------------------|-------------------------------------------------|
-| `lb-pending`   | The dispatching element | The round trip is in flight                     |
+| Attribute      | Written on              | Holds                                                                                   |
+| -------------- | ----------------------- | --------------------------------------------------------------------------------------- |
+| `lb-pending`   | The dispatching element | The round trip is in flight                                                             |
 | `lb-error`     | The dispatching element | The last round trip failed, cleared on the next — see [The round trip](#the-round-trip) |
-| `lb-row-count` | A list scope            | How many rows the scope is showing              |
+| `lb-row-count` | A list scope            | How many rows the scope is showing                                                      |
+
+They are also stamped on plain HTML, where a stylesheet is the only
+consumer: dim a pending button, mark a failed one, and style an empty list
+against `lb-row-count` rather than carrying an empty-state element.
+
+The hub reads one of them.  A native `lb-action` element, a button or a
+form, that is performed again while it carries `lb-pending` is ignored: the
+click or submit is cancelled and nothing is sent.  A pending native action is
+therefore disabled in fact, and a stylesheet only has to show it.  A widget is
+not held back this way, because a widget that sends on change must have its
+latest value sent rather than dropped.
 
-The hub writes all three and never reads them.  They are also stamped on
-plain HTML, where a stylesheet is the only consumer: dim a pending button,
-mark a failed one, and style an empty list against `lb-row-count` rather than
-carrying an empty-state element.
+Alongside `lb-pending` the hub sets `aria-busy="true"` on the same element and
+removes it when the round trip settles, so assistive technology hears the
+state a stylesheet shows.
 
 #### Row hooks
 
 | Name                            | Implemented By | Behavior                                                    |
-|---------------------------------|----------------|-------------------------------------------------------------|
+| ------------------------------- | -------------- | ----------------------------------------------------------- |
 | `applyRow(root, row)`           | Loadbare       | Fills one scope from one row                                |
 | `lbPlaceRow(el, row, template)` | Developer      | Optional on a list scope: where a row goes                  |
 | `lbRowsLanded()`                | Developer      | Optional on a list scope: scaffolding derived from the rows |
@@ -1020,7 +1059,7 @@ that defines it. The definition lives there and only there.
 Loadbare/app owns every flag in this table.
 
 | Flag       | Default | Names                                     | Defined in                                        |
-|------------|---------|-------------------------------------------|---------------------------------------------------|
+| ---------- | ------- | ----------------------------------------- | ------------------------------------------------- |
 | `--src`    | `src`   | The application's own tree, scanned whole | [What the builder scans](#what-the-builder-scans) |
 | `--out`    | `dist`  | Where the builder writes                  | [Running the builder](#running-the-builder)       |
 | `--watch`  | off     | Rebuild on change under `--src`           | [Running the builder](#running-the-builder)       |
@@ -1033,7 +1072,7 @@ named carries its meaning wherever it sits in the `--src` tree, so an
 application must not use one of these names for anything else.
 
 | File                    | How many               | Holds                                                    | Defined in                                              |
-|-------------------------|------------------------|----------------------------------------------------------|---------------------------------------------------------|
+| ----------------------- | ---------------------- | -------------------------------------------------------- | ------------------------------------------------------- |
 | `chrome.html`           | Exactly one            | The application's one HTML document                      | [Chrome](#chrome)                                       |
 | `imports.ts`            | Zero or one            | Default-exports an array of widget library package names | [Imported widget libraries](#imported-widget-libraries) |
 | `<stub>.page.html`      | One per page           | One page's markup, as a fragment                         | [Pages](#pages)                                         |
@@ -1051,7 +1090,7 @@ only when some origin has a stylesheet, `pages.ts` only when some page has a
 `.queries.ts` or a `.requests.ts`.
 
 | Path               | Written           | Holds                                                              | Read by    | Defined in                                  |
-|--------------------|-------------------|--------------------------------------------------------------------|------------|---------------------------------------------|
+| ------------------ | ----------------- | ------------------------------------------------------------------ | ---------- | ------------------------------------------- |
 | `/app.html`        | Always            | The chrome, built                                                  | The server | [Chrome](#chrome)                           |
 | `/client.js`       | Always            | `<lb-hub>` and every widget the application uses                   | The chrome | [Chrome](#chrome)                           |
 | `/client-entry.ts` | Always            | The generated entry `client.js` is bundled from                    | Nothing    | [Running the builder](#running-the-builder) |
@@ -1064,7 +1103,7 @@ Loadbare/app owns every key in this table. A widget library declares them.
 An application never does.
 
 | Key                | Value                     | Means                                                                        | Defined in                                              |
-|--------------------|---------------------------|------------------------------------------------------------------------------|---------------------------------------------------------|
+| ------------------ | ------------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------- |
 | `loadbare.widgets` | A path inside the package | Where this package's widgets are. Absent means the whole installed directory | [Imported widget libraries](#imported-widget-libraries) |
 
 ### Reserved namespaces
@@ -1072,11 +1111,11 @@ An application never does.
 Loadbare/app owns every namespace in this table. Ownership of a name and
 ownership of its behavior are stated separately, because they differ.
 
-| Namespace | Applies to                 | Loadbare owns                                | Defined in                                        |
-|-----------|----------------------------|----------------------------------------------|---------------------------------------------------|
-| `lb-*`    | HTML attributes            | The names and their behavior                 | [The lb-* namespace](#the-lb--namespace)           |
-| `exp-*`   | HTML attributes            | The behavior; widget authors pick the values | [Build time parameters](#build-time-parameters)   |
-| `lb*`     | Methods on custom elements | The names and their behavior                 | [Row hooks](#row-hooks)                           |
+| Namespace | Applies to                 | Loadbare owns                                | Defined in                                      |
+| --------- | -------------------------- | -------------------------------------------- | ----------------------------------------------- |
+| `lb-*`    | HTML attributes            | The names and their behavior                 | [The lb-* namespace](#the-lb--namespace)        |
+| `exp-*`   | HTML attributes            | The behavior; widget authors pick the values | [Build time parameters](#build-time-parameters) |
+| `lb*`     | Methods on custom elements | The names and their behavior                 | [Row hooks](#row-hooks)                         |
 
 #### The lb-* namespace
 
@@ -1090,23 +1129,24 @@ actions on the wire — see [Page Queries](#page-queries).
 
 Each attribute is defined in one section, and this table says which.
 
-| Attribute        | Written by  | Defined in                                        |
-|------------------|-------------|---------------------------------------------------|
-| `lb-list`        | Developer   | [Binding](#binding)                               |
-| `lb-row`         | Developer   | [Binding](#binding)                               |
-| `lb-cell`        | Developer   | [Binding](#binding)                               |
-| `lb-key`         | Developer   | [Binding](#binding)                               |
-| `lb-key-value`   | Hub         | [Binding](#binding)                               |
-| `lb-value`       | Hub         | [How a value lands](#how-a-value-lands)           |
-| `lb-action`      | Developer   | [Requests](#requests)                             |
-| `lb-nav-link`    | Developer   | [Links](#links)                                   |
-| `lb-pending`     | Hub         | [Request state](#request-state)                   |
-| `lb-error`       | Hub         | [Request state](#request-state)                   |
-| `lb-row-count`   | Hub         | [Request state](#request-state)                   |
-| `lb-unknown-page`| Developer   | [Chrome](#chrome)                                 |
-| `lb-slot`        | Widget author | [Slots and templates](#slots-and-templates)     |
-| `lb-template`    | Widget author | [Slots and templates](#slots-and-templates)     |
-| `lb-page`        | Builder     | [Pages](#pages)                                   |
+| Attribute         | Written by    | Defined in                                          |
+| ----------------- | ------------- | --------------------------------------------------- |
+| `lb-list`         | Developer     | [Binding](#binding)                                 |
+| `lb-row`          | Developer     | [Binding](#binding)                                 |
+| `lb-cell`         | Developer     | [Binding](#binding)                                 |
+| `lb-show`         | Developer     | [Displaying by condition](#displaying-by-condition) |
+| `lb-key`          | Developer     | [Binding](#binding)                                 |
+| `lb-key-value`    | Hub           | [Binding](#binding)                                 |
+| `lb-value`        | Hub           | [How a value lands](#how-a-value-lands)             |
+| `lb-action`       | Developer     | [Requests](#requests)                               |
+| `lb-nav-link`     | Developer     | [Links](#links)                                     |
+| `lb-pending`      | Hub           | [Request state](#request-state)                     |
+| `lb-error`        | Hub           | [Request state](#request-state)                     |
+| `lb-row-count`    | Hub           | [Request state](#request-state)                     |
+| `lb-unknown-page` | Developer     | [Chrome](#chrome)                                   |
+| `lb-slot`         | Widget author | [Slots and templates](#slots-and-templates)         |
+| `lb-template`     | Widget author | [Slots and templates](#slots-and-templates)         |
+| `lb-page`         | Builder       | [Pages](#pages)                                     |
 
 An attribute the builder does not recognize is left alone today.  Refusing
 one is on the list of validations still to land — see
@@ -1118,7 +1158,7 @@ Loadbare/app owns every tag in this table.  An application writes them and
 never defines them.
 
 | Tag        | Written in | Means                          | Defined in        |
-|------------|------------|--------------------------------|-------------------|
+| ---------- | ---------- | ------------------------------ | ----------------- |
 | `<lb-hub>` | The chrome | The application's live element | [Chrome](#chrome) |
 
 ### Reserved events
@@ -1127,7 +1167,7 @@ Loadbare/app owns every DOM event in this table, both the name and what its
 `detail` carries.
 
 | Event        | Dispatched from        | Bubbles | Cancelable | Defined in                              |
-|--------------|------------------------|---------|------------|-----------------------------------------|
+| ------------ | ---------------------- | ------- | ---------- | --------------------------------------- |
 | `lb-request` | The element that acted | Yes     | No         | [The request event](#the-request-event) |
 
 ### Reserved attributes
@@ -1136,6 +1176,6 @@ Loadbare/app owns every attribute in this table, both the name and its
 behavior.
 
 | Attribute         | Written on                          | Takes a value | Defined in        |
-|-------------------|-------------------------------------|---------------|-------------------|
+| ----------------- | ----------------------------------- | ------------- | ----------------- |
 | `lb-unknown-page` | A `<dialog>` in chrome              | No            | [Chrome](#chrome) |
 | `lb-page`         | A `<template>`, by the builder only | Yes           | [Pages](#pages)   |

package/docs/analysis-closed-set.md

@@ -0,0 +1,203 @@
+# A closed set for the Loadbare/app vocabulary
+
+> **LLM-authored, not yet revised by a person.**  Drafted by Claude on
+> 2026-09-13, from a design session against `@loadbare/app` 0.7.3 while
+> building a chart of accounts page.  Treat it as a proposal, not as the
+> author's statement.
+
+## The question
+
+Relational algebra is closed: every operation takes relations and returns a
+relation.  CRUD is closed in the same way on the write side.  Closure is what
+makes both easy to program against.  Combinations do not explode, the cases
+are finite, and nothing falls outside the model.
+
+Loadbare/app maps three data shapes (cell, row, list) and three relational
+operations (insert, update, delete) into HTML.  This document asks whether
+recent iterations have shown enough to state a **closed** vocabulary and set
+of behaviors: one where every combination of shape, operation, position,
+nesting and timing is defined, so application code never meets an edge case
+outside the model.
+
+Author note: a page can of course define invalid combinations, but their
+lack of validity must be intelligibly reported as a failure to stick to the
+closed set.
+
+"Closed" is tested four ways:
+
+1. **Shapes are closed.**  Everything a page receives is one of the shapes,
+   or a patch on a list.
+2. **Operations are closed over shapes.**  Each operation yields a defined
+   result in the same vocabulary.
+3. **Composition is closed.**  Nesting, many scopes bound to one name, scopes
+   that appear late, and several names in one response all stay inside the
+   rules.
+4. **Anything outside the spine is justified.**  It either reduces to the
+   spine or is a separate, deliberately bounded axis.
+
+## The model in one sentence
+
+> **A page holds named relations.  Every read and every write answers with
+> new values for those names.  Every scope is a view of one name.**
+
+Every rule below follows from it.
+
+## 1. Shapes: three, plus identity
+
+| Shape    | Attribute                                   | Relational                                                        |
+| -------- | ------------------------------------------- | ----------------------------------------------------------------- |
+| list     | `lb-list`                                   | a relation, as a variable that holds rows                         |
+| row      | `lb-row`                                    | a single row, read-only; a writable single row is a list of one   |
+| cell     | `lb-cell`                                   | a column value                                                    |
+| identity | `lb-key` written, `lb-key-value` stamped    | the primary key                                                   |
+
+## 2. What every answer is made of: three forms
+
+Every query, CRUD operation, declared action and refresh answers with
+`{ name: result }`, and each result is one of:
+
+- **a whole list** (an array), which replaces the relation, membership and
+  order included;
+- **a patch** (`{ rows, drop }`), which upserts rows by key and drops keys;
+- **a row** (an object), which replaces the single row.
+
+This is the closure property.  No operation answers with HTML, a redirect, or
+instructions.  Declared actions are open-ended, like stored procedures, but
+their results are still in these three forms, so the landing side stays
+closed.
+
+## 3. Operations: three, plus one open door
+
+| Operation        | Takes from position    | Carries                                      | Answers      |
+| ---------------- | -------------------    | -------------------------------------------- | ------------ |
+| `lb-row-insert`  | list                   | values, gathered from the record             | patch rows   |
+| `lb-row-update`  | list, key              | values, gathered or supplied by a widget     | patch rows   |
+| `lb-row-delete`  | list, key              | nothing                                      | patch drop   |
+| a declared name  | list or row, key, cell | value                                        | any names    |
+
+### Proposed: fold `lb-cell-change` into `lb-row-update`
+
+A cell change is an update whose `values` holds one entry, and the hub
+already keeps `values` a widget supplies.  SQL has one UPDATE whether it sets
+one column or many.  On the server, `cellChange` and `rowUpdate` merge into
+one `update(key, values)`, where a column absent from `values` is left as it
+is.
+
+### Reordering is not an operation
+
+Position is not a relational concept; order is a column.  A drag is an update
+to an ordering column such as `display_order`, which the wire already
+carries in `values`.  No move operation is needed, and no field for "where
+the row went".
+
+## 4. Position: taken from the page, never written in the request
+
+- An element's own attributes say what it displays.  Its ancestors say where
+  it belongs.
+- A nested scope begins a new scope.
+- A request is an action plus a position.  The hub supplies the position;
+  only an interaction supplies a value.
+
+These are the rules [Theory](./theory.md) already states.  They are listed
+here because closure depends on them.
+
+## 5. Landing: every combination defined
+
+| Result → target | list scope   | row scope                         | no scope yet               |
+| --------------- | ------------ | --------------------------------- | -------------------------- |
+| whole list      | reconcile    | error: one name has one shape     | stored                     |
+| patch           | upsert, drop | error                             | applied to the stored copy |
+| row             | error        | fill                              | stored                     |
+
+A result lands on every scope bound to its name, at any depth of nesting.
+0.7.3 already does this: a patch to `groups` reaches a picker in every row of
+an outer table, and the outer list's reconciliation does not mistake the
+picker's rows for its own.
+
+### The missing rule: timing
+
+In 0.7.3 a scope that appears after its name has landed stays empty.  A row
+added to an outer list by a patch starts with every nested list empty, and a
+widget's scaffolding built during landing, such as a ghost row holding a
+picker, starts empty too.  Pages work around it by ordering their queries so
+the outer list lands first, which only covers the first load.
+
+The closed rule:
+
+> **The hub holds each name's current value.  A scope shows that value
+> whenever it appears.**
+
+In relational terms a name is a relation variable, results are assignments to
+it, and scopes are views of it.  Whether a scope existed before or after its
+data arrived stops mattering.
+
+It also settles several things that were not worked on directly:
+
+- The blocker in [TECHREF-1.0](./TECHREF-1.0.md), "Decide how a new row
+  fills a nested list".
+- Pickers in newly created rows, and pickers in ghost rows built after the
+  first load.
+- Query order in a page's queries file stops mattering.
+- **What a partial patch row means.**  A patch row upserts by key, and a
+  column it does not name is left unchanged, as an SQL UPDATE leaves it.
+  The reference is silent on this today.
+- "No scope for a name" becomes an ordinary state rather than a console
+  warning, since a scope may simply not exist yet.
+
+#### Mechanism
+
+- The hub fills a cloned row, nested scopes included, before inserting it.
+  This extends the rule it already follows of filling before insertion.
+- After each landing, it sweeps for scopes that have never received data.
+  For a list, an absent `lb-row-count` already marks one.  A row scope would
+  need an equivalent mark.
+- A widget that builds scopes outside a landing, at some later time, would
+  need a `MutationObserver`.  No widget built so far does that.
+
+#### What would prove it wrong
+
+A case where the stored copy and the document legitimately disagree.  The
+only candidate is a control holding an edit not yet sent, and landing already
+overwrites that in 0.7.3, so the rule introduces nothing new.
+
+## 6. State attributes: four, stamped by the hub, read by CSS
+
+`lb-value`, `lb-row-count`, `lb-pending`, `lb-error`.
+
+## 7. Outside the algebra, deliberately bounded
+
+- **Composition at build time:** `lb-slot`, `lb-template`.
+- **The host channel:** `lb-page`, `lb-nav-link`, `lb-unknown-page`, and the
+  hub's own `lb-navigation` row.  That row already shows the hub's own state
+  landing through the same three forms.
+- **The widget protocol:** the `lb-request` event, which an ancestor may
+  stop, and the `lbPlaceRow` and `lbRowsLanded` hooks.
+
+## What this changes in 0.7.3
+
+1. The hub holds each name's current value and fills scopes that appear
+   late.
+2. `lb-cell-change` folds into `lb-row-update`, with widget-supplied
+   `values`, and the server's `cellChange` and `rowUpdate` merge.
+3. The reference states the patch row rule: upsert by key, unnamed columns
+   unchanged.
+
+Everything else is the current vocabulary, now justified as closed.
+
+## What the evidence has not settled
+
+Everything above is backed by pages already built.  These are not:
+
+1. **Parameters and view state:** a filter, a selection, a collapsed
+   section.  The likely closed answer is that URL query parameters become
+   columns of the `lb-navigation` row and reach queries as arguments, as
+   `<form method="get">` puts its fields in the query string.  No page needs
+   it yet, so this is a prediction rather than evidence.
+2. **Checkboxes and data types:** probably HTML's presence-or-absence
+   convention, still undecided.
+3. **Concurrent writers:** staleness is a property of the stored copy, so
+   the rule in section 5 makes this question easier to state without
+   answering it.
+4. **Error content:** `lb-error` records that a round trip failed, not why.
+   A closed answer would deliver the message as a result like any other,
+   perhaps as a hub row.  Untested.