octane 0.2.12 → 0.2.13

package/dist/server/early-signals.d.ts

@@ -0,0 +1,14 @@
+export interface EarlySignalBootstrapOptions {
+    readonly nonce?: string;
+    /** Include native intent capture for independently activated widgets. */
+    readonly independentHydration?: boolean;
+}
+/**
+ * Install the framework's renderer-free input and streaming mailboxes before
+ * exposing interactive HTML. Envelope-owning hosts emit this once and pass
+ * earlySignalBootstrap: 'external' to each fragment renderer. This does not
+ * import, preload or activate client modules, nor install application policy.
+ */
+export declare function earlySignalBootstrapScript(options?: EarlySignalBootstrapOptions): string;
+/** @internal Shared byte-identical bootstrap for buffered and streaming renderers. */
+export declare function streamedSignalBootstrapJs(independentHydration?: boolean): string;

package/dist/server/early-signals.js

@@ -0,0 +1,34 @@
+import {
+  HYDRATE_ID_ATTR,
+  HYDRATE_WHEN_ATTR,
+  HYDRATE_INDEPENDENT_ATTR,
+  SIGNAL_CONTROL_ATTR,
+  STREAM_SCRIPT_ATTR
+} from "../constants.js";
+import {
+  EARLY_HYDRATION_INTENTS_KEY,
+  EARLY_HYDRATION_INTENTS_LIMIT,
+  HYDRATE_DEFAULT_INTERACTION_EVENTS,
+  HYDRATE_INTERACTION_EVENTS_ATTR,
+  HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS,
+  HYDRATE_SELECTION_ATTR,
+  HYDRATE_SUPPORTED_INTERACTION_EVENTS
+} from "../hydration/interaction-config.js";
+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 " + 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("' + 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(EARLY_HYDRATION_INTENTS_KEY) + ";if(d[h])return;var u=d[h]={version:1,q:[]},es=" + JSON.stringify(HYDRATE_SUPPORTED_INTERACTION_EVENTS) + ",ds=" + JSON.stringify(HYDRATE_DEFAULT_INTERACTION_EVENTS) + ",ns=" + JSON.stringify(HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS) + ',is="[' + HYDRATE_INDEPENDENT_ATTR + ']",ms="[' + 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("' + HYDRATE_ID_ATTR + '");if(id===null)return;var w=b.getAttribute("' + HYDRATE_WHEN_ATTR + '"),a=b.getAttribute("' + 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("' + HYDRATE_WHEN_ATTR + '"),y=m.getAttribute("' + 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[' + HYDRATE_SELECTION_ATTR + ']");if(c&&c.type==="button"&&c.closest(is)===b)g=c.getAttribute("' + 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("' + HYDRATE_SELECTION_ATTR + '")===g){u.q[u.q.length-1]=v;}else{if(u.q.length>=' + 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);";
+}
+export {
+  earlySignalBootstrapScript,
+  streamedSignalBootstrapJs
+};

package/dist/server/index.d.ts

@@ -21,9 +21,17 @@ export { trustHTML, type TrustedHTML } from '../trusted-html.js';
  * private ABI — present because compiled output needs them, not because apps
  * should call them.
  */
-export { executeServerFunction } from './rpc.js';
+export { executeServerFunction, executeServerFunctionStream } from './rpc.js';
+export { earlySignalBootstrapScript, type EarlySignalBootstrapOptions } from './early-signals.js';
+export { batchServerCalls, executeServerFunctionBatch, type ServerCallBatchOptions, type ServerBatchMember, } from './rpc-batch.js';
+export type { ServerResultLimits } from '../server-rpc-protocol.js';
+export { createStreamedRegionPlacementFrame, type StreamedRegionPlacementOptions, } from './streamed-region.js';
+export { createAutomaticStreamedSignalInjection, createStreamedRendererFrameStream, createStreamedSignalInjection, createStreamedSignalResultFrames, streamedRendererFrameScript, type StreamedRendererLimits, type AutomaticStreamedSignalInjection, type AutomaticStreamedSignalOptions, type StreamedSignalResultOptions, } from './streamed-signals.js';
+export { installSignalOwnerEnvironment, retireSignalOwnerIdentity, } from '../signals/owner-context.js';
+export type { SignalOwner, SignalOwnerEnvironment } from '../signals/types.js';
+export { __registerServerFunction, __serverCall, __setServerCallContextSource, type ServerCallContext, type ServerCallContextSource, type ServerCallHost, type ServerCallOptions, type ServerFunction, type ServerFunctionTarget, } from '../server-call.js';
 export { version } from '../version.js';
 export { StrictMode, unstable_batchedUpdates } from '../compatibility.js';
 export { createSubSlot, subSlot, type SubSlot, type SlotlessSubSlot, type SubSlotOptions, } from '../sub-slot.js';
 export { __methodDep } from '../method-dep.js';
