@abide/abide 0.114.1 → 0.116.0

package/src/server/assistant.ts

@@ -12,11 +12,20 @@
 
 import { namedLogger } from '#shared/log.ts'
 import { refuse } from '#shared/refuse.ts'
+import { IMAGE_TYPES } from './IMAGE_TYPES.ts'
 import { type McpReply, McpSurface } from './generatedSurfaces.ts'
 import { request, within } from './requestScope.ts'
 
-/** One turn of the transcript a caller sends. */
-export type AssistantMessage = { role: 'user' | 'assistant'; content: string }
+/** A piece of a turn: words, or an image as base64 with its type. */
+export type AssistantContent =
+    | { type: 'text'; text: string }
+    | { type: 'image'; data: string; mimeType: string }
+
+/** One turn of the transcript a caller sends: its words, or its pieces in order. */
+export type AssistantMessage = {
+    role: 'user' | 'assistant'
+    content: string | AssistantContent[]
+}
 
 /** What a conversation yields, the same from every provider. */
 export type AssistantEvent =
@@ -43,19 +52,19 @@ export type ToolDefinition = {
     outputSchema: unknown
 }
 
+/** What a tool call answered: its pieces, and whether it failed. 20.21, 44.35. */
+export type ToolAnswer = { content: AssistantContent[]; failed: boolean }
+
 /** The app's MCP tools, called as the asker. */
 export type Toolbox = {
     list: ToolDefinition[]
-    call(
-        name: string,
-        input: unknown,
-    ): Promise<{ text: string; failed: boolean }>
+    call(name: string, input: unknown): Promise<ToolAnswer>
 }
 
 /** What runs a conversation: a model's API, or something that runs its own loop. */
 export type Provider = {
     run(
-        messages: AssistantMessage[],
+        messages: (AssistantMessage & { content: AssistantContent[] })[],
         tools: Toolbox,
         limits: { maxTurns: number; signal: AbortSignal },
     ): AsyncGenerator<AssistantEvent>
@@ -81,11 +90,38 @@ export async function* assistant(
             400,
             'The transcript has to end on a user turn for the assistant to answer it. RULEBOOK 44.3.',
         )
+    // Every turn as its pieces, so a provider reads one shape: words alone are one text piece.
+    const turns: Parameters<Provider['run']>[0] = []
+    for (const message of messages) {
+        if (typeof message.content === 'string') {
+            turns.push({
+                role: message.role,
+                content: [{ type: 'text', text: message.content }],
+            })
+            continue
+        }
+        turns.push({ role: message.role, content: message.content })
+        for (const piece of message.content) {
+            if (piece?.type !== 'image') continue
+            // 44.37 — an image is the asker's to show, never a turn the model answered.
+            if (message.role !== 'user')
+                throw refuse(
+                    400,
+                    'An image can only stand in a user turn of the transcript. RULEBOOK 44.37.',
+                )
+            // 44.36.
+            if (!IMAGE_TYPES.has(piece.mimeType))
+                throw refuse(
+                    400,
+                    `An image in the transcript is ${piece.mimeType}, and a model is shown only ${[...IMAGE_TYPES].join(', ')}. RULEBOOK 44.36.`,
+                )
+        }
+    }
     const tools = toolboxOver(
         options.mcp === true ? appSurface() : NO_SURFACE,
         askerOf(request()),
     )
-    const events = provider.run(messages, tools, {
+    const events = provider.run(turns, tools, {
         maxTurns: options.maxTurns ?? MAX_TURNS,
         signal: request().signal,
     })
@@ -181,10 +217,15 @@ function toolboxOver(surface: McpSurface, asker: Request): Toolbox {
                 return await surface.call(name, input, asker)
             } catch (thrown) {
                 return {
-                    text:
-                        thrown instanceof Error
-                            ? thrown.message
-                            : String(thrown),
+                    content: [
+                        {
+                            type: 'text',
+                            text:
+                                thrown instanceof Error
+                                    ? thrown.message
+                                    : String(thrown),
+                        },
+                    ],
                     failed: true,
                 }
             }
@@ -199,3 +240,31 @@ function toolboxOver(surface: McpSurface, asker: Request): Toolbox {
     )
     return tools
 }
+
+/**
+ * Pieces as Messages API blocks, in order: text as text, an image as base64 with its type. A text of
+ * whitespace alone is left out, as the API refuses one. 44.38.
+ */
+export function blocksOf(content: AssistantContent[]): unknown[] {
+    const blocks: unknown[] = []
+    for (const piece of content)
+        if (piece.type === 'image')
+            blocks.push({
+                type: 'image',
+                source: {
+                    type: 'base64',
+                    media_type: piece.mimeType,
+                    data: piece.data,
+                },
+            })
+        else if (/\S/.test(piece.text))
+            blocks.push({ type: 'text', text: piece.text })
+    return blocks
+}
+
+/** The words of `content`, its images left out. */
+export function textOf(content: AssistantContent[]): string {
+    let text = ''
+    for (const piece of content) if (piece.type === 'text') text += piece.text
+    return text
+}

package/src/server/claudeApi.ts

@@ -8,7 +8,7 @@
 
 import { framedStream } from '#shared/framing.ts'
 import { refuse } from '#shared/refuse.ts'
-import type { AssistantEvent, Provider } from './assistant.ts'
+import { blocksOf, type Provider, textOf } from './assistant.ts'
 
 /** A Messages API request body, less what abide writes, with the client's key and origin. */
 export type ClaudeApiConfig = {
@@ -80,8 +80,12 @@ export function claudeApi(config: ClaudeApiConfig): Provider {
                     input_schema: tool.inputSchema,
                 })
             const history: { role: string; content: unknown }[] = []
+            // 44.38 — each image in its place in its turn.
             for (const message of messages)
-                history.push({ role: message.role, content: message.content })
+                history.push({
+                    role: message.role,
+                    content: blocksOf(message.content),
+                })
             const usage = { input: 0, output: 0 }
             for (let turn = 1; ; turn++) {
                 const answered = await fetch(
@@ -189,28 +193,29 @@ export function claudeApi(config: ClaudeApiConfig): Provider {
                     }
                     return
                 }
-                const results = await Promise.all(
-                    called.map(
-                        async (
-                            block,
-                        ): Promise<AssistantEvent & { type: 'result' }> => ({
-                            type: 'result',
-                            id: block.id as string,
-                            ...(await tools.call(
-                                block.name as string,
-                                block.input,
-                            )),
-                        }),
-                    ),
+                const answers = await Promise.all(
+                    called.map(async (block) => ({
+                        id: block.id as string,
+                        ...(await tools.call(
+                            block.name as string,
+                            block.input,
+                        )),
+                    })),
                 )
                 const content: unknown[] = []
-                for (const result of results) {
-                    yield result
+                for (const answer of answers) {
+                    // 44.35 — the event carries the answer's words; an image goes to the model alone.
+                    yield {
+                        type: 'result',
+                        id: answer.id,
+                        text: textOf(answer.content),
+                        failed: answer.failed,
+                    }
                     content.push({
                         type: 'tool_result',
-                        tool_use_id: result.id,
-                        content: result.text,
-                        is_error: result.failed,
+                        tool_use_id: answer.id,
+                        content: blocksOf(answer.content),
+                        is_error: answer.failed,
                     })
                 }
                 // 44.12 — every result of one turn in one message.

package/src/server/claudeCode.ts

@@ -11,8 +11,10 @@
 import { mounted } from '#shared/mount.ts'
 import { refuse } from '#shared/refuse.ts'
 import {
+    type AssistantContent,
     type AssistantEvent,
     type AssistantMessage,
+    blocksOf,
     forwardOf,
     type Provider,
 } from './assistant.ts'
@@ -65,7 +67,7 @@ function claudeCodeProvider(config: ClaudeCodeConfig = {}): Provider {
             bridge.frames.push({
                 type: 'turn',
                 id: turn.id,
-                prompt: foldedPrompt(messages),
+                prompt: foldedContent(messages),
                 config,
                 maxTurns,
             })
@@ -105,16 +107,34 @@ function claudeCodeProvider(config: ClaudeCodeConfig = {}): Provider {
     }
 }
 
-/** The transcript as the one message Claude Code is sent: earlier turns folded above the last. 44.5. */
-function foldedPrompt(messages: AssistantMessage[]): string {
-    const last = (messages.at(-1) as AssistantMessage).content
-    if (messages.length === 1) return last
-    let earlier = ''
-    for (let index = 0; index < messages.length - 1; index++) {
-        const message = messages[index] as AssistantMessage
-        earlier += `<${message.role}>\n${message.content}\n</${message.role}>\n`
+/**
+ * The transcript as the one message Claude Code is sent, as Messages API blocks: earlier turns folded
+ * above the last, and each image in its place. 44.5.
+ */
+function foldedContent(
+    messages: (AssistantMessage & { content: AssistantContent[] })[],
+): unknown[] {
+    const pieces: AssistantContent[] = []
+    let words = messages.length > 1 ? '<conversation>\n' : ''
+    const last = messages.length - 1
+    for (let index = 0; index <= last; index++) {
+        const message = messages[index] as (typeof messages)[number]
+        if (index < last) words += `<${message.role}>\n`
+        for (let at = 0; at < message.content.length; at++) {
+            const piece = message.content[at] as AssistantContent
+            if (at > 0) words += '\n'
+            if (piece.type === 'text') {
+                words += piece.text
+                continue
+            }
+            pieces.push({ type: 'text', text: words }, piece)
+            words = ''
+        }
+        if (index < last) words += `\n</${message.role}>\n`
+        if (index === last - 1) words += '</conversation>\n\n'
     }
-    return `<conversation>\n${earlier}</conversation>\n\n${last}`
+    pieces.push({ type: 'text', text: words })
+    return blocksOf(pieces)
 }
 
 /** The browser asking, which a pairing is to. 44.13. */

package/src/server/createApp.ts

@@ -12,6 +12,7 @@ import { LONGEST_DELAY } from '#shared/LONGEST_DELAY.ts'
 import { namedLogger } from '#shared/log.ts'
 import { compose } from '#shared/Middleware.ts'
 import { MOUNT, unmounted } from '#shared/mount.ts'
+import { PRINCIPAL_HEADER } from '#shared/PRINCIPAL_HEADER.ts'
 import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
 import { servedTable } from './abideModules.ts'
 import { type AppSources, answerRequest } from './answerRequest.ts'
@@ -329,7 +330,7 @@ export async function bootEntered(
                         reportUnexpected(thrown)
                         answered = plainAnswer('internal server error', 500)
                     }
-                    const stamped = beating(stamp(answered))
+                    const stamped = beating(stamp(answered, booted.offline))
                     // 28.7 — a closed namespace does not pay for the line it would have written.
                     if (REQUEST_LOG.enabled())
                         REQUEST_LOG.debug(
@@ -494,8 +495,11 @@ export async function bootEntered(
  *
  * 22.9 — AND WHAT WAS WRITTEN THROUGH `response`, laid over every answer here and nowhere else: a
  * lane builds its answer at the written status and leaves the headers to this.
+ *
+ * 21.24 — and where the worker keeps answers (`offline`), a sign-in or a sign-out has the browser's
+ * own cache drop what it kept for the caller before, as the worker drops its copies (45.7).
  */
-function stamp(answered: Response): Response {
+function stamp(answered: Response, offline: boolean): Response {
     let stamped = answered
     try {
         stamped.headers.set('x-content-type-options', 'nosniff')
@@ -507,6 +511,8 @@ function stamp(answered: Response): Response {
     const timing = serverTiming()
     if (timing !== undefined) stamped.headers.set('server-timing', timing)
     const written = applyWritten(stamped.headers)
+    if (offline && stamped.headers.has(PRINCIPAL_HEADER))
+        stamped.headers.set('clear-site-data', '"cache"')
     const status = written !== 200 ? written : stamped.status
     // 17.8 — a failure nobody named a reason for is given its registered one.
     const statusText =

package/src/server/generatedSurfaces.ts

@@ -14,6 +14,7 @@
 // schema (19.9) as `argsDocument`.
 
 import { isFailed } from '#shared/Failed.ts'
+import { essenceOf } from '#shared/framing.ts'
 import { namedLogger } from '#shared/log.ts'
 import { mounted } from '#shared/mount.ts'
 import { type Reactive, reactive } from '#shared/reactive/index.ts'
@@ -21,9 +22,10 @@ import { parseRoutePattern } from '#shared/routePattern.ts'
 import { argsInURL, rpcRequest } from '#shared/rpcRequest.ts'
 import { answered } from './answerFailure.ts'
 import { bodyWithin, type Mounted } from './answerRpc.ts'
-import type { ToolDefinition } from './assistant.ts'
+import type { ToolAnswer, ToolDefinition } from './assistant.ts'
 import { appIdentity } from './config.ts'
 import { crossingOrigin, crossingRefusal } from './crossingOrigin.ts'
+import { IMAGE_TYPES } from './IMAGE_TYPES.ts'
 import { MCP_PROTOCOL_VERSION } from './MCP_PROTOCOL_VERSION.ts'
 import { type Listed, surfaceOf } from './surfaceOf.ts'
 
@@ -307,16 +309,12 @@ export class McpSurface {
     }
 
     /** What calling the tool `name` as `asker` answered, a refusal or a missing tool a failed one. */
-    call(
-        name: string,
-        args: unknown,
-        asker: Request,
-    ): Promise<{ text: string; failed: boolean }> {
+    call(name: string, args: unknown, asker: Request): Promise<ToolAnswer> {
         const tool = this.#tool(name)
         if (tool === undefined) {
             logCall(String(name), 404, undefined)
             return Promise.resolve({
-                text: `No tool named ${name}.`,
+                content: [{ type: 'text', text: `No tool named ${name}.` }],
                 failed: true,
             })
         }
@@ -331,7 +329,7 @@ export class McpSurface {
         one: Published,
         args: Record<string, unknown> | undefined,
         asker: Request,
-    ): Promise<{ text: string; failed: boolean }> {
+    ): Promise<ToolAnswer> {
         // 28.7 — a closed namespace does not pay for the line it would have written.
         const started = MCP_LOG.enabled() ? performance.now() : undefined
         let answer: Response
@@ -345,10 +343,41 @@ export class McpSurface {
             }
             answer = answered(thrown)
         }
+        const mimeType = essenceOf(answer.headers.get('content-type'))
+        if (answer.status < 400 && mimeType.startsWith('image/')) {
+            // 20.22 — a tool that promised a value and answered a picture has no structured content
+            // to carry: its handler's type is wrong, and the call says so where it happened.
+            if (structured(one)) {
+                await answer.body?.cancel()
+                logCall(one.name, 500, started)
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `${one.name} declares a result schema but answered an image, ${mimeType}.`,
+                        },
+                    ],
+                    failed: true,
+                }
+            }
+            // 20.21 — AN IMAGE A MODEL IS SHOWN IS THE IMAGE, handed on as one rather than its bytes
+            // read as text, so a model looks at what a handler drew. Any other (an svg) is its text.
+            if (IMAGE_TYPES.has(mimeType)) {
+                const data = (await answer.bytes()).toBase64()
+                logCall(one.name, answer.status, started)
+                return {
+                    content: [{ type: 'image', data, mimeType }],
+                    failed: false,
+                }
+            }
+        }
         // The body is the call's too: a handler that streams has only begun when its head arrives.
         const text = await answer.text()
         logCall(one.name, answer.status, started)
-        return { text, failed: answer.status >= 400 }
+        return {
+            content: [{ type: 'text', text }],
+            failed: answer.status >= 400,
+        }
     }
 
     /** One MCP request, made as `asker`, as JSON-RPC's `result` or `error`. */
@@ -379,20 +408,25 @@ export class McpSurface {
                         `No tool named ${String(params?.name)}.`,
                     )
                 }
-                const { text, failed } = await this.#called(
+                const { content, failed } = await this.#called(
                     tool,
                     params?.arguments as Record<string, unknown> | undefined,
                     asker,
                 )
+                const [piece] = content
                 return {
                     result: {
-                        content: [{ type: 'text', text }],
+                        // 20.21 — an AssistantContent piece is already an MCP content item.
+                        content,
                         // 20.16 — the same value as structured content, where the tool declares
-                        // its shape; a refusal is not that value.
+                        // its shape; a refusal is not that value. A tool declaring one answers no
+                        // image (20.22), so its one piece is its text.
                         structuredContent:
-                            failed || !structured(tool)
+                            failed ||
+                            !structured(tool) ||
+                            piece?.type !== 'text'
                                 ? undefined
-                                : JSON.parse(text),
+                                : JSON.parse(piece.text),
                         isError: failed,
                     },
                 }

package/src/server/index.ts

@@ -27,11 +27,13 @@ export {
 } from '#shared/rpc.ts'
 // 45 — a conversation with a model, piped through a handler, and the two providers abide ships.
 export {
+    type AssistantContent,
     type AssistantEvent,
     type AssistantMessage,
     type AssistantOptions,
     assistant,
     type Provider,
+    type ToolAnswer,
     type Toolbox,
     type ToolDefinition,
 } from './assistant.ts'

package/src/server/render.ts

@@ -379,8 +379,9 @@ function earlyCallScript(calls: PageCall[]): string {
 // THE RUNNER RECORDS, IT NEVER CLASSIFIES: the `Response`, and a painted call's body read to its end
 // — the one decision is `painted`, which the server made. `answerOf` reads the record as it reads an
 // answer it fetched, so no second reading of a content type lives in a string no typecheck reaches.
-// The shape is `EarlyCall`'s.
-export const EARLY_CALL_RUNNER = `(function(s,c){for(var i=0;i<c.length;i++)(function(k,u,n,h){var e=s[k]={painted:h,response:void 0,bytes:void 0};e.promise=fetch(u,n).then(function(r){return h?r.arrayBuffer().then(function(b){e.bytes=b;e.response=r}):e.response=r}).catch(function(){})})(c[i][0],c[i][1],c[i][2],c[i][3])})(self.${EARLY_CALLS}||(self.${EARLY_CALLS}={}),JSON.parse(document.currentScript.previousElementSibling.textContent))`
+// The shape is `EarlyCall`'s. 16.80 — a page the worker answers has it answer the page's calls too,
+// which the browser alone can tell: the server cannot see whether a worker will replay this page.
+export const EARLY_CALL_RUNNER = `(function(s,c,w){for(var i=0;i<c.length;i++)(function(k,u,n,h){if(w)n.cache='force-cache';var e=s[k]={painted:h,response:void 0,bytes:void 0};e.promise=fetch(u,n).then(function(r){return h?r.arrayBuffer().then(function(b){e.bytes=b;e.response=r}):e.response=r}).catch(function(){})})(c[i][0],c[i][1],c[i][2],c[i][3])})(self.${EARLY_CALLS}||(self.${EARLY_CALLS}={}),JSON.parse(document.currentScript.previousElementSibling.textContent),(self.navigator.serviceWorker||{}).controller)`
 
 /** The early-call runner's hash, as `script-src` names it. 29.9. */
 export const EARLY_CALL_HASH = `'sha256-${new Bun.CryptoHasher('sha256').update(EARLY_CALL_RUNNER).digest('base64')}'`

package/src/server/seedBuffer.ts

@@ -83,6 +83,32 @@ type Entry = {
 // which is how a refresh of it is told from a call the render never made (41.12).
 const BUFFER = new Map<string, Map<object, Map<string, Entry[]>>>()
 
+/** A render's one report of each call (1.8): the call's key where it is new, `undefined` where not. */
+function reportsOnce(): (rpc: object, args: unknown) => string | undefined {
+    const reported = new Map<object, Set<string>>()
+    return (rpc, args) => {
+        const key = seedKey(args)
+        if (key === undefined) return undefined
+        let keys = reported.get(rpc)
+        if (keys === undefined) {
+            keys = new Set()
+            reported.set(rpc, keys)
+        }
+        if (keys.has(key)) return undefined
+        keys.add(key)
+        return key
+    }
+}
+
+/**
+ * 41.30 — the seed sink of a page the worker keeps: each call reported once, for the early-call
+ * script, and none of them left in the seed buffer (41.29) — the page is opened later, if at all.
+ */
+export function callsOnly(): PageRender['seed'] {
+    const firstReport = reportsOnce()
+    return (rpc, args) => firstReport(rpc, args) !== undefined
+}
+
 /**
  * The sink a page's render scope reports each call into, for one caller.
  *
@@ -91,17 +117,10 @@ const BUFFER = new Map<string, Map<object, Map<string, Entry[]>>>()
  * browser's `Rpc` joins a standing call (1.8).
  */
 export function seedFor(caller: string): PageRender['seed'] {
-    const reported = new Map<object, Set<string>>()
+    const firstReport = reportsOnce()
     return (rpc, args, reached) => {
-        const key = seedKey(args)
+        const key = firstReport(rpc, args)
         if (key === undefined) return false
-        let keys = reported.get(rpc)
-        if (keys === undefined) {
-            keys = new Set()
-            reported.set(rpc, keys)
-        }
-        if (keys.has(key)) return false
-        keys.add(key)
         const entry: Entry = {
             rpc,
             key,

package/src/shared/KEEP_HEADER.ts

@@ -0,0 +1,7 @@
+/**
+ * The header the offline worker asks for a page it keeps under, so the page carries the early calls
+ * a later open of it starts (41.30, 45.23).
+ *
+ * A leaf, because the server writes it into the worker's script and reads it off the request.
+ */
+export const KEEP_HEADER = 'abide-keep'

package/src/shared/KEEP_OPENED.ts

@@ -0,0 +1,7 @@
+/**
+ * The value of the offline worker's `abide-keep` header on the page a navigation opens, which then
+ * hydrates and so is seeded as one (41.29, 45.23) — a page saved behind the one opened is not.
+ *
+ * A leaf, because the server writes it into the worker's script and reads it off the request.
+ */
+export const KEEP_OPENED = 'open'

package/src/shared/KEPT_HEADER.ts

@@ -0,0 +1,6 @@
+/**
+ * The header the offline worker lays on an answer it gave from a copy it kept, naming when (45.22).
+ *
+ * A leaf, because the server writes it into the worker's script and the wire reads it (16.85).
+ */
+export const KEPT_HEADER = 'abide-kept'

package/src/shared/LOAD_OFFLINE.ts

@@ -0,0 +1,15 @@
+/**
+ * The `offline` of the call that is starting a load, while it starts.
+ *
+ * 16.81 — SET AROUND THE REACH as `LOAD_SIGNAL` is, and read by the browser's wire as its body
+ * starts: what stands in for an answer the call could not get. A leaf, because `callLoad` sets it
+ * and the wire reads it.
+ */
+export const LOAD_OFFLINE: {
+    current: ((args: unknown) => unknown) | undefined
+    /**
+     * Where the body that queues the call asks for the value the call reached, which `callLoad`
+     * fills once the reach returns: what the delivered answer lands in (46.7).
+     */
+    standing: { value: unknown } | undefined
+} = { current: undefined, standing: undefined }

package/src/shared/OUTBOX_SENDING.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether the outbox has a call in flight, as a bare `busy` asks it (46.11).
+ *
+ * A leaf, because `outbox` fills it and the core's `busy` reads it from below `outbox`. Unfilled — an
+ * app holding no handler — no call is ever in flight.
+ */
+export const OUTBOX_SENDING: { any: (() => boolean) | undefined } = {
+    any: undefined,
+}

package/src/shared/REACHED_MESSAGE.ts

@@ -0,0 +1,7 @@
+/**
+ * The key of the message the router posts the offline worker, naming the address a navigation
+ * reached, which the worker then keeps (45.24).
+ *
+ * A leaf, because the server writes it into the worker's script and the router posts it.
+ */
+export const REACHED_MESSAGE = 'reached'

package/src/shared/answerOf.ts

@@ -11,6 +11,7 @@ import {
     framedChunks,
     framingOf,
 } from './framing.ts'
+import { KEPT_HEADER } from './KEPT_HEADER.ts'
 import { principalRotated } from './principalRotated.ts'
 import { refuse } from './refuse.ts'
 import type { RpcRequest } from './rpcRequest.ts'
@@ -35,6 +36,8 @@ export type Answer = {
     version: number | undefined
     /** The `max-age` its `cache-control` named, in ms (18.14, 21.8). */
     life: number | undefined
+    /** 16.85 — whether the worker answered from a copy it kept rather than the network (45.22). */
+    kept: boolean
     text: string | undefined
     /**
      * A binary answer's body read to the end (16.34), set in place of `text` — a body read as text
@@ -92,7 +95,7 @@ async function fetched(
         if (signal?.aborted === true) throw error
         // 16.79 — NO ANSWER AT ALL, as a status the app can narrow on rather than the browser's
         // own `TypeError`, whose message differs in each.
-        return unanswered()
+        return noAnswer()
     }
     // THE HANDLER SIGNED THIS CALLER IN OR OUT, and the cookie is already the browser's.
     principalRotated(response)
@@ -100,7 +103,7 @@ async function fetched(
 }
 
 /** The answer a call that reached no server stands in for: an empty 503, which `answered` refuses. */
-function unanswered(): Answer {
+export function noAnswer(): Answer {
     return {
         status: 503,
         statusText: '',
@@ -109,12 +112,20 @@ function unanswered(): Answer {
         followable: false,
         version: undefined,
         life: undefined,
+        kept: false,
         text: '',
         bytes: undefined,
         body: undefined,
     }
 }
 
+/** 46.4 — no answer at all (16.79), or a gateway's: try again later. */
+export function unanswered(answer: Answer): boolean {
+    return (
+        answer.status === 502 || answer.status === 503 || answer.status === 504
+    )
+}
+
 /**
  * `response`, classified: a body `read` to its end already (an early call the server painted)
  * decoded as what it carried, and one unread read as bytes where it is a binary (16.34), as text
@@ -139,6 +150,7 @@ function answerFrom(
         followable: ok && !binary,
         version: versionInEtag(headers.get(VERSION_HEADER)),
         life: seconds === null ? undefined : Number(seconds[1]) * 1000,
+        kept: headers.has(KEPT_HEADER),
         text: undefined,
         bytes: undefined,
         body: undefined,

package/src/shared/framing.ts

@@ -33,11 +33,19 @@ export function framingOf(type: string | null | undefined): Framed | null {
 export function carriesBytes(type: string | null | undefined): boolean {
     if (type === null || type === undefined || type === '') return false
     if (framingOf(type) !== null) return false
-    const semicolon = type.indexOf(';')
-    const essence = semicolon === -1 ? type : type.slice(0, semicolon)
+    const essence = essenceOf(type)
     return essence !== 'application/json' && !essence.endsWith('+json')
 }
 
+/** A content type less its parameters, folded to lower case, as a type is compared; `''` for none. */
+export function essenceOf(type: string | null | undefined): string {
+    if (type === null || type === undefined) return ''
+    const semicolon = type.indexOf(';')
+    return (semicolon === -1 ? type : type.slice(0, semicolon))
+        .trim()
+        .toLowerCase()
+}
+
 /** One frame: an sse event's name — `message` where it named none — `id` and `data`, or a jsonl line. */
 export type Frame = { name: string; id: string | undefined; data: string }