request-iframe 0.1.0 → 0.2.0

package/esm/{core → impl}/client.js

@@ -12,24 +12,24 @@ import "core-js/modules/es.array.filter.js";
 import "core-js/modules/es.array.from.js";
 import "core-js/modules/es.array.iterator.js";
 import "core-js/modules/es.array.slice.js";
-import "core-js/modules/es.map.js";
 import "core-js/modules/es.object.entries.js";
-import "core-js/modules/es.promise.js";
 import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.promise.js";
 import "core-js/modules/es.regexp.exec.js";
 import "core-js/modules/es.regexp.to-string.js";
-import "core-js/modules/es.string.match.js";
-import "core-js/modules/es.string.replace.js";
-import "core-js/modules/es.string.starts-with.js";
 import "core-js/modules/web.dom-collections.for-each.js";
 import "core-js/modules/web.dom-collections.iterator.js";
-import { RequestIframeError } from '../utils';
-import { isAckMetaEqual } from '../utils/ack-meta';
-import { detectContentType, blobToBase64, isWindowAvailable, matchOrigin } from '../utils';
-import { generateRequestId, generateInstanceId, CookieStore } from '../utils';
+import { RequestIframeError } from '../utils/error';
+import { isExpectedAckMatch } from '../endpoint';
+import { detectContentType } from '../utils/content-type';
+import { isWindowAvailable } from '../utils/window';
+import { generateRequestId, generateInstanceId } from '../utils/id';
+import { CookieStore } from '../utils/cookie';
 import { RequestInterceptorManager, ResponseInterceptorManager, runRequestInterceptors, runResponseInterceptors } from '../interceptors';
-import { DefaultTimeout, ErrorCode, MessageType, HttpStatus, HttpStatusText, HttpHeader, Messages, formatMessage, StreamType as StreamTypeConstant } from '../constants';
-import { IframeReadableStream, IframeFileReadableStream, isIframeWritableStream } from '../stream';
+import { RequestIframeEndpointFacade, createReadableStreamFromStart } from '../endpoint';
+import { autoResolveIframeFileReadableStream } from '../endpoint';
+import { DefaultTimeout, ErrorCode, MessageType, MessageRole, HttpStatus, HttpStatusText, HttpHeader, Messages, formatMessage, StreamType as StreamTypeConstant } from '../constants';
+import { isFunction } from '../utils/is';
 
 /**
  * Client configuration options
@@ -44,7 +44,14 @@ export class RequestIframeClientImpl {
    * When a response is received, we remember the server's creatorId as the targetId for future requests
    */
 
