@belte/belte 0.19.0

package/src/lib/server/redirect.ts

@@ -0,0 +1,42 @@
+/*
+Redirect Response with belte-friendly ergonomics — accepts relative
+URLs (the platform's `Response.redirect` throws on them), defaults to
+302, and matches the helper-style call site of `json`/`error` for
+visual consistency inside a handler.
+
+  return redirect('/login')              // 302 to /login
+  return redirect('/articles/1', 301)    // permanent
+  return redirect(externalUrl, 307)      // preserve method (POST stays POST)
+
+Status guidance:
+- 301 — moved permanently (cacheable; browsers may swap method to GET)
+- 302 — found / temporary (default; browsers may swap method to GET)
+- 303 — "after a POST, GET this" (forces GET on the follow-up)
+- 307 — temporary, preserve method
+- 308 — permanent, preserve method
+
+A final `ResponseInit` adds headers (e.g. a `Set-Cookie` on the redirect);
+the positional `status` always wins over any `init.status`.
+*/
+import { NO_STORE } from '../shared/CACHE_CONTROL_VALUES.ts'
+import type { TypedResponse } from './rpc/types/TypedResponse.ts'
+import { withResponseDefaults } from './runtime/withResponseDefaults.ts'
+
+type RedirectStatus = 301 | 302 | 303 | 307 | 308
+
+/*
+Return type is `TypedResponse<never>` for the same reason `error()` is —
+the wire response is a 3xx with no body the caller resolves to, so it
+must not pollute the inferred `Return` of a route that conditionally
+redirects vs returns json.
+*/
+export function redirect(
+    url: string,
+    status: RedirectStatus = 302,
+    init?: ResponseInit,
+): TypedResponse<never> {
+    return new Response(
+        null,
+        withResponseDefaults(init, { Location: url, 'Cache-Control': NO_STORE }, status),
+    ) as TypedResponse<never>
+}

package/src/lib/server/request.ts

@@ -0,0 +1,18 @@
+import { requestContext } from './runtime/requestContext.ts'
+
+/*
+Returns the inbound Request for the current SSR/RPC pass. Implemented as an
+AsyncLocalStorage lookup over the per-request store the server installs at
+the fetch boundary. Throws if called outside a request scope (e.g. from
+top-level module code or from app.ts init) — silent undefined would mask
+the misuse.
+*/
+export function request(): Request {
+    const store = requestContext.getStore()
+    if (!store) {
+        throw new Error(
+            '[belte] request() called outside a request scope — it only resolves while an SSR render or rpc handler is in flight',
+        )
+    }
+    return store.req
+}

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

