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

package/server-functions/dist/client.js

@@ -16,6 +16,7 @@ function withMeta(fn, meta) {
   Object.assign(metadata, meta);
   return fn;
 }
+const LIVE_SOURCE = Symbol.for("solid.LiveSource");
 const SERVER_FUNCTION_RPC = Symbol.for("solid.ServerFunctionRPC");
 function provideServerFunctionRPC(rpc) {
   globalThis[SERVER_FUNCTION_RPC] || (globalThis[SERVER_FUNCTION_RPC] = rpc);
@@ -136,7 +137,7 @@ const BodyFormat = {
   Uint8Array: "7",
   Json: "8"
 };
-const JSON_SAFE_DEPTH_LIMIT = 10000;
+const JSON_SAFE_DEPTH_LIMIT = 4096;
 const EXIT = {};
 function isJSONSafe(value) {
   const stack = [value];
@@ -163,6 +164,7 @@ function isJSONSafe(value) {
     } else {
       const proto = Object.getPrototypeOf(v);
       if (proto !== Object.prototype && proto !== null) return false;
+      if (Symbol.asyncIterator in v || Symbol.iterator in v) return false;
       for (const k in v) stack.push(v[k]);
     }
   }
@@ -364,7 +366,7 @@ async function deserializeStream(source, codecOptions) {
     function interpretChunk(chunk) {
       return deserializeChunk(JSON.parse(chunk));
     }
-    void reader.drain(interpretChunk);
+    reader.drain(interpretChunk).then(() => deserializeChunk.abort(new Error("Server function stream ended unexpectedly.")), error => deserializeChunk.abort(error));
     return interpretChunk(result.value);
   }
   return undefined;
@@ -392,6 +394,30 @@ const config = {
   responseHandler: undefined,
   serializeArgs: undefined
 };
+const CALL_OBSERVERS = new Set();
+function notifyCallObservers(type, id, instance, value, meta) {
+  if (CALL_OBSERVERS.size === 0) return;
+  const field = type === "request" ? "request" : "response";
+  const time = performance.now();
+  for (const observer of new Set(CALL_OBSERVERS)) {
+    try {
+      observer({
+        type,
+        id,
+        instance,
+        [field]: value.clone(),
+        meta,
+        time
+      });
+    } catch (error) {
+      console.error(error);
+    }
+  }
+}
+function observeServerFunctionCalls(observer) {
+  CALL_OBSERVERS.add(observer);
+  return () => CALL_OBSERVERS.delete(observer);
+}
 function serializeArguments(args) {
   if (!config.serializeArgs) {
     throw new Error("Server function arguments are sent as JSON by default and these " + "arguments are not JSON-serializable. Call enableRichArguments() " + '(from "@solidjs/web/server-functions/rich-args") once at startup ' + "to send Dates, Maps, Sets, typed arrays, etc. through the codec — " + "or pass a single Blob/FormData/File argument, which has a native " + "HTTP encoding.");
@@ -421,13 +447,18 @@ function provideRPC() {
     decodeResponse
   });
 }
+function serverFunctionFailure(response, value) {
+  const error = value ?? new Error(`Server function call failed with status ${response.status}`);
+  if (error instanceof Error && !("status" in error)) error.status = response.status;
+  return error;
+}
 async function createRequest(base, id, instance, options, meta) {
   const headers = {
     ...options.headers,
     [FUNCTION_HEADER]: id,
     [INSTANCE_HEADER]: instance
   };
-  if (getFlightDataConsumer() && (!options.method || options.method.toUpperCase() !== "GET")) {
+  if (getFlightDataConsumer() && !options.read && (!options.method || options.method.toUpperCase() !== "GET")) {
     headers[SINGLE_FLIGHT_HEADER] = "true";
   }
   let init = {
@@ -441,7 +472,12 @@ async function createRequest(base, id, instance, options, meta) {
       meta
     })) || init;
   }
-  return fetch(base, init);
+  if (CALL_OBSERVERS.size === 0) return fetch(base, init);
+  const request = new Request(new URL(base, globalThis.location?.href || "http://localhost"), init);
+  notifyCallObservers("request", id, instance, request, meta);
+  const response = await fetch(request);
+  notifyCallObservers("response", id, instance, response, meta);
+  return response;
 }
 async function initializeResponse(base, id, instance, options, args, meta) {
   if (args.length === 0) {
@@ -509,6 +545,11 @@ async function fetchServerFunction(base, id, options, args, meta, callArgs = arg
     id,
     meta
   }) : undefined;
+  const controller = options.signal ? undefined : new AbortController();
+  if (controller) options = {
+    ...options,
+    signal: controller.signal
+  };
   const response = await initializeResponse(base, id, instance, options, args, meta);
   if (handler) {
     const handled = handler.handle(response, {
@@ -519,6 +560,7 @@ async function fetchServerFunction(base, id, options, args, meta, callArgs = arg
     });
     if (handled !== undefined) return handled;
   }
+  const failed = response.headers.has(ERROR_HEADER) || response.status >= 500;
   if (response.headers.has(SINGLE_FLIGHT_HEADER)) {
     const consumer = getFlightDataConsumer();
     if (consumer) {
@@ -526,8 +568,8 @@ async function fetchServerFunction(base, id, options, args, meta, callArgs = arg
       await consumer(payload.data, {
         response
       });
-      if (response.headers.has(ERROR_HEADER) && !response.headers.has("Location") && !response.headers.has(REVALIDATE_HEADER)) {
-        throw payload.value;
+      if (failed && !response.headers.has("Location") && !response.headers.has(REVALIDATE_HEADER)) {
+        throw serverFunctionFailure(response, payload.value);
       }
       return payload.value;
     }
@@ -536,8 +578,22 @@ async function fetchServerFunction(base, id, options, args, meta, callArgs = arg
     return response;
   }
   const result = await decodeResponse(response.clone());
-  if (response.headers.has(ERROR_HEADER)) {
-    throw result;
+  if (failed) {
+    throw serverFunctionFailure(response, result);
+  }
+  if (controller && result?.[Symbol.asyncIterator]) {
+    return {
+      [Symbol.asyncIterator]() {
+        const it = result[Symbol.asyncIterator]();
+        return {
+          next: () => it.next(),
+          return: value => (controller.abort(), Promise.resolve({
+            done: true,
+            value
+          }))
+        };
+      }
+    };
   }
   return result;
 }
@@ -607,6 +663,136 @@ function GET(fn) {
     method: "GET"
   });
 }
+function live(fn) {
+  if (!isServerFunction(fn)) {
+    throw new Error("live expects a server function reference");
+  }
+  const id = fn.id;
+  const metadata = {
+    ...getServerFunctionMetadata(fn),
+    live: true
+  };
+  const wrapped = (...args) => {
+    const iterable = {
+      [LIVE_SOURCE]: true,
+      [Symbol.asyncIterator]() {
+        let it;
+        let connected = false;
+        let attempts = 0;
+        let stopped = false;
+        let ended = false;
+        let timer, wake;
+        const DONE = {
+          done: true,
+          value: undefined
+        };
+        const emit = (state, error) => {
+          try {
+            iterable.onstatus && iterable.onstatus(state, error);
+          } catch {}
+        };
+        const emitClosed = error => {
+          if (ended) return;
+          ended = true;
+          emit("closed", error);
+        };
+        const closeIt = value => {
+          const current = it;
+          it = undefined;
+          if (current) {
+            try {
+              const r = current.return && current.return(value);
+              if (r && typeof r.then === "function") r.then(undefined, () => {});
+            } catch {}
+          }
+        };
+        const callOnce = () => {
+          if (metadata.method === "GET") return fn(...args);
+          const handler = config.responseHandler;
+          if (handler && handler.intercept) {
+            const hit = handler.intercept({
+              id,
+              meta: metadata,
+              args
+            });
+            if (hit !== undefined) return hit;
+          }
+          return fetchServerFunction(fn.url, id, {
+            read: true
+          }, args, metadata, args);
+        };
+        const pull = async () => {
+          while (!stopped) {
+            try {
+              if (!it) {
+                const result = await callOnce();
+                connected = true;
+                it = result !== null && typeof result === "object" && result[Symbol.asyncIterator] ? result[Symbol.asyncIterator]() : async function* () {
+                  yield result;
+                }();
+                if (stopped) {
+                  closeIt();
+                  return DONE;
+                }
+                emit("connected");
+              }
+              const r = await it.next();
+              if (r.done) {
+                emitClosed();
+                return DONE;
+              }
+              if (stopped) return DONE;
+              attempts = 0;
+              return r;
+            } catch (error) {
+              if (!connected) throw error;
+              if (error !== null && typeof error === "object" && typeof error.status === "number" && error.status >= 400 && error.status < 500) {
+                stopped = true;
+                emitClosed(error);
+                throw error;
+              }
+              it = undefined;
+              emit("reconnecting", error);
+              await new Promise(resolve => {
+                wake = resolve;
+                timer = setTimeout(resolve, Math.min(500 * 2 ** attempts++, 10000));
+                if (typeof addEventListener === "function") addEventListener("online", resolve, {
+                  once: true
+                });
+              });
+              clearTimeout(timer);
+              if (typeof removeEventListener === "function") removeEventListener("online", wake);
+              timer = wake = undefined;
+            }
+          }
+          return DONE;
+        };
+        return {
+          next: () => pull(),
+          return(value) {
+            stopped = true;
+            if (timer !== undefined) clearTimeout(timer);
+            if (wake) wake();
+            closeIt(value);
+            emitClosed();
+            return Promise.resolve({
+              done: true,
+              value
+            });
+          }
+        };
+      }
+    };
+    return iterable;
+  };
+  wrapped[SERVER_FUNCTION_METADATA] = metadata;
+  wrapped.id = id;
+  Object.defineProperty(wrapped, "url", {
+    get: () => fn.url,
+    configurable: true
+  });
+  return wrapped;
+}
 function registerServerReference() {
   throw new Error("registerServerReference must not be called in the client build");
 }
@@ -614,4 +800,4 @@ function getServerFunctionInvocation() {
   return undefined;
 }
 
-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, serializeString, 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, live, observeServerFunctionCalls, registerServerReference, serializeString, subscribeFlightData, withMeta };

package/server-functions/dist/server.cjs

@@ -28,6 +28,7 @@ function withMeta(fn, meta) {
   Object.assign(metadata, meta);
   return fn;
 }
+const LIVE_SOURCE = Symbol.for("solid.LiveSource");
 const SERVER_FUNCTION_RPC = Symbol.for("solid.ServerFunctionRPC");
 function provideServerFunctionRPC(rpc) {
   globalThis[SERVER_FUNCTION_RPC] || (globalThis[SERVER_FUNCTION_RPC] = rpc);
@@ -132,7 +133,7 @@ const BodyFormat = {
   Uint8Array: "7",
   Json: "8"
 };
-const JSON_SAFE_DEPTH_LIMIT = 10000;
+const JSON_SAFE_DEPTH_LIMIT = 4096;
 const EXIT = {};
 function isJSONSafe(value) {
   const stack = [value];
@@ -159,6 +160,7 @@ function isJSONSafe(value) {
     } else {
       const proto = Object.getPrototypeOf(v);
       if (proto !== Object.prototype && proto !== null) return false;
+      if (Symbol.asyncIterator in v || Symbol.iterator in v) return false;
       for (const k in v) stack.push(v[k]);
     }
   }
@@ -321,27 +323,6 @@ class ChunkReader {
     }
   }
 }
-function serializeStream(value, codecOptions) {
-  return new ReadableStream({
-    async start(controller) {
-      const {
-        serializeJSON
-      } = await import('@solidjs/web/serialization');
-      serializeJSON(value, {
-        ...codecOptions,
-        onParse(node) {
-          controller.enqueue(createChunk(JSON.stringify(node)));
-        },
-        onDone() {
-          controller.close();
-        },
-        onError(error) {
-          controller.error(error);
-        }
-      });
-    }
-  });
-}
 async function deserializeStream(source, codecOptions) {
   if (!source.body) {
     throw new Error("missing body");
@@ -356,7 +337,7 @@ async function deserializeStream(source, codecOptions) {
     function interpretChunk(chunk) {
       return deserializeChunk(JSON.parse(chunk));
     }
-    void reader.drain(interpretChunk);
+    reader.drain(interpretChunk).then(() => deserializeChunk.abort(new Error("Server function stream ended unexpectedly.")), error => deserializeChunk.abort(error));
     return interpretChunk(result.value);
   }
   return undefined;
@@ -381,6 +362,7 @@ async function decodeResponsePayload(response, codecOptions) {
   };
 }
 
+typeof setImmediate === "function" ? setImmediate : fn => setTimeout(fn, 0);
 const RequestContext = Symbol.for("solid.RequestContext");
 function getRequestEvent() {
   return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || solidJs.sharedConfig.context && solidJs.sharedConfig.context.event || console.warn("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
@@ -512,7 +494,8 @@ const config = {
   transformFlightResult: undefined,
   transformDirectResult: undefined,
   handleNoJS: undefined,
-  endpoint: "/_server"
+  endpoint: "/_server",
+  csrf: true
 };
 function configureServerFunctionsServer({
   provideEvent,
@@ -523,6 +506,7 @@ function configureServerFunctionsServer({
   transformDirectResult,
   handleNoJS,
   endpoint,
+  csrf,
   codec
 } = {}) {
   if (provideEvent !== undefined) config.provideEvent = provideEvent;
@@ -533,6 +517,7 @@ function configureServerFunctionsServer({
   if (transformDirectResult !== undefined) config.transformDirectResult = transformDirectResult;
   if (handleNoJS !== undefined) config.handleNoJS = handleNoJS;
   if (endpoint !== undefined) config.endpoint = endpoint;
+  if (csrf !== undefined) config.csrf = csrf;
   if (codec !== undefined) configureServerFunctionsCodec(codec);
 }
 function provideEvent(event, fn) {
@@ -636,6 +621,29 @@ function GET(fn) {
     method: "GET"
   });
 }
+function live(fn) {
+  if (!isServerFunction(fn) || typeof fn.id !== "string") {
+    throw new Error("live expects a server function reference");
+  }
+  const metadata = {
+    ...getServerFunctionMetadata(fn),
+    live: true
+  };
+  const wrapped = async (...args) => {
+    const result = await fn(...args);
+    if (result !== null && typeof result === "object" && result[Symbol.asyncIterator]) {
+      result[LIVE_SOURCE] = true;
+    }
+    return result;
+  };
+  wrapped[SERVER_FUNCTION_METADATA] = metadata;
+  wrapped.id = fn.id;
+  Object.defineProperty(wrapped, "url", {
+    get: () => fn.url,
+    configurable: true
+  });
+  return wrapped;
+}
 function getServerFunctionInvocation() {
   return getEventServerFunctionInvocation(getRequestEvent());
 }
@@ -807,14 +815,102 @@ function isFormPost(request) {
   const type = request.headers.get("content-type") || "";
   return type.startsWith("application/x-www-form-urlencoded") || type.startsWith("multipart/form-data");
 }
-function serializedResponse(value, headers, codec) {
+function serializeResponseStream(value, codecOptions, signal) {
+  let closeIterator = null;
+  let closed = false;
+  let cancelSerialize = null;
+  let onAbort = null;
+  const teardown = () => {
+    if (closed) return;
+    closed = true;
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+    if (cancelSerialize) cancelSerialize();
+    if (closeIterator) closeIterator();
+  };
+  if (value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function") {
+    const source = value;
+    value = {
+      [Symbol.asyncIterator]() {
+        const it = source[Symbol.asyncIterator]();
+        let finished = false;
+        closeIterator = () => {
+          if (finished) return;
+          finished = true;
+          try {
+            const returned = it.return && it.return();
+            if (returned && typeof returned.then === "function") returned.then(undefined, () => {});
+          } catch {}
+        };
+        if (closed) closeIterator();
+        return {
+          next: () => finished ? Promise.resolve({
+            done: true,
+            value: undefined
+          }) : it.next()
+        };
+      }
+    };
+  }
+  return new ReadableStream({
+    async start(controller) {
+      if (signal) {
+        if (signal.aborted) {
+          teardown();
+          controller.close();
+          return;
+        }
+        onAbort = () => {
+          const alreadyClosed = closed;
+          teardown();
+          if (!alreadyClosed) {
+            try {
+              controller.error(signal.reason || new Error("The operation was aborted."));
+            } catch {}
+          }
+        };
+        signal.addEventListener("abort", onAbort);
+      }
+      const {
+        serializeJSON
+      } = await import('@solidjs/web/serialization');
+      if (closed) {
+        try {
+          controller.close();
+        } catch {}
+        return;
+      }
+      cancelSerialize = serializeJSON(value, {
+        ...codecOptions,
+        onParse(node) {
+          if (!closed) controller.enqueue(createChunk(JSON.stringify(node)));
+        },
+        onDone() {
+          if (closed) return;
+          closed = true;
+          if (onAbort) signal.removeEventListener("abort", onAbort);
+          controller.close();
+        },
+        onError(error) {
+          if (closed) return;
+          closed = true;
+          if (onAbort) signal.removeEventListener("abort", onAbort);
+          controller.error(error);
+        }
+      });
+    },
+    cancel() {
+      teardown();
+    }
+  });
+}
+function serializedResponse(value, headers, codec, signal) {
   headers.set(BODY_FORMAT_HEADER, BodyFormat.Serialized);
   headers.set("Content-Type", "text/plain");
-  return new Response(serializeStream(value, codec), {
+  return new Response(serializeResponseStream(value, codec, signal), {
     headers
   });
 }
-function encodeResult(value, headers, status, codec) {
+function encodeResult(value, headers, status, codec, signal) {
   const direct = getHeadersAndBody(value);
   if (direct) {
     for (const [key, val] of Object.entries(direct.headers || {})) {
@@ -842,7 +938,7 @@ function encodeResult(value, headers, status, codec) {
     }
   } catch {
   }
-  const response = serializedResponse(value, headers, codec);
+  const response = serializedResponse(value, headers, codec, signal);
   return status === 200 ? response : new Response(response.body, {
     status,
     headers
@@ -858,31 +954,96 @@ function sanitizeServerError(value) {
   if (isSafeError(value)) return value;
   return new Error(GENERIC_SERVER_ERROR_MESSAGE);
 }
+function observeServerFunctionCalls() {
+  return () => {};
+}
+async function matchesOrigin(origin, request, matcher) {
+  if (matcher === undefined) return origin === new URL(request.url).origin;
+  if (typeof matcher === "function") return !!(await matcher(origin, request));
+  return Array.isArray(matcher) ? matcher.includes(origin) : origin === matcher;
+}
+async function allowsServerFunctionRequest(request, options) {
+  const fetchSite = request.headers.get("Sec-Fetch-Site");
+  if (fetchSite === "same-origin") return true;
+  if (fetchSite === "same-site" || fetchSite === "cross-site" || fetchSite === "none") {
+    return false;
+  }
+  const origin = request.headers.get("Origin");
+  if (origin !== null) return matchesOrigin(origin, request, options.origin);
+  const referer = request.headers.get("Referer");
+  if (referer !== null) {
+    try {
+      return matchesOrigin(new URL(referer).origin, request, options.origin);
+    } catch {
+      return false;
+    }
+  }
+  return options.allowRequestsWithoutOriginCheck === true;
+}
+const CSRF_VARY = ["Sec-Fetch-Site", "Origin", "Referer"];
+function withCSRFVary(response) {
+  const current = response.headers.get("Vary");
+  if (current === "*") return response;
+  const values = current ? current.split(",").map(value => value.trim()) : [];
+  const names = new Set(values.map(value => value.toLowerCase()));
+  for (const value of CSRF_VARY) {
+    if (!names.has(value.toLowerCase())) values.push(value);
+  }
+  const vary = values.join(", ");
+  try {
+    response.headers.set("Vary", vary);
+    return response;
+  } catch {
+    const headers = new Headers(response.headers);
+    headers.set("Vary", vary);
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+function forbiddenResponse() {
+  return withCSRFVary(new Response(DEV ? "Forbidden" : null, {
+    status: 403,
+    headers: {
+      "Cache-Control": "no-store"
+    }
+  }));
+}
 async function handleServerFunctionRequest(request, options = {}) {
   const codec = options.codec !== undefined ? options.codec : getServerFunctionsCodec();
   const url = new URL(request.url);
+  const csrf = options.csrf !== undefined ? options.csrf : config.csrf;
+  const protectsRequest = csrf !== false;
+  if (protectsRequest && !(await allowsServerFunctionRequest(request, csrf === true ? {} : csrf))) {
+    return forbiddenResponse();
+  }
   const instance = request.headers.get(INSTANCE_HEADER);
   const functionId = resolveFunctionId(request, url);
   if (!functionId) {
-    return new Response(DEV ? "Server function not found" : null, {
+    const response = new Response(DEV ? "Server function not found" : null, {
       status: 404
     });
+    return protectsRequest ? withCSRFVary(response) : response;
   }
   let serverFunction;
   try {
     serverFunction = getServerFunction(functionId);
   } catch {
-    return new Response(DEV ? `Unknown server function: ${functionId}` : null, {
+    const response = new Response(DEV ? `Unknown server function: ${functionId}` : null, {
       status: 404
     });
+    return protectsRequest ? withCSRFVary(response) : response;
   }
   if (request.method === "GET" && METHODS.get(functionId) !== "GET") {
-    return new Response(DEV ? `Method not allowed for server function: ${functionId}` : null, {
+    const response = new Response(DEV ? `Method not allowed for server function: ${functionId}` : null, {
       status: 405,
       headers: {
         Allow: "POST"
       }
     });
+    return protectsRequest ? withCSRFVary(response) : response;
   }
   const event = options.createEvent ? options.createEvent(request) : {
     request,
@@ -970,9 +1131,9 @@ async function handleServerFunctionRequest(request, options = {}) {
       if (!instance) {
         if (handleNoJS) return handleNoJS(result, request, parsed);
         if (result instanceof Response) return result;
-        return encodeResult(result, headers, 200, codec);
+        return encodeResult(result, headers, 200, codec, request.signal);
       }
-      return encodeResult(result, headers, status, codec);
+      return encodeResult(result, headers, status, codec, request.signal);
     } catch (x) {
       if (x instanceof Response || isResponseEnvelope(x)) {
         if (transformResult) {
@@ -1026,7 +1187,7 @@ async function handleServerFunctionRequest(request, options = {}) {
           if (handleNoJS) return handleNoJS(x ?? metadata, request, parsed, true);
           if (x instanceof Response) return x;
         }
-        return encodeResult(x, headers, status, codec);
+        return encodeResult(x, headers, status, codec, request.signal);
       }
       const safe = sanitizeServerError(x);
       if (!instance) {
@@ -1038,10 +1199,11 @@ async function handleServerFunctionRequest(request, options = {}) {
       }
       const error = safe instanceof Error ? safe.message : typeof safe === "string" ? safe : "true";
       headers.set(ERROR_HEADER, encodeErrorHeaderValue(error));
-      return encodeResult(safe, headers, 200, codec);
+      return encodeResult(safe, headers, 200, codec, request.signal);
     }
   };
-  return commitEventResponse(await dispatch(), event);
+  const response = commitEventResponse(await dispatch(), event);
+  return protectsRequest ? withCSRFVary(response) : response;
 }
 
 exports.ERROR_HEADER = ERROR_HEADER;
@@ -1069,9 +1231,12 @@ exports.getServerFunctionMetadata = getServerFunctionMetadata;
 exports.handleServerFunctionRequest = handleServerFunctionRequest;
 exports.hasFlashCookie = hasFlashCookie;
 exports.isServerFunction = isServerFunction;
+exports.live = live;
+exports.observeServerFunctionCalls = observeServerFunctionCalls;
 exports.registerServerFunction = registerServerFunction;
 exports.registerServerReference = registerServerReference;
 exports.sanitizeServerError = sanitizeServerError;
+exports.serializeResponseStream = serializeResponseStream;
 exports.setServerFunctionsDev = setServerFunctionsDev;
 exports.subscribeFlightData = subscribeFlightData;
 exports.withMeta = withMeta;