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

package/types/serializer.d.ts

@@ -1,182 +1,94 @@
-// Serialization surface (published as `@solidjs/web/serialization`): the
-// runtime's Seroval machinery, exposed for the runtime's own entries and
-// for integrations building transports on the same codec. This is
-// INTEGRATION-FACING plumbing, not application API — it is exempt from the
-// 2.0 stability guarantee and may change between releases. Application and
-// router code should configure `codec` on the server-function entries
-// instead of importing from here.
-import type { Serializer } from "seroval";
-import {
-  JSONCodecOptions,
-  PluginInfo,
-  SerializerPlugin,
-  SerovalNode
-} from "./serializer-decode.js";
-
-// The decode half — `SerovalNode`, the plugin TYPES, `DEFAULT_WEB_PLUGINS`,
-// `resolveSerializerPlugins`, `JSONCodecOptions`, `createJSONDeserializer`,
-// `createJSONDataTable` — is declared in serializer-decode.d.ts (published
-// as `@solidjs/web/serialization/decode`, the module lazy client consumers
-// load) and re-exported here so this remains the full surface.
-export * from "./serializer-decode.js";
-
-// ---- Plugin authoring ----
-//
-// Unlike the rest of this entry, plugin authoring is APPLICATION-FACING —
-// it is the supported way to feed the serializers' `plugins` options and
-// the server-function entries' `codec.plugins`. The values re-export
-// seroval's own (`createPlugin`, `OpaqueReference` — see serializer.js);
-// the plugin TYPES live in serializer-decode.d.ts (hand-declared there —
-// see its banner for why).
-
-/**
- * Builds a `SerializerPlugin` — seroval's `createPlugin`, re-exported so
- * plugin authors stay on the exact seroval instance/version the runtime
- * serializes with. Import it from HERE, not from your own `seroval`
- * dependency: a plugin built against a different copy/version would not
- * fail the build — it would emit nodes the other peer can't interpret.
- *
- * Application-facing (see the plugin-authoring banner above).
- */
-export function createPlugin<Value, Info extends PluginInfo>(
-  plugin: SerializerPlugin<Value, Info>
-): SerializerPlugin<Value, Info>;
-
-/**
- * Seroval's `OpaqueReference`, re-exported from the runtime's own instance
- * (an `OpaqueReference` from another seroval copy fails the serializer's
- * instanceof check and serializes as a plain value): wraps a value so it
- * crosses the wire as its `replacement` (default `undefined`) while
- * staying readable in-process through `.value`.
- *
- * Application-facing (see the plugin-authoring banner above).
- */
-export class OpaqueReference<V, R = undefined> {
-  readonly value: V;
-  readonly replacement?: R;
-  constructor(value: V, replacement?: R);
-}
-
+import { Serializer } from "seroval";
+import type { JSONCodecOptions, PluginInfo, SerializerPlugin, SerovalNode } from "./serializer-decode.js";
+export { DEFAULT_WEB_PLUGINS, createJSONDataTable, createJSONDeserializer, resolveSerializerPlugins } from "./serializer-decode.js";
+export type * from "./serializer-decode.js";
 /**
  * Options for `createSerializer`.
  *
  * Integration-facing; may change (see the entry banner).
  */
 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). Outside
-   * development, `Error.prototype.stack` is additionally stripped on top of
-   * any override — serialized stacks leak server paths to the client.
-   */
-  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;
+    /** 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). Outside
+     * development, `Error.prototype.stack` is additionally stripped on top of
+     * any override — serialized stacks leak server paths to the client.
+     */
+    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.
- *
- * Integration-facing; may change (see the entry banner).
- */
-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) ----
-// (`JSONCodecOptions` and the decode half are declared in
-// serializer-decode.d.ts and re-exported above.)
-
+export type HydrationSerializerOptions = Omit<WebSerializerOptions, "globalIdentifier" | "disabledFeatures">;
 /**
  * Options for `serializeJSON`.
  *
  * Integration-facing; may change (see the entry banner).
  */
 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;