-  constructor(targetWindow, targetOrigin, server, options, instanceId) {
+  rememberTargetServerId(serverId) {
+    if (!serverId) return;
+    if (!this._targetServerId) {
+      this._targetServerId = serverId;
+      this.outbox.setDefaultTargetId(serverId);
+    }
+  }
+  constructor(targetWindow, targetOrigin, options, instanceId) {
     var _options$ackTimeout, _options$timeout, _options$asyncTimeout, _options$returnData;
     /** Unique instance ID */
     _defineProperty(this, "interceptors", {
@@ -57,28 +64,43 @@ export class RequestIframeClientImpl {
      * - Automatically parses Set-Cookie and saves when receiving response
      */
     _defineProperty(this, "_cookieStore", new CookieStore());
-    /** 
-     * Stream message handler map
-     * key: streamId
-     * value: stream message handler function
-     */
-    _defineProperty(this, "streamHandlers", new Map());
     this.id = instanceId || generateInstanceId();
     this.targetWindow = targetWindow;
     this.targetOrigin = targetOrigin;
-    this.server = server;
     this.secretKey = options === null || options === void 0 ? void 0 : options.secretKey;
+    var endpoint = new RequestIframeEndpointFacade({
+      role: MessageRole.CLIENT,
+      instanceId: this.id,
+      secretKey: options === null || options === void 0 ? void 0 : options.secretKey,
+      autoAckMaxMetaLength: options === null || options === void 0 ? void 0 : options.autoAckMaxMetaLength,
+      autoAckMaxIdLength: options === null || options === void 0 ? void 0 : options.autoAckMaxIdLength,
+      inbox: {},
+      streamDispatcher: {
+        handledBy: this.id
+      },
+      originValidator: {
+        allowedOrigins: options === null || options === void 0 ? void 0 : options.allowedOrigins,
+        validateOrigin: options === null || options === void 0 ? void 0 : options.validateOrigin
+      }
+    });
+    this.endpoint = endpoint;
+    /** Core/routers shared composition */
+    this.hub = endpoint.hub;
+    this.streamDispatcher = endpoint.streamDispatcher;
+    this.inbox = endpoint.inbox;
+    this.originValidator = endpoint.originValidator;
+
+    /** Create a fixed-peer sender (built-in client) */
+    this.outbox = this.hub.createOutbox(this.targetWindow, this.targetOrigin);
+
+    /**
+     * Register base message infra + response handlers via facade.
+     * These hooks will run when client.open() is called.
+     */
+    this.endpoint.onOpen(() => this.inbox.registerHandlers());
 
     // Provide fallback target for auto-ack (useful when MessageEvent.source is missing in tests)
-    this.server.messageDispatcher.setFallbackTarget(this.targetWindow, this.targetOrigin);
-
-    // Build origin validator (incoming messages)
-    if (options !== null && options !== void 0 && options.validateOrigin) {
-      this.originValidator = (origin, data, context) => options.validateOrigin(origin, data, context);
-    } else if (options !== null && options !== void 0 && options.allowedOrigins) {
-      var matcher = options.allowedOrigins;
-      this.originValidator = origin => matchOrigin(origin, matcher);
-    }
+    this.hub.setFallbackTarget(this.outbox.targetWindow, this.outbox.targetOrigin);
 
     // Set default timeout configuration
     this.defaultAckTimeout = (_options$ackTimeout = options === null || options === void 0 ? void 0 : options.ackTimeout) !== null && _options$ackTimeout !== void 0 ? _options$ackTimeout : DefaultTimeout.ACK;
@@ -91,73 +113,58 @@ export class RequestIframeClientImpl {
     // Save initial headers configuration
     this.initialHeaders = options === null || options === void 0 ? void 0 : options.headers;
 
-    // Register stream message processing callback
-    this.server.setStreamCallback((data, context) => {
-      this.dispatchStreamMessage(data, context);
+    // Stream dispatching is owned by facade (pluggable stream infra)
+    this.endpoint.enableStreamDispatcherCallback({
+      isOriginAllowed: (d, ctx) => this.hub.isOriginAllowedBy(ctx.origin, d, ctx, this.targetOrigin, this.originValidator)
     });
+    this.endpoint.registerClientStreamCallbackHandlers({
+      handlerOptions: this.hub.createHandlerOptions(() => {
+        /** ignore version errors for stream frames */
+      })
+    });
+
+    /** Auto-open by default (unless explicitly set to false) */
+    if ((options === null || options === void 0 ? void 0 : options.autoOpen) !== false) {
+      this.open();
+    }
   }
 
   /**
    * Register stream message handler (StreamMessageHandler interface implementation)
    */
   registerStreamHandler(streamId, handler) {
-    this.streamHandlers.set(streamId, handler);
+    this.streamDispatcher.register(streamId, handler);
   }
 
   /**
    * Unregister stream message handler (StreamMessageHandler interface implementation)
    */
   unregisterStreamHandler(streamId) {
-    this.streamHandlers.delete(streamId);
+    this.streamDispatcher.unregister(streamId);
   }
 
   /*
    Send message (StreamMessageHandler interface implementation)
    */
   postMessage(message) {
-    // Window check is handled in MessageDispatcher
-    this.server.messageDispatcher.send(this.targetWindow, message, this.targetOrigin);
+    this.sendRaw(message);
   }
 
   /**
-   * Dispatch stream message to corresponding handler
+   * Send raw framework message (advanced).
+   *
+   * Note: streams call `postMessage` via StreamMessageHandler, which delegates here.
    */
-  dispatchStreamMessage(data, context) {
-    // Validate origin for stream messages (stream_data/stream_end/stream_error/stream_cancel)
-    if (context) {
-      if (this.originValidator) {
-        try {
-          if (!this.originValidator(context.origin, data, context)) {
-            return;
-          }
-        } catch (_unused) {
-          return;
-        }
-      } else if (this.targetOrigin !== '*' && context.origin !== this.targetOrigin) {
-        return;
-      }
-    }
-    var body = data.body;
-    if (!body || !body.streamId) return;
-    var handler = this.streamHandlers.get(body.streamId);
-    if (handler) {
-      if (context && !context.handledBy) {
-        context.accepted = true;
-        context.handledBy = this.id;
-      }
-      // Extract message type (remove stream_ prefix)
-      var messageType = data.type.replace('stream_', '');
-      handler(_objectSpread(_objectSpread({}, body), {}, {
-        type: messageType
-      }));
-    }
+  sendRaw(message) {
+    // Window check is handled in MessageDispatcher
+    this.outbox.sendRaw(message);
   }
 
   /**
    * Resolve header value (handle function type headers)
    */
   resolveHeaderValue(value, config) {
-    if (typeof value === 'function') {
+    if (isFunction(value)) {
       return value(config);
     }
     return value;
@@ -222,60 +229,27 @@ export class RequestIframeClientImpl {
    * Check if server is reachable
    */
   isConnect() {
-    return new Promise((resolve, reject) => {
-      var requestId = generateRequestId();
-      var done = false;
-      var timeoutId = null;
-      var cleanup = () => {
-        if (timeoutId) clearTimeout(timeoutId);
-        this.server._unregisterPendingRequest(requestId);
-      };
-
-      // Check if target window is still available before sending ping
-      if (!isWindowAvailable(this.targetWindow)) {
-        reject(new RequestIframeError({
-          message: Messages.TARGET_WINDOW_CLOSED,
-          code: ErrorCode.TARGET_WINDOW_CLOSED,
-          config: undefined,
-          requestId
-        }));
-        return;
-      }
-      this.server._registerPendingRequest(requestId, data => {
-        if (done) return;
-        if (data.type === MessageType.ACK || data.type === MessageType.PONG) {
-          // Remember server's creatorId as target server ID for future requests
-          if (data.creatorId && !this._targetServerId) {
-            this._targetServerId = data.creatorId;
-          }
-          done = true;
-          cleanup();
-          resolve(true);
-        }
-      }, () => {
-        if (done) return;
-        done = true;
-        cleanup();
-        resolve(false);
-      }, this.targetOrigin, this.originValidator);
-      timeoutId = setTimeout(() => {
-        if (done) return;
-        done = true;
-        cleanup();
-        resolve(false);
-      }, this.defaultAckTimeout);
-
-      // Send ping via MessageDispatcher
-      this.server.messageDispatcher.sendMessage(this.targetWindow, this.targetOrigin, MessageType.PING, requestId, {
-        requireAck: true,
-        targetId: this._targetServerId
-      });
+    // Check if target window is still available before sending ping
+    if (!isWindowAvailable(this.targetWindow)) {
+      return Promise.reject(new RequestIframeError({
+        message: Messages.TARGET_WINDOW_CLOSED,
+        code: ErrorCode.TARGET_WINDOW_CLOSED,
+        config: undefined,
+        requestId: `ping_${Date.now()}`
+      }));
+    }
+    return this.endpoint.pingIsConnect({
+      peer: this.outbox,
+      timeoutMs: this.defaultAckTimeout,
+      targetOrigin: this.targetOrigin,
+      targetId: this._targetServerId,
+      onPeerId: serverId => this.rememberTargetServerId(serverId)
     });
   }
   send(path, body, options) {
     var _this = this;
     return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var config, processedConfig, processedBody, mergedHeaders, processedPath, processedCookies, userTargetId, _processedConfig$requ, requestId, targetId;
+      var config, processedConfig, processedBody;
       return _regeneratorRuntime.wrap(function (_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
@@ -287,25 +261,28 @@ export class RequestIframeClientImpl {
             return runRequestInterceptors(_this.interceptors.request, config);
           case 1:
             processedConfig = _context.sent;
-            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));
+            processedBody = processedConfig.body;
+            return _context.abrupt("return", _this.outbox.send({
+              data: processedBody,
+              onFileOrBlob: () => {
+                return _this.sendFile(path, processedBody, options);
+              },
+              onStream: () => {
+                return _this.sendStream(path, processedBody, options);
+              },
+              onOther: () => {
+                // Merge and resolve headers (initial headers + request headers)
+                var mergedHeaders = _this.mergeHeaders(processedConfig, processedBody);
+                var processedPath = processedConfig.path,
+                  processedCookies = processedConfig.cookies,
+                  userTargetId = processedConfig.targetId,
+                  _processedConfig$requ = processedConfig.requestId,
+                  requestId = _processedConfig$requ === void 0 ? generateRequestId() : _processedConfig$requ;
+                var targetId = userTargetId || _this._targetServerId;
+                return _this._sendRequest(processedPath, processedBody, mergedHeaders, processedCookies, processedConfig, requestId, targetId);
+              }
+            }));
           case 2:
-            if (!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 ? 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();
         }
@@ -318,67 +295,61 @@ export class RequestIframeClientImpl {
    */
   sendFile(path, content, options) {
     var _this2 = this;
-    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
-      var _options$autoResolve;
-      var streamAutoResolve, mimeType, fileName, _yield$import, IframeFileWritableStream, fileStream;
-      return _regeneratorRuntime.wrap(function (_context3) {
-        while (1) switch (_context3.prev = _context3.next) {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var _processedConfig$requ2, _processedConfig$targ, _options$autoResolve;
+      var config, processedConfig, requestId, targetId, processedPath, mergedHeaders, pathMatchedCookies, mergedCookies, streamConfig;
+      return _regeneratorRuntime.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.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 import('../stream');
+            config = _objectSpread({
+              path,
+              body: undefined
+            }, options);
+            _context2.next = 1;
+            return runRequestInterceptors(_this2.interceptors.request, config);
           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',
+            processedConfig = _context2.sent;
+            requestId = (_processedConfig$requ2 = processedConfig.requestId) !== null && _processedConfig$requ2 !== void 0 ? _processedConfig$requ2 : generateRequestId();
+            targetId = (_processedConfig$targ = processedConfig.targetId) !== null && _processedConfig$targ !== void 0 ? _processedConfig$targ : _this2._targetServerId;
+            processedPath = processedConfig.path;
+            mergedHeaders = _this2.mergeHeaders(processedConfig, undefined);
+            pathMatchedCookies = _this2._cookieStore.getForPath(processedPath);
+            mergedCookies = _objectSpread(_objectSpread({}, pathMatchedCookies), processedConfig.cookies);
+            streamConfig = _objectSpread(_objectSpread({}, processedConfig), {}, {
+              requestId
+            });
+            return _context2.abrupt("return", _this2.outbox.sendFile({
+              content,
+              fileName: options === null || options === void 0 ? void 0 : options.fileName,
+              mimeType: options === null || options === void 0 ? void 0 : options.mimeType,
               chunked: false,
-              autoResolve: streamAutoResolve,
-              next: function () {
-                var _next = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-                  var data, _t;
-                  return _regeneratorRuntime.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 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();
-                    }
-                  }, _callee2);
-                }));
-                function next() {
-                  return _next.apply(this, arguments);
+              autoResolve: (_options$autoResolve = options === null || options === void 0 ? void 0 : options.autoResolve) !== null && _options$autoResolve !== void 0 ? _options$autoResolve : true,
+              defaultFileName: typeof File !== 'undefined' && content instanceof File ? content.name : 'file',
+              defaultMimeType: 'application/octet-stream',
+              stream: {
+                bind: {
+                  requestId,
+                  registerStreamHandler: _this2.registerStreamHandler.bind(_this2),
+                  unregisterStreamHandler: _this2.unregisterStreamHandler.bind(_this2),
+                  heartbeat: () => _this2.isConnect(),
+                  clientId: _this2.id,
+                  targetId
+                },
+                awaitStart: false,
+                beforeStart: ({
+                  stream
+                }) => {
+                  return _this2._sendRequest(processedPath, undefined, mergedHeaders, mergedCookies, streamConfig, requestId, targetId, {
+                    streamId: stream.streamId
+                  });
                 }
-                return next;
-              }()
-            });
-            return _context3.abrupt("return", _this2.sendStream(path, fileStream, options));
+              }
+            }));
           case 2:
           case "end":
-            return _context3.stop();
+            return _context2.stop();
         }
-      }, _callee3);
+      }, _callee2);
     }))();
   }
 
@@ -388,52 +359,53 @@ export class RequestIframeClientImpl {
    */
   sendStream(path, stream, options) {
     var _this3 = this;
-    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
-      var _processedConfig$requ2, _processedConfig$targ;
-      var config, processedConfig, requestId, targetId, processedPath, mergedHeaders, pathMatchedCookies, mergedCookies, streamConfig, promise;
-      return _regeneratorRuntime.wrap(function (_context4) {
-        while (1) switch (_context4.prev = _context4.next) {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var _processedConfig$requ3, _processedConfig$targ2;
+      var config, processedConfig, requestId, targetId, processedPath, mergedHeaders, pathMatchedCookies, mergedCookies, streamConfig;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
           case 0:
             config = _objectSpread({
               path,
               body: undefined
             }, options);
-            _context4.next = 1;
+            _context3.next = 1;
             return runRequestInterceptors(_this3.interceptors.request, config);
           case 1:
-            processedConfig = _context4.sent;
-            requestId = (_processedConfig$requ2 = processedConfig.requestId) !== null && _processedConfig$requ2 !== void 0 ? _processedConfig$requ2 : generateRequestId();
-            targetId = (_processedConfig$targ = processedConfig.targetId) !== null && _processedConfig$targ !== void 0 ? _processedConfig$targ : _this3._targetServerId;
+            processedConfig = _context3.sent;
+            requestId = (_processedConfig$requ3 = processedConfig.requestId) !== null && _processedConfig$requ3 !== void 0 ? _processedConfig$requ3 : generateRequestId();
+            targetId = (_processedConfig$targ2 = processedConfig.targetId) !== null && _processedConfig$targ2 !== void 0 ? _processedConfig$targ2 : _this3._targetServerId;
             processedPath = processedConfig.path;
-            stream._bind({
-              requestId,
-              targetWindow: _this3.targetWindow,
-              targetOrigin: _this3.targetOrigin,
-              secretKey: _this3.secretKey,
-              channel: _this3.server.messageDispatcher.getChannel(),
-              registerStreamHandler: _this3.registerStreamHandler.bind(_this3),
-              unregisterStreamHandler: _this3.unregisterStreamHandler.bind(_this3),
-              heartbeat: () => _this3.isConnect(),
-              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);
+            return _context3.abrupt("return", _this3.outbox.sendStream({
+              stream: stream,
+              bind: {
+                requestId,
+                registerStreamHandler: _this3.registerStreamHandler.bind(_this3),
+                unregisterStreamHandler: _this3.unregisterStreamHandler.bind(_this3),
+                heartbeat: () => _this3.isConnect(),
+                clientId: _this3.id,
+                targetId
+              },
+              awaitStart: false,
+              beforeStart: ({
+                stream: s
+              }) => {
+                return _this3._sendRequest(processedPath, undefined, mergedHeaders, mergedCookies, streamConfig, requestId, targetId, {
+                  streamId: s.streamId
+                });
+              }
+            }));
           case 2:
           case "end":
-            return _context4.stop();
+            return _context3.stop();
         }
-      }, _callee4);
+      }, _callee3);
     }))();
   }
 
@@ -447,10 +419,10 @@ export class RequestIframeClientImpl {
       timeout = _processedConfig$time === void 0 ? this.defaultTimeout : _processedConfig$time,
       _processedConfig$asyn = processedConfig.asyncTimeout,
       asyncTimeout = _processedConfig$asyn === void 0 ? this.defaultAsyncTimeout : _processedConfig$asyn,
-      _processedConfig$requ3 = processedConfig.requireAck,
-      requireAck = _processedConfig$requ3 === void 0 ? true : _processedConfig$requ3,
+      _processedConfig$requ4 = processedConfig.requireAck,
+      requireAck = _processedConfig$requ4 === void 0 ? true : _processedConfig$requ4,
       streamTimeout = processedConfig.streamTimeout,
-      ackMeta = processedConfig.ackMeta,
+      ack = processedConfig.ack,
       _processedConfig$retu = processedConfig.returnData,
       returnData = _processedConfig$retu === void 0 ? this.defaultReturnData : _processedConfig$retu;
     return new Promise((resolve, reject) => {
@@ -458,7 +430,7 @@ export class RequestIframeClientImpl {
       var timeoutId = null;
       var cleanup = () => {
         if (timeoutId) clearTimeout(timeoutId);
-        this.server._unregisterPendingRequest(requestId);
+        this.inbox.unregisterPendingRequest(requestId);
       };
       var fail = error => {
         if (done) return;
@@ -519,19 +491,17 @@ export class RequestIframeClientImpl {
       };
 
       // Register to server's pending requests
-      this.server._registerPendingRequest(requestId, data => {
+      this.inbox.registerPendingRequest(requestId, data => {
         if (done) return;
 
         // Received ACK: server has received request
         if (data.type === MessageType.ACK) {
-          // Optional ackMeta match (ignore mismatched ACK)
-          if (ackMeta !== undefined && !isAckMetaEqual(ackMeta, data.ackMeta)) {
+          // Optional ack match (ignore mismatched ACK)
+          if (!isExpectedAckMatch(ack, data.ack)) {
             return;
           }
           // Remember server's creatorId as target server ID for future requests
-          if (data.creatorId && !this._targetServerId) {
-            this._targetServerId = data.creatorId;
-          }
+          this.rememberTargetServerId(data.creatorId);
           // Switch to request timeout
           setRequestTimeout();
           return;
@@ -540,9 +510,7 @@ export class RequestIframeClientImpl {
         // Received ASYNC notification: this is an async task
         if (data.type === MessageType.ASYNC) {
           // Remember server's creatorId as target server ID for future requests
-          if (data.creatorId && !this._targetServerId) {
-            this._targetServerId = data.creatorId;
-          }
+          this.rememberTargetServerId(data.creatorId);
           // Switch to async timeout
           setAsyncTimeout();
           return;
@@ -550,50 +518,40 @@ export class RequestIframeClientImpl {
 
         // Received stream start message
         if (data.type === MessageType.STREAM_START) {
-          var _streamBody$chunked, _streamBody$autoResol;
           done = true;
           cleanup();
-          var streamBody = data.body;
-          var streamId = streamBody.streamId;
-          var streamType = streamBody.type || StreamTypeConstant.DATA;
-          var streamMode = streamBody.mode;
-          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 === StreamTypeConstant.FILE) {
-            var _readableStream = new IframeFileReadableStream(streamId, requestId, this, {
-              chunked: streamChunked,
-              metadata: streamMetadata,
-              secretKey: this.secretKey,
-              idleTimeout: streamTimeout,
-              heartbeat: () => this.isConnect(),
-              mode: streamMode,
-              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[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 => {
+          // Remember server's creatorId as target server ID for future requests
+          this.rememberTargetServerId(data.creatorId);
+          var created = createReadableStreamFromStart({
+            requestId,
+            data,
+            handler: this,
+            secretKey: this.secretKey,
+            idleTimeout: streamTimeout,
+            heartbeat: () => this.isConnect()
+          });
+          if (!created) {
+            fail(new RequestIframeError({
+              message: formatMessage(Messages.STREAM_ERROR, 'invalid stream_start'),
+              code: ErrorCode.STREAM_ERROR,
+              config: processedConfig,
+              requestId
+            }));
+            return;
+          }
+          var readableStream = created.stream,
+            info = created.info;
+
+          // File stream: optional auto-resolve to File/Blob
+          if (info.type === StreamTypeConstant.FILE) {
+            var fileStream = readableStream;
+            if (info.autoResolve) {
+              autoResolveIframeFileReadableStream({
+                fileStream,
+                info,
+                headers: data.headers
+              }).then(fileData => {
                 var resp = {
                   data: fileData,
                   status: data.status || HttpStatus.OK,
@@ -607,32 +565,7 @@ export class RequestIframeClientImpl {
               }).catch(reject);
               return;
             }
-
-            // Non-autoResolve: return file stream directly
-            var _resp = {
-              data: undefined,
-              status: data.status || HttpStatus.OK,
-              statusText: data.statusText || HttpStatusText[HttpStatus.OK],
-              requestId,
-              headers: data.headers,
-              stream: _readableStream
-            };
-            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 IframeReadableStream(streamId, requestId, this, {
-            type: streamType,
-            mode: streamMode,
-            chunked: streamChunked,
-            metadata: streamMetadata,
-            secretKey: this.secretKey,
-            idleTimeout: streamTimeout,
-            heartbeat: () => this.isConnect()
-          });
           var resp = {
             data: undefined,
             status: data.status || HttpStatus.OK,
@@ -647,21 +580,13 @@ export class RequestIframeClientImpl {
           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 === 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;
-          }
+          this.rememberTargetServerId(data.creatorId);
 
           // Parse and save server-set cookies (from Set-Cookie header)
           if (data.headers && data.headers[HttpHeader.SET_COOKIE]) {
@@ -680,14 +605,14 @@ export class RequestIframeClientImpl {
               _iterator.f();
             }
           }
-          var _resp2 = {
+          var _resp = {
             data: data.data,
             status: data.status || HttpStatus.OK,
             statusText: data.statusText || HttpStatusText[HttpStatus.OK],
             requestId,
             headers: data.headers
           };
-          runResponseInterceptors(this.interceptors.response, _resp2).then(response => {
+          runResponseInterceptors(this.interceptors.response, _resp).then(response => {
             resolve(returnData ? response.data : response);
           }).catch(reject);
           return;
@@ -697,9 +622,7 @@ export class RequestIframeClientImpl {
         if (data.type === 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;
-          }
+          this.rememberTargetServerId(data.creatorId);
           fail(new RequestIframeError({
             message: ((_data$error = data.error) === null || _data$error === void 0 ? void 0 : _data$error.message) || Messages.REQUEST_FAILED,
             code: ((_data$error2 = data.error) === null || _data$error2 === void 0 ? void 0 : _data$error2.code) || ErrorCode.REQUEST_ERROR,
@@ -740,7 +663,7 @@ export class RequestIframeClientImpl {
         cookies: mergedCookies,
         targetId,
         requireAck,
-        ackMeta
+        ack
       };
       if (extraPayload !== null && extraPayload !== void 0 && extraPayload.streamId) {
         payload.streamId = extraPayload.streamId;
@@ -756,21 +679,21 @@ export class RequestIframeClientImpl {
         }));
         return;
       }
-      this.server.messageDispatcher.sendMessage(this.targetWindow, this.targetOrigin, MessageType.REQUEST, requestId, payload);
+      this.outbox.sendMessage(MessageType.REQUEST, requestId, payload);
     });
   }
   /**
-   * Get internal server instance (for debugging)
+   * Get internal hub instance (for debugging)
    */
-  getServer() {
-    return this.server;
+  getHub() {
+    return this.hub;
   }
 
   /**
    * Whether message handling is enabled
    */
   get isOpen() {
-    return this.server.isOpen;
+    return this.hub.isOpen;
   }
 
   /**
@@ -785,14 +708,14 @@ export class RequestIframeClientImpl {
    * Enable message handling (register message handlers)
    */
   open() {
-    this.server.open();
+    this.hub.open();
   }
 
   /**
    * Disable message handling (unregister message handlers, but don't release resources)
    */
   close() {
-    this.server.close();
+    this.hub.close();
   }
 
   /**
@@ -803,14 +726,14 @@ export class RequestIframeClientImpl {
     this._cookieStore.clear();
 
     // Clear stream handlers
-    this.streamHandlers.clear();
+    this.streamDispatcher.clear();
 
     // Clear interceptors
     this.interceptors.request.clear();
     this.interceptors.response.clear();
 
-    // Destroy server (this will also release the message channel)
-    this.server.destroy();
+    // Destroy core (this will also release the message channel)
+    this.hub.destroy();
   }
 
   /**