request-iframe 0.0.2 → 0.0.4

package/library/core/client.js

@@ -6,7 +6,7 @@ require("core-js/modules/es.array.from.js");
 require("core-js/modules/es.array.slice.js");
 require("core-js/modules/es.object.get-own-property-descriptors.js");
 require("core-js/modules/es.regexp.to-string.js");
-require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.weak-map.js");
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
@@ -15,12 +15,16 @@ exports.RequestIframeClientImpl = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 require("core-js/modules/es.array.iterator.js");
 require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.entries.js");
 require("core-js/modules/es.promise.js");
 require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.match.js");
 require("core-js/modules/es.string.replace.js");
 require("core-js/modules/es.string.starts-with.js");
+require("core-js/modules/web.dom-collections.for-each.js");
 require("core-js/modules/web.dom-collections.iterator.js");
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _utils = require("../utils");
 var _interceptors = require("../interceptors");
@@ -29,6 +33,7 @@ var _stream = require("../stream");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /**
@@ -39,8 +44,14 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
  * RequestIframeClient implementation (only responsible for initiating requests, reuses server's listener)
  */
 class RequestIframeClientImpl {
-  constructor(targetWindow, targetOrigin, server, options) {
-    var _options$ackTimeout, _options$timeout, _options$asyncTimeout;
+  /** 
+   * Target server ID (remembered from responses)
+   * When a response is received, we remember the server's creatorId as the targetId for future requests
+   */
+
+  constructor(targetWindow, targetOrigin, server, options, instanceId) {
+    var _options$ackTimeout, _options$timeout, _options$asyncTimeout, _options$returnData;
+    /** Unique instance ID */
     (0, _defineProperty2.default)(this, "interceptors", {
       request: new _interceptors.RequestInterceptorManager(),
       response: new _interceptors.ResponseInterceptorManager()
@@ -57,6 +68,7 @@ class RequestIframeClientImpl {
      * value: stream message handler function
      */
     (0, _defineProperty2.default)(this, "streamHandlers", new Map());
+    this.id = instanceId || (0, _utils.generateInstanceId)();
     this.targetWindow = targetWindow;
     this.targetOrigin = targetOrigin;
     this.server = server;
@@ -67,6 +79,12 @@ class RequestIframeClientImpl {
     this.defaultTimeout = (_options$timeout = options === null || options === void 0 ? void 0 : options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : _constants.DefaultTimeout.REQUEST;
     this.defaultAsyncTimeout = (_options$asyncTimeout = options === null || options === void 0 ? void 0 : options.asyncTimeout) !== null && _options$asyncTimeout !== void 0 ? _options$asyncTimeout : _constants.DefaultTimeout.ASYNC;
 
+    // Set default returnData configuration
+    this.defaultReturnData = (_options$returnData = options === null || options === void 0 ? void 0 : options.returnData) !== null && _options$returnData !== void 0 ? _options$returnData : false;
+
+    // Save initial headers configuration
+    this.initialHeaders = options === null || options === void 0 ? void 0 : options.headers;
+
     // Register stream message processing callback
     this.server.setStreamCallback(data => {
       this.dispatchStreamMessage(data);
@@ -87,8 +105,8 @@ class RequestIframeClientImpl {
     this.streamHandlers.delete(streamId);
   }
 
-  /**
-   * Send message (StreamMessageHandler interface implementation)
+  /*
+   Send message (StreamMessageHandler interface implementation)
    */
   postMessage(message) {
     this.server.messageDispatcher.send(this.targetWindow, message, this.targetOrigin);
@@ -110,6 +128,71 @@ class RequestIframeClientImpl {
     }
   }
 
+  /**
+   * Resolve header value (handle function type headers)
+   */
+  resolveHeaderValue(value, config) {
+    if (typeof value === 'function') {
+      return value(config);
+    }
+    return value;
+  }
+
+  /**
+   * Detect Content-Type for request body
+   */
+  detectContentTypeForBody(body) {
+    return (0, _utils.detectContentType)(body, {
+      checkStream: false
+    });
+  }
+
+  /**
+   * Check if header exists (case-insensitive)
+   */
+  hasHeader(headers, name) {
+    var lower = name.toLowerCase();
+    return Object.keys(headers).some(k => k.toLowerCase() === lower);
+  }
+
+  /**
+   * Merge and resolve headers (initial headers + request headers)
+   * Request headers take precedence over initial headers
+   * Also auto-detects and sets Content-Type if not already set
+   */
+  mergeHeaders(config, body) {
+    var resolvedHeaders = {};
+
+    // First, resolve initial headers
+    if (this.initialHeaders) {
+      for (var _i = 0, _Object$entries = Object.entries(this.initialHeaders); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2),
+          key = _Object$entries$_i[0],
+          value = _Object$entries$_i[1];
+        resolvedHeaders[key] = this.resolveHeaderValue(value, config);
+      }
+    }
+
+    // Then, merge request headers (request headers take precedence)
+    if (config.headers) {
+      for (var _i2 = 0, _Object$entries2 = Object.entries(config.headers); _i2 < _Object$entries2.length; _i2++) {
+        var _Object$entries2$_i = (0, _slicedToArray2.default)(_Object$entries2[_i2], 2),
+          _key = _Object$entries2$_i[0],
+          _value = _Object$entries2$_i[1];
+        resolvedHeaders[_key] = this.resolveHeaderValue(_value, config);
+      }
+    }
+
+    // Auto-detect and set Content-Type if not already set and body is provided
+    if (body !== undefined && !this.hasHeader(resolvedHeaders, _constants.HttpHeader.CONTENT_TYPE)) {
+      var contentType = this.detectContentTypeForBody(body);
+      if (contentType) {
+        resolvedHeaders[_constants.HttpHeader.CONTENT_TYPE] = contentType;
+      }
+    }
+    return resolvedHeaders;
+  }
+
   /**
    * Check if server is reachable
    */
@@ -149,7 +232,7 @@ class RequestIframeClientImpl {
   send(path, body, options) {
     var _this = this;
     return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
-      var config, processedConfig, processedPath, processedBody, processedHeaders, processedCookies, _processedConfig$ackT, ackTimeout, _processedConfig$time, timeout, _processedConfig$asyn, asyncTimeout, _processedConfig$requ, requestId;
+      var config, processedConfig, processedBody, mergedHeaders, processedPath, processedCookies, userTargetId, _processedConfig$requ, requestId, targetId;
       return _regenerator.default.wrap(function (_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
@@ -161,217 +244,456 @@ class RequestIframeClientImpl {
             return (0, _interceptors.runRequestInterceptors)(_this.interceptors.request, config);
           case 1:
             processedConfig = _context.sent;
-            processedPath = processedConfig.path, processedBody = processedConfig.body, processedHeaders = processedConfig.headers, processedCookies = processedConfig.cookies, _processedConfig$ackT = processedConfig.ackTimeout, ackTimeout = _processedConfig$ackT === void 0 ? _this.defaultAckTimeout : _processedConfig$ackT, _processedConfig$time = processedConfig.timeout, timeout = _processedConfig$time === void 0 ? _this.defaultTimeout : _processedConfig$time, _processedConfig$asyn = processedConfig.asyncTimeout, asyncTimeout = _processedConfig$asyn === void 0 ? _this.defaultAsyncTimeout : _processedConfig$asyn, _processedConfig$requ = processedConfig.requestId, requestId = _processedConfig$requ === void 0 ? (0, _utils.generateRequestId)() : _processedConfig$requ;
-            return _context.abrupt("return", new Promise((resolve, reject) => {
-              var prefixedPath = _this.prefixPath(processedPath);
-              var done = false;
-              var timeoutId = null;
-              var cleanup = () => {
-                if (timeoutId) clearTimeout(timeoutId);
-                _this.server._unregisterPendingRequest(requestId);
-              };
-              var fail = error => {
-                if (done) return;
-                done = true;
-                cleanup();
-                reject(error);
-              };
-              var setAckTimeout = () => {
-                if (timeoutId) clearTimeout(timeoutId);
-                timeoutId = setTimeout(() => {
-                  fail({
-                    message: (0, _constants.formatMessage)(_constants.Messages.ACK_TIMEOUT, ackTimeout),
-                    code: _constants.ErrorCode.ACK_TIMEOUT,
-                    config: processedConfig,
-                    requestId
-                  });
-                }, ackTimeout);
-              };
-              var setRequestTimeout = () => {
-                if (timeoutId) clearTimeout(timeoutId);
-                timeoutId = setTimeout(() => {
-                  fail({
-                    message: (0, _constants.formatMessage)(_constants.Messages.REQUEST_TIMEOUT, timeout),
-                    code: _constants.ErrorCode.TIMEOUT,
-                    config: processedConfig,
-                    requestId
-                  });
-                }, timeout);
-              };
-              var setAsyncTimeout = () => {
-                if (timeoutId) clearTimeout(timeoutId);
-                timeoutId = setTimeout(() => {
-                  fail({
-                    message: (0, _constants.formatMessage)(_constants.Messages.ASYNC_REQUEST_TIMEOUT, asyncTimeout),
-                    code: _constants.ErrorCode.ASYNC_TIMEOUT,
-                    config: processedConfig,
-                    requestId
-                  });
-                }, asyncTimeout);
-              };
-
-              // Register to server's pending requests
-              _this.server._registerPendingRequest(requestId, data => {
-                if (done) return;
-
-                // Received ACK: server has received request
-                if (data.type === _constants.MessageType.ACK) {
-                  // Switch to request timeout
-                  setRequestTimeout();
-                  return;
-                }
-
-                // Received ASYNC notification: this is an async task
-                if (data.type === _constants.MessageType.ASYNC) {
-                  // Switch to async timeout
-                  setAsyncTimeout();
-                  return;
-                }
-
-                // Received stream start message
-                if (data.type === _constants.MessageType.STREAM_START) {
-                  var _streamBody$chunked;
-                  done = true;
-                  cleanup();
-                  var streamBody = data.body;
-                  var streamId = streamBody.streamId;
-                  var streamType = streamBody.type || _constants.StreamType.DATA;
-                  var streamChunked = (_streamBody$chunked = streamBody.chunked) !== null && _streamBody$chunked !== void 0 ? _streamBody$chunked : true;
-                  var streamMetadata = streamBody.metadata;
-
-                  // Create corresponding readable stream based on stream type
-                  var readableStream;
-                  if (streamType === _constants.StreamType.FILE) {
-                    readableStream = new _stream.IframeFileReadableStream(streamId, requestId, _this, {
-                      chunked: streamChunked,
-                      metadata: streamMetadata,
-                      filename: streamMetadata === null || streamMetadata === void 0 ? void 0 : streamMetadata.filename,
-                      mimeType: streamMetadata === null || streamMetadata === void 0 ? void 0 : streamMetadata.mimeType,
-                      size: streamMetadata === null || streamMetadata === void 0 ? void 0 : streamMetadata.size
-                    });
-                  } else {
-                    readableStream = new _stream.IframeReadableStream(streamId, requestId, _this, {
-                      type: streamType,
-                      chunked: streamChunked,
-                      metadata: streamMetadata
-                    });
-                  }
-                  var resp = {
-                    data: undefined,
-                    status: data.status || _constants.HttpStatus.OK,
-                    statusText: data.statusText || _constants.HttpStatusText[_constants.HttpStatus.OK],
-                    requestId,
-                    headers: data.headers,
-                    stream: readableStream
-                  };
-                  (0, _interceptors.runResponseInterceptors)(_this.interceptors.response, resp).then(resolve).catch(reject);
-                  return;
-                }
-
-                // Received stream data/end/error/cancel message - dispatch to stream handler
-                if (data.type.startsWith('stream_')) {
-                  _this.dispatchStreamMessage(data);
-                  return;
-                }
+            processedBody = processedConfig.body; // Universal send: dispatch by type (like response.send)
+            if (!(typeof File !== 'undefined' && processedBody instanceof File || typeof Blob !== 'undefined' && processedBody instanceof Blob)) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return", _this.sendFile(path, processedBody, options));
+          case 2:
+            if (!(0, _stream.isIframeWritableStream)(processedBody)) {
+              _context.next = 3;
+              break;
+            }
+            return _context.abrupt("return", _this.sendStream(path, processedBody, options));
+          case 3:
+            // Merge and resolve headers (initial headers + request headers)
+            mergedHeaders = _this.mergeHeaders(processedConfig, processedBody);
+            processedPath = processedConfig.path, processedCookies = processedConfig.cookies, userTargetId = processedConfig.targetId, _processedConfig$requ = processedConfig.requestId, requestId = _processedConfig$requ === void 0 ? (0, _utils.generateRequestId)() : _processedConfig$requ;
+            targetId = userTargetId || _this._targetServerId;
+            return _context.abrupt("return", _this._sendRequest(processedPath, processedBody, mergedHeaders, processedCookies, processedConfig, requestId, targetId));
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }
 
-                // Received response
-                if (data.type === _constants.MessageType.RESPONSE) {
-                  done = true;
-                  cleanup();
-
-                  // If server requires acknowledgment, send received message
-                  if (data.requireAck) {
-                    _this.server.messageDispatcher.sendMessage(_this.targetWindow, _this.targetOrigin, _constants.MessageType.RECEIVED, requestId, {
-                      path: prefixedPath
-                    });
-                  }
-
-                  // Parse and save server-set cookies (from Set-Cookie header)
-                  if (data.headers && data.headers[_constants.HttpHeader.SET_COOKIE]) {
-                    var setCookies = data.headers[_constants.HttpHeader.SET_COOKIE];
-                    var setCookieArray = Array.isArray(setCookies) ? setCookies : [setCookies];
-                    var _iterator = _createForOfIteratorHelper(setCookieArray),
-                      _step;
-                    try {
-                      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                        var setCookieStr = _step.value;
-                        _this._cookieStore.setFromSetCookie(setCookieStr);
-                      }
-                    } catch (err) {
-                      _iterator.e(err);
-                    } finally {
-                      _iterator.f();
+  /**
+   * Send file as request body (stream only; server receives stream or auto-resolved File/Blob via autoResolve).
+   */
+  sendFile(path, content, options) {
+    var _this2 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      var _options$autoResolve;
+      var streamAutoResolve, mimeType, fileName, _yield$import, IframeFileWritableStream, fileStream;
+      return _regenerator.default.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            streamAutoResolve = (_options$autoResolve = options === null || options === void 0 ? void 0 : options.autoResolve) !== null && _options$autoResolve !== void 0 ? _options$autoResolve : true;
+            mimeType = options === null || options === void 0 ? void 0 : options.mimeType;
+            fileName = options === null || options === void 0 ? void 0 : options.fileName;
+            _context3.next = 1;
+            return Promise.resolve().then(() => _interopRequireWildcard(require('../stream')));
+          case 1:
+            _yield$import = _context3.sent;
+            IframeFileWritableStream = _yield$import.IframeFileWritableStream;
+            fileStream = new IframeFileWritableStream({
+              filename: fileName || (typeof File !== 'undefined' && content instanceof File ? content.name : 'file'),
+              mimeType: mimeType || (typeof File !== 'undefined' && content instanceof File ? content.type : content === null || content === void 0 ? void 0 : content.type) || 'application/octet-stream',
+              chunked: false,
+              autoResolve: streamAutoResolve,
+              next: function () {
+                var _next = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+                  var data, _t;
+                  return _regenerator.default.wrap(function (_context2) {
+                    while (1) switch (_context2.prev = _context2.next) {
+                      case 0:
+                        if (!(typeof content === 'string')) {
+                          _context2.next = 1;
+                          break;
+                        }
+                        _t = btoa(unescape(encodeURIComponent(content)));
+                        _context2.next = 3;
+                        break;
+                      case 1:
+                        _context2.next = 2;
+                        return (0, _utils.blobToBase64)(content);
+                      case 2:
+                        _t = _context2.sent;
+                      case 3:
+                        data = _t;
+                        return _context2.abrupt("return", {
+                          data,
+                          done: true
+                        });
+                      case 4:
+                      case "end":
+                        return _context2.stop();
                     }
-                  }
-                  var _resp = {
-                    data: data.data,
-                    status: data.status || _constants.HttpStatus.OK,
-                    statusText: data.statusText || _constants.HttpStatusText[_constants.HttpStatus.OK],
-                    requestId,
-                    headers: data.headers,
-                    fileData: data.fileData
-                  };
-                  (0, _interceptors.runResponseInterceptors)(_this.interceptors.response, _resp).then(resolve).catch(reject);
-                  return;
+                  }, _callee2);
+                }));
+                function next() {
+                  return _next.apply(this, arguments);
                 }
-
-                // Received error
-                if (data.type === _constants.MessageType.ERROR) {
-                  var _data$error, _data$error2;
-                  // If server requires acknowledgment, send received message
-                  if (data.requireAck) {
-                    _this.server.messageDispatcher.sendMessage(_this.targetWindow, _this.targetOrigin, _constants.MessageType.RECEIVED, requestId, {
-                      path: prefixedPath
-                    });
-                  }
-                  var err = {
-                    message: ((_data$error = data.error) === null || _data$error === void 0 ? void 0 : _data$error.message) || _constants.Messages.REQUEST_FAILED,
-                    code: ((_data$error2 = data.error) === null || _data$error2 === void 0 ? void 0 : _data$error2.code) || _constants.ErrorCode.REQUEST_ERROR,
-                    config: processedConfig,
-                    response: data.status ? {
-                      data: data.data,
-                      status: data.status,
-                      statusText: data.statusText || _constants.Messages.ERROR
-                    } : undefined,
-                    requestId
-                  };
-                  fail(err);
-                }
-              }, error => {
-                fail({
-                  message: error.message || _constants.Messages.REQUEST_FAILED,
-                  code: _constants.ErrorCode.REQUEST_ERROR,
-                  config: processedConfig,
-                  requestId
-                });
-              }, _this.targetOrigin);
-
-              // Set ACK timeout
-              setAckTimeout();
-
-              // Get cookies matching request path and merge with user-provided cookies (user-provided takes precedence)
-              var pathMatchedCookies = _this._cookieStore.getForPath(processedPath);
-              var mergedCookies = _objectSpread(_objectSpread({}, pathMatchedCookies), processedCookies);
-
-              // Send request via MessageDispatcher
-              _this.server.messageDispatcher.sendMessage(_this.targetWindow, _this.targetOrigin, _constants.MessageType.REQUEST, requestId, {
-                path: prefixedPath,
-                body: processedBody,
-                headers: processedHeaders,
-                cookies: mergedCookies
-              });
-            }));
+                return next;
+              }()
+            });
+            return _context3.abrupt("return", _this2.sendStream(path, fileStream, options));
           case 2:
           case "end":
-            return _context.stop();
+            return _context3.stop();
         }
-      }, _callee);
+      }, _callee3);
     }))();
   }
-  prefixPath(path) {
-    return this.secretKey ? `${this.secretKey}:${path}` : path;
+
+  /**
+   * Send stream as request body (server receives readable stream).
+   * Sends REQUEST with streamId and stream: true, then starts the writable stream.
+   */
+  sendStream(path, stream, options) {
+    var _this3 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var _processedConfig$requ2, _processedConfig$targ;
+      var config, processedConfig, requestId, targetId, processedPath, mergedHeaders, pathMatchedCookies, mergedCookies, streamConfig, promise;
+      return _regenerator.default.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            config = _objectSpread({
+              path,
+              body: undefined
+            }, options);
+            _context4.next = 1;
+            return (0, _interceptors.runRequestInterceptors)(_this3.interceptors.request, config);
+          case 1:
+            processedConfig = _context4.sent;
+            requestId = (_processedConfig$requ2 = processedConfig.requestId) !== null && _processedConfig$requ2 !== void 0 ? _processedConfig$requ2 : (0, _utils.generateRequestId)();
+            targetId = (_processedConfig$targ = processedConfig.targetId) !== null && _processedConfig$targ !== void 0 ? _processedConfig$targ : _this3._targetServerId;
+            processedPath = processedConfig.path;
+            stream._bind({
+              requestId,
+              targetWindow: _this3.targetWindow,
+              targetOrigin: _this3.targetOrigin,
+              secretKey: _this3.secretKey,
+              channel: _this3.server.messageDispatcher.getChannel(),
+              clientId: _this3.id,
+              targetId
+            });
+            mergedHeaders = _this3.mergeHeaders(processedConfig, undefined);
+            pathMatchedCookies = _this3._cookieStore.getForPath(processedPath);
+            mergedCookies = _objectSpread(_objectSpread({}, pathMatchedCookies), processedConfig.cookies);
+            streamConfig = _objectSpread(_objectSpread({}, processedConfig), {}, {
+              requestId
+            });
+            promise = _this3._sendRequest(processedPath, undefined, mergedHeaders, mergedCookies, streamConfig, requestId, targetId, {
+              streamId: stream.streamId
+            });
+            /** Start stream after REQUEST is sent (_sendRequest sends synchronously in executor) */
+            void stream.start();
+            return _context4.abrupt("return", promise);
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
   }
 
+  /**
+   * Internal: send REQUEST and wait for response (used by send, sendFile, sendStream).
+   */
+  _sendRequest(requestPath, body, mergedHeaders, processedCookies, processedConfig, requestId, targetId, extraPayload) {
+    var _processedConfig$ackT = processedConfig.ackTimeout,
+      ackTimeout = _processedConfig$ackT === void 0 ? this.defaultAckTimeout : _processedConfig$ackT,
+      _processedConfig$time = processedConfig.timeout,
+      timeout = _processedConfig$time === void 0 ? this.defaultTimeout : _processedConfig$time,
+      _processedConfig$asyn = processedConfig.asyncTimeout,
+      asyncTimeout = _processedConfig$asyn === void 0 ? this.defaultAsyncTimeout : _processedConfig$asyn,
+      _processedConfig$retu = processedConfig.returnData,
+      returnData = _processedConfig$retu === void 0 ? this.defaultReturnData : _processedConfig$retu;
+    return new Promise((resolve, reject) => {
+      var done = false;
+      var timeoutId = null;
+      var cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        this.server._unregisterPendingRequest(requestId);
+      };
+      var fail = error => {
+        if (done) return;
+        done = true;
+        cleanup();
+        // Run response interceptors to allow error logging
+        Promise.reject(error).catch(err => {
+          // Run through response interceptors' rejected callbacks
+          var promise = Promise.reject(err);
+          this.interceptors.response.forEach(interceptor => {
+            promise = promise.catch(e => {
+              if (interceptor.rejected) {
+                return interceptor.rejected(e);
+              }
+              return Promise.reject(e);
+            });
+          });
+          return promise;
+        }).catch(() => {
+          // After interceptors, reject with original error
+          reject(error);
+        });
+      };
+      var setAckTimeout = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+          fail({
+            message: (0, _constants.formatMessage)(_constants.Messages.ACK_TIMEOUT, ackTimeout),
+            code: _constants.ErrorCode.ACK_TIMEOUT,
+            config: processedConfig,
+            requestId
+          });
+        }, ackTimeout);
+      };
+      var setRequestTimeout = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+          fail({
+            message: (0, _constants.formatMessage)(_constants.Messages.REQUEST_TIMEOUT, timeout),
+            code: _constants.ErrorCode.TIMEOUT,
+            config: processedConfig,
+            requestId
+          });
+        }, timeout);
+      };
+      var setAsyncTimeout = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+          fail({
+            message: (0, _constants.formatMessage)(_constants.Messages.ASYNC_REQUEST_TIMEOUT, asyncTimeout),
+            code: _constants.ErrorCode.ASYNC_TIMEOUT,
+            config: processedConfig,
+            requestId
+          });
+        }, asyncTimeout);
+      };
+
+      // Register to server's pending requests
+      this.server._registerPendingRequest(requestId, data => {
+        if (done) return;
+
+        // Received ACK: server has received request
+        if (data.type === _constants.MessageType.ACK) {
+          // Remember server's creatorId as target server ID for future requests
+          if (data.creatorId && !this._targetServerId) {
+            this._targetServerId = data.creatorId;
+          }
+          // Switch to request timeout
+          setRequestTimeout();
+          return;
+        }
+
+        // Received ASYNC notification: this is an async task
+        if (data.type === _constants.MessageType.ASYNC) {
+          // Remember server's creatorId as target server ID for future requests
+          if (data.creatorId && !this._targetServerId) {
+            this._targetServerId = data.creatorId;
+          }
+          // Switch to async timeout
+          setAsyncTimeout();
+          return;
+        }
+
+        // Received stream start message
+        if (data.type === _constants.MessageType.STREAM_START) {
+          var _streamBody$chunked, _streamBody$autoResol;
+          done = true;
+          cleanup();
+          var streamBody = data.body;
+          var streamId = streamBody.streamId;
+          var streamType = streamBody.type || _constants.StreamType.DATA;
+          var streamChunked = (_streamBody$chunked = streamBody.chunked) !== null && _streamBody$chunked !== void 0 ? _streamBody$chunked : true;
+          var streamMetadata = streamBody.metadata;
+          var autoResolve = (_streamBody$autoResol = streamBody.autoResolve) !== null && _streamBody$autoResol !== void 0 ? _streamBody$autoResol : false;
+
+          // Create corresponding readable stream based on stream type
+          if (streamType === _constants.StreamType.FILE) {
+            var _readableStream = new _stream.IframeFileReadableStream(streamId, requestId, this, {
+              chunked: streamChunked,
+              metadata: streamMetadata,
+              filename: streamMetadata === null || streamMetadata === void 0 ? void 0 : streamMetadata.filename,
+              mimeType: streamMetadata === null || streamMetadata === void 0 ? void 0 : streamMetadata.mimeType,
+              size: streamMetadata === null || streamMetadata === void 0 ? void 0 : streamMetadata.size
+            });
+
+            // If autoResolve is enabled, automatically read and convert to File/Blob
+            if (autoResolve) {
+              var _data$headers;
+              // Extract fileName from headers if available
+              var contentDisposition = (_data$headers = data.headers) === null || _data$headers === void 0 ? void 0 : _data$headers[_constants.HttpHeader.CONTENT_DISPOSITION];
+              var fileName;
+              if (contentDisposition) {
+                var disposition = typeof contentDisposition === 'string' ? contentDisposition : contentDisposition[0];
+                var filenameMatch = disposition.match(/filename="?([^"]+)"?/i);
+                if (filenameMatch) {
+                  fileName = filenameMatch[1];
+                }
+              }
+              // Fallback to stream metadata if not found in headers
+              fileName = fileName || (streamMetadata === null || streamMetadata === void 0 ? void 0 : streamMetadata.filename) || _readableStream.filename;
+
+              // Use stream's readAsFile or readAsBlob method
+              var fileDataPromise = fileName ? _readableStream.readAsFile(fileName) : _readableStream.readAsBlob();
+              fileDataPromise.then(fileData => {
+                var resp = {
+                  data: fileData,
+                  status: data.status || _constants.HttpStatus.OK,
+                  statusText: data.statusText || _constants.HttpStatusText[_constants.HttpStatus.OK],
+                  requestId,
+                  headers: data.headers
+                };
+                return (0, _interceptors.runResponseInterceptors)(this.interceptors.response, resp);
+              }).then(response => {
+                resolve(returnData ? response.data : response);
+              }).catch(reject);
+              return;
+            }
+
+            // Non-autoResolve: return file stream directly
+            var _resp = {
+              data: undefined,
+              status: data.status || _constants.HttpStatus.OK,
+              statusText: data.statusText || _constants.HttpStatusText[_constants.HttpStatus.OK],
+              requestId,
+              headers: data.headers,
+              stream: _readableStream
+            };
+            (0, _interceptors.runResponseInterceptors)(this.interceptors.response, _resp).then(response => {
+              resolve(returnData ? response.data : response);
+            }).catch(reject);
+            return;
+          }
+
+          // Non-file stream: create regular readable stream
+          var readableStream = new _stream.IframeReadableStream(streamId, requestId, this, {
+            type: streamType,
+            chunked: streamChunked,
+            metadata: streamMetadata
+          });
+          var resp = {
+            data: undefined,
+            status: data.status || _constants.HttpStatus.OK,
+            statusText: data.statusText || _constants.HttpStatusText[_constants.HttpStatus.OK],
+            requestId,
+            headers: data.headers,
+            stream: readableStream
+          };
+          (0, _interceptors.runResponseInterceptors)(this.interceptors.response, resp).then(response => {
+            resolve(returnData ? response.data : response);
+          }).catch(reject);
+          return;
+        }
+
+        // Received stream data/end/error/cancel message - dispatch to stream handler
+        if (data.type.startsWith('stream_')) {
+          this.dispatchStreamMessage(data);
+          return;
+        }
+
+        // Received response
+        if (data.type === _constants.MessageType.RESPONSE) {
+          done = true;
+          cleanup();
+
+          // Remember server's creatorId as target server ID for future requests
+          if (data.creatorId && !this._targetServerId) {
+            this._targetServerId = data.creatorId;
+          }
+
+          // If server requires acknowledgment, send received message
+          if (data.requireAck) {
+            this.server.messageDispatcher.sendMessage(this.targetWindow, this.targetOrigin, _constants.MessageType.RECEIVED, requestId, {
+              path: requestPath,
+              targetId: data.creatorId
+            });
+          }
+
+          // Parse and save server-set cookies (from Set-Cookie header)
+          if (data.headers && data.headers[_constants.HttpHeader.SET_COOKIE]) {
+            var setCookies = data.headers[_constants.HttpHeader.SET_COOKIE];
+            var setCookieArray = Array.isArray(setCookies) ? setCookies : [setCookies];
+            var _iterator = _createForOfIteratorHelper(setCookieArray),
+              _step;
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var setCookieStr = _step.value;
+                this._cookieStore.setFromSetCookie(setCookieStr);
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+          }
+          var _resp2 = {
+            data: data.data,
+            status: data.status || _constants.HttpStatus.OK,
+            statusText: data.statusText || _constants.HttpStatusText[_constants.HttpStatus.OK],
+            requestId,
+            headers: data.headers
+          };
+          (0, _interceptors.runResponseInterceptors)(this.interceptors.response, _resp2).then(response => {
+            resolve(returnData ? response.data : response);
+          }).catch(reject);
+          return;
+        }
+
+        // Received error
+        if (data.type === _constants.MessageType.ERROR) {
+          var _data$error, _data$error2;
+          // Remember server's creatorId as target server ID for future requests
+          if (data.creatorId && !this._targetServerId) {
+            this._targetServerId = data.creatorId;
+          }
+
+          // If server requires acknowledgment, send received message
+          if (data.requireAck) {
+            this.server.messageDispatcher.sendMessage(this.targetWindow, this.targetOrigin, _constants.MessageType.RECEIVED, requestId, {
+              path: requestPath,
+              targetId: data.creatorId
+            });
+          }
+          var err = {
+            message: ((_data$error = data.error) === null || _data$error === void 0 ? void 0 : _data$error.message) || _constants.Messages.REQUEST_FAILED,
+            code: ((_data$error2 = data.error) === null || _data$error2 === void 0 ? void 0 : _data$error2.code) || _constants.ErrorCode.REQUEST_ERROR,
+            config: processedConfig,
+            response: data.status ? {
+              data: data.data,
+              status: data.status,
+              statusText: data.statusText || _constants.Messages.ERROR
+            } : undefined,
+            requestId
+          };
+          fail(err);
+        }
+      }, error => {
+        fail({
+          message: error.message || _constants.Messages.REQUEST_FAILED,
+          code: _constants.ErrorCode.REQUEST_ERROR,
+          config: processedConfig,
+          requestId
+        });
+      }, this.targetOrigin);
+
+      // Set ACK timeout
+      setAckTimeout();
+
+      // Get cookies matching request path and merge with user-provided cookies (user-provided takes precedence)
+      var pathMatchedCookies = this._cookieStore.getForPath(requestPath);
+      var mergedCookies = _objectSpread(_objectSpread({}, pathMatchedCookies), processedCookies);
+
+      // Send request via MessageDispatcher
+      var payload = {
+        path: requestPath,
+        body,
+        headers: mergedHeaders,
+        cookies: mergedCookies,
+        targetId
+      };
+      if (extraPayload !== null && extraPayload !== void 0 && extraPayload.streamId) {
+        payload.streamId = extraPayload.streamId;
+      }
+      this.server.messageDispatcher.sendMessage(this.targetWindow, this.targetOrigin, _constants.MessageType.REQUEST, requestId, payload);
+    });
+  }
   /**
    * Get internal server instance (for debugging)
    */