@@ -0,0 +1,133 @@
+import { buildRpcRequest } from '../../shared/buildRpcRequest.ts'
+import { createRemoteFunction } from '../../shared/createRemoteFunction.ts'
+import { forwardHeaders } from '../../shared/forwardHeaders.ts'
+import { isReadOnlyMethod } from '../../shared/isReadOnlyMethod.ts'
+import { resolveClientFlags } from '../../shared/resolveClientFlags.ts'
+import type { ClientFlags } from '../../shared/types/ClientFlags.ts'
+import type { HttpVerb } from '../../shared/types/HttpVerb.ts'
+import type { RemoteFunction } from '../../shared/types/RemoteFunction.ts'
+import type { StandardSchemaV1 } from '../../shared/types/StandardSchemaV1.ts'
+import { json } from '../json.ts'
+import { requestContext } from '../runtime/requestContext.ts'
+import { parseArgs } from './parseArgs.ts'
+import { registerVerb } from './registerVerb.ts'
+import type { RemoteHandler } from './types/RemoteHandler.ts'
+
+/*
+Builds a RemoteFunction from an HTTP verb + RPC URL + handler. The bundler
+rewrites every `export const VERB = handler(fn)` inside an `$rpc/**` module
+so the verb (from the export name) and the URL (from the file path under
+`src/server/rpc/`, with `/rpc/` prefix) are threaded into defineVerb.
+
+The plain call (`fn(args)`) resolves to the Content-Type-decoded body;
+non-2xx responses throw HttpError. `.raw(args)` returns the underlying
+Response for callers that need status/headers/body streaming.
+`.fetch(req)` is the dispatch hook the framework's router uses to
+invoke the handler from an incoming HTTP request (with args parsed off
+the Request via parseArgs).
+
+Every raw invocation records the synthesized Request against the returned
+promise so cache() can stash it on the entry without re-building.
+*/
+export function defineVerb<Args, Return>(
+    method: HttpVerb,
+    url: string,
+    handler: RemoteHandler<Args, Return>,
+    opts?: {
+        inputSchema?: StandardSchemaV1
+        outputSchema?: StandardSchemaV1
+        filesSchema?: StandardSchemaV1
+        clients?: Partial<ClientFlags>
+    },
+): RemoteFunction<Args, Return> {
+    const inputSchema = opts?.inputSchema
+    const outputSchema = opts?.outputSchema
+    const filesSchema = opts?.filesSchema
+    /*
+    An input schema makes the handler safe to advertise to non-browser
+    surfaces. CLI flips on for any verb with one (a human/script invokes it
+    deliberately). MCP only auto-exposes read-only verbs (GET/HEAD) — a
+    model shouldn't be able to mutate/delete just because the handler
+    carries a schema, so mutating verbs require an explicit clients.mcp.
+    Explicit `clients` always wins.
+    */
+    const hasSchema = inputSchema !== undefined
+    const clients = resolveClientFlags(opts?.clients, {
+        mcp: hasSchema && isReadOnlyMethod(method),
+        cli: hasSchema,
+    })
+
+    function buildRequest(args: Args | undefined): Request {
+        const store = requestContext.getStore()
+        const baseUrl = store ? store.url.href : 'http://localhost/'
+        const headers = store ? forwardHeaders(store.req.headers) : new Headers()
+        return buildRpcRequest({ method, url, args, baseUrl, headers })
+    }
+
+    /*
+    Handler bodies may throw synchronously (e.g. an `assert(...)` at the
+    top of the function). The `async function` wrapper coerces both sync
+    throws and returned non-promises into the Promise<Response> shape
+    callers expect, so an SSR caller's `await` always sees the rejection
+    through the cache layer's snapshot boundary instead of the error
+    escaping the request scope.
+    */
+    async function runHandler(args: Args | undefined): Promise<Response> {
+        return handler(args as Args) as unknown as Response
+    }
+
+    /*
+    Validates the parsed args against inputSchema (text fields), then — when the
+    verb declares filesSchema — validates the File parts parseArgs split onto
+    the request store and merges them into the args bag the handler receives.
+    Either schema's issues become a 422. Files stay out of inputSchema so its
+    JSON-Schema projection (OpenAPI/MCP/CLI) never has to model a binary.
+    */
+    async function validateThenHandle(args: Args | undefined): Promise<Response> {
+        let value: unknown = args
+        if (inputSchema) {
+            const result = await inputSchema['~standard'].validate(value)
+            if (result.issues) {
+                return json({ issues: result.issues }, { status: 422 })
+            }
+            value = result.value
+        }
+        if (filesSchema) {
+            const files = requestContext.getStore()?.files ?? {}
+            const result = await filesSchema['~standard'].validate(files)
+            if (result.issues) {
+                return json({ issues: result.issues }, { status: 422 })
+            }
+            value = { ...(value as object), ...(result.value as object) }
+        }
+        return runHandler(value as Args)
+    }
+
+    /*
+    `getRequest` is unused on the server path — handlers receive parsed
+    `args` directly and reach the inbound Request via `request()`.
+    createRemoteFunction passes a thunk so the client side can lazily
+    synthesize its Request without forcing the server to allocate one per
+    SSR call.
+    */
+    function invoke(args: Args | undefined): Promise<Response> {
+        return inputSchema || filesSchema ? validateThenHandle(args) : runHandler(args)
+    }
+
+    const remote = createRemoteFunction<Args, Return>({
+        method,
+        url,
+        clients,
+        buildRequest,
+        invoke,
+        parseArgsForFetch: (request) => parseArgs(method, request) as Promise<Args | undefined>,
+    })
+    registerVerb({
+        remote: remote as RemoteFunction<unknown, unknown>,
+        inputSchema,
+        outputSchema,
+        filesSchema,
+        clients,
+    })
+    return remote
+}

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

