@solidjs/web 2.0.0-beta.21 → 2.0.0-beta.23

package/types-cjs/frames/frame-sink.d.cts

@@ -0,0 +1,145 @@
+import { FrameChunk } from "./frame-client.cjs";
+
+/** Addresses a frame stream: the boundary id and this response's version. */
+export interface FrameAddress {
+  id: string;
+  version: number;
+}
+
+/**
+ * The emission surface `renderToStream` routes through when producing a
+ * frame stream instead of a document (see the `sink` render option). Each
+ * method emits transport-agnostic chunks; `emit` is the envelope boundary.
+ * @internal Compiler/renderer wiring — use `renderToFrameStream` or
+ * `renderServerComponent` instead.
+ */
+export function createFrameSink(
+  emit: (chunk: FrameChunk) => void,
+  frame: FrameAddress
+): Record<string, (...args: any[]) => void>;
+
+/** Options shared by the frame producers. */
+export interface FrameStreamOptions {
+  /** Boundary address; defaults to `{ id: "", version: 1 }`. */
+  frame?: { id?: string; version?: number };
+  /** Remaining `renderToStream` options (plugins, onError, manifest, ...). */
+  [key: string]: unknown;
+}
+
+/** A produced frame stream: pipe chunks, or await the collected array. */
+export interface FrameStream extends PromiseLike<FrameChunk[]> {
+  pipe(writable: { write(chunk: FrameChunk): void; end?(): void }): void;
+}
+
+/**
+ * Render to a FrameChunk stream: the same render core as `renderToStream`
+ * with emission swapped to the frame sink and the document writable replaced
+ * by a chunk envelope (`start` up front, `complete` at stream end). Data
+ * records default to the keyed JSON codec (decode with
+ * `createJSONDataTable`).
+ */
+export function renderToFrameStream(code: () => unknown, options?: FrameStreamOptions): FrameStream;
+
+/**
+ * Render a **server component** — a `props => JSX` function, typically
+ * returned from a server function — to a FrameChunk stream. `props` is a
+ * slot-props proxy, not data:
+ *
+ * - reading a prop as a child emits a marker range the client fills;
+ * - calling a prop as a render function emits a `slot` chunk for a fresh
+ *   occurrence (a primitive `$key` arg names it, so client state follows the
+ *   entity across responses — the slot-level analogue of For's `keyed`
+ *   function; positional otherwise, which is the right default for most
+ *   flows);
+ * - primitive args ride the chunk; server JSX args stream as nested regions
+ *   (`{$frame}` — html once, never data); other values serialize as `{$ref}`
+ *   data records with referential dedupe.
+ *
+ * The props a *client* passes never reach the server — server inputs are the
+ * function's arguments.
+ */
+export function renderServerComponent(
+  component: (props: Record<string, any>) => unknown,
+  options?: FrameStreamOptions
+): FrameStream;
+
+/**
+ * The slot props proxy used by `renderServerComponent`. Every key
+ * virtually exists (`in` is always true — a prop is a position the client
+ * may fill), enumeration is empty by design, and serialization goes through
+ * the live render context, so it must only be used during the frame's
+ * render.
+ * @internal Exposed for framework bindings composing their own producers.
+ */
+export function createSlotProps(
+  sink: ReturnType<typeof createFrameSink>,
+  frame: FrameAddress
+): Record<string, any>;
+
+/**
+ * A server component as an HTTP Response: the chunk stream framed with the
+ * server-function wire convention, tagged `X-Frame-Stream: <frame id>` for
+ * the client and `X-Content-Raw` so the server-function handler forwards it
+ * untouched. `init` (headers/status, e.g. from a `respond()` envelope)
+ * merges in; the frame tags win on conflict.
+ */
+export function serverComponentResponse(
+  component: (props: Record<string, any>) => unknown,
+  options?: FrameStreamOptions,
+  init?: { headers?: HeadersInit; status?: number }
+): Response;
+
+/**
+ * The server-component convention as a `transformResult` policy for
+ * `handleServerFunctionRequest`: a function result — or a `respond()`
+ * envelope whose value is a function — becomes a frame-stream Response,
+ * with the frame id defaulting to the server function's id so repeat calls
+ * target the same client boundary. Everything else passes through.
+ *
+ * @example
+ * ```ts
+ * handleServerFunctionRequest(request, {
+ *   transformResult: frameTransformResult,
+ *   provideEvent
+ * });
+ * ```
+ */
+export function frameTransformResult(event: unknown, result: unknown): unknown;
+
+// === Document SSR (t = 0) ===
+
+/**
+ * Document-mode slot props — the t = 0 counterpart of
+ * `createSlotProps`: the server component renders INLINE in the
+ * document and the client's real props render server-side inside its
+ * positions (the one hydration-time exception), wrapped in the same marker
+ * dialect the chunk producer emits so the adopting client binds slots and
+ * regions onto the server-rendered ranges.
+ */
+export function createDocumentSlotProps(
+  clientProps: Record<string, unknown>,
+  frameId: string
+): Record<string, unknown>;
+
+/**
+ * The in-process mirror of `frameTransformResult` for DOCUMENT SSR: install
+ * as `configureServerFunctionsServer({ transformDirectResult })` and a
+ * direct (same-process) server-function result that is a function comes back
+ * as an inline-renderable server component (frame markers + document
+ * slot props). Non-function results pass through.
+ */
+export function frameTransformDirectResult<T>(value: T, options: { id: string }): T;
+
+/**
+ * Seroval plugin for the hydration serializer: writes an inline server
+ * component as a stable per-function-id placeholder reference
+ * (`self._$SC.r(id)`) instead of meeting an unserializable function.
+ */
+export const ServerComponentPlugin: unknown;
+
+/**
+ * Inline bootstrap for the document shell: installs the `self._$SC`
+ * placeholder registry the hydration references resolve through; the client
+ * upgrades it via `installServerComponents()`.
+ */
+export const SERVER_COMPONENT_BOOTSTRAP: string;

