request-iframe 0.0.6 → 0.1.1

package/library/stream/writable-stream.js

@@ -2,7 +2,6 @@
 
 require("core-js/modules/es.array.filter.js");
 require("core-js/modules/es.object.get-own-property-descriptors.js");
-require("core-js/modules/web.dom-collections.for-each.js");
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
@@ -11,19 +10,19 @@ exports.IframeWritableStream = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-require("core-js/modules/es.symbol.description.js");
-require("core-js/modules/es.symbol.async-iterator.js");
 require("core-js/modules/es.array.iterator.js");
 require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.map.js");
 require("core-js/modules/es.promise.js");
+require("core-js/modules/es.promise.finally.js");
 require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.js");
 require("core-js/modules/web.dom-collections.iterator.js");
 var _utils = require("../utils");
 var _constants = require("../constants");
+var _streamCore = require("./stream-core");
 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; }
-function _asyncIterator(r) { var n, t, o, e = 2; for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) { if (t && null != (n = r[t])) return n.call(r); if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r)); t = "@@asyncIterator", o = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
-function AsyncFromSyncIterator(r) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var n = r.done; return Promise.resolve(r.value).then(function (r) { return { value: r, done: n }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(r) { this.s = r, this.n = r.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(r) { var n = this.s.return; return void 0 === n ? Promise.resolve({ value: r, done: !0 }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); }, throw: function _throw(r) { var n = this.s.return; return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(r); }
 /**
  * Generate a unique stream ID
  */
@@ -33,25 +32,113 @@ function generateStreamId() {
 
 /**
  * IframeWritableStream - Server-side writable stream
- * Used to send stream data to the client
+ *
+ * Writer/producer stream.
+ * It can be created on either side:
+ * - Server → Client: used as response stream (via `res.sendStream(stream)`)
+ * - Client → Server: used as request body stream (via `client.sendStream(path, stream)`)
  */
-class IframeWritableStream {
+class IframeWritableStream extends _streamCore.IframeStreamCore {
   constructor(options = {}) {
-    var _options$type, _options$chunked;
-    (0, _defineProperty2.default)(this, "_state", _constants.StreamState.PENDING);
+    var _options$type, _options$chunked, _options$mode, _options$expireTimeou;
+    var streamId = generateStreamId();
+    var streamType = (_options$type = options.type) !== null && _options$type !== void 0 ? _options$type : _constants.StreamType.DATA;
+    var chunked = (_options$chunked = options.chunked) !== null && _options$chunked !== void 0 ? _options$chunked : true;
+    super(streamId, streamType, chunked, options.metadata, false, options.mode);
     (0, _defineProperty2.default)(this, "context", null);
-    this.streamId = generateStreamId();
-    this.type = (_options$type = options.type) !== null && _options$type !== void 0 ? _options$type : _constants.StreamType.DATA;
-    this.chunked = (_options$chunked = options.chunked) !== null && _options$chunked !== void 0 ? _options$chunked : true;
+    (0, _defineProperty2.default)(this, "expireTimer", null);
+    (0, _defineProperty2.default)(this, "idleTimer", null);
+    (0, _defineProperty2.default)(this, "lastRemoteActivityAt", Date.now());
+    (0, _defineProperty2.default)(this, "heartbeatInFlight", null);
+    /** pull/ack protocol */
+    (0, _defineProperty2.default)(this, "pullCredit", 0);
+    (0, _defineProperty2.default)(this, "seq", 0);
+    (0, _defineProperty2.default)(this, "pendingBytes", 0);
+    (0, _defineProperty2.default)(this, "pendingQueue", []);
+    (0, _defineProperty2.default)(this, "pumping", false);
+    (0, _defineProperty2.default)(this, "completionPromise", null);
+    (0, _defineProperty2.default)(this, "resolveCompletion", null);
+    (0, _defineProperty2.default)(this, "rejectCompletion", null);
+    (0, _defineProperty2.default)(this, "ackWaiters", new Map());
+    (0, _defineProperty2.default)(this, "ackReceiverRegistered", false);
+    this.mode = (_options$mode = options.mode) !== null && _options$mode !== void 0 ? _options$mode : _constants.StreamMode.PULL;
     this.iterator = options.iterator;
     this.nextFn = options.next;
-    this.metadata = options.metadata;
     this.autoResolve = options.autoResolve;
+    // Default to async-timeout length to avoid leaking long-lived streams
+    this.expireTimeout = (_options$expireTimeou = options.expireTimeout) !== null && _options$expireTimeou !== void 0 ? _options$expireTimeou : _constants.DefaultTimeout.ASYNC;
+    this.streamTimeout = options.streamTimeout;
+    this.maxPendingChunks = options.maxPendingChunks;
+    this.maxPendingBytes = options.maxPendingBytes;
+  }
+  enqueue(item) {
+    var max = this.maxPendingChunks;
+    if (typeof max === 'number' && max > 0 && this.pendingQueue.length >= max) {
+      throw new Error((0, _constants.formatMessage)(_constants.Messages.STREAM_PENDING_QUEUE_OVERFLOW, max));
+    }
+    var bytes = this.estimateChunkBytes(item.data);
+    var maxBytes = this.maxPendingBytes;
+    if (typeof maxBytes === 'number' && maxBytes > 0) {
+      var next = this.pendingBytes + bytes;
+      if (!Number.isFinite(next) || next > maxBytes) {
+        throw new Error((0, _constants.formatMessage)(_constants.Messages.STREAM_PENDING_BYTES_OVERFLOW, maxBytes));
+      }
+    }
+    this.pendingQueue.push(_objectSpread(_objectSpread({}, item), {}, {
+      bytes
+    }));
+    this.pendingBytes += bytes;
+  }
+  estimateChunkBytes(data) {
+    if (data === null || data === undefined) return 0;
+    if (typeof data === 'string') return this.utf8ByteLength(data);
+    try {
+      // ArrayBuffer
+      if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer) {
+        return data.byteLength;
+      }
+      // TypedArray / DataView
+      if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView && ArrayBuffer.isView(data)) {
+        return data.byteLength;
+      }
+    } catch (_unused) {
+      /** ignore */
+    }
+    try {
+      // Blob / File
+      if (typeof Blob !== 'undefined' && data instanceof Blob) {
+        return data.size;
+      }
+    } catch (_unused2) {
+      /** ignore */
+    }
+
+    // Strategy C: only count well-defined types; other values are not counted.
+    return 0;
+  }
+  utf8ByteLength(text) {
+    try {
+      if (typeof TextEncoder !== 'undefined') {
+        return new TextEncoder().encode(text).length;
+      }
+    } catch (_unused3) {
+      /** ignore */
+    }
+    try {
+      // eslint-disable-next-line no-undef
+      if (typeof Buffer !== 'undefined') {
+        // eslint-disable-next-line no-undef
+        return Buffer.byteLength(text, 'utf8');
+      }
+    } catch (_unused4) {
+      /** ignore */
+    }
+    return text.length;
   }
 
   /** Get stream state */
   get state() {
-    return this._state;
+    return super.state;
   }
 
   /**
@@ -61,6 +148,125 @@ class IframeWritableStream {
   _bind(context) {
     this.context = context;
   }
+  registerControlHandler() {
+    var _this$context;
+    if (!((_this$context = this.context) !== null && _this$context !== void 0 && _this$context.registerStreamHandler)) return;
+    this.context.registerStreamHandler(this.streamId, this.handleControlMessage.bind(this));
+  }
+  unregisterControlHandler() {
+    var _this$context2;
+    if (!((_this$context2 = this.context) !== null && _this$context2 !== void 0 && _this$context2.unregisterStreamHandler)) return;
+    this.context.unregisterStreamHandler(this.streamId);
+  }
+  handleControlMessage(data) {
+    // Update remote activity timestamp on any control message
+    this.lastRemoteActivityAt = Date.now();
+    switch (data.type) {
+      case _constants.StreamInternalMessageType.PULL:
+        {
+          var credit = typeof data.credit === 'number' && data.credit > 0 ? data.credit : 1;
+          this.pullCredit += credit;
+          this.emit(_constants.StreamEvent.PULL, {
+            credit,
+            totalCredit: this.pullCredit
+          });
+          // Try flushing buffered chunks or pumping generator
+          this.flush();
+          break;
+        }
+      case _constants.StreamInternalMessageType.CANCEL:
+        this.emit(_constants.StreamEvent.CANCEL, {
+          reason: data.reason,
+          remote: true
+        });
+        this.cancel(data.reason);
+        break;
+      default:
+        break;
+    }
+  }
+  clearIdleTimer() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+  }
+  performHeartbeat() {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var _this$context3;
+      return _regenerator.default.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if ((_this$context3 = _this.context) !== null && _this$context3 !== void 0 && _this$context3.heartbeat) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return", false);
+          case 1:
+            if (!_this.heartbeatInFlight) {
+              _this.heartbeatInFlight = Promise.resolve().then(() => _this.context.heartbeat()).catch(() => false).finally(() => {
+                _this.heartbeatInFlight = null;
+              });
+            }
+            return _context.abrupt("return", _this.heartbeatInFlight);
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }
+  startIdleTimer() {
+    var _this2 = this;
+    if (!this.streamTimeout || this.streamTimeout <= 0) return;
+    this.clearIdleTimer();
+    var timeout = this.streamTimeout;
+    this.idleTimer = setTimeout(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var ok;
+      return _regenerator.default.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(_this2._state !== _constants.StreamState.STREAMING)) {
+              _context2.next = 1;
+              break;
+            }
+            return _context2.abrupt("return");
+          case 1:
+            if (!(Date.now() - _this2.lastRemoteActivityAt < timeout)) {
+              _context2.next = 2;
+              break;
+            }
+            _this2.startIdleTimer();
+            return _context2.abrupt("return");
+          case 2:
+            _context2.next = 3;
+            return _this2.performHeartbeat();
+          case 3:
+            ok = _context2.sent;
+            if (!ok) {
+              _context2.next = 4;
+              break;
+            }
+            _this2.lastRemoteActivityAt = Date.now();
+            _this2.startIdleTimer();
+            return _context2.abrupt("return");
+          case 4:
+            try {
+              _this2.emit(_constants.StreamEvent.TIMEOUT, {
+                timeout
+              });
+              _this2.error((0, _constants.formatMessage)(_constants.Messages.STREAM_TIMEOUT, timeout));
+            } catch (_unused5) {
+              /** ignore */
+            }
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })), timeout);
+  }
 
   /**
    * Send message (to client when server-side stream, to server when client-side stream)
@@ -85,266 +291,459 @@ class IframeWritableStream {
     var ok = this.context.channel.send(this.context.targetWindow, message, this.context.targetOrigin);
     if (!ok) {
       this._state = _constants.StreamState.CANCELLED;
+      this.clearExpireTimer();
       // For most stream messages, if we cannot send, treat as a hard cancellation signal
       // so callers can stop further processing immediately.
       throw new Error((0, _constants.formatMessage)(_constants.Messages.STREAM_CANCELLED, 'Target window closed'));
     }
     return true;
   }
+  ensureAckReceiver() {
+    if (this.ackReceiverRegistered) return;
+    if (!this.context) return;
+    var ch = this.context.channel;
+    if (typeof ch.addReceiver !== 'function' || typeof ch.removeReceiver !== 'function') return;
+    this.ackReceiver = (data, context) => {
+      if (!data || data.type !== _constants.MessageType.ACK) return;
+      var pending = this.ackWaiters.get(data.requestId);
+      if (!pending) return;
+      if (context && !context.handledBy) {
+        context.handledBy = `stream:${this.streamId}`;
+      }
+      clearTimeout(pending.timeoutId);
+      this.ackWaiters.delete(data.requestId);
+      pending.resolve(true);
+    };
+    ch.addReceiver(this.ackReceiver);
+    this.ackReceiverRegistered = true;
+  }
+  cleanupAckWaiters() {
+    this.ackWaiters.forEach(p => {
+      clearTimeout(p.timeoutId);
+      p.resolve(false);
+    });
+    this.ackWaiters.clear();
+    if (this.ackReceiverRegistered && this.ackReceiver && this.context) {
+      var ch = this.context.channel;
+      if (typeof ch.removeReceiver === 'function') {
+        try {
+          ch.removeReceiver(this.ackReceiver);
+        } catch (_unused6) {
+          /** ignore */
+        }
+      }
+    }
+    this.ackReceiverRegistered = false;
+    this.ackReceiver = undefined;
+  }
+  registerAckWaiter(requestId, timeoutMs, resolve) {
+    var timeoutId = setTimeout(() => {
+      this.ackWaiters.delete(requestId);
+      resolve(false);
+    }, timeoutMs);
+    this.ackWaiters.set(requestId, {
+      resolve,
+      timeoutId
+    });
+  }
+  clearExpireTimer() {
+    if (this.expireTimer) {
+      clearTimeout(this.expireTimer);
+      this.expireTimer = null;
+    }
+  }
+  startExpireTimer() {
+    if (!this.expireTimeout || this.expireTimeout <= 0) return;
+    var expireTimeout = this.expireTimeout;
+    this.clearExpireTimer();
+    this.expireTimer = setTimeout(() => {
+      if (this._state !== _constants.StreamState.STREAMING) return;
+      try {
+        this.emit(_constants.StreamEvent.EXPIRED, {
+          timeout: expireTimeout
+        });
+        this.error((0, _constants.formatMessage)(_constants.Messages.STREAM_EXPIRED, expireTimeout));
+      } catch (_unused7) {
+        /** ignore timer-triggered send failures */
+      }
+    }, expireTimeout);
+  }
 
   /**
    * Start stream transfer
    */
   start() {
-    var _this = this;
-    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+    var _this3 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
       var _t;
-      return _regenerator.default.wrap(function (_context) {
-        while (1) switch (_context.prev = _context.next) {
+      return _regenerator.default.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
           case 0:
-            if (_this.context) {
-              _context.next = 1;
+            if (_this3.context) {
+              _context3.next = 1;
               break;
             }
             throw new Error(_constants.Messages.STREAM_NOT_BOUND);
           case 1:
-            if (!(_this._state !== _constants.StreamState.PENDING)) {
-              _context.next = 2;
+            if (!(_this3._state !== _constants.StreamState.PENDING)) {
+              _context3.next = 2;
               break;
             }
             throw new Error(_constants.Messages.STREAM_ALREADY_STARTED);
           case 2:
-            _this._state = _constants.StreamState.STREAMING;
+            _this3.completionPromise = new Promise((resolve, reject) => {
+              _this3.resolveCompletion = resolve;
+              _this3.rejectCompletion = reject;
+            });
+            _this3._state = _constants.StreamState.STREAMING;
+            _this3.startExpireTimer();
+            _this3.startIdleTimer();
+            _this3.lastRemoteActivityAt = Date.now();
+            _this3.registerControlHandler();
 
             // Send stream start message
-            _this.sendMessage(_constants.MessageType.STREAM_START, {
-              type: _this.type,
-              chunked: _this.chunked,
-              metadata: _this.metadata,
-              autoResolve: _this.autoResolve
+            _this3.sendMessage(_constants.MessageType.STREAM_START, {
+              type: _this3.type,
+              mode: _this3.mode,
+              chunked: _this3.chunked,
+              metadata: _this3.metadata,
+              autoResolve: _this3.autoResolve
             });
-            _context.prev = 3;
-            if (!_this.iterator) {
-              _context.next = 5;
+            _this3.emit(_constants.StreamEvent.START, {
+              streamId: _this3.streamId,
+              type: _this3.type,
+              chunked: _this3.chunked,
+              mode: _this3.mode,
+              metadata: _this3.metadata
+            });
+            _context3.prev = 3;
+            if (!(_this3.mode === _constants.StreamMode.PUSH)) {
+              _context3.next = 5;
               break;
             }
-            _context.next = 4;
-            return _this.streamFromIterator();
+            _context3.next = 4;
+            return _this3.completionPromise;
           case 4:
-            _context.next = 8;
-            break;
+            return _context3.abrupt("return", _context3.sent);
           case 5:
-            if (!_this.nextFn) {
-              _context.next = 7;
-              break;
-            }
-            _context.next = 6;
-            return _this.streamFromNext();
+            // pull protocol: produce only when receiver grants credit
+            _this3.flush();
+            _context3.next = 6;
+            return _this3.completionPromise;
           case 6:
-            _context.next = 8;
-            break;
+            return _context3.abrupt("return", _context3.sent);
           case 7:
-            // No data source, end directly
-            _this.end();
-          case 8:
-            _context.next = 11;
-            break;
-          case 9:
-            _context.prev = 9;
-            _t = _context["catch"](3);
-            if (!(_this._state === _constants.StreamState.CANCELLED)) {
-              _context.next = 10;
+            _context3.prev = 7;
+            _t = _context3["catch"](3);
+            if (!(_this3._state === _constants.StreamState.CANCELLED)) {
+              _context3.next = 8;
               break;
             }
+            _this3.clearExpireTimer();
             throw _t;
+          case 8:
+            _this3.error(_t.message || String(_t));
+            _context3.next = 9;
+            return _this3.completionPromise;
+          case 9:
+            return _context3.abrupt("return", _context3.sent);
           case 10:
-            _this.error(_t.message || String(_t));
-          case 11:
           case "end":
-            return _context.stop();
+            return _context3.stop();
         }
-      }, _callee, null, [[3, 9]]);
+      }, _callee3, null, [[3, 7]]);
     }))();
   }
 
+  /**
+   * Push a chunk manually (mode === 'push').
+   */
+
+  write(data, doneOrOptions = false, options) {
+    var _opts$ackTimeout;
+    if (this.mode !== _constants.StreamMode.PUSH) {
+      throw new Error(_constants.Messages.STREAM_WRITE_ONLY_IN_PUSH_MODE);
+    }
+    if (this._state === _constants.StreamState.PENDING) {
+      /**
+       * In push mode, users must call start() first so STREAM_START is sent and binding is complete.
+       */
+      throw new Error(_constants.Messages.STREAM_NOT_BOUND);
+    }
+    if (this._state !== _constants.StreamState.STREAMING) {
+      throw new Error(_constants.Messages.STREAM_ENDED);
+    }
+    var done = typeof doneOrOptions === 'boolean' ? doneOrOptions : false;
+    var opts = typeof doneOrOptions === 'object' ? doneOrOptions : options;
+    var requireAck = (opts === null || opts === void 0 ? void 0 : opts.requireAck) === true;
+    var ackTimeout = (_opts$ackTimeout = opts === null || opts === void 0 ? void 0 : opts.ackTimeout) !== null && _opts$ackTimeout !== void 0 ? _opts$ackTimeout : _constants.DefaultTimeout.ACK;
+    if (!requireAck) {
+      // push mode now buffers and sends based on pull credit
+      this.enqueue({
+        data,
+        done
+      });
+      this.emit(_constants.StreamEvent.WRITE, {
+        data,
+        done
+      });
+      this.flush();
+      return;
+    }
+    return new Promise(resolve => {
+      var ackRequestId = (0, _utils.generateRequestId)();
+      this.enqueue({
+        data,
+        done,
+        requireAck: true,
+        ackRequestId,
+        ackTimeout,
+        resolveAck: resolve
+      });
+      this.emit(_constants.StreamEvent.WRITE, {
+        data,
+        done
+      });
+      this.flush();
+    });
+  }
+
+  /**
+   * End the stream (mode === 'push').
+   */
+  end() {
+    if (this.mode !== _constants.StreamMode.PUSH) {
+      // For pull mode, end is controlled internally
+      this.endInternal();
+      return;
+    }
+    // In push mode, end means enqueue a terminal marker if nothing queued
+    if (this.mode === _constants.StreamMode.PUSH) {
+      if (this.pendingQueue.length === 0) {
+        this.enqueue({
+          data: undefined,
+          done: true
+        });
+      } else {
+        // Ensure the last queued chunk marks done
+        this.pendingQueue[this.pendingQueue.length - 1].done = true;
+      }
+      this.flush();
+      return;
+    }
+    this.endInternal();
+  }
+
   /**
    * Generate data from iterator
    */
-  streamFromIterator() {
-    var _this2 = this;
-    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
-      var gen, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, chunk, _t2, _t3, _t4;
-      return _regenerator.default.wrap(function (_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
+  pumpFromGenerator() {
+    var _this4 = this;
+    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var gen, r, result, _t2;
+      return _regenerator.default.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
           case 0:
-            if (_this2.iterator) {
-              _context2.next = 1;
+            if (!_this4.pumping) {
+              _context4.next = 1;
               break;
             }
-            return _context2.abrupt("return");
+            return _context4.abrupt("return");
           case 1:
-            gen = _this2.iterator();
-            _context2.prev = 2;
-            _iteratorAbruptCompletion = false;
-            _didIteratorError = false;
-            _context2.prev = 3;
-            _iterator = _asyncIterator(gen);
-          case 4:
-            _context2.next = 5;
-            return _iterator.next();
-          case 5:
-            if (!(_iteratorAbruptCompletion = !(_step = _context2.sent).done)) {
-              _context2.next = 10;
+            _this4.pumping = true;
+            _context4.prev = 2;
+            if (!_this4.iterator) {
+              _context4.next = 8;
               break;
             }
-            chunk = _step.value;
-            if (!(_this2._state !== _constants.StreamState.STREAMING)) {
-              _context2.next = 6;
+            gen = _this4.iterator();
+          case 3:
+            if (!(_this4._state === _constants.StreamState.STREAMING)) {
+              _context4.next = 7;
               break;
             }
-            return _context2.abrupt("continue", 10);
-          case 6:
-            _context2.prev = 6;
-            _this2.sendData(chunk);
-            _context2.next = 9;
-            break;
-          case 7:
-            _context2.prev = 7;
-            _t2 = _context2["catch"](6);
-            if (!(_this2._state === _constants.StreamState.CANCELLED)) {
-              _context2.next = 8;
+            if (!(_this4.pullCredit <= 0)) {
+              _context4.next = 4;
               break;
             }
-            throw _t2;
-          case 8:
-            throw _t2;
-          case 9:
-            _iteratorAbruptCompletion = false;
-            _context2.next = 4;
-            break;
-          case 10:
-            _context2.next = 12;
-            break;
-          case 11:
-            _context2.prev = 11;
-            _t3 = _context2["catch"](3);
-            _didIteratorError = true;
-            _iteratorError = _t3;
-          case 12:
-            _context2.prev = 12;
-            _context2.prev = 13;
-            if (!(_iteratorAbruptCompletion && _iterator.return != null)) {
-              _context2.next = 14;
-              break;
-            }
-            _context2.next = 14;
-            return _iterator.return();
-          case 14:
-            _context2.prev = 14;
-            if (!_didIteratorError) {
-              _context2.next = 15;
+            return _context4.abrupt("continue", 7);
+          case 4:
+            _context4.next = 5;
+            return gen.next();
+          case 5:
+            r = _context4.sent;
+            if (!r.done) {
+              _context4.next = 6;
               break;
             }
-            throw _iteratorError;
-          case 15:
-            return _context2.finish(14);
-          case 16:
-            return _context2.finish(12);
-          case 17:
-            if (_this2._state === _constants.StreamState.STREAMING) {
-              _this2.end();
-            }
-            _context2.next = 20;
+            // no more data: send end
+            _this4.endInternal();
+            return _context4.abrupt("continue", 7);
+          case 6:
+            _this4.enqueue({
+              data: r.value,
+              done: false
+            });
+            _this4.flush();
+            _context4.next = 3;
             break;
-          case 18:
-            _context2.prev = 18;
-            _t4 = _context2["catch"](2);
-            if (!(_this2._state === _constants.StreamState.CANCELLED)) {
-              _context2.next = 19;
+          case 7:
+            _context4.next = 15;
+            break;
+          case 8:
+            if (!_this4.nextFn) {
+              _context4.next = 14;
               break;
             }
-            throw _t4;
-          case 19:
-            if (_this2._state === _constants.StreamState.STREAMING) {
-              _this2.error(_t4.message || String(_t4));
-            }
-          case 20:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2, null, [[2, 18], [3, 11, 12, 17], [6, 7], [13,, 14, 16]]);
-    }))();
-  }
-
-  /**
-   * Generate data from next function
-   */
-  streamFromNext() {
-    var _this3 = this;
-    return (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
-      var result, _t5;
-      return _regenerator.default.wrap(function (_context3) {
-        while (1) switch (_context3.prev = _context3.next) {
-          case 0:
-            if (_this3.nextFn) {
-              _context3.next = 1;
+          case 9:
+            if (!(_this4._state === _constants.StreamState.STREAMING)) {
+              _context4.next = 13;
               break;
             }
-            return _context3.abrupt("return");
-          case 1:
-            _context3.prev = 1;
-          case 2:
-            if (!(_this3._state === _constants.StreamState.STREAMING)) {
-              _context3.next = 5;
+            if (!(_this4.pullCredit <= 0)) {
+              _context4.next = 10;
               break;
             }
-            _context3.next = 3;
-            return Promise.resolve(_this3.nextFn());
-          case 3:
-            result = _context3.sent;
+            return _context4.abrupt("continue", 13);
+          case 10:
+            _context4.next = 11;
+            return Promise.resolve(_this4.nextFn());
+          case 11:
+            result = _context4.sent;
+            _this4.enqueue({
+              data: result.data,
+              done: result.done
+            });
+            _this4.flush();
             if (!result.done) {
-              _context3.next = 4;
+              _context4.next = 12;
               break;
             }
-            _this3.sendData(result.data, true);
-            _this3.end();
-            return _context3.abrupt("continue", 5);
-          case 4:
-            _this3.sendData(result.data);
-            _context3.next = 2;
+            return _context4.abrupt("continue", 13);
+          case 12:
+            _context4.next = 9;
             break;
-          case 5:
-            _context3.next = 8;
+          case 13:
+            _context4.next = 15;
             break;
-          case 6:
-            _context3.prev = 6;
-            _t5 = _context3["catch"](1);
-            if (!(_this3._state === _constants.StreamState.CANCELLED)) {
-              _context3.next = 7;
-              break;
+          case 14:
+            // No producer, just end when pulled
+            if (_this4.pullCredit > 0) {
+              _this4.endInternal();
             }
-            throw _t5;
-          case 7:
-            if (_this3._state === _constants.StreamState.STREAMING) {
-              _this3.error(_t5.message || String(_t5));
+          case 15:
+            _context4.next = 17;
+            break;
+          case 16:
+            _context4.prev = 16;
+            _t2 = _context4["catch"](2);
+            if (_this4._state === _constants.StreamState.STREAMING) {
+              _this4.error((_t2 === null || _t2 === void 0 ? void 0 : _t2.message) || String(_t2));
             }
-          case 8:
+          case 17:
+            _context4.prev = 17;
+            _this4.pumping = false;
+            return _context4.finish(17);
+          case 18:
           case "end":
-            return _context3.stop();
+            return _context4.stop();
         }
-      }, _callee3, null, [[1, 6]]);
+      }, _callee4, null, [[2, 16, 17, 18]]);
     }))();
   }
 
   /**
    * Send data chunk
    */
-  sendData(data, done = false) {
-    this.sendMessage(_constants.MessageType.STREAM_DATA, {
-      data: this.encodeData(data),
+  sendData(data, done = false, options) {
+    var _this$context$serverI2, _options$requestId;
+    if (!this.context) {
+      throw new Error(_constants.Messages.STREAM_NOT_BOUND);
+    }
+    var seq = this.seq++;
+    var isClientStream = this.context.clientId !== undefined && this.context.serverId === undefined;
+    var role = isClientStream ? _constants.MessageRole.CLIENT : _constants.MessageRole.SERVER;
+    var creatorId = (_this$context$serverI2 = this.context.serverId) !== null && _this$context$serverI2 !== void 0 ? _this$context$serverI2 : this.context.clientId;
+    var message = (0, _utils.createPostMessage)(_constants.MessageType.STREAM_DATA, (_options$requestId = options === null || options === void 0 ? void 0 : options.requestId) !== null && _options$requestId !== void 0 ? _options$requestId : this.context.requestId, {
+      secretKey: this.context.secretKey,
+      requireAck: options === null || options === void 0 ? void 0 : options.requireAck,
+      /**
+       * When per-frame requireAck is enabled, include a unique identifier in ack.
+       * - seq is the stream frame sequence number.
+       *
+       * NOTE: ack is an internal reserved field (not part of public API).
+       */
+      ack: options !== null && options !== void 0 && options.requireAck ? {
+        id: `${this.streamId}:${seq}`
+      } : undefined,
+      body: {
+        streamId: this.streamId,
+        data: this.encodeData(data),
+        done,
+        seq
+      },
+      role,
+      creatorId,
+      targetId: this.context.targetId
+    });
+    var ok = this.context.channel.send(this.context.targetWindow, message, this.context.targetOrigin);
+    if (!ok) {
+      this._state = _constants.StreamState.CANCELLED;
+      this.clearExpireTimer();
+      throw new Error((0, _constants.formatMessage)(_constants.Messages.STREAM_CANCELLED, 'Target window closed'));
+    }
+    this.emit(_constants.StreamEvent.SEND, {
+      seq,
       done
     });
   }
+  flush() {
+    if (this._state !== _constants.StreamState.STREAMING) return;
+
+    // First try to pump from generator if needed
+    if (this.mode === _constants.StreamMode.PULL && this.pendingQueue.length === 0) {
+      void this.pumpFromGenerator();
+    }
+    while (this.pullCredit > 0 && this.pendingQueue.length > 0 && this._state === _constants.StreamState.STREAMING) {
+      var item = this.pendingQueue.shift();
+      this.pendingBytes -= item.bytes;
+      this.pullCredit--;
+      try {
+        if (item.requireAck && item.ackRequestId && item.resolveAck) {
+          this.ensureAckReceiver();
+          if (this.ackReceiverRegistered) {
+            var _item$ackTimeout;
+            this.registerAckWaiter(item.ackRequestId, (_item$ackTimeout = item.ackTimeout) !== null && _item$ackTimeout !== void 0 ? _item$ackTimeout : _constants.DefaultTimeout.ACK, item.resolveAck);
+            this.sendData(item.data, item.done, {
+              requestId: item.ackRequestId,
+              requireAck: true
+            });
+          } else {
+            item.resolveAck(false);
+            this.sendData(item.data, item.done);
+          }
+        } else {
+          this.sendData(item.data, item.done);
+        }
+      } catch (e) {
+        var _this$rejectCompletio;
+        // send failure treated as cancellation
+        this._state = _constants.StreamState.CANCELLED;
+        this.clearExpireTimer();
+        this.clearIdleTimer();
+        this.unregisterControlHandler();
+        this.pendingQueue.length = 0;
+        this.pendingBytes = 0;
+        this.cleanupAckWaiters();
+        (_this$rejectCompletio = this.rejectCompletion) === null || _this$rejectCompletio === void 0 || _this$rejectCompletio.call(this, e instanceof Error ? e : new Error(String(e)));
+        throw e;
+      }
+      if (item.done) {
+        this.endInternal();
+        break;
+      }
+    }
+  }
 
   /**
    * Encode data (subclasses can override, e.g., FileStream needs Base64 encoding)
@@ -356,38 +755,89 @@ class IframeWritableStream {
   /**
    * End stream
    */
-  end() {
+  endInternal() {
+    var _this$resolveCompleti;
     if (this._state !== _constants.StreamState.STREAMING) return;
     this._state = _constants.StreamState.ENDED;
+    this.clearExpireTimer();
+    this.clearIdleTimer();
+    this.unregisterControlHandler();
+    this.pendingQueue.length = 0;
+    this.pendingBytes = 0;
     this.sendMessage(_constants.MessageType.STREAM_END);
+    this.emit(_constants.StreamEvent.END);
+    this.emit(_constants.StreamEvent.STATE, {
+      state: this._state
+    });
+    this.cleanupAckWaiters();
+    this.clearAllListeners();
+    (_this$resolveCompleti = this.resolveCompletion) === null || _this$resolveCompleti === void 0 || _this$resolveCompleti.call(this);
   }
 
   /**
    * Send error
    */
   error(message) {
+    var _this$resolveCompleti2;
     if (this._state !== _constants.StreamState.STREAMING) return;
     this._state = _constants.StreamState.ERROR;
+    this.clearExpireTimer();
+    this.clearIdleTimer();
+    this.unregisterControlHandler();
+    this.pendingQueue.length = 0;
+    this.pendingBytes = 0;
     this.sendMessage(_constants.MessageType.STREAM_ERROR, {
       error: message
     });
+    this.emit(_constants.StreamEvent.ERROR, {
+      error: new Error(message)
+    });
+    this.emit(_constants.StreamEvent.STATE, {
+      state: this._state
+    });
+    this.cleanupAckWaiters();
+    this.clearAllListeners();
+    (_this$resolveCompleti2 = this.resolveCompletion) === null || _this$resolveCompleti2 === void 0 || _this$resolveCompleti2.call(this);
+  }
+
+  /**
+   * Abort stream transfer (is alias of cancel method)
+   */
+  abort(reason) {
+    this.cancel(reason);
   }
 
   /**
    * Cancel stream transfer
    */
   cancel(reason) {
+    var _this$resolveCompleti3;
     if (this._state !== _constants.StreamState.PENDING && this._state !== _constants.StreamState.STREAMING) return;
     this._state = _constants.StreamState.CANCELLED;
+    this.clearExpireTimer();
+    this.clearIdleTimer();
+    this.unregisterControlHandler();
+    this.pendingQueue.length = 0;
+    this.pendingBytes = 0;
+    this.emit(_constants.StreamEvent.CANCEL, {
+      reason,
+      remote: false
+    });
+    this.emit(_constants.StreamEvent.STATE, {
+      state: this._state
+    });
     if (this.context) {
       try {
         this.sendMessage(_constants.MessageType.STREAM_CANCEL, {
           reason
         });
-      } catch (_unused) {
+      } catch (_unused8) {
         // ignore send failures on cancel
       }
     }
+    this.cleanupAckWaiters();
+    this.clearAllListeners();
+    (_this$resolveCompleti3 = this.resolveCompletion) === null || _this$resolveCompleti3 === void 0 || _this$resolveCompleti3.call(this);
   }
 }
 exports.IframeWritableStream = IframeWritableStream;