@abide/abide 0.48.0 → 0.50.0

package/src/lib/bundle/disconnected.abide

@@ -149,72 +149,69 @@ async function saveConfig() {
 }
 </script>
 
-<template if={phase === 'splash'}>
+{#if phase === 'splash'}
     <div class="flex min-h-screen items-center justify-center bg-gray-50 dark:bg-gray-950">
-        <template if={logo}>
+        {#if logo}
             <img src={logo} alt="" class="h-16 w-16 rounded-xl object-contain opacity-90" />
-        </template>
+        {/if}
     </div>
-    <template else>
-        <main
-            class="flex min-h-screen items-center justify-center bg-gray-50 p-6 text-gray-900 dark:bg-gray-950 dark:text-gray-100">
-            <div
-                class="w-full max-w-sm rounded-2xl bg-white p-8 shadow-sm ring-1 ring-gray-200 dark:bg-gray-900 dark:ring-gray-800">
-                <template if={logo}>
-                    <img
-                        src={logo}
-                        alt=""
-                        class="mx-auto mb-5 h-16 w-16 rounded-xl object-contain" />
-                </template>
-                <h1 class="mb-6 text-center text-xl font-semibold tracking-tight">{heading}</h1>
-
-                <form class="flex flex-col gap-3" onsubmit={(event) => { event.preventDefault(); void connect() }}>
-                    <input
-                        type="url"
-                        bind:value={url}
-                        placeholder={placeholder}
-                        autocomplete="url"
-                        class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900 focus:ring-1 focus:ring-gray-900 dark:border-gray-700 dark:bg-gray-800 dark:focus:border-gray-100 dark:focus:ring-gray-100" />
-                    <button
-                        type="submit"
-                        class="w-full rounded-lg bg-gray-900 px-3 py-2 text-sm font-medium text-white hover:bg-gray-700 dark:bg-gray-100 dark:text-gray-900 dark:hover:bg-gray-300">
-                        Connect
-                    </button>
-                </form>
-
-                <div class="my-5 flex items-center gap-3 text-xs text-gray-400 dark:text-gray-500">
-                    <span class="h-px flex-1 bg-gray-200 dark:bg-gray-800"></span>
-                    or
-                    <span class="h-px flex-1 bg-gray-200 dark:bg-gray-800"></span>
-                </div>
+{:else}
+    <main
+        class="flex min-h-screen items-center justify-center bg-gray-50 p-6 text-gray-900 dark:bg-gray-950 dark:text-gray-100">
+        <div
+            class="w-full max-w-sm rounded-2xl bg-white p-8 shadow-sm ring-1 ring-gray-200 dark:bg-gray-900 dark:ring-gray-800">
+            {#if logo}
+                <img
+                    src={logo}
+                    alt=""
+                    class="mx-auto mb-5 h-16 w-16 rounded-xl object-contain" />
+            {/if}
+            <h1 class="mb-6 text-center text-xl font-semibold tracking-tight">{heading}</h1>
 
+            <form class="flex flex-col gap-3" onsubmit={(event) => { event.preventDefault(); void connect() }}>
+                <input
+                    type="url"
+                    bind:value={url}
+                    placeholder={placeholder}
+                    autocomplete="url"
+                    class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900 focus:ring-1 focus:ring-gray-900 dark:border-gray-700 dark:bg-gray-800 dark:focus:border-gray-100 dark:focus:ring-gray-100" />
                 <button
-                    type="button"
-                    onclick={() => void start()}
-                    class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm font-medium hover:bg-gray-50 dark:border-gray-700 dark:hover:bg-gray-800">
-                    Start server
+                    type="submit"
+                    class="w-full rounded-lg bg-gray-900 px-3 py-2 text-sm font-medium text-white hover:bg-gray-700 dark:bg-gray-100 dark:text-gray-900 dark:hover:bg-gray-300">
+                    Connect
                 </button>
+            </form>
 
-                <template if={error}>
-                    <p class="mt-4 text-center text-sm text-red-600 dark:text-red-400">
-                        {error}
-                    </p>
-                </template>
-
-                <p class="mt-8 text-center text-xs text-gray-400 dark:text-gray-500">
-                    made with
-                    <a
-                        href="https://github.com/briancray/abide"
-                        class="underline hover:text-gray-600 dark:hover:text-gray-300"
-                        >abide</a
-                    >
-                </p>
+            <div class="my-5 flex items-center gap-3 text-xs text-gray-400 dark:text-gray-500">
+                <span class="h-px flex-1 bg-gray-200 dark:bg-gray-800"></span>
+                or
+                <span class="h-px flex-1 bg-gray-200 dark:bg-gray-800"></span>
             </div>
-        </main>
-    </template>
-</template>
 
-<template if={showConfig}>
+            <button
+                type="button"
+                onclick={() => void start()}
+                class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm font-medium hover:bg-gray-50 dark:border-gray-700 dark:hover:bg-gray-800">
+                Start server
+            </button>
+
+            {#if error}
+                <p class="mt-4 text-center text-sm text-red-600 dark:text-red-400">{error}</p>
+            {/if}
+
+            <p class="mt-8 text-center text-xs text-gray-400 dark:text-gray-500">
+                made with
+                <a
+                    href="https://github.com/briancray/abide"
+                    class="underline hover:text-gray-600 dark:hover:text-gray-300"
+                    >abide</a
+                >
+            </p>
+        </div>
+    </main>
+{/if}
+
+{#if showConfig}
     <div
         class="fixed inset-0 z-10 flex items-center justify-center bg-black/40 p-6 text-gray-900 dark:text-gray-100">
         <div
@@ -222,29 +219,28 @@ async function saveConfig() {
             <h2 class="mb-5 text-lg font-semibold tracking-tight">Set up {heading}</h2>
 
             <form class="flex flex-col gap-4" onsubmit={(event) => { event.preventDefault(); void saveConfig() }}>
-                <template each={configFields} as="field" key="field.key">
+                {#for field of configFields by field.key}
                     <label class="flex flex-col gap-1 text-sm">
                         <span class="font-medium">{field.label}</span>
-                        <template if={field.inputType === 'checkbox'}>
+                        {#if field.inputType === 'checkbox'}
                             <input
                                 type="checkbox"
                                 onchange={(event) => { configValues[field.key] = event.currentTarget.checked ? 'true' : 'false' }}
                                 class="mt-1 size-4 self-start rounded border-gray-300 dark:border-gray-700" />
-                            <template else>
-                                <input
-                                    type={field.inputType}
-                                    value={configValues[field.key]}
-                                    oninput={(event) => { configValues[field.key] = event.currentTarget.value }}
-                                    class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900 focus:ring-1 focus:ring-gray-900 dark:border-gray-700 dark:bg-gray-800 dark:focus:border-gray-100 dark:focus:ring-gray-100" />
-                            </template>
-                        </template>
-                        <template if={field.description}>
+                        {:else}
+                            <input
+                                type={field.inputType}
+                                value={configValues[field.key]}
+                                oninput={(event) => { configValues[field.key] = event.currentTarget.value }}
+                                class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none focus:border-gray-900 focus:ring-1 focus:ring-gray-900 dark:border-gray-700 dark:bg-gray-800 dark:focus:border-gray-100 dark:focus:ring-gray-100" />
+                        {/if}
+                        {#if field.description}
                             <span class="text-xs text-gray-400 dark:text-gray-500"
                                 >{field.description}</span
                             >
-                        </template>
+                        {/if}
                     </label>
-                </template>
+                {/for}
 
                 <div class="mt-1 flex gap-3">
                     <button
@@ -261,9 +257,9 @@ async function saveConfig() {
                 </div>
             </form>
 
-            <template if={error}>
+            {#if error}
                 <p class="mt-4 text-center text-sm text-red-600 dark:text-red-400">{error}</p>
-            </template>
+            {/if}
         </div>
     </div>
-</template>
+{/if}

package/src/lib/bundle/infoPlist.ts

@@ -15,9 +15,15 @@ export function infoPlist({
     version: string
     icon?: string
 }): string {
+    /* Interpolated values ride inside plist `<string>` elements, so any `&`/`<`/`>` in a
+       project name would otherwise emit malformed XML that codesign/Gatekeeper reject. */
+    const escapeXml = (value: string): string =>
+        value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
+    const safeName = escapeXml(name)
+    const safeVersion = escapeXml(version)
     const iconEntry = icon
         ? `    <key>CFBundleIconFile</key>
-    <string>${icon}</string>
+    <string>${escapeXml(icon)}</string>
 `
         : ''
     return `<?xml version="1.0" encoding="UTF-8"?>
@@ -25,17 +31,17 @@ export function infoPlist({
 <plist version="1.0">
 <dict>
     <key>CFBundleName</key>
-    <string>${name}</string>
+    <string>${safeName}</string>
     <key>CFBundleDisplayName</key>
-    <string>${name}</string>
+    <string>${safeName}</string>
     <key>CFBundleExecutable</key>
-    <string>${name}</string>
+    <string>${safeName}</string>
     <key>CFBundleIdentifier</key>
-    <string>com.abide.${name}</string>
+    <string>com.abide.${safeName}</string>
     <key>CFBundleVersion</key>
-    <string>${version}</string>
+    <string>${safeVersion}</string>
     <key>CFBundleShortVersionString</key>
-    <string>${version}</string>
+    <string>${safeVersion}</string>
 ${iconEntry}    <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>NSHighResolutionCapable</key>

package/src/lib/bundle/installDownloads.ts

@@ -16,9 +16,19 @@ export function installDownloads(libPath: string, webviewHandle: Pointer | null)
     if (process.platform !== 'darwin') {
         return
     }
-    const { symbols, close } = dlopen(libPath, {
-        abide_install_downloads: { args: [FFIType.ptr], returns: FFIType.void },
-    })
+    /* abide_install_downloads exists only in abide's own webview lib. A vanilla
+       ABIDE_WEBVIEW_LIB on darwin lacks it, so dlopen throws — degrade to a no-op
+       (downloads simply unhandled) instead of crashing the launcher, matching the
+       optional-symbol FFI binders. */
+    let symbols: { abide_install_downloads: (handle: Pointer | null) => void }
+    let close: () => void
+    try {
+        ;({ symbols, close } = dlopen(libPath, {
+            abide_install_downloads: { args: [FFIType.ptr], returns: FFIType.void },
+        }))
+    } catch {
+        return
+    }
     symbols.abide_install_downloads(webviewHandle)
     close()
 }

package/src/lib/bundle/installMacMenu.ts

@@ -30,9 +30,19 @@ export function installMacMenu(
     if (process.platform !== 'darwin') {
         return
     }
-    const { symbols, close } = dlopen(libPath, {
-        abide_install_app_menu: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.void },
-    })
+    /* The abide_install_app_menu symbol is compiled only into abide's own webview lib.
+       A user who points ABIDE_WEBVIEW_LIB at a vanilla webview.dylib is on darwin but
+       lacks the symbol, so dlopen throws — degrade to a no-op (native menu simply absent)
+       rather than crashing the launcher, matching bindConnectedFlag/bindRequestNavigate. */
+    let symbols: { abide_install_app_menu: (handle: Pointer | null, config: Uint8Array) => void }
+    let close: () => void
+    try {
+        ;({ symbols, close } = dlopen(libPath, {
+            abide_install_app_menu: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.void },
+        }))
+    } catch {
+        return
+    }
     const config = JSON.stringify({ appName, fileMenu, menu })
     symbols.abide_install_app_menu(webviewHandle, new TextEncoder().encode(`${config}\0`))
     close()

package/src/lib/bundle/spawnEmbeddedServer.ts

@@ -53,10 +53,19 @@ export async function spawnEmbeddedServer({
         env: { ...process.env, PORT: String(port), ABIDE_PARENT_PID: String(process.pid) },
         stdio: ['inherit', 'inherit', 'inherit'],
     })
-    const outcome = await Promise.race([
-        waitForServer(url, timeoutMs ? { timeoutMs } : undefined).then(() => undefined),
-        child.exited,
-    ])
+    let outcome: number | undefined
+    try {
+        outcome = await Promise.race([
+            waitForServer(url, timeoutMs ? { timeoutMs } : undefined).then(() => undefined),
+            child.exited,
+        ])
+    } catch (error) {
+        /* Readiness timed out (waitForServer threw) — reap the child we spawned so it doesn't
+           orphan and hold its fixed PORT, which would then fail the next spawn's bind. The caller
+           only owns the child once we successfully return it. */
+        child.kill()
+        throw error
+    }
     if (outcome !== undefined) {
         throw new Error(`[abide] embedded server exited (code ${outcome}) before binding`)
     }

package/src/lib/bundle/waitForServer.ts

@@ -13,7 +13,12 @@ export async function waitForServer(
     const deadline = Bun.nanoseconds() + timeoutMs * 1e6
     while (Bun.nanoseconds() < deadline) {
         try {
-            await fetch(url)
+            /* Bound each probe by the time left to the deadline: a connection that is accepted but
+               stalls its HTTP response leaves a bare `fetch(url)` pending forever (it never rejects),
+               which would hang the loop past its own timeout. The abort caps a single hung probe at
+               the remaining budget so the deadline is always honored. */
+            const remainingMs = Math.max(0, (deadline - Bun.nanoseconds()) / 1e6)
+            await fetch(url, { signal: AbortSignal.timeout(remainingMs) })
             return
         } catch {
             await Bun.sleep(intervalMs)

package/src/lib/cli/parseArgvForRpc.ts

@@ -74,8 +74,36 @@ export async function parseArgvForRpc(
         }
         const name = token.name
         const propType = properties[name]?.type
+        /* Coerce one string token to a schema scalar type (or throw). Shared by scalar
+           props and array ELEMENTS so `--tags 1 --tags 2` on `z.array(z.number())` yields
+           numbers, not strings the server then rejects. */
+        const coerceScalar = (raw: string, type: string | undefined): unknown => {
+            if (type === 'number' || type === 'integer') {
+                // Reject a blank value explicitly — `Number('')` / `Number('  ')` is 0,
+                // not NaN, so the NaN guard alone would silently coerce it to zero.
+                const n = raw.trim() === '' ? Number.NaN : Number(raw)
+                if (Number.isNaN(n)) {
+                    throw new Error(`--${name} expects a number, got ${raw}`)
+                }
+                return n
+            }
+            if (type === 'boolean') {
+                const lowered = raw.trim().toLowerCase()
+                if (lowered === 'true' || lowered === '1') {
+                    return true
+                }
+                if (lowered === 'false' || lowered === '0') {
+                    return false
+                }
+                throw new Error(`--${name} expects true or false, got ${raw}`)
+            }
+            return raw
+        }
         if (propType === 'boolean') {
-            args[name] = !token.negated
+            /* Bare `--flag` / `--no-flag` toggles; inline `--flag=false` honours the RHS
+               instead of always resolving to true. */
+            args[name] =
+                token.value !== undefined ? coerceScalar(token.value, 'boolean') : !token.negated
             continue
         }
         if (token.missingValue || token.value === undefined) {
@@ -83,18 +111,17 @@ export async function parseArgvForRpc(
         }
         const value = token.value
         if (propType === 'number' || propType === 'integer') {
-            // Reject a blank value explicitly — `Number('')` / `Number('  ')` is 0,
-            // not NaN, so the NaN guard alone would silently coerce it to zero.
-            const n = value.trim() === '' ? Number.NaN : Number(value)
-            if (Number.isNaN(n)) {
-                throw new Error(`--${name} expects a number, got ${value}`)
-            }
-            args[name] = n
+            args[name] = coerceScalar(value, propType)
             continue
         }
         if (propType === 'array') {
+            /* Coerce each repeated element per the schema's `items.type` — a string-only
+               array arg silently fails server-side Zod validation for numeric/boolean items. */
+            const itemType = (properties[name] as { items?: { type?: string } } | undefined)?.items
+                ?.type
+            const element = coerceScalar(value, itemType)
             const existing = args[name]
-            args[name] = Array.isArray(existing) ? [...existing, value] : [value]
+            args[name] = Array.isArray(existing) ? [...existing, element] : [element]
             continue
         }
         args[name] = value

package/src/lib/cli/tokenizeArgvFlags.ts

@@ -64,9 +64,11 @@ export function* tokenizeArgvFlags(
             : undefined
         const negated = negatedName !== undefined && properties[negatedName]?.type === 'boolean'
         const name = negated ? (negatedName as string) : literalName
-        // Boolean props and inline `--name=value` consume no following token.
+        // Boolean props and inline `--name=value` consume no following token. Pass any
+        // inline value through (`--flag=false`) so the parser can honour the RHS instead
+        // of the boolean always resolving to true.
         if (properties[name]?.type === 'boolean') {
-            yield { name, negated }
+            yield { name, negated, value: inlineValue }
             continue
         }
         if (inlineValue !== undefined) {

package/src/lib/mcp/createMcpResourceServer.ts

@@ -1,5 +1,6 @@
 // node:fs existsSync — cheap sync presence check, mirrors createPublicAssetServer
 import { existsSync } from 'node:fs'
+import { resolve, sep } from 'node:path'
 import { Glob } from 'bun'
 import { mimeForExtension } from '../server/runtime/mimeForExtension.ts'
 import type { Assets } from '../server/runtime/types/Assets.ts'
@@ -81,8 +82,10 @@ export function createMcpResourceServer({
                 return undefined
             }
             const relativePath = uri.slice(URI_PREFIX.length)
-            // reject `..` traversal in the requested uri before any disk read
-            if (relativePath.split('/').includes('..')) {
+            // reject `..` traversal on EITHER separator — a backslash-joined `..\` escapes
+            // resourcesDir on Windows (its OS layer treats `\` as a separator regardless of
+            // how the JS string was built), so a `/`-only split lets it through.
+            if (relativePath.split(/[\\/]/).includes('..')) {
                 return undefined
             }
             if (mcpResources) {
@@ -92,6 +95,14 @@ export function createMcpResourceServer({
                 }
                 return contentsFor(relativePath, Bun.gunzipSync(compressed))
             }
+            // Belt-and-braces for the on-disk branch: resolve the target and confirm it
+            // stays inside resourcesDir, catching any traversal the segment check missed
+            // (absolute paths, platform separator quirks).
+            const root = resolve(resourcesDir)
+            const target = resolve(root, relativePath)
+            if (target !== root && !target.startsWith(root + sep)) {
+                return undefined
+            }
             const file = Bun.file(`${resourcesDir}/${relativePath}`)
             if (!(await file.exists())) {
                 return undefined

package/src/lib/mcp/mcpTools.ts

@@ -1,4 +1,8 @@
 import { dispatchRpcInProcess } from '../server/rpc/dispatchRpcInProcess.ts'
+import {
+    resolveInputJsonSchema,
+    resolveOutputJsonSchema,
+} from '../server/rpc/resolveRpcJsonSchema.ts'
 import { rpcRegistry } from '../server/rpc/rpcRegistry.ts'
 import type { RpcRegistryEntry } from '../server/rpc/types/RpcRegistryEntry.ts'
 import { socketOperations } from '../server/sockets/socketOperations.ts'
@@ -37,7 +41,7 @@ RPCs enumerate first, so on a name collision the rpc tool wins.
 function mcpToolRefs(): McpToolRef[] {
     const refs: McpToolRef[] = []
     for (const entry of rpcRegistry.values()) {
-        if (!entry.clients.mcp) {
+        if (!entry.remote.clients.mcp) {
             continue
         }
         refs.push({ kind: 'rpc', name: commandNameForUrl(entry.remote.url), entry })
@@ -63,7 +67,9 @@ from a write.
 */
 function describeTool(ref: McpToolRef): ToolDescriptor {
     if (ref.kind === 'rpc') {
-        const inputSchema = jsonSchemaForSchema(ref.entry.inputSchema)
+        // The declared inputSchema VALIDATOR overrides the build-projected input-type schema
+        // (ADR-0030 input side); with neither the tool advertises the opaque fallback, as before.
+        const inputSchema = resolveInputJsonSchema(ref.entry) ?? jsonSchemaForSchema(undefined)
         const tool: ToolDescriptor = {
             name: ref.name,
             description:
@@ -72,8 +78,11 @@ function describeTool(ref: McpToolRef): ToolDescriptor {
             inputSchema,
             annotations: annotationsForMethod(ref.entry.remote.method),
         }
-        if (ref.entry.outputSchema) {
-            tool.outputSchema = jsonSchemaForSchema(ref.entry.outputSchema)
+        // The declared outputSchema VALIDATOR overrides the build-projected return-type schema
+        // (ADR-0030 D2); with neither the tool advertises no outputSchema, exactly as before.
+        const outputSchema = resolveOutputJsonSchema(ref.entry)
+        if (outputSchema) {
+            tool.outputSchema = outputSchema
         }
         return tool
     }
@@ -149,8 +158,8 @@ function callSocketTool(
         }
     }
     try {
-        // broadcast() validates the payload against the socket schema and throws on failure.
-        entry.socket.broadcast(args)
+        // publish() validates the payload against the socket schema and throws on failure.
+        entry.socket.publish(args)
     } catch (error) {
         return textResult(messageFromError(error), true)
     }

package/src/lib/mcp/toolResultFromResponse.ts

@@ -4,6 +4,12 @@ import { messageFromError } from '../shared/messageFromError.ts'
 import { responseErrorText } from '../shared/responseErrorText.ts'
 import { streamResponse } from '../shared/streamResponse.ts'
 
+/* MCP `tools/call` is request/response, not a streaming transport, so a genuinely live
+   stream must be bounded: return what arrived within these limits (with a truncation note)
+   rather than buffering forever and never answering. */
+const MAX_STREAM_FRAMES = 1000
+const STREAM_TOOL_TIMEOUT_MS = 30_000
+
 // Frames a value as MCP text content — strings verbatim, everything else as JSON.
 // An undefined body (204 / empty) becomes '' — `JSON.stringify(undefined)` is the
 // value `undefined`, not a string, which would make an invalid text content block.
@@ -38,26 +44,48 @@ export async function toolResultFromResponse(response: Response): Promise<Record
 
     if (isStreamingResponse(response)) {
         const frames: unknown[] = []
+        // Set when WE stop the stream (cap/timeout), so the iterator's resulting end/throw
+        // reads as truncation, not a stream error.
+        let truncated: string | undefined
+        const timer = setTimeout(() => {
+            truncated = `stream truncated after ${STREAM_TOOL_TIMEOUT_MS}ms — MCP tools/call is request/response, not a live stream`
+            void response.body?.cancel()
+        }, STREAM_TOOL_TIMEOUT_MS)
         try {
             for await (const frame of streamResponse(response)) {
                 frames.push(frame)
+                if (frames.length >= MAX_STREAM_FRAMES) {
+                    truncated = `stream truncated at ${MAX_STREAM_FRAMES} frames`
+                    void response.body?.cancel()
+                    break
+                }
             }
         } catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: frames.map(asText).join('\n') },
-                    {
-                        type: 'text',
-                        text: `stream error: ${messageFromError(error)}`,
-                    },
-                ],
-                structuredContent: { frames },
-                isError: true,
+            /* A real mid-stream error (we didn't cancel) surfaces as isError; a throw caused
+               by our own cancel falls through to the truncated result below. */
+            if (truncated === undefined) {
+                clearTimeout(timer)
+                return {
+                    content: [
+                        { type: 'text', text: frames.map(asText).join('\n') },
+                        { type: 'text', text: `stream error: ${messageFromError(error)}` },
+                    ],
+                    structuredContent: { frames },
+                    isError: true,
+                }
             }
+        } finally {
+            clearTimeout(timer)
+        }
+        const content: { type: 'text'; text: string }[] = [
+            { type: 'text', text: frames.map(asText).join('\n') },
+        ]
+        if (truncated !== undefined) {
+            content.push({ type: 'text', text: truncated })
         }
         return {
-            content: [{ type: 'text', text: frames.map(asText).join('\n') }],
-            structuredContent: { frames },
+            content,
+            structuredContent: truncated === undefined ? { frames } : { frames, truncated },
         }
     }
 

package/src/lib/server/error.ts

@@ -93,15 +93,15 @@ expose the error on `rpc.isError(e, 'name')` (`.kind` and typed `.data`). No
 (a const can't read its own variable name); `schema` types `.data` and is never
 validated at runtime here.
 */
-function typed<Name extends string, Schema extends StandardSchemaV1>(
+function typed<Name extends string, Status extends number, Schema extends StandardSchemaV1>(
     name: Name,
-    status: number,
+    status: Status,
     schema: Schema,
-): (data: StandardSchemaV1.InferInput<Schema>) => TypedError<Name, { status: number; data: Schema }>
-function typed<Name extends string>(
+): (data: StandardSchemaV1.InferInput<Schema>) => TypedError<Name, { status: Status; data: Schema }>
+function typed<Name extends string, Status extends number>(
     name: Name,
-    status: number,
-): () => TypedError<Name, { status: number; data?: undefined }>
+    status: Status,
+): () => TypedError<Name, { status: Status; data?: undefined }>
 function typed(name: string, status: number, _schema?: StandardSchemaV1) {
     return (data?: unknown) => typedErrorResponse(name, status, data)
 }

package/src/lib/server/json.ts

@@ -1,7 +1,13 @@
 import { NO_STORE } from '../shared/CACHE_CONTROL_VALUES.ts'
+import { encodeWireBody } from '../shared/encodeWireBody.ts'
 import type { TypedResponse } from './rpc/types/TypedResponse.ts'
 import { withResponseDefaults } from './runtime/withResponseDefaults.ts'
 
+/* The Content-Type `Response.json` sets — replicated here because the wire-encode step serializes
+   with a replacer, so the body is built by hand rather than through `Response.json`. Seeds the
+   default header set so an explicit caller `content-type` still wins. */
+const JSON_CONTENT_TYPE = 'application/json;charset=utf-8'
+
 /*
 JSON Response with rpc-friendly defaults — same shape as
 `Response.json(data, init)`, except `Cache-Control: no-store` is set
@@ -36,8 +42,16 @@ export function json<T>(data: T, init?: ResponseInit): TypedResponse<T> {
             withResponseDefaults(init, { 'Cache-Control': NO_STORE }, 204),
         ) as TypedResponse<T>
     }
-    return Response.json(
-        data,
-        withResponseDefaults(init, { 'Cache-Control': NO_STORE }),
+    /* Wire-encode the body (ADR-0029 output path) through the shared honest-JSON encoder: a
+       value-directed replacer rewrites a `Set` → array, a `Map` → `[K,V]` entries, and a `bigint`
+       → digit string, so a structured return crosses as honest JSON rather than a lost `{}` or a
+       500 (plain `Response.json` throws on a bigint). A `Date` already rides as an ISO string via
+       its native `toJSON`. */
+    return new Response(
+        encodeWireBody(data),
+        withResponseDefaults(init, {
+            'Cache-Control': NO_STORE,
+            'Content-Type': JSON_CONTENT_TYPE,
+        }),
     ) as TypedResponse<T>
 }