package/types-cjs/frames/frame-transport.d.cts

@@ -0,0 +1,105 @@
+import { FrameChunk, FrameHost } from "./frame-client.cjs";
+
+/**
+ * Header tagging a Response as a frame stream; its value is the producing
+ * frame's id. Frame-owned wire contract — deliberately not a server-function
+ * `BodyFormat` entry, since the body is frame chunks, not a serialized value.
+ */
+export const FRAME_STREAM_HEADER: "X-Frame-Stream";
+
+/** Whether a fetch Response carries a frame stream. */
+export function isFrameStreamResponse(response: Response): boolean;
+
+/** Options for `applyFrameResponse`. */
+export interface ApplyFrameResponseOptions {
+  /**
+   * Remap the producer's root frame id onto a local one — the id your
+   * insertable/frame registered under — so navigations to the same boundary
+   * reuse the same frame regardless of what the server called it. Boundary
+   * identity belongs to the client.
+   */
+  as?: string;
+  /**
+   * Restamp every chunk of the response with this version (one response IS
+   * one version). Versions belong to the client too: the producer cannot
+   * know how many streams a boundary has consumed, so pass the Nth-response
+   * counter to make policy A's stale-guard real across navigations.
+   */
+  version?: number;
+}
+
+/**
+ * Reads a frame-stream Response to completion, applying every chunk to
+ * `host`. Chunks are length-prefixed JSON over the server-function wire
+ * framing. Resolves with the id the chunks were applied under once the
+ * stream ends; rejects on a malformed or errored stream.
+ *
+ * @example
+ * ```ts
+ * const response = await getStory(id); // frame-tagged server function result
+ * if (isFrameStreamResponse(response)) {
+ *   await applyFrameResponse(response, host, { as: "story-pane" });
+ * }
+ * ```
+ */
+export function applyFrameResponse(
+  response: Response,
+  host: FrameHost,
+  options?: ApplyFrameResponseOptions
+): Promise<string>;
+
+/** Options for `createServerComponentHandler`. */
+export interface ServerComponentHandlerOptions<C = unknown> {
+  host: FrameHost;
+  /**
+   * Builds the framework's mountable component for a boundary. Invoked once
+   * per boundary and cached; every mount of the returned component is its
+   * own frame instance under the boundary id (multi-mount fans out).
+   */
+  component(frameId: string): C;
+  /**
+   * Runs synchronously at each server-function call site (before any
+   * await); its return is the call's ambient identity — e.g. Solid's
+   * `getOwner`. Calls sharing a captured context share one boundary.
+   */
+  capture?(info: { id: string; meta: unknown }): unknown;
+  /**
+   * A new response is about to stream into a boundary: rotate
+   * response-scoped state (codec data tables) here. `version` is the
+   * client-owned stream counter the chunks will be stamped with.
+   */
+  onStream?(frameId: string, version: number, response: Response): void;
+  /**
+   * Document-SSR adoption: given a boundary id the page already carries
+   * (server-rendered between `frame:<id>` markers), return the component
+   * that adopts that range — or `undefined` to stream normally. Consulted
+   * once per boundary, before any fetch.
+   */
+  documentComponent?(frameId: string): C | undefined;
+  /**
+   * Answer a call SYNCHRONOUSLY before any request is made (t = 0 local
+   * answers — e.g. a boundary the document already carries). Returning a
+   * non-undefined value resolves the call with it; a hydrating consumer
+   * never observes a pending beat.
+   */
+  intercept?(info: { id: string; meta: unknown; args: unknown[] }): C | undefined;
+}
+
+/**
+ * The client mirror of `frameTransformResult`, shaped for the server-function
+ * client's `responseHandler` seam: frame-stream responses resolve the call
+ * with a **stable component** instead of data, so an equals-gated consumer
+ * (Solid's `dynamic`) never remounts across refetches — the response streams
+ * into the boundary underneath as the only observable effect.
+ *
+ * Boundary identity is derived, never declared: contexts captured per call
+ * key a WeakMap of boundaries (dying with their call sites); ownerless calls
+ * fall back to one boundary per function id.
+ */
+export function createServerComponentHandler<C>(
+  options: ServerComponentHandlerOptions<C>
+): {
+  capture?(info: { id: string; meta: unknown }): unknown;
+  intercept?(info: { id: string; meta: unknown; args: unknown[] }): C | undefined;
+  handle(response: Response, ctx: { id: string; meta: unknown; args: unknown[]; context: unknown }): C | undefined;
+};

