@briancray/belte 0.1.0

package/src/lib/mcp/createMcpResourceServer.ts

@@ -0,0 +1,101 @@
+// node:fs existsSync — cheap sync presence check, mirrors createPublicAssetServer
+import { existsSync } from 'node:fs'
+import { Glob } from 'bun'
+import { mimeForExtension } from '../server/runtime/mimeForExtension.ts'
+import type { Assets } from '../server/runtime/types/Assets.ts'
+import type { McpResourceContents } from './types/McpResourceContents.ts'
+import type { McpResourceDescriptor } from './types/McpResourceDescriptor.ts'
+import type { McpResourceServer } from './types/McpResourceServer.ts'
+
+/*
+The belte:// URI namespace for file-based resources. A resource's URI is this
+prefix followed by its path relative to src/mcp/resources.
+*/
+const URI_PREFIX = 'belte://resources/'
+
+/*
+MIME essences returned inline as UTF-8 `text` in resources/read; everything
+else is returned as a base64 `blob`. The essence is taken before any `;charset`
+parameter that Bun.file().type appends.
+*/
+function isTextMime(mime: string): boolean {
+    const essence = mime.split(';')[0].trim()
+    return (
+        essence.startsWith('text/') ||
+        essence === 'application/json' ||
+        essence === 'application/xml' ||
+        essence === 'image/svg+xml' ||
+        essence.endsWith('+json') ||
+        essence.endsWith('+xml')
+    )
+}
+
+function descriptorFor(relativePath: string): McpResourceDescriptor {
+    return {
+        uri: `${URI_PREFIX}${relativePath}`,
+        name: relativePath,
+        mimeType: mimeForExtension(relativePath),
+    }
+}
+
+function contentsFor(relativePath: string, bytes: Uint8Array): McpResourceContents {
+    const mimeType = mimeForExtension(relativePath)
+    const uri = `${URI_PREFIX}${relativePath}`
+    if (isTextMime(mimeType)) {
+        return { uri, mimeType, text: new TextDecoder().decode(bytes) }
+    }
+    return { uri, mimeType, blob: bytes.toBase64() }
+}
+
+/*
+Serves files under src/mcp/resources as MCP resources. Two sources, picked at
+construction (mirrors createPublicAssetServer):
+  - `mcpResources` (standalone compile): a map of relative-path → zstd bytes
+    embedded into the binary.
+  - `resourcesDir` on disk (dev + `belte start`): files read straight from
+    `${cwd}/src/mcp/resources`.
+*/
+export function createMcpResourceServer({
+    resourcesDir,
+    mcpResources,
+}: {
+    resourcesDir: string
+    mcpResources?: Assets
+}): McpResourceServer {
+    return {
+        async list(): Promise<McpResourceDescriptor[]> {
+            if (mcpResources) {
+                return Object.keys(mcpResources).map(descriptorFor)
+            }
+            if (!existsSync(resourcesDir)) {
+                return []
+            }
+            const files = await Array.fromAsync(
+                new Glob('**/*').scan({ cwd: resourcesDir, onlyFiles: true }),
+            )
+            return files.map(descriptorFor)
+        },
+        async read(uri: string): Promise<McpResourceContents | undefined> {
+            if (!uri.startsWith(URI_PREFIX)) {
+                return undefined
+            }
+            const relativePath = uri.slice(URI_PREFIX.length)
+            // reject `..` traversal in the requested uri before any disk read
+            if (relativePath.split('/').includes('..')) {
+                return undefined
+            }
+            if (mcpResources) {
+                const compressed = mcpResources[relativePath]
+                if (!compressed) {
+                    return undefined
+                }
+                return contentsFor(relativePath, Bun.zstdDecompressSync(compressed))
+            }
+            const file = Bun.file(`${resourcesDir}/${relativePath}`)
+            if (!(await file.exists())) {
+                return undefined
+            }
+            return contentsFor(relativePath, await file.bytes())
+        },
+    }
+}

package/src/lib/mcp/createMcpServer.ts