@@ -0,0 +1,46 @@
+import { buildRpcRequest } from '../../shared/buildRpcRequest.ts'
+import type { AppModule } from '../AppModule.ts'
+import { runWithRequestScope } from '../runtime/runWithRequestScope.ts'
+import type { VerbRegistryEntry } from './types/VerbRegistryEntry.ts'
+
+/*
+Runs a registered verb in-process: synthesizes the rpc Request from the
+entry's own method + url and pipes it through entry.remote.fetch — the
+same handler/validation/error path the HTTP router uses, no network hop.
+The single in-process dispatch every registry-backed consumer surface (the
+CLI client, the MCP tool dispatcher, and the test client) routes through, so
+they can't drift on how a verb is invoked. `baseUrl` gives the synthetic
+Request its origin (handlers reading request.url see the caller's host);
+`headers` carries forwarded auth/identity context.
+
+Runs inside the runWithRequestScope seam createServer crosses for real
+requests, so a handler sees an identical scope to a live HTTP request: a fresh
+per-request cache, the cookie jar with Set-Cookie flush, request()/server()
+resolution, and the app's handleError (or the 500 fallback) on a throw. The
+synthesized Request is shared between the scope store and the handler fetch so
+request() returns the same Request parseArgs read from.
+*/
+export function dispatchVerbInProcess({
+    entry,
+    args,
+    baseUrl,
+    headers,
+    app,
+}: {
+    entry: VerbRegistryEntry
+    args: unknown
+    baseUrl: string
+    headers?: Headers
+    app?: AppModule
+}): Promise<Response> {
+    const request = buildRpcRequest({
+        method: entry.remote.method,
+        url: entry.remote.url,
+        args,
+        baseUrl,
+        headers,
+    })
+    return runWithRequestScope(request, { app, logRequests: false }, () =>
+        entry.remote.fetch(request),
+    )
+}

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

@@ -0,0 +1,18 @@
+import { commandNameForUrl } from '../../shared/commandNameForUrl.ts'
+import type { VerbRegistryEntry } from './types/VerbRegistryEntry.ts'
+import { verbRegistry } from './verbRegistry.ts'
+
+/*
+Finds the registered verb whose URL maps to a given command name (folder
+segments joined with `-`, per commandNameForUrl). The CLI client proxy and
+the MCP tool dispatcher both key off this name, so the scan lives here once
+rather than being re-implemented — and reused — at each call site.
+*/
+export function findVerbByCommandName(name: string): VerbRegistryEntry | undefined {
+    for (const entry of verbRegistry.values()) {
+        if (commandNameForUrl(entry.remote.url) === name) {
+            return entry
+        }
+    }
+    return undefined
+}

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

@@ -0,0 +1,95 @@
+import { carriesBodyArgs } from '../../shared/carriesBodyArgs.ts'
+import type { HttpVerb } from '../../shared/types/HttpVerb.ts'
+import { requestContext } from '../runtime/requestContext.ts'
+
+/*
+Splits a parsed FormData into the text fields that become args and the File
+parts that don't. Repeated text keys collapse into an array (an HTML form posts
+multiple same-named inputs); File parts group by field name and stash on the
+request store for files() to read — they never enter args, so the input schema
+keeps validating a plain object with no binary in it.
+*/
+function splitFormData(form: FormData): Record<string, unknown> {
+    const fileMap: Record<string, File[]> = {}
+    const fields: Record<string, unknown> = {}
+    for (const [key, value] of form) {
+        if (value instanceof File) {
+            fileMap[key] ??= []
+            fileMap[key].push(value)
+            continue
+        }
+        const existing = fields[key]
+        if (!(key in fields)) {
+            fields[key] = value
+        } else if (Array.isArray(existing)) {
+            existing.push(value)
+        } else {
+            fields[key] = [existing, value]
+        }
+    }
+    const store = requestContext.getStore()
+    if (store && Object.keys(fileMap).length > 0) {
+        store.files = fileMap
+    }
+    return fields
+}
+
+/*
+Parses + merges every source of args available for a verb-defined handler:
+- body (json or form-encoded, ignored for GET/DELETE/HEAD)
+- url query string
+
+When both are present and the body is a plain object, the merge layers the
+body on top of the query so the typed body wins on collision — the query
+supplies defaults a body field can override, and a URL param can't silently
+shadow a validated body value. A non-object body (array, primitive, null)
+skips the merge entirely and is returned as-is — there's no key on the body
+to layer the query into, and the framework's args type is a single bag rather
+than a `{body, query}` envelope. Returns undefined when no source contributes
+any key.
+*/
+export async function parseArgs(method: HttpVerb, request: Request): Promise<unknown> {
+    /*
+    Skip the URL parse entirely when the raw request URL has no query —
+    typical POST/PUT/PATCH calls land here with a flat rpc URL and no
+    `?…`, so the `new URL(...)` constructor cost (which dwarfs the
+    indexOf check) is wasted work.
+    */
+    const queryStart = request.url.indexOf('?')
+    const hasQuery = queryStart !== -1
+    const url = hasQuery ? new URL(request.url) : undefined
+
+    let body: unknown
+    if (carriesBodyArgs(method)) {
+        const contentType = (request.headers.get('content-type') ?? '').toLowerCase()
+        if (contentType.includes('application/json')) {
+            const text = await request.text()
+            if (text !== '') {
+                body = JSON.parse(text)
+            }
+        } else if (
+            contentType.includes('application/x-www-form-urlencoded') ||
+            contentType.includes('multipart/form-data')
+        ) {
+            body = splitFormData(await request.formData())
+        }
+    }
+
+    if (body !== undefined && (typeof body !== 'object' || body === null || Array.isArray(body))) {
+        return body
+    }
+
+    if (!url) {
+        if (body === undefined) {
+            return undefined
+        }
+        return body
+    }
+
+    const bodyObject = (body ?? {}) as Record<string, unknown>
+    const merged = { ...Object.fromEntries(url.searchParams), ...bodyObject }
+    if (Object.keys(merged).length === 0) {
+        return undefined
+    }
+    return merged
+}

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

