@abide/abide 0.122.0 → 0.123.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @abide/abide
 
+## 0.123.1
+
+### Patch Changes
+
+- the args-as-sent walk returns the args it does not copy, walks a cycle once, and keeps a parsed __proto__ a member (RULEBOOK 19.25) ([`ee02cac`](https://github.com/briancray/abide/commit/ee02cacbb64f00374ae98154e788c59c5a4ec49b))
+- bf77c28: `abide check` no longer fails when an inline component is passed to a component that sits inside another component's body: the outer close tag's read in the check's projection now ends with a `;`, so the braces that scope the passed component are not parsed as an arrow function.
+- 7c24094: A no-argument mutation behind `middleware` no longer starts its body before its rungs run. Dropping the previous call's answer built the request's instance of the handler, which started the body ahead of every rung, so a refusing rung (`signedIn`) answered after the body had already run. Calling the same mutation twice in one request now writes twice behind rungs as well (RULEBOOK 16.7, 16.11, 16.16).
+- 94fbea7: A handler's derived args schema reads a member left `undefined` as absent, so an in-process call like `getResearch({ home, topic: undefined })` is answered as the wire answers it rather than refused 422 (RULEBOOK 19.25, 15.8).
+
+## 0.123.0
+
+### Minor Changes
+
+- 0e5f83e: an unfinished conversation's log line says why — aborted, failed with the throw, or stopped (RULEBOOK 44.31) ([`042aea3`](https://github.com/briancray/abide/commit/042aea3150ae0fd29959bbe1346d1595b86617bc))
+- 0e5f83e: Breaking: a member the value's type declares is the value's, and a read prop holds a Reactive where one is due (RULEBOOK 31.5, 31.6, 33.27) ([`50b1151`](https://github.com/briancray/abide/commit/50b1151d46389185df0b61d0dd82241566446275))
+
 ## 0.122.0
 
 ### Minor Changes

package/docs/REGISTRY.md

@@ -168,7 +168,7 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `Selection` | `Reactive<any, any, any, any> \| Keyed<any, any, any, any> \| Rpc<any, any, any, any> \| { tags: string[] }` | What is being asked about. | 13.1, 13.8, 13.9, 13.13, 31.14 |
+| `Selection` | `Reactive<any, any, any, any> \| Keyed<any, any, any, any> \| Rpc<any, any, any, any> \| { tags: string[] }` | What is being asked about. | 13.1, 13.8, 13.9, 13.13, 31.13 |
 | `busy` | `(selection?: Selection, pattern?: Partial<Args>) => boolean` | Whether any entry in the selection has work in flight. | 13.2, 13.3, 13.5, 13.12, 41.28, 41.31, 46.11 |
 | `ready` | `(selection?: Selection, pattern?: Partial<Args>) => boolean` | Whether every entry in the selection has a value to serve. | 13.3, 13.5, 13.11, 13.12, 41.28, 41.31 |
 | `synced` | `(selection?: Selection, pattern?: Partial<Args>) => boolean` | Whether every entry in the selection holds what its producer made. | 13.12, 13.18 |
@@ -273,7 +273,7 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `Schema<T>` | `((value: unknown) => T) \| StandardSchemaV1<T>` | The two forms a shape may be declared in. | 19.2, 19.3, 19.4, 19.6, 19.8, 19.9, 19.10, 19.18, 19.11, 19.12 |
+| `Schema<T>` | `((value: unknown) => T) \| StandardSchemaV1<T>` | The two forms a shape may be declared in. | 19.2, 19.3, 19.4, 19.6, 19.8, 19.9, 19.10, 19.18, 19.25, 19.11, 19.12 |
 | `JsonValue` | `null \| boolean \| number \| string \| JsonValue[] \| { [k: string]: JsonValue }` | What an `Args` may hold. | — |
 | `Issues<T>` | `T extends object ? Partial<Record<Paths<T> \| '', string[]>> : string[]` | What was wrong, keyed by where. | 19.4, 19.19 |
 | `Paths<T>` | `string` | The dot-joined leaf paths of a type. | 19.5 |
@@ -349,7 +349,7 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `claudeCode` | `(config?: ClaudeCodeConfig) => Provider` | The visitor's own Claude Code, reached through the bridge paired with their browser, as a provider. | 44.5, 44.13, 44.17, 44.18, 44.19, 44.24, 44.25, 44.27, 44.30, 44.33 |
+| `claudeCode` | `(config?: ClaudeCodeConfig) => Provider` | The visitor's own Claude Code, reached through the bridge paired with their browser, as a provider. | 44.5, 44.13, 44.17, 44.18, 44.19, 44.24, 44.25, 44.27, 44.30, 44.33, 44.45, 44.46 |
 | `ClaudeCodeConfig` | `{ model?: string; fallbackModel?: string; systemPrompt?: string; appendSystemPrompt?: string; effort?: 'low' \| 'medium' \| 'high' \| 'xhigh' \| 'max'; maxBudgetUsd?: number; betas?: string[]; disallowedTools?: string[]; tools?: string[] }` | The Claude Code options a site may set for a turn, and the built-in tools it asks the visitor for. | 44.16, 44.29 |
 | `claudeCode.bridgeCommand` | `(options?: { tools?: string[] }) => { command: string; link: string; expires: number }` | The command and the link that pair a bridge with this browser, granting the built-in tools it is given. | 44.14, 44.32, 44.33, 44.40, 44.41, 44.42, 44.43, 44.44 |
 | `claudeCode.bridge` | `(options?: { tools?: string[] }) => AsyncGenerator<BridgeStatus>` | This browser's pairing, as it changes. | 44.20, 44.22, 44.32, 44.33, 44.34, 44.40 |
@@ -380,11 +380,11 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `route.url` | `Reactive<URL>` | Where we are, fragment included. | 23.1, 23.2, 23.3, 23.4, 30.20, 30.21, 30.23, 30.33, 19.16, 31.16 |
-| `route.params` | `Reactive<Params>` | The matched route's segments — typed by its own route in a page or a layout, and `Params` in any other file. | 23.1, 23.5, 23.9, 30.23, 31.16 |
+| `route.url` | `Reactive<URL>` | Where we are, fragment included. | 23.1, 23.2, 23.3, 23.4, 30.20, 30.21, 30.23, 30.33, 19.16, 31.15 |
+| `route.params` | `Reactive<Params>` | The matched route's segments — typed by its own route in a page or a layout, and `Params` in any other file. | 23.1, 23.5, 23.9, 30.23, 31.15 |
 | `Params` | `Record<string, string \| string[]>` | What a matched route's segments are. | 23.5 |
-| `route.name` | `Reactive<string>` | The resolution path, the same under any mount path. | 23.1, 23.6, 23.14, 31.16 |
-| `route.navigating` | `Reactive<boolean>` | Whether a navigation is in flight. | 23.1, 31.16 |
+| `route.name` | `Reactive<string>` | The resolution path, the same under any mount path. | 23.1, 23.6, 23.14, 31.15 |
+| `route.navigating` | `Reactive<boolean>` | Whether a navigation is in flight. | 23.1, 31.15 |
 
 ## `online`
 
@@ -533,12 +533,12 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 | `foo` wherever the declared type of its position is not a `Reactive` | a live read | 31.1, 31.2, 31.10 |
 | `const x: Reactive<…> = foo` / a `Reactive<…>`-typed parameter, return or `bind:` operand | the `Reactive` | 31.3 |
 | `await foo` | the settling of the `Reactive`, which is its value | 1.4, 2.7, 31.3 |
-| `refresh(foo)` / a `Selection`-typed parameter | the `Reactive` | 31.14 |
+| `refresh(foo)` / a `Selection`-typed parameter | the `Reactive` | 31.13 |
 | `foo = bar` | a write | 31.4, 11.61 |
-| `foo.bar = v` | a write through a path | 31.8, 31.15 |
+| `foo.bar = v` | a write through a path | 31.8, 31.14 |
 | `foo.push(v)` | the same | 31.8, 31.9 |
 | `const [a, b] = foo` / `...foo` | one read of the value | 31.12 |
-| `foo.bar` | the value's `bar`, or the `Reactive`'s own `bar` where it declares one | 31.5, 31.13 |
+| `foo.bar` | the value's `bar`, or the `Reactive`'s own `bar` where it declares one the value does not | 31.5 |
 | `foo.bar(…)` | the `Reactive` API where `bar` is a member | 31.6 |
 | `foo()` / `foo.set(v)` | the explicit forms | 31.7, 31.11 |
 
@@ -596,7 +596,7 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `props` | `<Props>() => { [K in keyof Props]: Props[K] }` | One live accessor per prop the component declares. | 33.1, 33.2, 33.3, 33.4, 33.5, 33.6, 33.7, 33.8, 33.9, 33.10, 33.11, 33.14, 33.15, 33.20, 33.22, 33.25 |
+| `props` | `<Props>() => { [K in keyof Props]: Props[K] }` | One live accessor per prop the component declares. | 33.1, 33.2, 33.3, 33.4, 33.5, 33.6, 33.7, 33.8, 33.9, 33.10, 33.11, 33.14, 33.15, 33.20, 33.22, 33.25, 33.27 |
 | `Attributes<Tag>` | `Attributes<Tag extends keyof HTMLElementTagNameMap \| keyof SVGElementTagNameMap>` | The attributes an HTML or SVG element takes, typed as a component's props. | 33.23, 33.24, 33.26 |
 | `children` | always accepted | What a caller passes between the tags. | 33.16, 32.18 |
 

package/docs/RULEBOOK.md

@@ -1335,6 +1335,9 @@ to, and MUST NOT change the type of the value that slot gates.
 19.24 The value a body produces MUST be typed from the body alone, and a `schema` declared beside it
 MUST NOT change that type.
 
+19.25 A `Schema` derived per 19.9 MUST read a member left `undefined`, at any depth of a record, as
+absent — in process as the wire carries it (30.28).
+
 # 20. Generated surfaces
 
 20.1 Every surface `Clients` names MUST be derived from the route table, and MUST NOT be authored
@@ -1871,16 +1874,17 @@ the routes 30.9 ranks after that route.
 
 31.3 A name MUST hold the `Reactive` only where the declared type of its position is a `Reactive`: an
 annotated binding, an annotated return, a `Reactive`-typed parameter, a `bind:` operand, an `await`
-operand — or where 31.14 holds it.
+operand — or where 31.13 holds it.
 
 31.4 Assignment to such a name MUST be a write, and the assigned value MAY be settled, a load, or a
 `Reactive`.
 
 31.5 A property access on such a name MUST reach the value, except a member declared on the
-`Reactive` type, which MUST reach that member bound to the `Reactive`.
+`Reactive` type that the value's type does not declare, which MUST reach that member bound to the
+`Reactive`.
 
-31.6 A call on such a name MUST reach the `Reactive` API where the member is declared on the
-`Reactive` type, and the value's method otherwise.
+31.6 A call on such a name MUST reach the `Reactive` API where 31.5 reaches the `Reactive`'s
+member, and the value's method otherwise.
 
 31.7 `s` and `s.set` MUST keep compiling inside a `.abide` file.
 
@@ -1896,17 +1900,14 @@ the member name.
 
 31.12 A destructuring pattern or a spread over such a name MUST read it once.
 
-31.13 The compiler MUST warn where 31.5 reaches a `Reactive` member the value's type also declares,
-naming the explicit read.
-
-31.14 A name MUST hold the `Reactive` where the declared type of its position is a `Selection`, or a
+31.13 A name MUST hold the `Reactive` where the declared type of its position is a `Selection`, or a
 type parameter constrained by one.
 
-31.15 A write through a member path that reaches a value which is not plain data — an array, or an
+31.14 A write through a member path that reaches a value which is not plain data — an array, or an
 object whose prototype is `Object.prototype` or `null` — MUST assign on that value itself, MUST NOT
 copy it or any level above it, and MUST NOT wake a reader.
 
-31.16 `route.url`, `route.params`, `route.name` and `route.navigating` MUST each be read and written
+31.15 `route.url`, `route.params`, `route.name` and `route.navigating` MUST each be read and written
 as a name bound to a `Reactive` is, per 31.1 to 31.7.
 
 # 32. Templating
@@ -2219,6 +2220,10 @@ that element as its `currentTarget`.
 included, under the names SVG spells them, and a tag both HTML and SVG name MUST be typed as the HTML
 element.
 
+33.27 A name `props` binds MUST hold a `Reactive` wherever 31.3 or 31.13 has a name hold its
+`Reactive` or 31.5 has it reach its `Reactive`'s member, and that `Reactive`'s probes MUST answer for
+every `Reactive` the caller's expression read.
+
 # 34. Script and style blocks
 
 34.1 A `<script>` block MUST be per-instance component setup.
@@ -3355,8 +3360,8 @@ run no turn for 30 seconds.
 44.23 A post to `/__abide/bridge` carrying a line that is not JSON MUST be refused 400, and none of
 its lines MUST be relayed.
 
-44.24 A bridge MUST answer an MCP request its Claude Code made with a failure where the report
-carrying it was not taken by `/__abide/bridge`, or where no reply arrived within 120 seconds.
+44.24 A bridge MUST answer an MCP request its Claude Code made with a failure where
+`/__abide/bridge` sent no reply within 120 seconds.
 
 44.25 A bridge whose stream from `/__abide/bridge` ends unasked MUST redial it with its pairing's
 token, each wait twice the last, until it is refused or 60 seconds have passed.
@@ -3379,7 +3384,9 @@ before it exits.
 
 44.31 A conversation MUST write one `debug` line on `abide:assistant` when its events end, naming
 its stop reason, the transcript's length, the tool calls it made, its usage and how long it took,
-and naming it `unfinished` where it ended without a `done`.
+and naming it `unfinished` where it ended without a `done`, followed by why — `aborted` where the
+request's signal aborted, else `failed` where its provider threw, with the throw's message ending the
+line, else `stopped` where its caller stopped reading.
 
 44.32 A command `claudeCode.bridgeCommand` or `claudeCode.bridge` mints with `tools` MUST grant
 those built-in tools after its `--` as `--tools`, and one minted without `tools` MUST carry no `--`.
@@ -3427,6 +3434,12 @@ install wrote.
 NAME=VALUE` it is given, and a bridge opening an `abide-bridge` link MUST run Claude Code with those
 options ahead of the link's built-in tools and with those variables set, and a link MUST NOT set either.
 
+44.45 A bridge MUST say that `/__abide/bridge` did not take a report once, and not again until a
+report is taken, and MUST NOT say it while it redials per 44.25.
+
+44.46 A bridge MUST end a turn once `/__abide/bridge` did not take a report carrying it, and MUST
+report that turn failed.
+
 # 45. Offline
 
 45.1 Where `ABIDE_OFFLINE` is on, a page `abide build` built MUST register the worker

package/docs/abide.md

@@ -625,7 +625,7 @@ test('typing writes the value, and the value fills the field', async () => {
 | `const [a, b] = foo` / `...foo` | one read, taken apart |
 | `foo = bar` | a write |
 | `foo.bar` | the value's `bar` |
-| `foo.bar(…)` | the value's method, or a member of the `Reactive` such as `busy` |
+| `foo.bar(…)` | the value's method where it has one, and otherwise a member of the `Reactive` such as `busy` |
 | `foo()` / `foo.set(v)` | the explicit read and write |
 | `await foo` | the value, once it has settled |
 | `refresh(foo)` / a `Selection`-typed parameter | the `Reactive` itself |
@@ -7482,7 +7482,7 @@ Arrive here knowing which name you want. Each page is read off the registry: the
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `Selection` | `Reactive<any, any, any, any> \| Keyed<any, any, any, any> \| Rpc<any, any, any, any> \| { tags: string[] }` | What is being asked about. | [13.1](/rulebook#13.1), [13.8](/rulebook#13.8), [13.9](/rulebook#13.9), [13.13](/rulebook#13.13), [31.14](/rulebook#31.14) |
+| `Selection` | `Reactive<any, any, any, any> \| Keyed<any, any, any, any> \| Rpc<any, any, any, any> \| { tags: string[] }` | What is being asked about. | [13.1](/rulebook#13.1), [13.8](/rulebook#13.8), [13.9](/rulebook#13.9), [13.13](/rulebook#13.13), [31.13](/rulebook#31.13) |
 
 ## Taught in
 
@@ -8067,7 +8067,7 @@ Transports: what is written in place rather than imported.
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `Schema<T>` | `((value: unknown) => T) \| StandardSchemaV1<T>` | The two forms a shape may be declared in. | [19.2](/rulebook#19.2), [19.3](/rulebook#19.3), [19.4](/rulebook#19.4), [19.6](/rulebook#19.6), [19.8](/rulebook#19.8), [19.9](/rulebook#19.9), [19.10](/rulebook#19.10), [19.18](/rulebook#19.18), [19.11](/rulebook#19.11), [19.12](/rulebook#19.12) |
+| `Schema<T>` | `((value: unknown) => T) \| StandardSchemaV1<T>` | The two forms a shape may be declared in. | [19.2](/rulebook#19.2), [19.3](/rulebook#19.3), [19.4](/rulebook#19.4), [19.6](/rulebook#19.6), [19.8](/rulebook#19.8), [19.9](/rulebook#19.9), [19.10](/rulebook#19.10), [19.18](/rulebook#19.18), [19.25](/rulebook#19.25), [19.11](/rulebook#19.11), [19.12](/rulebook#19.12) |
 | `JsonSchema` | `JsonValue` | A JSON Schema document, the native form. | [19.7](/rulebook#19.7), [19.14](/rulebook#19.14) |
 
 ## Taught in
@@ -8418,7 +8418,7 @@ Generated surfaces: what is written in place rather than imported.
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `claudeCode` | `(config?: ClaudeCodeConfig) => Provider` | The visitor's own Claude Code, reached through the bridge paired with their browser, as a provider. | [44.5](/rulebook#44.5), [44.13](/rulebook#44.13), [44.17](/rulebook#44.17), [44.18](/rulebook#44.18), [44.19](/rulebook#44.19), [44.24](/rulebook#44.24), [44.25](/rulebook#44.25), [44.27](/rulebook#44.27), [44.30](/rulebook#44.30), [44.33](/rulebook#44.33) |
+| `claudeCode` | `(config?: ClaudeCodeConfig) => Provider` | The visitor's own Claude Code, reached through the bridge paired with their browser, as a provider. | [44.5](/rulebook#44.5), [44.13](/rulebook#44.13), [44.17](/rulebook#44.17), [44.18](/rulebook#44.18), [44.19](/rulebook#44.19), [44.24](/rulebook#44.24), [44.25](/rulebook#44.25), [44.27](/rulebook#44.27), [44.30](/rulebook#44.30), [44.33](/rulebook#44.33), [44.45](/rulebook#44.45), [44.46](/rulebook#44.46) |
 | `claudeCode.bridgeCommand` | `(options?: { tools?: string[] }) => { command: string; link: string; expires: number }` | The command and the link that pair a bridge with this browser, granting the built-in tools it is given. | [44.14](/rulebook#44.14), [44.32](/rulebook#44.32), [44.33](/rulebook#44.33), [44.40](/rulebook#44.40), [44.41](/rulebook#44.41), [44.42](/rulebook#44.42), [44.43](/rulebook#44.43), [44.44](/rulebook#44.44) |
 | `claudeCode.bridge` | `(options?: { tools?: string[] }) => AsyncGenerator<BridgeStatus>` | This browser's pairing, as it changes. | [44.20](/rulebook#44.20), [44.22](/rulebook#44.22), [44.32](/rulebook#44.32), [44.33](/rulebook#44.33), [44.34](/rulebook#44.34), [44.40](/rulebook#44.40) |
 | `/__abide/bridge` | `GET`, `POST` | Where a bridge pairs, and is relayed its turns. | [36.7](/rulebook#36.7), [44.14](/rulebook#44.14), [44.15](/rulebook#44.15), [44.19](/rulebook#44.19), [44.23](/rulebook#44.23), [44.26](/rulebook#44.26), [16.57](/rulebook#16.57), [16.78](/rulebook#16.78) |
@@ -8529,10 +8529,10 @@ Generated surfaces: what is written in place rather than imported.
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `route.url` | `Reactive<URL>` | Where we are, fragment included. | [23.1](/rulebook#23.1), [23.2](/rulebook#23.2), [23.3](/rulebook#23.3), [23.4](/rulebook#23.4), [30.20](/rulebook#30.20), [30.21](/rulebook#30.21), [30.23](/rulebook#30.23), [30.33](/rulebook#30.33), [19.16](/rulebook#19.16), [31.16](/rulebook#31.16) |
-| `route.params` | `Reactive<Params>` | The matched route's segments — typed by its own route in a page or a layout, and `Params` in any other file. | [23.1](/rulebook#23.1), [23.5](/rulebook#23.5), [23.9](/rulebook#23.9), [30.23](/rulebook#30.23), [31.16](/rulebook#31.16) |
-| `route.name` | `Reactive<string>` | The resolution path, the same under any mount path. | [23.1](/rulebook#23.1), [23.6](/rulebook#23.6), [23.14](/rulebook#23.14), [31.16](/rulebook#31.16) |
-| `route.navigating` | `Reactive<boolean>` | Whether a navigation is in flight. | [23.1](/rulebook#23.1), [31.16](/rulebook#31.16) |
+| `route.url` | `Reactive<URL>` | Where we are, fragment included. | [23.1](/rulebook#23.1), [23.2](/rulebook#23.2), [23.3](/rulebook#23.3), [23.4](/rulebook#23.4), [30.20](/rulebook#30.20), [30.21](/rulebook#30.21), [30.23](/rulebook#30.23), [30.33](/rulebook#30.33), [19.16](/rulebook#19.16), [31.15](/rulebook#31.15) |
+| `route.params` | `Reactive<Params>` | The matched route's segments — typed by its own route in a page or a layout, and `Params` in any other file. | [23.1](/rulebook#23.1), [23.5](/rulebook#23.5), [23.9](/rulebook#23.9), [30.23](/rulebook#30.23), [31.15](/rulebook#31.15) |
+| `route.name` | `Reactive<string>` | The resolution path, the same under any mount path. | [23.1](/rulebook#23.1), [23.6](/rulebook#23.6), [23.14](/rulebook#23.14), [31.15](/rulebook#31.15) |
+| `route.navigating` | `Reactive<boolean>` | Whether a navigation is in flight. | [23.1](/rulebook#23.1), [31.15](/rulebook#31.15) |
 
 ## Taught in
 
@@ -9215,12 +9215,12 @@ Generated surfaces: what is written in place rather than imported.
 | `foo` wherever the declared type of its position is not a `Reactive` | a live read | [31.1](/rulebook#31.1), [31.2](/rulebook#31.2), [31.10](/rulebook#31.10) |
 | `const x: Reactive<…> = foo` / a `Reactive<…>`-typed parameter, return or `bind:` operand | the `Reactive` | [31.3](/rulebook#31.3) |
 | `await foo` | the settling of the `Reactive`, which is its value | [1.4](/rulebook#1.4), [2.7](/rulebook#2.7), [31.3](/rulebook#31.3) |
-| `refresh(foo)` / a `Selection`-typed parameter | the `Reactive` | [31.14](/rulebook#31.14) |
+| `refresh(foo)` / a `Selection`-typed parameter | the `Reactive` | [31.13](/rulebook#31.13) |
 | `foo = bar` | a write | [31.4](/rulebook#31.4), [11.61](/rulebook#11.61) |
-| `foo.bar = v` | a write through a path | [31.8](/rulebook#31.8), [31.15](/rulebook#31.15) |
+| `foo.bar = v` | a write through a path | [31.8](/rulebook#31.8), [31.14](/rulebook#31.14) |
 | `foo.push(v)` | the same | [31.8](/rulebook#31.8), [31.9](/rulebook#31.9) |
 | `const [a, b] = foo` / `...foo` | one read of the value | [31.12](/rulebook#31.12) |
-| `foo.bar` | the value's `bar`, or the `Reactive`'s own `bar` where it declares one | [31.5](/rulebook#31.5), [31.13](/rulebook#31.13) |
+| `foo.bar` | the value's `bar`, or the `Reactive`'s own `bar` where it declares one the value does not | [31.5](/rulebook#31.5) |
 | `foo.bar(…)` | the `Reactive` API where `bar` is a member | [31.6](/rulebook#31.6) |
 | `foo()` / `foo.set(v)` | the explicit forms | [31.7](/rulebook#31.7), [31.11](/rulebook#31.11) |
 
@@ -9330,7 +9330,7 @@ Generated surfaces: what is written in place rather than imported.
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `props` | `<Props>() => { [K in keyof Props]: Props[K] }` | One live accessor per prop the component declares. | [33.1](/rulebook#33.1), [33.2](/rulebook#33.2), [33.3](/rulebook#33.3), [33.4](/rulebook#33.4), [33.5](/rulebook#33.5), [33.6](/rulebook#33.6), [33.7](/rulebook#33.7), [33.8](/rulebook#33.8), [33.9](/rulebook#33.9), [33.10](/rulebook#33.10), [33.11](/rulebook#33.11), [33.14](/rulebook#33.14), [33.15](/rulebook#33.15), [33.20](/rulebook#33.20), [33.22](/rulebook#33.22), [33.25](/rulebook#33.25) |
+| `props` | `<Props>() => { [K in keyof Props]: Props[K] }` | One live accessor per prop the component declares. | [33.1](/rulebook#33.1), [33.2](/rulebook#33.2), [33.3](/rulebook#33.3), [33.4](/rulebook#33.4), [33.5](/rulebook#33.5), [33.6](/rulebook#33.6), [33.7](/rulebook#33.7), [33.8](/rulebook#33.8), [33.9](/rulebook#33.9), [33.10](/rulebook#33.10), [33.11](/rulebook#33.11), [33.14](/rulebook#33.14), [33.15](/rulebook#33.15), [33.20](/rulebook#33.20), [33.22](/rulebook#33.22), [33.25](/rulebook#33.25), [33.27](/rulebook#33.27) |
 | `children` | always accepted | What a caller passes between the tags. | [33.16](/rulebook#33.16), [32.18](/rulebook#32.18) |
 
 ## Taught in

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.122.0",
+    "version": "0.123.1",
     "type": "module",
     "description": "Isomorphic type-safe framework for reactive async interfaces for humans and machines",
     "license": "MIT",

package/src/compiler/Lowering.ts

@@ -686,7 +686,8 @@ export class Lowering {
     /**
      * The read's name as emitted: `name()` for a written prop, whose cell its accessor hands back.
      *
-     * 33.6 — a written prop's cell is reached through its accessor.
+     * 33.6 — a written prop's cell is reached through its accessor. 33.27 — a read prop where a
+     * `Reactive` is due, a cell over its accessor.
      */
     private nameOf(read: Read): string {
         const spelled = this.projection.text.slice(read.start, read.end)
@@ -694,6 +695,7 @@ export class Lowering {
         // reads the one `route` every page shares.
         if (this.routed !== undefined && read.routeParams)
             return `(${spelled} as unknown as () => __RouteParams<${JSON.stringify(this.routed.route)}, ${JSON.stringify(this.routed.kind)}>)`
+        if (read.held) return `${this.use('heldProp')}(${spelled})`
         return read.through ? `${spelled}()` : spelled
     }
 
@@ -734,7 +736,7 @@ export class Lowering {
         const name = this.nameOf(read)
         switch (read.shape) {
             case 'asWritten':
-                return read.through ? name : undefined
+                return read.through || read.held ? name : undefined
             // 31.5 — the member BOUND to the `Reactive`, arguments and all.
             case 'member':
                 return this.checking

package/src/compiler/REACTIVE_MEMBERS.ts

@@ -8,9 +8,8 @@
  * `Reactive` itself, which reaches that. Without the list every `n.foo` reads as the API and the
  * value's own members are unreachable, which is what `regions.join is not a function` was.
  *
- * 31.9 wants the same question answered from the TYPE rather than from the name, which is a
- * checker query this does not make yet. A value whose own type declares `set` or `peek` therefore
- * resolves to the `Reactive`'s, and 31.13 asks for a warning naming exactly that case.
+ * The list names the candidates; the value's TYPE decides (`declaresMember` in `readsIn`): a value
+ * whose own type declares `set` or `error` keeps its own, so a `Map`'s `set` is the map's.
  *
  * WHICH IS WHY A NAME THE `Reactive` DOES NOT DECLARE MUST NOT BE HERE: it takes a member the
  * value really has and resolves it to nothing. This list is exactly `MEMBERS` in

package/src/compiler/SHARED_NAMES.ts

@@ -29,6 +29,8 @@ export const SHARED_NAMES: ReadonlySet<string> = new Set([
     // 32.6, 33.6, 33.7 — a component's `bind:`, and the cell a child writing that prop builds.
     'boundProp',
     'propCell',
+    // 33.27 — a read prop where its position holds the `Reactive`.
+    'heldProp',
     'propCells',
     // 33.20 — a default answering where the caller's accessor reads `undefined`.
     'propOr',

package/src/compiler/TypeSession.ts

@@ -625,7 +625,7 @@ export class TypeSession {
      * shadow is asked is `readsIn`'s.
      *
      * WHAT IT HAS TO SAY THAT IS NOT A TYPE ERROR comes back beside the reads: the compiler's own
-     * warnings (14.14 to 14.17, 31.13, 32.14), each on the `.abide` line where the source's text
+     * warnings (14.14 to 14.17, 32.14), each on the `.abide` line where the source's text
      * was handed in.
      */
     async readsFor(

package/src/compiler/classifyRead.ts

@@ -52,8 +52,7 @@ export type Read = {
      * that brackets a binding element's initializer, which together make a default an accessor;
      * `absent`, which gives a binding with no default an accessor of `undefined` (33.4); and
      * `restMember`, a member of the rest element, which calls that key's accessor (33.15), beside
-     * `restWhole`, the rest element handed on as one value (33.22). The
-     * pair and `absent` are INSERTIONS — zero-width, so what stands between the pair goes on being
+     * `restWhole`, the rest element handed on as one value (33.22). The pair and `absent` are INSERTIONS — zero-width, so what stands between the pair goes on being
      * lowered by the same walk, and a default reading a `Reactive` still reads it.
      */
     shape:
@@ -96,6 +95,12 @@ export type Read = {
      * pair, that the default is one too.
      */
     through: boolean
+    /**
+     * 33.27 — the name is a prop the child only reads, standing where a `Reactive` is due.
+     *
+     * So the `Reactive` every rewrite reaches is a cell over its accessor, `heldProp(name)`.
+     */
+    held: boolean
     /** 32.32 — the name is bound to a `reactive(…)` whose options declare `by`. */
     byValue: boolean
     /** 14.8 — the name is declared by a branch-local `<script>`, inside the body it scopes. */
@@ -136,6 +141,7 @@ export function newRead(
         path: [],
         value: undefined,
         through: false,
+        held: false,
         byValue: false,
         local: false,
         keys: [],
@@ -235,7 +241,10 @@ export function classifyPropRead(node: Node): Read | undefined {
  * `undefined` for an occurrence that is not a read at all: the declaration itself, an import or
  * export specifier, and a `typeof n` in a type.
  */
-export function classifyRead(node: Node): Read | undefined {
+export function classifyRead(
+    node: Node,
+    valueMember = false,
+): Read | undefined {
     const parent = node.parent
     if (isNotARead(parent)) return undefined
     if (
@@ -278,7 +287,12 @@ export function classifyRead(node: Node): Read | undefined {
         if (isPropertyAccessExpression(up) && up.expression === top) {
             // 31.5 — the `Reactive`'s own member is the API, and no path. Called, it stays as
             // written; REFERENCED, it is handed over bound, so `promise.then(n.set)` writes `n`.
-            if (top === node && REACTIVE_MEMBERS.has(up.name.text)) {
+            // `valueMember` where the value's own type declares one of that name (31.5).
+            if (
+                top === node &&
+                !valueMember &&
+                REACTIVE_MEMBERS.has(up.name.text)
+            ) {
                 const outer = up.parent
                 if (
                     (isCallExpression(outer) && outer.expression === up) ||

package/src/compiler/projectShadow.ts

@@ -391,11 +391,13 @@ function project(file: AbideFile): Projection {
         }
         text += '}))\n'
         // 38.116 — a close tag of its own is a second read of the name, so it is renamed with it.
+        // Ended by its `;`: the braces a passed component is scoped in (32.51) can follow, and
+        // `(Name)\n{` parses as an arrow function's head.
         const closed = file.origins.closes.get(node)
         if (closed !== undefined) {
             text += ';('
             copied(node.tag, closed)
-            text += ')\n'
+            text += ');\n'
         }
         for (const attribute of refused)
             slots.set(
@@ -697,6 +699,7 @@ declare function ${BOUND}<Value>(value: ${REACTIVE}<Value, any, any, any>): Valu
 declare function ${BOUND}<Value>(value: { get(): Value; set(value: Value): unknown }): Value
 declare function __restValues<Accessors>(record: Accessors): { [Key in keyof Accessors]: NonNullable<Accessors[Key]> extends () => infer Value ? Value : never }
 declare function __propCell<Value>(read: () => Value): () => ${REACTIVE}<Value>
+declare function __heldProp<Value>(read: () => Value): ${REACTIVE}<Value, Value, any, any>
 declare function __raw(value: unknown): unknown
 declare function __writePath<Root>(root: Root, path: readonly PropertyKey[], value: unknown): Root
 declare type __RouteParams<Pattern extends string, Kind extends string> = Kind extends 'layout' ? ${ROUTE_PARAMS}<Pattern> & { [name: string]: string | string[] | undefined } : ${ROUTE_PARAMS}<Pattern>

package/src/compiler/reactiveTypes.ts

@@ -111,7 +111,7 @@ export type Abide = {
     route: string | undefined
     reactive: CheckedSymbol | undefined
     /**
-     * 31.14 — abide's `Selection` alias, which a position may be typed as rather than as a `Reactive`.
+     * 31.13 — abide's `Selection` alias, which a position may be typed as rather than as a `Reactive`.
      */
     selection: CheckedSymbol | undefined
     props: string | undefined
@@ -185,7 +185,7 @@ export async function isReactiveType(
 /**
  * Whether a type is abide's `Selection`, or a type parameter constrained by one.
  *
- * 31.14 — A POSITION TYPED AS A `Selection`, or as a type parameter constrained by one (the free
+ * 31.13 — A POSITION TYPED AS A `Selection`, or as a type parameter constrained by one (the free
  * `refresh`, `invalidate`, `busy` and `ready` take `Chosen extends Selection`). A value is never a
  * selection of itself, so a read there hands `refresh` the invoice rather than the thing to reload.
  */

package/src/compiler/readsIn.ts

@@ -246,27 +246,22 @@ export async function readsIn(
             )
         }),
     )
+    const owned = await ownMembers(checker, nodes.flat(), (node) =>
+        valueTypeOf(checker, node),
+    )
     const holding: Promise<void>[] = []
     const located: { node: Node; read: Read }[] = []
     for (let index = 0; index < nodes.length; index += 1)
         for (const node of nodes[index] as (Node | undefined)[]) {
             if (node === undefined) continue
-            const read = classifyRead(node)
+            const read = classifyRead(node, owned.has(node))
             if (read === undefined) continue
             read.byValue = byValue[index] as boolean
             read.local = index >= topLevel
             reads.push(read)
             located.push({ node, read })
             if (read.shape === 'value')
-                holding.push(
-                    declaredType(checker, node).then(async (type) => {
-                        if (
-                            type !== undefined &&
-                            (await isReactiveType(checker, abide, type, true))
-                        )
-                            read.shape = 'asWritten'
-                    }),
-                )
+                holding.push(holdIn(checker, abide, node, read))
         }
     await Promise.all(holding)
     await props
@@ -392,7 +387,7 @@ async function bindingsOfReads(
  * The tracking and type warnings a file's reactive reads earn.
  *
  * The syntax alone decides 14.14 to 14.16 (`trackingWarnings`);
- * 14.17 and 31.13 ask what a read hands back, which is the return of the `Reactive`'s call.
+ * 14.17 asks what a read hands back, which is the return of the `Reactive`'s call.
  */
 async function warningsFor(
     checker: Checker,
@@ -424,45 +419,16 @@ async function warningsFor(
             isBinaryExpression(parent) &&
             parent.left === node &&
             parent.operatorToken.kind === SyntaxKind.QuestionQuestionToken
-        const member =
-            isPropertyAccessExpression(parent) &&
-            parent.expression === node &&
-            isIdentifier(parent.name) &&
-            REACTIVE_MEMBERS.has(parent.name.text)
-                ? parent.name.text
-                : undefined
-        if (!nullish && member === undefined) continue
+        if (!nullish) continue
         typed.push(
             valueTypeOf(checker, node).then(async (value) => {
-                if (value === undefined) return
                 // 14.17 — the fallback of a read that is never nullish is never taken: an unlanded
                 // read is a hole the position fills, not an `undefined` (2.2).
-                if (nullish && !(await admitsNullish(value)))
+                if (value !== undefined && !(await admitsNullish(value)))
                     warnings.push({
                         at: read.start,
                         message: `abide: \`${name} ?? …\` never takes its fallback — a read of \`${name}\` is not undefined while it loads, and its type says it is not undefined after. Ask \`${name}.ready()\` to tell the two apart. RULEBOOK 14.17.`,
                     })
-                if (member === undefined) return
-                // Per member, because a union's properties are only those every member shares, and
-                // `undefined` shares none — so `HTMLVideoElement | undefined` would declare no `error`.
-                for (const held of await unionMembers(value)) {
-                    if ((held.flags & NULLISH) !== 0) continue
-                    for (const property of await checker.getPropertiesOfType(
-                        held,
-                    ))
-                        if (property.name === member) {
-                            const dot = (
-                                parent as { questionDotToken?: unknown }
-                            ).questionDotToken
-                                ? '?.'
-                                : '.'
-                            warnings.push({
-                                at: read.start,
-                                message: `abide: \`${name}${dot}${member}\` reaches the Reactive's own \`${member}\`, and the value it holds has one too. Write \`${name}()${dot}${member}\` for the value's. RULEBOOK 31.13.`,
-                            })
-                            return
-                        }
-                }
             }),
         )
     }
