@abide/abide 0.110.4 → 0.112.0

package/src/compiler/emitClient.ts

@@ -21,6 +21,7 @@ import {
     classifyAttributes,
     isBound,
     isSingleRooted,
+    type MergeGroup,
     isSlot,
 } from './classifyTemplate.ts'
 import { decodeCharacterReferences } from './decodeCharacterReferences.ts'
@@ -220,9 +221,7 @@ export function emitClient(
     const registered = heads
         ? `if (${ROUTED}) ${ROUTED}.setHead(() => ${headMarkup})\n`
         : ''
-    const applied = heads
-        ? `if (${ROUTED}) ${lowering.use('applyHead')}(${ROUTED}.headMarkup()); `
-        : ''
+    const applied = heads ? `if (${ROUTED}) ${ROUTED}.reconcile(); ` : ''
     // Applied with the fill either way, so the watch's first run only subscribes: what it would
     // write is already there, from the server or from the line above.
     if (liveHeads) lines.push(`if (${ROUTED}) ${ROUTED}.followHead(${SCOPE})`)
@@ -767,6 +766,17 @@ function elementUnits(
             )
         // 32.5, 32.7, 32.8 — THE PROPERTY AND THE VALUE, IN STEP BOTH WAYS: a watch on this
         // region's scope writes the property, and a listener writes it back.
+        // 32.8 — a group compares against the input's own value, read where the value is.
+        else if (one.kind === 'bound' && one.bind === 'group')
+            binds.push(
+                `${lowering.use('bindGroup')}(${element}, ${lowering.reference(one.attribute)}, () => (${
+                    one.own === undefined
+                        ? "'on'"
+                        : one.own.expression
+                          ? lowering.binding(one.own)
+                          : JSON.stringify(one.own.value)
+                }), ${SCOPE})`,
+            )
         else if (one.kind === 'bound')
             binds.push(
                 `${lowering.use('bindProperty')}(${element}, ${JSON.stringify(one.bind)}, ${lowering.reference(one.attribute)}, ${SCOPE})`,
@@ -798,16 +808,32 @@ if (__r${slot} !== undefined) ${SCOPE}.stops.push(__r${slot})`,
                           write: 'attribute' as const,
                           name: one.attribute.name,
                       }
+            // 32.71 — A SHARED GROUP IS ONE WATCH over its whole value, which wakes for any member:
+            // a directive cannot keep what the plain attribute holds from a watch of its own.
+            const group =
+                one.kind === 'merged' && writesGroup(write)
+                    ? one.group
+                    : undefined
             // 32.67 — one reading a row's item is one of the row's item watches, on a name of its
             // own because it is installed apart from the element's other attributes.
-            if (lowering.readsOwnItem(one.attribute))
-                itemWrites.push(
-                    `${SCOPE}.itemWatch(() => ${lowering.use(WRITES[write])}(__i${slot}, ${JSON.stringify(name)}, ${lowering.binding(one.attribute)}))`,
-                )
-            else
-                writes.push(
-                    `${SCOPE}.watch(() => ${lowering.use(WRITES[write])}(__a${slot}, ${JSON.stringify(name)}, ${lowering.binding(one.attribute)}))`,
-                )
+            const asItem =
+                group === undefined
+                    ? lowering.readsOwnItem(one.attribute)
+                    : groupReadsOwnItem(group, lowering)
+            const call = writeCall(
+                write,
+                asItem ? `__i${slot}` : `__a${slot}`,
+                name,
+                group === undefined
+                    ? lowering.binding(one.attribute)
+                    : groupArguments(group, (attribute) =>
+                          lowering.binding(attribute),
+                      ),
+                lowering,
+            )
+            ;(asItem ? itemWrites : writes).push(
+                `${SCOPE}.${asItem ? 'itemWatch' : 'watch'}(() => ${call})`,
+            )
         }
     }
     if (itemWrites.length > 0)
@@ -825,14 +851,27 @@ if (__r${slot} !== undefined) ${SCOPE}.stops.push(__r${slot})`,
 const SCOPE = '__scope'
 
 // Which runtime write each kind of attribute binding is handed to. A record rather than a chain
-// of ternaries, so a fourth kind is a row here and the call site stays one line — all three take
-// the same three arguments, which is what makes them one site at all.
+// of ternaries, so a sixth kind is a row here and the call site stays one line — all take the
+// same three arguments, which is what makes them one site at all.
 const WRITES = {
     attribute: 'setAttribute',
     class: 'setClass',
     style: 'setStyleProperty',
+    classGroup: 'setClassGroup',
+    styleGroup: 'setStyleGroup',
 } as const
 
+/** One attribute binding's write: the element, the one name it owns, and the value. */
+function writeCall(
+    write: keyof typeof WRITES,
+    element: string,
+    name: string,
+    value: string,
+    lowering: Lowering,
+): string {
+    return `${lowering.use(WRITES[write])}(${element}, ${JSON.stringify(name)}, ${value})`
+}
+
 // The share scope an instance captures for its deferred mounts (10.5), named apart from the one an
 // instance OPENS (`shareScope`): a page that shares nothing still carries this for a child that does.
 const SHARE_AT = '__shareAt'
@@ -1059,6 +1098,41 @@ function buildRender(lowering: Lowering): ValueRender {
     }
 }
 
+/** 32.71 — whether a write is a shared group's whole value. */
+function writesGroup(write: keyof typeof WRITES): boolean {
+    return write === 'classGroup' || write === 'styleGroup'
+}
+
+/** 32.71 — whether a shared group is one of a row's item watches: any member is. */
+function groupReadsOwnItem(group: MergeGroup, lowering: Lowering): boolean {
+    for (const member of group.members)
+        if (member.expression && lowering.readsOwnItem(member)) return true
+    return false
+}
+
+/**
+ * 32.71 — a shared group's write arguments: the plain attribute's value, then every directive's
+ * condition or value in the order the group names them, each read by `read`. A directive with no
+ * expression is a class that is always on, or a property's own bytes.
+ */
+function groupArguments(
+    group: MergeGroup,
+    read: (attribute: Attribute) => string,
+): string {
+    const values: string[] = []
+    for (const directive of group.directives)
+        values.push(
+            directive.expression
+                ? read(directive)
+                : group.name === 'class'
+                  ? 'true'
+                  : JSON.stringify(
+                        decodeCharacterReferences(directive.value, 'attribute'),
+                    ),
+        )
+    return `${read(group.plain as Attribute)}, [${values.join(', ')}]`
+}
+
 /**
  * Emits a region's `_build` and `_mount` pair into `helpers`, for a region nobody painted.
  *
@@ -1565,6 +1639,40 @@ function rowUpdate(
             position.holder as ElementNode,
             lowering,
         )) {
+            // 32.71 — a shared group is written whole where a member moves with the item — and
+            // where none is live, as for any attribute: a live group's watch reads the item too.
+            if (
+                one.kind === 'merged' &&
+                one.group !== undefined &&
+                one.toggles !== undefined &&
+                writesGroup(one.toggles.write)
+            ) {
+                if (one.live) continue
+                for (const member of one.group.members)
+                    if (
+                        member.expression &&
+                        !lowering.isLive(member) &&
+                        lowering.readsItem(member, block)
+                    ) {
+                        own.push(
+                            writeCall(
+                                one.toggles.write,
+                                `__a${slot}`,
+                                one.toggles.name,
+                                groupArguments(one.group, (attribute) =>
+                                    unlandable(
+                                        lowering,
+                                        attribute,
+                                        lowering.expression(attribute),
+                                    ),
+                                ),
+                                lowering,
+                            ),
+                        )
+                        break
+                    }
+                continue
+            }
             if (!one.attribute.expression || one.live) continue
             if (!lowering.readsItem(one.attribute, block)) continue
             const toggles =
@@ -1578,7 +1686,13 @@ function rowUpdate(
                       : undefined
             if (toggles === undefined) continue
             own.push(
-                `${lowering.use(WRITES[toggles.write])}(__a${slot}, ${JSON.stringify(toggles.name)}, ${lowering.expression(one.attribute)})`,
+                writeCall(
+                    toggles.write,
+                    `__a${slot}`,
+                    toggles.name,
+                    lowering.expression(one.attribute),
+                    lowering,
+                ),
             )
         }
         if (own.length === 0) continue

package/src/compiler/renderMarkup.ts

@@ -354,13 +354,9 @@ function renderPosition(
     // `<br>`, and a close tag written for one is markup no browser accepts.
     if (node.children.length === 0 && VOID_ELEMENTS.has(node.lowerTag))
         return parts.join(' + ')
-    // 32.61 — THE VALUE IN PLACE OF THE AUTHOR'S TEXT, led by the newline the parser drops after
-    // `<textarea>` so a value opening on one keeps it.
-    if (
-        within !== undefined &&
-        node.lowerTag === 'textarea' &&
-        node.children.length === 0
-    )
+    // 32.61 — THE VALUE AS THE TEXT, led by the newline the parser drops after `<textarea>` so a
+    // value opening on one keeps it. The author wrote none: 32.72 refuses it beside the bind.
+    if (within !== undefined && node.lowerTag === 'textarea')
         return [
             ...parts,
             `'\\n' + ${lowering.use('escapeAttribute')}(${within})`,
@@ -614,7 +610,17 @@ function boundMarkup(
         return `' value="' + ${lowering.use('escapeAttribute')}(${read}) + '"'`
     const on =
         written.bind === 'group'
-            ? `${lowering.use('groupHolds')}(${read}, ${JSON.stringify(written.own)})`
+            ? `${lowering.use('groupHolds')}(${read}, ${
+                  written.own === undefined
+                      ? "'on'"
+                      : written.own.expression
+                        ? unlandable(
+                              lowering,
+                              written.own,
+                              lowering.expression(written.own),
+                          )
+                        : JSON.stringify(written.own.value)
+              })`
             : read
     return `(${on} ? ' ${written.reflects}' : '')`
 }

package/src/server/BRIDGE_VERSION.ts

@@ -1,3 +1,3 @@
 // The `abide-bridge` release a pairing command names, so a visitor's `bunx` runs the relay this
 // server speaks. `packages/abide/tests/claudeCode.test.ts` holds it to the bridge package's own.
-export const BRIDGE_VERSION = '0.3.2'
+export const BRIDGE_VERSION = '0.3.3'

package/src/server/HEARTBEAT_MILLISECONDS.ts

@@ -0,0 +1,2 @@
+/** How often a held-open event stream carries a comment while it has nothing else to send. 16.57. */
+export const HEARTBEAT_MILLISECONDS = 15_000

package/src/server/IDLE_TIMEOUT_SECONDS.ts

@@ -0,0 +1,6 @@
+/**
+ * How long a connection `App.listen` or `abide dev` binds may go without a byte while nothing over it
+ * is being answered (16.56): a body still arriving, or a kept-alive connection between requests.
+ * `Bun.serve`'s own default, named so the bound a request lifts can be put back.
+ */
+export const IDLE_TIMEOUT_SECONDS = 10

package/src/server/answerRequest.ts

@@ -8,15 +8,19 @@
 
 import {
     ABIDE_ADDRESS,
+    APP_MANIFEST_ADDRESS,
     BRIDGE_ADDRESS,
     CLIENT_ADDRESS,
     HEALTH_ADDRESS,
     MCP_ADDRESS,
     OPENAPI_ADDRESS,
     PRIVATE_HANDLERS_ADDRESS,
+    WORKER_ADDRESS,
 } from '#shared/ADDRESSES.ts'
 import { APP_META } from '#shared/APP_META.ts'
 import { DEBUG_META } from '#shared/DEBUG_META.ts'
+import { ICON_ADDRESSES } from '#shared/LAUNCHER_FILES.ts'
+import { OFFLINE_META } from '#shared/OFFLINE_META.ts'
 import { decodedOrKept } from '#shared/decodedOrKept.ts'
 import { ERROR_META } from '#shared/ERROR_META.ts'
 import { escapeAttribute } from '#shared/escapeText.ts'
@@ -49,7 +53,10 @@ import {
 import { answerBlobTagged, answerValue, contentEtag } from './answerValue.ts'
 import { answerBridge } from './bridgeRelay.ts'
 import { CLIENT_ENTRY } from './CLIENT_BUILD.ts'
+import { appManifest } from './appManifest.ts'
+import { answerWorker } from './answerWorker.ts'
 import { callerOrMint } from './callerOf.ts'
+import { settingOn } from './config.ts'
 import { compressAnswer } from './compressAnswer.ts'
 import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
 import { noteCallInRender } from './deferredBuilds.ts'
@@ -72,6 +79,7 @@ import {
     adoptRequest,
     beginRender,
     currentRequestScope,
+    type PageRender,
     type RequestScope,
     within,
     writtenStatus,
@@ -162,6 +170,9 @@ export type AppSources = {
     explained: ((thrown: unknown) => Response) | undefined
 }
 
+// 41.29 — the seed sink of a render no page hydrates: every call is left to run when it is made.
+const SEEDS_NOTHING: PageRender['seed'] = () => false
+
 /** The `Response` to one request: a handler, a surface of abide's own, a file, or a page. */
 export async function answerRequest(
     app: AppSources,
@@ -338,7 +349,10 @@ async function answerMatched(
     arrive(at.href, page.pattern, params)
     // 11.32 — the page renders in a scope of its own, so what its values hold is this request's —
     // and 41.13, every call it makes is left for the browser's own call to be answered from.
-    beginRender({ seed: seedFor(caller), calls: [] })
+    // 41.29 — BUT NOT A PAGE A SCRIPT FETCHED, which nothing hydrates: its entries would answer the
+    // next call this caller makes with what the render saw, a sign-in since included.
+    const hydrated = request.headers.get('sec-fetch-dest') !== 'empty'
+    beginRender({ seed: hydrated ? seedFor(caller) : SEEDS_NOTHING, calls: [] })
     // 41.1, 35.2 — THE DOCUMENT IS THE BUILT PAGE, read whole before there is a `Response` to commit a
     // status to: a refusal the page read, or a throw, is answered by the nearest error page at its own
     // status rather than as a 200 the stream then abandons.
@@ -457,6 +471,11 @@ type ClientLane = {
     manifest: Manifest
     framework: AppSources['framework']
     head: string
+    /**
+     * 45.1, 45.9 — whether the worker saves `manifest`'s bundle and the pages register it: `abide
+     * build`'s, unless `ABIDE_OFFLINE` is off. Where not, the worker address answers the removing one.
+     */
+    offline: boolean
 }
 
 /**
@@ -476,10 +495,19 @@ export async function appSources(parts: SourceParts): Promise<AppSources> {
     ])
     // 35.6 — every page is served in abide's own document; what it carries beyond that, the root
     // `layout.abide` writes (35.15).
+    // 45.15 — installable where the pages are kept offline and the app has an icon to install by.
+    const icon = published.get(ICON_ADDRESSES.png)
+    const install =
+        icon !== undefined && settingOn('ABIDE_OFFLINE', true)
+            ? await appManifest(icon.path)
+            : undefined
     const documentOf = (modules: string[]): string =>
         intoHead(
             DEFAULT_DOCUMENT,
-            clientTags(client.manifest, modules) + client.head,
+            clientTags(client.manifest, modules) +
+                (client.offline ? `<meta name="${OFFLINE_META}">` : '') +
+                (install?.tags ?? '') +
+                client.head,
         )
     const pages: Omit<Ranked, 'segments'>[] = []
     for (const route of parts.table.routes)
@@ -517,7 +545,20 @@ export async function appSources(parts: SourceParts): Promise<AppSources> {
         errors,
         // 35.18 — marked, so the browser hydrates no page over what an error page painted.
         errorDocument: intoHead(documentOf([]), `<meta name="${ERROR_META}">`),
-        framework: client.framework,
+        framework: (pathname, request) => {
+            if (pathname === WORKER_ADDRESS)
+                return answerWorker(
+                    client.offline ? client.manifest : undefined,
+                )
+            if (pathname === APP_MANIFEST_ADDRESS && install !== undefined)
+                return new Response(install.body, {
+                    headers: {
+                        'content-type': 'application/manifest+json',
+                        'cache-control': 'no-cache',
+                    },
+                })
+            return client.framework(pathname, request)
+        },
         published,
         explained: parts.explained,
         ...mounted,

package/src/server/answerRpc.ts

@@ -3,7 +3,7 @@
 // args off the request, and the answer onto a response.
 //
 // WIRE-ONLY, per 16.13: the `Origin` gate on a mutation, `maxBodySize`, the `crossOrigin` preflight,
-// raising the request's idle timeout (16.22), and 19.7's coercion of the text a URL carried.
+// and 19.7's coercion of the text a URL carried.
 
 import type { CopyOptions } from '#shared/CopyOptions.ts'
 import { type Failed, isFailed } from '#shared/Failed.ts'
@@ -47,9 +47,9 @@ import { type AppRung, failureOf, rungsOver } from './hooks.ts'
 import { prefers } from './prefers.ts'
 import {
     currentRequestScope,
-    LISTENING,
     rungsTook,
     timed,
+    unreap,
     writtenStatus,
 } from './requestScope.ts'
 import { type Outcome, outcomeOf, takeSeed } from './seedBuffer.ts'
@@ -265,9 +265,6 @@ export async function answerRpc(
         if (isFailed(refused)) return answered(refused)
         throw refused
     }
-    // 16.56 — where neither names one, nothing is raised and the server's own idle timeout stands.
-    const timeout = handler.timeout ?? RPC_SERVER.timeout()
-    if (timeout !== undefined) raiseTimeout(timeout)
     // 41.7 — the call a hydrating page makes for what its render already reached is answered from
     // that, and the handler is not run again (41.13).
     // 16.51 — a `HEAD` leaves the seed for the `GET` it stands in front of.
@@ -499,23 +496,25 @@ function withParameters(
 }
 
 /**
- * The request's body under the ceiling `maxBodySize` sets, or `ABIDE_MAX_REQUEST_BODY_SIZE` where it
- * is unset, or a 413 refusal past it — the request itself where neither names one.
+ * The request's body, received whole, under the ceiling `maxBodySize` sets, or
+ * `ABIDE_MAX_REQUEST_BODY_SIZE` where it is unset, or a 413 refusal past it.
  *
  * 16.54 — NO CEILING BY DEFAULT. 16.55 — read off the declared length before a byte of the body is.
  * 16.78 — EVERY BODY ABIDE READS, a handler's and `/__abide/mcp`'s and `/__abide/bridge`'s alike.
+ * 16.23 — and the request received whole once it is read, which is where its idle timeout goes off.
  */
 export async function bodyWithin(
     request: Request,
     maxBodySize: number | undefined,
-): Promise<Request | Response | Failed<'HttpError', undefined>> {
+): Promise<Response | Failed<'HttpError', undefined>> {
     const ceiling =
         maxBodySize ??
         positiveSetting('ABIDE_MAX_REQUEST_BODY_SIZE', Number.POSITIVE_INFINITY)
-    if (!Number.isFinite(ceiling)) return request
     if (Number(request.headers.get('content-length') ?? 0) > ceiling)
         return overCeiling(ceiling)
-    return bodyUnder(request, ceiling)
+    const body = await bodyUnder(request, ceiling)
+    if (!isFailed(body)) unreap(currentRequestScope())
+    return body
 }
 
 /**
@@ -530,6 +529,11 @@ async function bodyUnder(
     request: Request,
     ceiling: number,
 ): Promise<Response | Failed<'HttpError', undefined>> {
+    if (!Number.isFinite(ceiling))
+        // A blob, which a `Response` shares where it copies an `ArrayBuffer`.
+        return new Response(await request.blob(), {
+            headers: request.headers,
+        })
     const chunks: Uint8Array[] = []
     let size = 0
     if (request.body !== null)
@@ -560,37 +564,6 @@ function preflight(found: Mounted, origin: string, request: Request): Response {
     return new Response(null, { status: 204, headers })
 }
 
-/**
- * Raises the request's idle timeout to cover `milliseconds`, never lowering it.
- *
- * 16.22, 16.23 — the floor is the longest any handler in the request asked for. Where no socket is
- * bound there is no idle timeout to raise.
- *
- * 16.57 — `Infinity` is never reaped, which bun spells 0; any finite bound is capped at the 255
- * seconds bun's idle timeout can hold.
- *
- * FOUR SECONDS PAST THE TIMEOUT, NOT AT IT: a load that goes its timeout is refused at that moment,
- * and a stream's refusal is a frame written then (16.68). bun's sockets check an idle timeout on a
- * tick four seconds wide, so an idle timeout of the same second — or one past it — fired anywhere in
- * the tick before it and reaped the connection ahead of the frame, one stream in two under `abide
- * dev`. Four is the tick, so the refusal always goes out first.
- *
- * ON THE REQUEST THE LISTENER RECEIVED, never the one being answered: under a mount, or past a
- * rung that handed `next` its own, that is a copy, and bun's `timeout` does nothing for a request
- * it was not handed itself.
- */
-export function raiseTimeout(milliseconds: number): void {
-    const scope = currentRequestScope()
-    const received = scope?.received
-    if (scope === undefined || received === undefined) return
-    const seconds = Number.isFinite(milliseconds)
-        ? Math.min(255, Math.ceil(milliseconds / 1000) + 4)
-        : Number.POSITIVE_INFINITY
-    if (seconds <= scope.timeout) return
-    scope.timeout = seconds
-    LISTENING.timeout(received, Number.isFinite(seconds) ? seconds : 0)
-}
-
 function isForm(request: Request): boolean {
     const type = request.headers.get('content-type') ?? ''
     return (

package/src/server/answerSocket.ts

@@ -315,7 +315,7 @@ export class MuxConnection {
             upgrade.headers.get('origin'),
             upgrade.url,
         )
-        // NO `received`: an upgraded connection has no http idle timeout for 16.22 to raise.
+        // NO `received`: an upgraded connection has no http idle timeout for 16.23 to set.
         this.scope = scopeFor(
             new Request(upgrade, { signal: this.hangUp.signal }),
             undefined,
@@ -562,7 +562,7 @@ export function followAsEvents(
     let ended = false
     return new ReadableStream({
         start(controller) {
-            controller.enqueue(ENCODER.encode(EVENT_STREAM_OPENER))
+            controller.enqueue(EVENT_STREAM_OPENER)
             // Ended by the app's stop as any body it holds open is, or that stop waits on it.
             unhold = heldByApp(() => {
                 if (ended) return

package/src/server/answerValue.ts

@@ -14,6 +14,7 @@ import {
 } from './requestScope.ts'
 import {
     EVENT_STREAM_OPENER,
+    heldBody,
     refusalFrame,
     streamEvent,
 } from './streamEvent.ts'
@@ -38,7 +39,7 @@ export async function answerValue(
     headers: Headers,
     status: number,
 ): Promise<Response> {
-    if (value instanceof Response) return value
+    if (value instanceof Response) return heldUntilSent(value)
     const framing = currentRequestScope()?.framing
     // 17.9, 17.10 — what `json` fixed: the standing value, whatever it is, and `null` for nothing.
     if (framing === 'json') {
@@ -223,8 +224,7 @@ export function bodyOf(
     const unhold = heldByApp(() => stopped())
     return new ReadableStream<Uint8Array>({
         start(controller) {
-            if (framing === 'sse')
-                controller.enqueue(ENCODER.encode(EVENT_STREAM_OPENER))
+            if (framing === 'sse') controller.enqueue(EVENT_STREAM_OPENER)
             stopped = () => {
                 if (ended) return
                 release()
@@ -290,6 +290,18 @@ export function bodyOf(
     })
 }
 
+/**
+ * `answer`, holding its request's scope until its body has been read to the end.
+ *
+ * 12.5, 16.23 — A `Response` A HANDLER BUILT MAY BE A STREAM, and nothing tells a stream from a
+ * string or a blob once it is one: `body` is a `ReadableStream` either way. So every body is held,
+ * at the price of a buffered one going out chunked rather than under a `Content-Length`.
+ */
+function heldUntilSent(answer: Response): Response {
+    if (answer.body === null) return answer
+    return new Response(heldBody(answer.body, holdScope(), false), answer)
+}
+
 /**
  * A blob answered at its own type under the given etag, range-aware.
  *