@@ -0,0 +1,6 @@
+import type { VerbRegistryEntry } from './types/VerbRegistryEntry.ts'
+import { verbRegistry } from './verbRegistry.ts'
+
+export function registerVerb(entry: VerbRegistryEntry): void {
+    verbRegistry.set(entry.remote.url, entry)
+}

package/src/lib/server/rpc/types/RemoteHandler.ts

@@ -0,0 +1,27 @@
+import type { TypedResponse } from './TypedResponse.ts'
+
+/*
+Handler signature for verb-defined remote functions. Args is `undefined` for
+GETs/DELETEs with no query, JSON-shaped objects for json bodies, and
+form-shaped objects for form-encoded bodies. For a multipart upload it's the
+text fields (`inputSchema`) intersected with the validated File parts
+(`filesSchema`), merged into one bag. For a raw binary body Args is `undefined`
+— read the stream via `request()` from `belte/server` instead.
+
+Return is the value type the call site sees after Content-Type-driven
+decoding (a parsed object for JSON, a string for text/*, a Blob otherwise,
+`undefined` for 204). The handler must return a Response at runtime; the
+`TypedResponse<Return>` brand on `json`/`error`/`redirect`/`jsonl`/`sse`
+carries the body shape through the function's inferred return type so the
+verb helper can infer `Return` automatically — no need to annotate
+`GET<Args, Return>` when the handler returns one of the respond helpers.
+A bare `new Response(...)` is still acceptable: the brand is optional, so
+untagged Responses fall back to `Return = unknown`.
+
+Handlers that need the inbound Request (headers, `request.signal`, …) read
+it via `request()` from `belte/server` rather than a handler parameter, so
+the signature stays a single parsed-`args` bag.
+*/
+export type RemoteHandler<Args, Return> = (
+    args: Args,
+) => TypedResponse<Return> | Promise<TypedResponse<Return>>

package/src/lib/server/rpc/types/RemoteRoutes.ts

@@ -0,0 +1,13 @@
+import type { RemoteFunction } from '../../../shared/types/RemoteFunction.ts'
+
+/*
+Manifest of RPC URL → module loader. Produced by the resolver plugin from
+every `.ts` under src/server/rpc — each file maps to one URL (derived from its
+path under `$rpc`, prefixed with `/rpc/`). Each module has exactly one
+named export, a RemoteFunction whose `.method` and `.url` were stamped in
+by the bundler rewrite.
+*/
+export type RemoteRoutes = Record<
+    string,
+    () => Promise<Record<string, RemoteFunction<unknown, unknown>>>
+>

package/src/lib/server/rpc/types/TypedResponse.ts

@@ -0,0 +1,18 @@
+/*
+A `Response` tagged with the body type the framework will hand back to
+callers after Content-Type-driven decoding. The tag is phantom — it
+adds no runtime field, only a type-level slot so the verb helpers can
+infer `Return` from the handler's return type instead of forcing every
+route to annotate it via `GET<Args, Return>`.
+
+The respond helpers (`json<T>`, `error`, `redirect`, `jsonl<F>`,
+`sse<F>`) all return a `TypedResponse<T>`, so a handler ending in
+`return json({ user })` exposes `{ user: ... }` as its body type; the
+verb overload picks it up via `RemoteHandler<Args, Return>`.
+
+`T` is optional on the brand so a plain `new Response(...)` (untagged)
+remains assignable to `TypedResponse<unknown>`; in that case `Return`
+just falls back to its `unknown` default, matching pre-existing
+behaviour for handlers that build Responses by hand.
+*/
+export type TypedResponse<T> = Response & { readonly __body?: T }

