@solidjs/web 2.0.0-beta.27 → 2.0.0-beta.29

package/server-functions/dist/server.js

@@ -6,6 +6,7 @@ const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
 function isResponseEnvelope(value) {
   return !!(value && typeof value === "object" && value[ENVELOPE]);
 }
+const REVALIDATE_HEADER = "X-Revalidate";
 
 Feature.AggregateError | Feature.BigIntTypedArray;
 const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : Feature.ErrorPrototypeStack;
@@ -341,6 +342,18 @@ async function decodeResponse(response, codecOptions) {
   if (!response.body) return undefined;
   return await extractBody(response, codecOptions === undefined ? codecConfig.codec : codecOptions);
 }
+async function decodeResponsePayload(response, codecOptions) {
+  const decoded = await decodeResponse(response, codecOptions);
+  if (decoded !== undefined && response.headers.has(SINGLE_FLIGHT_HEADER)) {
+    return {
+      value: decoded.value,
+      flightData: decoded.data
+    };
+  }
+  return {
+    value: decoded
+  };
+}
 
 function encodeInputValue(value) {
   if (value instanceof FormData) return {
@@ -395,6 +408,7 @@ const config = {
   provideEvent: undefined,
   collectFlightData: undefined,
   transformResult: undefined,
+  transformFlightResult: undefined,
   transformDirectResult: undefined,
   handleNoJS: undefined,
   endpoint: "/_server"
@@ -403,6 +417,7 @@ function configureServerFunctionsServer({
   provideEvent,
   collectFlightData,
   transformResult,
+  transformFlightResult,
   transformDirectResult,
   handleNoJS,
   endpoint,
@@ -411,6 +426,7 @@ function configureServerFunctionsServer({
   if (provideEvent !== undefined) config.provideEvent = provideEvent;
   if (collectFlightData !== undefined) config.collectFlightData = collectFlightData;
   if (transformResult !== undefined) config.transformResult = transformResult;
+  if (transformFlightResult !== undefined) config.transformFlightResult = transformFlightResult;
   if (transformDirectResult !== undefined) config.transformDirectResult = transformDirectResult;
   if (handleNoJS !== undefined) config.handleNoJS = handleNoJS;
   if (endpoint !== undefined) config.endpoint = endpoint;
@@ -424,6 +440,7 @@ function provideEvent(event, fn) {
 }
 const REGISTRATIONS = new Map();
 const METHODS = new Map();
+const INVOCATIONS = new WeakMap();
 function registerServerFunction(id, callback) {
   REGISTRATIONS.set(id, callback);
   return callback;
@@ -467,9 +484,9 @@ function createServerReference({
       const evt = {
         ...ogEvt
       };
-      evt.locals.serverFunctionMeta = {
+      INVOCATIONS.set(evt, {
         id
-      };
+      });
       evt.serverOnly = true;
       const result = provideEvent(evt, () => {
         return fn.apply(thisArg, args);
@@ -478,11 +495,13 @@ function createServerReference({
       if (transform && result && typeof result.then === "function") {
         return result.then(value => transform(value, {
           id,
+          args,
           event: evt
         }));
       }
       return transform ? transform(result, {
         id,
+        args,
         event: evt
       }) : result;
     }
@@ -497,9 +516,11 @@ function GET(fn) {
     method: "GET"
   });
 }
-function getServerFunctionMeta() {
-  const event = getRequestEvent();
-  return event && event.locals.serverFunctionMeta;
+function getServerFunctionInvocation() {
+  return getEventServerFunctionInvocation(getRequestEvent());
+}
+function getEventServerFunctionInvocation(event) {
+  return event && INVOCATIONS.get(event);
 }
 function resolveFunctionId(request, url) {
   const reference = request.headers.get(FUNCTION_HEADER);
@@ -529,15 +550,49 @@ async function parseArguments(request, url, instance, codec) {
   }
   return parsed;
 }
-async function foldFlightData(hook, event, headers, outcome) {
+async function foldFlightData(hook, event, headers, outcome, context = {}) {
+  if (outcome.value instanceof Response && outcome.value.body) return outcome.value;
+  digestOutcome(event, outcome);
   const data = await hook(event, outcome);
   if (data === undefined) return outcome.value;
   headers.set(SINGLE_FLIGHT_HEADER, "true");
+  if (context.transformFlightResult) {
+    const transformed = await context.transformFlightResult(event, {
+      value: outcome.value,
+      data
+    }, context);
+    if (transformed !== undefined) {
+      for (const cookie of headers.getSetCookie()) transformed.headers.append("Set-Cookie", cookie);
+      headers.forEach((value, key) => {
+        if (key !== "set-cookie" && !transformed.headers.has(key)) {
+          transformed.headers.set(key, value);
+        }
+      });
+      return transformed;
+    }
+  }
   return {
     value: outcome.value,
     data
   };
 }
+function digestOutcome(event, outcome) {
+  const {
+    request,
+    response
+  } = outcome;
+  outcome.revalidateKeys = response?.headers.get(REVALIDATE_HEADER)?.split(",");
+  outcome.foldedHeaders = foldSetCookies(request.headers, [...(event.response?.headers?.getSetCookie() ?? []), ...(response?.headers?.getSetCookie() ?? [])]);
+  try {
+    const referrer = request.headers.get("referer");
+    if (referrer) {
+      const location = response?.headers.get("Location");
+      const target = location ? new URL(location, request.url) : new URL(referrer);
+      if (target.origin === new URL(request.url).origin) outcome.targetUrl = target.toString();
+    }
+  } catch {
+  }
+}
 function parseSetCookie(setCookie) {
   const [pair, ...attributes] = setCookie.split(";");
   const eq = pair.indexOf("=");
@@ -676,22 +731,29 @@ async function handleServerFunctionRequest(request, options = {}) {
   const provide = options.provideEvent || provideEvent;
   const flightHook = options.collectFlightData !== undefined ? options.collectFlightData : config.collectFlightData;
   const transformResult = options.transformResult !== undefined ? options.transformResult : config.transformResult;
+  const transformFlightResult = options.transformFlightResult !== undefined ? options.transformFlightResult : config.transformFlightResult;
   const handleNoJS = options.handleNoJS !== undefined ? options.handleNoJS : config.handleNoJS !== undefined ? config.handleNoJS : isFormPost(request) ? defaultNoJSHandler || (defaultNoJSHandler = createNoJSHandler()) : undefined;
   const collectsFlight = !!(flightHook && instance && request.headers.has(SINGLE_FLIGHT_HEADER));
   const parsed = await parseArguments(request, url, instance, codec);
+  const flightContext = {
+    id: functionId,
+    args: parsed,
+    instance,
+    request,
+    collectsFlight,
+    codec,
+    transformFlightResult
+  };
   const headers = new Headers();
   try {
     let result = await provide(event, async () => {
-      event.locals.serverFunctionMeta = {
+      INVOCATIONS.set(event, {
         id: functionId
-      };
+      });
       return serverFunction(...parsed);
     });
     if (transformResult) {
-      result = await transformResult(event, result, {
-        instance,
-        request
-      });
+      result = await transformResult(event, result, flightContext);
     }
     let status = 200;
     let metadata;
@@ -733,7 +795,8 @@ async function handleServerFunctionRequest(request, options = {}) {
         response: metadata,
         request,
         thrown: false
-      });
+      }, flightContext);
+      if (result instanceof Response && result.headers.has("X-Content-Raw")) return result;
     }
     if (!instance) {
       if (handleNoJS) return handleNoJS(result, request, parsed);
@@ -745,8 +808,7 @@ async function handleServerFunctionRequest(request, options = {}) {
     if (x instanceof Response || isResponseEnvelope(x)) {
       if (transformResult) {
         x = await transformResult(event, x, {
-          instance,
-          request,
+          ...flightContext,
           thrown: true
         });
       }
@@ -784,7 +846,11 @@ async function handleServerFunctionRequest(request, options = {}) {
           response: metadata,
           request,
           thrown: true
-        });
+        }, flightContext);
+        if (x instanceof Response && x.headers.has("X-Content-Raw")) {
+          x.headers.set(ERROR_HEADER, "true");
+          return x;
+        }
       }
       headers.set(ERROR_HEADER, "true");
       if (!instance) {
@@ -806,4 +872,4 @@ async function handleServerFunctionRequest(request, options = {}) {
   }
 }
 
-export { ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, GET, INSTANCE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, configureServerFunctionsServer, createNoJSHandler, createServerReference, decodeErrorHeaderValue, decodeFlashCookie, decodeResponse, encodeErrorHeaderValue, encodeFlashCookie, foldSetCookies, getServerFunction, getServerFunctionMeta, getServerFunctionMetadata, handleServerFunctionRequest, hasFlashCookie, isServerFunction, registerServerFunction, registerServerReference, subscribeFlightData, withMeta };
+export { ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, GET, INSTANCE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, configureServerFunctionsServer, createNoJSHandler, createServerReference, decodeErrorHeaderValue, decodeFlashCookie, decodeResponse, decodeResponsePayload, encodeErrorHeaderValue, encodeFlashCookie, foldSetCookies, getEventServerFunctionInvocation, getServerFunction, getServerFunctionInvocation, getServerFunctionMetadata, handleServerFunctionRequest, hasFlashCookie, isServerFunction, registerServerFunction, registerServerReference, subscribeFlightData, withMeta };

package/types/client.d.ts

@@ -148,6 +148,21 @@ export function generateHydrationScript(options?: {
   eventNames?: string[];
 }): string;
 export function Assets(props: { children?: JSX.Element }): JSX.Element;
+/**
+ * See the server entry's `ResponseStub` — the shape of the mutable response
+ * head integrations expose as `event.response` via module augmentation.
+ */
+export interface ResponseStub {
+  status?: number;
+  statusText?: string;
+  headers: Headers;
+  /**
+   * Set by the integration once the response head has been derived/sent
+   * from this stub (status/headers can no longer change); consumers must
+   * treat later writes and cleanup-time retractions as no-ops.
+   */
+  committed?: boolean;
+}
 export interface RequestEvent {
   request: Request;
   locals: Record<string | number | symbol, any>;

package/types/core.d.ts

@@ -1,4 +1,4 @@
-export { getOwner, runWithOwner, createComponent, createRoot as root, sharedConfig, untrack, merge as mergeProps, flatten, ssrHandleError, ssrScope, NoHydration, Hydration } from "solid-js";
+export { getOwner, runWithOwner, createComponent, createRoot as root, sharedConfig, untrack, merge as mergeProps, flatten, ssrHandleError, ssrScope, NoHydration, Hydration, runInServerComponentScope } from "solid-js";
 export declare const effect: (fn: any, effectFn: any, options: any) => void;
 export declare const memo: (fn: any) => import("solid-js").SourceAccessor<any>;
 export declare const runWithHydrationScope: (id: any, fn: any) => unknown;

package/types/frames/client.d.ts

@@ -1,14 +1,17 @@
 export { createFrame, createFrameHost, createFrameElement, FRAME_APPLIED_EVENT } from "./frame-client.js";
 export { FRAME_STREAM_HEADER, applyFrameResponse, isFrameStreamResponse, createServerComponentHandler } from "./frame-transport.js";
 export { createJSONDataTable } from "./serializer.js";
+export type { Slot } from "./server.js";
 export declare function getFrameHost(): any;
 /**
  * Installs the server-component transport policy on the server-function
- * client: boundary identity derives from the reactive owner captured at
- * each call site (`getOwner`), so distinct `dynamic()` sources get
- * independent boundaries with nothing declared, refetches from the same
- * source resolve to the identical component, and ownerless calls fall back
- * to one boundary per function id.
+ * client: boundary identity is the call's intrinsic (function, arguments)
+ * address — per-args, exactly like the query cache, so a cached component
+ * always mounts the boundary showing the call it was cached for. Repeat
+ * calls for the same args resolve the identical component (refetches morph
+ * in place, cache hits pass `dynamic`'s equals-gate); a source switching
+ * args swaps boundaries, re-materialized instantly from the host's
+ * retained state.
  *
  * Call once in the client entry (an explicit call — the package is
  * `sideEffects: false`, so a bare import would be tree-shaken away);

package/types/frames/frame-client.d.ts

@@ -71,6 +71,14 @@ export interface SlotContext {
    * re-call displaced (e.g. `{$frame}` region ranges) is dropped.
    */
   adopted?: boolean;
+  /**
+   * Whether this occurrence is a render-prop CALL (the producer placed it
+   * with arguments — possibly empty — via a slot record) as opposed to a
+   * direct-insert position. Consumers cannot tell from the resolved props
+   * alone: an argless render prop and a direct insert both arrive as `{}`,
+   * but one is a function to invoke and the other a value to place.
+   */
+  invoked?: boolean;
   /**
    * Register cleanup for when this occurrence's range is removed from the
    * server content, or the owning frame is disposed.
@@ -83,6 +91,15 @@ export interface SlotContext {
    * in place (zero DOM mutation).
    */
   existing: ChildNode[];
+  /**
+   * The range's own marker comments, when the occurrence has a placed range.
+   * A framework binding whose slot content is reactive at the top level (a
+   * boundary accessor, changing route children) owns the interior instead of
+   * returning nodes: bind before `end` with the framework's insert primitive
+   * and return `undefined` — the frame leaves the range alone (server morphs
+   * already protect slot ranges).
+   */
+  range?: { start: Comment; end: Comment };
 }
 
 /**

package/types/frames/frame-sink.d.ts

@@ -126,16 +126,39 @@ export function createDocumentSlotProps(
  * 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.
+ * slot props), branded with its function id and the call's wire address.
+ * Non-function results pass through.
  */
-export function frameTransformDirectResult<T>(value: T, options: { id: string }): T;
+export function frameTransformDirectResult<T>(
+  value: T,
+  options: { id: string; args?: unknown[] }
+): 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.
+ * The frame half of single-flight, as a `transformFlightResult` policy for
+ * `handleServerFunctionRequest`: when part of what a mutation invalidated is
+ * markup (a component-valued flight-data entry), the frame stream carries
+ * the whole payload — each component's content as a region addressed by its
+ * call, the `{ value, data }` envelope as `outcome` chunks with the
+ * component entries serialized as flight references. Returns `undefined`
+ * when nothing invalidated is markup (the response stays the plain
+ * single-flight envelope).
  */
-export const ServerComponentPlugin: unknown;
+export function frameTransformFlightResult(
+  event: unknown,
+  outcome: { value: unknown; data: unknown },
+  context?: unknown
+): Promise<Response | undefined>;
+
+// The brands and the codec plugin live with the transport (client bundles
+// resolve flight references against the live registry); re-exported here for
+// server integrations importing the document-SSR surface.
+export {
+  SERVER_COMPONENT,
+  SERVER_COMPONENT_ADDRESS,
+  SERVER_COMPONENT_SOURCE,
+  ServerComponentPlugin
+} from "./frame-transport.js";
 
 /**
  * Inline bootstrap for the document shell: installs the `self._$SC`

package/types/frames/frame-transport.d.ts

@@ -1,4 +1,11 @@
 import { FrameChunk, FrameHost } from "./frame-client.js";
+import { JSONCodecOptions } from "./serializer.js";
+
+// Structural mirror of server-functions/shared.js's FlightDataConsumer:
+// this file may only reference siblings that ship with it when integrations
+// copy the frames declaration set (solid-web's types build), and the
+// server-functions declarations are copied to a different root.
+type FlightConsumer = (data: unknown, context: { response: Response }) => void | Promise<void>;
 
 /**
  * Header tagging a Response as a frame stream; its value is the producing
@@ -23,9 +30,24 @@ export interface ApplyFrameResponseOptions {
    * 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.
+   * counter to make policy A's stale-guard real across navigations. A
+   * single-flight response addresses several boundaries, each with its own
+   * history — pass a function and it is called once per frame in the
+   * response.
+   */
+  version?: number | ((frameId: string) => number);
+  /**
+   * Remap any frame id other than the response's own root onto a local one
+   * — how a consumer resolves the addresses a single-flight response uses
+   * for the regions it refreshed.
    */
-  version?: number;
+  route?(id: string): string;
+  /**
+   * Receives the payload text of each `outcome` chunk — the response-scoped
+   * single-flight envelope, the caller's result rather than anything the
+   * host renders.
+   */
+  onOutcome?(payload: string): void;
 }
 
 /**
@@ -48,6 +70,31 @@ export function applyFrameResponse(
   options?: ApplyFrameResponseOptions
 ): Promise<string>;
 
+/** Brands an inline-rendered server component with its function id. */
+export const SERVER_COMPONENT: unique symbol;
+
+/** The unwrapped server component behind an inline-render wrap. */
+export const SERVER_COMPONENT_SOURCE: unique symbol;
+
+/** The call's wire address (`frameAddress`), for regions to be emitted under. */
+export const SERVER_COMPONENT_ADDRESS: unique symbol;
+
+/**
+ * Seroval plugin for a server component crossing a serialization boundary:
+ * a branded component serializes as a REFERENCE — a per-function document
+ * placeholder in the hydration serializer, a live-registry lookup by call
+ * address in the JSON codec (single-flight envelopes) — its markup never
+ * rides as data.
+ */
+export const ServerComponentPlugin: unknown;
+
+/**
+ * The codec options for a single-flight envelope: `codec` plus
+ * `ServerComponentPlugin` (deduped by tag). Injected by the protocol on both
+ * legs; exported for integrations composing their own flight carriers.
+ */
+export function flightCodec(codec?: JSONCodecOptions): JSONCodecOptions;
+
 /** Options for `createServerComponentHandler`. */
 export interface ServerComponentHandlerOptions<C = unknown> {
   host: FrameHost;
@@ -57,12 +104,6 @@ export interface ServerComponentHandlerOptions<C = unknown> {
    * 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
@@ -83,6 +124,18 @@ export interface ServerComponentHandlerOptions<C = unknown> {
    * never observes a pending beat.
    */
   intercept?(info: { id: string; meta: unknown; args: unknown[] }): C | undefined;
+  /**
+   * Reads the registered single-flight consumer at delivery time. The
+   * consumer is module state in the server-function client's SHARED
+   * instance; pass a getter reading that instance when your bundling gives
+   * this module a private copy. Defaults to the local copy's reader.
+   */
+  consumer?(): FlightConsumer | undefined;
+  /**
+   * Reads the configured codec options at decode time — same instance-
+   * identity contract as `consumer`. Defaults to the local copy's reader.
+   */
+  codec?(): JSONCodecOptions | undefined;
 }
 
 /**
@@ -92,15 +145,26 @@ export interface ServerComponentHandlerOptions<C = unknown> {
  * (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.
+ * Boundary identity is derived, never declared: every call keys by its
+ * intrinsic (function, arguments) address — the query cache's per-args rule,
+ * so cached components and boundaries stay one-to-one. Same-args calls
+ * resolve the identical component and morph in place; an args switch swaps
+ * boundaries, re-materialized from the host's retained state.
  */
 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;
+  /**
+   * Declares that the document is showing a call: hydration-data references
+   * carry their call's address (`_$SC.r(id, address)`) but never travel
+   * through the transport, so the integration forwards those records here —
+   * they are how a post-load call for the same (function, arguments) finds
+   * its way back to the adopted boundary. `component` must be the exact
+   * reference the integration's cache holds for the call (the per-function
+   * placeholder), or readers' equals-gates fail into remounts.
+   */
+  showing(address: string, functionId: string, component: C): void;
 };

package/types/frames/server.d.ts

@@ -1,2 +1,30 @@
-export { renderToFrameStream, renderServerComponent, serverComponentResponse, frameTransformResult, createFrameSink, frameTransformDirectResult, ServerComponentPlugin, SERVER_COMPONENT_BOOTSTRAP } from "./frame-sink.js";
+import type { Element as SolidElement } from "solid-js";
+/**
+ * A client position in a server component: a prop the server renders (as JSX
+ * or by calling it) where client-owned markup belongs. `P` is the client
+ * component's own props, so a server component can reference the client
+ * component's type directly instead of restating it.
+ *
+ * Arguments are classified by VALUE, not by name — any prop may carry any of
+ * these:
+ *
+ * - primitives ride the chunk;
+ * - server JSX streams as a nested region (html once, never data);
+ * - anything else serializes as a data record.
+ *
+ * Async server JSX in an argument needs its own boundary: the region is
+ * emitted as one finished string, so a bare async read has no fallback to
+ * show and no fragment to reveal into.
+ *
+ * `$key` names the occurrence so client state follows an entity across
+ * responses rather than being positional — the slot-level analogue of `For`'s
+ * `keyed`, for when references can't carry identity because every response
+ * re-creates everything. It is occurrence identity, not client data: it is
+ * stripped before the client component sees its props. Positional identity is
+ * the right default; `$key` matters when a live list reorders.
+ */
+export type Slot<P = {}> = (props: P & {
+    $key?: string | number;
+}) => SolidElement;
+export { renderToFrameStream, renderServerComponent, serverComponentResponse, frameTransformResult, frameTransformFlightResult, createFrameSink, frameTransformDirectResult, ServerComponentPlugin, SERVER_COMPONENT_BOOTSTRAP } from "./frame-sink.js";
 export { FRAME_STREAM_HEADER, isFrameStreamResponse } from "./frame-transport.js";

package/types/index.d.ts

@@ -176,3 +176,77 @@ export declare function dynamic<T extends ValidComponent>(source: () => T | Prom
  * @description https://docs.solidjs.com/reference/components/dynamic
  */
 export declare function Dynamic<T extends ValidComponent>(props: DynamicProps<T>): JSX.Element;
+/**
+ * Wraps a dynamically imported component so it renders only in the browser.
+ * The server renders `props.fallback` (and nothing else); the client shows
+ * the fallback until the import resolves and the tree has mounted, then
+ * swaps the real component in.
+ *
+ * Unlike `lazy()`, this avoids Suspense entirely and never server-renders
+ * the wrapped component — only the fallback — so the component participates
+ * in no hydration asset manifest and its code is guaranteed to never run on
+ * the server (safe for browser-only libraries touching `window`, DOM
+ * measurement, etc.). The mount gate keeps hydration safe: during hydration
+ * the fallback is rendered exactly as the server did, and the swap happens
+ * only after settle, so there is no mismatch.
+ *
+ * By default the import starts as soon as `clientOnly` is called (module
+ * load); pass `{ lazy: true }` to defer the import to the component's first
+ * render.
+ *
+ * @example
+ * ```tsx
+ * const Chart = clientOnly(() => import("./Chart.jsx"));
+ * // <Chart fallback={<div>Loading chart…</div>} data={data()} />
+ * ```
+ */
+export declare function clientOnly<T extends Component<any>>(fn: () => Promise<{
+    default: T;
+}>, options?: {
+    lazy?: boolean;
+}): Component<ComponentProps<T> & {
+    fallback?: JSX.Element;
+}>;
+/**
+ * Declares the HTTP response status (and optional status text) for the
+ * lifetime of the current reactive scope during SSR — call it bare in a
+ * component or reactive-scope body where the status is decided (a 404
+ * route, an error fallback). Client build: a no-op — the response head was
+ * sent long ago.
+ *
+ * Naming note — this is a scope-tied *declaration*, not a mutation: "while
+ * this reactive scope is live, the response has this status." Solid
+ * reserves `set*` verbs for event-time mutation; like
+ * `createSignal`/`onCleanup` this is called in scope bodies and un-declares
+ * on scope disposal.
+ *
+ * Retraction semantics (server): the write snapshots the previous
+ * `event.response` status at write time and restores it when the owning
+ * scope is disposed — so a boundary that errored, declared a status, and
+ * then recovered retracts its write instead of stomping a status a
+ * surviving part of the tree legitimately set. Once the integration marks
+ * the response head `committed` (head derived/sent), writes and
+ * retractions are no-ops.
+ */
+export declare function httpStatus(_code: number, _text?: string): void;
+/**
+ * Declares an HTTP response header (or with `append`, appends to one) for
+ * the lifetime of the current reactive scope during SSR — call it bare in a
+ * component or reactive-scope body. Client build: a no-op — the response
+ * head was sent long ago.
+ *
+ * Naming note — this is a scope-tied *declaration*, not a mutation: "while
+ * this reactive scope is live, the response has this header." Solid
+ * reserves `set*` verbs for event-time mutation; like
+ * `createSignal`/`onCleanup` this is called in scope bodies and un-declares
+ * on scope disposal.
+ *
+ * Retraction semantics (server): the header's prior value is snapshotted at
+ * write time and restored when the owning scope is disposed (deleted if
+ * there was none) — a boundary that errors or recovers retracts its writes.
+ * Once the integration marks the response head `committed` (head
+ * derived/sent), writes and retractions are no-ops.
+ */
+export declare function httpHeader(_name: string, _value: string, _options?: {
+    append?: boolean;
+}): void;

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

@@ -2,21 +2,29 @@ import { JSONCodecOptions } from "../serializer.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,
   subscribeFlightData,
   withMeta
 } from "./shared.js";
+export { REVALIDATE_HEADER } from "../response.js";
 export type {
   FlightDataConsumer,
   FlightDataContext,
@@ -173,3 +181,20 @@ export function createServerReference(id: string, name?: string, base?: string):
  * @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;
+}
+
+/**
+ * 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;