@@ -0,0 +1,40 @@
+import { dispatchMcpRequest, MCP_NO_STORE_HEADERS } from './dispatchMcpRequest.ts'
+import type { McpServer } from './types/McpServer.ts'
+import type { McpServerOptions } from './types/McpServerOptions.ts'
+
+const DEFAULT_NAME = 'belte-app'
+const DEFAULT_VERSION = '0.0.0'
+
+/*
+Constructs an MCP server bound to the project's rpc registry. Returns an
+object whose `handle(request)` is the function the bun route at
+/__belte/mcp invokes. Framework-internal — the belte:mcp virtual
+default-constructs it; there is no user-authored server module. Server
+name/version default from package.json.
+
+Tools are derived from every verb with `clients.mcp: true` (auto-on when
+the verb carries a schema) — one tool per rpc regardless of HTTP verb.
+Sockets are not exposed to MCP. Auth inherits from the inbound request —
+bearer / cookie headers
+flow into the synthesized Request that hits each rpc handler. An optional
+`authorize` hook in opts can short-circuit the request before any tool
+dispatches.
+*/
+export function createMcpServer(opts: McpServerOptions = {}): McpServer {
+    const serverInfo = {
+        name: opts.name ?? DEFAULT_NAME,
+        version: opts.version ?? DEFAULT_VERSION,
+    }
+    return {
+        async handle(request: Request): Promise<Response> {
+            if (request.method !== 'POST') {
+                return new Response('Method Not Allowed', {
+                    status: 405,
+                    headers: { Allow: 'POST', 'Cache-Control': 'no-store' },
+                })
+            }
+            const envelope = await dispatchMcpRequest(request, opts, serverInfo)
+            return new Response(JSON.stringify(envelope), { headers: MCP_NO_STORE_HEADERS })
+        },
+    }
+}

package/src/lib/mcp/dispatchMcpRequest.ts

