@abide/abide 0.100.0 → 0.102.0

package/src/shared/matchRoute.ts

@@ -55,8 +55,18 @@ function walk(
     if (index === segments.length)
         return prefix || at === parts.length ? {} : null
     const segment = segments[index] as Segment
-    // 30.5 — A REST TAKES WHAT IS LEFT, including nothing, and it is last by construction.
-    if (segment.kind === 'rest') return { [segment.name]: parts.slice(at) }
+    // 30.5 — A REST TAKES THE MOST THE SEGMENTS AFTER IT LEAVE, nothing included, so a handler's
+    // name after one (`/docs/[...path]/save`) is reached rather than spent on the rest.
+    if (segment.kind === 'rest') {
+        for (let end = parts.length; end >= at; end -= 1) {
+            const params = walk(segments, index + 1, parts, end, prefix)
+            if (params !== null) {
+                params[segment.name] = parts.slice(at, end)
+                return params
+            }
+        }
+        return null
+    }
     const part = parts[at]
     if (segment.kind === 'optional') {
         if (part !== undefined) {
@@ -80,8 +90,9 @@ function walk(
  * The first route whose pattern matches `parts`, with its params, or `undefined`.
  *
  * 30.9 — THE FIRST PATTERN THAT MATCHES WINS, over a table already ranked most-specific-first.
- * BOTH SEAMS WALK THIS ONE. The server resolving an address and the client router resolving the
- * same one is the isomorphism 30.8 rests on.
+ * The client router resolves through this, and the server walks the same ranked table with
+ * `matchOf`, passing a route with no answer for the method asked. The two resolving one address
+ * alike is the isomorphism 30.8 rests on.
  *
  * Walked rather than compiled to a regex: a route table is matched once per navigation, so the
  * walk is never the cost, and a regex would have to encode three segment kinds in a grammar nobody
@@ -97,3 +108,11 @@ export function firstMatch<T extends { segments: Segment[] }>(
     }
     return undefined
 }
+
+/** The params `segments` match the whole of `parts` with, or `undefined` where they do not. */
+export function matchOf(
+    segments: Segment[],
+    parts: string[],
+): Params | undefined {
+    return walk(segments, 0, parts, 0, false) ?? undefined
+}

package/src/shared/menuItem.ts

@@ -1,8 +1,8 @@
-// 38.89 — THE DESKTOP APP'S MENU BAR IS THE ROUTE'S: a layout or a page exports `menu` from its
+// 38.88 — THE DESKTOP APP'S MENU BAR IS THE ROUTE'S: a layout or a page exports `menu` from its
 // `<script module>`, and the window shows what the route it stands on exports. An item made by
 // `menuItem` is one a page answers; the rest are an address or a role, which need no page.
 
-/** What a menu item does natively, where an address or a page's own answer could not. 38.90. */
+/** What a menu item does natively, where an address or a page's own answer could not. 38.89. */
 export type MenuRole =
     | 'about'
     | 'hide'
@@ -37,7 +37,7 @@ export type MenuItem =
           items?: MenuItem[]
       }
 
-/** An item a page answers: each function `on` filed runs when it is picked. 38.92. */
+/** An item a page answers: each function `on` filed runs when it is picked. 38.91. */
 export class MenuEntry {
     label: string
     key: string | undefined

package/src/shared/reactive/Cursor.ts

@@ -8,13 +8,13 @@
 // cursor reads is a handful of fields, and naming them keeps the cell's internals out of a
 // second file.
 
+import { PATCHES } from './PATCHES.ts'
 import {
     dropReader,
     newSubscriber,
     type Subscriber,
     type Tracked,
 } from './tracking.ts'
-import { PATCHES } from './PATCHES.ts'
 
 /**
  * What a cursor reads, and all of a cell the server is handed (`servedCellOf`).
@@ -22,15 +22,10 @@ import { PATCHES } from './PATCHES.ts'
  * `ring[index]` carries ordinal `ringBase + index + 1`, so a cursor holding an ordinal finds its
  * place in a stream's chunk buffer without the buffer having to hold one.
  */
-export type Retained = {
+export type Retained = Tracked & {
     /** The window a `throttle` or a `debounce` holds open, `holding` while a production waits on it. */
     cap: { holding: boolean } | null
     ordinal: number
-    /**
-     * Unused by a cursor and declared so a `Cell` still satisfies `Tracked`, which a cursor's
-     * subscriber is registered through.
-     */
-    probeReaders: Subscriber[]
     ring: unknown[]
     ringBase: number
     servable: boolean
@@ -41,7 +36,6 @@ export type Retained = {
      */
     stream: object | null
     value: unknown
-    readers: Subscriber[]
 }
 
 // The cursors standing over each source, for a patch to keep the place of the ones behind (5.7).
@@ -118,7 +112,7 @@ export class Cursor implements AsyncIterator<unknown> {
         // reader in the graph carries for the sake of the few that are cursors.
         // Registered outside the tracking protocol, so the source it waits on is declared
         // rather than discovered — see the same shape in `Reactive`'s `settled`.
-        this.reader = newSubscriber([source as unknown as Tracked], null)
+        this.reader = newSubscriber([source], null)
         // One production per waiting turn, in the order they were asked for: a burst that
         // lands three productions on a consumer holding two turns answers both.
         this.reader.notify = (): void => {

package/src/shared/reactive/Keyed.ts

@@ -12,7 +12,7 @@ import type { Schema } from '../Schema.ts'
 import {
     ARGS_GATE,
     type Gated,
-    normalised,
+    normalized,
     PARAMETER_DEFAULTS,
 } from './argsContract.ts'
 import { CELL } from './CELL.ts'
@@ -40,6 +40,7 @@ import {
     detachProbes,
     dropReader,
     newSubscriber,
+    newTracked,
     type Subscriber,
     TRACKING,
     type Tracked,
@@ -332,7 +333,7 @@ export function createKeyed<
     // entry's probe carries it: a guard asked before a key was reached subscribed to the entries
     // there were, so the key that starts loading next — search-as-you-type — never woke it. One
     // signal per `Keyed`, moved where an entry is reached and where one is released.
-    const membership: Tracked = { readers: [], probeReaders: [] }
+    const membership = newTracked()
 
     function askMembership(): void {
         const reader = TRACKING.reader
@@ -351,7 +352,7 @@ export function createKeyed<
     }
 
     function reach(given: Args): Reactive<Stored, Accepted, Failures> {
-        const args = normalised(self, given)
+        const args = normalized(self, given)
         const key = canonicalKey(args)
         const standing = entries.get(key)
         // 1.8: reaching an instance that exists joins the standing work — 15.19, unless that work

package/src/shared/reactive/NotLanded.ts

@@ -2,7 +2,7 @@
  * What a read throws where nothing has landed.
  *
  * RULEBOOK 2.2. It carries the value it was thrown FOR, and that is the whole mechanism behind the
- * abort: a tracked body that meets one subscribes to `source` and re-runs when it lands, so the
+ * abort: a tracked body that meets one subscribes to `source` and reruns when it lands, so the
  * body never computes against an absent value and never takes the wrong branch. The
  * privileged-call hazard is what that buys — a body run to completion against an unlanded read
  * issues the else arm's call for a caller nothing has authenticated.