octane 0.2.12 → 0.2.13

package/dist/cjs/server/early-signals.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var early_signals_exports = {};
+__export(early_signals_exports, {
+  earlySignalBootstrapScript: () => earlySignalBootstrapScript,
+  streamedSignalBootstrapJs: () => streamedSignalBootstrapJs
+});
+module.exports = __toCommonJS(early_signals_exports);
+var import_constants = require("../constants.cjs");
+var import_interaction_config = require("../hydration/interaction-config.cjs");
+function earlySignalBootstrapScript(options = {}) {
+  const nonce = options.nonce === void 0 ? "" : ' nonce="' + options.nonce.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;") + '"';
+  return "<script " + import_constants.STREAM_SCRIPT_ATTR + nonce + ">" + streamedSignalBootstrapJs(options.independentHydration) + "</script>";
+}
+let STREAMED_SIGNAL_BOOTSTRAP_JS;
+let STREAMED_SIGNAL_INDEPENDENT_BOOTSTRAP_JS;
+function streamedSignalBootstrapJs(independentHydration = false) {
+  const signals = STREAMED_SIGNAL_BOOTSTRAP_JS ??= '(function(g){var z="__octaneStreamedSignalSelections",v=g[z];if(!v){var a=[];g[z]={version:1,identities:a,register:function(i){if(a.length>=256){this.overflow=true;return;}a.push(i);}};}var k="__octaneStreamedRenderer",e=g[k];if(e)return;var q=[];g[k]={version:1,frames:q,receive:function(f){if(q.length>=512){this.overflow=true;return;}q.push(f);}};var s=g.__octaneEarlySignalControls||(g.__octaneEarlySignalControls={q:[],n:0});if(!s.l){s.l=1;document.addEventListener("input",function(e){var t=e.target;if(!t||!t.getAttribute||!t.getAttribute("' + import_constants.SIGNAL_CONTROL_ATTR + '"))return;var r=++s.n,p=g.__octanePublishSignalControl;if(p){p(t,r);return;}for(var i=0;i<s.q.length;i++)if(s.q[i][0]===t){s.q[i]=[t,r];return;}if(s.q.length<256)s.q.push([t,r]);},true);}})(globalThis);';
+  if (!independentHydration) return signals;
+  return STREAMED_SIGNAL_INDEPENDENT_BOOTSTRAP_JS ??= signals + // A completed client build can contain its first independent widget only
+  // in a later streamed wave. Capture its intent before module evaluation,
+  // with no activation dependency on its parent or sidecar being present.
+  "(function(d){var h=" + JSON.stringify(import_interaction_config.EARLY_HYDRATION_INTENTS_KEY) + ";if(d[h])return;var u=d[h]={version:1,q:[]},es=" + JSON.stringify(import_interaction_config.HYDRATE_SUPPORTED_INTERACTION_EVENTS) + ",ds=" + JSON.stringify(import_interaction_config.HYDRATE_DEFAULT_INTERACTION_EVENTS) + ",ns=" + JSON.stringify(import_interaction_config.HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS) + ',is="[' + import_constants.HYDRATE_INDEPENDENT_ATTR + ']",ms="[' + import_constants.HYDRATE_ID_ATTR + ']";function c(e){var t=e.target;if(!t||!t.closest)return;var b=t.closest(is);if(!b)return;var id=b.getAttribute("' + import_constants.HYDRATE_ID_ATTR + '");if(id===null)return;var w=b.getAttribute("' + import_constants.HYDRATE_WHEN_ATTR + '"),a=b.getAttribute("' + import_interaction_config.HYDRATE_INTERACTION_EVENTS_ATTR + '");if(w===null||w==="never")return;var link=t.closest("a[href],area[href]");if(link&&b.contains(link))return;if((e.type==="pointerenter"||e.type==="mouseenter")&&d.elementFromPoint){var hit=d.elementFromPoint(e.clientX,e.clientY),nested=hit&&hit.closest(is);if(nested&&nested!==b&&b.contains(nested))return;}var m=t.closest(ms),ok=false;while(m){var x=m.getAttribute("' + import_constants.HYDRATE_WHEN_ATTR + '"),y=m.getAttribute("' + import_interaction_config.HYDRATE_INTERACTION_EVENTS_ATTR + '");if(x==="dynamic"&&e.type==="click"||x==="interaction"&&(y===null?ds:y.split(/\\s+/)).indexOf(e.type)!==-1)ok=true;if(m===b)break;m=m.parentElement&&m.parentElement.closest(ms);}if(!ok)return;var c=null,g=null,p=u.q[u.q.length-1];if(e.type==="click"&&e.button===0&&!e.altKey&&!e.ctrlKey&&!e.metaKey&&!e.shiftKey){c=t.closest("button[' + import_interaction_config.HYDRATE_SELECTION_ATTR + ']");if(c&&c.type==="button"&&c.closest(is)===b)g=c.getAttribute("' + import_interaction_config.HYDRATE_SELECTION_ATTR + '");}var v=g?[e,t,b,id,w,a,c,g]:[e,t,b,id,w,a];if(g&&p&&p[2]===b&&p[7]===g&&p[6].isConnected&&p[6].contains(p[1])&&p[6].type==="button"&&p[6].getAttribute("' + import_interaction_config.HYDRATE_SELECTION_ATTR + '")===g){u.q[u.q.length-1]=v;}else{if(u.q.length>=' + import_interaction_config.EARLY_HYDRATION_INTENTS_LIMIT + "){u.overflow=true;u.q.length=0;u.stop();return;}u.q.push(v);}if(e.bubbles){if(e.cancelable&&ns.indexOf(e.type)===-1)e.preventDefault();e.stopPropagation();e.stopImmediatePropagation();}}u.stop=function(){for(var i=0;i<es.length;i++)d.removeEventListener(es[i],c,true);u.stop=null;};for(var j=0;j<es.length;j++)d.addEventListener(es[j],c,true);})(document);";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  earlySignalBootstrapScript,
+  streamedSignalBootstrapJs
+});

