@abide/abide 0.30.0 → 0.31.1

package/AGENTS.md

@@ -160,8 +160,9 @@ Same selector grammar as `cache.invalidate`; also accept a `Subscribable`. See C
 ## UI surface — `abide/ui/*` (client-only)
 
 ### Reactive primitives — `@readme plumbing` (in scope inside `.abide`, no import)
-- `abide/ui/state(initial)` → writable `State<T>` (`.value` getter/setter).
-- `abide/ui/derived(compute)` → lazy read-only computed (`.value`); re-derived on resume, never serialized.
+- `abide/ui/state(initial, transform?)` → writable `State<T>` (`.value` getter/setter). Local truth. `transform(next, prev) => T` is a write-coercion gate: each `.value=` stores what it returns (`return prev` rejects via the `Object.is` no-op); construction `initial` is verbatim. Plain `state(x)` is a serializable doc slot; `state(x, transform)` is a non-serializing `.value` cell.
+- `abide/ui/linked(seed, transform?)` → writable `State<T>` seeded reactively from upstream (Angular's `linkedSignal`): owns a local value, reseeds when the `seed` thunk's deps change, edits stay local. `transform` gates reseeds and writes alike. Thunk seed is required (it is the reactivity); seed captured by reference (clone in the thunk for isolation). Non-serializing — reseeds on resume.
+- `abide/ui/derived(compute)` → lazy read-only computed (`.value`); re-derived on resume, never serialized. `derived(compute, set)` → writable lens: `.value` derives from upstream, assigning runs imperative `set(next)` to write *through* to the sources (no local store).
 - `abide/ui/effect(fn)` → run now, re-run on dependency change; `fn` may return teardown / be async; returns dispose.
 - `abide/ui/doc(initial?)` → reactive document: immutable tree addressed by path, every change a patch (the substrate under all reactivity / resumability / sync).
 
@@ -180,7 +181,7 @@ Same selector grammar as `cache.invalidate`; also accept a `Subscribable`. See C
 Valid HTML with `<script>` + native `<template>` control flow + scoped `<style>`.
 - **Bindings:** `{expr}` text, `name={expr}` attr, `onclick={fn}`, `bind:value={…}` / `bind:checked` / `bind:group`, `attach={fn}` (node-lifetime attachment — the dual of `on`; the `use:`-action / `{@attach}` equivalent, lowered to `ui/dom/attach`).
 - **Control flow (native `<template>`):** `if`/`else`, `each={list} as="x" key="x.id"`, `await={p}`/`then`/`catch`, `switch`/`case`/`default`.
-- **Components:** capitalised tags (`<Layout title=…>`); children fill `<slot/>`; props are reactive (passed as thunks). `prop('name')` reads a typed page param.
+- **Components:** capitalised tags (`<Layout title=…>`); children fill `<slot/>`; props are reactive (passed as thunks). A component has no directives — every attribute is a prop under its written name (so `onclick=`/`bind:open=`/`attach=` pass through as props, e.g. callbacks, not the DOM-element directives those are on a lowercase tag) and is type-checked against the child's declared props. `prop('name')` reads a typed component prop (the parent-supplied thunk, reactive + read-only); route params come from the `page` proxy (`page.params.name`), not `prop()`.
 - **Snippets / named slots:** `<template name="x" args={…}>` declares a reusable named builder (the `snippet()` form), rendered like a function — covers named slots / `{@render}`.
 - **Reactivity:** write plain assignment (`count += 1`, `items.push(x)`); the compiler lowers it to patches. Deep-field edits wake only that field.
 - **SSR:** byte-identical HTML string; `renderToStream` ships the shell then streams `<template await>` fragments out of order; `hydrate` adopts static structure in place (control-flow blocks + child components fall back to `mount`/re-render — known gap).

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # abide
 
+## 0.31.1
+
+### Patch Changes
+
+- [`a9f7b3b`](https://github.com/briancray/abide/commit/a9f7b3b09f1db15fa784844a2672b1058dde2b25) - stop the type-check shadow merging a semicolon-less call into the next component ([`7d863d7`](https://github.com/briancray/abide/commit/7d863d7b1f2d4d973a5eafd94cf5002fdeb519c4))
+
+## 0.31.0
+
+### Minor Changes
+
+- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - linked() reactive cell, writable derived, state write-transform ([`82301ea`](https://github.com/briancray/abide/commit/82301eabcda0866eec471f95048f74079ea93ab7))
+
+- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - sharper template type-checking in the shadow ([`f280619`](https://github.com/briancray/abide/commit/f280619778c23200a0f11cf8e6344edf2ea39884))
+
+- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - pass component on\*/bind/attach attributes through as props ([`f9a9202`](https://github.com/briancray/abide/commit/f9a9202d8555d7246fcc4338e833551f54ee8968))
+
+### Patch Changes
+
+- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - extract messageFromError, contentTypeOf, discardBoundary helpers ([`1bfb721`](https://github.com/briancray/abide/commit/1bfb721a8a8d3c8907bc9d4d0c6d97ddc265ed1e))
+
+- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - resolve the chained route on the page proxy ([`ed518c1`](https://github.com/briancray/abide/commit/ed518c1e8232c04496fe3fd04783f750164bc378))
+
+- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - share one component analysis across client and SSR back-ends ([`f330664`](https://github.com/briancray/abide/commit/f33066441625c08077b1b413603204ec2afe59eb))
+
+- [`ea69bad`](https://github.com/briancray/abide/commit/ea69bad96d516dc6884d8a8c014b47c4864ebbe6) - format .abide <script> bodies via Biome ([`f4fc64e`](https://github.com/briancray/abide/commit/f4fc64ecb838a449dfb669af5fcaf40bcf7fa8ca))
+
 ## 0.30.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.30.0",
+    "version": "0.31.1",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",
@@ -73,6 +73,7 @@
         "./shared/url": "./src/lib/shared/url.ts",
         "./shared/createSubscriber": "./src/lib/shared/createSubscriber.ts",
         "./ui/state": "./src/lib/ui/state.ts",
+        "./ui/linked": "./src/lib/ui/linked.ts",
         "./ui/derived": "./src/lib/ui/derived.ts",
         "./ui/effect": "./src/lib/ui/effect.ts",
         "./ui/doc": "./src/lib/ui/doc.ts",

package/src/lib/bundle/disconnected.abide

@@ -1,149 +1,149 @@
 <script>
-  /*
+/*
   Default bundle connect screen (abide-ui). The launcher serves this (logo baked in
   at build time, app title injected at runtime) instead of a blank window; override
   it by dropping a `src/bundle/disconnected.abide`. It connects to a remote server
   by URL and boots the embedded server, talking to the launcher's in-process control
   server: POST /connect and POST /start each reply with a `{ redirect }` to follow.
   */
-  const LAST_URL_KEY = 'abide:last-server-url'
+const LAST_URL_KEY = 'abide:last-server-url'
 
-  const heading = globalThis.__ABIDE_TITLE__ ?? 'abide app'
-  const logo = globalThis.__ABIDE_LOGO__
-  const placeholder = 'https://example.com'
+const heading = globalThis.__ABIDE_TITLE__ ?? 'abide app'
+const logo = globalThis.__ABIDE_LOGO__
+const placeholder = 'https://example.com'
 
-  let url = state(localStorage.getItem(LAST_URL_KEY) ?? '')
-  let error = state('')
+let url = state(localStorage.getItem(LAST_URL_KEY) ?? '')
+let error = state('')
 
-  const launchAction = new URLSearchParams(location.search).get('action')
+const launchAction = new URLSearchParams(location.search).get('action')
 
-  /* Two phases so the screen never flashes before a redirect. */
-  let phase = state(launchAction === 'start' ? 'splash' : 'connect')
+/* Two phases so the screen never flashes before a redirect. */
+let phase = state(launchAction === 'start' ? 'splash' : 'connect')
 
-  let configFields = state([])
-  let configValues = state({})
-  let showConfig = state(false)
-  let savingConfig = state(false)
+let configFields = state([])
+let configValues = state({})
+let showConfig = state(false)
+let savingConfig = state(false)
 
-  /* Interpret the boot intent once on load. */
-  effect(() => {
+/* Interpret the boot intent once on load. */
+effect(() => {
     if (launchAction === 'start') {
-      void start()
-      return
+        void start()
+        return
     }
     if (launchAction === 'lost') {
-      error = 'The server stopped responding.'
-      return
+        error = 'The server stopped responding.'
+        return
     }
     if (launchAction === 'disconnect') {
-      void fetch('/__abide/disconnect').catch(() => {})
+        void fetch('/__abide/disconnect').catch(() => {})
     }
-  })
+})
 
-  async function connect() {
+async function connect() {
     const cleaned = url.trim()
     if (!cleaned) {
-      return
+        return
     }
     await postAndFollow('/connect', { url: cleaned }, 'Could not connect', () => {
-      localStorage.setItem(LAST_URL_KEY, cleaned)
+        localStorage.setItem(LAST_URL_KEY, cleaned)
     })
-  }
+}
 
-  async function postAndFollow(path, body, failure, onSuccess) {
+async function postAndFollow(path, body, failure, onSuccess) {
     error = ''
     phase = 'splash'
     try {
-      const response = await fetch(path, {
-        method: 'POST',
-        ...(body === undefined
-          ? {}
-          : { headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) }),
-      })
-      if (!response.ok) {
-        const reply = await response.json()
-        throw new Error(reply.error ?? `${path.slice(1)} failed (${response.status})`)
-      }
-      const { redirect } = await response.json()
-      onSuccess?.()
-      location.href = redirect
+        const response = await fetch(path, {
+            method: 'POST',
+            ...(body === undefined
+                ? {}
+                : { headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) }),
+        })
+        if (!response.ok) {
+            const reply = await response.json()
+            throw new Error(reply.error ?? `${path.slice(1)} failed (${response.status})`)
+        }
+        const { redirect } = await response.json()
+        onSuccess?.()
+        location.href = redirect
     } catch (cause) {
-      error = `${failure}: ${String(cause)}`
-      phase = 'connect'
+        error = `${failure}: ${String(cause)}`
+        phase = 'connect'
     }
-  }
+}
 
-  async function start() {
+async function start() {
     error = ''
     const config = await loadConfig().catch(() => undefined)
     if (config) {
-      configFields = config.fields
-      configValues = { ...config.values }
-      phase = 'connect'
-      showConfig = true
-      return
+        configFields = config.fields
+        configValues = { ...config.values }
+        phase = 'connect'
+        showConfig = true
+        return
     }
     await boot()
-  }
+}
 
-  async function boot() {
+async function boot() {
     await postAndFollow('/start', undefined, 'Could not start the server')
-  }
+}
 
-  async function loadConfig() {
+async function loadConfig() {
     const response = await fetch('/__abide/config')
     const { schema, values } = await response.json()
     if (!schema) {
-      return undefined
+        return undefined
     }
     return { fields: fieldsFromSchema(schema), values: values ?? {} }
-  }
+}
 
-  function fieldsFromSchema(schema) {
+function fieldsFromSchema(schema) {
     const properties = schema.properties ?? {}
     const required = new Set(schema.required ?? [])
     return Object.entries(properties).map(([key, property]) => ({
-      key,
-      label: property.title ?? key,
-      description: property.description,
-      inputType: inputType(property),
-      required: required.has(key),
+        key,
+        label: property.title ?? key,
+        description: property.description,
+        inputType: inputType(property),
+        required: required.has(key),
     }))
-  }
+}
 
-  function inputType(property) {
+function inputType(property) {
     if (property.type === 'boolean') {
-      return 'checkbox'
+        return 'checkbox'
     }
     if (property.type === 'number' || property.type === 'integer') {
-      return 'number'
+        return 'number'
     }
     if (property.format === 'password') {
-      return 'password'
+        return 'password'
     }
     return 'text'
-  }
+}
 
-  async function saveConfig() {
+async function saveConfig() {
     error = ''
     savingConfig = true
     try {
-      const response = await fetch('/__abide/config', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ values: configValues }),
-      })
-      if (!response.ok) {
-        throw new Error(`save failed (${response.status})`)
-      }
-      showConfig = false
-      savingConfig = false
-      await boot()
+        const response = await fetch('/__abide/config', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ values: configValues }),
+        })
+        if (!response.ok) {
+            throw new Error(`save failed (${response.status})`)
+        }
+        showConfig = false
+        savingConfig = false
+        await boot()
     } catch (cause) {
-      error = `Could not save settings: ${String(cause)}`
-      savingConfig = false
+        error = `Could not save settings: ${String(cause)}`
+        savingConfig = false
     }
-  }
+}
 </script>
 
 <template if={phase === 'splash'}>

package/src/lib/cli/dispatchCommand.ts

@@ -1,5 +1,6 @@
 import { decodeResponse } from '../shared/decodeResponse.ts'
 import { isStreamingResponse } from '../shared/isStreamingResponse.ts'
+import { messageFromError } from '../shared/messageFromError.ts'
 import { responseErrorText } from '../shared/responseErrorText.ts'
 import { streamResponse } from '../shared/streamResponse.ts'
 import { createClient } from './createClient.ts'
@@ -41,7 +42,7 @@ export async function dispatchCommand({
     try {
         args = await parseArgvForRpc(argvTail, entry.jsonSchema)
     } catch (error) {
-        console.error(`${programName}: ${error instanceof Error ? error.message : String(error)}`)
+        console.error(`${programName}: ${messageFromError(error)}`)
         return 1
     }
 
@@ -65,7 +66,7 @@ export async function dispatchCommand({
         printValue(await decodeResponse(response), true)
         return 0
     } catch (error) {
-        console.error(`${programName}: ${error instanceof Error ? error.message : String(error)}`)
+        console.error(`${programName}: ${messageFromError(error)}`)
         return 1
     }
 }

package/src/lib/cli/resolveCliTarget.ts

@@ -1,6 +1,7 @@
 import { probeAbideServer } from '../bundle/probeAbideServer.ts'
 import { spawnEmbeddedServer } from '../bundle/spawnEmbeddedServer.ts'
 import { abideLog } from '../shared/abideLog.ts'
+import { messageFromError } from '../shared/messageFromError.ts'
 import { readLastConnection } from '../shared/readLastConnection.ts'
 import type { CliTarget } from './types/CliTarget.ts'
 
@@ -28,9 +29,7 @@ export async function resolveCliTarget(programName: string): Promise<CliTarget |
             })
             return { url, child }
         } catch (error) {
-            abideLog.warn(
-                `could not start local instance: ${error instanceof Error ? error.message : String(error)}`,
-            )
+            abideLog.warn(`could not start local instance: ${messageFromError(error)}`)
             return undefined
         }
     }

package/src/lib/cli/runCli.ts

@@ -1,5 +1,6 @@
 import { clearLastConnection } from '../shared/clearLastConnection.ts'
 import { loadEnvFromDataDir } from '../shared/loadEnvFromDataDir.ts'
+import { messageFromError } from '../shared/messageFromError.ts'
 import { connectToServer } from './connectToServer.ts'
 import { dispatchCommand } from './dispatchCommand.ts'
 import { loadEnvFromBinaryDir } from './loadEnvFromBinaryDir.ts'
@@ -146,9 +147,7 @@ export async function runCli({
         try {
             target = await startLocalInstance(programName)
         } catch (error) {
-            console.error(
-                `${programName}: ${error instanceof Error ? error.message : String(error)}`,
-            )
+            console.error(`${programName}: ${messageFromError(error)}`)
             return 1
         }
         return runSession({ programName, manifest, footer, target })

package/src/lib/cli/runSession.ts

@@ -1,4 +1,5 @@
 import { clearLastConnection } from '../shared/clearLastConnection.ts'
+import { messageFromError } from '../shared/messageFromError.ts'
 import { connectToServer } from './connectToServer.ts'
 import { dispatchCommand } from './dispatchCommand.ts'
 import { printSessionHelp } from './printSessionHelp.ts'
@@ -77,9 +78,7 @@ export async function runSession({
             try {
                 await swap(await startLocalInstance(programName))
             } catch (error) {
-                console.error(
-                    `could not start local instance: ${error instanceof Error ? error.message : String(error)}`,
-                )
+                console.error(`could not start local instance: ${messageFromError(error)}`)
             }
         } else if (head === '/disconnect') {
             await clearLastConnection(programName)

package/src/lib/mcp/dispatchMcpRequest.ts

@@ -1,4 +1,5 @@
 import { ensureRegistriesLoaded } from '../server/runtime/registryManifests.ts'
+import { messageFromError } from '../shared/messageFromError.ts'
 import { getMcpResourceServer } from './mcpResourceServerSlot.ts'
 import { buildPrompts, buildTools, callTool, renderPrompt } from './mcpSurface.ts'
 import type { JsonRpcRequest } from './types/JsonRpcRequest.ts'
@@ -68,7 +69,7 @@ export async function dispatchMcpRequest(
         try {
             await opts.authorize(request)
         } catch (error) {
-            const message = error instanceof Error ? error.message : String(error)
+            const message = messageFromError(error)
             return jsonRpcError(id, -32001, message)
         }
     }
@@ -132,7 +133,7 @@ export async function dispatchMcpRequest(
                 return jsonRpcError(id, -32601, `Method not found: ${envelope.method}`)
         }
     } catch (error) {
-        const message = error instanceof Error ? error.message : String(error)
+        const message = messageFromError(error)
         return jsonRpcError(id, -32603, message)
     }
 }

package/src/lib/mcp/mcpSurface.ts

@@ -8,6 +8,7 @@ import { abideLog } from '../shared/abideLog.ts'
 import { commandNameForUrl } from '../shared/commandNameForUrl.ts'
 import { forwardHeaders } from '../shared/forwardHeaders.ts'
 import { jsonSchemaForSchema } from '../shared/jsonSchemaForSchema.ts'
+import { messageFromError } from '../shared/messageFromError.ts'
 import { annotationsForMethod } from './annotationsForMethod.ts'
 import { getMcpResourceServer } from './mcpResourceServerSlot.ts'
 import { toolResultFromResponse } from './toolResultFromResponse.ts'
@@ -193,7 +194,7 @@ function callSocketTool(
             // publish() validates the payload against the socket schema and throws on failure.
             entry.socket.publish(args)
         } catch (error) {
-            return textResult(error instanceof Error ? error.message : String(error), true)
+            return textResult(messageFromError(error), true)
         }
         return textResult('ok')
     }

package/src/lib/mcp/toolResultFromResponse.ts

@@ -1,5 +1,6 @@
 import { decodeResponse } from '../shared/decodeResponse.ts'
 import { isStreamingResponse } from '../shared/isStreamingResponse.ts'
+import { messageFromError } from '../shared/messageFromError.ts'
 import { responseErrorText } from '../shared/responseErrorText.ts'
 import { streamResponse } from '../shared/streamResponse.ts'
 
@@ -42,7 +43,7 @@ export async function toolResultFromResponse(response: Response): Promise<Record
                     { type: 'text', text: frames.map(asText).join('\n') },
                     {
                         type: 'text',
-                        text: `stream error: ${error instanceof Error ? error.message : String(error)}`,
+                        text: `stream error: ${messageFromError(error)}`,
                     },
                 ],
                 structuredContent: { frames },

package/src/lib/server/rpc/parseArgs.ts

@@ -112,9 +112,7 @@ export async function parseArgs(
     }
 
     if (!url) {
-        if (body === undefined) {
-            return undefined
-        }
+        /* `body` is undefined or a plain object here — return it as-is. */
         return body
     }
 

package/src/lib/server/runtime/streamFromIterator.ts

@@ -1,3 +1,5 @@
+import { messageFromError } from '../../shared/messageFromError.ts'
+
 /*
 Shared body builder for the streaming respond helpers (`jsonl`, `sse`).
 Both flow the same shape — pull from an AsyncIterator, encode each frame
@@ -62,7 +64,7 @@ export function streamFromIterator<T>(
                 }
                 controller.enqueue(textEncoder.encode(encoder.encodeFrame(next.value)))
             } catch (error) {
-                const message = error instanceof Error ? error.message : String(error)
+                const message = messageFromError(error)
                 controller.enqueue(textEncoder.encode(encoder.encodeError(message)))
                 stopKeepalive()
                 controller.close()

package/src/lib/server/runtime/warnUnguardedMcp.ts

@@ -18,9 +18,10 @@ export async function warnUnguardedMcp(): Promise<void> {
     } catch {
         return
     }
-    const exposed =
-        Array.from(verbRegistry.values()).filter((entry) => entry.clients.mcp).length +
-        Array.from(socketRegistry.values()).filter((entry) => entry.clients.mcp).length
+    const isMcpExposed = (entry: { clients: { mcp: boolean } }): boolean => entry.clients.mcp
+    const exposed = [...verbRegistry.values(), ...socketRegistry.values()].filter(
+        isMcpExposed,
+    ).length
     if (exposed === 0) {
         return
     }

package/src/lib/server/sockets/createSocketDispatcher.ts

@@ -1,6 +1,7 @@
 import type { ServerWebSocket } from 'bun'
 import { abideLog } from '../../shared/abideLog.ts'
 import { memoizeByKey } from '../../shared/memoizeByKey.ts'
+import { messageFromError } from '../../shared/messageFromError.ts'
 import { error } from '../error.ts'
 import { json } from '../json.ts'
 import { sse } from '../sse.ts'
@@ -86,7 +87,7 @@ export function createSocketDispatcher(sockets: SocketRoutes): SocketDispatcher
             abideLog.error(loadError)
             return {
                 failure: 'load-failed',
-                message: loadError instanceof Error ? loadError.message : String(loadError),
+                message: messageFromError(loadError),
             }
         }
         const entry = lookupSocket(name)
@@ -214,8 +215,8 @@ export function createSocketDispatcher(sockets: SocketRoutes): SocketDispatcher
         */
         try {
             entry.socket.publish(frame.message)
-        } catch (error) {
-            abideLog.error(error)
+        } catch (publishError) {
+            abideLog.error(publishError)
         }
         /*
         ws parameter retained for future per-ws auth context (cookies on
@@ -276,10 +277,7 @@ export function createSocketDispatcher(sockets: SocketRoutes): SocketDispatcher
                 // publish() validates against the socket schema and throws on a bad payload.
                 entry.socket.publish(message)
             } catch (publishError) {
-                return error(
-                    422,
-                    publishError instanceof Error ? publishError.message : String(publishError),
-                )
+                return error(422, messageFromError(publishError))
             }
             return json({ ok: true })
         }

package/src/lib/shared/cacheEntryFromSnapshot.ts

@@ -1,3 +1,4 @@
+import { contentTypeOf } from './contentTypeOf.ts'
 import type { CacheEntry } from './types/CacheEntry.ts'
 import type { CacheSnapshotEntry } from './types/CacheSnapshotEntry.ts'
 
@@ -39,7 +40,7 @@ function warmValueFromSnapshot(status: number, headers: Headers, body: string):
     if (status === 204 || status < 200 || status >= 300) {
         return undefined
     }
-    const contentType = (headers.get('content-type') ?? '').toLowerCase()
+    const contentType = contentTypeOf(headers)
     if (contentType.includes('json')) {
         /*
         `.includes('json')` also matches streaming/non-JSON types like

package/src/lib/shared/contentTypeOf.ts

@@ -0,0 +1,6 @@
+/* The `content-type` header, lowercased, or '' when absent — the canonical shape
+   every content-type comparison in the codebase reads (case-insensitive match,
+   no undefined to guard). */
+export function contentTypeOf(headers: Headers): string {
+    return (headers.get('content-type') ?? '').toLowerCase()
+}

package/src/lib/shared/decodeResponse.ts

@@ -1,3 +1,4 @@
+import { contentTypeOf } from './contentTypeOf.ts'
 import { HttpError } from './HttpError.ts'
 import { isStreamingResponse } from './isStreamingResponse.ts'
 
@@ -31,7 +32,7 @@ export async function decodeResponse(response: Response): Promise<unknown> {
     if (response.status === 204) {
         return undefined
     }
-    const contentType = (response.headers.get('content-type') ?? '').toLowerCase()
+    const contentType = contentTypeOf(response.headers)
     if (isStreamingResponse(response)) {
         throw new Error(
             `[abide] response at ${response.url} is a stream (${contentType}) — use tail(fn.stream(args)) for a reactive view, or fn.stream(args) for per-call iteration, instead of awaiting the bare call or cache()`,

package/src/lib/shared/isCompileTarget.ts

@@ -1,6 +1,12 @@
 import type { CompileTarget } from './types/CompileTarget.ts'
 
-/* The canonical cross-compile targets, as a runtime set for validation. */
+/* The canonical cross-compile targets, as a runtime set for validation. Kept
+   separate from `detectTarget`'s `HOST_TO_TARGET` on purpose, though the two lists
+   coincide today: this is "every target `--target` accepts" (all cross-targets),
+   while that map is "targets auto-detectable from a host". A future Bun target that
+   no host maps to (a new arch/libc we cross-compile to but don't run on) belongs
+   here and not there — deriving one from the other would couple distinct concerns.
+   Both stay aligned to `CompileTarget`, the single source of truth. */
 const COMPILE_TARGETS: readonly CompileTarget[] = [
     'bun-darwin-arm64',
     'bun-darwin-x64',

package/src/lib/shared/isModuleNotFound.ts

@@ -1,3 +1,5 @@
+import { messageFromError } from './messageFromError.ts'
+
 /*
 True when an error from a dynamic `import(...)` is a module-resolution
 failure (the package isn't installed) rather than an error thrown while
@@ -11,6 +13,6 @@ export function isModuleNotFound(error: unknown): boolean {
     if (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') {
         return true
     }
-    const message = error instanceof Error ? error.message : String(error)
+    const message = messageFromError(error)
     return /cannot find (module|package)|failed to resolve/i.test(message)
 }

package/src/lib/shared/isStreamingResponse.ts

@@ -1,3 +1,4 @@
+import { contentTypeOf } from './contentTypeOf.ts'
 import { STREAMING_CONTENT_TYPES } from './STREAMING_CONTENT_TYPES.ts'
 
 /*
@@ -6,6 +7,6 @@ Content-Type, so callers drain it frame-by-frame instead of buffering.
 Shared by the CLI print path and the MCP tool dispatcher.
 */
 export function isStreamingResponse(response: Response): boolean {
-    const contentType = (response.headers.get('content-type') ?? '').toLowerCase()
+    const contentType = contentTypeOf(response.headers)
     return STREAMING_CONTENT_TYPES.some((type) => contentType.startsWith(type))
 }

package/src/lib/shared/messageFromError.ts

@@ -0,0 +1,6 @@
+/* A thrown value's human message: an Error's `.message`, otherwise the value
+   coerced to a string. The one place the "how a non-Error surfaces to users"
+   rule lives, instead of inlining `x instanceof Error ? x.message : String(x)`. */
+export function messageFromError(error: unknown): string {
+    return error instanceof Error ? error.message : String(error)
+}

package/src/lib/shared/streamResponse.ts

@@ -1,3 +1,4 @@
+import { contentTypeOf } from './contentTypeOf.ts'
 import { decodeResponse } from './decodeResponse.ts'
 import { HttpError } from './HttpError.ts'
 import { jsonlErrorFrame } from './jsonlErrorFrame.ts'
@@ -29,7 +30,7 @@ export function streamResponse<T>(response: Response): AsyncIterable<T> {
     if (!response.ok) {
         return errorIterable<T>(new HttpError(response))
     }
-    const contentType = (response.headers.get('content-type') ?? '').toLowerCase()
+    const contentType = contentTypeOf(response.headers)
     if (contentType.startsWith('text/event-stream')) {
         return parseSse<T>(response)
     }

package/src/lib/ui/compile/REACTIVE_CALLEES.ts

@@ -0,0 +1,7 @@
+/* The callee names the `.abide` compiler recognises as reactive declarations
+   (`let x = state(...)`, `linked(...)`, `derived(...)`, `prop(...)`): the shared
+   "is this a reactive binding" allowlist read by the desugarer, the nested-script
+   scoper, and the type-checking shadow. How each lowers — a serializable doc slot
+   vs a `.value` cell — is decided per-site; this is only the membership set, so a
+   new primitive is a single edit here. */
+export const REACTIVE_CALLEES: ReadonlySet<string> = new Set(['state', 'linked', 'derived', 'prop'])