package/types-cjs/frames/serializer.d.cts

@@ -0,0 +1,151 @@
+import { Plugin, Serializer, SerovalNode } from "seroval";
+
+/**
+ * Seroval's node shape — the intermediate representation `serializeJSON`
+ * emits and `createJSONDeserializer` consumes. Safe to `JSON.stringify`.
+ */
+export type { SerovalNode };
+
+/**
+ * A Seroval plugin usable with the web serializers — teaches the codec how
+ * to encode/decode a custom value type. Supply matching plugins on both
+ * peers of a transport.
+ */
+export type SerializerPlugin = Plugin<any, any>;
+
+/**
+ * Baseline plugin set for serializing web-platform values (AbortSignal,
+ * Event, FormData, Headers, ReadableStream, Request, Response, URL, ...).
+ * Applied by every serializer in this module; custom plugins compose ahead
+ * of it via `resolveSerializerPlugins`.
+ */
+export const DEFAULT_WEB_PLUGINS: readonly SerializerPlugin[];
+
+/**
+ * Composes custom plugins with `DEFAULT_WEB_PLUGINS`. Custom plugins come
+ * first so they can shadow a default for values both would match. Returns a
+ * fresh array; the defaults are never mutated. Useful when handing a full
+ * plugin list to another serialization layer.
+ */
+export function resolveSerializerPlugins(customPlugins?: SerializerPlugin[]): SerializerPlugin[];
+
+/** Options for `createSerializer`. */
+export interface WebSerializerOptions {
+  /** Name of the global object the emitted scripts write resolved values into. */
+  globalIdentifier: string;
+  /** Cross-reference scope id, for isolating multiple streams on one page. */
+  scopeId?: string;
+  /**
+   * Seroval feature bitflags to exclude from output. Defaults to disabling
+   * post-ES2017 features (AggregateError, BigInt typed arrays).
+   */
+  disabledFeatures?: number;
+  /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
+  plugins?: SerializerPlugin[];
+  /** Receives each emitted script chunk. */
+  onData: (result: string) => void;
+  onError?: (error: unknown) => void;
+  /** Fires once all async values have settled. */
+  onDone?: () => void;
+}
+
+/**
+ * Creates a streaming Seroval serializer preconfigured with the web plugin
+ * set and the default feature policy. Emits JavaScript chunks (through
+ * `onData`) that reconstruct the values under `globalIdentifier` when
+ * evaluated — the script-injection form of serialization renderers build
+ * on. For a JSON-based wire codec (no eval on the receiving side), use
+ * `serializeJSON` / `createJSONDeserializer` instead.
+ */
+export function createSerializer(options: WebSerializerOptions): Serializer;
+
+/**
+ * Options for `createHydrationSerializer` — `WebSerializerOptions` minus
+ * the knobs hydration pins (`globalIdentifier`, `disabledFeatures`).
+ * @internal
+ */
+export type HydrationSerializerOptions = Omit<
+  WebSerializerOptions,
+  "globalIdentifier" | "disabledFeatures"
+>;
+
+/**
+ * Renderer primitive — the serializer SSR uses for hydration output. Pins
+ * the hydration global (`_$HY.r`) and feature policy; only the wiring
+ * options (callbacks, scope, extra plugins) are configurable. Not meant
+ * for hand-written code — custom serialization should use
+ * `createSerializer` or the JSON codec.
+ * @internal
+ */
+export function createHydrationSerializer(options: HydrationSerializerOptions): Serializer;
+
+/**
+ * Renderer primitive — returns the cross-reference bootstrap script SSR
+ * emits ahead of hydration data for a render scope. Not meant for
+ * hand-written code.
+ * @internal
+ */
+export function getLocalHeaderScript(id?: string): string;
+
+// ---- JSON codec (server function transports) ----
+
+/**
+ * Options shared by both halves of the JSON codec. All of them must match
+ * on the serializing and deserializing peer or payloads will not
+ * round-trip — for server functions, set them once through the
+ * client/server `codec` config option.
+ */
+export interface JSONCodecOptions {
+  /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. Must match on both peers. */
+  plugins?: SerializerPlugin[];
+  /**
+   * Seroval feature bitflags to exclude. Defaults to disabling `RegExp`
+   * (payloads may come from an untrusted peer). Must match on both peers.
+   */
+  disabledFeatures?: number;
+  /** Maximum parse/deserialize depth. Defaults to 64. Must match on both peers. */
+  depthLimit?: number;
+}
+
+/** Options for `serializeJSON`. */
+export interface JSONSerializeOptions extends JSONCodecOptions {
+  /**
+   * Receives each serialized node; `initial` is true for the first chunk
+   * (the source value itself). Async values produce additional chunks as
+   * they resolve.
+   */
+  onParse: (node: SerovalNode, initial: boolean) => void;
+  onError?: (error: unknown) => void;
+  /** Fires once all async values have settled. */
+  onDone?: () => void;
+}
+
+/**
+ * Serializes `value` as SerovalNode chunks delivered through `onParse` —
+ * the encoding half of the eval-free JSON codec (RPC-style transports;
+ * the deserializing peer needs no script evaluation, so CSP-safe). Wire
+ * framing of the nodes is the transport's concern. Returns a cancel
+ * function that aborts pending async serialization.
+ */
+export function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
+
+/**
+ * Creates the decoding counterpart of `serializeJSON`. Cross-references
+ * between chunks resolve through state shared across calls, so all chunks
+ * from one stream must go through the same deserializer instance. The first
+ * chunk's return value is the decoded source value; feeding later chunks
+ * settles the async values referenced inside it.
+ */
+export function createJSONDeserializer(options?: JSONCodecOptions): <T>(node: SerovalNode) => T;
+
+/**
+ * A resident, response-scoped decode table over the keyed JSON codec: apply
+ * each frame `data` chunk with `apply`, resolve `{ $ref }` slot args with
+ * `resolve`. The frames client host wires one per response
+ * (`applyData: c => table.apply(c)`).
+ */
+export interface JSONDataTable {
+  apply(chunk: { key?: string; node?: unknown; initial?: boolean }): void;
+  resolve<T = unknown>(ref: { $ref: string }): T;
+}
+export function createJSONDataTable(options?: JSONCodecOptions): JSONDataTable;

