@actuallab/rpc 12.1.62 → 12.1.100

package/dist/index.js

@@ -10,7 +10,12 @@ var RpcSystemCalls = {
   error: "$sys.Error:1",
   cancel: "$sys.Cancel:0",
   keepAlive: "$sys.KeepAlive:1",
-  reconnect: "$sys.Reconnect:3"
+  reconnect: "$sys.Reconnect:3",
+  ack: "$sys.Ack:2",
+  ackEnd: "$sys.AckEnd:1",
+  item: "$sys.I:2",
+  batch: "$sys.B:2",
+  end: "$sys.End:2"
 };
 var ENVELOPE_DELIMITER = "\n";
 var ARG_DELIMITER = "";
@@ -170,18 +175,18 @@ function createMessageChannelPair() {
 var RpcType = {
   object: /* @__PURE__ */ Symbol("object"),
   stream: /* @__PURE__ */ Symbol("stream"),
+  noWait: /* @__PURE__ */ Symbol("noWait"),
   void: /* @__PURE__ */ Symbol("void")
 };
 function wireMethodName(def) {
   return `${def.serviceName}.${def.name}:${def.wireArgCount}`;
 }
-function defineRpcService(name, methods, options) {
-  const ctOffset = options?.ctOffset ?? 0;
+function defineRpcService(name, methods) {
   const map = /* @__PURE__ */ new Map();
   for (const [key, input] of Object.entries(methods)) {
     const colonIndex = key.indexOf(":");
     const cleanName = colonIndex >= 0 ? key.substring(0, colonIndex) : key;
-    const wireArgCount = input.args.length + ctOffset;
+    const wireArgCount = input.wireArgCount ?? input.args.length + 1;
     const mapKey = `${cleanName}:${wireArgCount}`;
     map.set(mapKey, {
       name: cleanName,
@@ -189,8 +194,8 @@ function defineRpcService(name, methods, options) {
       argCount: input.args.length,
       wireArgCount,
       callTypeId: input.callTypeId ?? 0,
-      stream: input.stream ?? input.returns === RpcType.stream,
-      noWait: input.noWait ?? false
+      stream: input.returns === RpcType.stream,
+      noWait: input.returns === RpcType.noWait
     });
   }
   return { name, methods: map };
@@ -295,40 +300,270 @@ var RpcInboundCallTracker = class {
   }
 };
 
-// src/rpc-system-call-handler.ts
-function handleSystemCall(message, args, outboundTracker, inboundTracker) {
-  const method = message.Method;
-  const relatedId = message.RelatedId ?? 0;
-  switch (method) {
-    case RpcSystemCalls.ok: {
-      const call = outboundTracker.get(relatedId);
-      if (call !== void 0) {
-        if (call.removeOnOk) {
-          outboundTracker.remove(relatedId);
+// src/rpc-stream.ts
+import { PromiseSource as PromiseSource3 } from "@actuallab/core";
+
+// src/rpc-object.ts
+var RpcObjectKind = { Local: 0, Remote: 1 };
+
+// src/rpc-stream.ts
+function parseStreamRef(value) {
+  if (typeof value !== "string") return null;
+  const parts = value.split(",");
+  if (parts.length < 4 || parts.length > 5) return null;
+  const hostId = parts[0];
+  const localId = parseInt(parts[1], 10);
+  const ackPeriod = parseInt(parts[2], 10);
+  const ackAdvance = parseInt(parts[3], 10);
+  if (isNaN(localId) || isNaN(ackPeriod) || isNaN(ackAdvance)) return null;
+  const allowReconnect = parts.length < 5 || parts[4] !== "0";
+  return { hostId, localId, ackPeriod, ackAdvance, allowReconnect };
+}
+var RpcStream = class {
+  id;
+  kind = RpcObjectKind.Remote;
+  allowReconnect;
+  peer;
+  ackPeriod;
+  ackAdvance;
+  _buffer = [];
+  _nextExpectedIndex = 0;
+  _consumerWaiting = null;
+  _completed = false;
+  _completionError = null;
+  _disposed = false;
+  _started = false;
+  _iterating = false;
+  _ackSentUpTo = 0;
+  constructor(ref, peer) {
+    this.id = { hostId: ref.hostId, localId: ref.localId };
+    this.allowReconnect = ref.allowReconnect;
+    this.peer = peer;
+    this.ackPeriod = ref.ackPeriod;
+    this.ackAdvance = ref.ackAdvance;
+  }
+  /** Called by system call handler when a single item arrives ($sys.I). */
+  onItem(index, item) {
+    if (this._disposed || this._completed) return;
+    if (index > this._nextExpectedIndex) {
+      this._sendAck(this._nextExpectedIndex, true);
+      return;
+    }
+    if (index < this._nextExpectedIndex) {
+      this._maybeSendAck(index + 1);
+      return;
+    }
+    this._buffer.push(item);
+    this._nextExpectedIndex = index + 1;
+    this._maybeSendAck(this._nextExpectedIndex);
+    this._notifyConsumer();
+  }
+  /** Called by system call handler when a batch arrives ($sys.B). */
+  onBatch(index, items) {
+    if (this._disposed || this._completed) return;
+    if (index > this._nextExpectedIndex) {
+      this._sendAck(this._nextExpectedIndex, true);
+      return;
+    }
+    if (index < this._nextExpectedIndex) {
+      this._maybeSendAck(index + items.length);
+      return;
+    }
+    for (const item of items) this._buffer.push(item);
+    this._nextExpectedIndex = index + items.length;
+    this._maybeSendAck(this._nextExpectedIndex);
+    this._notifyConsumer();
+  }
+  /** Called by system call handler when the stream ends ($sys.End). */
+  onEnd(index, error) {
+    if (this._disposed || this._completed) return;
+    this._completed = true;
+    this._completionError = error;
+    this._notifyConsumer();
+  }
+  // -- IRpcObject --
+  reconnect() {
+    if (this.allowReconnect) {
+      this._sendAck(this._nextExpectedIndex, true);
+    } else {
+      this.disconnect();
+    }
+  }
+  disconnect() {
+    if (this._completed) return;
+    this._completed = true;
+    this._completionError = new Error("Peer disconnected.");
+    this._notifyConsumer();
+  }
+  // -- AsyncIterable --
+  [Symbol.asyncIterator]() {
+    if (this._iterating) throw new Error("RpcStream can only be iterated once.");
+    this._iterating = true;
+    let bufferIndex = 0;
+    let consumedIndex = 0;
+    const self = this;
+    return {
+      async next() {
+        if (!self._started) {
+          self._started = true;
+          self._sendAck(0, true);
+        }
+        while (true) {
+          if (bufferIndex < self._buffer.length) {
+            const value = self._buffer[bufferIndex];
+            bufferIndex++;
+            consumedIndex++;
+            return { value, done: false };
+          }
+          if (self._completed) {
+            if (self._completionError) throw self._completionError;
+            return { value: void 0, done: true };
+          }
+          self._consumerWaiting = new PromiseSource3();
+          await self._consumerWaiting.promise;
         }
-        call.result.resolve(args[0]);
+      },
+      async return() {
+        self._sendAckEnd();
+        self.dispose();
+        return { value: void 0, done: true };
       }
-      break;
+    };
+  }
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._completed = true;
+    this.peer.remoteObjects.unregister(this);
+    this._notifyConsumer();
+  }
+  // -- Private --
+  _notifyConsumer() {
+    if (this._consumerWaiting !== null) {
+      this._consumerWaiting.resolve();
+      this._consumerWaiting = null;
     }
-    case RpcSystemCalls.error: {
-      const call = outboundTracker.remove(relatedId);
-      if (call !== void 0) {
-        const errorInfo = args[0];
-        const msg = errorInfo?.Message ?? errorInfo?.message ?? "RPC error";
-        call.result.reject(new Error(msg));
-      }
-      break;
+  }
+  _maybeSendAck(nextIndex) {
+    if (this.ackPeriod <= 0) return;
+    const threshold = this._ackSentUpTo + this.ackPeriod;
+    if (nextIndex >= threshold) {
+      this._sendAck(nextIndex, false);
+    }
+  }
+  _sendAck(nextIndex, _mustReset) {
+    this._ackSentUpTo = nextIndex;
+    const conn = this.peer.connection;
+    if (conn) {
+      this.peer.hub.systemCallSender.ack(conn, this.id.localId, nextIndex, this.id.hostId);
+    }
+  }
+  _sendAckEnd() {
+    const conn = this.peer.connection;
+    if (conn) {
+      this.peer.hub.systemCallSender.ackEnd(conn, this.id.localId, this.id.hostId);
+    }
+  }
+};
+function resolveStreamRefs(value, peer) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") {
+    const ref = parseStreamRef(value);
+    if (ref !== null) {
+      const stream = new RpcStream(ref, peer);
+      peer.remoteObjects.register(stream);
+      return stream;
     }
-    case RpcSystemCalls.cancel: {
-      inboundTracker.remove(relatedId);
-      break;
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = resolveStreamRefs(value[i], peer);
     }
-    case RpcSystemCalls.keepAlive: {
-      break;
+    return value;
+  }
+  if (typeof value === "object") {
+    for (const key of Object.keys(value)) {
+      value[key] = resolveStreamRefs(
+        value[key],
+        peer
+      );
     }
+    return value;
   }
+  return value;
 }
 
+// src/rpc-system-call-handler.ts
+var RpcSystemCallHandler = class {
+  handle(message, args, peer) {
+    const method = message.Method;
+    const relatedId = message.RelatedId ?? 0;
+    switch (method) {
+      case RpcSystemCalls.ok: {
+        const call = peer.outbound.get(relatedId);
+        if (call !== void 0) {
+          if (call.removeOnOk) {
+            peer.outbound.remove(relatedId);
+          }
+          call.result.resolve(args[0]);
+        }
+        break;
+      }
+      case RpcSystemCalls.error: {
+        const call = peer.outbound.remove(relatedId);
+        if (call !== void 0) {
+          const errorInfo = args[0];
+          const msg = errorInfo?.Message ?? errorInfo?.message ?? "RPC error";
+          call.result.reject(new Error(msg));
+        }
+        break;
+      }
+      case RpcSystemCalls.cancel: {
+        peer.inbound.remove(relatedId);
+        break;
+      }
+      case RpcSystemCalls.keepAlive: {
+        break;
+      }
+      case RpcSystemCalls.item: {
+        const stream = peer.remoteObjects.get(relatedId);
+        if (stream) stream.onItem(args[0], resolveStreamRefs(args[1], peer));
+        break;
+      }
+      case RpcSystemCalls.batch: {
+        const stream = peer.remoteObjects.get(relatedId);
+        if (stream) {
+          const items = args[1];
+          for (let i = 0; i < items.length; i++) items[i] = resolveStreamRefs(items[i], peer);
+          stream.onBatch(args[0], items);
+        }
+        break;
+      }
+      case RpcSystemCalls.end: {
+        const stream = peer.remoteObjects.get(relatedId);
+        if (stream) {
+          const errorInfo = args[1];
+          const msg = errorInfo?.Message ?? errorInfo?.message;
+          const error = msg ? new Error(msg) : null;
+          stream.onEnd(args[0], error);
+        }
+        break;
+      }
+      case RpcSystemCalls.ack: {
+        const sender = peer.sharedObjects.get(relatedId);
+        sender?.onAck(args[0], args[1]);
+        break;
+      }
+      case RpcSystemCalls.ackEnd: {
+        const sender = peer.sharedObjects.get(relatedId);
+        sender?.onAckEnd(args[0]);
+        break;
+      }
+    }
+  }
+};
+
 // src/rpc-system-call-sender.ts
 var RpcSystemCallSender = class {
   handshake(conn, peerId, hubId, index) {
@@ -361,10 +596,191 @@ var RpcSystemCallSender = class {
     const msg = serializeMessage({ Method: RpcSystemCalls.keepAlive }, [activeCallIds]);
     conn.send(msg);
   }
+  item(conn, localId, index, item) {
+    const msg = serializeMessage(
+      { Method: RpcSystemCalls.item, RelatedId: localId },
+      [index, item]
+    );
+    conn.send(msg);
+  }
+  batch(conn, localId, index, items) {
+    const msg = serializeMessage(
+      { Method: RpcSystemCalls.batch, RelatedId: localId },
+      [index, items]
+    );
+    conn.send(msg);
+  }
+  end(conn, localId, index, error = null) {
+    const msg = serializeMessage(
+      { Method: RpcSystemCalls.end, RelatedId: localId },
+      [index, error]
+    );
+    conn.send(msg);
+  }
+  ack(conn, localId, nextIndex, hostId) {
+    const msg = serializeMessage(
+      { Method: RpcSystemCalls.ack, RelatedId: localId },
+      [nextIndex, hostId]
+    );
+    conn.send(msg);
+  }
+  ackEnd(conn, localId, hostId) {
+    const msg = serializeMessage(
+      { Method: RpcSystemCalls.ackEnd, RelatedId: localId },
+      [hostId]
+    );
+    conn.send(msg);
+  }
+};
+
+// src/rpc-stream-sender.ts
+import { PromiseSource as PromiseSource4 } from "@actuallab/core";
+var DEFAULT_ACK_PERIOD = 256;
+var DEFAULT_ACK_ADVANCE = 128;
+var RpcStreamSender = class {
+  id;
+  kind = RpcObjectKind.Local;
+  allowReconnect;
+  peer;
+  ackPeriod;
+  ackAdvance;
+  _nextIndex = 0;
+  _ended = false;
+  _started = new PromiseSource4();
+  constructor(peer, ackPeriod = DEFAULT_ACK_PERIOD, ackAdvance = DEFAULT_ACK_ADVANCE, allowReconnect = true) {
+    const localId = peer.sharedObjects.nextId();
+    this.id = { hostId: peer.hub.hubId, localId };
+    this.allowReconnect = allowReconnect;
+    this.peer = peer;
+    this.ackPeriod = ackPeriod;
+    this.ackAdvance = ackAdvance;
+  }
+  /** Returns the stream reference string for the $sys.Ok response. */
+  toRef() {
+    return `${this.id.hostId},${this.id.localId},${this.ackPeriod},${this.ackAdvance},${this.allowReconnect ? "1" : "0"}`;
+  }
+  /** Called by system call handler when $sys.Ack is received from the client. */
+  onAck(_nextIndex, _hostId) {
+    if (!this._started.isCompleted) {
+      this._started.resolve();
+    }
+  }
+  /** Called by system call handler when $sys.AckEnd is received from the client. */
+  onAckEnd(_hostId) {
+    this._ended = true;
+    this.peer.sharedObjects.unregister(this);
+  }
+  /** Send a single item to the client. */
+  sendItem(item) {
+    if (this._ended) return;
+    const conn = this.peer.connection;
+    if (!conn) return;
+    this.peer.hub.systemCallSender.item(conn, this.id.localId, this._nextIndex, item);
+    this._nextIndex++;
+  }
+  /** Send a batch of items to the client. */
+  sendBatch(items) {
+    if (this._ended || items.length === 0) return;
+    const conn = this.peer.connection;
+    if (!conn) return;
+    this.peer.hub.systemCallSender.batch(conn, this.id.localId, this._nextIndex, items);
+    this._nextIndex += items.length;
+  }
+  /** Signal stream completion to the client. */
+  sendEnd(error) {
+    if (this._ended) return;
+    this._ended = true;
+    const conn = this.peer.connection;
+    if (!conn) return;
+    const errorInfo = error ? { Message: error.message } : null;
+    this.peer.hub.systemCallSender.end(conn, this.id.localId, this._nextIndex, errorInfo);
+  }
+  /**
+   * Consume an AsyncIterable and send all items to the client.
+   * Waits for the client's initial Ack before starting to pump items.
+   */
+  async writeFrom(source) {
+    await this._started.promise;
+    try {
+      for await (const item of source) {
+        if (this._ended) return;
+        this.sendItem(item);
+      }
+      if (!this._ended) {
+        this.sendEnd();
+      }
+    } catch (e) {
+      if (!this._ended) {
+        this.sendEnd(e instanceof Error ? e : new Error(String(e)));
+      }
+    }
+  }
+  // -- IRpcObject --
+  reconnect() {
+  }
+  disconnect() {
+    this._ended = true;
+    if (!this._started.isCompleted) {
+      this._started.resolve();
+    }
+    this.peer.sharedObjects.unregister(this);
+  }
+};
+
+// src/rpc-remote-object-tracker.ts
+var RpcRemoteObjectTracker = class {
+  _objects = /* @__PURE__ */ new Map();
+  register(obj) {
+    this._objects.set(obj.id.localId, obj);
+  }
+  get(localId) {
+    return this._objects.get(localId);
+  }
+  unregister(obj) {
+    this._objects.delete(obj.id.localId);
+  }
+  disconnectAll() {
+    for (const obj of this._objects.values()) {
+      obj.disconnect();
+    }
+    this._objects.clear();
+  }
+  reconnectAll() {
+    for (const obj of this._objects.values()) {
+      if (obj.allowReconnect)
+        obj.reconnect();
+      else
+        obj.disconnect();
+    }
+  }
+};
+
+// src/rpc-shared-object-tracker.ts
+var RpcSharedObjectTracker = class {
+  _nextId = 1;
+  _objects = /* @__PURE__ */ new Map();
+  nextId() {
+    return this._nextId++;
+  }
+  register(obj) {
+    this._objects.set(obj.id.localId, obj);
+  }
+  get(localId) {
+    return this._objects.get(localId);
+  }
+  unregister(obj) {
+    this._objects.delete(obj.id.localId);
+  }
+  disconnectAll() {
+    for (const obj of this._objects.values()) {
+      obj.disconnect();
+    }
+    this._objects.clear();
+  }
 };
 
 // src/rpc-peer.ts
-import { EventHandlerSet as EventHandlerSet3, PromiseSource as PromiseSource3 } from "@actuallab/core";
+import { EventHandlerSet as EventHandlerSet3, PromiseSource as PromiseSource5 } from "@actuallab/core";
 
 // src/rpc-client-peer-reconnect-delayer.ts
 import { RetryDelaySeq, RetryDelayer } from "@actuallab/core";
@@ -390,6 +806,8 @@ var RpcPeer = class {
   _connection;
   outbound = new RpcOutboundCallTracker();
   inbound = new RpcInboundCallTracker();
+  remoteObjects = new RpcRemoteObjectTracker();
+  sharedObjects = new RpcSharedObjectTracker();
   connected = new EventHandlerSet3();
   disconnected = new EventHandlerSet3();
   _pendingSends = [];
@@ -398,6 +816,9 @@ var RpcPeer = class {
     this.ref = ref;
     this._hub = hub;
   }
+  get hub() {
+    return this._hub;
+  }
   get connection() {
     return this._connection;
   }
@@ -463,6 +884,8 @@ var RpcPeer = class {
   }
   close() {
     this._stopKeepAlive();
+    this.remoteObjects.disconnectAll();
+    this.sharedObjects.disconnectAll();
     for (const call of this._pendingSends) {
       if (!call.result.isCompleted)
         call.result.reject(new Error("Peer closed."));
@@ -496,7 +919,7 @@ var RpcPeer = class {
       return;
     }
     if (method.startsWith("$sys")) {
-      this._hub.handleSystemCall(message, args, this.outbound, this.inbound);
+      this._hub.systemCallHandler.handle(message, args, this);
       return;
     }
     this._handleInbound(message, args);
@@ -516,7 +939,12 @@ var RpcPeer = class {
         try {
           const context = this._connection !== void 0 ? { __rpcDispatch: true, callId: relatedId, connection: this._connection } : void 0;
           const result = await serviceHost.dispatch(method, args, context);
-          if (!isNoWait && this._connection !== void 0) {
+          if (methodDef?.stream === true && this._connection !== void 0) {
+            const sender = new RpcStreamSender(this);
+            this.sharedObjects.register(sender);
+            this._hub.systemCallSender.ok(this._connection, relatedId, sender.toRef());
+            void sender.writeFrom(result);
+          } else if (!isNoWait && this._connection !== void 0) {
             this._hub.systemCallSender.ok(this._connection, relatedId, result);
           }
         } catch (e) {
@@ -601,7 +1029,7 @@ var RpcClientPeer = class extends RpcPeer {
         const ws = wsFactory?.(connUrl) ?? new WebSocket(connUrl);
         const conn = new RpcWebSocketConnection(ws);
         this._connectionKind = 1 /* Connecting */;
-        this._pendingHandshake = new PromiseSource3();
+        this._pendingHandshake = new PromiseSource5();
         this.setupConnection(conn);
         this._connection = void 0;
         const closedRejection = new Promise((_, reject) => conn.closed.add(() => reject(new Error("Connection failed"))));
@@ -657,6 +1085,11 @@ var RpcClientPeer = class extends RpcPeer {
   _reconnect(_isPeerChanged) {
     if (this._connection === void 0) return;
     const conn = this._connection;
+    if (_isPeerChanged) {
+      this.remoteObjects.disconnectAll();
+    } else {
+      this.remoteObjects.reconnectAll();
+    }
     const trackerCalls = [...this.outbound.values()];
     for (const call of trackerCalls) {
       if (!call.removeOnOk && call.result.isCompleted) {
@@ -739,12 +1172,10 @@ function getMethodsMeta(cls) {
 function getServiceMeta(cls) {
   return cls[Symbol.metadata]?.[SERVICE_META];
 }
-function rpcService(serviceName, options) {
+function rpcService(serviceName) {
   return function(_target, context) {
     const meta = context.metadata[SERVICE_META] ??= {};
     meta.name = serviceName;
-    if (options?.ctOffset !== void 0)
-      meta.ctOffset = options.ctOffset;
   };
 }
 function rpcMethod(options) {
@@ -754,8 +1185,7 @@ function rpcMethod(options) {
     methods[methodName] = {
       ...methods[methodName],
       argCount: target.length,
-      stream: options?.stream ?? false,
-      noWait: options?.noWait ?? false
+      returns: options?.returns
     };
     return target;
   };
@@ -767,6 +1197,7 @@ var RpcHub = class {
   peers = /* @__PURE__ */ new Map();
   serviceHost;
   systemCallSender = new RpcSystemCallSender();
+  systemCallHandler = new RpcSystemCallHandler();
   constructor(hubId) {
     this.hubId = hubId ?? crypto.randomUUID();
     this.serviceHost = new RpcServiceHost();
@@ -840,19 +1271,14 @@ var RpcHub = class {
     for (const peer of this.peers.values()) peer.close();
     this.peers.clear();
   }
-  /** Dispatch an inbound system call. Override in FusionHub to handle compute-specific system calls. */
-  handleSystemCall(message, args, outbound, inbound) {
-    handleSystemCall(message, args, outbound, inbound);
-  }
   /** Build an RpcServiceDef from decorator metadata on a contract class. Override in FusionHub for compute support. */
   _buildServiceDef(cls) {
     const svcMeta = getServiceMeta(cls);
     if (svcMeta === void 0) throw new Error("Contract class missing @rpcService metadata");
     const methodsMeta = getMethodsMeta(cls) ?? {};
-    const ctOffset = svcMeta.ctOffset ?? 0;
     const methods = /* @__PURE__ */ new Map();
     for (const [name, meta] of Object.entries(methodsMeta)) {
-      const wireArgCount = meta.argCount + ctOffset;
+      const wireArgCount = meta.argCount + 1;
       const mapKey = `${name}:${wireArgCount}`;
       methods.set(mapKey, {
         name,
@@ -860,8 +1286,8 @@ var RpcHub = class {
         argCount: meta.argCount,
         wireArgCount,
         callTypeId: 0,
-        stream: meta.stream ?? false,
-        noWait: meta.noWait ?? false
+        stream: meta.returns === RpcType.stream,
+        noWait: meta.returns === RpcType.noWait
       });
     }
     return { name: svcMeta.name, methods };
@@ -885,11 +1311,24 @@ var RpcHub = class {
         peer.callNoWait(wireName, callArgs);
       };
     }
+    if (methodDef.stream) {
+      return async (...args) => {
+        const callArgs = args.slice(0, methodDef.argCount);
+        const outboundCall = peer.call(wireName, callArgs);
+        const result = await outboundCall.result.promise;
+        const ref = parseStreamRef(result);
+        if (!ref) throw new Error(`Expected stream reference, got: ${JSON.stringify(result)}`);
+        const stream = new RpcStream(ref, peer);
+        peer.remoteObjects.register(stream);
+        return stream;
+      };
+    }
     const callOptions = methodDef.callTypeId !== 0 ? { callTypeId: methodDef.callTypeId } : void 0;
     return async (...args) => {
       const callArgs = args.slice(0, methodDef.argCount);
       const outboundCall = peer.call(wireName, callArgs, callOptions);
-      return outboundCall.result.promise;
+      const result = await outboundCall.result.promise;
+      return resolveStreamRefs(result, peer);
     };
   }
 };
@@ -1099,14 +1538,20 @@ export {
   RpcInboundCall,
   RpcInboundCallTracker,
   RpcMessageChannelConnection,
+  RpcObjectKind,
   RpcOutboundCall,
   RpcOutboundCallTracker,
   RpcPeer,
   RpcPeerConnectionKind,
   RpcPeerStateKind,
   RpcPeerStateMonitor,
+  RpcRemoteObjectTracker,
   RpcServerPeer,
   RpcServiceHost,
+  RpcSharedObjectTracker,
+  RpcStream,
+  RpcStreamSender,
+  RpcSystemCallHandler,
   RpcSystemCallSender,
   RpcSystemCalls,
   RpcType,
@@ -1120,9 +1565,10 @@ export {
   getMethodsMeta,
   getServiceMeta,
   getStateDescription,
-  handleSystemCall,
   isConnected,
   likelyConnected,
+  parseStreamRef,
+  resolveStreamRefs,
   rpcMethod,
   rpcService,
   serializeFrame,