@solidjs/web 2.0.0-rc.3 → 2.0.0-rc.4

package/types/server-functions/client.d.ts

@@ -1,7 +1,7 @@
-export { ChunkReader, ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, INSTANCE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, createChunk, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, deserializeStream, encodeErrorHeaderValue, frameAddress, getFlightDataConsumer, getServerFunctionMetadata, getServerFunctionsCodec, hasFlashCookie, isServerFunction, serializeString, subscribeFlightData, withMeta } from "./shared.js";
+export { ChunkReader, ERROR_HEADER, FLASH_COOKIE, INSTANCE_HEADER, SERVER_FUNCTION_INVOKE, SINGLE_FLIGHT_HEADER, clearFlashCookie, createChunk, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, deserializeStream, encodeErrorHeaderValue, frameAddress, getFlightDataConsumer, getServerFunctionMetadata, getServerFunctionsCodec, hasFlashCookie, invoke, isServerFunction, serializeString, subscribeFlightData, withMeta } from "./shared.js";
 export { REVALIDATE_HEADER } from "../response.js";
 import { JSONCodecOptions } from "../serializer-decode.js";
-export type { FlightDataConsumer, FlightDataContext, ServerFunction, ServerFunctionMetadata, SingleFlightPayload } from "./shared.js";
+export type { FlightDataConsumer, FlightDataContext, InvokeOptions, ServerFunction, ServerFunctionInvoker, ServerFunctionMetadata, SingleFlightPayload } from "./shared.js";
 /** The context `prepareRequest` receives alongside the outgoing RequestInit. */
 export interface PrepareRequestContext {
     /** The build-stable id of the function being called. */
@@ -25,10 +25,11 @@ export type PrepareRequestHook = (init: RequestInit, context: PrepareRequestCont
 /** Options for `configureServerFunctionsClient`. */
 export interface ServerFunctionsClientConfig {
     /**
-     * Endpoint the server's HTTP handler is mounted on. Must match the
-     * server configuration — SSR'd reference `url`s (e.g. form actions) and
-     * client fetches both derive from it. Prefix it when the app serves from
-     * a base path (e.g. `` `${BASE_URL}_server` ``).
+     * Mount path the server's HTTP handler answers on. Must match the server
+     * configuration — the id travels as the segment after it, and SSR'd
+     * reference `url`s (e.g. form actions) and client fetches both derive
+     * from it. Prefix it when the app serves from a base path
+     * (e.g. `` `${BASE_URL}_server` ``).
      * @default "/_server"
      */
     endpoint?: string;
@@ -38,6 +39,34 @@ export interface ServerFunctionsClientConfig {
      * `decodeResponse` sees them too.
      */
     codec?: JSONCodecOptions;
+    /**
+     * Sends every server-function request — retries, telemetry, a test
+     * double, or an app's own route. Always called as `(address, init)`, the
+     * address relative to the document as the global one receives it, so
+     * `parseServerFunctionUrl` reads the id back out for telemetry. `null`
+     * restores the global.
+     *
+     * ```ts
+     * configureServerFunctionsClient({
+     *   fetch: (address, init) => fetch(rewrite(address), init)
+     * });
+     * ```
+     *
+     * Forward `init` — the call's `signal` rides on it, and dropping it voids
+     * both the caller's abort and the teardown a live source's `break`
+     * performs. Keep the call same-origin, since a cross-origin send is
+     * stamped `Sec-Fetch-Site: cross-site` and the handler's origin gate
+     * refuses it, and hand back what the peer answered, unread.
+     *
+     * A retrying wrapper may re-send a request that got NO response; it must
+     * never replay one whose response ended. A response that dies mid-body may
+     * have executed (mutations are not idempotent), and reconnecting a live
+     * source is the runtime's job — a replay would race it.
+     *
+     * The wrapper replaces delivery for the requests the runtime chooses to
+     * send; the call-to-request mapping itself is not contractual.
+     */
+    fetch?: ((address: string, init: RequestInit) => Response | Promise<Response>) | null;
     /**
      * Runs before every server-function fetch. Return (or mutate and return)
      * the RequestInit the transport will use; `context.meta` is the
@@ -125,6 +154,8 @@ export interface ServerFunctionInvocation {
     id: string;
 }
 export declare function observeServerFunctionCalls(observer: (call: ServerFunctionCall) => void): () => void;
+export declare function serverFunctionUrl(id: string, boundArgs?: readonly unknown[]): string;
+export declare function parseServerFunctionUrl(url: string): string | null;
 export declare function configureServerFunctionsClient(config?: ServerFunctionsClientConfig): void;
 export declare function createServerReference(id: string, name?: string, base?: string): ServerFunction;
 export declare function GET<A extends readonly any[], R>(fn: (...args: A) => R): ServerFunction<A, Awaited<R>>;

package/types/server-functions/registry.d.ts

@@ -1,4 +1,5 @@
-export type { ServerFunction, ServerFunctionMetadata, ServerFunctionRPC } from "./shared.js";
+export type { InvokeOptions, ServerFunction, ServerFunctionInvoker, ServerFunctionMetadata, ServerFunctionRPC } from "./shared.js";
+import type { InvokeOptions } from "./shared.js";
 export declare const SERVER_FUNCTION_METADATA: unique symbol;
 /**
  * Reads a server function reference's declaration metadata (e.g.
@@ -45,6 +46,42 @@ export declare function isServerFunction(fn: any): boolean;
  * ```
  */
 export declare function withMeta(fn: any, meta: any): any;
+export declare const SERVER_FUNCTION_INVOKE: unique symbol;
+/**
+ * Applies a server function once with per-call, invocation-scoped options —
+ * `Function.prototype.call` for server functions, the options bag in the
+ * `thisArg` slot (declaration wrappers like `GET` and `withMeta` are `bind`:
+ * they return a new reference with context baked in; `invoke` applies one
+ * call and leaves no residue on the reference).
+ *
+ * ```ts
+ * import { invoke } from "@solidjs/web/server-functions";
+ *
+ * const user = await invoke(getUser, { signal: controller.signal }, id);
+ * ```
+ *
+ * Options are strictly invocation-scoped — things that vary between calls
+ * of the SAME function and cannot be declared or configured: `signal`
+ * (the call's lifecycle; aborting rejects the call and cancels the
+ * request), `keepalive` (calls made while the page unloads), `priority`
+ * (fetch priority hint). Anything with a longer lifetime is refused with a
+ * pointer to its home: session-dynamic transport policy → `prepareRequest`;
+ * declaration-static shape → `GET`/`withMeta`; call policy (retries,
+ * dedupe, deadlines) → the data layer that owns the call, wired through
+ * `signal`.
+ *
+ * Dispatches through the reference's invocation channel
+ * (`SERVER_FUNCTION_INVOKE`). Core's declaration wrappers forward it —
+ * `GET` invokes over its query encoding, `live` ends its iteration on
+ * abort. Wrappers that share calls (caches, channels) may adapt or decline
+ * it; a data layer needs neither — it holds the reference below such
+ * wrappers and invokes it directly with its own signal. On the server the
+ * call runs in-process: `signal`
+ * rejects the caller (the work, like a server behind HTTP, runs on unless
+ * the function observes a signal itself) and the transport hints are
+ * no-ops, since they describe a wire that does not exist.
+ */
+export declare function invoke<A extends readonly any[], R>(fn: (...args: A) => R, options: InvokeOptions, ...args: A): R;
 export declare const LIVE_SOURCE: unique symbol;
 /**
  * Fills the RPC seam. Called by the transport halves (client fetch RPC,

package/types/server-functions/server.d.ts

@@ -1,9 +1,9 @@
-export { ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, INSTANCE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, encodeErrorHeaderValue, getServerFunctionMetadata, hasFlashCookie, isServerFunction, subscribeFlightData, withMeta } from "./shared.js";
+export { ERROR_HEADER, FLASH_COOKIE, INSTANCE_HEADER, SERVER_FUNCTION_INVOKE, SINGLE_FLIGHT_HEADER, clearFlashCookie, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, encodeErrorHeaderValue, getServerFunctionMetadata, hasFlashCookie, invoke, isServerFunction, subscribeFlightData, withMeta } from "./shared.js";
 export { decodeFlashCookie, encodeFlashCookie } from "./flash.js";
 import { ResponseEnvelope } from "../response.js";
 import { JSONCodecOptions } from "../serializer-decode.js";
 import { RequestEvent } from "../server.js";
-export type { FlightDataConsumer, FlightDataContext, ServerFunction, ServerFunctionMetadata, SingleFlightPayload } from "./shared.js";
+export type { FlightDataConsumer, FlightDataContext, InvokeOptions, ServerFunction, ServerFunctionInvoker, ServerFunctionMetadata, SingleFlightPayload } from "./shared.js";
 export type { FlashSubmission } from "./flash.js";
 /**
  * The request event a server function call runs under: the base
@@ -208,10 +208,11 @@ export interface ServerFunctionsServerConfig {
      */
     handleNoJS?: ((result: unknown, request: Request, args: unknown[], thrown?: boolean) => Response | Promise<Response>) | null;
     /**
-     * Endpoint the HTTP handler is mounted on, used for the `url` of SSR'd
-     * references (e.g. form actions) — must match the client configuration.
-     * Prefix it when the app serves from a base path (e.g.
-     * `` `${BASE_URL}_server` ``).
+     * Mount path the HTTP handler answers on. Must match the client
+     * configuration — the id travels as the segment after it, a request whose
+     * path does not start with it is not a call, and SSR'd reference `url`s
+     * (e.g. form actions) derive from it. Prefix it when the app serves from
+     * a base path (e.g. `` `${BASE_URL}_server` ``).
      * @default "/_server"
      */
     endpoint?: string;
@@ -396,4 +397,6 @@ export declare const GENERIC_SERVER_ERROR_MESSAGE = "Internal Server Error";
 export declare function setServerFunctionsDev(dev: boolean): void;
 export declare function sanitizeServerError(value: unknown): unknown;
 export declare function observeServerFunctionCalls(observer: (call: ServerFunctionCall) => void): () => void;
+export declare function serverFunctionUrl(id: string, boundArgs?: readonly unknown[]): string;
+export declare function parseServerFunctionUrl(url: string): string | null;
 export declare function handleServerFunctionRequest(request: Request, options?: HandleServerFunctionOptions): Promise<Response>;

package/types/server-functions/shared.d.ts

@@ -1,4 +1,4 @@
-export { LIVE_SOURCE, SERVER_FUNCTION_METADATA, getServerFunctionMetadata, getServerFunctionRPC, isServerFunction, provideServerFunctionRPC, withMeta } from "./registry.js";
+export { LIVE_SOURCE, SERVER_FUNCTION_INVOKE, SERVER_FUNCTION_METADATA, getServerFunctionMetadata, getServerFunctionRPC, invoke, isServerFunction, provideServerFunctionRPC, withMeta } from "./registry.js";
 export { FLASH_COOKIE, clearFlashCookie, hasFlashCookie, matchFlashCookie } from "../cookies.js";
 import { JSONCodecOptions } from "../serializer-decode.js";
 /**
@@ -45,6 +45,42 @@ export interface ServerFunction<A extends readonly any[] = any[], T = any> {
     /** URL invoking this function directly over HTTP (form `action`s, raw fetches). */
     readonly url: string;
 }
+/**
+ * Per-call, invocation-scoped options for `invoke` — things that vary
+ * between calls of the SAME function and cannot be declared (`GET`,
+ * `withMeta`) or configured (`prepareRequest`). On the server the call is
+ * in-process: `signal` still rejects the caller, the transport hints are
+ * no-ops (they describe a wire that does not exist).
+ */
+export interface InvokeOptions {
+    /**
+     * The call's lifecycle. Aborting rejects the call with the signal's
+     * reason and cancels the request (firing `request.signal` server-side);
+     * a live source's iteration ends across reconnects. When provided, the
+     * signal owns the wire — timeouts compose through it
+     * (`AbortSignal.timeout`, `AbortSignal.any`).
+     */
+    signal?: AbortSignal;
+    /**
+     * Lets the request outlive the page — fire-and-forget calls during
+     * unload (`pagehide`). Maps to fetch's `keepalive`, body-size caps
+     * included.
+     */
+    keepalive?: boolean;
+    /** Fetch priority hint — speculative prefetch vs. interaction fetch. */
+    priority?: "high" | "low" | "auto";
+}
+/**
+ * A reference's invocation channel, carried under `SERVER_FUNCTION_INVOKE`:
+ * applies one call with per-call options. Declaration wrappers (`GET`,
+ * `live`) forward it mechanically — they keep the call mapping 1:1. A
+ * wrapper that shares calls (a deduping cache, a multicast channel) opts
+ * in deliberately, deciding first what a caller's abort means for shared
+ * work — or declines, leaving `invoke` to answer with a directed error.
+ * Options arrive already validated — `invoke` admits only
+ * invocation-scoped keys.
+ */
+export type ServerFunctionInvoker<A extends readonly any[] = any[], R = any> = (args: A, options?: InvokeOptions) => R;
 /**
  * Declaration-static metadata attached to a server function reference
  * through declaration wrappers (`GET`, `withMeta`). Read it with
@@ -98,8 +134,8 @@ export declare function getServerFunctionsCodec(): JSONCodecOptions | undefined;
 export declare function subscribeFlightData<D = unknown>(consumer: FlightDataConsumer<D>): () => void;
 export declare function getFlightDataConsumer(): FlightDataConsumer | undefined;
 export declare function frameAddress(id: string, args?: readonly unknown[]): string;
-/** Header carrying the server function id. */
-export declare const FUNCTION_HEADER = "X-Server-Function-Id";
+export declare function serverFunctionAddress(endpoint: string, id: string): string;
+export declare function parseServerFunctionAddress(pathname: string, endpoint: string): string | null;
 /**
  * Response header marking a thrown server-function error. The value is the
  * error's message (the structured error itself travels in the body); `"true"`
@@ -141,6 +177,13 @@ export declare const BodyFormat: {
      * included) on the response.
      */
     Json: string;
+    /**
+     * No body at all — a function that returned nothing. It marks the response
+     * as one the runtime encoded, which separates a void result with a status
+     * on it from a refusal answered by something else. Decoding falls through
+     * to `undefined`, which is what a peer predating the tag reads too.
+     */
+    Void: string;
 };
 export declare function isJSONSafe(value: unknown): boolean;
 export declare function getHeadersAndBody(body: unknown): {

package/types-cjs/client.d.cts

@@ -79,6 +79,8 @@ export interface RequestEvent {
 export type { CookieOptions } from "./cookies.cjs";
 export type { ServerFunction, ServerFunctionMetadata, ServerFunctionRPC } from "./server-functions/shared.cjs";
 export declare const waitAsset: (promise: Promise<unknown>) => void;
+export declare let listDriver: ((parent: Node, listFn: any, marker?: Node, lateClassic?: () => void) => boolean) | undefined;
+export declare function installListDriver(driver: typeof listDriver): void;
 export { DOMWithState, ChildProperties, DOMElements, SVGElements, MathMLElements, VoidElements, RawTextElements, Namespaces, DelegatedEvents } from "./constants.cjs";
 /** Client stub — hydration bootstrap is a server-only emit. */
 export declare function generateHydrationScript(_options?: {
@@ -145,10 +147,10 @@ export declare function spread<T>(node: Element, accessor: T, skipChildren?: Boo
 export declare function dynamicProperty(props: unknown, key: string): unknown;
 export declare function applyRef<T extends Element = Element>(r: ((element: NoInfer<T>) => void) | ((element: NoInfer<T>) => void)[], element: T): void;
 export declare function ref(fn: () => ((element: Element) => void) | ((element: Element) => void)[], element: Element): void;
-export declare function rowProof(fn: any): any; /** Compiler-emitted primitive; not for hand-written code. @internal */
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export declare function scope<T extends () => any>(fn: T): T;
 export declare function installHydrationRuntime(): void;
-export declare function patchDriver(subject: any, body: any): void; /**
+/**
  * Compiler-emitted primitive; not for hand-written code.
  * @internal
  */

package/types-cjs/index.d.cts

@@ -1,6 +1,7 @@
 import { Component } from "solid-js";
 import type { JSX } from "./jsx.cjs";
 export * from "./client.cjs";
+export { patchDriver, rowProof, driveList } from "./patch-driver.cjs";
 export * from "./server-mock.cjs";
 export * from "./response.cjs";
 export type { JSX } from "./jsx.cjs";

package/types-cjs/patch-driver.d.cts

@@ -0,0 +1,3 @@
+export declare function rowProof<T extends Function>(fn: T): T;
+export declare const driveList: (parent: Node, listFn: any, marker?: Node, lateClassic?: () => void) => boolean;
+export declare const patchDriver: (subject: any, body: any) => void;

package/types-cjs/response.d.cts

@@ -16,7 +16,15 @@ export declare const ResponseEnvelope: {
 export declare function isResponseEnvelope(value: unknown): value is ResponseEnvelope;
 export declare const HREF: unique symbol;
 export interface Href {
-    [HREF]: true;
+    /**
+     * The brand doubles as a channel: when the slot holds a string it is the
+     * value's *logical* path — the routable pathname before an integration's
+     * display rendering (eg. a hash router's `#` prefix). `redirect()` prefers
+     * it over coercion so Location headers carry routable paths; `toString()`
+     * remains the display href for the DOM. `true` brands a value whose
+     * string form is already logical.
+     */
+    [HREF]: true | string;
     toString(): string;
 }
 /** Whether `value` is an `Href`-branded URL-bearing value. */

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

@@ -1,7 +1,7 @@
-export { ChunkReader, ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, INSTANCE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, createChunk, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, deserializeStream, encodeErrorHeaderValue, frameAddress, getFlightDataConsumer, getServerFunctionMetadata, getServerFunctionsCodec, hasFlashCookie, isServerFunction, serializeString, subscribeFlightData, withMeta } from "./shared.cjs";
+export { ChunkReader, ERROR_HEADER, FLASH_COOKIE, INSTANCE_HEADER, SERVER_FUNCTION_INVOKE, SINGLE_FLIGHT_HEADER, clearFlashCookie, createChunk, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, deserializeStream, encodeErrorHeaderValue, frameAddress, getFlightDataConsumer, getServerFunctionMetadata, getServerFunctionsCodec, hasFlashCookie, invoke, isServerFunction, serializeString, subscribeFlightData, withMeta } from "./shared.cjs";
 export { REVALIDATE_HEADER } from "../response.cjs";
 import { JSONCodecOptions } from "../serializer-decode.cjs";
-export type { FlightDataConsumer, FlightDataContext, ServerFunction, ServerFunctionMetadata, SingleFlightPayload } from "./shared.cjs";
+export type { FlightDataConsumer, FlightDataContext, InvokeOptions, ServerFunction, ServerFunctionInvoker, ServerFunctionMetadata, SingleFlightPayload } from "./shared.cjs";
 /** The context `prepareRequest` receives alongside the outgoing RequestInit. */
 export interface PrepareRequestContext {
     /** The build-stable id of the function being called. */
@@ -25,10 +25,11 @@ export type PrepareRequestHook = (init: RequestInit, context: PrepareRequestCont
 /** Options for `configureServerFunctionsClient`. */
 export interface ServerFunctionsClientConfig {
     /**
-     * Endpoint the server's HTTP handler is mounted on. Must match the
-     * server configuration — SSR'd reference `url`s (e.g. form actions) and
-     * client fetches both derive from it. Prefix it when the app serves from
-     * a base path (e.g. `` `${BASE_URL}_server` ``).
+     * Mount path the server's HTTP handler answers on. Must match the server
+     * configuration — the id travels as the segment after it, and SSR'd
+     * reference `url`s (e.g. form actions) and client fetches both derive
+     * from it. Prefix it when the app serves from a base path
+     * (e.g. `` `${BASE_URL}_server` ``).
      * @default "/_server"
      */
     endpoint?: string;
@@ -38,6 +39,34 @@ export interface ServerFunctionsClientConfig {
      * `decodeResponse` sees them too.
      */
     codec?: JSONCodecOptions;
+    /**
+     * Sends every server-function request — retries, telemetry, a test
+     * double, or an app's own route. Always called as `(address, init)`, the
+     * address relative to the document as the global one receives it, so
+     * `parseServerFunctionUrl` reads the id back out for telemetry. `null`
+     * restores the global.
+     *
+     * ```ts
+     * configureServerFunctionsClient({
+     *   fetch: (address, init) => fetch(rewrite(address), init)
+     * });
+     * ```
+     *
+     * Forward `init` — the call's `signal` rides on it, and dropping it voids
+     * both the caller's abort and the teardown a live source's `break`
+     * performs. Keep the call same-origin, since a cross-origin send is
+     * stamped `Sec-Fetch-Site: cross-site` and the handler's origin gate
+     * refuses it, and hand back what the peer answered, unread.
+     *
+     * A retrying wrapper may re-send a request that got NO response; it must
+     * never replay one whose response ended. A response that dies mid-body may
+     * have executed (mutations are not idempotent), and reconnecting a live
+     * source is the runtime's job — a replay would race it.
+     *
+     * The wrapper replaces delivery for the requests the runtime chooses to
+     * send; the call-to-request mapping itself is not contractual.
+     */
+    fetch?: ((address: string, init: RequestInit) => Response | Promise<Response>) | null;
     /**
      * Runs before every server-function fetch. Return (or mutate and return)
      * the RequestInit the transport will use; `context.meta` is the
@@ -125,6 +154,8 @@ export interface ServerFunctionInvocation {
     id: string;
 }
 export declare function observeServerFunctionCalls(observer: (call: ServerFunctionCall) => void): () => void;
+export declare function serverFunctionUrl(id: string, boundArgs?: readonly unknown[]): string;
+export declare function parseServerFunctionUrl(url: string): string | null;
 export declare function configureServerFunctionsClient(config?: ServerFunctionsClientConfig): void;
 export declare function createServerReference(id: string, name?: string, base?: string): ServerFunction;
 export declare function GET<A extends readonly any[], R>(fn: (...args: A) => R): ServerFunction<A, Awaited<R>>;

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

@@ -1,4 +1,5 @@
-export type { ServerFunction, ServerFunctionMetadata, ServerFunctionRPC } from "./shared.cjs";
+export type { InvokeOptions, ServerFunction, ServerFunctionInvoker, ServerFunctionMetadata, ServerFunctionRPC } from "./shared.cjs";
+import type { InvokeOptions } from "./shared.cjs";
 export declare const SERVER_FUNCTION_METADATA: unique symbol;
 /**
  * Reads a server function reference's declaration metadata (e.g.
@@ -45,6 +46,42 @@ export declare function isServerFunction(fn: any): boolean;
  * ```
  */
 export declare function withMeta(fn: any, meta: any): any;
+export declare const SERVER_FUNCTION_INVOKE: unique symbol;
+/**
+ * Applies a server function once with per-call, invocation-scoped options —
+ * `Function.prototype.call` for server functions, the options bag in the
+ * `thisArg` slot (declaration wrappers like `GET` and `withMeta` are `bind`:
+ * they return a new reference with context baked in; `invoke` applies one
+ * call and leaves no residue on the reference).
+ *
+ * ```ts
+ * import { invoke } from "@solidjs/web/server-functions";
+ *
+ * const user = await invoke(getUser, { signal: controller.signal }, id);
+ * ```
+ *
+ * Options are strictly invocation-scoped — things that vary between calls
+ * of the SAME function and cannot be declared or configured: `signal`
+ * (the call's lifecycle; aborting rejects the call and cancels the
+ * request), `keepalive` (calls made while the page unloads), `priority`
+ * (fetch priority hint). Anything with a longer lifetime is refused with a
+ * pointer to its home: session-dynamic transport policy → `prepareRequest`;
+ * declaration-static shape → `GET`/`withMeta`; call policy (retries,
+ * dedupe, deadlines) → the data layer that owns the call, wired through
+ * `signal`.
+ *
+ * Dispatches through the reference's invocation channel
+ * (`SERVER_FUNCTION_INVOKE`). Core's declaration wrappers forward it —
+ * `GET` invokes over its query encoding, `live` ends its iteration on
+ * abort. Wrappers that share calls (caches, channels) may adapt or decline
+ * it; a data layer needs neither — it holds the reference below such
+ * wrappers and invokes it directly with its own signal. On the server the
+ * call runs in-process: `signal`
+ * rejects the caller (the work, like a server behind HTTP, runs on unless
+ * the function observes a signal itself) and the transport hints are
+ * no-ops, since they describe a wire that does not exist.
+ */
+export declare function invoke<A extends readonly any[], R>(fn: (...args: A) => R, options: InvokeOptions, ...args: A): R;
 export declare const LIVE_SOURCE: unique symbol;
 /**
  * Fills the RPC seam. Called by the transport halves (client fetch RPC,

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

@@ -1,9 +1,9 @@
-export { ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, INSTANCE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, encodeErrorHeaderValue, getServerFunctionMetadata, hasFlashCookie, isServerFunction, subscribeFlightData, withMeta } from "./shared.cjs";
+export { ERROR_HEADER, FLASH_COOKIE, INSTANCE_HEADER, SERVER_FUNCTION_INVOKE, SINGLE_FLIGHT_HEADER, clearFlashCookie, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, encodeErrorHeaderValue, getServerFunctionMetadata, hasFlashCookie, invoke, isServerFunction, subscribeFlightData, withMeta } from "./shared.cjs";
 export { decodeFlashCookie, encodeFlashCookie } from "./flash.cjs";
 import { ResponseEnvelope } from "../response.cjs";
 import { JSONCodecOptions } from "../serializer-decode.cjs";
 import { RequestEvent } from "../server.cjs";
-export type { FlightDataConsumer, FlightDataContext, ServerFunction, ServerFunctionMetadata, SingleFlightPayload } from "./shared.cjs";
+export type { FlightDataConsumer, FlightDataContext, InvokeOptions, ServerFunction, ServerFunctionInvoker, ServerFunctionMetadata, SingleFlightPayload } from "./shared.cjs";
 export type { FlashSubmission } from "./flash.cjs";
 /**
  * The request event a server function call runs under: the base
@@ -208,10 +208,11 @@ export interface ServerFunctionsServerConfig {
      */
     handleNoJS?: ((result: unknown, request: Request, args: unknown[], thrown?: boolean) => Response | Promise<Response>) | null;
     /**
-     * Endpoint the HTTP handler is mounted on, used for the `url` of SSR'd
-     * references (e.g. form actions) — must match the client configuration.
-     * Prefix it when the app serves from a base path (e.g.
-     * `` `${BASE_URL}_server` ``).
+     * Mount path the HTTP handler answers on. Must match the client
+     * configuration — the id travels as the segment after it, a request whose
+     * path does not start with it is not a call, and SSR'd reference `url`s
+     * (e.g. form actions) derive from it. Prefix it when the app serves from
+     * a base path (e.g. `` `${BASE_URL}_server` ``).
      * @default "/_server"
      */
     endpoint?: string;
@@ -396,4 +397,6 @@ export declare const GENERIC_SERVER_ERROR_MESSAGE = "Internal Server Error";
 export declare function setServerFunctionsDev(dev: boolean): void;
 export declare function sanitizeServerError(value: unknown): unknown;
 export declare function observeServerFunctionCalls(observer: (call: ServerFunctionCall) => void): () => void;
+export declare function serverFunctionUrl(id: string, boundArgs?: readonly unknown[]): string;
+export declare function parseServerFunctionUrl(url: string): string | null;
 export declare function handleServerFunctionRequest(request: Request, options?: HandleServerFunctionOptions): Promise<Response>;

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

@@ -1,4 +1,4 @@
-export { LIVE_SOURCE, SERVER_FUNCTION_METADATA, getServerFunctionMetadata, getServerFunctionRPC, isServerFunction, provideServerFunctionRPC, withMeta } from "./registry.cjs";
+export { LIVE_SOURCE, SERVER_FUNCTION_INVOKE, SERVER_FUNCTION_METADATA, getServerFunctionMetadata, getServerFunctionRPC, invoke, isServerFunction, provideServerFunctionRPC, withMeta } from "./registry.cjs";
 export { FLASH_COOKIE, clearFlashCookie, hasFlashCookie, matchFlashCookie } from "../cookies.cjs";
 import { JSONCodecOptions } from "../serializer-decode.cjs";
 /**
@@ -45,6 +45,42 @@ export interface ServerFunction<A extends readonly any[] = any[], T = any> {
     /** URL invoking this function directly over HTTP (form `action`s, raw fetches). */
     readonly url: string;
 }
+/**
+ * Per-call, invocation-scoped options for `invoke` — things that vary
+ * between calls of the SAME function and cannot be declared (`GET`,
+ * `withMeta`) or configured (`prepareRequest`). On the server the call is
+ * in-process: `signal` still rejects the caller, the transport hints are
+ * no-ops (they describe a wire that does not exist).
+ */
+export interface InvokeOptions {
+    /**
+     * The call's lifecycle. Aborting rejects the call with the signal's
+     * reason and cancels the request (firing `request.signal` server-side);
+     * a live source's iteration ends across reconnects. When provided, the
+     * signal owns the wire — timeouts compose through it
+     * (`AbortSignal.timeout`, `AbortSignal.any`).
+     */
+    signal?: AbortSignal;
+    /**
+     * Lets the request outlive the page — fire-and-forget calls during
+     * unload (`pagehide`). Maps to fetch's `keepalive`, body-size caps
+     * included.
+     */
+    keepalive?: boolean;
+    /** Fetch priority hint — speculative prefetch vs. interaction fetch. */
+    priority?: "high" | "low" | "auto";
+}
+/**
+ * A reference's invocation channel, carried under `SERVER_FUNCTION_INVOKE`:
+ * applies one call with per-call options. Declaration wrappers (`GET`,
+ * `live`) forward it mechanically — they keep the call mapping 1:1. A
+ * wrapper that shares calls (a deduping cache, a multicast channel) opts
+ * in deliberately, deciding first what a caller's abort means for shared
+ * work — or declines, leaving `invoke` to answer with a directed error.
+ * Options arrive already validated — `invoke` admits only
+ * invocation-scoped keys.
+ */
+export type ServerFunctionInvoker<A extends readonly any[] = any[], R = any> = (args: A, options?: InvokeOptions) => R;
 /**
  * Declaration-static metadata attached to a server function reference
  * through declaration wrappers (`GET`, `withMeta`). Read it with
@@ -98,8 +134,8 @@ export declare function getServerFunctionsCodec(): JSONCodecOptions | undefined;
 export declare function subscribeFlightData<D = unknown>(consumer: FlightDataConsumer<D>): () => void;
 export declare function getFlightDataConsumer(): FlightDataConsumer | undefined;
 export declare function frameAddress(id: string, args?: readonly unknown[]): string;
-/** Header carrying the server function id. */
-export declare const FUNCTION_HEADER = "X-Server-Function-Id";
+export declare function serverFunctionAddress(endpoint: string, id: string): string;
+export declare function parseServerFunctionAddress(pathname: string, endpoint: string): string | null;
 /**
  * Response header marking a thrown server-function error. The value is the
  * error's message (the structured error itself travels in the body); `"true"`
@@ -141,6 +177,13 @@ export declare const BodyFormat: {
      * included) on the response.
      */
     Json: string;
+    /**
+     * No body at all — a function that returned nothing. It marks the response
+     * as one the runtime encoded, which separates a void result with a status
+     * on it from a refusal answered by something else. Decoding falls through
+     * to `undefined`, which is what a peer predating the tag reads too.
+     */
+    Void: string;
 };
 export declare function isJSONSafe(value: unknown): boolean;
 export declare function getHeadersAndBody(body: unknown): {