package/src/lib/server/rpc/types/VerbHelper.ts

@@ -0,0 +1,68 @@
+import type { ClientFlags } from '../../../shared/types/ClientFlags.ts'
+import type { RemoteFunction } from '../../../shared/types/RemoteFunction.ts'
+import type { StandardSchemaV1 } from '../../../shared/types/StandardSchemaV1.ts'
+import type { RemoteHandler } from './RemoteHandler.ts'
+
+/*
+Shared signature for every verb helper (GET / POST / …). Three overloads:
+
+  - `Verb(fn, { inputSchema, outputSchema?, clients? })` — `Args` infers
+    from `InferInput<InputSchema>`, the handler receives
+    `InferOutput<InputSchema>`. Generic order is `<Return, InputSchema>` so
+    users can override `Return` while letting `InputSchema` infer from
+    `opts.inputSchema`. `outputSchema` is an optional Standard Schema for
+    the success body — it feeds the OpenAPI 200 response and the MCP tool
+    `outputSchema`. JSON Schema is projected from each schema's own
+    `toJSONSchema()` (wrap with withJsonSchema if the library lacks one).
+    `clients` controls which surfaces (browser / mcp / cli) expose this verb.
+  - `Verb(fn, { clients })` — schemaless but with explicit client
+    targeting (e.g. server-internal RPC with `clients: { browser: false }`).
+  - `Verb(fn)` — bare handler. `Args` and `Return` come from the handler
+    type; `Return` is usually inferred via the `TypedResponse<T>` brand on
+    `json`/`error`/`redirect`/`jsonl`/`sse`.
+*/
+export type VerbHelper = {
+    /*
+    `Verb(fn, { inputSchema, filesSchema, … })` — multipart upload. The
+    handler receives the text fields (`InferOutput<InputSchema>`) intersected
+    with the validated File parts (`InferOutput<FilesSchema>`); both are merged
+    into one args bag. The call site sends a FormData (RemoteFunction's call
+    accepts it), since a File can't ride a JSON body. filesSchema stays off the
+    JSON-Schema projection — a File has no honest conversion (see
+    jsonSchemaForSchema) — so only inputSchema feeds MCP/CLI/OpenAPI.
+    */
+    <
+        Return = unknown,
+        InputSchema extends StandardSchemaV1 = StandardSchemaV1,
+        FilesSchema extends StandardSchemaV1 = StandardSchemaV1,
+    >(
+        fn: RemoteHandler<
+            StandardSchemaV1.InferOutput<InputSchema> & StandardSchemaV1.InferOutput<FilesSchema>,
+            Return
+        >,
+        opts: {
+            inputSchema: InputSchema
+            filesSchema: FilesSchema
+            outputSchema?: StandardSchemaV1
+            clients?: Partial<ClientFlags>
+        },
+    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, Return>
+    <Return = unknown, InputSchema extends StandardSchemaV1 = StandardSchemaV1>(
+        fn: RemoteHandler<StandardSchemaV1.InferOutput<InputSchema>, Return>,
+        opts: {
+            inputSchema: InputSchema
+            outputSchema?: StandardSchemaV1
+            clients?: Partial<ClientFlags>
+        },
+    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, Return>
+    <Args = undefined, Return = unknown>(
+        fn: RemoteHandler<Args, Return>,
+        opts: {
+            outputSchema?: StandardSchemaV1
+            clients: Partial<ClientFlags>
+        },
+    ): RemoteFunction<Args, Return>
+    <Args = undefined, Return = unknown>(
+        fn: RemoteHandler<Args, Return>,
+    ): RemoteFunction<Args, Return>
+}

package/src/lib/server/rpc/types/VerbRegistryEntry.ts

@@ -0,0 +1,29 @@
+import type { ClientFlags } from '../../../shared/types/ClientFlags.ts'
+import type { RemoteFunction } from '../../../shared/types/RemoteFunction.ts'
+import type { StandardSchemaV1 } from '../../../shared/types/StandardSchemaV1.ts'
+
+/*
+Per-verb registry record on the server side. MCP and CLI enumerate this
+to discover which RPCs are advertised (clients flags) and what shapes
+they expect/return. The schemas and resolved clients stay off the public
+RemoteFunction shape so the browser-side proxy doesn't need to carry
+server-only state.
+
+`inputSchema` validates the argument bag and feeds the MCP tool
+`inputSchema` / OpenAPI parameters; `outputSchema` describes the success
+body and feeds the OpenAPI 200 response + MCP tool `outputSchema`. Each
+projects to JSON Schema via its own `toJSONSchema()` (jsonSchemaForSchema) —
+schemas whose library lacks one are wrapped with withJsonSchema.
+
+`filesSchema` validates the File parts of a multipart body, kept separate
+from `inputSchema` because a File has no honest JSON-Schema conversion — it
+stays out of the MCP/CLI projection that `inputSchema` feeds, and the OpenAPI
+multipart body advertises the file parts generically as binary.
+*/
+export type VerbRegistryEntry = {
+    remote: RemoteFunction<unknown, unknown>
+    inputSchema: StandardSchemaV1 | undefined
+    outputSchema: StandardSchemaV1 | undefined
+    filesSchema: StandardSchemaV1 | undefined
+    clients: ClientFlags
+}

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

@@ -0,0 +1,14 @@
+import type { RemoteFunction } from '../../shared/types/RemoteFunction.ts'
+
+/*
+Verb helpers (GET / POST / …) are placeholders — the bundler rewrites every
+`export const x = GET(fn)` inside `src/server/rpc/<file>.ts` into a call to
+defineVerb (server target) or remoteProxy (client target). If a call slips
+through, the bundler plugin didn't process the file; throwing here surfaces
+that cleanly instead of silently returning undefined.
+*/
+export function unprocessed<Args, Return>(verb: string): RemoteFunction<Args, Return> {
+    throw new Error(
+        `[belte] \`${verb}\` was called outside an $rpc module — verb helpers are only valid as the value of \`export const <filename> = ...\` inside a file under src/server/rpc/`,
+    )
+}

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

@@ -0,0 +1,11 @@
+import type { VerbRegistryEntry } from './types/VerbRegistryEntry.ts'
+
+/*
+Process-wide registry of every verb-bound RPC declared in the app.
+defineVerb inserts on first construction (which happens at module-load
+time inside the rpc dispatcher cache or eagerly when MCP / CLI walks the
+rpc manifest). MCP server reads this to build its tools list; the CLI
+binary reads it to generate subcommands. The browser path never touches
+this — the client stub has no schema or clients metadata to register.
+*/
+export const verbRegistry = new Map<string, VerbRegistryEntry>()

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

@@ -0,0 +1,6 @@
+/*
+The port scanning starts from when no PORT is configured. Every selector (the
+real listener, the embedded launcher, the dev orchestrator) scans upward from
+here so all modes land on the same predictable 3000+ address.
+*/
+export const DEFAULT_PORT = 3000

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

@@ -0,0 +1,4 @@
+// IPC payload the dev server sends its orchestrator parent (via process.send) to
+// request a rebuild + restart. Shared so producer (createServer) and consumer
+// (devEntry) can't drift.
+export const DEV_REBUILD_MESSAGE = 'belte:reload'

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

@@ -0,0 +1,29 @@
+/*
+Dev-only live-reload client, injected into the served shell when the server
+runs under `belte dev`. It opens an EventSource to /__belte/dev and reloads on
+*reconnect*: the channel only drops when the dev orchestrator restarts the
+server after a rebuild, so re-establishing the connection is the signal that
+fresh code is being served. The first open is the initial page load (no
+reload); every open after that is a restart. Self-managed retry keeps the gap
+short instead of relying on EventSource's multi-second default backoff.
+*/
+export const DEV_RELOAD_CLIENT_SCRIPT = `<script>
+;(() => {
+  let opened = false
+  function connect() {
+    const source = new EventSource('/__belte/dev')
+    source.onopen = () => {
+      if (opened) {
+        location.reload()
+        return
+      }
+      opened = true
+    }
+    source.onerror = () => {
+      source.close()
+      setTimeout(connect, 250)
+    }
+  }
+  connect()
+})()
+</script>`

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

@@ -0,0 +1,8 @@
+/*
+Whether the client advertised zstd in Accept-Encoding. Both static-asset
+servers (the `/_app/` chunk server and the public/ server) gate their
+pre-compressed responses on this, so the check lives in one place.
+*/
+export function acceptsZstd(req: Request): boolean {
+    return (req.headers.get('accept-encoding') ?? '').toLowerCase().includes('zstd')
+}