+    /**
+     * 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.
- *
- * Integration-facing; may change (see the entry banner).
- */
-export function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
-
 /** Options for `createJSONSerializer`. */
 export interface JSONSerializerOptions extends JSONCodecOptions {
-  /**
-   * Receives each keyed record — `initial` is true for a key's first node
-   * (the written value itself); async values patch through later records
-   * under the same key. The decoding peer is `createJSONDataTable`.
-   */
-  onData: (record: { key: string; node: SerovalNode; initial: boolean }) => void;
-  onError?: (error: unknown) => void;
-  /** Fires once `flush()` has been called and every pending value settled. */
-  onDone?: () => void;
+    /**
+     * Receives each keyed record — `initial` is true for a key's first node
+     * (the written value itself); async values patch through later records
+     * under the same key. The decoding peer is `createJSONDataTable`.
+     */
+    onData: (record: {
+        key: string;
+        node: SerovalNode;
+        initial: boolean;
+    }) => void;
+    onError?: (error: unknown) => void;
+    /** Fires once `flush()` has been called and every pending value settled. */
+    onDone?: () => void;
+}
+export declare const createPlugin: <Value, Info extends PluginInfo>(plugin: SerializerPlugin<Value, Info>) => SerializerPlugin<Value, Info>;
+export interface OpaqueReference<V = unknown, R = undefined> {
+    readonly value: V;
+    readonly replacement?: R;
 }
-
+export declare const OpaqueReference: {
+    new <V, R = undefined>(value: V, replacement?: R): OpaqueReference<V, R>;
+};
 /**
- * The keyed, streaming encoder of the eval-free JSON codec — the render
- * stream's data serializer (frames default to it). Each `write(key, value)`
- * shares one reference space, so cross-record identity holds; `flush()`
- * marks the write set complete (writes after it are dropped, mirroring the
- * hydration serializer); `close()` aborts pending async serialization.
+ * 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.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
-export function createJSONSerializer(options: JSONSerializerOptions): {
-  write(key: string, value: unknown): void;
-  flush(): void;
-  close(): void;
+export declare function createSerializer(options: WebSerializerOptions): Serializer;
+export declare function createHydrationSerializer(options: HydrationSerializerOptions): Serializer;
+export declare function getLocalHeaderScript(id?: string): string;
+export declare function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
+export declare function createJSONSerializer(options: JSONSerializerOptions): {
+    write(key: string, value: unknown): void;
+    flush(): void;
+    close(): void;
 };

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

@@ -1,50 +1,17 @@
-import { JSONCodecOptions } from "../serializer-decode.js";
-import { ServerFunction, ServerFunctionMetadata } from "./shared.js";
-
-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";
-export type {
-  FlightDataConsumer,
-  FlightDataContext,
-  ServerFunction,
-  ServerFunctionMetadata,
-  SingleFlightPayload
-} from "./shared.js";
-
+import { JSONCodecOptions } from "../serializer-decode.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. */
-  id: string;
-  /**
-   * The reference's declaration metadata (e.g. `method: "GET"` for
-   * `GET(fn)` references). Plain references carry an empty object.
-   */
-  meta: ServerFunctionMetadata | undefined;
+    /** The build-stable id of the function being called. */
+    id: string;
+    /**
+     * The reference's declaration metadata (e.g. `method: "GET"` for
+     * `GET(fn)` references). Plain references carry an empty object.
+     */
+    meta: ServerFunctionMetadata | undefined;
 }
-
 /**
  * Client-side session-dynamic transport hook: runs before every
  * server-function fetch. Return (or mutate and return) the RequestInit the
@@ -54,141 +21,119 @@ export interface PrepareRequestContext {
  * the client-side symmetric of the server handler hooks. Single hook, not
  * a chain — compose by wrapping functions in userland.
  */
-export type PrepareRequestHook = (
-  init: RequestInit,
-  context: PrepareRequestContext
-) => RequestInit | Promise<RequestInit>;
-
+export type PrepareRequestHook = (init: RequestInit, context: PrepareRequestContext) => RequestInit | Promise<RequestInit>;
 /** 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;
-  /**
-   * Runs before every server-function fetch. Return (or mutate and return)
-   * the RequestInit the transport will use; `context.meta` is the
-   * reference's declaration metadata (e.g. method). For session-dynamic
-   * cross-cutting concerns — bearer tokens, tracing headers:
-   *
-   * ```ts
-   * configureServerFunctionsClient({
-   *   prepareRequest(init) {
-   *     return {
-   *       ...init,
-   *       headers: { ...init.headers, Authorization: `Bearer ${session.token()}` }
-   *     };
-   *   }
-   * });
-   * ```
-   */
-  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>;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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
+     * reference's declaration metadata (e.g. method). For session-dynamic
+     * cross-cutting concerns — bearer tokens, tracing headers:
+     *
+     * ```ts
+     * configureServerFunctionsClient({
+     *   prepareRequest(init) {
+     *     return {
+     *       ...init,
+     *       headers: { ...init.headers, Authorization: `Bearer ${session.token()}` }
+     *     };
+     *   }
+     * });
+     * ```
+     */
+    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>;
 }