@@ -0,0 +1,294 @@
+import { promptRegistry } from '../server/prompts/promptRegistry.ts'
+import type { HttpVerb } from '../server/rpc/types/HttpVerb.ts'
+import { verbRegistry } from '../server/rpc/verbRegistry.ts'
+import { ensureRegistriesLoaded } from '../server/runtime/registryManifests.ts'
+import { buildRpcRequest } from '../shared/buildRpcRequest.ts'
+import { NO_STORE } from '../shared/cacheControlValues.ts'
+import { commandNameForUrl } from '../shared/commandNameForUrl.ts'
+import { decodeResponse } from '../shared/decodeResponse.ts'
+import { forwardHeaders } from '../shared/forwardHeaders.ts'
+import { jsonSchemaForSchema } from '../shared/jsonSchemaForSchema.ts'
+import { getMcpResourceServer } from './mcpResourceServerSlot.ts'
+import type { JsonRpcRequest } from './types/JsonRpcRequest.ts'
+import type { JsonRpcResponse } from './types/JsonRpcResponse.ts'
+import type { McpServerOptions } from './types/McpServerOptions.ts'
+
+const PROTOCOL_VERSION = '2025-06-18'
+
+function jsonRpcError(
+    id: string | number | null,
+    code: number,
+    message: string,
+    data?: unknown,
+): JsonRpcResponse {
+    return { jsonrpc: '2.0', id, error: { code, message, ...(data === undefined ? {} : { data }) } }
+}
+
+function jsonRpcOk(id: string | number | null, result: unknown): JsonRpcResponse {
+    return { jsonrpc: '2.0', id, result }
+}
+
+/*
+Builds the array of MCP tool descriptors. Every rpc with clients.mcp=true
+becomes one tool named after the export's URL (folder segments joined
+with `-`), regardless of HTTP verb — GET reads and mutating verbs alike.
+Sockets are never exposed to MCP.
+*/
+function buildTools(): Array<{
+    name: string
+    description: string
+    inputSchema: Record<string, unknown>
+}> {
+    const tools: Array<{
+        name: string
+        description: string
+        inputSchema: Record<string, unknown>
+    }> = []
+    for (const entry of verbRegistry.values()) {
+        if (!entry.clients.mcp) {
+            continue
+        }
+        tools.push({
+            name: commandNameForUrl(entry.remote.url),
+            description: `${entry.remote.method} ${entry.remote.url}`,
+            inputSchema: jsonSchemaForSchema(entry.schema, entry.jsonSchema),
+        })
+    }
+    return tools
+}
+
+/*
+MCP prompts derived from src/mcp/prompts. Arguments come from the
+prompt's schema (top-level properties + required flags); the model fills
+them in and the framework validates + renders on prompts/get.
+*/
+function buildPrompts(): Array<{
+    name: string
+    description?: string
+    arguments: Array<{ name: string; description?: string; required: boolean }>
+}> {
+    return Array.from(promptRegistry.values()).map((entry) => {
+        const jsonSchema = jsonSchemaForSchema(entry.schema, entry.jsonSchema)
+        const properties = (jsonSchema.properties ?? {}) as Record<string, { description?: string }>
+        const required = new Set((jsonSchema.required as string[] | undefined) ?? [])
+        return {
+            name: entry.prompt.name,
+            ...(entry.prompt.description ? { description: entry.prompt.description } : {}),
+            arguments: Object.entries(properties).map(([argName, prop]) => ({
+                name: argName,
+                ...(prop?.description ? { description: prop.description } : {}),
+                required: required.has(argName),
+            })),
+        }
+    })
+}
+
+/*
+Tool dispatch. Synthesizes a Request (with forwarded auth headers) and
+pipes it through verb.fetch — the same code path the HTTP router uses, so
+validation + handler + error helpers behave identically. Every rpc is a
+tool regardless of verb.
+*/
+async function callTool(
+    toolName: string,
+    args: Record<string, unknown> | undefined,
+    inbound: Request,
+): Promise<Record<string, unknown>> {
+    let found: ReturnType<(typeof verbRegistry)['get']> | undefined
+    for (const entry of verbRegistry.values()) {
+        if (!entry.clients.mcp) {
+            continue
+        }
+        if (commandNameForUrl(entry.remote.url) === toolName) {
+            found = entry
+            break
+        }
+    }
+    if (!found) {
+        throw new Error(`unknown tool: ${toolName}`)
+    }
+    const response = await runRpc(found.remote.method, found.remote.url, args, inbound)
+    if (!response.ok) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${response.status} ${response.statusText}: ${await response.text()}`,
+                },
+            ],
+            isError: true,
+        }
+    }
+    const body = await decodeResponse(response.clone())
+    return {
+        content: [
+            {
+                type: 'text',
+                text: typeof body === 'string' ? body : JSON.stringify(body),
+            },
+        ],
+    }
+}
+
+/*
+Synthesizes the rpc Request and dispatches through verb.fetch, forwarding
+the inbound MCP request's auth headers so session/bearer middleware keeps
+working. Shared by tool calls (non-GET) and resource reads (GET).
+*/
+function runRpc(
+    method: HttpVerb,
+    url: string,
+    args: Record<string, unknown> | undefined,
+    inbound: Request,
+): Promise<Response> {
+    const inboundUrl = new URL(inbound.url)
+    const baseUrl = `${inboundUrl.protocol}//${inboundUrl.host}/`
+    const request = buildRpcRequest({
+        method,
+        url,
+        args,
+        baseUrl,
+        headers: forwardHeaders(inbound.headers),
+    })
+    const entry = verbRegistry.get(url)
+    if (entry && entry.remote.method === method) {
+        return entry.remote.fetch(request)
+    }
+    throw new Error(`unknown rpc: ${method} ${url}`)
+}
+
+/*
+Validates prompt arguments against the prompt's schema (when present),
+renders the messages, and maps them to the MCP prompts/get wire shape.
+A bare string render result becomes a single user message.
+*/
+async function getPrompt(
+    name: string,
+    args: Record<string, unknown> | undefined,
+): Promise<Record<string, unknown>> {
+    const entry = promptRegistry.get(name)
+    if (!entry) {
+        throw new Error(`unknown prompt: ${name}`)
+    }
+    let value: unknown = args ?? {}
+    if (entry.schema) {
+        const result = await entry.schema['~standard'].validate(value)
+        if (result.issues) {
+            throw new Error(
+                `prompt "${name}" arguments failed validation: ${JSON.stringify(result.issues)}`,
+            )
+        }
+        value = result.value
+    }
+    const rendered = await entry.prompt.render(value as Record<string, string>)
+    const messages =
+        typeof rendered === 'string'
+            ? [{ role: 'user', content: { type: 'text', text: rendered } }]
+            : rendered.map((message) => ({
+                  role: message.role,
+                  content: { type: 'text', text: message.text },
+              }))
+    return {
+        ...(entry.prompt.description ? { description: entry.prompt.description } : {}),
+        messages,
+    }
+}
+
+/*
+Parses a single JSON-RPC envelope and dispatches by method. Errors
+become JSON-RPC error responses (the HTTP layer always returns 200 with
+an envelope for JSON-RPC over HTTP; transport errors are different).
+*/
+export async function dispatchMcpRequest(
+    request: Request,
+    opts: McpServerOptions,
+    serverInfo: { name: string; version: string },
+): Promise<JsonRpcResponse> {
+    let envelope: JsonRpcRequest
+    try {
+        envelope = (await request.clone().json()) as JsonRpcRequest
+    } catch {
+        return jsonRpcError(null, -32700, 'Parse error')
+    }
+    const id = envelope.id ?? null
+    if (envelope.jsonrpc !== '2.0' || typeof envelope.method !== 'string') {
+        return jsonRpcError(id, -32600, 'Invalid Request')
+    }
+
+    if (opts.authorize) {
+        try {
+            await opts.authorize(request)
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error)
+            return jsonRpcError(id, -32001, message)
+        }
+    }
+
+    try {
+        await ensureRegistriesLoaded()
+        switch (envelope.method) {
+            case 'initialize':
+                return jsonRpcOk(id, {
+                    protocolVersion: PROTOCOL_VERSION,
+                    capabilities: {
+                        tools: { listChanged: false },
+                        prompts: { listChanged: false },
+                        resources: { listChanged: false },
+                    },
+                    serverInfo,
+                })
+            case 'ping':
+                return jsonRpcOk(id, {})
+            case 'tools/list':
+                return jsonRpcOk(id, { tools: buildTools() })
+            case 'tools/call': {
+                const params = envelope.params as
+                    | { name?: string; arguments?: Record<string, unknown> }
+                    | undefined
+                if (!params?.name) {
+                    return jsonRpcError(id, -32602, 'Missing tool name')
+                }
+                return jsonRpcOk(id, await callTool(params.name, params.arguments, request))
+            }
+            case 'resources/list': {
+                const resourceServer = getMcpResourceServer()
+                return jsonRpcOk(id, {
+                    resources: resourceServer ? await resourceServer.list() : [],
+                })
+            }
+            case 'resources/read': {
+                const params = envelope.params as { uri?: string } | undefined
+                if (!params?.uri) {
+                    return jsonRpcError(id, -32602, 'Missing resource uri')
+                }
+                const resourceServer = getMcpResourceServer()
+                const contents = resourceServer ? await resourceServer.read(params.uri) : undefined
+                if (!contents) {
+                    return jsonRpcError(id, -32602, `unknown resource: ${params.uri}`)
+                }
+                return jsonRpcOk(id, { contents: [contents] })
+            }
+            case 'prompts/list':
+                return jsonRpcOk(id, { prompts: buildPrompts() })
+            case 'prompts/get': {
+                const params = envelope.params as
+                    | { name?: string; arguments?: Record<string, unknown> }
+                    | undefined
+                if (!params?.name) {
+                    return jsonRpcError(id, -32602, 'Missing prompt name')
+                }
+                return jsonRpcOk(id, await getPrompt(params.name, params.arguments))
+            }
+            default:
+                return jsonRpcError(id, -32601, `Method not found: ${envelope.method}`)
+        }
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        return jsonRpcError(id, -32603, message)
+    }
+}
+
+export const MCP_NO_STORE_HEADERS = {
+    'Content-Type': 'application/json',
+    'Cache-Control': NO_STORE,
+} as const