-export { renderToString, renderToStaticMarkup, renderToPipeableStream, renderToReadableStream, type RenderResult, type RenderOptions, type ServerRenderNode, type StreamOptions, type StreamInjectionSource, setSsrSuspenseTimeout, getSsrSuspenseTimeout, EXTERNAL_HYDRATION_PROMISE, HYDRATION_RANGE_BOUNDARY, useState, useLinkedState, useReducer, __useStateWithGetter, __useLinkedStateWithGetter, __useReducerWithGetter, type LinkedStatePrevious, type LinkedStateOptions, useEffect, useLayoutEffect, useInsertionEffect, useImperativeHandle, useMemo, useCallback, useRef, useId, useEffectEvent, useTransition, useDeferredValue, useSyncExternalStore, useActionState, useActionState as useFormState, useFormStatus, useOptimistic, useDebugValue, memo, lazy, hookSlots, withSlot, manualHook, invokeManualHook, startTransition, flushSync, isChildrenBlock, isValidElement, cloneElement, Children, createPortal, requestFormReset, preload, preinit, preloadModule, preinitModule, preconnect, prefetchDNS, Suspense, ErrorBoundary, Hydrate, Fragment, Activity, Activity as unstable_Activity, ViewTransition, ViewTransition as unstable_ViewTransition, addTransitionType, addTransitionType as unstable_addTransitionType, createContext, use, useContext, ssrIsSuspense, type Context, type FormStatus, markChildrenBlock, markWarm, ssrHtml, ssrChildTextPre, ssrChildPre, descriptorChildren, createElement, createScopedValue, createScopedElement, positionalChildren, escapeHtml, escapeAttr, ssrText, ssrTextPre, ssrNestingText, ssrChild, ssrChildText, ssrAttr, normalizeClass, ssrStyle, ssrClass, ssrAttrs, ssrSnapshotSpread, ssrSpread, ssrInnerHtml, ssrScriptInnerHtml, ssrChildrenSources, ssrSpreadContent, ssrVoidContent, ssrValueAttr, ssrCheckedAttr, ssrInputAttrs, ssrFormAuthoringDiagnostics, ssrTextareaValue, ssrTextareaValueSources, ssrSelectAttrs, ssrSelectScope, ssrSelectScopeSources, ssrOptionValueSources, ssrOption, ssrElement, ssrComponent, ssrComponentNS, ssrInNamespace, ssrBlock, ssrFragmentMarker, ssrActivity, ssrForBlock, mapSlot, ssrControl, ssrArm, ssrForItem, ssrTry, ssrPortal, injectStyle, ssrHeadEl, styleMap, touchStyleMap, ssrStylesheetResource, ssrStyleResource, ssrScriptResource, namespaceHead, namespaceHeadElement, puMemo, puBatch, warmMemo, warmChild, } from '../runtime.server.js';
+export { renderToString, renderToStaticMarkup, renderToPipeableStream, renderToReadableStream, type RenderResult, type RenderOptions, type ServerRenderNode, type StreamOptions, type StreamInjectionSource, setSsrSuspenseTimeout, getSsrSuspenseTimeout, EXTERNAL_HYDRATION_PROMISE, HYDRATION_RANGE_BOUNDARY, useState, useLinkedState, useReducer, __useStateWithGetter, __useLinkedStateWithGetter, __useReducerWithGetter, type LinkedStatePrevious, type LinkedStateOptions, useEffect, useLayoutEffect, useInsertionEffect, useImperativeHandle, useMemo, useCallback, useRef, useId, useEffectEvent, useTransition, useDeferredValue, useSyncExternalStore, useActionState, useActionState as useFormState, useFormStatus, useOptimistic, useDebugValue, memo, lazy, hookSlots, withSlot, manualHook, invokeManualHook, startTransition, flushSync, isChildrenBlock, isValidElement, cloneElement, Children, createPortal, requestFormReset, preload, preinit, preloadModule, preinitModule, preconnect, prefetchDNS, Suspense, ErrorBoundary, Hydrate, Fragment, Activity, Activity as unstable_Activity, ViewTransition, ViewTransition as unstable_ViewTransition, addTransitionType, addTransitionType as unstable_addTransitionType, createContext, use, useContext, ssrIsSuspense, type Context, type FormStatus, markChildrenBlock, markWarm, ssrHtml, ssrChildTextPre, ssrChildPre, descriptorChildren, createElement, createScopedValue, createScopedElement, positionalChildren, escapeHtml, escapeAttr, ssrText, ssrTextPre, ssrNestingText, ssrChild, ssrChildText, ssrAttr, normalizeClass, ssrStyle, ssrClass, ssrAttrs, ssrSignalValue, ssrSignalControlValue, ssrSignalControlAttrs, ssrSnapshotSpread, enableServerSignalBindings, ssrSpread, ssrInnerHtml, ssrScriptInnerHtml, ssrChildrenSources, ssrSpreadContent, ssrVoidContent, ssrValueAttr, ssrCheckedAttr, ssrInputAttrs, ssrFormAuthoringDiagnostics, ssrTextareaValue, ssrTextareaValueSources, ssrSelectAttrs, ssrSelectScope, ssrSelectScopeSources, ssrOptionValueSources, ssrOption, ssrElement, ssrComponent, ssrComponentNS, ssrInNamespace, ssrBlock, ssrFragmentMarker, ssrActivity, ssrForBlock, mapSlot, ssrControl, ssrArm, ssrForItem, ssrTry, ssrPortal, injectStyle, ssrHeadEl, styleMap, touchStyleMap, ssrStylesheetResource, ssrStyleResource, ssrScriptResource, namespaceHead, namespaceHeadElement, puMemo, puBatch, warmMemo, warmChild, } from '../runtime.server.js';