package/types-cjs/frames/server.d.cts

@@ -0,0 +1,21 @@
+/**
+ * @solidjs/web/frames — server half. Render server components (functions
+ * returned from server functions) to frame-chunk streams, serve them as
+ * framed HTTP responses through the server-function handler's
+ * transformResult hook, and render them inline during document SSR.
+ *
+ * Copied next to the runtime's frame d.ts files at publish (see
+ * types:copy-frames), so the relative imports below resolve in-place.
+ */
+export {
+  renderToFrameStream,
+  renderServerComponent,
+  serverComponentResponse,
+  frameTransformResult,
+  createFrameSink,
+  frameTransformDirectResult,
+  ServerComponentPlugin,
+  SERVER_COMPONENT_BOOTSTRAP
+} from "./frame-sink.cjs";
+export type { FrameAddress, FrameStream, FrameStreamOptions } from "./frame-sink.cjs";
+export { FRAME_STREAM_HEADER, isFrameStreamResponse } from "./frame-transport.cjs";

package/types-cjs/jsx.d.cts

@@ -1120,7 +1120,7 @@ export namespace JSX {
 
   interface AnchorHTMLAttributes<T> extends HTMLAttributes<T> {
     download?: string | EnumeratedAcceptsEmpty | RemoveAttribute;
-    href?: string | RemoveAttribute;
+    href?: string | SerializableAttributeValue | RemoveAttribute;
     hreflang?: string | RemoveAttribute;
     ping?: string | RemoveAttribute;
     referrerpolicy?: HTMLReferrerPolicy | RemoveAttribute;
@@ -1128,6 +1128,21 @@ export namespace JSX {
     target?: "_self" | "_blank" | "_parent" | "_top" | (string & {}) | RemoveAttribute;
     type?: string | RemoveAttribute;
 
+    // Client-side navigation contract. These attributes are inert markup on
+    // their own — a routing integration that delegates anchor clicks (e.g.
+    // @solidjs/router) reads them off the element at event time. Typed here
+    // so plain `<a>` elements participate without per-router augmentation.
+    /** Marks the anchor as a client-navigation link when the integration requires explicit opt-in. */
+    link?: BooleanAttribute | RemoveAttribute;
+    /** Serialized (JSON) history state pushed alongside the navigation. */
+    state?: string | RemoveAttribute;
+    /** Suppress scroll restoration/reset after the navigation. */
+    noScroll?: BooleanAttribute | RemoveAttribute;
+    /** Replace the current history entry instead of pushing a new one. */
+    replace?: BooleanAttribute | RemoveAttribute;
+    /** Route preload intent; `"false"` disables the integration's default eager preload. */
+    preload?: boolean | "false" | RemoveAttribute;
+
     /** @experimental */
     attributionsrc?: string | RemoveAttribute;
 
@@ -1147,7 +1162,7 @@ export namespace JSX {
     alt?: string | RemoveAttribute;
     coords?: string | RemoveAttribute;
     download?: string | EnumeratedAcceptsEmpty | RemoveAttribute;
-    href?: string | RemoveAttribute;
+    href?: string | SerializableAttributeValue | RemoveAttribute;
     ping?: string | RemoveAttribute;
     referrerpolicy?: HTMLReferrerPolicy | RemoveAttribute;
     rel?: string | RemoveAttribute;

package/types-cjs/response.d.cts

@@ -23,6 +23,32 @@ export class ResponseEnvelope<T = unknown> {
  */
 export function isResponseEnvelope(value: unknown): value is ResponseEnvelope;
 
+/**
+ * Registered-symbol brand (`Symbol.for("solid.Href")`) marking URL-bearing
+ * values. Declared `unique symbol` type-side; the runtime value is the
+ * registered symbol, so separately bundled copies agree on identity.
+ */
+export declare const HREF: unique symbol;
+
+/**
+ * A URL-bearing value: coerces to its URL via `toString()` and carries the
+ * `HREF` registered-symbol brand. Integrations mint these (e.g. a router's
+ * typed path objects answer the brand from their proxy) and URL-accepting
+ * APIs like `redirect()` accept them alongside plain strings. The brand is
+ * what makes the type meaningful — every object has `toString()`.
+ */
+export interface Href {
+  [HREF]: true;
+  toString(): string;
+}
+
+/**
+ * Whether `value` is an `Href`-branded URL-bearing value. Registered-symbol
+ * check, so it stays correct across duplicated module instances — same
+ * rationale as `isResponseEnvelope`.
+ */
+export function isHref(value: unknown): value is Href;
+
 /** `ResponseInit` accepted by the response helpers, plus `revalidate`. */
 export interface ResponseHelperInit extends ResponseInit {
   /**
@@ -51,7 +77,7 @@ export interface ResponseHelperInit extends ResponseInit {
  * }
  * ```
  */
-export function redirect(url: string, init?: number | ResponseHelperInit): Response;
+export function redirect(url: string | Href, init?: number | ResponseHelperInit): Response;
 
 /**
  * Empty response requesting revalidation of the named cache keys — all of

package/types-cjs/serializer.d.cts

@@ -137,3 +137,15 @@ export function serializeJSON(value: unknown, options: JSONSerializeOptions): ()
  * settles the async values referenced inside it.
  */
 export function createJSONDeserializer(options?: JSONCodecOptions): <T>(node: SerovalNode) => T;
+
+/**
+ * A resident, response-scoped decode table over the keyed JSON codec: apply
+ * each frame `data` chunk with `apply`, resolve `{ $ref }` slot args with
+ * `resolve`. The frames client host wires one per response
+ * (`applyData: c => table.apply(c)`).
+ */
+export interface JSONDataTable {
+  apply(chunk: { key?: string; node?: unknown; initial?: boolean }): void;
+  resolve<T = unknown>(ref: { $ref: string }): T;
+}
+export function createJSONDataTable(options?: JSONCodecOptions): JSONDataTable;

package/types-cjs/server-functions/client.d.cts

@@ -2,10 +2,13 @@ import { JSONCodecOptions } from "../serializer.cjs";
 import { ServerFunction, ServerFunctionMetadata } from "./shared.cjs";
 
 export {
+  ERROR_HEADER,
   FUNCTION_HEADER,
   INSTANCE_HEADER,
   SINGLE_FLIGHT_HEADER,
+  decodeErrorHeaderValue,
   decodeResponse,
+  encodeErrorHeaderValue,
   getServerFunctionMetadata,
   isServerFunction,
   subscribeFlightData,
@@ -78,6 +81,30 @@ export interface ServerFunctionsClientConfig {
    * ```
    */
   prepareRequest?: PrepareRequestHook;
+  /**
+   * Response-side integration seam — the client mirror of the handler's
+   * `transformResult`. `handle(response, ctx)` sees every response before
+   * the transport decodes it; returning anything but undefined resolves the
+   * call with that value. `capture(info)` runs synchronously at the call
+   * site (before any await) and its return arrives as `ctx.context`, so
+   * ambient per-call state (e.g. a reactive owner) survives to response
+   * time. See `createServerComponentHandler` in frame-transport for the
+   * canonical implementation.
+   */
+  responseHandler?: {
+    capture?(info: { id: string; meta: unknown }): unknown;
+    handle(
+      response: Response,
+      ctx: { id: string; meta: unknown; args: unknown[]; context: unknown }
+    ): unknown;
+  };
+  /**
+   * Encoder for argument lists JSON can't carry faithfully. JSON-safe args
+   * always go as plain JSON (no codec in the bundle); anything else throws
+   * unless this is set. Installed by `enableRichArguments()` from the
+   * rich-args entry — set directly only for custom wire encodings.
+   */
+  serializeArgs?(args: unknown[]): string | Promise<string>;
 }
 
 /**
@@ -97,10 +124,11 @@ export function configureServerFunctionsClient(config?: ServerFunctionsClientCon
  *
  * The declaration rides the metadata channel
  * (`getServerFunctionMetadata(fn)?.method === "GET"`) for routers and
- * integrations to detect, and the server enforces it: GET-declared
- * functions accept GET requests (and only GET), everything else answers
- * 405. Server-side the wrapper is identity-flavored — SSR calls stay
- * in-process.
+ * integrations to detect, and the server honors it: GET-declared functions
+ * accept GET requests in addition to the default POST transport (declaring
+ * GET grants, it does not revoke); functions that never declared GET answer
+ * GET requests with 405. Server-side the wrapper is identity-flavored — SSR
+ * calls stay in-process.
  *
  * Wrap the reference at its declaration; the compiler round-trips the call
  * in both builds:
@@ -123,9 +151,16 @@ export function GET<A extends readonly any[], R>(
  * source name as the trailing argument (dev-only metadata seeded on the
  * metadata channel; never emitted in production). Not meant for
  * hand-written code.
+ *
+ * The optional `base` targets calls at that url verbatim instead of the
+ * configured endpoint — for integrations reconstructing a callable from a
+ * server-rendered action url (e.g. a router intercepting a form submit whose
+ * `action="/_server?id=...&args=..."` came off the wire): bound arguments
+ * stay in the query string, where the server reads them for natural-encoding
+ * bodies (FormData, urlencoded).
  * @internal
  */
-export function createServerReference(id: string, name?: string): ServerFunction;
+export function createServerReference(id: string, name?: string, base?: string): ServerFunction;
 
 /**
  * Compiler ABI — only ever referenced by server-mode compiler output;

package/types-cjs/server-functions/server.d.cts

@@ -3,10 +3,13 @@ import { JSONCodecOptions } from "../serializer.cjs";
 import { RequestEvent } from "../server.cjs";
 
 export {
+  ERROR_HEADER,
   FUNCTION_HEADER,
   INSTANCE_HEADER,
   SINGLE_FLIGHT_HEADER,
+  decodeErrorHeaderValue,
   decodeResponse,
+  encodeErrorHeaderValue,
   getServerFunctionMetadata,
   isServerFunction,
   subscribeFlightData,
@@ -194,8 +197,9 @@ export function createServerReference<T extends any[], R>(
  * declaration on the reference's metadata channel
  * (`getServerFunctionMetadata(fn)?.method === "GET"`) and records the
  * declared method for the function's id so `handleServerFunctionRequest`
- * enforces it: GET-declared functions accept GET requests (and only GET),
- * everything else answers 405.
+ * honors it: GET-declared functions accept GET requests in addition to the
+ * default POST transport (declaring GET grants, it does not revoke);
+ * functions that never declared GET answer GET requests with 405.
  *
  * Wrap the reference at its declaration; the compiler round-trips the call
  * in both builds:
@@ -282,9 +286,9 @@ export interface HandleServerFunctionOptions {
 
 /**
  * Web-standard HTTP handler for server function calls: resolves the
- * function id from the request, enforces the declared method (405 when the
- * request method contradicts a `GET` declaration — or uses GET without
- * one), decodes arguments, runs the function under a request-event scope,
+ * function id from the request, gates GET dispatch on the declaration (405
+ * for a GET request to a function that never declared `GET`; POST is always
+ * accepted), decodes arguments, runs the function under a request-event scope,
  * and encodes the result (forwarding redirect/revalidation metadata
  * through headers). Mount it on the endpoint the client transport targets
  * (default `/_server`); platform adapters (h3, express, ...) convert their

package/types-cjs/server-functions/shared.d.cts

@@ -38,6 +38,35 @@ export const FUNCTION_HEADER: string;
  */
 export const INSTANCE_HEADER: string;
 
+/**
+ * Response header marking a thrown server-function error
+ * (`"X-Server-Function-Error"`). The client transport rejects with the
+ * decoded body when it is present (unless redirect/revalidation metadata
+ * marks the response as control flow). The value carries the error's
+ * message — `"true"` for thrown control-flow responses and non-Error
+ * values — encoded with `encodeErrorHeaderValue`, so integrations reading
+ * it must pass it through `decodeErrorHeaderValue`.
+ */
+export const ERROR_HEADER: string;
+
+/**
+ * Encodes an error message for the `ERROR_HEADER` value. HTTP header values
+ * are latin1 ByteStrings — `Headers.set` throws on code points above U+00FF
+ * — so plain printable-latin1 messages ride verbatim (ASCII stays
+ * byte-identical on the wire) and everything else (CJK, emoji, controls)
+ * travels percent-encoded behind a marker. `decodeErrorHeaderValue`
+ * round-trips the message exactly, astral-plane characters included (lone
+ * surrogates are replaced with U+FFFD — they cannot survive UTF-8 anyway).
+ */
+export function encodeErrorHeaderValue(value: string): string;
+
+/**
+ * Decodes an `ERROR_HEADER` value produced by `encodeErrorHeaderValue`:
+ * marked values are percent-decoded, everything else (including values from
+ * peers that never encode) passes through untouched.
+ */
+export function decodeErrorHeaderValue(value: string): string;
+
 /**
  * Header driving the single-flight protocol on both legs
  * (`"X-Single-Flight"`). On the request it opts the call into data