package/src/lib/mcp/mcpResourceServerSlot.ts

@@ -0,0 +1,18 @@
+import type { McpResourceServer } from './types/McpResourceServer.ts'
+
+/*
+Process-wide slot for the MCP resource server. createServer assigns it at
+boot; dispatchMcpRequest reads it on resources/list + resources/read. Mirrors
+the registryManifests slot — the default MCP server is constructed in the
+belte:mcp virtual with no args, so the resource server (which needs the
+project's resourcesDir + embedded map) is injected out of band.
+*/
+let resourceServer: McpResourceServer | undefined
+
+export function setMcpResourceServer(value: McpResourceServer): void {
+    resourceServer = value
+}
+
+export function getMcpResourceServer(): McpResourceServer | undefined {
+    return resourceServer
+}

package/src/lib/mcp/types/JsonRpcRequest.ts

@@ -0,0 +1,12 @@
+/*
+JSON-RPC 2.0 request frame as MCP delivers it over Streamable HTTP. The
+`id` is absent for notifications (which we don't currently receive from
+clients but accept silently). `method` is a string like "tools/list" or
+"resources/read".
+*/
+export type JsonRpcRequest = {
+    jsonrpc: '2.0'
+    id?: string | number
+    method: string
+    params?: Record<string, unknown>
+}

