@abide/abide 0.101.0 → 0.102.0

package/src/shared/ADDRESSES.ts

@@ -7,20 +7,19 @@
 /**
  * The namespace every framework address lives under.
  *
- * UNDER `/__abide`, which is the namespace the framework's own addresses live in (19.1, 20.5,
- * 25.1). That is what makes a route table and an asset table incapable of colliding: a page is a
- * directory under `pages/` and no directory there can be named `__abide` without an author
- * writing it, so nothing has to be checked at build time and nothing can be shadowed at run time.
- * 38.21 is the clause.
+ * UNDER `/__abide`, which is the namespace the framework's own addresses live in (20.5, 25.1).
+ * That is what keeps the app's routes and abide's own addresses from colliding: a route whose first
+ * segment is `__abide` is refused at build (23.17), so nothing can be shadowed at run time. 38.20
+ * is the clause.
  */
 export const ABIDE_ADDRESS = '/__abide'
 
 /**
  * Where the browser bundle is served.
  *
- * The bundle's own address below `ABIDE_ADDRESS` (38.17, 38.21). One request path answers
+ * The bundle's own address below `ABIDE_ADDRESS` (38.16, 38.20). One request path answers
  * everything under `ABIDE_ADDRESS` and the command supplying the app decides what is there, so a
- * command with a second address of its own — the reload client `abide dev` serves (38.18) — adds
+ * command with a second address of its own — the reload client `abide dev` serves (38.17) — adds
  * one rather than a lane.
  */
 export const CLIENT_ADDRESS = `${ABIDE_ADDRESS}/client`
@@ -31,8 +30,6 @@ export const CLIENT_ADDRESS = `${ABIDE_ADDRESS}/client`
 export const OPENAPI_ADDRESS = `${ABIDE_ADDRESS}/openapi.json`
 /** The MCP endpoint. */
 export const MCP_ADDRESS = `${ABIDE_ADDRESS}/mcp`
-/** The stream of log records. */
-export const LOGS_ADDRESS = `${ABIDE_ADDRESS}/logs`
 /** The health check. */
 export const HEALTH_ADDRESS = `${ABIDE_ADDRESS}/health`
 /** Where a visitor's Claude Code bridge pairs, and is relayed turns (45.13). */
@@ -41,19 +38,11 @@ export const BRIDGE_ADDRESS = `${ABIDE_ADDRESS}/bridge`
 /**
  * The socket the dev reload client holds open.
  *
- * 38.18 — the LISTENER upgrades it on the main thread and the dev WORKER serves the script that
+ * 38.17 — the LISTENER upgrades it on the main thread and the dev WORKER serves the script that
  * opens it.
  */
 export const DEV_ADDRESS = `${ABIDE_ADDRESS}/dev`
 
-/**
- * Where a `server/rpc` handler is answered over http.
- *
- * 16.2 — its path below that directory, then its export name (19.1). The build writes the address
- * into the browser's wrapper and the server answers at it.
- */
-export const RPC_ADDRESS = `${ABIDE_ADDRESS}/rpc`
-
 /**
  * Where the one web socket a page follows its `GET`s over is served, below the app's root.
  *

package/src/shared/APP_META.ts

@@ -0,0 +1,7 @@
+/**
+ * The `<meta>` the server writes the app's name into, and a browser's logger reads it back from, so
+ * `log.named` prefixes the same name on both sides.
+ *
+ * 28.4.
+ */
+export const APP_META = 'abide-app'

package/src/shared/CopyOptions.ts

@@ -4,7 +4,7 @@
  * 18.4 — WHAT A `GET`'s VALUE DECLARES THAT ITS BROWSER COPY HAS TO BEHAVE BY, as the build reads
  * it off the declaration and writes it into the wrapper: data, because it crosses as text.
  * `structural` is named rather than carried, being abide's own comparator on both sides; an app's