package/dist/server/index.js

@@ -1,5 +1,29 @@
 import { trustHTML } from "../trusted-html.js";
-import { executeServerFunction } from "./rpc.js";
+import { executeServerFunction, executeServerFunctionStream } from "./rpc.js";
+import { earlySignalBootstrapScript } from "./early-signals.js";
+import {
+  batchServerCalls,
+  executeServerFunctionBatch
+} from "./rpc-batch.js";
+import {
+  createStreamedRegionPlacementFrame
+} from "./streamed-region.js";
+import {
+  createAutomaticStreamedSignalInjection,
+  createStreamedRendererFrameStream,
+  createStreamedSignalInjection,
+  createStreamedSignalResultFrames,
+  streamedRendererFrameScript
+} from "./streamed-signals.js";
+import {
+  installSignalOwnerEnvironment,
+  retireSignalOwnerIdentity
+} from "../signals/owner-context.js";
+import {
+  __registerServerFunction,
+  __serverCall,
+  __setServerCallContextSource
+} from "../server-call.js";
 import { version } from "../version.js";
 import { StrictMode, unstable_batchedUpdates } from "../compatibility.js";
 import {
@@ -95,7 +119,11 @@ import {
   ssrStyle,
   ssrClass,
   ssrAttrs,
+  ssrSignalValue,
+  ssrSignalControlValue,
+  ssrSignalControlAttrs,
   ssrSnapshotSpread,
+  enableServerSignalBindings,
   ssrSpread,
   ssrInnerHtml,
   ssrScriptInnerHtml,
@@ -153,25 +181,39 @@ export {
   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,
@@ -198,6 +240,7 @@ export {
   renderToStaticMarkup,
   renderToString,
   requestFormReset,
+  retireSignalOwnerIdentity,
   setSsrSuspenseTimeout,
   ssrActivity,
   ssrArm,
@@ -234,6 +277,9 @@ export {
   ssrSelectAttrs,
   ssrSelectScope,
   ssrSelectScopeSources,
+  ssrSignalControlAttrs,
+  ssrSignalControlValue,
+  ssrSignalValue,
   ssrSnapshotSpread,
   ssrSpread,
   ssrSpreadContent,
@@ -248,6 +294,7 @@ export {
   ssrValueAttr,
   ssrVoidContent,
   startTransition,
+  streamedRendererFrameScript,
   styleMap,
   subSlot,
   touchStyleMap,

package/dist/server/rpc-batch.d.ts

@@ -0,0 +1,17 @@
+import { type ServerCallBatchOptions, type ServerResultLimits } from '../server-rpc-protocol.js';
+export type { ServerCallBatchOptions } from '../server-rpc-protocol.js';
+/** In-process calls keep their per-call authorization; there is no HTTP batch to collect. */
+export declare function batchServerCalls<T>(options: ServerCallBatchOptions, callback: () => T): T;
+export interface ServerBatchMember {
+    id: number;
+    hash: string;
+    body: string;
+}
+/**
+ * Finite independent reads only. Each member crosses the ordinary authorized
+ * request boundary. Multi-yield subscriptions use their own demand-driven RPC.
+ * At most 32 bounded single values can be ready; no unbounded per-channel queue.
+ */
+export declare function executeServerFunctionBatch(body: string, invoke: (member: ServerBatchMember, signal: AbortSignal) => Promise<Response>, options?: ServerResultLimits & {
+    signal?: AbortSignal;
+}): ReadableStream<Uint8Array>;

package/dist/server/rpc-batch.js

@@ -0,0 +1,129 @@
+import { InvalidServerFunctionPayloadError } from "../server-call.js";
+import {
+  decodeServerArguments,
+  encodeServerResultFrame,
+  serverResultLimits,
+  validateServerCallBatch
+} from "../server-rpc-protocol.js";
+import { readServerResult } from "../server-rpc-stream-client.js";
+import { createServerResultStream } from "./rpc-stream.js";
+function batchServerCalls(options, callback) {
+  validateServerCallBatch(options);
+  return callback();
+}
+function executeServerFunctionBatch(body, invoke, options = {}) {
+  const limits = 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");
+      }
+      decodeServerArguments(member[2]);
+      return { id, hash: member[1], body: member[2] };
+    });
+  } catch (error) {
+    throw new 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 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 (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 createServerResultStream(results(), {
+    ...limits,
+    signal,
+    cancel: () => cancellation.abort()
+  });
+}
+export {
+  batchServerCalls,
+  executeServerFunctionBatch
+};

package/dist/server/rpc-stream.d.ts

@@ -0,0 +1,9 @@
+import { type ServerResultLimits } from '../server-rpc-protocol.js';
+/**
+ * One invocation, one bounded result channel. next() is demand-driven: a slow
+ * reader cannot make a generator produce an unbounded server-side mailbox.
+ */
+export declare function createServerResultStream(result: unknown, options?: ServerResultLimits & {
+    signal?: AbortSignal;
+    cancel?: () => void;
+}): ReadableStream<Uint8Array>;

package/dist/server/rpc-stream.js

@@ -0,0 +1,125 @@
+import {
+  encodeServerResultFrame,
+  serverResultLimits
+} from "../server-rpc-protocol.js";
+function createServerResultStream(result, options = {}) {
+  const limits = 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 = 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 }
+  );
+}
+export {
+  createServerResultStream
+};

package/dist/server/rpc.d.ts

@@ -1,3 +1,5 @@
+import { type ServerCallContext } from '../server-call.js';
+import { type ServerResultLimits } from '../server-rpc-protocol.js';
 /**
  * Execute a `module server` function for an RPC request. The wire format is
  * devalue on both sides (matching @ripple-ts/adapter's client stub, and chosen
@@ -7,4 +9,6 @@
  * graph (`ssrLoadModule('octane/server')`) so the executor and the resolved
  * server function share one runtime.
  */
-export declare function executeServerFunction(fn: (...args: any[]) => unknown, body: string): Promise<string>;
+export declare function executeServerFunction(fn: Function, body: string, context?: ServerCallContext): Promise<string>;
+/** Opt-in result streaming; application authorization runs before this executor. */
+export declare function executeServerFunctionStream(fn: Function, body: string, context?: ServerCallContext, limits?: ServerResultLimits): ReadableStream<Uint8Array>;

package/dist/server/rpc.js

@@ -1,24 +1,48 @@
 import * as devalue from "devalue";
-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) {
+import {
+  InvalidServerFunctionPayloadError,
+  invokeServerFunction
+} from "../server-call.js";
+import { createServerResultStream } from "./rpc-stream.js";
+import {
+  decodeServerArguments,
+  serverResultLimits
+} from "../server-rpc-protocol.js";
+function serverArguments(body) {
   let args;
   try {
     args = devalue.parse(body);
   } catch (error) {
     throw new InvalidServerFunctionPayloadError(error);
   }
-  if (!Array.isArray(args)) {
-    throw new InvalidServerFunctionPayloadError();
-  }
-  const value = await fn.apply(null, args);
+  if (!Array.isArray(args)) throw new InvalidServerFunctionPayloadError();
+  return args;
+}
+async function executeServerFunction(fn, body, context) {
+  const args = serverArguments(body);
+  const value = await invokeServerFunction(fn, args, context);
   return devalue.stringify({ value });
 }
+function executeServerFunctionStream(fn, body, context, limits) {
+  const resolvedLimits = serverResultLimits(limits);
+  let args;
+  try {
+    args = decodeServerArguments(body);
+  } catch (error) {
+    throw new 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 createServerResultStream(
+    Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return invokeServerFunction(fn, args, trusted);
+    }),
+    { ...resolvedLimits, signal, cancel: () => cancellation.abort() }
+  );
+}
 export {
-  executeServerFunction
+  executeServerFunction,
+  executeServerFunctionStream
 };

package/dist/server/signal-query-observation.d.ts

@@ -0,0 +1,3 @@
+import type { ServerSignalQueryAttemptObservations } from '../signals/query-attempt-observer.js';
+/** Allocate server mirrors only for an observed attempt, not ordinary browser requests. */
+export declare function createServerSignalQueryAttemptObservations(): ServerSignalQueryAttemptObservations;