@abide/abide 0.101.0 → 0.103.0

package/src/shared/reactive/recordWrites.ts

@@ -5,8 +5,9 @@
 //
 // ONLY ARRAYS AND PLAIN OBJECTS ARE WRAPPED. A `Map`, a `Set` or a class instance keeps internal
 // slots a proxy cannot stand in for — `Map.prototype.set` refuses a proxy as its receiver — so one
-// reached is marked written the moment it is read, path and all. That over-reports, and an
-// over-report costs a row remade where an under-report shows a stale one.
+// reached is marked written the moment it is read, path and all, and each object a `Map` or a `Set`
+// hands out is marked as it leaves (`heldView`). That over-reports, and an over-report costs a row
+// remade where an under-report shows a stale one.
 //
 // 18.11 — AND WHERE A SINK IS HANDED IN, each write is kept as data too, as JSON Patch (RFC 6902) at
 // the JSON Pointer it was reached by: a member set is `add`, an index `replace` (or `add` one past
@@ -49,7 +50,15 @@ export function recordWrites<Value>(
     sink?: { ops: PatchOp[]; lost: boolean },
 ): void {
     if (!isWrappable(root)) {
-        mutate(root)
+        // A root no proxy can stand in for is written as a whole: what the callback reads out of it
+        // reaches the rows that show it with no proxy to say so.
+        if (root === null || typeof root !== 'object') {
+            mutate(root)
+            return
+        }
+        PATCHES.epoch += 1
+        PATCHES.written.set(root, PATCHES.epoch)
+        mutate(heldView(root, PATCHES.epoch) as Value)
         return
     }
     PATCHES.epoch += 1
@@ -217,9 +226,10 @@ export function recordWrites<Value>(
             }
             if (entry.proxy !== null) return entry.proxy
             mark(value)
+            entry.view ??= heldView(value, epoch)
             // Reached, and outside what a proxy can watch: whatever it does next is not kept.
             if (sink !== undefined) sink.lost = true
-            return value
+            return entry.view
         },
         set(held, property, value) {
             mark(held)
@@ -363,7 +373,7 @@ function pointerOf(path: (string | number)[]): string {
 /**
  * The JSON Patch an array method makes, read off the array BEFORE it runs.
  *
- * A `splice`'s start and count are normalised the way the method does, so the `remove`s and `add`s
+ * A `splice`'s start and count are normalized the way the method does, so the `remove`s and `add`s
  * name the indices it touches.
  */
 function opsOfCall(
@@ -421,10 +431,13 @@ class Reached {
      * Written in this patch, directly or below — `PATCHES.written` holds this patch's epoch for it.
      */
     marked: boolean
+    /** What one no proxy can stand in for is handed out as: `heldView` of it. */
+    view: object | undefined
     constructor(proxy: object | null, parent: object | Parents | null) {
         this.proxy = proxy
         this.parent = parent
         this.marked = false
+        this.view = undefined
     }
 }
 
@@ -463,6 +476,91 @@ class Parents {
     }
 }
 
+/**
+ * `container` as the callback is handed it: a `Map` or a `Set` that marks written each object key,
+ * value or member it hands out, and anything else as it is.
+ *
+ * A row over `[...map.values()]` reads one of them, and a write the callback makes to it through
+ * `map.get(id)` reaches it with nothing on the way to record it — so each one taken out is taken as
+ * written. AS IT LEAVES rather than all of them up front, which would make a patch of one entry cost
+ * the whole container. One level down: a row reads its item.
+ */
+function heldView(container: object, epoch: number): object {
+    if (!(container instanceof Map) && !(container instanceof Set))
+        return container
+    return new Proxy(container, new HeldHandler(epoch))
+}
+
+// `Map`'s and `Set`'s own methods run on the container itself, which is the receiver their internal
+// slots answer to; the ones that hand an object out mark it first.
+class HeldHandler {
+    epoch: number
+    constructor(epoch: number) {
+        this.epoch = epoch
+    }
+    get(
+        held: Map<unknown, unknown> | Set<unknown>,
+        property: string | symbol,
+    ): unknown {
+        if (property === TARGET) return held
+        const value = Reflect.get(held, property, held)
+        if (typeof value !== 'function') return value
+        const epoch = this.epoch
+        if (property === 'get')
+            return (key: unknown) =>
+                markedOut((held as Map<unknown, unknown>).get(key), epoch)
+        if (property === 'forEach')
+            return (
+                each: (value: unknown, key: unknown, set: unknown) => void,
+                self?: unknown,
+            ) => {
+                for (const [key, member] of held.entries())
+                    each.call(
+                        self,
+                        markedOut(member, epoch),
+                        markedOut(key, epoch),
+                        held,
+                    )
+            }
+        if (
+            property === 'values' ||
+            property === 'keys' ||
+            property === 'entries' ||
+            property === Symbol.iterator
+        )
+            // A Map's own iterator is its entries; a Set's is its values.
+            return () =>
+                markedEach(
+                    (value as () => Iterator<unknown>).call(held),
+                    property === 'entries' ||
+                        (property === Symbol.iterator && held instanceof Map),
+                    epoch,
+                )
+        return (value as (...args: unknown[]) => unknown).bind(held)
+    }
+}
+
+function* markedEach(
+    each: Iterator<unknown>,
+    pairs: boolean,
+    epoch: number,
+): Generator<unknown> {
+    for (let next = each.next(); next.done !== true; next = each.next()) {
+        if (pairs) {
+            const [key, value] = next.value as [unknown, unknown]
+            markedOut(key, epoch)
+            markedOut(value, epoch)
+        } else markedOut(next.value, epoch)
+        yield next.value
+    }
+}
+
+function markedOut<Value>(value: Value, epoch: number): Value {
+    if (typeof value === 'object' && value !== null)
+        PATCHES.written.set(value, epoch)
+    return value
+}
+
 /** Whether a proxy can stand in for `value`: an array or a plain object. */
 function isWrappable(value: unknown): value is object {
     if (value === null || typeof value !== 'object') return false

package/src/shared/reactive/structural.ts

@@ -2,7 +2,7 @@
  * The by-value comparator an app passes as `identity`: deep equality over arrays and plain objects.
  *
  * Not the default: the default is the reference, and this is what a value whose producer
- * RE-MATERIALISES declares — `reactive(() => getInvoice({ id }), { identity: structural })`. A
+ * RE-MATERIALIZES declares — `reactive(() => getInvoice({ id }), { identity: structural })`. A
  * fresh-but-equal payload waking every reader is why it exists at all; what it stops being is the
  * price every other value pays.
  *

package/src/shared/reactive/tracking.ts

@@ -255,7 +255,7 @@ export function dropProbeReader(source: Tracked, reader: Subscriber): void {
  * sweep below takes it out.
  *
  * SWEPT ONCE HALF THE LIST IS DEAD, which keeps a walk to at most twice the live readers and the
- * sweep amortised O(1) a drop — and keeps the invariant every `length` test leans on: a list with
+ * sweep amortized O(1) a drop — and keeps the invariant every `length` test leans on: a list with
  * entries has a LIVE one, since a list that is all dead is at least half dead. HALF, NOT MORE THAN
  * HALF: a keyed replace ends on exactly half, n old rows dead behind n new ones, and a sweep that
  * waited for one more drop kept the old rows — and through each one's `notify`, its scope and its

package/src/shared/reactive/watch.ts

@@ -203,7 +203,7 @@ export function watchOver(
         // UNTRACKED, AND THE CLEAR IS WHAT MAKES IT SO. The sources are given rather
         // than discovered, but the effect still RUNS wherever it was reached from — a
         // `s.watch` opened inside a `watch` had its reads attributed to the OUTER
-        // reader, which then re-ran on a value it never read. A mirror is the same
+        // reader, which then reran on a value it never read. A mirror is the same
         // shape one turn up: it runs inside the mark walk, and 4.7 has the `transform`
         // it calls there running untracked.
         const previous = TRACKING.reader
@@ -219,7 +219,7 @@ export function watchOver(
             // subscribed to, so its landing is what runs this again.
             if (thrown instanceof NotLanded) return
             // 12.8: one that throws once usually throws every run, and a watch
-            // re-running into the same throw is a loop with a log line per iteration.
+            // rerunning into the same throw is a loop with a log line per iteration.
             reader.alive = false
             detach(reader)
             effectThrew(thrown)
@@ -242,7 +242,7 @@ export function watchOver(
 }
 
 /**
- * The bare form: runs `effect` as a tracked context, re-running when anything it read changes.
+ * The bare form: runs `effect` as a tracked context, rerunning when anything it read changes.
  *
  * UNOWNED — the caller holds the stop. `watch` is this handed to its owners (`owned`); a template
  * binding's `Scope` and a `{#try}`'s retry hold their own, and call this direct.

package/src/shared/refuse.ts

@@ -15,7 +15,7 @@ import type { JsonValue } from './JsonValue.ts'
 import { namedLogger } from './log.ts'
 import { type Found, runSchema, type Schema } from './Schema.ts'
 
-/** The `abide:refuse` logger (28.9) — 15.13 and 15.15's namespace. */
+/** The `abide:refuse` logger (28.8) — 15.13 and 15.15's namespace. */
 const REFUSE_LOG = namedLogger('abide:refuse')
 
 /**

package/src/{ui → shared}/reportMenu.ts

@@ -1,9 +1,9 @@
-// 38.89 — A ROUTE'S MENU, TOLD TO THE WINDOW IT IS SHOWN IN. Loaded only inside a desktop app, where
-// the window has opened `abideMenu` to the page; anywhere else the router never imports it.
+// 38.88 — A ROUTE'S MENUS, TOLD TO THE WINDOW IT IS SHOWN IN. Loaded only inside a desktop app, where
+// the window has opened `abideMenu` to the page; anywhere else `onMenu` never imports it.
 
-import { MenuEntry, type MenuItem } from '#shared/menuItem.ts'
-import { navigate } from '#shared/navigate.ts'
 import { menuBridge } from './menuBridge.ts'
+import { MenuEntry, type MenuItem } from './menuItem.ts'
+import { navigate } from './navigate.ts'
 
 /** A menu item as the window builds it: an item the page answers carries the `id` it is told by. */
 type Told =
@@ -20,18 +20,16 @@ type Told =
 let numbered: Exclude<MenuItem, 'separator'>[] = []
 let listening = false
 
-/** Tells the window the menus `chain` exports, layouts outermost first and the page last. */
-export function reportMenu(chain: { menu?: unknown }[]): void {
+/** Tells the window `menus`, the layouts' outermost first and the page's last. */
+export function reportMenu(menus: readonly MenuItem[]): void {
     const bridge = menuBridge()
     if (bridge === undefined) return
     numbered = []
     const told: Told[] = []
-    for (const level of chain)
-        if (Array.isArray(level.menu))
-            for (const menu of level.menu as MenuItem[]) told.push(tell(menu))
+    for (const menu of menus) told.push(tell(menu))
     if (!listening) {
         listening = true
-        // 38.91, 38.92 — the window names the item picked; the page does what it means.
+        // 38.90, 38.91 — the window names the item picked; the page does what it means.
         addEventListener('abide:menu', (event) => {
             const item = numbered[(event as CustomEvent<number>).detail]
             if (item === undefined) return

package/src/shared/routePattern.ts

@@ -1,5 +1,5 @@
-// A ROUTE LITERAL, PARSED. One grammar for two things that would otherwise drift: the directory a
-// page is filed under (`ui/pages/invoices/[id]/page.abide`) and the literal an author writes
+// A ROUTE LITERAL, PARSED. One grammar for two things that would otherwise drift: the file a
+// page is filed as (`invoices/[id].abide`) and the literal an author writes
 // (`'/invoices/[id]'`). The bracket spelling is the file system's, so the address is read off the
 // tree rather than declared beside it and the two cannot disagree.
 //
@@ -7,8 +7,11 @@
 // required takes a value, optional may be left out and omits its segment with it, and rest takes
 // an array as well as a scalar.
 //
-// A LEAF: no imports, because the compiler, the client router and a server router all read it and
-// a constant crossing a seam lives where nothing pulls a graph in behind it.
+// A LEAF: nothing imported but another leaf, because the compiler, the client router and a server
+// router all read it and a constant crossing a seam lives where nothing pulls a graph in behind it.
+
+import { LAUNCHER_PAGE } from './LAUNCHER_FILES.ts'
+import { RESERVED_DIRECTORIES } from './RESERVED_DIRECTORIES.ts'
 
 type SegmentKind = 'static' | 'required' | 'optional' | 'rest'
 
@@ -40,57 +43,111 @@ export function parseRoutePattern(pattern: string): Segment[] {
     return out
 }
 
-const ROUTES = 'ui/pages/'
-
 /** Whether a source is a page, a layout, an error page or a component. */
 export type FileKind = 'page' | 'layout' | 'error' | 'component'
 
 /**
  * Whether the `.abide` at `path` is a page, a layout, an error page or a component.
  *
- * AN ADDRESS RATHER THAN A NAME. Both halves are load-bearing: the file name is the address and
- * the directory is what says the address is a ROUTE rather than a component filed anywhere. One
- * test for every name (35.1 reads `layout.abide` the same way), so the directory half cannot be
- * got right for one and wrong for another — and one test for every reader: the build's routes,
- * the checker's `Routes` and the `route.params` a page is typed by.
+ * 23.21 — WHERE IT SITS, THEN ITS NAME. Every `.abide` directly in an address directory is a page
+ * but a `layout.abide`, an `error.abide` and the root's `launcher.abide`; one under a fence is a
+ * component whatever it is called.
+ * One test for every reader: the build's routes, the checker's `Routes` and the `route.params` a
+ * page is typed by.
  *
- * 23.3 — under `ui/pages/` and nowhere else: a `page.abide` filed in some other `pages/`
- * directory is a component, as it is to the `Routes` the checker declares. `path` may be relative
- * to the app or the project, or absolute.
+ * `path` is RELATIVE TO THE APP'S ROOT: its directories are its route, so an absolute path would
+ * read the machine's directories as the app's.
  */
 export function fileKind(path: string): FileKind {
-    if (routesAt(path) === -1) return 'component'
-    // The WHOLE basename: `homepage.abide` ends with `page.abide` and is a component.
+    if (placeOf(path) !== 'address' || path === LAUNCHER_PAGE)
+        return 'component'
     const name = path.slice(path.lastIndexOf('/') + 1)
-    if (name === 'page.abide') return 'page'
     if (name === 'layout.abide') return 'layout'
-    return name === 'error.abide' ? 'error' : 'component'
+    if (name === 'error.abide') return 'error'
+    return 'page'
 }
 
+/** Where a file sits in an app, which is what it is to every reader (`placeOf`). */
+export type Place =
+    | 'address'
+    | 'server'
+    | 'public'
+    | 'lib'
+    | 'tests'
+    | 'dependency'
+    | 'skipped'
+
 /**
- * The route literal a page file is filed under, read off its path below `ui/pages/`.
+ * Where the file at `path`, relative to the app's root, sits — THE ONE ANSWER every walk, fence and
+ * emit reads, so no two of them disagree about a path.
  *
- * `page.abide` is an address rather than a name (CLAUDE.md), so the directories above it ARE the
- * route and the file itself contributes nothing.
+ * - `dependency` — 34.24: a package's, outside the root or under `node_modules`, whose directories
+ *   are its package's layout and none of the app's;
+ * - `skipped` — under a dot directory, which no walk of the app enters;
+ * - `server`, `public`, `lib` or `tests` — 23.15: under that fence, the nearest to the root deciding
+ *   (23.16 refuses one inside another);
+ * - `address` — 23.14: everywhere else, its directories the segments of its route.
+ */
+export function placeOf(path: string): Place {
+    if (path.startsWith('../') || path.startsWith('/')) return 'dependency'
+    const parts = path.split('/')
+    // The last part is the file itself, which is never a directory.
+    for (let index = 0; index < parts.length - 1; index += 1) {
+        const part = parts[index] as string
+        if (part === 'node_modules') return 'dependency'
+        if (part.startsWith('.')) return 'skipped'
+        // Each fence's place is its name.
+        if (RESERVED_DIRECTORIES.has(part)) return part as Place
+    }
+    return 'address'
+}
+
+/** Whether a walk of the app passes over the entry `name`: a dot file or directory, or `node_modules`. */
+export function skipped(name: string): boolean {
+    return name.startsWith('.') || name === 'node_modules'
+}
+
+/**
+ * The route a file answers at — its path below the root without its extension.
  *
- * 23.3 — BELOW THE FIRST `ui/pages/`, which is the routes directory, and not below the last `pages/`:
- * a section an app files as `ui/pages/pages/` is the address `/pages`, and cutting at the last one
- * served `ui/pages/pages/add-a-page` at `/add-a-page` and gave `/` two pages.
+ * 23.14 — `media/[id].abide` and `media/getGrid.ts` are `/media/[id]` and `/media/getGrid`; an
+ * `index.abide`, a `layout.abide` and an `error.abide` are their directory's. `path` is relative to
+ * the app's root, as `fileKind`'s is.
  */
-export function routeOf(pagePath: string): string {
-    const at = routesAt(pagePath)
-    const tail = at === -1 ? pagePath : pagePath.slice(at + ROUTES.length)
-    const parts: string[] = []
-    for (const part of tail.split('/'))
-        if (part !== '' && !part.endsWith('.abide')) parts.push(part)
-    return `/${parts.join('/')}`
+export function routeOf(path: string): string {
+    const parts = path.split('/')
+    const file = parts.pop() as string
+    // The extension alone: `[...rest].abide` carries dots of its own.
+    if (!DIRECTORY_FILES.has(file)) parts.push(file.replace(EXTENSION, ''))
+    return `/${parts.filter((part) => part !== '').join('/')}`
 }
 
-/** Where the first `ui/pages/` in `path` begins, as whole directories, or -1. */
-function routesAt(path: string): number {
-    if (path.startsWith(ROUTES)) return 0
-    const at = path.indexOf(`/${ROUTES}`)
-    return at === -1 ? -1 : at + 1
+const EXTENSION = /\.(?:abide|ts)$/
+
+/** 23.14, 23.18 — the names whose route is their directory's, and so a route's wherever they stand. */
+export const DIRECTORY_FILES = new Set([
+    'index.abide',
+    'layout.abide',
+    'error.abide',
+])
+
+/**
+ * The route the hooks and private handlers of the file at `path` are filed at.
+ *
+ * 37.1 — an address's own route; under a `lib` or a `tests` directory, the route of the directory
+ * holding it, so a component an admin page renders runs under the admin route's rungs; under a
+ * `server` or a `public` directory, and for a dependency's file, the root's.
+ */
+export function scopeOf(path: string): string {
+    // 38.82 — the launcher answers at no route, and files what it calls at the root's.
+    if (path === LAUNCHER_PAGE) return '/'
+    const place = placeOf(path)
+    if (place === 'address') return routeOf(path)
+    if (place !== 'lib' && place !== 'tests') return '/'
+    const parts = path.split('/')
+    // The fence `placeOf` named is the first one, and its name is its place.
+    const fence = parts.indexOf(place)
+    return `/${parts.slice(0, fence).join('/')}`
 }
 
 /**
@@ -107,27 +164,44 @@ function routesAt(path: string): number {
  * themselves, and `/x` ranked BELOW `/[[a]]/[[b]]` for the path `/x`: a static segment beaten by
  * two optionals, which is 30.9 exactly inverted. Both were live on the scalar this replaced.
  *
- * THE SHORTER PATTERN WINS A TIE, and only an exhausted prefix can produce one: every segment the
- * two share is the same kind, so what is left is the extra segments of the longer, which can only
- * be optional or rest or the two would not match one path. `/a` admits one address and
- * `/a/[[b]]` admits two, so the shorter is the narrower claim.
+ * WHERE ONE PATTERN ENDS, ITS END RANKS AS A SEGMENT: below a static or a required one and above an
+ * optional or a rest. `/a` admits one address and `/a/[[b]]` admits two, so the shorter is the
+ * narrower claim; but `/[[lang]]` and `/[[lang]]/about` both match `/about`, the longer by a static
+ * segment where the shorter spends `about` on an optional, so there the longer is.
  */
 export function compareRoutes(a: Segment[], b: Segment[]): number {
-    const shared = a.length < b.length ? a.length : b.length
-    for (let at = 0; at < shared; at += 1) {
-        const kind =
-            specificity(b[at] as Segment) - specificity(a[at] as Segment)
+    const longest = a.length > b.length ? a.length : b.length
+    for (let at = 0; at < longest; at += 1) {
+        const kind = specificity(b[at]) - specificity(a[at])
         if (kind !== 0) return kind
     }
-    return a.length - b.length
+    return 0
 }
 
-function specificity(segment: Segment): number {
-    if (segment.kind === 'static') return 3
-    if (segment.kind === 'required') return 2
+function specificity(segment: Segment | undefined): number {
+    if (segment === undefined) return 2
+    if (segment.kind === 'static') return 4
+    if (segment.kind === 'required') return 3
     return segment.kind === 'optional' ? 1 : 0
 }
 
+/**
+ * Whether `outer` is the front of `route`: a static segment by name, a parameter by kind.
+ *
+ * 35.1, 37.2 — what a layout wraps and what a route's hooks run over: the routes at or below its
+ * own, a parameter's name aside, so `/media/[id]` covers `/media/[slug]/edit`.
+ */
+export function coversRoute(outer: Segment[], route: Segment[]): boolean {
+    if (outer.length > route.length) return false
+    for (let at = 0; at < outer.length; at += 1) {
+        const one = outer[at] as Segment
+        const two = route[at] as Segment
+        if (one.kind !== two.kind) return false
+        if (one.kind === 'static' && one.name !== two.name) return false
+    }
+    return true
+}
+
 /**
  * A route table compiled for matching: each row with its pattern parsed, most specific first.
  *

package/src/shared/rpc.ts

@@ -6,7 +6,7 @@
 // A HANDLER IS A `reactive` OR BECOMES ONE (16.1), so an `Rpc` is not a second kind of value: the
 // call hands back the handler's own `Reactive` (16.3), and every probe, trigger and failure on it is
 // the reactive core's — the `Rpc`'s own `busy`, `ready`, `refresh` and `invalidate` are the
-// handler's, passed through. What this file adds is the normalising — a plain function or a value becomes the
+// handler's, passed through. What this file adds is the normalizing — a plain function or a value becomes the
 // `reactive` it would have been (16.6) — and the method.
 //
 // A HANDLER DECLARING `middleware` IS REACHED THROUGH ITS RUNGS (16.11), in process as over the wire:
@@ -14,6 +14,7 @@
 // handler's own.
 
 import { type Failed, isFailedNamed } from './Failed.ts'
+import { filledSegments } from './filledPath.ts'
 import { GLOBAL_GETS } from './GLOBAL_GETS.ts'
 import { compose, type Middleware } from './Middleware.ts'
 import { principalRotated } from './principalRotated.ts'
@@ -23,7 +24,7 @@ import {
     type Gated,
     gateOf,
     keyOf,
-    normalised,
+    normalized,
 } from './reactive/argsContract.ts'
 import { callLoad } from './reactive/callLoad.ts'
 import {
@@ -48,7 +49,8 @@ import { MUTATION } from './reactive/MUTATION.ts'
 import { SELECTION_MEMBERS } from './reactive/SELECTION_MEMBERS.ts'
 import { isForwarder } from './reactive/scoped.ts'
 import { checkArgs } from './refuse.ts'
-import { rpcRequest } from './rpcRequest.ts'
+import { parseRoutePattern, type Segment } from './routePattern.ts'
+import { pathRefusal, rpcRequest } from './rpcRequest.ts'
 import type { Schema } from './Schema.ts'
 
 export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
@@ -131,7 +133,7 @@ export type RpcContext<Args = unknown> = { request: Request; args: () => Args }
  * The context key holding the args as sent.
  *
  * 11.26 — THE ARGS AS SENT, carried on the context under a key no rung spells, so the reach at the
- * onion's centre keys the value by them rather than by what the gate made of them.
+ * onion's center keys the value by them rather than by what the gate made of them.
  */
 const SENT: unique symbol = Symbol('abide.sent')
 
@@ -331,10 +333,10 @@ export function declare(method: Method): Declare {
                 args: argsOnce(gateOf(contract), args),
                 [SENT]: args,
             }) as RpcContext
-        // 16.32 BEHIND RUNGS — A STREAM'S CHUNKS ARE FORWARDED, not collected. The centre of the
+        // 16.32 BEHIND RUNGS — A STREAM'S CHUNKS ARE FORWARDED, not collected. The center of the
         // onion is an async function, and a `Reactive` is thenable (1.4), so handing a streaming value
         // out through it would wait out the whole run and answer the accumulation once it closed. So
-        // the centre waits only until the value settles or turns out to stream (9.6), and hands a
+        // the center waits only until the value settles or turns out to stream (9.6), and hands a
         // stream on as its chunks — a generator, which is not thenable. The value the call reaches
         // resolves to it and is a stream of its own from then (9.6), so a second call joining it
         // (1.8) reads the same accumulation. A refusal a rung answers with is the value's refusal.
@@ -369,8 +371,35 @@ export function declare(method: Method): Declare {
         // this handler and these args is then answered from what this one reached, rather than by
         // running the handler again. In a browser nothing fills the slot, so the report is one load
         // of a `null`.
+        //
+        // 15.8 — AND REFUSED AHEAD OF THE HANDLER where the args leave a parameter of its route no
+        // spelling (30.3, 30.19), as the wire refuses them: a render and the browser's call then
+        // reach the same refusal, and there is no request for the render to report. The route is
+        // parsed once per address, which is stamped after the declaration (16.10).
+        let routed: string | undefined
+        let routeSegments: Segment[] | null = null
         const call = (given?: unknown, options?: CallOptions): unknown => {
-            const args = normalised(contract, given)
+            const args = normalized(contract, given)
+            const address = rpc.address
+            if (address !== routed) {
+                routed = address
+                routeSegments =
+                    address?.includes('[') === true
+                        ? parseRoutePattern(address)
+                        : null
+            }
+            if (routeSegments !== null) {
+                try {
+                    filledSegments(
+                        routeSegments,
+                        (args ?? {}) as Record<string, unknown>,
+                        routed as string,
+                        pathRefusal,
+                    )
+                } catch (refused) {
+                    return reactive(() => refused)
+                }
+            }
             const reached = callLoad(
                 reachThrough,
                 args,
@@ -472,7 +501,7 @@ export const DELETE: Declare = declare('DELETE')
 function addressOf(rpc: { address: string | undefined }): string {
     if (rpc.address === undefined)
         throw new Error(
-            'abide: this handler has no address yet. A handler is given one where it is mounted, under src/server/rpc (16.2).',
+            "abide: this handler has no address yet. A handler is given one where it is mounted: a handler file's default (16.2), or a `const` in a <script server> (16.70).",
         )
     return rpc.address
 }

package/src/shared/rpcRequest.ts

@@ -4,9 +4,12 @@
 // that agreement: method, URL and body, which is what makes two requests the same one.
 //
 // A `GET` or `DELETE` carries its args in the URL, in `queryText`'s spelling, and a mutation in its
-// body; 19.7 is where text becomes the declared type again.
+// body; 19.7 is where text becomes the declared type again. 16.9 — whatever the method, a parameter
+// of the handler's route rides in the path, and the server puts it back among the args (16.65).
 
+import { filledPath, parametersOf } from './filledPath.ts'
 import { queryText } from './queryText.ts'
+import { validationError } from './refuse.ts'
 import type { Method } from './rpc.ts'
 
 export type RpcRequest = {
@@ -32,10 +35,26 @@ export function argsInURL(method: Method): boolean {
 export function rpcRequest(
     method: Method,
     address: string,
-    args: Record<string, unknown> | undefined,
+    given: Record<string, unknown> | undefined,
 ): RpcRequest {
+    let args = given
     let url = address
     let body: string | undefined
+    // A route with parameters: they are written into the path and leave the args, so the query or
+    // body never carries one twice (16.66). 15.8 — one no address carries (30.3, 30.19) is refused as
+    // args a gate refused, so every caller answers it as the wire answers a 422.
+    if (address.includes('[')) {
+        const params = given ?? {}
+        url = filledPath(address, params, address, pathRefusal)
+        const inPath = parametersOf(address)
+        let rest: Record<string, unknown> | undefined
+        for (const name in params) {
+            if (inPath.has(name)) continue
+            rest ??= {}
+            rest[name] = params[name]
+        }
+        args = rest
+    }
     if (argsInURL(method)) {
         if (args !== undefined) {
             let text = queryText(args)
@@ -47,7 +66,7 @@ export function rpcRequest(
                 const bare = bareName(name)
                 text = text === '' ? bare : `${text}&${bare}`
             }
-            if (text !== '') url = `${address}?${text}`
+            if (text !== '') url = `${url}?${text}`
         }
     } else if (args !== undefined) body = JSON.stringify(args)
     // 18.14 — A COPY IS ITS OWN CACHE and keeps its own `max-age`. What it asks the server is asked
@@ -67,6 +86,11 @@ export function rpcRequest(
     return { method, url, body, init, key: `${method} ${url} ${body ?? ''}` }
 }
 
+/** 15.8 — a parameter no address carries, refused as args a gate refused. */
+export function pathRefusal(name: string, message: string): unknown {
+    return validationError<Record<string, unknown>>({ [name]: [message] })
+}
+
 /** A query member's name in the encoding `URLSearchParams` gives it, without its `=`. */
 export function bareName(name: string): string {
     return new URLSearchParams([[name, '']]).toString().slice(0, -1)