- * own has no serialisation and stays the server's, as a function `by` or `tags` does.
+ * own has no serialization and stays the server's, as a function `by` or `tags` does.
  */
 export type CopyOptions = {
     by?: string

package/src/shared/DEBUG_META.ts

@@ -1,6 +1,6 @@
 /**
  * The `<meta>` the server writes `DEBUG` into, and a browser reads it back from.
  *
- * 28.11.
+ * 28.10.
  */
 export const DEBUG_META = 'abide-debug'

package/src/shared/RESERVED_DIRECTORIES.ts

@@ -0,0 +1,15 @@
+// THE TWO DIRECTORY NAMES THAT ARE NEVER AN ADDRESS (23.15): `server` fences a graph (16.29) and
+// `public` is answered as authored (36.11). Every other directory under the root is a segment of the
+// address of the `page.abide`, `layout.abide` and `error.abide` in it (23.14).
+
+/** A module under one only the server loads. */
+export const SERVER_DIRECTORY = 'server'
+
+/** A file under one is answered as authored, at the path above it. */
+export const PUBLIC_DIRECTORY = 'public'
+
+/** Both, as the walk of the app tests a directory against them. */
+export const RESERVED_DIRECTORIES: ReadonlySet<string> = new Set([
+    SERVER_DIRECTORY,
+    PUBLIC_DIRECTORY,
+])

package/src/shared/cookies.ts

@@ -185,12 +185,12 @@ export function serializeCookie(init: CookieInit, inBrowser: boolean): string {
     // A page's own script cannot set an `HttpOnly` cookie, and a browser drops the whole line that
     // asks to — so the attribute is a server's alone.
     if (init.httpOnly === true && !inBrowser) line += '; HttpOnly'
-    line += `; SameSite=${capitalised(init.sameSite ?? 'lax')}`
+    line += `; SameSite=${capitalized(init.sameSite ?? 'lax')}`
     if (init.partitioned === true) line += '; Partitioned'
     return line
 }
 
-function capitalised(sameSite: string): string {
+function capitalized(sameSite: string): string {
     return sameSite.charAt(0).toUpperCase() + sameSite.slice(1)
 }
 

package/src/shared/csp.ts

@@ -41,7 +41,7 @@ export function documentNonce(): string {
  * A middleware rung that sets the content security policy, and `csp.nonce()` for the current one.
  *
  * THE RUNG IS BUILT ON ITS FIRST REQUEST, because an app's `middleware` can be read before the
- * server half has filled `CSP`: `app.ts` is one more module, and nothing orders it after that one.
+ * server half has filled `CSP`: the root `layout.abide` is one more module, and nothing orders it after that one.
  */
 export const csp = Object.assign(
     (sources?: Record<string, string[]>): Rung => {

package/src/shared/escapeText.ts

@@ -10,7 +10,7 @@ import { RAW_WRITES, Raw, textOf } from './Raw.ts'
 // the fallback: a clean string is returned as it arrived, with no allocation.
 //
 // THE DETECTION IS THE ENGINE'S, not a `charCodeAt` loop. The hand-written scan is one JS
-// iteration per character where this is vectorised, and it lost on the case it was written for:
+// iteration per character where this is vectorized, and it lost on the case it was written for:
 // 5x on a clean 74-character slot and 14x on a clean 320-character one, over two runs that did
 // not swap places. The share is named — `escapeText` is 74-86% of a 500-row x 4-slot markup
 // build, and the whole build moves 1.7x.

package/src/shared/filledPath.ts

@@ -0,0 +1,85 @@
+// A ROUTE'S PATH WITH ITS PARAMETERS WRITTEN IN, for the two things that build an address from a
+// route: `url`, from a page's literal (30.1), and a call, from its handler's route (16.9).
+
+import { parseRoutePattern, type Segment } from './routePattern.ts'
+
+/**
+ * `pattern` with each parameter `params` names written in as a path segment, or `/` for none.
+ *
+ * `spelled` is how the caller is named where a parameter is refused — `url('/x/[id]')`, or a
+ * handler's route — and `refused` what is thrown for it: an `Error` naming the clause, by default.
+ */
+export function filledPath(
+    pattern: string,
+    params: Record<string, unknown>,
+    spelled: string,
+    refused: (name: string, message: string) => unknown = thrownError,
+): string {
+    return filledSegments(parseRoutePattern(pattern), params, spelled, refused)
+}
+
+/** `filledPath` over a route already parsed, for a caller that fills the same route per call. */
+export function filledSegments(
+    segments: Segment[],
+    params: Record<string, unknown>,
+    spelled: string,
+    refused: (name: string, message: string) => unknown,
+): string {
+    let address = ''
+    for (const segment of segments) {
+        if (segment.kind === 'static') {
+            address += `/${segment.name}`
+            continue
+        }
+        const value = params[segment.name]
+        if (value === undefined || value === null || value === '') {
+            // 30.4 — an optional left out omits its segment, and so does an empty rest (30.5).
+            if (segment.kind !== 'required') continue
+            throw refused(
+                segment.name,
+                `abide: ${spelled} was given no '${segment.name}', and the route requires it. RULEBOOK 30.3.`,
+            )
+        }
+        if (segment.kind === 'rest' && Array.isArray(value)) {
+            for (const each of value)
+                address += `/${encodedSegment(spelled, segment.name, each, refused)}`
+            continue
+        }
+        address += `/${encodedSegment(spelled, segment.name, value, refused)}`
+    }
+    return address === '' ? '/' : address
+}
+
+/** The names of `pattern`'s parameters — what a call takes out of its args and into the path (16.66). */
+export function parametersOf(pattern: string): Set<string> {
+    const names = new Set<string>()
+    for (const segment of parseRoutePattern(pattern))
+        if (segment.kind !== 'static') names.add(segment.name)
+    return names
+}
+
+/**
+ * A param value encoded as one path segment; `.` and `..` are refused.
+ *
+ * 30.19 — A VALUE OF `.` OR `..` HAS NO SPELLING AS A SEGMENT: the URL parser collapses it as a
+ * dot-segment, and `%2E` / `%2E%2E` with it, so the address would land on another route. Refused
+ * rather than written, as a missing required segment is (30.3).
+ */
+function encodedSegment(
+    spelled: string,
+    name: string,
+    value: unknown,
+    refused: (name: string, message: string) => unknown,
+): string {
+    const text = String(value)
+    if (text === '.' || text === '..')
+        throw refused(
+            name,
+            `abide: ${spelled} was given '${text}' for '${name}', and no address carries it as a segment — the URL parser resolves it to another route. RULEBOOK 30.19.`,
+        )
+    return encodeURIComponent(text)
+}
+
+function thrownError(_name: string, message: string): Error {
+    return new Error(message)
+}

package/src/shared/framing.ts

@@ -1,6 +1,34 @@
 // 16.32 — A FRAMED ANSWER, read one JSON value per line: the whole line for jsonl, the `data:` line of
 // each event for sse. A line that does not carry the prefix — an sse `event:` line, a blank line — is
 // skipped. One line reader behind both a body read to the end and one read as it lands.
+//
+// 16.68 — AND ITS LAST FRAME MAY BE A REFUSAL: one that reached the stream after it had answered, so
+// after its status was sent. An sse `event: refusal` and the Problem Details on its `data:` line, or a
+// jsonl line `{"$refusal": <Problem Details>}` — read here as the refusal, thrown where it lands.
+
+import { failedFrom, isProblem, type Problem } from './Failed.ts'
+
+/** The key a jsonl line carries a refusal under (16.68). */
+const REFUSAL_KEY = '$refusal'
+
+/** A framed stream's last frame, as the server writes it for a refusal (16.68). */
+export function refusalFrame(problem: Problem, prefix: string): string {
+    return prefix === ''
+        ? `${JSON.stringify({ [REFUSAL_KEY]: problem })}\n`
+        : `event: refusal\n${prefix}${JSON.stringify(problem)}\n\n`
+}
+
+// What a read of one framed body carries from one line to the next: whether an sse event named the
+// data line after it a refusal.
+type Reading = { refusal: boolean }
+
+// A refusal's frame, read: thrown where it lands among the chunks.
+class Refused {
+    problem: Problem
+    constructor(problem: Problem) {
+        this.problem = problem
+    }
+}
 
 /**
  * What precedes a chunk's JSON on its line: nothing for jsonl, `data: ` for sse, and `null` where
@@ -67,14 +95,16 @@ async function* bytesStream(
 /** The chunks a framed text carried, every line of it complete. */
 export function framedChunks(text: string, prefix: string): unknown[] {
     const chunks: unknown[] = []
-    readLines(text, prefix, true, chunks)
+    readLines(text, prefix, true, chunks, { refusal: false })
+    for (const chunk of chunks)
+        if (chunk instanceof Refused) throw failedFrom(chunk.problem)
     return chunks
 }
 
 /**
  * A framed body's chunks, yielded as each line completes.
  *
- * Cancelled when the reader stops reading — a refresh starts a new run and the old one's reader has
+ * Canceled when the reader stops reading — a refresh starts a new run and the old one's reader has
  * nothing left to hand anything.
  */
 export async function* framedStream(
@@ -84,6 +114,7 @@ export async function* framedStream(
     const reader = body.getReader()
     const decoder = new TextDecoder()
     const chunks: unknown[] = []
+    const reading: Reading = { refusal: false }
     let buffered = ''
     try {
         for (;;) {
@@ -97,8 +128,17 @@ export async function* framedStream(
                 buffered += decoded
                 continue
             }
-            buffered = readLines(buffered + decoded, prefix, done, chunks)
-            yield* chunks
+            buffered = readLines(
+                buffered + decoded,
+                prefix,
+                done,
+                chunks,
+                reading,
+            )
+            for (const chunk of chunks) {
+                if (chunk instanceof Refused) throw failedFrom(chunk.problem)
+                yield chunk
+            }
             chunks.length = 0
             if (done) return
         }
@@ -117,15 +157,48 @@ function readLines(
     prefix: string,
     ended: boolean,
     chunks: unknown[],
+    reading: Reading,
 ): string {
     let start = 0
     for (;;) {
         const newline = text.indexOf('\n', start)
         if (newline === -1 && !ended) return text.slice(start)
         const end = newline === -1 ? text.length : newline
-        if (end > start && text.startsWith(prefix, start))
-            chunks.push(JSON.parse(text.slice(start + prefix.length, end)))
+        if (prefix !== '' && text.startsWith('event: refusal', start))
+            reading.refusal = true
+        else if (end > start && text.startsWith(prefix, start)) {
+            const value: unknown = JSON.parse(
+                text.slice(start + prefix.length, end),
+            )
+            chunks.push(refusalIn(value, prefix, reading) ?? value)
+            reading.refusal = false
+        }
         if (newline === -1) return ''
         start = newline + 1
     }
 }
+
+// The refusal a value carries as its frame: the data line an sse event named one, or a jsonl line
+// holding the one reserved key and Problem Details under it.
+function refusalIn(
+    value: unknown,
+    prefix: string,
+    reading: Reading,
+): Refused | undefined {
+    if (prefix !== '')
+        return reading.refusal && isProblem(value)
+            ? new Refused(value)
+            : undefined
+    // Per chunk: the reserved key is tested before any key list is built.
+    if (
+        value === null ||
+        typeof value !== 'object' ||
+        !Object.hasOwn(value, REFUSAL_KEY)
+    )
+        return undefined
+    const keys = Object.keys(value)
+    const problem = (value as Record<string, unknown>)[REFUSAL_KEY]
+    return keys.length === 1 && isProblem(problem)
+        ? new Refused(problem)
+        : undefined
+}

package/src/shared/headKeyOf.ts

@@ -20,6 +20,8 @@ export function headKeyOf(
 ): string | undefined {
     if (lowerTag === 'title' || lowerTag === 'base') return lowerTag
     if (lowerTag === 'meta') {
+        // One encoding a document, so a layout's replaces the default document's.
+        if (attribute('charset') != null) return 'meta charset'
         const named = attribute('name')
         const key = named === null ? attribute('property') : named
         return key == null ? undefined : `meta ${key}`

package/src/shared/index.ts

@@ -36,7 +36,7 @@ export { listOf } from './listOf.ts'
 export { type Logger, type LogRecord, log } from './log.ts'
 export type { Middleware } from './Middleware.ts'
 export type { Params } from './matchRoute.ts'
-// 38.89 — a desktop app's menu items, exported by the route's layouts and page.
+// 38.88 — a desktop app's menu items, exported by the route's layouts and page.
 export {
     type MenuEntry,
     type MenuItem,

package/src/shared/log.ts

@@ -1,14 +1,15 @@
 // SECTION 28 — the logger, on both sides. A line is written to the console AND published to
-// `log.records` (28.1), so a subscriber — `abide logs`, a test, a page — sees exactly what the
+// `log.records` (28.1), so a subscriber — a handler, a test, a page — sees exactly what the
 // terminal saw.
 //
 // THE RECORDS ARE BUILT ON FIRST ASK. The reactive core warns through this module, so a
 // `reactive` built at this module's evaluation would be a cycle evaluated in the wrong order;
 // built on the first line or the first read of `log.records`, the core has long since loaded.
 //
-// 28.11, 28.12 — IN A BROWSER, `DEBUG` IS THE DOCUMENT'S: the server names it in a `<meta>` it writes
+// 28.10, 28.11 — IN A BROWSER, `DEBUG` IS THE DOCUMENT'S: the server names it in a `<meta>` it writes
 // into the head, and the browser's own stored `debug` answers only where the document carries none.
 
+import { APP_META } from './APP_META.ts'
 import { DEBUG_META } from './DEBUG_META.ts'
 import { paint } from './paint.ts'
 import { type Reactive, reactive } from './reactive/index.ts'
@@ -53,7 +54,7 @@ function recordsValue(): Reactive<LogRecord[]> {
             Number.isInteger(configured) && configured >= 0
                 ? configured
                 : DEFAULT_BUFFER
-        // 28.1 — one array for the process, which `/__abide/logs` follows (28.2).
+        // 28.1 — one array for the process.
         records = reactive<LogRecord[]>([], { global: true })
     }
     return records
@@ -62,7 +63,7 @@ function recordsValue(): Reactive<LogRecord[]> {
 /**
  * Appends `record` to `log.records`, trimming to the buffer it keeps.
  *
- * THE TRIM IS AMORTISED: grown to twice the buffer and cut back in one move, rather than a `shift`
+ * THE TRIM IS AMORTIZED: grown to twice the buffer and cut back in one move, rather than a `shift`
  * per line that moves every record still held.
  */
 function keep(list: LogRecord[], record: LogRecord): void {
@@ -81,14 +82,26 @@ function keep(list: LogRecord[], record: LogRecord): void {
  */
 let documentDebugRead: string | undefined
 
+let documentAppRead: string | undefined
+
 function environment(name: string): string | undefined {
     if (typeof process !== 'undefined') return process.env[name]
+    // 28.4 — the app's name, as the server wrote it into the document.
+    if (name === 'APP_NAME') {
+        documentAppRead ??=
+            (typeof document === 'undefined'
+                ? undefined
+                : document
+                      .querySelector(`meta[name="${APP_META}"]`)
+                      ?.getAttribute('content')) ?? ''
+        return documentAppRead === '' ? undefined : documentAppRead
+    }
     if (name !== 'DEBUG') return undefined
     documentDebugRead ??= documentDebug() ?? ''
     return documentDebugRead
 }
 
-/** The document's `DEBUG`, or the browser's own stored one where it carries none (28.11, 28.12). */
+/** The document's `DEBUG`, or the browser's own stored one where it carries none (28.10, 28.11). */
 export function documentDebug(): string | undefined {
     if (typeof document === 'undefined') return undefined
     const named = document
@@ -106,7 +119,7 @@ export function documentDebug(): string | undefined {
 /**
  * The compiled `DEBUG` patterns: namespaces included, and namespaces excluded.
  *
- * 28.10 — THE debug-npm GRAMMAR: a list split on commas or whitespace, `*` any run of characters,
+ * 28.9 — THE debug-npm GRAMMAR: a list split on commas or whitespace, `*` any run of characters,
  * and a leading `-` an exclusion that beats every inclusion. Compiled once per distinct `DEBUG`.
  */
 type Gate = { include: RegExp[]; exclude: RegExp[] }
@@ -131,7 +144,7 @@ function currentGate(): Gate {
     return gate
 }
 
-/** Whether `DEBUG` enables a namespace's gated lines (28.7). */
+/** Whether `DEBUG` enables a namespace's gated lines (28.6). */
 function isEnabled(namespace: string): boolean {
     const { include, exclude } = currentGate()
     for (const pattern of exclude) if (pattern.test(namespace)) return false
@@ -215,12 +228,12 @@ function write(
     recordsValue().patch((list) => keep(list, record))
 }
 
-/** A logger under `namespace`, which 28.5 builds from the app's name and 28.9 from `abide:`. */
+/** A logger under `namespace`, which 28.4 builds from the app's name and 28.8 from `abide:`. */
 export function namedLogger(namespace: string): Logger {
     return loggerOver(() => namespace)
 }
 
-/** Both lanes' render logger (28.9): the server's escalations and 32.20's dropped URLs. */
+/** Both lanes' render logger (28.8): the server's escalations and 32.20's dropped URLs. */
 export const RENDER_LOG = namedLogger('abide:render')
 
 /**
@@ -229,7 +242,7 @@ export const RENDER_LOG = namedLogger('abide:render')
  * The namespace is ASKED per line rather than held, which is all `log` needs over a named logger.
  */
 function loggerOver(namespaceOf: () => string): Logger {
-    // 28.3 — the bare call always writes. 28.4 — so do warnings and errors.
+    // 28.2 — the bare call always writes. 28.3 — so do warnings and errors.
     const logger = ((...args: unknown[]): void => {
         write(namespaceOf(), 'info', args)
     }) as Logger
@@ -243,7 +256,7 @@ function loggerOver(namespaceOf: () => string): Logger {
     }
     logger.warning = (...args) => write(namespaceOf(), 'warning', args)
     logger.error = (...args) => write(namespaceOf(), 'error', args)
-    // 28.5 — another segment, below this one. 28.13 — asked per line too, so a logger named at module
+    // 28.4 — another segment, below this one. 28.12 — asked per line too, so a logger named at module
     // load, before the app's name resolved, writes under the name once it has.
     logger.named = (name) => loggerOver(() => `${namespaceOf()}:${name}`)
     logger.enabled = () => isEnabled(namespaceOf())
@@ -254,14 +267,15 @@ function loggerOver(namespaceOf: () => string): Logger {
 /**
  * The slot the derived app name is read through, filled by the server's `config`.
  *
- * 28.5 — the app's name is the root every `log.named` hangs off: the environment's, or what 27.3
+ * 28.4 — the app's name is the root every `log.named` hangs off: the environment's, or what 27.3
  * derived, which the server's `config` fills in here.
  */
 export const APP_NAME: { derived: () => string | undefined } = {
     derived: () => undefined,
 }
 
-function appName(): string {
+/** The name every `log.named` hangs off: the environment's, or the one the app derived (28.4). */
+export function appName(): string {
     return environment('APP_NAME') ?? APP_NAME.derived() ?? 'app'
 }
 

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/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'
@@ -352,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.