request-iframe 0.0.6 → 0.1.0

package/library/stream/writable-stream.js

@@ -11,19 +11,15 @@ 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.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.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
  */
@@ -35,23 +31,38 @@ function generateStreamId() {
  * IframeWritableStream - Server-side writable stream
  * Used to send stream data to the client
  */
-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, "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);
+    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;
   }
 
   /** Get stream state */
   get state() {
-    return this._state;
+    return super.state;
   }
 
   /**
@@ -61,6 +72,117 @@ 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;
+          // Try flushing buffered chunks or pumping generator
+          this.flush();
+          break;
+        }
+      case _constants.StreamInternalMessageType.ACK:
+        // Ack is treated as heartbeat; no further action required
+        break;
+      case _constants.StreamInternalMessageType.CANCEL:
+        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.error((0, _constants.formatMessage)(_constants.Messages.STREAM_TIMEOUT, timeout));
+            } catch (_unused) {
+              /** 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,254 +207,277 @@ 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;
   }
+  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.error((0, _constants.formatMessage)(_constants.Messages.STREAM_EXPIRED, expireTimeout));
+      } catch (_unused2) {
+        /** 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;
+            _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, done = false) {
+    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);
+    }
+    // push mode now buffers and sends based on pull credit
+    this.pendingQueue.push({
+      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.pendingQueue.push({
+          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;
-              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;
+            gen = _this4.iterator();
+          case 3:
+            if (!(_this4._state === _constants.StreamState.STREAMING)) {
+              _context4.next = 7;
               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;
+            if (!(_this4.pullCredit <= 0)) {
+              _context4.next = 4;
               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.pendingQueue.push({
+              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.pendingQueue.push({
+              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]]);
     }))();
   }
 
@@ -342,9 +487,38 @@ class IframeWritableStream {
   sendData(data, done = false) {
     this.sendMessage(_constants.MessageType.STREAM_DATA, {
       data: this.encodeData(data),
-      done
+      done,
+      seq: this.seq++
     });
   }
+  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.pullCredit--;
+      try {
+        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$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 +530,60 @@ 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.sendMessage(_constants.MessageType.STREAM_END);
+    (_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.sendMessage(_constants.MessageType.STREAM_ERROR, {
       error: message
     });
+    (_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();
     if (this.context) {
       try {
         this.sendMessage(_constants.MessageType.STREAM_CANCEL, {
           reason
         });
-      } catch (_unused) {
+      } catch (_unused3) {
         // ignore send failures on cancel
       }
     }
+    (_this$resolveCompleti3 = this.resolveCompletion) === null || _this$resolveCompleti3 === void 0 || _this$resolveCompleti3.call(this);
   }
 }
 exports.IframeWritableStream = IframeWritableStream;