@solidjs/web 2.0.0-beta.17 → 2.0.0-beta.19

package/types/server.d.ts

@@ -1,4 +1,5 @@
 import { JSX } from "./jsx.js";
+import { SerializerPlugin } from "./serializer.js";
 export const DOMWithState: Record<string, Record<string, 1 | 2>>;
 export const ChildProperties: Set<string>;
 export const DelegatedEvents: Set<string>;
@@ -11,17 +12,59 @@ export const Namespaces: Record<string, string>;
 
 type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
 
+/** Static asset manifest produced by a build (e.g. parsed Vite manifest.json). */
+export type AssetManifest = Record<
+  string,
+  { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
+> & { _base?: string };
+
+/** Inline style content, e.g. dev CSS collected from a bundler's module graph. */
+export type InlineStyleAsset = {
+  id: string;
+  content: string;
+  attrs?: Record<string, string>;
+};
+
+export type ResolvedAssets = {
+  js: string[];
+  css: (string | InlineStyleAsset)[];
+};
+
+/**
+ * Resolver form of the manifest option — the primitive a dev server
+ * implements against its live module graph (a static manifest object is
+ * normalized into a sync resolver internally). `resolve` may return a
+ * promise (async resolvers require streaming rendering); CSS entries may be
+ * URL strings (emitted as load-gated `<link>` tags) or inline-style
+ * descriptors (emitted as `<style>` tags). A bare `resolve`-shaped function
+ * is accepted as shorthand for `{ resolve }`.
+ */
+export type AssetResolver = {
+  resolve(
+    key: string
+  ): ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
+  /**
+   * Synchronous fast path answering with whatever is knowable without async
+   * work (typically js URLs, omitting css). Sync consumers — e.g. a lazy
+   * component's `moduleUrl` getter used by islands — use this when `resolve`
+   * would return a promise, so adapters should provide it whenever possible.
+   */
+  resolveSync?(key: string): ResolvedAssets | null | undefined;
+};
+
+/** Bare-function shorthand for `AssetResolver` (no sync fast path). */
+export type AssetResolverFn = (
+  key: string
+) => ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
+
 export function renderToString<T>(
   fn: () => T,
   options?: {
     nonce?: string;
     renderId?: string;
     noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<
-      string,
-      { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
-    > & { _base?: string };
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onError?: (err: any) => void;
   }
 ): string;
@@ -33,11 +76,8 @@ export function renderToStringAsync<T>(
     nonce?: string;
     renderId?: string;
     noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<
-      string,
-      { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
-    > & { _base?: string };
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onError?: (err: any) => void;
   }
 ): Promise<string>;
@@ -47,11 +87,8 @@ export function renderToStream<T>(
     nonce?: string;
     renderId?: string;
     noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<
-      string,
-      { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
-    > & { _base?: string };
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onCompleteShell?: (info: { write: (v: string) => void }) => void;
     onCompleteAll?: (info: { write: (v: string) => void }) => void;
     onError?: (err: any) => void;
@@ -95,11 +132,29 @@ export function generateHydrationScript(options?: {
   nonce?: string;
   eventNames?: string[];
 }): string;
+/**
+ * Registered symbol (`Symbol.for("solid.RequestContext")`) naming the
+ * global slot where `provideRequestEvent` parks the AsyncLocalStorage that
+ * scopes request events. Integration plumbing — application code reads the
+ * event through `getRequestEvent()` instead.
+ * @internal
+ */
 export declare const RequestContext: unique symbol;
+/**
+ * The per-request context available on the server: the incoming `Request`
+ * and a `locals` bag integrations and middleware can hang state on.
+ * Frameworks typically extend this shape with richer fields.
+ */
 export interface RequestEvent {
   request: Request;
   locals: Record<string | number | symbol, any>;
 }
+/**
+ * The current request event, when called on the server inside a request
+ * scope (established by `provideRequestEvent` from `@solidjs/web/storage`
+ * or by the framework). Undefined on the client and outside a request.
+ * Read it above `await` boundaries in partially-polyfilled environments.
+ */
 export function getRequestEvent(): RequestEvent | undefined;
 
 export function Assets(props: { children?: JSX.Element }): JSX.Element;

package/types-cjs/index.d.cts

@@ -3,6 +3,7 @@ import { Component } from "solid-js";
 import type { JSX } from "./jsx.cjs";
 export * from "./client.cjs";
 export * from "./server-mock.cjs";
+export * from "./response.cjs";
 export type { JSX } from "./jsx.cjs";
 export { For, Show, Switch, Match, Errored, Loading, Repeat, Reveal, NoHydration, Hydration } from "solid-js";
 import { merge } from "solid-js";
@@ -118,6 +119,12 @@ export declare const hydrate: typeof hydrateCore;
  * still participates in the parent's reactive scope and disposes when the
  * parent does.
  *
+ * Portals are client-only islands: the server renders nothing for them, and
+ * under hydration the children render fresh once hydration settles. Async
+ * read inside a portal therefore starts on the client — data that should be
+ * fetched on the server belongs above the portal (hoist the read, not the
+ * render), and async UI inside one wants its own `<Loading>` boundary.
+ *
  * @example
  * ```tsx
  * <Portal mount={document.getElementById("modal-root")!}>
@@ -127,7 +134,7 @@ export declare const hydrate: typeof hydrateCore;
  *
  * @description https://docs.solidjs.com/reference/components/portal
  */
-export declare function Portal<T extends boolean = false, S extends boolean = false>(props: {
+export declare function Portal(props: {
     mount?: Element;
     children: JSX.Element;
 }): JSX.Element;

package/types-cjs/response.d.cts

@@ -0,0 +1,93 @@
+/**
+ * Envelope pairing HTTP metadata (a `Response`) with an in-memory value.
+ * Produced by `respond()` and by server-function `transformResult`
+ * implementations (e.g. single-flight payloads). The HTTP handler forwards
+ * `response`'s headers and (non-redirect) status and encodes `value` as the
+ * body through the codec, while client-only integrations read `value`
+ * directly — no reparse. Mostly consumed by integrations (routers);
+ * application code usually just returns what `respond()` gives it.
+ */
+export class ResponseEnvelope<T = unknown> {
+  constructor(response: Response | undefined, value: T);
+  /** The HTTP metadata: status and headers to forward (body ignored by integrations). */
+  response: Response | undefined;
+  /** The structured value the caller receives. */
+  value: T;
+}
+
+/**
+ * Whether `value` is a `ResponseEnvelope`. Uses a registered-symbol brand
+ * rather than `instanceof`, so it stays correct when separately bundled
+ * entries each carry a copy of the class. Integrations should always use
+ * this over `instanceof`.
+ */
+export function isResponseEnvelope(value: unknown): value is ResponseEnvelope;
+
+/** `ResponseInit` accepted by the response helpers, plus `revalidate`. */
+export interface ResponseHelperInit extends ResponseInit {
+  /**
+   * Cache keys the mutation invalidated, carried in the `X-Revalidate`
+   * header. Opaque to the protocol — the integration's keyed cache (e.g.
+   * the router's `query` cache) assigns them meaning.
+   */
+  revalidate?: string | string[];
+}
+
+/**
+ * Response redirecting to `url` (default status 302). Return (or throw) it
+ * from a server function — the HTTP handler forwards the redirect for the
+ * client integration to follow — or return it from a client-side action,
+ * where the integration interprets it in memory. Same object, same
+ * meaning, both sides.
+ *
+ * @example
+ * ```ts
+ * import { redirect } from "@solidjs/web";
+ *
+ * async function login(form: FormData) {
+ *   "use server";
+ *   // ...
+ *   return redirect("/dashboard", { revalidate: "session" });
+ * }
+ * ```
+ */
+export function redirect(url: string, init?: number | ResponseHelperInit): Response;
+
+/**
+ * Empty response requesting revalidation of the named cache keys — all of
+ * them when omitted. For mutations whose only effect the caller needs is
+ * "refetch your data".
+ *
+ * @example
+ * ```ts
+ * import { reload } from "@solidjs/web";
+ *
+ * async function addTodo(title: string) {
+ *   "use server";
+ *   await db.insert(title);
+ *   return reload({ revalidate: "todos" });
+ * }
+ * ```
+ */
+export function reload(init?: ResponseHelperInit): Response;
+
+/**
+ * A value paired with response metadata (status, headers, `revalidate`) —
+ * for the things a naked return can't express. Scripted callers receive
+ * `value` transparently (the transport unwraps the envelope), and
+ * progressive enhancement stays invisible: the carried response holds a
+ * plain JSON body so consumers without the client runtime (no-JS form
+ * posts, direct HTTP) get real JSON.
+ *
+ * @example
+ * ```ts
+ * import { respond } from "@solidjs/web";
+ *
+ * async function createItem(input: Item) {
+ *   "use server";
+ *   const item = await db.create(input);
+ *   return respond(item, { status: 201, revalidate: "items" });
+ * }
+ * ```
+ */
+export function respond<T>(value: T, init?: ResponseHelperInit): ResponseEnvelope<T>;

package/types-cjs/serializer.d.cts

@@ -0,0 +1,139 @@
+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;

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

@@ -0,0 +1,63 @@
+import { JSONCodecOptions } from "../serializer.cjs";
+
+export { FUNCTION_HEADER, INSTANCE_HEADER, decodeResponse } from "./shared.cjs";
+
+/** 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` ``).
+   * @default "/_server"
+   */
+  endpoint?: string;
+  /**
+   * Codec options (extra plugins etc.) for encoding arguments and decoding
+   * results — must match the server's. Stored in the shared layer, so
+   * `decodeResponse` sees them too.
+   */
+  codec?: JSONCodecOptions;
+}
+
+/**
+ * Configures the client transport. Call once, before any server function is
+ * invoked — typically in the client entry, next to `hydrate()`. Only needed
+ * when deviating from the defaults (custom endpoint or codec plugins).
+ */
+export function configureServerFunctionsClient(config?: ServerFunctionsClientConfig): void;
+
+/**
+ * What a server function import is at runtime on the client: an async
+ * callable that fetches the server, plus escape hatches for forms and
+ * custom requests.
+ */
+export interface ServerFunctionCallable {
+  (...args: any[]): Promise<any>;
+  /** URL invoking this function directly over HTTP (e.g. form `action`s). */
+  url: string;
+  /**
+   * Variant issuing GET requests with the arguments encoded in the query
+   * string — cacheable by HTTP infrastructure.
+   */
+  GET: ServerFunctionCallable;
+  /** Variant applying a custom RequestInit to every call (headers etc.). */
+  withOptions(options: RequestInit): ServerFunctionCallable;
+}
+
+/**
+ * Compiler ABI — emitted by compiled `"use server"` client output where a
+ * server function was referenced; produces the fetch-backed callable for
+ * the function's build-stable id. Not meant for hand-written code.
+ * @internal
+ */
+export function createServerReference(id: string): ServerFunctionCallable;
+
+/**
+ * Compiler ABI — only ever referenced by server-mode compiler output;
+ * throws so a misconfigured build (server transform feeding a client
+ * bundle) fails loudly instead of with a missing-export error. Not meant
+ * for hand-written code.
+ * @internal
+ */
+export function registerServerReference(): never;

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

@@ -0,0 +1,188 @@
+import { ResponseEnvelope } from "../response.cjs";
+import { JSONCodecOptions } from "../serializer.cjs";
+import { RequestEvent } from "../server.cjs";
+
+export { FUNCTION_HEADER, INSTANCE_HEADER, decodeResponse } from "./shared.cjs";
+
+/**
+ * The request event a server function call runs under: the base
+ * `RequestEvent` (request + locals) plus `serverOnly`, set when the call is
+ * an in-process SSR invocation whose result never serializes to a client.
+ */
+export interface ServerFunctionEvent extends RequestEvent {
+  serverOnly?: boolean;
+}
+
+/** Options for `configureServerFunctionsServer`. */
+export interface ServerFunctionsServerConfig {
+  /**
+   * Establishes the request-event scope for a call — the function passed
+   * runs with `event` visible to `getRequestEvent()`. Wire it to
+   * `provideRequestEvent` from `@solidjs/web/storage` (or the framework's
+   * equivalent). When omitted, falls back to the AsyncLocalStorage instance
+   * an established request scope parks on the global.
+   */
+  provideEvent?: <T>(event: ServerFunctionEvent, fn: () => T) => T;
+  /**
+   * 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` ``).
+   * @default "/_server"
+   */
+  endpoint?: string;
+  /**
+   * Codec options (extra plugins etc.) for decoding arguments and encoding
+   * results — must match the client's. Stored in the shared layer, so
+   * `decodeResponse` sees them too.
+   */
+  codec?: JSONCodecOptions;
+}
+
+/**
+ * Configures the server runtime. Call once at server startup, before
+ * handling requests. Only needed when deviating from the defaults (custom
+ * endpoint, codec plugins, or an explicit event provider).
+ */
+export function configureServerFunctionsServer(config?: ServerFunctionsServerConfig): void;
+
+/**
+ * A registered server function: its build-stable id paired with the
+ * original implementation. Returned by `registerServerReference` and
+ * consumed by the server-side `createServerReference`.
+ *
+ * Compiler ABI shape; hand-written code rarely constructs these.
+ * @internal
+ */
+export interface ServerFunctionReference<T extends any[] = any[], R = any> {
+  id: string;
+  fn: (...args: T) => R;
+}
+
+/**
+ * Adds a function to the dispatch registry under an id and returns it
+ * unchanged. The low-level registry write for integrations registering
+ * functions outside the compiler (e.g. a router registering its own
+ * endpoints); compiled output goes through `registerServerReference`
+ * instead. Ids must be stable across the client and server builds.
+ */
+export function registerServerFunction<T extends any[], R>(
+  id: string,
+  callback: (...args: T) => R
+): (...args: T) => R;
+
+/**
+ * Looks up a registered server function by id; throws for unknown ids.
+ * The HTTP handler uses this for dispatch — integrations building custom
+ * dispatch (or introspection) can too.
+ */
+export function getServerFunction<T extends any[], R>(id: string): (...args: T) => R;
+
+/**
+ * Compiler ABI — emitted by compiled `"use server"` server output for
+ * every server function: registers `fn` for HTTP dispatch under its
+ * build-stable id and returns the reference the server-side
+ * `createServerReference` consumes. Not meant for hand-written code.
+ * @internal
+ */
+export function registerServerReference<T extends any[], R>(
+  id: string,
+  fn: (...args: T) => R
+): ServerFunctionReference<T, R>;
+
+/**
+ * Compiler ABI — emitted by compiled `"use server"` server output where
+ * the function was referenced; produces the server-side callable. Calling
+ * it during SSR runs the original function in-process (no HTTP), under a
+ * request event derived from the current one — marked `serverOnly` and
+ * carrying the function's meta. Not meant for hand-written code.
+ * @internal
+ */
+export function createServerReference<T extends any[], R>(
+  reference: ServerFunctionReference<T, R>
+): (...args: T) => R;
+
+/** Identity of the currently executing server function. */
+export interface ServerFunctionMeta {
+  id: string;
+}
+
+/**
+ * Reads the calling server function's meta (its id) off the current request
+ * event — usable inside a server function body, e.g. to key caches or logs
+ * by function. Returns undefined outside a server function call.
+ */
+export function getServerFunctionMeta(): ServerFunctionMeta | undefined;
+
+/**
+ * Hooks layering framework policy onto `handleServerFunctionRequest`.
+ * All are optional — the bare handler dispatches, scopes events, and
+ * encodes results on its own.
+ */
+export interface HandleServerFunctionOptions {
+  /**
+   * Builds the request event a call runs under (default: bare
+   * `{ request, locals: {} }`). Integrations supply their richer event
+   * (cookies, response helpers, platform handles).
+   */
+  createEvent?(request: Request): ServerFunctionEvent;
+  /**
+   * Overrides the configured event provider for this handler — same
+   * contract as the `provideEvent` config option.
+   */
+  provideEvent?<T>(event: ServerFunctionEvent, fn: () => T): T;
+  /**
+   * Observes or replaces the function's result before encoding — the
+   * extension point for policies like single-flight payloads. Runs for
+   * returned and thrown results alike (`context.thrown` distinguishes);
+   * `context.instance` is null for no-JS calls. Return the result
+   * unchanged to pass through, or a `ResponseEnvelope` (exposed through
+   * the core entry) to send HTTP metadata plus a structured payload.
+   */
+  transformResult?(
+    event: ServerFunctionEvent,
+    result: unknown,
+    context: { instance: string | null; request: Request; thrown?: boolean }
+  ): unknown | ResponseEnvelope | Promise<unknown | ResponseEnvelope>;
+  /**
+   * Builds the response for calls made without the client runtime (no
+   * instance header — no-JS form posts, direct HTTP) — the extension
+   * point for conventions like redirect-with-flash-cookie. Receives the
+   * (transformed) result, the request, and the decoded arguments; `thrown`
+   * is set when the result was thrown rather than returned. Defaults to
+   * the normal serialized response.
+   */
+  handleNoJS?(
+    result: unknown,
+    request: Request,
+    args: unknown[],
+    thrown?: boolean
+  ): Response | Promise<Response>;
+  /** Overrides the configured codec options for this handler. */
+  codec?: JSONCodecOptions;
+}
+
+/**
+ * Web-standard HTTP handler for server function calls: resolves the
+ * function id from the request, 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 request shape to a web `Request` around
+ * it.
+ *
+ * @example
+ * ```ts
+ * import { handleServerFunctionRequest } from "@solidjs/web/server-functions";
+ * import "virtual:solid-server-function-manifest";
+ *
+ * // in the server's request handling:
+ * if (url.pathname.startsWith("/_server")) {
+ *   return handleServerFunctionRequest(request);
+ * }
+ * ```
+ */
+export function handleServerFunctionRequest(
+  request: Request,
+  options?: HandleServerFunctionOptions
+): Promise<Response>;