-
-/**
- * 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, codec plugins, or a
- * `prepareRequest` hook).
- */
-export function configureServerFunctionsClient(config?: ServerFunctionsClientConfig): void;
-
 export interface ServerFunctionRequestCall {
-  type: "request";
-  id: string;
-  instance: string;
-  request: Request;
-  meta: ServerFunctionMetadata | undefined;
-  time: number;
+    type: "request";
+    id: string;
+    instance: string;
+    request: Request;
+    meta: ServerFunctionMetadata | undefined;
+    time: number;
 }
-
 export interface ServerFunctionResponseCall {
-  type: "response";
-  id: string;
-  instance: string;
-  response: Response;
-  meta: ServerFunctionMetadata | undefined;
-  time: number;
+    type: "response";
+    id: string;
+    instance: string;
+    response: Response;
+    meta: ServerFunctionMetadata | undefined;
+    time: number;
 }
-
 export type ServerFunctionCall = ServerFunctionRequestCall | ServerFunctionResponseCall;
-
-/**
- * Observes cloned requests and responses without handling them. Subscribe
- * from devtools; do not use this to replace `prepareRequest` /
- * `responseHandler`. The server entry exports a no-op of the same name so
- * isomorphic `@solidjs/web/server-functions` imports resolve.
- */
-export function observeServerFunctionCalls(
-  observer: (call: ServerFunctionCall) => void
-): () => void;
-
-/**
- * Declares a server function callable over HTTP GET: calls to the returned
- * reference go out as GET requests with the arguments codec-encoded in the
- * query string — cacheable by HTTP infrastructure. Cache headers flow
- * through the handler's header forwarding
- * (`respond(data, { headers: { "cache-control": "max-age=60" } })`).
- *
- * The declaration rides the metadata channel
- * (`getServerFunctionMetadata(fn)?.method === "GET"`) for routers and
- * 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:
- *
- * ```ts
- * export const getUser = GET(async (id: string) => {
- *   "use server";
- *   return db.users.find(id);
- * });
- * ```
- */
-export function GET<A extends readonly any[], R>(
-  fn: (...args: A) => R
-): ServerFunction<A, Awaited<R>>;
-
 /** Wire-state transitions a live call's iterable can report. */
 export type LiveSourceStatus = "connected" | "reconnecting" | "closed";
-
 /**
  * A live call's answer: the source's iterable, plus an optional `onstatus`
  * side channel for the wire facts the reconnect loop erases from the value
@@ -198,65 +143,22 @@ export type LiveSourceStatus = "connected" | "reconnecting" | "closed";
  * end was a definite rejection (4xx) failing fast instead of retrying.
  */
 export type LiveSource<R> = R & {
-  onstatus?: (state: LiveSourceStatus, error?: unknown) => void;
+    onstatus?: (state: LiveSourceStatus, error?: unknown) => void;
 };
-
-/**
- * Declares a value-shaped live source: a server function returning an async
- * iterable whose yields are successive VALUES of one logical query, with the
- * contract that the source re-yields current state on every invocation.
- * Calls to the returned reference produce an iterable that survives the
- * connection — post-connect deaths re-invoke with exponential backoff
- * (reset per healthy value, woken early by connectivity returning),
- * first-connect failures reject like a normal call, and `break` aborts the
- * in-flight request. Live calls are reads and never opt into single-flight
- * enveloping. Wire state, if wanted, rides the returned iterable's
- * `onstatus` hook. Compose with `GET` inside-out: `live(GET(fn))`.
- */
-export function live<A extends readonly any[], R>(
-  fn: (...args: A) => R
-): ServerFunction<A, LiveSource<Awaited<R>>>;
-
-/**
- * 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. Development builds pass the function's
- * 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, base?: string): ServerFunction;
-
-/**
- * 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;
-
 /**
  * Identity of the currently executing server function call — see the
  * server entry. Named here so isomorphic code can import the type from
  * either entry.
  */
 export interface ServerFunctionInvocation {
-  id: string;
+    id: string;
 }
-
-/**
- * Client no-op mirror of the server entry's accessor: there is never a
- * server function call in flight on the client, so this always returns
- * undefined. Present so `"use server"` modules that import it stay
- * import-stable in client builds before dead-code elimination.
- */
-export function getServerFunctionInvocation(): ServerFunctionInvocation | undefined;
+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>>;
+export declare function live<A extends readonly any[], R>(fn: (...args: A) => R): ServerFunction<A, LiveSource<Awaited<R>>>;
+export declare function registerServerReference(): never;
+export declare function getServerFunctionInvocation(): ServerFunctionInvocation | undefined;