@abide/abide 0.115.0 → 0.116.1

package/src/server/answerWorker.ts

@@ -15,8 +15,10 @@ import {
     OFFLINE_BUNDLE,
     OFFLINE_CACHE_PREFIX,
     OFFLINE_SAVED,
+    OFFLINE_SHARED,
 } from '#shared/OFFLINE_CACHES.ts'
 import { PRINCIPAL_HEADER } from '#shared/PRINCIPAL_HEADER.ts'
+import { REACHED_MESSAGE } from '#shared/REACHED_MESSAGE.ts'
 import type { Manifest } from './manifestOf.ts'
 
 // What `framingOf` reads as a framed stream (16.32), and a binary's bytes (16.34), which may be one —
@@ -30,6 +32,7 @@ const STREAMED_TYPES = [
 
 const CACHES = `const OURS = ${JSON.stringify(OFFLINE_CACHE_PREFIX)}
 const SAVED = ${JSON.stringify(OFFLINE_SAVED)}
+const SHARED = ${JSON.stringify(OFFLINE_SHARED)}
 const BUNDLE = ${JSON.stringify(OFFLINE_BUNDLE)}
 
 async function dropOurs(keeping) {
@@ -38,7 +41,7 @@ async function dropOurs(keeping) {
 }
 `
 
-// 45.3 through 45.8, 45.13, and 45.17 through 45.21.
+// 45.3 through 45.8, 45.13, 45.17 through 45.21, and 45.24.
 const SAVING = `
 self.addEventListener('install', (event) => {
     event.waitUntil(
@@ -60,26 +63,23 @@ self.addEventListener('activate', (event) => {
             await self.registration.navigationPreload?.disable()
             await self.clients.claim()
             for (const client of await self.clients.matchAll({ type: 'window' }))
-                await fetch(pageRequest(client.url, undefined, '1')).then(
-                    (response) =>
-                        kept(response)
-                            ? keep(new Request(client.url), response)
-                            : response.body?.cancel(),
-                    () => {},
-                )
+                await keepPage(client.url)
         })(),
     )
 })
 
 self.addEventListener('message', (event) => {
-    if (event.data === 'rotated') event.waitUntil(caches.delete(SAVED))
+    if (event.data === 'rotated') event.waitUntil(dropSaved())
+    const reached = event.data?.[REACHED]
+    if (typeof reached === 'string' && reached.startsWith(\`\${self.location.origin}/\`))
+        event.waitUntil(keepReached(reached))
 })
 
 self.addEventListener('fetch', (event) => {
     const request = event.request
     if (request.mode === 'navigate') {
         if (request.method === 'GET') event.respondWith(answer(event, true))
-        else event.waitUntil(caches.delete(SAVED))
+        else event.waitUntil(dropSaved())
         return
     }
     if (request.method !== 'GET') return
@@ -114,7 +114,7 @@ async function answer(event, page) {
             request.cache === 'no-store')
     const saved = bypass
         ? undefined
-        : await caches.match(request, { cacheName: SAVED, ignoreVary: true })
+        : await savedCopy(request)
     const life = saved === undefined ? undefined : lifeOf(saved)
     if (life !== undefined) {
         if (life.age < life.fresh) return marked(saved)
@@ -132,8 +132,7 @@ async function answer(event, page) {
     try {
         return await fromNetwork(event, page, page)
     } catch {
-        if (life !== undefined && life.age < life.fresh + life.error)
-            return marked(saved)
+        if (life !== undefined && standsIn(life)) return marked(saved)
         return page ? offline() : Response.error()
     }
 }
@@ -169,18 +168,49 @@ async function fromNetwork(event, page, opened) {
     const asked = page
         ? pageRequest(request.url, request.headers, opened ? OPENED : '1')
         : new Request(request, { cache: 'no-cache' })
+    const since = drops
     const response = await fetch(asked)
     // A copy nothing reads is a tee holding every chunk, so one is cloned only to be saved.
     const copy = kept(response) ? response.clone() : undefined
-    const rotated = response.headers.has(PRINCIPAL)
-    event.waitUntil(
-        (rotated ? caches.delete(SAVED) : Promise.resolve()).then(() =>
-            copy === undefined ? undefined : keep(request, copy),
-        ),
-    )
+    event.waitUntil(keep(request, copy, since, response.headers.has(PRINCIPAL)))
     return response
 }
 
+// 45.13, 45.24 — A PAGE NO NAVIGATION ASKED FOR, kept as a page behind the one opened is: an open
+// window's as the worker activates, and an address the router reached.
+function keepPage(url) {
+    const since = drops
+    return fetch(pageRequest(url, undefined, '1')).then((response) => {
+        // Nothing reads this answer, so one 45.3 or 45.4 turns away is let go here.
+        const copy = kept(response) ? response : undefined
+        if (copy === undefined) response.body?.cancel()
+        return keep(new Request(url), copy, since, response.headers.has(PRINCIPAL))
+    }, () => {})
+}
+
+// The addresses being kept, so one reached twice before its copy lands is asked for once.
+const reaching = new Set()
+
+// 45.24 — AN ADDRESS THE ROUTER REACHED, whose page no navigation asked for, so none is saved unless
+// this asks — and only where no copy saved would stand in offline: one that would is refreshed by the
+// page's own next load, and asking on every step renders each page twice. A page kept holds no seed
+// (RULEBOOK 41.29), so what a reload paints stale is markup its calls then answer over.
+async function keepReached(url) {
+    if (reaching.has(url)) return
+    reaching.add(url)
+    try {
+        const saved = await savedCopy(url)
+        if (saved === undefined || !standsIn(lifeOf(saved))) await keepPage(url)
+    } finally {
+        reaching.delete(url)
+    }
+}
+
+// 45.19 — whether a copy kept still stands in where the network gives nothing.
+function standsIn(life) {
+    return life.age < life.fresh + life.error
+}
+
 // How old a kept copy is and how long each of its windows runs, in seconds; a copy with no date is
 // as old as it can be.
 function lifeOf(response) {
@@ -219,9 +249,41 @@ function kept(response) {
     return !STREAMED.some((streamed) => type.startsWith(streamed))
 }
 
-async function keep(request, response) {
-    const cache = await caches.open(SAVED)
-    await cache.put(request, response)
+// The copy saved of an address, a caller's own ahead of one any caller may be answered.
+async function savedCopy(request) {
+    return (
+        (await caches.match(request, { cacheName: SAVED, ignoreVary: true })) ??
+        (await caches.match(request, { cacheName: SHARED, ignoreVary: true }))
+    )
+}
+
+// 45.7 — EVERY PAGE SAVED DROPPED, and with them every copy asked for before the drop: one asked under
+// the cookies of then would land after it holding the caller signed out since. The drop an answer's
+// own abide-principal makes is the exception, since that answer is the new caller's. What any caller
+// may be answered is kept apart and left standing: it was never the caller's to drop, and a font
+// thrown away at sign-in is a page drawn without it offline.
+let drops = 0
+
+function dropSaved() {
+    drops += 1
+    return caches.delete(SAVED)
+}
+
+// Saves a copy 45.3 and 45.4 let through where no drop has come since its request was asked — after
+// the drop its own answer makes where that answer rotated the principal — and cancels one where one has.
+// One any caller may be answered is saved whenever it was asked, since no caller's cookies made it.
+async function keep(request, copy, since, rotated) {
+    if (rotated) {
+        await dropSaved()
+        since = drops
+    }
+    if (copy === undefined) return
+    const shared = directivesOf(copy).has('public')
+    if (!shared && since !== drops) return copy.body?.cancel()
+    // An address whose answer went public or private since leaves no copy behind for savedCopy to
+    // prefer over this one.
+    await (await caches.open(shared ? SAVED : SHARED)).delete(request)
+    await (await caches.open(shared ? SHARED : SAVED)).put(request, copy)
 }
 
 function offline() {
@@ -277,6 +339,7 @@ const KEPT = ${JSON.stringify(KEPT_HEADER)}
 const KEEP = ${JSON.stringify(KEEP_HEADER)}
 const OPENED = ${JSON.stringify(KEEP_OPENED)}
 const NAVIGATION = ${JSON.stringify(NAVIGATION_HEADER)}
+const REACHED = ${JSON.stringify(REACHED_MESSAGE)}
 // 45.4 — the types a stream 16.32 frames, which has no end to save.
 const STREAMED = ${JSON.stringify(STREAMED_TYPES)}
 const OFFLINE = ${JSON.stringify(OFFLINE)}

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/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/shared/OFFLINE_CACHES.ts

@@ -5,8 +5,11 @@
 /** What every cache the worker keeps is named under, so a cache an earlier worker named is found. */
 export const OFFLINE_CACHE_PREFIX = 'abide:'
 
-/** The pages, the handlers' answers and the public files the worker saved, by address. */
+/** The pages and the handlers' answers the worker saved, by address. */
 export const OFFLINE_SAVED = `${OFFLINE_CACHE_PREFIX}saved`
 
+/** What the worker saved that any caller may be answered — `cache-control: public` — by address. */
+export const OFFLINE_SHARED = `${OFFLINE_CACHE_PREFIX}shared`
+
 /** The build's bundle, saved as the worker installs. */
 export const OFFLINE_BUNDLE = `${OFFLINE_CACHE_PREFIX}bundle`

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/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 }