package/src/lib/mcp/types/JsonRpcResponse.ts

@@ -0,0 +1,20 @@
+/*
+JSON-RPC 2.0 response frame. Exactly one of `result` / `error` is set
+per request. The `id` echoes the inbound request id (null when the
+request id was malformed and the error is being returned).
+*/
+export type JsonRpcResponse =
+    | {
+          jsonrpc: '2.0'
+          id: string | number | null
+          result: unknown
+      }
+    | {
+          jsonrpc: '2.0'
+          id: string | number | null
+          error: {
+              code: number
+              message: string
+              data?: unknown
+          }
+      }

package/src/lib/mcp/types/McpResourceContents.ts

@@ -0,0 +1,10 @@
+/*
+One entry in an MCP resources/read result. Text-typed resources carry `text`;
+everything else carries base64 `blob` — exactly one is present.
+*/
+export type McpResourceContents = {
+    uri: string
+    mimeType: string
+    text?: string
+    blob?: string
+}

package/src/lib/mcp/types/McpResourceDescriptor.ts

@@ -0,0 +1,6 @@
+/* One entry in an MCP resources/list result — a file under src/mcp/resources. */
+export type McpResourceDescriptor = {
+    uri: string
+    name: string
+    mimeType: string
+}

package/src/lib/mcp/types/McpResourceServer.ts

@@ -0,0 +1,12 @@
+import type { McpResourceContents } from './McpResourceContents.ts'
+import type { McpResourceDescriptor } from './McpResourceDescriptor.ts'
+
+/*
+Serves the project's src/mcp/resources files to the MCP dispatcher. `list`
+backs resources/list; `read` backs resources/read and resolves to undefined
+for an unknown uri.
+*/
+export type McpResourceServer = {
+    list(): Promise<McpResourceDescriptor[]>
+    read(uri: string): Promise<McpResourceContents | undefined>
+}

package/src/lib/mcp/types/McpServer.ts

@@ -0,0 +1,9 @@
+/*
+Public shape returned by createMcpServer. The bun route handler at
+/__belte/mcp delegates inbound requests to `handle(request)`, which
+parses the JSON-RPC envelope, dispatches to tools/resources, and returns
+a Response carrying the JSON-RPC reply.
+*/
+export type McpServer = {
+    handle(request: Request): Promise<Response>
+}

package/src/lib/mcp/types/McpServerOptions.ts

@@ -0,0 +1,16 @@
+/*
+User-facing options for createMcpServer. All fields optional — the
+zero-arg call works for any belte project (server info is derived from
+package.json by the bundler when MCP is wired into createServer).
+
+- `name` / `version`: identify the server in the MCP `initialize`
+  response. Defaults come from the project's package.json.
+- `authorize`: optional boundary check. Runs once per MCP request before
+  any tool/resource dispatch. Throw HttpError (or any Error) to reject.
+  Per-tool authorization stays in the underlying verb handler.
+*/
+export type McpServerOptions = {
+    name?: string
+    version?: string
+    authorize?: (request: Request) => Promise<void> | void
+}

package/src/lib/server/AppModule.ts