package/dist/cjs/server/index.cjs

@@ -29,25 +29,39 @@ __export(server_exports, {
   Suspense: () => import_runtime_server.Suspense,
   ViewTransition: () => import_runtime_server.ViewTransition,
   __methodDep: () => import_method_dep.__methodDep,
+  __registerServerFunction: () => import_server_call.__registerServerFunction,
+  __serverCall: () => import_server_call.__serverCall,
+  __setServerCallContextSource: () => import_server_call.__setServerCallContextSource,
   __useLinkedStateWithGetter: () => import_runtime_server.__useLinkedStateWithGetter,
   __useReducerWithGetter: () => import_runtime_server.__useReducerWithGetter,
   __useStateWithGetter: () => import_runtime_server.__useStateWithGetter,
   addTransitionType: () => import_runtime_server.addTransitionType,
+  batchServerCalls: () => import_rpc_batch.batchServerCalls,
   cloneElement: () => import_runtime_server.cloneElement,
+  createAutomaticStreamedSignalInjection: () => import_streamed_signals.createAutomaticStreamedSignalInjection,
   createContext: () => import_runtime_server.createContext,
   createElement: () => import_runtime_server.createElement,
   createPortal: () => import_runtime_server.createPortal,
   createScopedElement: () => import_runtime_server.createScopedElement,
   createScopedValue: () => import_runtime_server.createScopedValue,
+  createStreamedRegionPlacementFrame: () => import_streamed_region.createStreamedRegionPlacementFrame,
+  createStreamedRendererFrameStream: () => import_streamed_signals.createStreamedRendererFrameStream,
+  createStreamedSignalInjection: () => import_streamed_signals.createStreamedSignalInjection,
+  createStreamedSignalResultFrames: () => import_streamed_signals.createStreamedSignalResultFrames,
   createSubSlot: () => import_sub_slot.createSubSlot,
   descriptorChildren: () => import_runtime_server.descriptorChildren,
+  earlySignalBootstrapScript: () => import_early_signals.earlySignalBootstrapScript,
+  enableServerSignalBindings: () => import_runtime_server.enableServerSignalBindings,
   escapeAttr: () => import_runtime_server.escapeAttr,
   escapeHtml: () => import_runtime_server.escapeHtml,
   executeServerFunction: () => import_rpc.executeServerFunction,
+  executeServerFunctionBatch: () => import_rpc_batch.executeServerFunctionBatch,
+  executeServerFunctionStream: () => import_rpc.executeServerFunctionStream,
   flushSync: () => import_runtime_server.flushSync,
   getSsrSuspenseTimeout: () => import_runtime_server.getSsrSuspenseTimeout,
   hookSlots: () => import_runtime_server.hookSlots,
   injectStyle: () => import_runtime_server.injectStyle,
+  installSignalOwnerEnvironment: () => import_owner_context.installSignalOwnerEnvironment,
   invokeManualHook: () => import_runtime_server.invokeManualHook,
   isChildrenBlock: () => import_runtime_server.isChildrenBlock,
   isValidElement: () => import_runtime_server.isValidElement,
@@ -74,6 +88,7 @@ __export(server_exports, {
   renderToStaticMarkup: () => import_runtime_server.renderToStaticMarkup,
   renderToString: () => import_runtime_server.renderToString,
   requestFormReset: () => import_runtime_server.requestFormReset,
+  retireSignalOwnerIdentity: () => import_owner_context.retireSignalOwnerIdentity,
   setSsrSuspenseTimeout: () => import_runtime_server.setSsrSuspenseTimeout,
   ssrActivity: () => import_runtime_server.ssrActivity,
   ssrArm: () => import_runtime_server.ssrArm,
@@ -110,6 +125,9 @@ __export(server_exports, {
   ssrSelectAttrs: () => import_runtime_server.ssrSelectAttrs,
   ssrSelectScope: () => import_runtime_server.ssrSelectScope,
   ssrSelectScopeSources: () => import_runtime_server.ssrSelectScopeSources,
+  ssrSignalControlAttrs: () => import_runtime_server.ssrSignalControlAttrs,
+  ssrSignalControlValue: () => import_runtime_server.ssrSignalControlValue,
+  ssrSignalValue: () => import_runtime_server.ssrSignalValue,
   ssrSnapshotSpread: () => import_runtime_server.ssrSnapshotSpread,
   ssrSpread: () => import_runtime_server.ssrSpread,
   ssrSpreadContent: () => import_runtime_server.ssrSpreadContent,
@@ -124,6 +142,7 @@ __export(server_exports, {
   ssrValueAttr: () => import_runtime_server.ssrValueAttr,
   ssrVoidContent: () => import_runtime_server.ssrVoidContent,
   startTransition: () => import_runtime_server.startTransition,
+  streamedRendererFrameScript: () => import_streamed_signals.streamedRendererFrameScript,
   styleMap: () => import_runtime_server.styleMap,
   subSlot: () => import_sub_slot.subSlot,
   touchStyleMap: () => import_runtime_server.touchStyleMap,
@@ -162,6 +181,12 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 var import_trusted_html = require("../trusted-html.cjs");
 var import_rpc = require("./rpc.cjs");
+var import_early_signals = require("./early-signals.cjs");
+var import_rpc_batch = require("./rpc-batch.cjs");
+var import_streamed_region = require("./streamed-region.cjs");
+var import_streamed_signals = require("./streamed-signals.cjs");
+var import_owner_context = require("../signals/owner-context.cjs");
+var import_server_call = require("../server-call.cjs");
 var import_version = require("../version.cjs");
 var import_compatibility = require("../compatibility.cjs");
 var import_sub_slot = require("../sub-slot.cjs");
@@ -180,25 +205,39 @@ var import_runtime_server = require("../runtime.server.cjs");
   Suspense,
   ViewTransition,
   __methodDep,
+  __registerServerFunction,
+  __serverCall,
+  __setServerCallContextSource,
   __useLinkedStateWithGetter,
   __useReducerWithGetter,
   __useStateWithGetter,
   addTransitionType,
+  batchServerCalls,
   cloneElement,
+  createAutomaticStreamedSignalInjection,
   createContext,
   createElement,
   createPortal,
   createScopedElement,
   createScopedValue,
+  createStreamedRegionPlacementFrame,
+  createStreamedRendererFrameStream,
+  createStreamedSignalInjection,
+  createStreamedSignalResultFrames,
   createSubSlot,
   descriptorChildren,
+  earlySignalBootstrapScript,
+  enableServerSignalBindings,
   escapeAttr,
   escapeHtml,
   executeServerFunction,
+  executeServerFunctionBatch,
+  executeServerFunctionStream,
   flushSync,
   getSsrSuspenseTimeout,
   hookSlots,
   injectStyle,
+  installSignalOwnerEnvironment,
   invokeManualHook,
   isChildrenBlock,
   isValidElement,
@@ -225,6 +264,7 @@ var import_runtime_server = require("../runtime.server.cjs");
   renderToStaticMarkup,
   renderToString,
   requestFormReset,
+  retireSignalOwnerIdentity,
   setSsrSuspenseTimeout,
   ssrActivity,
   ssrArm,
@@ -261,6 +301,9 @@ var import_runtime_server = require("../runtime.server.cjs");
   ssrSelectAttrs,
   ssrSelectScope,
   ssrSelectScopeSources,
+  ssrSignalControlAttrs,
+  ssrSignalControlValue,
+  ssrSignalValue,
   ssrSnapshotSpread,
   ssrSpread,
   ssrSpreadContent,
@@ -275,6 +318,7 @@ var import_runtime_server = require("../runtime.server.cjs");
   ssrValueAttr,
   ssrVoidContent,
   startTransition,
+  streamedRendererFrameScript,
   styleMap,
   subSlot,
   touchStyleMap,

package/dist/cjs/server/rpc-batch.cjs

@@ -0,0 +1,149 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rpc_batch_exports = {};
+__export(rpc_batch_exports, {
+  batchServerCalls: () => batchServerCalls,
+  executeServerFunctionBatch: () => executeServerFunctionBatch
+});
+module.exports = __toCommonJS(rpc_batch_exports);
+var import_server_call = require("../server-call.cjs");
+var import_server_rpc_protocol = require("../server-rpc-protocol.cjs");
+var import_server_rpc_stream_client = require("../server-rpc-stream-client.cjs");
+var import_rpc_stream = require("./rpc-stream.cjs");
+function batchServerCalls(options, callback) {
+  (0, import_server_rpc_protocol.validateServerCallBatch)(options);
+  return callback();
+}
+function executeServerFunctionBatch(body, invoke, options = {}) {
+  const limits = (0, import_server_rpc_protocol.serverResultLimits)(options);
+  let members;
+  try {
+    const envelope = JSON.parse(body);
+    if (!Array.isArray(envelope) || envelope.length !== 2 || envelope[0] !== 1 || !Array.isArray(envelope[1]) || envelope[1].length === 0 || envelope[1].length > 32) {
+      throw new Error("Invalid batch");
+    }
+    members = envelope[1].map((member, id) => {
+      if (!Array.isArray(member) || member.length !== 3 || member[0] !== id || typeof member[1] !== "string" || !/^[a-f0-9]{8}$/.test(member[1]) || typeof member[2] !== "string") {
+        throw new Error("Invalid batch member");
+      }
+      (0, import_server_rpc_protocol.decodeServerArguments)(member[2]);
+      return { id, hash: member[1], body: member[2] };
+    });
+  } catch (error) {
+    throw new import_server_call.InvalidServerFunctionPayloadError(error);
+  }
+  const cancellation = new AbortController();
+  const signal = options.signal === void 0 ? cancellation.signal : AbortSignal.any([options.signal, cancellation.signal]);
+  async function* results() {
+    const ready = [];
+    let wake;
+    let remaining = members.length;
+    let closed = false;
+    let sequence = 1;
+    for (const member of members) {
+      void (async () => {
+        const timeout = new AbortController();
+        const memberSignal = AbortSignal.any([signal, timeout.signal]);
+        const timer = setTimeout(
+          () => timeout.abort(new DOMException("Server batch member timed out", "TimeoutError")),
+          limits.timeoutMs
+        );
+        let abort;
+        const aborted = new Promise((_, reject) => {
+          abort = () => reject(memberSignal.reason);
+          memberSignal.addEventListener("abort", abort, { once: true });
+          if (memberSignal.aborted) abort();
+        });
+        let outcome;
+        try {
+          const work = (async () => {
+            memberSignal.throwIfAborted();
+            const response = await invoke(member, memberSignal);
+            if (memberSignal.aborted) {
+              void response.body?.cancel().catch(() => {
+              });
+              memberSignal.throwIfAborted();
+            }
+            if (!response.ok) {
+              void response.body?.cancel().catch(() => {
+              });
+              return [
+                member.id,
+                response.headers.get("Octane-RPC-Outcome") === "rejected" ? "rejected" : "uncertain",
+                `Server function failed with status ${response.status}`
+              ];
+            }
+            const value = await (0, import_server_rpc_stream_client.readServerResult)(response, { ...limits, signal: memberSignal });
+            if (value !== null && typeof value === "object" && Symbol.asyncIterator in value) {
+              await value[Symbol.asyncIterator]().return?.();
+              throw new Error("Subscriptions cannot join a finite server-call batch");
+            }
+            return [member.id, "value", value];
+          })();
+          outcome = await Promise.race([work, aborted]);
+        } catch {
+          outcome = [
+            member.id,
+            "uncertain",
+            "Server batch member did not produce an authoritative result"
+          ];
+        } finally {
+          clearTimeout(timer);
+          memberSignal.removeEventListener("abort", abort);
+        }
+        if (!closed) {
+          ready.push(outcome);
+          wake?.();
+        }
+      })();
+    }
+    try {
+      while (remaining > 0) {
+        if (ready.length === 0)
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+        wake = void 0;
+        while (ready.length > 0) {
+          remaining--;
+          let outcome = ready.shift();
+          if ((0, import_server_rpc_protocol.encodeServerResultFrame)(sequence, { kind: "value", value: outcome }).byteLength > limits.maxFrameBytes) {
+            outcome = [outcome[0], "uncertain", "Server batch member exceeded its frame budget"];
+          }
+          sequence++;
+          yield outcome;
+        }
+      }
+    } finally {
+      closed = true;
+      cancellation.abort();
+      ready.length = 0;
+    }
+  }
+  return (0, import_rpc_stream.createServerResultStream)(results(), {
+    ...limits,
+    signal,
+    cancel: () => cancellation.abort()
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  batchServerCalls,
+  executeServerFunctionBatch
+});

package/dist/cjs/server/rpc-stream.cjs

@@ -0,0 +1,146 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rpc_stream_exports = {};
+__export(rpc_stream_exports, {
+  createServerResultStream: () => createServerResultStream
+});
+module.exports = __toCommonJS(rpc_stream_exports);
+var import_server_rpc_protocol = require("../server-rpc-protocol.cjs");
+function createServerResultStream(result, options = {}) {
+  const limits = (0, import_server_rpc_protocol.serverResultLimits)(options);
+  let sequence = 0;
+  let totalBytes = 0;
+  let iterator;
+  let finished = false;
+  let terminal = false;
+  let streaming = false;
+  let initialized = false;
+  let pending = Promise.resolve(result);
+  void pending.catch(() => {
+  });
+  let controller;
+  let timer;
+  const cleanup = () => {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+  };
+  const closeIterator = () => {
+    try {
+      void Promise.resolve(iterator?.return?.()).catch(() => {
+      });
+    } catch {
+    }
+    iterator = void 0;
+  };
+  const write = (frame) => {
+    const encoded = (0, import_server_rpc_protocol.encodeServerResultFrame)(sequence, frame);
+    if (encoded.byteLength > limits.maxFrameBytes || totalBytes + encoded.byteLength > limits.maxTotalBytes) {
+      throw new Error("Server result exceeded its response budget");
+    }
+    sequence++;
+    totalBytes += encoded.byteLength;
+    controller.enqueue(encoded);
+  };
+  const fail = (message) => {
+    if (finished) return;
+    finished = true;
+    pending = void 0;
+    cleanup();
+    options.cancel?.();
+    closeIterator();
+    try {
+      write({ kind: "error", error: message });
+      controller.close();
+    } catch (error) {
+      controller.error(error);
+    }
+  };
+  const abort = () => fail("Server function was canceled");
+  return new ReadableStream(
+    {
+      start(streamController) {
+        controller = streamController;
+        timer = setTimeout(() => fail("Server function timed out"), limits.timeoutMs);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted) abort();
+      },
+      async pull() {
+        if (finished) return;
+        try {
+          if (terminal) {
+            write({ kind: "complete" });
+            finished = true;
+            cleanup();
+            controller.close();
+            return;
+          }
+          if (!initialized) {
+            const value = await pending;
+            pending = void 0;
+            if (finished) {
+              if (value !== null && typeof value === "object" && Symbol.asyncIterator in value) {
+                iterator = value[Symbol.asyncIterator]();
+                closeIterator();
+              }
+              return;
+            }
+            initialized = true;
+            if (value !== null && typeof value === "object" && Symbol.asyncIterator in value) {
+              iterator = value[Symbol.asyncIterator]();
+              streaming = true;
+              write({ kind: "stream" });
+              return;
+            }
+            write({ kind: "value", value });
+            terminal = true;
+            return;
+          }
+          if (streaming) {
+            const item = await iterator.next();
+            if (finished) return;
+            if (item.done) {
+              iterator = void 0;
+              write({ kind: "complete" });
+              finished = true;
+              cleanup();
+              controller.close();
+            } else {
+              write({ kind: "value", value: item.value });
+            }
+          }
+        } catch {
+          fail("Server function failed");
+        }
+      },
+      cancel() {
+        if (finished) return;
+        finished = true;
+        pending = void 0;
+        cleanup();
+        options.cancel?.();
+        closeIterator();
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServerResultStream
+});

package/dist/cjs/server/rpc.cjs

@@ -28,31 +28,50 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var rpc_exports = {};
 __export(rpc_exports, {
-  executeServerFunction: () => executeServerFunction
+  executeServerFunction: () => executeServerFunction,
+  executeServerFunctionStream: () => executeServerFunctionStream
 });
 module.exports = __toCommonJS(rpc_exports);
 var devalue = __toESM(require("devalue"), 1);
-class InvalidServerFunctionPayloadError extends Error {
-  code = "OCTANE_INVALID_RPC_PAYLOAD";
-  constructor(cause) {
-    super("Invalid server function arguments", { cause });
-    this.name = "InvalidServerFunctionPayloadError";
-  }
-}
-async function executeServerFunction(fn, body) {
+var import_server_call = require("../server-call.cjs");
+var import_rpc_stream = require("./rpc-stream.cjs");
+var import_server_rpc_protocol = require("../server-rpc-protocol.cjs");
+function serverArguments(body) {
   let args;
   try {
     args = devalue.parse(body);
   } catch (error) {
-    throw new InvalidServerFunctionPayloadError(error);
-  }
-  if (!Array.isArray(args)) {
-    throw new InvalidServerFunctionPayloadError();
+    throw new import_server_call.InvalidServerFunctionPayloadError(error);
   }
-  const value = await fn.apply(null, args);
+  if (!Array.isArray(args)) throw new import_server_call.InvalidServerFunctionPayloadError();
+  return args;
+}
+async function executeServerFunction(fn, body, context) {
+  const args = serverArguments(body);
+  const value = await (0, import_server_call.invokeServerFunction)(fn, args, context);
   return devalue.stringify({ value });
 }
+function executeServerFunctionStream(fn, body, context, limits) {
+  const resolvedLimits = (0, import_server_rpc_protocol.serverResultLimits)(limits);
+  let args;
+  try {
+    args = (0, import_server_rpc_protocol.decodeServerArguments)(body);
+  } catch (error) {
+    throw new import_server_call.InvalidServerFunctionPayloadError(error);
+  }
+  const cancellation = new AbortController();
+  const signal = context === void 0 ? cancellation.signal : AbortSignal.any([context.signal, cancellation.signal]);
+  const trusted = context === void 0 ? void 0 : { ...context, signal };
+  return (0, import_rpc_stream.createServerResultStream)(
+    Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return (0, import_server_call.invokeServerFunction)(fn, args, trusted);
+    }),
+    { ...resolvedLimits, signal, cancel: () => cancellation.abort() }
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  executeServerFunction
+  executeServerFunction,
+  executeServerFunctionStream
 });