@adminide-stack/extension-api 11.0.1-alpha.7 → 11.0.1-alpha.9

package/lib/protocol/rpc-protocol.js

@@ -1,750 +1,762 @@
 import {RunOnceScheduler}from'@vscode-alt/monaco-editor/esm/vs/base/common/async.js';import {CancellationTokenSource,CancellationToken}from'@vscode-alt/monaco-editor/esm/vs/base/common/cancellation.js';import*as errors from'@vscode-alt/monaco-editor/esm/vs/base/common/errors.js';import {Emitter}from'@vscode-alt/monaco-editor/esm/vs/base/common/event.js';import {Disposable}from'@vscode-alt/monaco-editor/esm/vs/base/common/lifecycle.js';import {transformIncomingURIs}from'@vscode-alt/monaco-editor/esm/vs/base/common/uriIpc.js';import {LazyPromise}from'./utils/lazy-promise.js';import {ProxyIdentifier,getStringIdentifierForProxy}from'./proxy-identifier.js';import {VSBuffer}from'@vscode-alt/monaco-editor/esm/vs/base/common/buffer.js';/* tslint:disable */
 function safeStringify(obj, replacer) {
-    try {
-        return JSON.stringify(obj, replacer);
-    }
-    catch (err) {
-        return 'null';
-    }
+  try {
+    return JSON.stringify(obj, replacer);
+  } catch (err) {
+    return 'null';
+  }
 }
 function createURIReplacer(transformer) {
-    if (!transformer) {
-        return null;
-    }
-    return (key, value) => {
-        if (value && value.$mid === 1) {
-            return transformer.transformOutgoing(value);
-        }
-        return value;
-    };
+  if (!transformer) {
+    return null;
+  }
+  return (key, value) => {
+    if (value && value.$mid === 1) {
+      return transformer.transformOutgoing(value);
+    }
+    return value;
+  };
 }
 var RequestInitiator;
 (function (RequestInitiator) {
-    RequestInitiator[RequestInitiator["LocalSide"] = 0] = "LocalSide";
-    RequestInitiator[RequestInitiator["OtherSide"] = 1] = "OtherSide";
+  RequestInitiator[RequestInitiator["LocalSide"] = 0] = "LocalSide";
+  RequestInitiator[RequestInitiator["OtherSide"] = 1] = "OtherSide";
 })(RequestInitiator || (RequestInitiator = {}));
 var ResponsiveState;
 (function (ResponsiveState) {
-    ResponsiveState[ResponsiveState["Responsive"] = 0] = "Responsive";
-    ResponsiveState[ResponsiveState["Unresponsive"] = 1] = "Unresponsive";
+  ResponsiveState[ResponsiveState["Responsive"] = 0] = "Responsive";
+  ResponsiveState[ResponsiveState["Unresponsive"] = 1] = "Unresponsive";
 })(ResponsiveState || (ResponsiveState = {}));
