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

package/server-functions/dist/client.js

@@ -40,6 +40,9 @@ const codecConfig = {
 function configureServerFunctionsCodec(codec) {
   codecConfig.codec = codec;
 }
+function getServerFunctionsCodec() {
+  return codecConfig.codec;
+}
 const flightConfig = {
   consumer: undefined
 };
@@ -52,6 +55,50 @@ function subscribeFlightData(consumer) {
 function getFlightDataConsumer() {
   return flightConfig.consumer;
 }
+function frameAddress(id, args) {
+  return args && args.length ? id + ":" + hashArguments(args) : id;
+}
+function hashArguments(args) {
+  let hash = 0;
+  const text = stableString(args);
+  for (let i = 0; i < text.length; i++) {
+    hash = (hash << 5) - hash + text.charCodeAt(i);
+    hash |= 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+function stableString(value, seen) {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "bigint" ? value + "n" : String(value);
+  }
+  if (value instanceof Date) return "Date:" + value.getTime();
+  seen || (seen = new Set());
+  if (seen.has(value)) return "~";
+  seen.add(value);
+  if (value instanceof Map) {
+    const entries = [];
+    for (const [k, v] of value) {
+      entries.push(stableString(k, seen) + "=>" + stableString(v, seen));
+    }
+    return "Map{" + entries.sort().join(",") + "}";
+  }
+  if (value instanceof Set) {
+    const members = [];
+    for (const v of value) members.push(stableString(v, seen));
+    return "Set{" + members.sort().join(",") + "}";
+  }
+  if (Array.isArray(value)) {
+    let out = "[";
+    for (let i = 0; i < value.length; i++) out += (i ? "," : "") + stableString(value[i], seen);
+    return out + "]";
+  }
+  const keys = Object.keys(value).sort();
+  let out = "{";
+  for (let i = 0; i < keys.length; i++) {
+    out += (i ? "," : "") + keys[i] + ":" + stableString(value[keys[i]], seen);
+  }
+  return out + "}";
+}
 const SERVER_FUNCTION_METADATA = Symbol.for("solid.ServerFunctionMetadata");
 function getServerFunctionMetadata(fn) {
   if (typeof fn !== "function") return undefined;
@@ -209,6 +256,17 @@ async function extractBody(source, codecOptions) {
   }
   return undefined;
 }
+function createChunk(data) {
+  const encodeData = new TextEncoder().encode(data);
+  const bytes = encodeData.length;
+  const baseHex = bytes.toString(16);
+  const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex;
+  const head = new TextEncoder().encode(`;0x${totalHex};`);
+  const chunk = new Uint8Array(12 + bytes);
+  chunk.set(head);
+  chunk.set(encodeData, 12);
+  return chunk;
+}
 class ChunkReader {
   constructor(stream) {
     this.reader = stream.getReader();
@@ -389,6 +447,21 @@ async function initializeResponse(base, id, instance, options, args, meta) {
       }
     }, meta);
   }
+  if (args.length > 1) {
+    const trailing = getHeadersAndBody(args[args.length - 1]);
+    const leading = args.slice(0, -1).map(arg => arg === undefined ? null : arg);
+    if (trailing && isJSONSafe(leading)) {
+      const target = base + (base.includes("?") ? "&" : "?") + "args=" + encodeURIComponent(JSON.stringify(leading));
+      return createRequest(target, id, instance, {
+        ...options,
+        body: trailing.body,
+        headers: {
+          ...options.headers,
+          ...trailing.headers
+        }
+      }, meta);
+    }
+  }
   return createRequest(base, id, instance, {
     ...options,
     body: await serializeArguments(args),
@@ -399,7 +472,7 @@ async function initializeResponse(base, id, instance, options, args, meta) {
     }
   }, meta);
 }
-async function fetchServerFunction(base, id, options, args, meta) {
+async function fetchServerFunction(base, id, options, args, meta, callArgs = args) {
   const instance = `server-function:${INSTANCE++}`;
   const handler = config.responseHandler;
   const context = handler && handler.capture ? handler.capture({
@@ -411,7 +484,7 @@ async function fetchServerFunction(base, id, options, args, meta) {
     const handled = handler.handle(response, {
       id,
       meta,
-      args,
+      args: callArgs,
       context
     });
     if (handled !== undefined) return handled;
@@ -490,7 +563,7 @@ function GET(fn) {
     }
     return fetchServerFunction(base, id, {
       method: "GET"
-    }, [], metadata);
+    }, [], metadata, args);
   };
   wrapped[SERVER_FUNCTION_METADATA] = metadata;
   wrapped.id = id;
@@ -505,5 +578,8 @@ function GET(fn) {
 function registerServerReference() {
   throw new Error("registerServerReference must not be called in the client build");
 }
+function getServerFunctionInvocation() {
+  return undefined;
+}
 
-export { ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, GET, INSTANCE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, configureServerFunctionsClient, createServerReference, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, encodeErrorHeaderValue, getServerFunctionMetadata, hasFlashCookie, isServerFunction, registerServerReference, subscribeFlightData, withMeta };
+export { ChunkReader, ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, GET, INSTANCE_HEADER, REVALIDATE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, configureServerFunctionsClient, createChunk, createServerReference, decodeErrorHeaderValue, decodeResponse, decodeResponsePayload, deserializeStream, encodeErrorHeaderValue, frameAddress, getFlightDataConsumer, getServerFunctionInvocation, getServerFunctionMetadata, getServerFunctionsCodec, hasFlashCookie, isServerFunction, registerServerReference, subscribeFlightData, withMeta };

package/server-functions/dist/server.cjs

@@ -410,6 +410,7 @@ const config = {
   provideEvent: undefined,
   collectFlightData: undefined,
   transformResult: undefined,
+  transformFlightResult: undefined,
   transformDirectResult: undefined,
   handleNoJS: undefined,
   endpoint: "/_server"
@@ -418,6 +419,7 @@ function configureServerFunctionsServer({
   provideEvent,
   collectFlightData,
   transformResult,
+  transformFlightResult,
   transformDirectResult,
   handleNoJS,
   endpoint,
@@ -426,6 +428,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;
@@ -439,6 +442,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;
@@ -482,9 +486,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);
@@ -493,11 +497,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;
     }
@@ -512,9 +518,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);
@@ -544,12 +552,27 @@ 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
@@ -710,22 +733,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;
@@ -767,7 +797,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);
@@ -779,8 +810,7 @@ async function handleServerFunctionRequest(request, options = {}) {
     if (x instanceof Response || isResponseEnvelope(x)) {
       if (transformResult) {
         x = await transformResult(event, x, {
-          instance,
-          request,
+          ...flightContext,
           thrown: true
         });
       }
@@ -818,7 +848,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) {
@@ -857,8 +891,9 @@ exports.decodeResponsePayload = decodeResponsePayload;
 exports.encodeErrorHeaderValue = encodeErrorHeaderValue;
 exports.encodeFlashCookie = encodeFlashCookie;
 exports.foldSetCookies = foldSetCookies;
+exports.getEventServerFunctionInvocation = getEventServerFunctionInvocation;
 exports.getServerFunction = getServerFunction;
-exports.getServerFunctionMeta = getServerFunctionMeta;
+exports.getServerFunctionInvocation = getServerFunctionInvocation;
 exports.getServerFunctionMetadata = getServerFunctionMetadata;
 exports.handleServerFunctionRequest = handleServerFunctionRequest;
 exports.hasFlashCookie = hasFlashCookie;

package/server-functions/dist/server.js

@@ -408,6 +408,7 @@ const config = {
   provideEvent: undefined,
   collectFlightData: undefined,
   transformResult: undefined,
+  transformFlightResult: undefined,
   transformDirectResult: undefined,
   handleNoJS: undefined,
   endpoint: "/_server"
@@ -416,6 +417,7 @@ function configureServerFunctionsServer({
   provideEvent,
   collectFlightData,
   transformResult,
+  transformFlightResult,
   transformDirectResult,
   handleNoJS,
   endpoint,
@@ -424,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;
@@ -437,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;
@@ -480,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);
@@ -491,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;
     }
@@ -510,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);
@@ -542,12 +550,27 @@ 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
@@ -708,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;
@@ -765,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);
@@ -777,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
         });
       }
@@ -816,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) {
@@ -838,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, decodeResponsePayload, 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

@@ -5,11 +5,13 @@ 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`