@solidjs/web 2.0.0-rc.0 → 2.0.0-rc.1

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

@@ -156,6 +156,36 @@ 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
+ * stream — `"connected"` on each successful (re)connect, `"reconnecting"`
+ * (with the error) on each post-connect death, `"closed"` when the source
+ * completes or the consumer ends it.
+ */
+export type LiveSource<R> = R & {
+  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

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

@@ -392,6 +392,34 @@ 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 (client side). */
+export type LiveSourceStatus = "connected" | "reconnecting" | "closed";
+
+/**
+ * Type-level mirror of the client's live answer shape so isomorphic code
+ * assigning `onstatus` typechecks against either build's declarations. On
+ * the server the hook is inert: in-process calls hand back the source's
+ * own iterable — there is no connection to report on.
+ */
+export type LiveSource<R> = R & {
+  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.
+ * Writes `live: true` on the metadata channel and brands the resolved
+ * iterable (registered symbol `solid.LiveSource`) so SSR faces meeting the
+ * value in-process can apply live policy (document face: first value, then
+ * client takeover). Dispatch is untouched — over-the-wire calls stream the
+ * raw registered function's result. Declare live outermost:
+ * `live(GET(fn))`.
+ */
+export function live<A extends readonly any[], R>(
+  fn: (...args: A) => R
+): ServerFunction<A, LiveSource<Awaited<R>>>;
+
 /** Identity of the currently executing server function call. */
 export interface ServerFunctionInvocation {
   id: string;