@@ -0,0 +1,25 @@
+import type { Server } from 'bun'
+
+/*
+Optional hooks exported from src/app.ts. All hooks are optional; defaults
+kick in when an export is missing. init returns an optional cleanup
+function that runs on SIGINT/SIGTERM. handle is single-middleware with
+next so user code can mutate the response or branch on the URL.
+
+WebSockets are not exposed here — belte's only native WebSocket
+surface is the sockets hub (see `belte/sockets`), multiplexed onto a
+single framework-owned connection per client at `/__belte/sockets`.
+Inside request scopes, the live Bun.Server is reachable via the
+exported `server` proxy from `belte/server`; `init` receives it
+explicitly because it runs outside a request.
+*/
+export type AppModule = {
+    init?: (ctx: {
+        server: Server<unknown>
+    }) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)>
+    handle?: (
+        request: Request,
+        next: (req: Request) => Promise<Response>,
+    ) => Promise<Response> | Response
+    handleError?: (error: unknown, request: Request) => Promise<Response> | Response
+}

package/src/lib/server/DELETE.ts

@@ -0,0 +1,9 @@
+import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import { unprocessed } from './rpc/unprocessed.ts'
+
+/*
+DELETE verb helper. The bundler rewrites every `export const x = DELETE(fn)` inside
+`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+remoteProxy stub (client target). Calling this directly throws.
+*/
+export const DELETE: VerbHelper = (_fn: any, _opts?: any) => unprocessed('DELETE')

package/src/lib/server/GET.ts

@@ -0,0 +1,9 @@
+import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import { unprocessed } from './rpc/unprocessed.ts'
+
+/*
+GET verb helper. The bundler rewrites every `export const x = GET(fn)` inside
+`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+remoteProxy stub (client target). Calling this directly throws.
+*/
+export const GET: VerbHelper = (_fn: any, _opts?: any) => unprocessed('GET')

package/src/lib/server/HEAD.ts

@@ -0,0 +1,9 @@
+import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import { unprocessed } from './rpc/unprocessed.ts'
+
+/*
+HEAD verb helper. The bundler rewrites every `export const x = HEAD(fn)` inside
+`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+remoteProxy stub (client target). Calling this directly throws.
+*/
+export const HEAD: VerbHelper = (_fn: any, _opts?: any) => unprocessed('HEAD')

package/src/lib/server/HttpError.ts

@@ -0,0 +1,19 @@
+/*
+Thrown by remote-function calls when the server responds with a non-2xx
+status. Carries the raw Response so callers can inspect body, headers, or
+status text — useful for showing user-friendly error UI without having to
+opt every call site into the `.raw()` escape hatch.
+*/
+export class HttpError extends Error {
+    readonly status: number
+    readonly statusText: string
+    readonly response: Response
+
+    constructor(response: Response) {
+        super(`HTTP ${response.status} ${response.statusText || 'error'}`)
+        this.name = 'HttpError'
+        this.status = response.status
+        this.statusText = response.statusText
+        this.response = response
+    }
+}

package/src/lib/server/PATCH.ts

@@ -0,0 +1,9 @@
+import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import { unprocessed } from './rpc/unprocessed.ts'
+
+/*
+PATCH verb helper. The bundler rewrites every `export const x = PATCH(fn)` inside
+`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+remoteProxy stub (client target). Calling this directly throws.
+*/
+export const PATCH: VerbHelper = (_fn: any, _opts?: any) => unprocessed('PATCH')

package/src/lib/server/POST.ts

@@ -0,0 +1,9 @@
+import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import { unprocessed } from './rpc/unprocessed.ts'
+
+/*
+POST verb helper. The bundler rewrites every `export const x = POST(fn)` inside
+`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+remoteProxy stub (client target). Calling this directly throws.
+*/
+export const POST: VerbHelper = (_fn: any, _opts?: any) => unprocessed('POST')

package/src/lib/server/PUT.ts

@@ -0,0 +1,9 @@
+import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import { unprocessed } from './rpc/unprocessed.ts'
+
+/*
+PUT verb helper. The bundler rewrites every `export const x = PUT(fn)` inside
+`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+remoteProxy stub (client target). Calling this directly throws.
+*/
+export const PUT: VerbHelper = (_fn: any, _opts?: any) => unprocessed('PUT')