@abide/abide 0.112.0 → 0.114.0

package/src/server/requestScope.ts

@@ -22,6 +22,9 @@ import { IDLE_TIMEOUT_SECONDS } from './IDLE_TIMEOUT_SECONDS.ts'
 /** The three framings a stream is answered in. 17.6. */
 export type Framing = Framed | 'bytes'
 
+/** A principal cookie's claims, `exp` and `iat` aside, and when it lapses. 26.11. */
+export type Sealed = { claims: Record<string, unknown>; expires: number }
+
 /** What one request, or one `App.run`, carries across every `await` its work makes. */
 export type RequestScope = Scope & {
     /**
@@ -38,6 +41,8 @@ export type RequestScope = Scope & {
     caller: string | undefined
     /** This request's one resolve of the principal. 26.14. */
     principal: Promise<Principal> | undefined
+    /** What the principal cookie opened to once read, or `null` where it held no seal. */
+    opened: Sealed | null | undefined
     /** 16.23 — whether the received request's idle timeout is off until the answer is sent. */
     unreaped: boolean
     /** This response's nonce, minted by the `csp` rung or on the first ask. 29.3. */
@@ -168,6 +173,7 @@ export function scopeFor(
         unreaped: false,
         caller: undefined,
         principal: undefined,
+        opened: undefined,
         applied: false,
         request: given,
         route: undefined,

package/src/shared/FOREIGN_ATTRIBUTES.ts

@@ -0,0 +1,24 @@
+const XLINK = 'http://www.w3.org/1999/xlink'
+const XML = 'http://www.w3.org/XML/1998/namespace'
+const XMLNS = 'http://www.w3.org/2000/xmlns/'
+
+/**
+ * The attributes the HTML parser puts in a namespace on an SVG or MathML element — its "adjust
+ * foreign attributes" table — each to that namespace. Every other attribute it writes has none.
+ *
+ * A leaf, because the compiler reads it to know which built attribute needs the client's
+ * `addAttribute`, and the client reads it to write one.
+ */
+export const FOREIGN_ATTRIBUTES: ReadonlyMap<string, string> = new Map([
+    ['xlink:actuate', XLINK],
+    ['xlink:arcrole', XLINK],
+    ['xlink:href', XLINK],
+    ['xlink:role', XLINK],
+    ['xlink:show', XLINK],
+    ['xlink:title', XLINK],
+    ['xlink:type', XLINK],
+    ['xml:lang', XML],
+    ['xml:space', XML],
+    ['xmlns', XMLNS],
+    ['xmlns:xlink', XMLNS],
+])

package/src/shared/INTEGRATION_POINTS.ts

@@ -0,0 +1,20 @@
+/**
+ * The SVG and MathML elements whose children the HTML parser reads as HTML again — the
+ * integration points — less `annotation-xml`, which is one only by the encoding it declares.
+ *
+ * A leaf, because the client's parse and build read it (`namespaceUnder`) and the compiler reads
+ * it to know a built element below one is HTML's, whatever its parent's namespace.
+ */
+export const INTEGRATION_POINTS: ReadonlySet<string> = new Set([
+    'foreignObject',
+    'desc',
+    'title',
+    'mi',
+    'mo',
+    'mn',
+    'ms',
+    'mtext',
+])
+
+/** HTML's namespace: what the parser gives an element outside SVG and MathML, and below an integration point. */
+export const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml'

package/src/shared/IN_PROCESS_ORIGIN.ts

@@ -0,0 +1,5 @@
+// The origin a request made in process is addressed to, where no listener names a real one: an
+// rpc's `raw` answered by the app this process holds, a CLI command asking the app it booted, and
+// an `App.run` given a principal and no request (42.19). A leaf, because the server and the shared
+// rpc both build one.
+export const IN_PROCESS_ORIGIN = 'http://app.internal'

package/src/shared/reactive/Keyed.ts

@@ -34,6 +34,7 @@ import {
     refuseBothCaps,
     signalMoved,
     startDeferred,
+    unwatchStore,
 } from './Reactive.ts'
 import {
     detach,
@@ -46,6 +47,7 @@ import {
     type Tracked,
     trackProbe,
 } from './tracking.ts'
+import { owned, owning } from './watch.ts'
 
 /**
  * The keyed face: one `Reactive` per `Args` key, plus the probes and triggers over its entries.
@@ -262,27 +264,22 @@ class StartWindow {
 }
 
 /**
- * `body` behind the `args` gate: validate, then run the body with what the gate accepted.
- *
- * 11.27's LAST TWO STEPS as one body. The gate runs on every run of the entry — a refresh
- * re-validates — and throws the refusal, which is what a body failing already does: the entry's
- * `error` holds it and its read throws it (2.2), and the body the gate stands in front of is never
- * called. What it accepts is what the body is handed (11.68).
+ * `body` handed what the `args` gate accepted for one entry (11.68), rather than the args it was
+ * reached with.
  *
  * A STREAM STAYS A STREAM FROM CONSTRUCTION. 9.6 reads the body's KIND, so the wrapper around an
  * async generator is an async generator, or a gated keyed stream would be one only from its first
  * run.
  */
-function gated<Args>(
+function handed<Args>(
     body: (args: Args) => unknown,
-    gate: Schema<Args>,
+    accepted: Args,
 ): (args: Args) => unknown {
-    const check = (args: Args): Args => checkArgs(gate, args)
     if (isStreamBody(body))
-        return async function* (args: Args) {
-            yield* (body as (args: Args) => AsyncIterable<unknown>)(check(args))
+        return async function* () {
+            yield* (body as (args: Args) => AsyncIterable<unknown>)(accepted)
         }
-    return (args: Args): unknown => body(check(args))
+    return (): unknown => body(accepted)
 }
 
 /**
@@ -348,7 +345,7 @@ export function createKeyed<
                   (throttle ?? debounce) as number,
               )
     const lifetime = ttl === undefined ? null : new Lifetime(ttl)
-    const entryBody = heldOnce(gate === undefined ? body : gated(body, gate))
+    const entryBody = heldOnce(body)
     // 11.27, 11.29 — the defaults are applied before the key is taken, so the entry is one for a
     // call that wrote them and one that left them to the parameter. Read once, here: a body with
     // none pays a `null` test per reach.
@@ -358,6 +355,12 @@ export function createKeyed<
     // 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 = newTracked()
+    // 8.21 — A `Keyed` BUILT IN A SETUP OR A REQUEST ends with it, and every store its entries
+    // watch is stopped then: the entries are the cache's, so no owner of their own stops them.
+    if (options?.store !== undefined && owning())
+        owned(() => {
+            for (const entry of entries.values()) unwatchStore(entry)
+        })
 
     function askMembership(): void {
         const reader = TRACKING.reader
@@ -372,6 +375,7 @@ export function createKeyed<
     ): void {
         entries.delete(key)
         leaveSelections(created)
+        unwatchStore(created)
         signalMoved(membership)
     }
 
@@ -385,9 +389,32 @@ export function createKeyed<
             if (failedTransiently(standing)) standing.refresh()
             return standing
         }
+        // 11.27's VALIDATE, ONCE PER ENTRY AND BEFORE IT IS FILED: a refused `Args` is answered by a
+        // value holding the refusal (2.2) that no map keeps, so args nobody should have sent never
+        // take a place among the entries — on a `global` value, a place nothing but `invalidate`
+        // would take back (11.35). Built with none of the options: a `store` would restore a value
+        // over the refusal and watch for an entry nothing releases.
+        let run: (args: Args) => unknown = entryBody
+        if (gate !== undefined) {
+            let accepted: Args
+            try {
+                accepted = checkArgs(gate, args)
+            } catch (refusal) {
+                return createReactive<Stored, Accepted, Failures>(
+                    `${label}(${key})`,
+                    () => {
+                        throw refusal
+                    },
+                    args,
+                    undefined,
+                    undefined,
+                )
+            }
+            run = handed(entryBody, accepted)
+        }
         const created = createReactive<Stored, Accepted, Failures>(
             `${label}(${key})`,
-            entryBody as (args: unknown) => unknown,
+            run as (args: unknown) => unknown,
             args,
             undefined,
             entryOptions as ReactiveOptions<Accepted, Stored, Failures>,

package/src/shared/reactive/Reactive.ts

@@ -75,6 +75,7 @@ export type Transformer<Accepted, Stored, Failures = never> = (
 export type Store<Stored> = {
     get: () => Stored | undefined | Promise<Stored | undefined>
     set: (value: Stored, retention: { ttl: number }) => void | Promise<void>
+    watch?: (changed: () => void) => () => void
 }
 
 /**
@@ -366,6 +367,8 @@ type Persisted = {
      * what `pending` sends next, and what 8.18 serves a re-read in place of calling `get`.
      */
     unconfirmed: unknown
+    /** What stops the store's `watch`, where it has one (8.21). */
+    unwatch: (() => void) | null
 }
 
 /**
@@ -891,6 +894,7 @@ class Cell {
                       writing: false,
                       pending: false,
                       unconfirmed: undefined,
+                      unwatch: null,
                   }
         this.by = (options?.by ?? null) as
             | string
@@ -3801,6 +3805,32 @@ function rereadStore(cell: Cell, persisted: Persisted): void {
     )
 }
 
+/**
+ * Follows what the store says changed outside this process, re-reading it each time.
+ *
+ * 8.20 — A RE-READ, NEVER THE BODY: an edit made where the value lives is the store's news, so it
+ * is read back as a refresh of a value whose only producer is its store would read it, and 8.18
+ * still has a write the app made stand over it. 8.21 — stopped with the value: by its owner here,
+ * and by its `Keyed` through `unwatchStore` where an entry is evicted.
+ */
+function watchStore(cell: Cell, persisted: Persisted, cached: boolean): void {
+    const watch = persisted.store.watch
+    if (watch === undefined) return
+    persisted.unwatch = watch(() => {
+        rereadStore(cell, persisted)
+    })
+    if (!cached && owning()) owned(() => unwatchStore(cell.callable))
+}
+
+/** Stops the store's `watch` on `value`, once (8.21). */
+export function unwatchStore(value: unknown): void {
+    const persisted = (value as Callable)[CELL].store
+    if (persisted === null || persisted.unwatch === null) return
+    const unwatch = persisted.unwatch
+    persisted.unwatch = null
+    unwatch()
+}
+
 /**
  * Lands a store re-read, letting an unconfirmed write win.
  *
@@ -4693,8 +4723,10 @@ export function createReactive<
     // (2.2, 4.14) rather than serving an `undefined` its own type says is a `Stored`.
     // 8.3 AND 8.14: a store answers first, where the value is constructed, and whatever it misses
     // falls back to what the value would have done without one.
-    if (cell.store !== null) restoreFirst(cell, cell.store, initial)
-    else if (body === null) {
+    if (cell.store !== null) {
+        restoreFirst(cell, cell.store, initial)
+        watchStore(cell, cell.store, cached)
+    } else if (body === null) {
         if (initial === undefined) landOpening(cell)
         else if (initial !== NO_INITIAL) open(cell, initial)
     } else if (deferred) cell.loading = true

package/src/shared/rpc.ts

@@ -16,6 +16,7 @@
 import { type Failed, isFailedNamed } from './Failed.ts'
 import { GLOBAL_GETS } from './GLOBAL_GETS.ts'
 import { HandlerRoute } from './HandlerRoute.ts'
+import { IN_PROCESS_ORIGIN } from './IN_PROCESS_ORIGIN.ts'
 import { compose, type Middleware } from './Middleware.ts'
 import { principalRotated } from './principalRotated.ts'
 import { RPC_SERVER } from './RPC_SERVER.ts'
@@ -442,7 +443,7 @@ export function declare(method: Method): Declare {
                 if (RPC_SERVER.raw !== null)
                     return RPC_SERVER.raw(
                         new Request(
-                            new URL(asked.url, 'http://app.internal'),
+                            new URL(asked.url, IN_PROCESS_ORIGIN),
                             given,
                         ),
                     )

package/src/ui/bindSpread.ts

@@ -4,6 +4,7 @@
 
 import { spreadEntries } from '#shared/spread.ts'
 import type { Scope } from './Scope.ts'
+import { addAttribute } from './setAttribute.ts'
 
 /** Keeps an element's spread attributes and `on<event>` listeners written as the value changes. */
 export function bindSpread(
@@ -19,8 +20,9 @@ export function bindSpread(
         const next = new Set<string>()
         for (const [name, text] of spreadEntries(read(), explicit, wanted)) {
             next.add(name)
-            if (element.getAttribute(name) !== text)
-                element.setAttribute(name, text)
+            const standing = element.getAttribute(name)
+            if (standing === null) addAttribute(element, name, text)
+            else if (standing !== text) element.setAttribute(name, text)
         }
         for (const name of written)
             if (!next.has(name)) element.removeAttribute(name)

package/src/ui/index.ts

@@ -48,7 +48,7 @@ export { escapeless } from './escapeless.ts'
 export { contributeHead } from './Level.ts'
 export { listAt, updateList } from './List.ts'
 export { warnMismatch } from './Mismatch.ts'
-export { markupNodes } from './parseMarkup.ts'
+export { markupNodes, namespaceUnder } from './parseMarkup.ts'
 export {
     fillEmpty,
     fillRegion,
@@ -58,7 +58,7 @@ export {
 export { rowKeyOf } from './rowKeyOf.ts'
 export { itemOf, noUpdate, replaceRow, rowCell } from './rows.ts'
 export { EMPTY_SCOPE, Scope } from './Scope.ts'
-export { setAttribute } from './setAttribute.ts'
+export { addAttribute, setAttribute } from './setAttribute.ts'
 export { setClass } from './setClass.ts'
 export { setClassGroup } from './setClassGroup.ts'
 export { setMarkup } from './setMarkup.ts'

package/src/ui/parseMarkup.ts

@@ -1,3 +1,8 @@
+import {
+    HTML_NAMESPACE,
+    INTEGRATION_POINTS,
+} from '#shared/INTEGRATION_POINTS.ts'
+
 // MARKUP PARSED IN THE DOCUMENT `parent` BELONGS TO, not the global one. A page mounted into a second
 // document (an example `<iframe>`) parsed its `{#if}` arms in the right one and its `{#for}` rows in
 // the page's while the two were separate copies of this; one copy is one answer.
@@ -9,26 +14,22 @@ const TEMPLATES = new WeakMap<Document, HTMLTemplateElement>()
 const SVG = 'http://www.w3.org/2000/svg'
 const MATHML = 'http://www.w3.org/1998/Math/MathML'
 
-// The foreign elements whose children the parser reads as HTML again — the integration points —
-// so markup going into one parses the way it would at the template's own top level.
-const INTEGRATION_POINTS = new Set([
-    'foreignObject',
-    'desc',
-    'title',
-    'mi',
-    'mo',
-    'mn',
-    'ms',
-    'mtext',
-])
-
-/** Whether the parser reads `element`'s children as HTML again, though it is SVG or MathML. */
-function isIntegrationPoint(element: Element): boolean {
-    if (INTEGRATION_POINTS.has(element.localName)) return true
+/**
+ * The namespace an element the parser makes inside `parent` takes: SVG's or MathML's under an
+ * element of either, and HTML's under anything else — an HTML element, a document, a fragment, and
+ * an integration point (`INTEGRATION_POINTS`), whose children the parser reads as HTML again.
+ */
+export function namespaceUnder(parent: Node): string {
+    const element = parent as Element
+    const space = element.namespaceURI
+    if (space !== SVG && space !== MATHML) return HTML_NAMESPACE
+    if (INTEGRATION_POINTS.has(element.localName)) return HTML_NAMESPACE
     // The HTML standard makes an `<annotation-xml>` one only by the encoding it declares.
-    if (element.localName !== 'annotation-xml') return false
+    if (element.localName !== 'annotation-xml') return space
     const encoding = element.getAttribute('encoding')?.toLowerCase()
     return encoding === 'text/html' || encoding === 'application/xhtml+xml'
+        ? HTML_NAMESPACE
+        : space
 }
 
 /**
@@ -48,14 +49,8 @@ export function parseMarkup(parent: Node, markup: string): DocumentFragment {
         template = document.createElement('template')
         TEMPLATES.set(document, template)
     }
-    const space = (parent as Element).namespaceURI
-    const wrapper =
-        (space !== SVG && space !== MATHML) ||
-        isIntegrationPoint(parent as Element)
-            ? undefined
-            : space === SVG
-              ? 'svg'
-              : 'math'
+    const space = namespaceUnder(parent)
+    const wrapper = space === HTML_NAMESPACE ? undefined : space === SVG ? 'svg' : 'math'
     if (wrapper === undefined) {
         template.innerHTML = markup
         return template.content

package/src/ui/setAttribute.ts

@@ -1,4 +1,6 @@
 import { attributeText } from '#shared/attributeText.ts'
+import { FOREIGN_ATTRIBUTES } from '#shared/FOREIGN_ATTRIBUTES.ts'
+import { HTML_NAMESPACE } from '#shared/INTEGRATION_POINTS.ts'
 import { WORK } from '#shared/WORK.ts'
 
 /**
@@ -33,5 +35,27 @@ export function setAttribute(
         if (element.hasAttribute(name)) element.removeAttribute(name)
         return
     }
-    if (element.getAttribute(name) !== next) element.setAttribute(name, next)
+    const standing = element.getAttribute(name)
+    if (standing === next) return
+    if (standing === null) addAttribute(element, name, next)
+    else element.setAttribute(name, next)
+}
+
+/**
+ * Writes an attribute `element` does not hold yet, in the namespace the parser gives it there.
+ *
+ * 32.70 — an `xlink:href` on an SVG element is XLink's (`FOREIGN_ATTRIBUTES`), and one
+ * `setAttribute` makes has none, so a `<use>` it names draws nothing. Only an attribute's CREATION
+ * decides its namespace: `setAttribute` and `getAttribute` find a standing one by its qualified
+ * name, whatever namespace it is in.
+ */
+export function addAttribute(
+    element: Element,
+    name: string,
+    text: string,
+): void {
+    const space = FOREIGN_ATTRIBUTES.get(name)
+    if (space === undefined || element.namespaceURI === HTML_NAMESPACE)
+        element.setAttribute(name, text)
+    else element.setAttributeNS(space, name, text)
 }