@solidjs/web 2.0.0-rc.3 → 2.0.0-rc.5

package/server-functions/dist/client.js

@@ -16,6 +16,32 @@ function withMeta(fn, meta) {
   Object.assign(metadata, meta);
   return fn;
 }
+const SERVER_FUNCTION_INVOKE = Symbol.for("solid.ServerFunctionInvoke");
+const INVOKE_OPTION_REDIRECTS = {
+  headers: "Session-dynamic headers belong to the prepareRequest hook, declaration metadata to " + "withMeta(fn, meta), and data belongs in the arguments, where it is serialized, typed, " + "and part of the cache key.",
+  method: "The method is declaration-scoped: declare the function with GET(fn).",
+  body: "The arguments are the body: pass them in the args array.",
+  timeout: "Compose timeouts through `signal` with AbortSignal.timeout(ms) (and AbortSignal.any to " + "combine it with a caller signal)."
+};
+function invoke(fn, options, ...args) {
+  const channel = typeof fn === "function" && fn[SERVER_FUNCTION_INVOKE];
+  if (!channel) {
+    throw new Error(isServerFunction(fn) ? "invoke: this wrapper does not forward the invocation channel " + "(SERVER_FUNCTION_INVOKE). Wrappers that share calls (caches, channels) opt in " + "deliberately — a caller's signal cannot own a wire other callers share. Invoke " + "the underlying reference directly, or use the wrapper's own per-call idioms." : "invoke expects a server function reference (or a wrapper that forwards its " + "invocation channel). Per-call options apply at the transport; for a data " + "layer's calls, use its per-call options instead.");
+  }
+  if (options === null || typeof options !== "object") {
+    throw new Error("invoke's second argument is the invocation options bag: invoke(fn, { signal }, ...args)");
+  }
+  const picked = {};
+  for (const key in options) {
+    if (key !== "signal" && key !== "keepalive" && key !== "priority") {
+      throw new Error(`\`${key}\` is not an invocation option. ` + (INVOKE_OPTION_REDIRECTS[key] || "Options here are strictly invocation-scoped (they vary between calls of the " + "same function): signal, keepalive, priority."));
+    }
+  }
+  if (options.signal !== undefined) picked.signal = options.signal;
+  if (options.keepalive !== undefined) picked.keepalive = options.keepalive;
+  if (options.priority !== undefined) picked.priority = options.priority;
+  return channel(args, picked);
+}
 const LIVE_SOURCE = Symbol.for("solid.LiveSource");
 const SERVER_FUNCTION_RPC = Symbol.for("solid.ServerFunctionRPC");
 function provideServerFunctionRPC(rpc) {
@@ -40,17 +66,30 @@ function configureServerFunctionsCodec(codec) {
 function getServerFunctionsCodec() {
   return codecConfig.codec;
 }
+const UNNAMED_FLIGHT_SOURCE = "true";
 const flightConfig = {
-  consumer: undefined
+  consumers: new Map()
 };
-function subscribeFlightData(consumer) {
-  flightConfig.consumer = consumer;
+function assertFlightSource(source) {
+  if (source === UNNAMED_FLIGHT_SOURCE || source === "" || source.includes(",")) {
+    throw new TypeError(`Invalid flight data source id "${source}": ids ride the ` + `${SINGLE_FLIGHT_HEADER} header as a comma-separated list, and "true" is ` + `reserved for the unnamed registration (the bare consumer/hook signatures).`);
+  }
+}
+function subscribeFlightData(sourceOrConsumer, maybeConsumer) {
+  const named = typeof sourceOrConsumer === "string";
+  if (named) assertFlightSource(sourceOrConsumer);
+  const source = named ? sourceOrConsumer : UNNAMED_FLIGHT_SOURCE;
+  const consumer = named ? maybeConsumer : sourceOrConsumer;
+  flightConfig.consumers.set(source, consumer);
   return () => {
-    if (flightConfig.consumer === consumer) flightConfig.consumer = undefined;
+    if (flightConfig.consumers.get(source) === consumer) flightConfig.consumers.delete(source);
   };
 }
-function getFlightDataConsumer() {
-  return flightConfig.consumer;
+function getFlightDataConsumer(source) {
+  return flightConfig.consumers.get(source === undefined ? UNNAMED_FLIGHT_SOURCE : source);
+}
+function getFlightDataSourceIds() {
+  return [...flightConfig.consumers.keys()];
 }
 function frameAddress(id, args) {
   return args && args.length ? id + ":" + hashArguments(args) : id;
@@ -96,7 +135,35 @@ function stableString(value, seen) {
   }
   return out + "}";
 }
-const FUNCTION_HEADER = "X-Server-Function-Id";
+function serverFunctionAddress(endpoint, id) {
+  const mount = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+  return `${mount}/${encodeURIComponent(id)}`;
+}
+function serverFunctionDataAddress(endpoint, id) {
+  const mount = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+  return `${mount}/data/${encodeURIComponent(id)}`;
+}
+function parseServerFunctionAddress(pathname, endpoint) {
+  const mount = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+  if (!pathname.startsWith(mount)) return null;
+  const rest = pathname.slice(mount.length);
+  if (!rest.startsWith("/")) return null;
+  let segment = rest.slice(1);
+  let data = false;
+  if (segment.startsWith("data/")) {
+    segment = segment.slice(5);
+    data = true;
+  }
+  if (!segment || segment.includes("/")) return null;
+  try {
+    return {
+      id: decodeURIComponent(segment),
+      data
+    };
+  } catch {
+    return null;
+  }
+}
 const ERROR_HEADER = "X-Server-Function-Error";
 const ERROR_HEADER_MARKER = "=?1?";
 const NEEDS_ENCODING = /[^\x20-\x7e\xa0-\xff]/;
@@ -124,6 +191,28 @@ function decodeErrorHeaderValue(value) {
 }
 const INSTANCE_HEADER = "X-Server-Function-Instance";
 const BODY_FORMAT_HEADER = "X-Server-Function-Format";
+const UNKNOWN_HEADER = "X-Server-Function-Unknown";
+const REDIRECT_HEADER = "X-Server-Function-Redirect";
+function decodeRedirectHeaderValue(value) {
+  if (typeof value !== "string") return undefined;
+  const at = value.indexOf(" ");
+  if (at < 0) return undefined;
+  const status = Number(value.slice(0, at));
+  const url = value.slice(at + 1);
+  if (!Number.isInteger(status) || !url) return undefined;
+  if (status !== 301 && status !== 302 && status !== 303 && status !== 307 && status !== 308) return undefined;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return undefined;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return undefined;
+  return {
+    status,
+    url
+  };
+}
 const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
 const FILE_FORM_KEY = "__server_function_file__";
 const BodyFormat = {
@@ -135,7 +224,8 @@ const BodyFormat = {
   File: "5",
   ArrayBuffer: "6",
   Uint8Array: "7",
-  Json: "8"
+  Json: "8",
+  Void: "9"
 };
 const JSON_SAFE_DEPTH_LIMIT = 4096;
 const EXIT = {};
@@ -165,7 +255,11 @@ function isJSONSafe(value) {
       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]);
+      for (const k in v) {
+        const descriptor = Object.getOwnPropertyDescriptor(v, k);
+        if (descriptor === undefined || !("value" in descriptor)) return false;
+        stack.push(descriptor.value);
+      }
     }
   }
   return true;
@@ -274,18 +368,34 @@ function createChunk(data) {
 class ChunkReader {
   constructor(stream) {
     this.reader = stream.getReader();
-    this.buffer = new Uint8Array(0);
+    this.store = new Uint8Array(0);
+    this.buffer = this.store;
     this.done = false;
   }
   async readChunk() {
     const chunk = await this.reader.read();
-    if (!chunk.done) {
-      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
-      newBuffer.set(this.buffer);
-      newBuffer.set(chunk.value, this.buffer.length);
-      this.buffer = newBuffer;
-    } else {
+    if (chunk.done) {
       this.done = true;
+      return;
+    }
+    const incoming = chunk.value;
+    const store = this.store;
+    const start = this.buffer.byteOffset;
+    const end = start + this.buffer.length;
+    const needed = this.buffer.length + incoming.length;
+    if (end + incoming.length <= store.length) {
+      store.set(incoming, end);
+      this.buffer = store.subarray(start, end + incoming.length);
+    } else if (needed <= store.length) {
+      store.copyWithin(0, start, end);
+      store.set(incoming, this.buffer.length);
+      this.buffer = store.subarray(0, needed);
+    } else {
+      const grown = new Uint8Array(Math.max(needed, store.length * 2));
+      grown.set(this.buffer);
+      grown.set(incoming, this.buffer.length);
+      this.store = grown;
+      this.buffer = grown.subarray(0, needed);
     }
   }
   async next() {
@@ -327,6 +437,18 @@ class ChunkReader {
     }
   }
 }
+const ERROR_TRAILER_PREFIX = "!";
+function errorFromTrailer(payload) {
+  let shape;
+  try {
+    shape = JSON.parse(payload.slice(1));
+  } catch {
+    shape = null;
+  }
+  const error = new Error(shape && typeof shape.message === "string" ? shape.message : "Server function result could not be delivered.");
+  if (shape && typeof shape.name === "string") error.name = shape.name;
+  return error;
+}
 function serializeStream(value, codecOptions) {
   return new ReadableStream({
     async start(controller) {
@@ -359,11 +481,17 @@ async function deserializeStream(source, codecOptions) {
   const reader = new ChunkReader(source.body);
   const result = await reader.next();
   if (!result.done) {
+    if (result.value.startsWith(ERROR_TRAILER_PREFIX)) {
+      throw errorFromTrailer(result.value);
+    }
     const {
       createJSONDeserializer
     } = await import('@solidjs/web/serialization/decode');
     const deserializeChunk = createJSONDeserializer(codecOptions);
     function interpretChunk(chunk) {
+      if (chunk.startsWith(ERROR_TRAILER_PREFIX)) {
+        throw errorFromTrailer(chunk);
+      }
       return deserializeChunk(JSON.parse(chunk));
     }
     reader.drain(interpretChunk).then(() => deserializeChunk.abort(new Error("Server function stream ended unexpectedly.")), error => deserializeChunk.abort(error));
@@ -390,6 +518,7 @@ async function decodeResponsePayload(response, codecOptions) {
 
 const config = {
   endpoint: "/_server",
+  fetch: undefined,
   prepareRequest: undefined,
   responseHandler: undefined,
   serializeArgs: undefined
@@ -418,6 +547,18 @@ function observeServerFunctionCalls(observer) {
   CALL_OBSERVERS.add(observer);
   return () => CALL_OBSERVERS.delete(observer);
 }
+function serverFunctionUrl(id, boundArgs) {
+  const address = serverFunctionAddress(config.endpoint, id);
+  if (!boundArgs || !boundArgs.length) return address;
+  if (!isJSONSafe(boundArgs)) {
+    throw new Error("Bound arguments in an action url must be JSON-safe: the server reads them the way it " + "reads a form post's, and that convention has no codec. Pass the value through the " + "function's body, or call the reference instead of rendering a url for it.");
+  }
+  return `${address}?args=${encodeURIComponent(JSON.stringify(boundArgs))}`;
+}
+function parseServerFunctionUrl(url) {
+  const parsed = parseServerFunctionAddress(new URL(url, globalThis.location?.href || "http://localhost").pathname, config.endpoint);
+  return parsed && parsed.id;
+}
 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.");
@@ -427,17 +568,20 @@ function serializeArguments(args) {
 function configureServerFunctionsClient({
   endpoint,
   codec,
+  fetch,
   prepareRequest,
   responseHandler,
   serializeArgs
 } = {}) {
   if (endpoint !== undefined) config.endpoint = endpoint;
   if (codec !== undefined) configureServerFunctionsCodec(codec);
+  if (fetch !== undefined) config.fetch = fetch;
   if (prepareRequest !== undefined) config.prepareRequest = prepareRequest;
   if (responseHandler !== undefined) config.responseHandler = responseHandler;
   if (serializeArgs !== undefined) config.serializeArgs = serializeArgs;
 }
 let INSTANCE = 0;
+const MAX_GET_URL_LENGTH = 2000;
 let rpcProvided = false;
 function provideRPC() {
   if (rpcProvided) return;
@@ -447,19 +591,41 @@ function provideRPC() {
     decodeResponse
   });
 }
+function dataAddressFor(base) {
+  const splitAt = base.search(/[?#]/);
+  const path = splitAt < 0 ? base : base.slice(0, splitAt);
+  const rest = splitAt < 0 ? "" : base.slice(splitAt);
+  const slash = path.lastIndexOf("/");
+  if (path.endsWith("/data/", slash + 1)) return base;
+  return `${path.slice(0, slash + 1)}data/${path.slice(slash + 1)}${rest}`;
+}
 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;
+  const unknown = response.headers.get(UNKNOWN_HEADER) !== null;
+  const error = value ?? new Error(unknown ? "Server function is not part of the deployment that answered (version skew or removed function)" : `Server function call failed with status ${response.status}`);
+  if (error instanceof Error && !("status" in error)) {
+    error.status = response.status;
+    const retryAfter = parseRetryAfter(response.headers.get("Retry-After"));
+    if (retryAfter !== undefined) error.retryAfter = retryAfter;
+  }
+  if (unknown && error instanceof Error) error.unknownFunction = true;
   return error;
 }
+function parseRetryAfter(header) {
+  if (!header) return undefined;
+  const trimmed = header.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed);
+  const date = Date.parse(trimmed);
+  if (!Number.isNaN(date)) return Math.max(0, Math.ceil((date - Date.now()) / 1000));
+  return undefined;
+}
 async function createRequest(base, id, instance, options, meta) {
   const headers = {
     ...options.headers,
-    [FUNCTION_HEADER]: id,
     [INSTANCE_HEADER]: instance
   };
-  if (getFlightDataConsumer() && !options.read && (!options.method || options.method.toUpperCase() !== "GET")) {
-    headers[SINGLE_FLIGHT_HEADER] = "true";
+  const flightSources = getFlightDataSourceIds();
+  if (flightSources.length > 0 && !options.read && (!options.method || options.method.toUpperCase() !== "GET")) {
+    headers[SINGLE_FLIGHT_HEADER] = flightSources.join(",");
   }
   let init = {
     method: "POST",
@@ -472,10 +638,14 @@ async function createRequest(base, id, instance, options, meta) {
       meta
     })) || init;
   }
-  if (CALL_OBSERVERS.size === 0) return fetch(base, init);
-  const request = new Request(new URL(base, globalThis.location?.href || "http://localhost"), init);
+  const send = config.fetch || fetch;
+  if (CALL_OBSERVERS.size === 0) return send(base, init);
+  const request = new Request(new URL(base, globalThis.location?.href || "http://localhost"), {
+    ...init,
+    body: init.body instanceof ReadableStream ? undefined : init.body
+  });
   notifyCallObservers("request", id, instance, request, meta);
-  const response = await fetch(request);
+  const response = await send(base, init);
   notifyCallObservers("response", id, instance, response, meta);
   return response;
 }
@@ -560,21 +730,27 @@ 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.status >= 400 && !response.headers.has(BODY_FORMAT_HEADER)) {
+    throw serverFunctionFailure(response, undefined);
+  }
+  const failed = response.headers.has(ERROR_HEADER);
   if (response.headers.has(SINGLE_FLIGHT_HEADER)) {
-    const consumer = getFlightDataConsumer();
-    if (consumer) {
+    const folded = response.headers.get(SINGLE_FLIGHT_HEADER).split(",");
+    const consumers = folded.map(source => [source, getFlightDataConsumer(source)]).filter(([, consumer]) => consumer);
+    if (consumers.length > 0) {
       const payload = await decodeResponse(response);
-      await consumer(payload.data, {
-        response
-      });
-      if (failed && !response.headers.has("Location") && !response.headers.has(REVALIDATE_HEADER)) {
+      for (const [source, consumer] of consumers) {
+        await consumer(payload.data[source], {
+          response
+        });
+      }
+      if (failed && !response.headers.has(REDIRECT_HEADER) && !response.headers.has(REVALIDATE_HEADER)) {
         throw serverFunctionFailure(response, payload.value);
       }
       return payload.value;
     }
   }
-  if (response.headers.has("Location") || response.headers.has(REVALIDATE_HEADER) || response.headers.has(SINGLE_FLIGHT_HEADER)) {
+  if (response.headers.has(REDIRECT_HEADER) || response.headers.has(REVALIDATE_HEADER) || response.headers.has(SINGLE_FLIGHT_HEADER) || response.status >= 300 && response.status < 400 && response.status !== 304) {
     return response;
   }
   const result = await decodeResponse(response.clone());
@@ -602,7 +778,7 @@ function createServerReference(id, name, base) {
   const metadata = name === undefined ? {} : {
     name
   };
-  const fn = (...args) => {
+  const run = (args, invokeOptions) => {
     const handler = config.responseHandler;
     if (handler && handler.intercept) {
       const hit = handler.intercept({
@@ -612,14 +788,18 @@ function createServerReference(id, name, base) {
       });
       if (hit !== undefined) return hit;
     }
-    return fetchServerFunction(base || config.endpoint, id, {}, args, metadata);
+    return fetchServerFunction(base ? dataAddressFor(base) : serverFunctionDataAddress(config.endpoint, id), id, invokeOptions ? {
+      ...invokeOptions
+    } : {}, args, metadata);
   };
+  const fn = (...args) => run(args);
   fn[SERVER_FUNCTION_METADATA] = metadata;
+  fn[SERVER_FUNCTION_INVOKE] = run;
   return new Proxy(fn, {
     get(target, prop) {
       if (prop === "id") return id;
       if (prop === "url") {
-        return base || `${config.endpoint}?id=${encodeURIComponent(id)}`;
+        return base || serverFunctionAddress(config.endpoint, id);
       }
       return target[prop];
     }
@@ -634,7 +814,7 @@ function GET(fn) {
   const metadata = {
     ...getServerFunctionMetadata(fn)
   };
-  const wrapped = async (...args) => {
+  const run = async (args, invokeOptions) => {
     const handler = config.responseHandler;
     if (handler && handler.intercept) {
       const hit = handler.intercept({
@@ -644,19 +824,34 @@ function GET(fn) {
       });
       if (hit !== undefined) return hit;
     }
-    let base = `${config.endpoint}?id=${encodeURIComponent(id)}`;
-    if (args.length) {
-      const encoded = isJSONSafe(args) ? JSON.stringify(args) : await serializeArguments(args);
-      base += `&args=${encodeURIComponent(encoded)}`;
+    const opts = invokeOptions || {};
+    const address = serverFunctionDataAddress(config.endpoint, id);
+    if (!args.length) {
+      return fetchServerFunction(address, id, {
+        ...opts,
+        method: "GET"
+      }, [], metadata, args);
     }
-    return fetchServerFunction(base, id, {
+    const encoded = isJSONSafe(args) ? JSON.stringify(args) : await serializeArguments(args);
+    const url = `${address}?args=${encodeURIComponent(encoded)}`;
+    const absolute = new URL(url, globalThis.location?.href || "http://localhost").href;
+    if (absolute.length > MAX_GET_URL_LENGTH) {
+      return fetchServerFunction(address, id, {
+        ...opts,
+        read: true
+      }, args, metadata);
+    }
+    return fetchServerFunction(url, id, {
+      ...opts,
       method: "GET"
     }, [], metadata, args);
   };
+  const wrapped = (...args) => run(args);
   wrapped[SERVER_FUNCTION_METADATA] = metadata;
+  wrapped[SERVER_FUNCTION_INVOKE] = run;
   wrapped.id = id;
   Object.defineProperty(wrapped, "url", {
-    get: () => `${config.endpoint}?id=${encodeURIComponent(id)}`,
+    get: () => serverFunctionAddress(config.endpoint, id),
     configurable: true
   });
   return withMeta(wrapped, {
@@ -672,7 +867,7 @@ function live(fn) {
     ...getServerFunctionMetadata(fn),
     live: true
   };
-  const wrapped = (...args) => {
+  const makeIterable = (args, invokeOptions) => {
     const iterable = {
       [LIVE_SOURCE]: true,
       [Symbol.asyncIterator]() {
@@ -686,6 +881,12 @@ function live(fn) {
           done: true,
           value: undefined
         };
+        const invokeSignal = invokeOptions && invokeOptions.signal;
+        const controller = new AbortController();
+        const wireOptions = {
+          ...invokeOptions,
+          signal: invokeSignal ? AbortSignal.any([invokeSignal, controller.signal]) : controller.signal
+        };
         const emit = (state, error) => {
           try {
             iterable.onstatus && iterable.onstatus(state, error);
@@ -707,7 +908,7 @@ function live(fn) {
           }
         };
         const callOnce = () => {
-          if (metadata.method === "GET") return fn(...args);
+          if (metadata.method === "GET") return fn[SERVER_FUNCTION_INVOKE](args, wireOptions);
           const handler = config.responseHandler;
           if (handler && handler.intercept) {
             const hit = handler.intercept({
@@ -718,6 +919,7 @@ function live(fn) {
             if (hit !== undefined) return hit;
           }
           return fetchServerFunction(fn.url, id, {
+            ...wireOptions,
             read: true
           }, args, metadata, args);
         };
@@ -732,6 +934,7 @@ function live(fn) {
                 }();
                 if (stopped) {
                   closeIt();
+                  controller.abort();
                   return DONE;
                 }
                 emit("connected");
@@ -745,8 +948,14 @@ function live(fn) {
               attempts = 0;
               return r;
             } catch (error) {
+              if (stopped) return DONE;
               if (!connected) throw error;
-              if (error !== null && typeof error === "object" && typeof error.status === "number" && error.status >= 400 && error.status < 500) {
+              if (invokeSignal && invokeSignal.aborted) {
+                stopped = true;
+                emitClosed(error);
+                throw error;
+              }
+              if (error !== null && typeof error === "object" && typeof error.status === "number" && error.status >= 400 && error.status < 500 && error.status !== 408 && error.status !== 425 && error.status !== 429 && typeof error.retryAfter !== "number") {
                 stopped = true;
                 emitClosed(error);
                 throw error;
@@ -755,13 +964,18 @@ function live(fn) {
               emit("reconnecting", error);
               await new Promise(resolve => {
                 wake = resolve;
-                timer = setTimeout(resolve, Math.min(500 * 2 ** attempts++, 10000));
+                const named = error !== null && typeof error === "object" && typeof error.retryAfter === "number" ? Math.min(error.retryAfter * 1000, 60000) : undefined;
+                timer = setTimeout(resolve, named ?? Math.min(500 * 2 ** attempts++, 10000));
                 if (typeof addEventListener === "function") addEventListener("online", resolve, {
                   once: true
                 });
+                if (invokeSignal) invokeSignal.addEventListener("abort", resolve, {
+                  once: true
+                });
               });
               clearTimeout(timer);
               if (typeof removeEventListener === "function") removeEventListener("online", wake);
+              if (invokeSignal) invokeSignal.removeEventListener("abort", wake);
               timer = wake = undefined;
             }
           }
@@ -774,6 +988,7 @@ function live(fn) {
             if (timer !== undefined) clearTimeout(timer);
             if (wake) wake();
             closeIt(value);
+            controller.abort();
             emitClosed();
             return Promise.resolve({
               done: true,
@@ -785,7 +1000,9 @@ function live(fn) {
     };
     return iterable;
   };
+  const wrapped = (...args) => makeIterable(args);
   wrapped[SERVER_FUNCTION_METADATA] = metadata;
+  wrapped[SERVER_FUNCTION_INVOKE] = makeIterable;
   wrapped.id = id;
   Object.defineProperty(wrapped, "url", {
     get: () => fn.url,
@@ -800,4 +1017,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, live, observeServerFunctionCalls, registerServerReference, serializeString, subscribeFlightData, withMeta };
+export { ChunkReader, ERROR_HEADER, FLASH_COOKIE, GET, INSTANCE_HEADER, REDIRECT_HEADER, REVALIDATE_HEADER, SERVER_FUNCTION_INVOKE, SINGLE_FLIGHT_HEADER, UNKNOWN_HEADER, clearFlashCookie, configureServerFunctionsClient, createChunk, createServerReference, decodeErrorHeaderValue, decodeRedirectHeaderValue, decodeResponse, decodeResponsePayload, deserializeStream, encodeErrorHeaderValue, frameAddress, getFlightDataConsumer, getFlightDataSourceIds, getServerFunctionInvocation, getServerFunctionMetadata, getServerFunctionsCodec, hasFlashCookie, invoke, isServerFunction, live, observeServerFunctionCalls, parseServerFunctionUrl, registerServerReference, serializeString, serverFunctionUrl, subscribeFlightData, withMeta };