@abide/abide 0.123.0 → 0.123.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @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

package/docs/REGISTRY.md

@@ -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 |

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

package/docs/abide.md

@@ -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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.123.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/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(

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/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,