@@ -779,7 +745,7 @@ function valueLeaves(node: Node, leaves: Node[]): void {
 const ROUTE_MEMBERS = new Set(['url', 'params', 'name', 'navigating'])
 
 /**
- * 31.16 — `route`'s four values, each read by name as a name bound to a `Reactive` is.
+ * 31.15 — `route`'s four values, each read by name as a name bound to a `Reactive` is.
  *
  * `route.params.id` reads `route.params().id`, and the explicit call keeps compiling (31.7). Told
  * by the symbol, as `props` is, so an app's own `route` is not abide's.
@@ -1142,13 +1108,18 @@ async function propsReads(
                   ),
         ),
     )
+    const owned = await ownMembers(checker, found.flat(), (node) =>
+        checker.getTypeAtLocation(node),
+    )
+    // 33.27 — each prop asked whether its position holds the `Reactive`, all at once.
+    const holding: Promise<void>[] = []
     for (let at = 0; at < found.length; at += 1) {
         const binding = bindings[at] as (typeof bindings)[number]
         if (binding.rest) {
             restReads(found[at] as (Node | undefined)[], reads)
             continue
         }
-        const uses: Read[] = []
+        const uses: { node: Node; read: Read }[] = []
         let written = false
         for (const node of found[at] as (Node | undefined)[]) {
             // The binding itself is the pattern's, and not a use of the name.
@@ -1157,15 +1128,16 @@ async function propsReads(
                 node.parent?.kind === SyntaxKind.BindingElement
             )
                 continue
-            const read = classifyRead(node)
+            const read = classifyRead(node, owned.has(node))
             if (read === undefined) continue
             if (
                 read.shape === 'write' ||
                 read.shape === 'update' ||
-                isBindOperand(positions, node)
+                isBindOperand(positions, node) ||
+                writesThrough(node, owned)
             )
                 written = true
-            uses.push(read)
+            uses.push({ node, read })
         }
         if (!written) {
             for (const node of found[at] as (Node | undefined)[]) {
@@ -1173,18 +1145,141 @@ async function propsReads(
                 const read = classifyPropRead(node)
                 if (read === undefined) continue
                 read.local = binding.local
-                reads.push(read)
+                if (read.shape !== 'value') {
+                    reads.push(read)
+                    continue
+                }
+                holding.push(
+                    holdsProp(checker, abide, node, owned.has(node)).then(
+                        (held) => {
+                            if (!held) return void reads.push(read)
+                            // Classified as a page's own name is, reaching a cell over the accessor.
+                            const asHeld = classifyRead(node) as Read
+                            if (asHeld.shape === 'value')
+                                asHeld.shape = 'asWritten'
+                            asHeld.held = true
+                            asHeld.local = binding.local
+                            reads.push(asHeld)
+                        },
+                    ),
+                )
             }
             continue
         }
         binding.call.path.push({ name: binding.key, start: 0, end: 0 })
         for (const read of binding.defaults) read.through = true
-        for (const read of uses) {
+        // A written prop's cell is already a `Reactive`, and a position due one holds it.
+        for (const { node, read } of uses) {
             read.through = true
             read.local = binding.local
             reads.push(read)
+            if (read.shape === 'value')
+                holding.push(holdIn(checker, abide, node, read))
         }
     }
+    await Promise.all(holding)
+}
+
+/**
+ * 31.5 — the `Reactive`'s member a property access reaches by name, or `undefined` where the name
+ * is not one — `n.ready`, `n.set`. Whether it is the `Reactive`'s is the value's type's to say
+ * (`ownMembers`).
+ */
+function memberNamed(node: Node): string | undefined {
+    const parent = node.parent
+    return isPropertyAccessExpression(parent) &&
+        parent.expression === node &&
+        isIdentifier(parent.name) &&
+        REACTIVE_MEMBERS.has(parent.name.text)
+        ? parent.name.text
+        : undefined
+}
+
+/**
+ * 31.5 — the occurrences among `nodes` reaching a member the VALUE's own type declares, where the
+ * access is the value's rather than the `Reactive`'s — a `Map`'s `set` is the map's. Asked before
+ * any is classified, so each is classified once.
+ *
+ * Per union member, because a union's properties are only those every member shares, and
+ * `undefined` shares none — so `HTMLVideoElement | undefined` would declare no `error`. A value
+ * typed `any` or `unknown` declares none: its type says nothing of what it holds.
+ */
+async function ownMembers(
+    checker: Checker,
+    nodes: readonly (Node | undefined)[],
+    valueOf: (node: Node) => Promise<Type | undefined>,
+): Promise<Set<Node>> {
+    const owned = new Set<Node>()
+    const asked: Promise<void>[] = []
+    for (const node of nodes) {
+        if (node === undefined) continue
+        const member = memberNamed(node)
+        if (member === undefined) continue
+        asked.push(
+            valueOf(node).then(async (value) => {
+                if (value === undefined) return
+                for (const held of await unionMembers(value))
+                    if (
+                        (held.flags & NULLISH) === 0 &&
+                        (await checker.getPropertyOfType(held, member)) !==
+                            undefined
+                    )
+                        return void owned.add(node)
+            }),
+        )
+    }
+    await Promise.all(asked)
+    return owned
+}
+
+/**
+ * 31.7, 33.6, 33.7 — `n.set(v)` and `n.patch(…)` are writes by name, called or handed on, where the
+ * value's own type declares no member of that name — a `Map`'s `set` writes the map, not the prop.
+ */
+function writesThrough(node: Node, owned: ReadonlySet<Node>): boolean {
+    const member = memberNamed(node)
+    return (member === 'set' || member === 'patch') && !owned.has(node)
+}
+
+/**
+ * 33.27 — whether a prop the child only reads stands where its `Reactive` is due, as a page's own
+ * name would: an `await` operand (31.3), a `Reactive`'s member its value does not declare (31.5),
+ * or a position typed as a `Reactive` or a `Selection` (31.3, 31.13).
+ */
+async function holdsProp(
+    checker: Checker,
+    abide: Abide,
+    node: Node,
+    ownsMember: boolean,
+): Promise<boolean> {
+    if (node.parent.kind === SyntaxKind.AwaitExpression) return true
+    if (memberNamed(node) !== undefined) return !ownsMember
+    return typedReactive(checker, abide, node)
+}
+
+/**
+ * 31.3, 31.13 — `read` holds the `Reactive` where `node` stands in a position whose declared type
+ * is a `Reactive` or a `Selection`.
+ */
+async function holdIn(
+    checker: Checker,
+    abide: Abide,
+    node: Node,
+    read: Read,
+): Promise<void> {
+    if (await typedReactive(checker, abide, node)) read.shape = 'asWritten'
+}
+
+/** 31.3, 31.13 — whether `node`'s position is declared a `Reactive` or a `Selection`. */
+async function typedReactive(
+    checker: Checker,
+    abide: Abide,
+    node: Node,
+): Promise<boolean> {
+    const type = await declaredType(checker, node)
+    return (
+        type !== undefined && (await isReactiveType(checker, abide, type, true))
+    )
 }
 
 /**

package/src/server/BRIDGE_VERSION.ts

@@ -1,3 +1,3 @@
 // The `abide-bridge` release a pairing command names, so a visitor's `bunx` runs the relay this
 // server speaks. `packages/abide/tests/claudeCode.test.ts` holds it to the bridge package's own.
-export const BRIDGE_VERSION = '0.5.0'
+export const BRIDGE_VERSION = '0.5.1'

package/src/server/assistant.ts

@@ -122,37 +122,58 @@ export async function* assistant(
         options.mcp === true ? appSurface() : NO_SURFACE,
         askerOf(request()),
     )
+    const signal = request().signal
     const events = provider.run(turns, tools, {
         maxTurns: options.maxTurns ?? MAX_TURNS,
-        signal: request().signal,
+        signal,
     })
     // 28.7 — a closed namespace runs the provider's stream untouched.
-    yield* ASSISTANT_LOG.enabled() ? traced(events, messages.length) : events
+    yield* ASSISTANT_LOG.enabled()
+        ? traced(events, messages.length, signal)
+        : events
 }
 
-/** `events`, and one line on `abide:assistant` once they end, however they end. 44.31. */
+/**
+ * `events`, and one line on `abide:assistant` once they end, however they end. 44.31.
+ *
+ * AN UNFINISHED CONVERSATION SAYS WHY, an abort read ahead of a throw: an aborted provider may throw
+ * as it unwinds, and the abort is what ended it.
+ */
 async function* traced(
     events: AsyncGenerator<AssistantEvent>,
     messageCount: number,
+    signal: AbortSignal,
 ): AsyncGenerator<AssistantEvent> {
     const started = performance.now()
     let calls = 0
     let done: Extract<AssistantEvent, { type: 'done' }> | undefined
+    let failure: string | undefined
     try {
         for await (const event of events) {
             if (event.type === 'tool') calls += 1
             else if (event.type === 'done') done = event
             yield event
         }
+    } catch (thrown) {
+        failure = thrown instanceof Error ? thrown.message : String(thrown)
+        throw thrown
     } finally {
+        const ending =
+            done?.stop ??
+            (signal.aborted
+                ? 'unfinished aborted'
+                : failure === undefined
+                  ? 'unfinished stopped'
+                  : 'unfinished failed')
         ASSISTANT_LOG.debug(
-            done === undefined ? 'unfinished' : done.stop,
+            ending,
             `${messageCount} messages`,
             `${calls} tool calls`,
             done === undefined
                 ? 'no usage'
                 : `${done.usage.input}/${done.usage.output} tokens`,
             `${(performance.now() - started).toFixed(1)}ms`,
+            ...(ending === 'unfinished failed' ? [failure] : []),
         )
     }
 }

package/src/server/derivedArgs.ts

@@ -15,12 +15,81 @@ import { argsDocumentOf } from './coerceArgs.ts'
  * called, whether or not an app mounted it. Not where its `args` gate publishes a document of its
  * own, which holds the args itself (19.7). Args that did not come are held as an empty record: a
  * schema is only derived where the handler's args are a required record, so a required member
- * missing is refused, not read off nothing.
+ * missing is refused, not read off nothing. The args are held as SENT (`asSent`): a call in process
+ * passing a member `undefined` is the call the wire carries without it.
  */
 export function derivedArgs(
     handler: HeldToAnnotation & Gated<unknown>,
     schema: JsonValue,
 ): void {
     if (argsDocumentOf(handler) !== undefined) return
-    handler[DERIVED_ARGS] = (args) => validateJson(schema, args ?? {})
+    handler[DERIVED_ARGS] = (args) => validateJson(schema, asSent(args ?? {}))
+}
+
+/** The records `asSent` is inside of, so a cyclic value is walked once rather than forever. */
+const WALKING: object[] = []
+
+/**
+ * `value` as the wire carries it, which drops a member left `undefined` (19.25): a URL omits it
+ * (30.28) and JSON leaves it out, at any depth of a body. `value` itself wherever it holds none, so
+ * the walk allocates nothing for the call that writes no `undefined` member.
+ *
+ * AN `undefined` IN A LIST IS KEPT. The two encodings part there — JSON writes `null`, a URL the
+ * text `undefined` — so neither is the wire's, and the schema answers the value as given.
+ */
+export function asSent(value: unknown): unknown {
+    if (value === null || typeof value !== 'object' || WALKING.includes(value))
+        return value
+    WALKING.push(value)
+    try {
+        return Array.isArray(value)
+            ? listAsSent(value)
+            : recordAsSent(value as Record<string, unknown>)
+    } finally {
+        WALKING.pop()
+    }
+}
+
+function listAsSent(list: unknown[]): unknown[] {
+    let sent: unknown[] | null = null
+    for (let index = 0; index < list.length; index += 1) {
+        const member = list[index]
+        const held = asSent(member)
+        if (sent === null && held !== member) sent = list.slice(0, index)
+        sent?.push(held)
+    }
+    return sent ?? list
+}
+
+function recordAsSent(
+    record: Record<string, unknown>,
+): Record<string, unknown> {
+    let sent: Record<string, unknown> | null = null
+    for (const key in record) {
+        if (!Object.hasOwn(record, key)) continue
+        const member = record[key]
+        const held = member === undefined ? undefined : asSent(member)
+        if (sent === null && (member === undefined || held !== member))
+            sent = membersBefore(record, key)
+        if (sent !== null && held !== undefined) sent[key] = held
+    }
+    return sent ?? record
+}
+
+/**
+ * A copy of `record`'s own members ahead of `key`, in their order.
+ *
+ * NO PROTOTYPE, so an own `__proto__` member JSON parsed stays a member the schema reads rather
+ * than becoming the copy's prototype.
+ */
+function membersBefore(
+    record: Record<string, unknown>,
+    key: string,
+): Record<string, unknown> {
+    const copy: Record<string, unknown> = Object.create(null)
+    for (const earlier in record) {
+        if (earlier === key) break
+        if (Object.hasOwn(record, earlier)) copy[earlier] = record[earlier]
+    }
+    return copy
 }

package/src/shared/index.ts

@@ -54,8 +54,9 @@ export { online } from './online.ts'
 export { outbox, type QueuedCall } from './outbox.ts'
 export { onMenu } from './onMenu.ts'
 export { type Principal, principal } from './principal.ts'
-// EMITTED CODE'S: a prop the child writes (33.6, 33.7).
+// EMITTED CODE'S: a prop the child writes (33.6, 33.7), and one it hands where a `Reactive` is due (33.27).
 export {
+    heldProp,
     propCell,
     propCells,
     propOr,

package/src/shared/propCell.ts

@@ -21,6 +21,24 @@ export function propCell(read: Accessor): () => Reactive<unknown> {
     return () => cell
 }
 
+// Each read prop's `heldProp`, built on the first ask and kept for as long as its accessor is.
+const HELD = new WeakMap<Accessor, Reactive<unknown>>()
+
+/**
+ * 33.27 — a prop the child only reads, where its position holds the `Reactive` (31.3, 31.13): the
+ * one cell `propCell` would have built, over the caller's accessor. So `busy(rows)` asks what the
+ * caller's expression read — the caller's own `Reactive` where it bound one — and a plain value's is
+ * a cell nothing loads. Built only where one is asked for, and once per accessor.
+ */
+export function heldProp(read: Accessor): Reactive<unknown> {
+    let cell = HELD.get(read)
+    if (cell === undefined) {
+        cell = propCell(read)()
+        HELD.set(read, cell)
+    }
+    return cell
+}
+
 /**
  * 33.20 — a defaulted prop's accessor: the caller's, answering the default wherever it reads
  * `undefined`, and the default alone where the caller passed nothing. A bound accessor asked to

package/src/shared/rpc.ts

@@ -407,6 +407,12 @@ export function declare(method: Method): Declare {
             rungs.length === 0
                 ? null
                 : compose(rungs, async (ctx: RpcContext) => {
+                      // 16.7 behind rungs — the handler's spent answer is dropped HERE, once the
+                      // rungs let the call through: reading an unkeyed value's cell builds this
+                      // request's instance, which starts its body (1.7), and dropped in `call` that
+                      // ran the body ahead of every rung (16.11, 16.16).
+                      if (cacheOptions !== undefined && !keyed)
+                          dropAnswered(value)
                       const reached = reach(argsOf(ctx))
                       const started = performance.now()
                       try {
@@ -464,8 +470,9 @@ export function declare(method: Method): Declare {
             }
             // 16.7 — a mutation's call is a write each time, even where the last one settled this
             // turn: a keyed value's reach evicts an outlived entry itself, and an unkeyed one's
-            // spent answer is dropped here.
-            if (cacheOptions !== undefined && !keyed) dropAnswered(value)
+            // spent answer is dropped here — or, behind rungs, in the onion's center.
+            if (cacheOptions !== undefined && !keyed && wrapped === null)
+                dropAnswered(value)
             const reached = callLoad(
                 reachThrough,
                 args,

package/src/shared/writePath.ts

@@ -14,7 +14,7 @@ import { putOwn } from './putOwn.ts'
  * object where an array was, and `length`, `map` and every later `{#for}` over it go with it. The
  * shape is decided here, where the value is.
  *
- * 31.15 — ONLY PLAIN DATA IS COPIED. An element, a class instance, a `Map`: anything whose prototype
+ * 31.14 — ONLY PLAIN DATA IS COPIED. An element, a class instance, a `Map`: anything whose prototype
  * is not `Object.prototype`, `null` or `Array.prototype` owns its own state, and its setters say
  * what a write means — `video.currentTime = t` seeks. A spread of one is a plain object holding a
  * few own fields, so the write reached nothing and the `Reactive` came to hold the husk. The write