-const noop = () => { };
+const noop = () => {};
 class RPCProtocol extends Disposable {
-    static UNRESPONSIVE_TIME = 3 * 1000; // 3s
-    _onDidChangeResponsiveState = this._register(new Emitter());
-    onDidChangeResponsiveState = this._onDidChangeResponsiveState.event;
-    _protocol;
-    _logger;
-    _uriTransformer;
-    _uriReplacer;
-    _isDisposed;
-    _locals;
-    _proxies;
-    _lastMessageId;
-    _cancelInvokedHandlers;
-    _pendingRPCReplies;
-    _responsiveState;
-    _unacknowledgedCount;
-    _unresponsiveTime;
-    _asyncCheckUresponsive;
-    localHostId;
-    constructor(protocol, _localHostId = null, logger = null, transformer = null) {
-        super();
-        this.localHostId = _localHostId;
-        this._protocol = protocol;
-        this._logger = logger;
-        this._uriTransformer = transformer;
-        this._uriReplacer = createURIReplacer(this._uriTransformer);
-        this._isDisposed = false;
-        this._locals = [];
-        this._proxies = [];
-        for (let i = 0, len = ProxyIdentifier.count; i < len; i++) {
-            this._locals[i] = null;
-            this._proxies[i] = null;
-        }
-        this._lastMessageId = 0;
-        this._cancelInvokedHandlers = Object.create(null);
-        this._pendingRPCReplies = {};
-        this._responsiveState = 0 /* ResponsiveState.Responsive */;
-        this._unacknowledgedCount = 0;
-        this._unresponsiveTime = 0;
-        this._asyncCheckUresponsive = this._register(new RunOnceScheduler(() => this._checkUnresponsive(), 1000));
-        this._protocol.onMessage((msg) => this._receiveOneMessage(msg));
-    }
-    dispose() {
-        this._isDisposed = true;
-        // Release all outstanding promises with a canceled error
-        Object.keys(this._pendingRPCReplies).forEach((msgId) => {
-            const pending = this._pendingRPCReplies[msgId];
-            pending.resolveErr(errors.canceled());
-        });
-    }
-    _onWillSendRequest(req) {
-        if (this._unacknowledgedCount === 0) {
-            // Since this is the first request we are sending in a while,
-            // mark this moment as the start for the countdown to unresponsive time
-            this._unresponsiveTime = Date.now() + RPCProtocol.UNRESPONSIVE_TIME;
-        }
-        this._unacknowledgedCount++;
-        if (!this._asyncCheckUresponsive.isScheduled()) {
-            this._asyncCheckUresponsive.schedule();
-        }
-    }
-    _onDidReceiveAcknowledge(req) {
-        // The next possible unresponsive time is now + delta.
-        this._unresponsiveTime = Date.now() + RPCProtocol.UNRESPONSIVE_TIME;
-        this._unacknowledgedCount--;
-        if (this._unacknowledgedCount === 0) {
-            // No more need to check for unresponsive
-            this._asyncCheckUresponsive.cancel();
-        }
-        // The ext host is responsive!
-        this._setResponsiveState(0 /* ResponsiveState.Responsive */);
-    }
-    _checkUnresponsive() {
-        if (this._unacknowledgedCount === 0) {
-            // Not waiting for anything => cannot say if it is responsive or not
-            return;
-        }
-        if (Date.now() > this._unresponsiveTime) {
-            // Unresponsive!!
-            this._setResponsiveState(1 /* ResponsiveState.Unresponsive */);
-        }
-        else {
-            // Not (yet) unresponsive, be sure to check again soon
-            this._asyncCheckUresponsive.schedule();
-        }
-    }
-    _setResponsiveState(newResponsiveState) {
-        if (this._responsiveState === newResponsiveState) {
-            // no change
-            return;
-        }
-        this._responsiveState = newResponsiveState;
-        this._onDidChangeResponsiveState.fire(this._responsiveState);
-    }
-    get responsiveState() {
-        return this._responsiveState;
-    }
-    transformIncomingURIs(obj) {
-        if (!this._uriTransformer) {
-            return obj;
-        }
-        return transformIncomingURIs(obj, this._uriTransformer);
-    }
-    getProxy(identifier) {
-        const rpcId = identifier.nid;
-        if (!this._proxies[rpcId]) {
-            this._proxies[rpcId] = this._createProxy(rpcId, identifier.hostId);
-        }
-        return this._proxies[rpcId];
-    }
-    _createProxy(rpcId, destId) {
-        let handler = {
-            get: (target, name) => {
-                // @sri due to some issue we need to do this way
-                // if (!target[name] && name.charCodeAt(0) === CharCode.DollarSign) {
-                if (!target[name] && name[0] === '$') {
-                    target[name] = (...myArgs) => {
-                        return this._remoteCall(destId, rpcId, name, myArgs);
-                    };
-                }
-                return target[name];
-            }
-        };
-        return new Proxy(Object.create(null), handler);
-    }
-    set(identifier, value) {
-        this._locals[identifier.nid] = value;
-        return value;
-    }
-    assertRegistered(identifiers) {
-        for (let i = 0, len = identifiers.length; i < len; i++) {
-            const identifier = identifiers[i];
-            if (!this._locals[identifier.nid]) {
-                // @sri to log missing identifier
-                console.log('identifer missing', identifier);
-                throw new Error(`Missing actor ${identifier.sid} (isMain: ${identifier.isMain})`);
-            }
-        }
-    }
-    _receiveOneMessage(rawmsg) {
-        if (this._isDisposed) {
-            return;
-        }
-        let senderHost = null;
-        let destHostId = null;
-        let leadNum = 0;
-        if (this.localHostId !== null) {
-            destHostId = rawmsg.readUInt8(0);
-            if (destHostId !== this.localHostId) {
-                return this._protocol.forward(rawmsg, destHostId);
-            }
-            leadNum = 2;
-            senderHost = rawmsg.readUInt8(1);
-        }
-        const msgLength = rawmsg.byteLength - leadNum;
-        const buff = MessageBuffer.read(rawmsg, leadNum);
-        const messageType = buff.readUInt8();
-        const req = buff.readUInt32();
-        switch (messageType) {
-            case 1 /* MessageType.RequestJSONArgs */:
-            case 2 /* MessageType.RequestJSONArgsWithCancellation */: {
-                let { rpcId, method, args } = MessageIO.deserializeRequestJSONArgs(buff);
-                if (this._uriTransformer) {
-                    args = transformIncomingURIs(args, this._uriTransformer);
-                }
-                // @sri add senderHost for identification
-                this._receiveRequest(senderHost, msgLength, req, rpcId, method, args, (messageType === 2 /* MessageType.RequestJSONArgsWithCancellation */));
-                break;
-            }
-            case 3 /* MessageType.RequestMixedArgs */:
-            case 4 /* MessageType.RequestMixedArgsWithCancellation */: {
-                let { rpcId, method, args } = MessageIO.deserializeRequestMixedArgs(buff);
-                if (this._uriTransformer) {
-                    args = transformIncomingURIs(args, this._uriTransformer);
-                }
-                // @sri add senderHost as identifier
-                this._receiveRequest(senderHost, msgLength, req, rpcId, method, args, (messageType === 4 /* MessageType.RequestMixedArgsWithCancellation */));
-                break;
-            }
-            case 5 /* MessageType.Acknowledged */: {
-                if (this._logger) {
-                    this._logger.logIncoming(msgLength, req, 0 /* RequestInitiator.LocalSide */, `ack`);
-                }
-                this._onDidReceiveAcknowledge(req);
-                break;
-            }
-            case 6 /* MessageType.Cancel */: {
-                this._receiveCancel(msgLength, req);
-                break;
-            }
-            case 7 /* MessageType.ReplyOKEmpty */: {
-                this._receiveReply(msgLength, req, undefined);
-                break;
-            }
-            case 9 /* MessageType.ReplyOKJSON */: {
-                let value = MessageIO.deserializeReplyOKJSON(buff);
-                if (this._uriTransformer) {
-                    value = transformIncomingURIs(value, this._uriTransformer);
-                }
-                this._receiveReply(msgLength, req, value);
-                break;
-            }
-            case 10 /* MessageType.ReplyOKJSONWithBuffers */: {
-                let value = MessageIO.deserializeReplyOKBuffer(buff);
-                this._receiveReply(msgLength, req, value);
-                break;
-            }
-            case 8 /* MessageType.ReplyOKVSBuffer */: {
-                let value = MessageIO.deserializeReplyOKVSBuffer(buff);
-                this._receiveReply(msgLength, req, value);
-                break;
-            }
-            case 11 /* MessageType.ReplyErrError */: {
-                let err = MessageIO.deserializeReplyErrError(buff);
-                if (this._uriTransformer) {
-                    err = transformIncomingURIs(err, this._uriTransformer);
-                }
-                this._receiveReplyErr(msgLength, req, err);
-                break;
-            }
-            case 12 /* MessageType.ReplyErrEmpty */: {
-                this._receiveReplyErr(msgLength, req, undefined);
-                break;
-            }
-            default:
-                console.error(`received unexpected message`);
-                console.error(rawmsg);
-        }
-    }
-    //@sri added destId for identification
-    _receiveRequest(destId, msgLength, req, rpcId, method, args, usesCancellationToken) {
-        if (this._logger) {
-            this._logger.logIncoming(msgLength, req, 1 /* RequestInitiator.OtherSide */, `receiveRequest ${getStringIdentifierForProxy(rpcId)}.${method}(`, args);
-        }
-        const callId = String(req);
-        let promise;
-        let cancel;
-        if (usesCancellationToken) {
-            const cancellationTokenSource = new CancellationTokenSource();
-            args.push(cancellationTokenSource.token);
-            promise = this._invokeHandler(rpcId, method, args);
-            cancel = () => cancellationTokenSource.cancel();
-        }
-        else {
-            // cannot be cancelled
-            promise = this._invokeHandler(rpcId, method, args);
-            cancel = noop;
-        }
-        this._cancelInvokedHandlers[callId] = cancel;
-        // Acknowledge the request
-        const msg = MessageIO.serializeAcknowledged(req);
-        if (this._logger) {
-            this._logger.logOutgoing(msg.byteLength, req, 1 /* RequestInitiator.OtherSide */, `ack`);
-        }
-        this._protocol.send(msg, destId);
-        promise.then((r) => {
-            delete this._cancelInvokedHandlers[callId];
-            const msg = MessageIO.serializeReplyOK(req, r, this._uriReplacer);
-            if (this._logger) {
-                this._logger.logOutgoing(msg.byteLength, req, 1 /* RequestInitiator.OtherSide */, `reply:`, r);
-            }
-            this._protocol.send(msg, destId);
-        }, (err) => {
-            delete this._cancelInvokedHandlers[callId];
-            const msg = MessageIO.serializeReplyErr(req, err);
-            if (this._logger) {
-                this._logger.logOutgoing(msg.byteLength, req, 1 /* RequestInitiator.OtherSide */, `replyErr:`, err);
-            }
-            this._protocol.send(msg, destId);
-        });
-    }
-    _receiveCancel(msgLength, req) {
-        if (this._logger) {
-            this._logger.logIncoming(msgLength, req, 1 /* RequestInitiator.OtherSide */, `receiveCancel`);
-        }
-        const callId = String(req);
-        if (this._cancelInvokedHandlers[callId]) {
-            this._cancelInvokedHandlers[callId]();
-        }
-    }
-    _receiveReply(msgLength, req, value) {
-        if (this._logger) {
-            this._logger.logIncoming(msgLength, req, 0 /* RequestInitiator.LocalSide */, `receiveReply:`, value);
-        }
-        const callId = String(req);
-        if (!this._pendingRPCReplies.hasOwnProperty(callId)) {
-            return;
-        }
-        const pendingReply = this._pendingRPCReplies[callId];
-        delete this._pendingRPCReplies[callId];
-        pendingReply.resolveOk(value);
-    }
-    _receiveReplyErr(msgLength, req, value) {
+  static UNRESPONSIVE_TIME = 3 * 1000; // 3s
+  _onDidChangeResponsiveState = this._register(new Emitter());
+  onDidChangeResponsiveState = this._onDidChangeResponsiveState.event;
+  _protocol;
+  _logger;
+  _uriTransformer;
+  _uriReplacer;
+  _isDisposed;
+  _locals;
+  _proxies;
+  _lastMessageId;
+  _cancelInvokedHandlers;
+  _pendingRPCReplies;
+  _responsiveState;
+  _unacknowledgedCount;
+  _unresponsiveTime;
+  _asyncCheckUresponsive;
+  localHostId;
+  constructor(protocol, _localHostId = null, logger = null, transformer = null) {
+    super();
+    this.localHostId = _localHostId;
+    this._protocol = protocol;
+    this._logger = logger;
+    this._uriTransformer = transformer;
+    this._uriReplacer = createURIReplacer(this._uriTransformer);
+    this._isDisposed = false;
+    this._locals = [];
+    this._proxies = [];
+    for (let i = 0, len = ProxyIdentifier.count; i < len; i++) {
+      this._locals[i] = null;
+      this._proxies[i] = null;
+    }
+    this._lastMessageId = 0;
+    this._cancelInvokedHandlers = Object.create(null);
+    this._pendingRPCReplies = {};
+    this._responsiveState = 0 /* ResponsiveState.Responsive */;
+    this._unacknowledgedCount = 0;
+    this._unresponsiveTime = 0;
+    this._asyncCheckUresponsive = this._register(new RunOnceScheduler(() => this._checkUnresponsive(), 1000));
+    this._protocol.onMessage(msg => this._receiveOneMessage(msg));
+  }
+  dispose() {
+    this._isDisposed = true;
+    // Release all outstanding promises with a canceled error
+    Object.keys(this._pendingRPCReplies).forEach(msgId => {
+      const pending = this._pendingRPCReplies[msgId];
+      pending.resolveErr(errors.canceled());
+    });
+  }
+  _onWillSendRequest(req) {
+    if (this._unacknowledgedCount === 0) {
+      // Since this is the first request we are sending in a while,
+      // mark this moment as the start for the countdown to unresponsive time
+      this._unresponsiveTime = Date.now() + RPCProtocol.UNRESPONSIVE_TIME;
+    }
+    this._unacknowledgedCount++;
+    if (!this._asyncCheckUresponsive.isScheduled()) {
+      this._asyncCheckUresponsive.schedule();
+    }
+  }
+  _onDidReceiveAcknowledge(req) {
+    // The next possible unresponsive time is now + delta.
+    this._unresponsiveTime = Date.now() + RPCProtocol.UNRESPONSIVE_TIME;
+    this._unacknowledgedCount--;
+    if (this._unacknowledgedCount === 0) {
+      // No more need to check for unresponsive
+      this._asyncCheckUresponsive.cancel();
+    }
+    // The ext host is responsive!
+    this._setResponsiveState(0 /* ResponsiveState.Responsive */);
+  }
+  _checkUnresponsive() {
+    if (this._unacknowledgedCount === 0) {
+      // Not waiting for anything => cannot say if it is responsive or not
+      return;
+    }
+    if (Date.now() > this._unresponsiveTime) {
+      // Unresponsive!!
+      this._setResponsiveState(1 /* ResponsiveState.Unresponsive */);
+    } else {
+      // Not (yet) unresponsive, be sure to check again soon
+      this._asyncCheckUresponsive.schedule();
+    }
+  }
+  _setResponsiveState(newResponsiveState) {
+    if (this._responsiveState === newResponsiveState) {
+      // no change
+      return;
+    }
+    this._responsiveState = newResponsiveState;
+    this._onDidChangeResponsiveState.fire(this._responsiveState);
+  }
+  get responsiveState() {
+    return this._responsiveState;
+  }
+  transformIncomingURIs(obj) {
+    if (!this._uriTransformer) {
+      return obj;
+    }
+    return transformIncomingURIs(obj, this._uriTransformer);
+  }
+  getProxy(identifier) {
+    const rpcId = identifier.nid;
+    if (!this._proxies[rpcId]) {
+      this._proxies[rpcId] = this._createProxy(rpcId, identifier.hostId);
+    }
+    return this._proxies[rpcId];
+  }
+  _createProxy(rpcId, destId) {
+    let handler = {
+      get: (target, name) => {
+        // @sri due to some issue we need to do this way
+        // if (!target[name] && name.charCodeAt(0) === CharCode.DollarSign) {
+        if (!target[name] && name[0] === '$') {
+          target[name] = (...myArgs) => {
+            return this._remoteCall(destId, rpcId, name, myArgs);
+          };
+        }
+        return target[name];
+      }
+    };
+    return new Proxy(Object.create(null), handler);
+  }
+  set(identifier, value) {
+    this._locals[identifier.nid] = value;
+    return value;
+  }
+  assertRegistered(identifiers) {
+    for (let i = 0, len = identifiers.length; i < len; i++) {
+      const identifier = identifiers[i];
+      if (!this._locals[identifier.nid]) {
+        // @sri to log missing identifier
+        console.log('identifer missing', identifier);
+        throw new Error(`Missing actor ${identifier.sid} (isMain: ${identifier.isMain})`);
+      }
+    }
+  }
+  _receiveOneMessage(rawmsg) {
+    if (this._isDisposed) {
+      return;
+    }
+    let senderHost = null;
+    let destHostId = null;
+    let leadNum = 0;
+    if (this.localHostId !== null) {
+      destHostId = rawmsg.readUInt8(0);
+      if (destHostId !== this.localHostId) {
+        return this._protocol.forward(rawmsg, destHostId);
+      }
+      leadNum = 2;
+      senderHost = rawmsg.readUInt8(1);
+    }
+    const msgLength = rawmsg.byteLength - leadNum;
+    const buff = MessageBuffer.read(rawmsg, leadNum);
+    const messageType = buff.readUInt8();
+    const req = buff.readUInt32();
+    switch (messageType) {
+      case 1 /* MessageType.RequestJSONArgs */:
+      case 2 /* MessageType.RequestJSONArgsWithCancellation */:
+        {
+          let {
+            rpcId,
+            method,
+            args
+          } = MessageIO.deserializeRequestJSONArgs(buff);
+          if (this._uriTransformer) {
+            args = transformIncomingURIs(args, this._uriTransformer);
+          }
+          // @sri add senderHost for identification
+          this._receiveRequest(senderHost, msgLength, req, rpcId, method, args, messageType === 2 /* MessageType.RequestJSONArgsWithCancellation */);
+          break;
+        }
+      case 3 /* MessageType.RequestMixedArgs */:
+      case 4 /* MessageType.RequestMixedArgsWithCancellation */:
+        {
+          let {
+            rpcId,
+            method,
+            args
+          } = MessageIO.deserializeRequestMixedArgs(buff);
+          if (this._uriTransformer) {
+            args = transformIncomingURIs(args, this._uriTransformer);
+          }
+          // @sri add senderHost as identifier
+          this._receiveRequest(senderHost, msgLength, req, rpcId, method, args, messageType === 4 /* MessageType.RequestMixedArgsWithCancellation */);
+          break;
+        }
+      case 5 /* MessageType.Acknowledged */:
+        {
+          if (this._logger) {
+            this._logger.logIncoming(msgLength, req, 0 /* RequestInitiator.LocalSide */, `ack`);
+          }
+          this._onDidReceiveAcknowledge(req);
+          break;
+        }
+      case 6 /* MessageType.Cancel */:
+        {
+          this._receiveCancel(msgLength, req);
+          break;
+        }
+      case 7 /* MessageType.ReplyOKEmpty */:
+        {
+          this._receiveReply(msgLength, req, undefined);
+          break;
+        }
+      case 9 /* MessageType.ReplyOKJSON */:
+        {
+          let value = MessageIO.deserializeReplyOKJSON(buff);
+          if (this._uriTransformer) {
+            value = transformIncomingURIs(value, this._uriTransformer);
+          }
+          this._receiveReply(msgLength, req, value);
+          break;
+        }
+      case 10 /* MessageType.ReplyOKJSONWithBuffers */:
+        {
+          let value = MessageIO.deserializeReplyOKBuffer(buff);
+          this._receiveReply(msgLength, req, value);
+          break;
+        }
+      case 8 /* MessageType.ReplyOKVSBuffer */:
+        {
+          let value = MessageIO.deserializeReplyOKVSBuffer(buff);
+          this._receiveReply(msgLength, req, value);
+          break;
+        }
+      case 11 /* MessageType.ReplyErrError */:
+        {
+          let err = MessageIO.deserializeReplyErrError(buff);
+          if (this._uriTransformer) {
+            err = transformIncomingURIs(err, this._uriTransformer);
+          }
+          this._receiveReplyErr(msgLength, req, err);
+          break;
+        }
+      case 12 /* MessageType.ReplyErrEmpty */:
+        {
+          this._receiveReplyErr(msgLength, req, undefined);
+          break;
+        }
+      default:
+        console.error(`received unexpected message`);
+        console.error(rawmsg);
+    }
+  }
+  //@sri added destId for identification
+  _receiveRequest(destId, msgLength, req, rpcId, method, args, usesCancellationToken) {
+    if (this._logger) {
+      this._logger.logIncoming(msgLength, req, 1 /* RequestInitiator.OtherSide */, `receiveRequest ${getStringIdentifierForProxy(rpcId)}.${method}(`, args);
+    }
+    const callId = String(req);
+    let promise;
+    let cancel;
+    if (usesCancellationToken) {
+      const cancellationTokenSource = new CancellationTokenSource();
+      args.push(cancellationTokenSource.token);
+      promise = this._invokeHandler(rpcId, method, args);
+      cancel = () => cancellationTokenSource.cancel();
+    } else {
+      // cannot be cancelled
+      promise = this._invokeHandler(rpcId, method, args);
+      cancel = noop;
+    }
+    this._cancelInvokedHandlers[callId] = cancel;
+    // Acknowledge the request
+    const msg = MessageIO.serializeAcknowledged(req);
+    if (this._logger) {
+      this._logger.logOutgoing(msg.byteLength, req, 1 /* RequestInitiator.OtherSide */, `ack`);
+    }
+    this._protocol.send(msg, destId);
+    promise.then(r => {
+      delete this._cancelInvokedHandlers[callId];
+      const msg = MessageIO.serializeReplyOK(req, r, this._uriReplacer);
+      if (this._logger) {
+        this._logger.logOutgoing(msg.byteLength, req, 1 /* RequestInitiator.OtherSide */, `reply:`, r);
+      }
+      this._protocol.send(msg, destId);
+    }, err => {
+      delete this._cancelInvokedHandlers[callId];
+      const msg = MessageIO.serializeReplyErr(req, err);
+      if (this._logger) {
+        this._logger.logOutgoing(msg.byteLength, req, 1 /* RequestInitiator.OtherSide */, `replyErr:`, err);
+      }
+      this._protocol.send(msg, destId);
+    });
+  }
+  _receiveCancel(msgLength, req) {
+    if (this._logger) {
+      this._logger.logIncoming(msgLength, req, 1 /* RequestInitiator.OtherSide */, `receiveCancel`);
+    }
+    const callId = String(req);
+    if (this._cancelInvokedHandlers[callId]) {
+      this._cancelInvokedHandlers[callId]();
+    }
+  }
+  _receiveReply(msgLength, req, value) {
+    if (this._logger) {
+      this._logger.logIncoming(msgLength, req, 0 /* RequestInitiator.LocalSide */, `receiveReply:`, value);
+    }
+    const callId = String(req);
+    if (!this._pendingRPCReplies.hasOwnProperty(callId)) {
+      return;
+    }
+    const pendingReply = this._pendingRPCReplies[callId];
+    delete this._pendingRPCReplies[callId];
+    pendingReply.resolveOk(value);
+  }
+  _receiveReplyErr(msgLength, req, value) {
+    if (this._logger) {
+      this._logger.logIncoming(msgLength, req, 0 /* RequestInitiator.LocalSide */, `receiveReplyErr:`, value);
+    }
+    const callId = String(req);
+    if (!this._pendingRPCReplies.hasOwnProperty(callId)) {
+      return;
+    }
+    const pendingReply = this._pendingRPCReplies[callId];
+    delete this._pendingRPCReplies[callId];
+    let err = null;
+    if (value && value.$isError) {
+      err = new Error();
+      err.name = value.name;
+      err.message = value.message;
+      err.stack = value.stack;
+    }
+    pendingReply.resolveErr(err);
+  }
+  _invokeHandler(rpcId, methodName, args) {
+    try {
+      return Promise.resolve(this._doInvokeHandler(rpcId, methodName, args));
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  _doInvokeHandler(rpcId, methodName, args) {
+    const actor = this._locals[rpcId];
+    if (!actor) {
+      // @sri add logging
+      console.log('Unknown actor: ', {
+        actor: this._locals[0],
+        exists: this._locals.hasOwnProperty(rpcId),
+        actors: Object.keys(this._locals),
+        rpcId
+      });
+      throw new Error('Unknown actor ' + getStringIdentifierForProxy(rpcId));
+    }
+    let method = actor[methodName];
+    if (typeof method !== 'function') {
+      throw new Error('Unknown method ' + methodName + ' on actor ' + getStringIdentifierForProxy(rpcId));
+    }
+    return method.apply(actor, args);
+  }
+  _remoteCall(destId, rpcId, methodName, args) {
+    if (this._isDisposed) {
+      return Promise.reject(errors.canceled());
+    }
+    let cancellationToken = null;
+    if (args.length > 0 && CancellationToken.isCancellationToken(args[args.length - 1])) {
+      cancellationToken = args.pop();
+    }
+    if (cancellationToken && cancellationToken.isCancellationRequested) {
+      // No need to do anything...
+      return Promise.reject(errors.canceled());
+    }
+    const req = ++this._lastMessageId;
+    const callId = String(req);
+    const result = new LazyPromise();
+    if (cancellationToken) {
+      cancellationToken.onCancellationRequested(() => {
+        const msg = MessageIO.serializeCancel(req);
         if (this._logger) {
-            this._logger.logIncoming(msgLength, req, 0 /* RequestInitiator.LocalSide */, `receiveReplyErr:`, value);
-        }
-        const callId = String(req);
-        if (!this._pendingRPCReplies.hasOwnProperty(callId)) {
-            return;
-        }
-        const pendingReply = this._pendingRPCReplies[callId];
-        delete this._pendingRPCReplies[callId];
-        let err = null;
-        if (value && value.$isError) {
-            err = new Error();
-            err.name = value.name;
-            err.message = value.message;
-            err.stack = value.stack;
-        }
-        pendingReply.resolveErr(err);
-    }
-    _invokeHandler(rpcId, methodName, args) {
-        try {
-            return Promise.resolve(this._doInvokeHandler(rpcId, methodName, args));
-        }
-        catch (err) {
-            return Promise.reject(err);
-        }
-    }
-    _doInvokeHandler(rpcId, methodName, args) {
-        const actor = this._locals[rpcId];
-        if (!actor) {
-            // @sri add logging
-            console.log('Unknown actor: ', { actor: this._locals[0], exists: this._locals.hasOwnProperty(rpcId), actors: Object.keys(this._locals), rpcId });
-            throw new Error('Unknown actor ' + getStringIdentifierForProxy(rpcId));
-        }
-        let method = actor[methodName];
-        if (typeof method !== 'function') {
-            throw new Error('Unknown method ' + methodName + ' on actor ' + getStringIdentifierForProxy(rpcId));
+          this._logger.logOutgoing(msg.byteLength, req, 0 /* RequestInitiator.LocalSide */, `cancel`);
         }
-        return method.apply(actor, args);
+        this._protocol.send(MessageIO.serializeCancel(req), destId);
+      });
     }
-    _remoteCall(destId, rpcId, methodName, args) {
-        if (this._isDisposed) {
-            return Promise.reject(errors.canceled());
-        }
-        let cancellationToken = null;
-        if (args.length > 0 && CancellationToken.isCancellationToken(args[args.length - 1])) {
-            cancellationToken = args.pop();
-        }
-        if (cancellationToken && cancellationToken.isCancellationRequested) {
-            // No need to do anything...
-            return Promise.reject(errors.canceled());
-        }
-        const req = ++this._lastMessageId;
-        const callId = String(req);
-        const result = new LazyPromise();
-        if (cancellationToken) {
-            cancellationToken.onCancellationRequested(() => {
-                const msg = MessageIO.serializeCancel(req);
-                if (this._logger) {
-                    this._logger.logOutgoing(msg.byteLength, req, 0 /* RequestInitiator.LocalSide */, `cancel`);
-                }
-                this._protocol.send(MessageIO.serializeCancel(req), destId);
-            });
-        }
-        this._pendingRPCReplies[callId] = result;
-        this._onWillSendRequest(req);
-        const msg = MessageIO.serializeRequest(req, rpcId, methodName, args, !!cancellationToken, this._uriReplacer);
-        if (this._logger) {
-            this._logger.logOutgoing(msg.byteLength, req, 0 /* RequestInitiator.LocalSide */, `request: ${getStringIdentifierForProxy(rpcId)}.${methodName}(`, args);
-        }
-        this._protocol.send(msg, destId);
-        return result;
+    this._pendingRPCReplies[callId] = result;
+    this._onWillSendRequest(req);
+    const msg = MessageIO.serializeRequest(req, rpcId, methodName, args, !!cancellationToken, this._uriReplacer);
+    if (this._logger) {
+      this._logger.logOutgoing(msg.byteLength, req, 0 /* RequestInitiator.LocalSide */, `request: ${getStringIdentifierForProxy(rpcId)}.${methodName}(`, args);
     }
+    this._protocol.send(msg, destId);
+    return result;
+  }
 }
 class MessageBuffer {
-    static alloc(type, req, messageSize) {
-        let result = new MessageBuffer(VSBuffer.alloc(messageSize + 1 /* type */ + 4 /* req */), 0);
-        result.writeUInt8(type);
-        result.writeUInt32(req);
-        return result;
-    }
-    static read(buff, offset) {
-        return new MessageBuffer(buff, offset);
-    }
-    _buff;
-    _offset;
-    get buffer() {
-        return this._buff;
-    }
-    constructor(buff, offset) {
-        this._buff = buff;
-        this._offset = offset;
-    }
-    static sizeUInt8() {
-        return 1;
-    }
-    writeUInt8(n) {
-        this._buff.writeUInt8(n, this._offset);
-        this._offset += 1;
-    }
-    readUInt8() {
-        const n = this._buff.readUInt8(this._offset);
-        this._offset += 1;
-        return n;
-    }
-    writeUInt32(n) {
-        this._buff.writeUInt32BE(n, this._offset);
-        this._offset += 4;
-    }
-    readUInt32() {
-        const n = this._buff.readUInt32BE(this._offset);
-        this._offset += 4;
-        return n;
-    }
-    static sizeShortString(str) {
-        return 1 /* string length */ + str.byteLength /* actual string */;
-    }
-    writeShortString(str) {
-        this._buff.writeUInt8(str.byteLength, this._offset);
-        this._offset += 1;
-        this._buff.set(str, this._offset);
-        this._offset += str.byteLength;
-    }
-    readShortString() {
-        const strByteLength = this._buff.readUInt8(this._offset);
-        this._offset += 1;
-        const strBuff = this._buff.slice(this._offset, this._offset + strByteLength);
-        const str = strBuff.toString();
-        this._offset += strByteLength;
-        return str;
-    }
-    static sizeLongString(str) {
-        return 4 /* string length */ + str.byteLength /* actual string */;
-    }
-    writeLongString(str) {
-        this._buff.writeUInt32BE(str.byteLength, this._offset);
-        this._offset += 4;
-        this._buff.set(str, this._offset);
-        this._offset += str.byteLength;
-    }
-    readLongString() {
-        const strByteLength = this._buff.readUInt32BE(this._offset);
-        this._offset += 4;
-        const strBuff = this._buff.slice(this._offset, this._offset + strByteLength);
-        const str = strBuff.toString();
-        this._offset += strByteLength;
-        return str;
-    }
-    static sizeBuffer(buff) {
-        return 4 /* buffer length */ + buff.byteLength /* actual buffer */;
-    }
-    writeBuffer(buff) {
-        this._buff.writeUInt32BE(buff.byteLength, this._offset);
-        this._offset += 4;
-        this._buff.set(buff, this._offset);
-        this._offset += buff.byteLength;
-    }
-    readBuffer() {
-        const buffLength = this._buff.readUInt32BE(this._offset);
-        this._offset += 4;
-        const buff = this._buff.slice(this._offset, this._offset + buffLength);
-        this._offset += buffLength;
-        return buff.buffer;
-    }
-    static sizeVSBuffer(buff) {
-        return 4 /* buffer length */ + buff.byteLength /* actual buffer */;
-    }
-    writeVSBuffer(buff) {
-        this._buff.writeUInt32BE(buff.byteLength, this._offset);
-        this._offset += 4;
-        this._buff.set(buff, this._offset);
-        this._offset += buff.byteLength;
-    }
-    readVSBuffer() {
-        const buffLength = this._buff.readUInt32BE(this._offset);
-        this._offset += 4;
-        const buff = this._buff.slice(this._offset, this._offset + buffLength);
-        this._offset += buffLength;
-        return buff;
-    }
-    static sizeMixedArray(arr, arrType) {
-        let size = 0;
-        size += 1; // arr length
-        for (let i = 0, len = arr.length; i < len; i++) {
-            const el = arr[i];
-            const elType = arrType[i];
-            size += 1; // arg type
-            if (elType === 1 /* ArgType.String */) {
-                size += this.sizeLongString(el);
-            }
-            else if (elType === 2 /* ArgType.Buffer */) {
-                size += this.sizeBuffer(el);
-            }
-            else {
-                size += this.sizeVSBuffer(el);
-            }
-        }
-        return size;
-    }
-    writeMixedArray(arr, arrType) {
-        this._buff.writeUInt8(arr.length, this._offset);
-        this._offset += 1;
-        for (let i = 0, len = arr.length; i < len; i++) {
-            const el = arr[i];
-            const elType = arrType[i];
-            if (elType === 1 /* ArgType.String */) {
-                this.writeUInt8(1 /* ArgType.String */);
-                this.writeLongString(el);
-            }
-            else if (elType === 2 /* ArgType.Buffer */) {
-                this.writeUInt8(2 /* ArgType.Buffer */);
-                this.writeVSBuffer(el);
-            }
-            else {
-                this.writeUInt8(3 /* ArgType.VSBuffer */);
-                this.writeVSBuffer(el);
-            }
-        }
-    }
-    readMixedArray() {
-        const arrLen = this._buff.readUInt8(this._offset);
-        this._offset += 1;
-        let arr = new Array(arrLen);
-        for (let i = 0; i < arrLen; i++) {
-            const argType = this.readUInt8();
-            switch (argType) {
-                case 1 /* ArgType.String */:
-                    arr[i] = this.readLongString();
-                    break;
-                case 2 /* ArgType.Buffer */:
-                    arr[i] = this.readBuffer();
-                    break;
-                case 3 /* ArgType.VSBuffer */:
-                    arr[i] = this.readVSBuffer();
-                    break;
-            }
-        }
-        return arr;
-    }
+  static alloc(type, req, messageSize) {
+    let result = new MessageBuffer(VSBuffer.alloc(messageSize + 1 /* type */ + 4 /* req */), 0);
+    result.writeUInt8(type);
+    result.writeUInt32(req);
+    return result;
+  }
+  static read(buff, offset) {
+    return new MessageBuffer(buff, offset);
+  }
+  _buff;
+  _offset;
+  get buffer() {
+    return this._buff;
+  }
+  constructor(buff, offset) {
+    this._buff = buff;
+    this._offset = offset;
+  }
+  static sizeUInt8() {
+    return 1;
+  }
+  writeUInt8(n) {
+    this._buff.writeUInt8(n, this._offset);
+    this._offset += 1;
+  }
+  readUInt8() {
+    const n = this._buff.readUInt8(this._offset);
+    this._offset += 1;
+    return n;
+  }
+  writeUInt32(n) {
+    this._buff.writeUInt32BE(n, this._offset);
+    this._offset += 4;
+  }
+  readUInt32() {
+    const n = this._buff.readUInt32BE(this._offset);
+    this._offset += 4;
+    return n;
+  }
+  static sizeShortString(str) {
+    return 1 /* string length */ + str.byteLength /* actual string */;
+  }
+  writeShortString(str) {
+    this._buff.writeUInt8(str.byteLength, this._offset);
+    this._offset += 1;
+    this._buff.set(str, this._offset);
+    this._offset += str.byteLength;
+  }
+  readShortString() {
+    const strByteLength = this._buff.readUInt8(this._offset);
+    this._offset += 1;
+    const strBuff = this._buff.slice(this._offset, this._offset + strByteLength);
+    const str = strBuff.toString();
+    this._offset += strByteLength;
+    return str;
+  }
+  static sizeLongString(str) {
+    return 4 /* string length */ + str.byteLength /* actual string */;
+  }
+  writeLongString(str) {
+    this._buff.writeUInt32BE(str.byteLength, this._offset);
+    this._offset += 4;
+    this._buff.set(str, this._offset);
+    this._offset += str.byteLength;
+  }
+  readLongString() {
+    const strByteLength = this._buff.readUInt32BE(this._offset);
+    this._offset += 4;
+    const strBuff = this._buff.slice(this._offset, this._offset + strByteLength);
+    const str = strBuff.toString();
+    this._offset += strByteLength;
+    return str;
+  }
+  static sizeBuffer(buff) {
+    return 4 /* buffer length */ + buff.byteLength /* actual buffer */;
+  }
+  writeBuffer(buff) {
+    this._buff.writeUInt32BE(buff.byteLength, this._offset);
+    this._offset += 4;
+    this._buff.set(buff, this._offset);
+    this._offset += buff.byteLength;
+  }
+  readBuffer() {
+    const buffLength = this._buff.readUInt32BE(this._offset);
+    this._offset += 4;
+    const buff = this._buff.slice(this._offset, this._offset + buffLength);
+    this._offset += buffLength;
+    return buff.buffer;
+  }
+  static sizeVSBuffer(buff) {
+    return 4 /* buffer length */ + buff.byteLength /* actual buffer */;
+  }
+  writeVSBuffer(buff) {
+    this._buff.writeUInt32BE(buff.byteLength, this._offset);
+    this._offset += 4;
+    this._buff.set(buff, this._offset);
+    this._offset += buff.byteLength;
+  }
+  readVSBuffer() {
+    const buffLength = this._buff.readUInt32BE(this._offset);
+    this._offset += 4;
+    const buff = this._buff.slice(this._offset, this._offset + buffLength);
+    this._offset += buffLength;
+    return buff;
+  }
+  static sizeMixedArray(arr, arrType) {
+    let size = 0;
+    size += 1; // arr length
+    for (let i = 0, len = arr.length; i < len; i++) {
+      const el = arr[i];
+      const elType = arrType[i];
+      size += 1; // arg type
+      if (elType === 1 /* ArgType.String */) {
+        size += this.sizeLongString(el);
+      } else if (elType === 2 /* ArgType.Buffer */) {
+        size += this.sizeBuffer(el);
+      } else {
+        size += this.sizeVSBuffer(el);
+      }
+    }
+    return size;
+  }
+  writeMixedArray(arr, arrType) {
+    this._buff.writeUInt8(arr.length, this._offset);
+    this._offset += 1;
+    for (let i = 0, len = arr.length; i < len; i++) {
+      const el = arr[i];
+      const elType = arrType[i];
+      if (elType === 1 /* ArgType.String */) {
+        this.writeUInt8(1 /* ArgType.String */);
+        this.writeLongString(el);
+      } else if (elType === 2 /* ArgType.Buffer */) {
+        this.writeUInt8(2 /* ArgType.Buffer */);
+        this.writeVSBuffer(el);
+      } else {
+        this.writeUInt8(3 /* ArgType.VSBuffer */);
+        this.writeVSBuffer(el);
+      }
+    }
+  }
+  readMixedArray() {
+    const arrLen = this._buff.readUInt8(this._offset);
+    this._offset += 1;
+    let arr = new Array(arrLen);
+    for (let i = 0; i < arrLen; i++) {
+      const argType = this.readUInt8();
+      switch (argType) {
+        case 1 /* ArgType.String */:
+          arr[i] = this.readLongString();
+          break;
+        case 2 /* ArgType.Buffer */:
+          arr[i] = this.readBuffer();
+          break;
+        case 3 /* ArgType.VSBuffer */:
+          arr[i] = this.readVSBuffer();
+          break;
+      }
+    }
+    return arr;
+  }
 }
 class MessageIO {
-    static _arrayContainsBuffer(arr) {
-        for (let i = 0, len = arr.length; i < len; i++) {
-            if (Buffer.isBuffer(arr[i])) {
-                return true;
-            }
-            if (arr[i] instanceof VSBuffer) {
-                return true;
-            }
-        }
-        return false;
-    }
-    static serializeRequest(req, rpcId, method, args, usesCancellationToken, replacer) {
-        if (this._arrayContainsBuffer(args)) {
-            let massagedArgs = [];
-            let massagedArgsType = [];
-            for (let i = 0, len = args.length; i < len; i++) {
-                const arg = args[i];
-                if (Buffer.isBuffer(arg)) {
-                    massagedArgs[i] = VSBuffer.wrap(arg);
-                    massagedArgsType[i] = 2 /* ArgType.Buffer */;
-                }
-                else if (arg instanceof VSBuffer) {
-                    massagedArgs[i] = arg;
-                    massagedArgsType[i] = 3 /* ArgType.VSBuffer */;
-                }
-                else {
-                    massagedArgs[i] = VSBuffer.fromString(safeStringify(arg, replacer));
-                    massagedArgsType[i] = 1 /* ArgType.String */;
-                }
-            }
-            return this._requestMixedArgs(req, rpcId, method, massagedArgs, massagedArgsType, usesCancellationToken);
-        }
-        return this._requestJSONArgs(req, rpcId, method, safeStringify(args, replacer), usesCancellationToken);
-    }
-    static _requestJSONArgs(req, rpcId, method, args, usesCancellationToken) {
-        const methodBuff = VSBuffer.fromString(method);
-        const argsBuff = VSBuffer.fromString(args);
-        let len = 0;
-        len += MessageBuffer.sizeUInt8();
-        len += MessageBuffer.sizeShortString(methodBuff);
-        len += MessageBuffer.sizeLongString(argsBuff);
-        let result = MessageBuffer.alloc(usesCancellationToken ? 2 /* MessageType.RequestJSONArgsWithCancellation */ : 1 /* MessageType.RequestJSONArgs */, req, len);
-        result.writeUInt8(rpcId);
-        result.writeShortString(methodBuff);
-        result.writeLongString(argsBuff);
-        return result.buffer;
-    }
-    static deserializeRequestJSONArgs(buff) {
-        const rpcId = buff.readUInt8();
-        const method = buff.readShortString();
-        const args = buff.readLongString();
-        return {
-            rpcId: rpcId,
-            method: method,
-            args: JSON.parse(args)
-        };
-    }
-    static _requestMixedArgs(req, rpcId, method, args, argsType, usesCancellationToken) {
-        const methodBuff = VSBuffer.fromString(method);
-        let len = 0;
-        len += MessageBuffer.sizeUInt8();
-        len += MessageBuffer.sizeShortString(methodBuff);
-        len += MessageBuffer.sizeMixedArray(args, argsType);
-        let result = MessageBuffer.alloc(usesCancellationToken ? 4 /* MessageType.RequestMixedArgsWithCancellation */ : 3 /* MessageType.RequestMixedArgs */, req, len);
-        result.writeUInt8(rpcId);
-        result.writeShortString(methodBuff);
-        result.writeMixedArray(args, argsType);
-        return result.buffer;
-    }
-    static deserializeRequestMixedArgs(buff) {
-        const rpcId = buff.readUInt8();
-        const method = buff.readShortString();
-        const rawargs = buff.readMixedArray();
-        const args = new Array(rawargs.length);
-        for (let i = 0, len = rawargs.length; i < len; i++) {
-            const rawarg = rawargs[i];
-            if (typeof rawarg === 'string') {
-                args[i] = JSON.parse(rawarg);
-            }
-            else {
-                args[i] = rawarg;
-            }
-        }
-        return {
-            rpcId: rpcId,
-            method: method,
-            args: args
-        };
-    }
-    static serializeAcknowledged(req) {
-        return MessageBuffer.alloc(5 /* MessageType.Acknowledged */, req, 0).buffer;
-    }
-    static serializeCancel(req) {
-        return MessageBuffer.alloc(6 /* MessageType.Cancel */, req, 0).buffer;
-    }
-    static serializeReplyOK(req, res, replacer) {
-        if (typeof res === 'undefined') {
-            return this._serializeReplyOKEmpty(req);
-        }
-        if (Buffer.isBuffer(res)) {
-            return this._serializeReplyOKBuffer(req, res);
-        }
-        if (res instanceof VSBuffer) {
-            return this._serializeReplyOKVSBuffer(req, res);
-        }
-        return this._serializeReplyOKJSON(req, safeStringify(res, replacer));
-    }
-    static _serializeReplyOKEmpty(req) {
-        return MessageBuffer.alloc(7 /* MessageType.ReplyOKEmpty */, req, 0).buffer;
-    }
-    static _serializeReplyOKBuffer(req, res) {
-        const buff = VSBuffer.wrap(res);
-        let len = 0;
-        len += MessageBuffer.sizeBuffer(buff);
-        let result = MessageBuffer.alloc(10 /* MessageType.ReplyOKJSONWithBuffers */, req, len);
-        result.writeBuffer(buff);
-        return result.buffer;
-    }
-    static _serializeReplyOKVSBuffer(req, res) {
-        let len = 0;
-        len += MessageBuffer.sizeVSBuffer(res);
-        let result = MessageBuffer.alloc(8 /* MessageType.ReplyOKVSBuffer */, req, len);
-        result.writeVSBuffer(res);
-        return result.buffer;
-    }
-    static deserializeReplyOKBuffer(buff) {
-        return buff.readBuffer();
-    }
-    static deserializeReplyOKVSBuffer(buff) {
-        return buff.readVSBuffer();
-    }
-    static _serializeReplyOKJSON(req, res) {
-        const resBuff = VSBuffer.fromString(res);
-        let len = 0;
-        len += MessageBuffer.sizeLongString(resBuff);
-        let result = MessageBuffer.alloc(9 /* MessageType.ReplyOKJSON */, req, len);
-        result.writeLongString(resBuff);
-        return result.buffer;
-    }
-    static deserializeReplyOKJSON(buff) {
-        const res = buff.readLongString();
-        return JSON.parse(res);
-    }
-    static serializeReplyErr(req, err) {
-        if (err instanceof Error) {
-            return this._serializeReplyErrEror(req, err);
-        }
-        return this._serializeReplyErrEmpty(req);
-    }
-    static _serializeReplyErrEror(req, _err) {
-        const errBuff = VSBuffer.fromString(safeStringify(errors.transformErrorForSerialization(_err), null));
-        let len = 0;
-        len += MessageBuffer.sizeLongString(errBuff);
-        let result = MessageBuffer.alloc(11 /* MessageType.ReplyErrError */, req, len);
-        result.writeLongString(errBuff);
-        return result.buffer;
-    }
-    static deserializeReplyErrError(buff) {
-        const err = buff.readLongString();
-        return JSON.parse(err);
-    }
-    static _serializeReplyErrEmpty(req) {
-        return MessageBuffer.alloc(12 /* MessageType.ReplyErrEmpty */, req, 0).buffer;
-    }
+  static _arrayContainsBuffer(arr) {
+    for (let i = 0, len = arr.length; i < len; i++) {
+      if (Buffer.isBuffer(arr[i])) {
+        return true;
+      }
+      if (arr[i] instanceof VSBuffer) {
+        return true;
+      }
+    }
+    return false;
+  }
+  static serializeRequest(req, rpcId, method, args, usesCancellationToken, replacer) {
+    if (this._arrayContainsBuffer(args)) {
+      let massagedArgs = [];
+      let massagedArgsType = [];
+      for (let i = 0, len = args.length; i < len; i++) {
+        const arg = args[i];
+        if (Buffer.isBuffer(arg)) {
+          massagedArgs[i] = VSBuffer.wrap(arg);
+          massagedArgsType[i] = 2 /* ArgType.Buffer */;
+        } else if (arg instanceof VSBuffer) {
+          massagedArgs[i] = arg;
+          massagedArgsType[i] = 3 /* ArgType.VSBuffer */;
+        } else {
+          massagedArgs[i] = VSBuffer.fromString(safeStringify(arg, replacer));
+          massagedArgsType[i] = 1 /* ArgType.String */;
+        }
+      }
+      return this._requestMixedArgs(req, rpcId, method, massagedArgs, massagedArgsType, usesCancellationToken);
+    }
+    return this._requestJSONArgs(req, rpcId, method, safeStringify(args, replacer), usesCancellationToken);
+  }
+  static _requestJSONArgs(req, rpcId, method, args, usesCancellationToken) {
+    const methodBuff = VSBuffer.fromString(method);
+    const argsBuff = VSBuffer.fromString(args);
+    let len = 0;
+    len += MessageBuffer.sizeUInt8();
+    len += MessageBuffer.sizeShortString(methodBuff);
+    len += MessageBuffer.sizeLongString(argsBuff);
+    let result = MessageBuffer.alloc(usesCancellationToken ? 2 /* MessageType.RequestJSONArgsWithCancellation */ : 1 /* MessageType.RequestJSONArgs */, req, len);
+    result.writeUInt8(rpcId);
+    result.writeShortString(methodBuff);
+    result.writeLongString(argsBuff);
+    return result.buffer;
+  }
+  static deserializeRequestJSONArgs(buff) {
+    const rpcId = buff.readUInt8();
+    const method = buff.readShortString();
+    const args = buff.readLongString();
+    return {
+      rpcId: rpcId,
+      method: method,
+      args: JSON.parse(args)
+    };
+  }
+  static _requestMixedArgs(req, rpcId, method, args, argsType, usesCancellationToken) {
+    const methodBuff = VSBuffer.fromString(method);
+    let len = 0;
+    len += MessageBuffer.sizeUInt8();
+    len += MessageBuffer.sizeShortString(methodBuff);
+    len += MessageBuffer.sizeMixedArray(args, argsType);
+    let result = MessageBuffer.alloc(usesCancellationToken ? 4 /* MessageType.RequestMixedArgsWithCancellation */ : 3 /* MessageType.RequestMixedArgs */, req, len);
+    result.writeUInt8(rpcId);
+    result.writeShortString(methodBuff);
+    result.writeMixedArray(args, argsType);
+    return result.buffer;
+  }
+  static deserializeRequestMixedArgs(buff) {
+    const rpcId = buff.readUInt8();
+    const method = buff.readShortString();
+    const rawargs = buff.readMixedArray();
+    const args = new Array(rawargs.length);
+    for (let i = 0, len = rawargs.length; i < len; i++) {
+      const rawarg = rawargs[i];
+      if (typeof rawarg === 'string') {
+        args[i] = JSON.parse(rawarg);
+      } else {
+        args[i] = rawarg;
+      }
+    }
+    return {
+      rpcId: rpcId,
+      method: method,
+      args: args
+    };
+  }
+  static serializeAcknowledged(req) {
+    return MessageBuffer.alloc(5 /* MessageType.Acknowledged */, req, 0).buffer;
+  }
+  static serializeCancel(req) {
+    return MessageBuffer.alloc(6 /* MessageType.Cancel */, req, 0).buffer;
+  }
+  static serializeReplyOK(req, res, replacer) {
+    if (typeof res === 'undefined') {
+      return this._serializeReplyOKEmpty(req);
+    }
+    if (Buffer.isBuffer(res)) {
+      return this._serializeReplyOKBuffer(req, res);
+    }
+    if (res instanceof VSBuffer) {
+      return this._serializeReplyOKVSBuffer(req, res);
+    }
+    return this._serializeReplyOKJSON(req, safeStringify(res, replacer));
+  }
+  static _serializeReplyOKEmpty(req) {
+    return MessageBuffer.alloc(7 /* MessageType.ReplyOKEmpty */, req, 0).buffer;
+  }
+  static _serializeReplyOKBuffer(req, res) {
+    const buff = VSBuffer.wrap(res);
+    let len = 0;
+    len += MessageBuffer.sizeBuffer(buff);
+    let result = MessageBuffer.alloc(10 /* MessageType.ReplyOKJSONWithBuffers */, req, len);
+    result.writeBuffer(buff);
+    return result.buffer;
+  }
+  static _serializeReplyOKVSBuffer(req, res) {
+    let len = 0;
+    len += MessageBuffer.sizeVSBuffer(res);
+    let result = MessageBuffer.alloc(8 /* MessageType.ReplyOKVSBuffer */, req, len);
+    result.writeVSBuffer(res);
+    return result.buffer;
+  }
+  static deserializeReplyOKBuffer(buff) {
+    return buff.readBuffer();
+  }
+  static deserializeReplyOKVSBuffer(buff) {
+    return buff.readVSBuffer();
+  }
+  static _serializeReplyOKJSON(req, res) {
+    const resBuff = VSBuffer.fromString(res);
+    let len = 0;
+    len += MessageBuffer.sizeLongString(resBuff);
+    let result = MessageBuffer.alloc(9 /* MessageType.ReplyOKJSON */, req, len);
+    result.writeLongString(resBuff);
+    return result.buffer;
+  }
+  static deserializeReplyOKJSON(buff) {
+    const res = buff.readLongString();
+    return JSON.parse(res);
+  }
+  static serializeReplyErr(req, err) {
+    if (err instanceof Error) {
+      return this._serializeReplyErrEror(req, err);
+    }
+    return this._serializeReplyErrEmpty(req);
+  }
+  static _serializeReplyErrEror(req, _err) {
+    const errBuff = VSBuffer.fromString(safeStringify(errors.transformErrorForSerialization(_err), null));
+    let len = 0;
+    len += MessageBuffer.sizeLongString(errBuff);
+    let result = MessageBuffer.alloc(11 /* MessageType.ReplyErrError */, req, len);
+    result.writeLongString(errBuff);
+    return result.buffer;
+  }
+  static deserializeReplyErrError(buff) {
+    const err = buff.readLongString();
+    return JSON.parse(err);
+  }
+  static _serializeReplyErrEmpty(req) {
+    return MessageBuffer.alloc(12 /* MessageType.ReplyErrEmpty */, req, 0).buffer;
+  }
 }
 var MessageType;
 (function (MessageType) {
-    MessageType[MessageType["RequestJSONArgs"] = 1] = "RequestJSONArgs";
-    MessageType[MessageType["RequestJSONArgsWithCancellation"] = 2] = "RequestJSONArgsWithCancellation";
-    MessageType[MessageType["RequestMixedArgs"] = 3] = "RequestMixedArgs";
-    MessageType[MessageType["RequestMixedArgsWithCancellation"] = 4] = "RequestMixedArgsWithCancellation";
-    MessageType[MessageType["Acknowledged"] = 5] = "Acknowledged";
-    MessageType[MessageType["Cancel"] = 6] = "Cancel";
-    MessageType[MessageType["ReplyOKEmpty"] = 7] = "ReplyOKEmpty";
-    MessageType[MessageType["ReplyOKVSBuffer"] = 8] = "ReplyOKVSBuffer";
-    MessageType[MessageType["ReplyOKJSON"] = 9] = "ReplyOKJSON";
-    MessageType[MessageType["ReplyOKJSONWithBuffers"] = 10] = "ReplyOKJSONWithBuffers";
-    MessageType[MessageType["ReplyErrError"] = 11] = "ReplyErrError";
-    MessageType[MessageType["ReplyErrEmpty"] = 12] = "ReplyErrEmpty";
+  MessageType[MessageType["RequestJSONArgs"] = 1] = "RequestJSONArgs";
+  MessageType[MessageType["RequestJSONArgsWithCancellation"] = 2] = "RequestJSONArgsWithCancellation";
+  MessageType[MessageType["RequestMixedArgs"] = 3] = "RequestMixedArgs";
+  MessageType[MessageType["RequestMixedArgsWithCancellation"] = 4] = "RequestMixedArgsWithCancellation";
+  MessageType[MessageType["Acknowledged"] = 5] = "Acknowledged";
+  MessageType[MessageType["Cancel"] = 6] = "Cancel";
+  MessageType[MessageType["ReplyOKEmpty"] = 7] = "ReplyOKEmpty";
+  MessageType[MessageType["ReplyOKVSBuffer"] = 8] = "ReplyOKVSBuffer";
+  MessageType[MessageType["ReplyOKJSON"] = 9] = "ReplyOKJSON";
+  MessageType[MessageType["ReplyOKJSONWithBuffers"] = 10] = "ReplyOKJSONWithBuffers";
+  MessageType[MessageType["ReplyErrError"] = 11] = "ReplyErrError";
+  MessageType[MessageType["ReplyErrEmpty"] = 12] = "ReplyErrEmpty";
 })(MessageType || (MessageType = {}));
 var ArgType;
 (function (ArgType) {
-    ArgType[ArgType["String"] = 1] = "String";
-    ArgType[ArgType["Buffer"] = 2] = "Buffer";
-    ArgType[ArgType["VSBuffer"] = 3] = "VSBuffer";
-})(ArgType || (ArgType = {}));export{ArgType,MessageBuffer,MessageIO,MessageType,RPCProtocol,RequestInitiator,ResponsiveState,safeStringify};
+  ArgType[ArgType["String"] = 1] = "String";
+  ArgType[ArgType["Buffer"] = 2] = "Buffer";
+  ArgType[ArgType["VSBuffer"] = 3] = "VSBuffer";
+})(ArgType || (ArgType = {}));export{ArgType,MessageBuffer,MessageIO,MessageType,RPCProtocol,RequestInitiator,ResponsiveState,safeStringify};//# sourceMappingURL=rpc-protocol.js.map