@electric-sql/client 1.0.3 → 1.0.5

package/dist/index.mjs

@@ -267,6 +267,12 @@ function isControlMessage(message) {
 function isUpToDateMessage(message) {
   return isControlMessage(message) && message.headers.control === `up-to-date`;
 }
+function getOffset(message) {
+  const lsn = Number(message.headers.global_last_seen_lsn);
+  if (lsn && !isNaN(lsn)) {
+    return `${lsn}_0`;
+  }
+}
 
 // src/constants.ts
 var LIVE_CACHE_BUSTER_HEADER = `electric-cursor`;
@@ -283,7 +289,9 @@ var TABLE_QUERY_PARAM = `table`;
 var WHERE_QUERY_PARAM = `where`;
 var REPLICA_PARAM = `replica`;
 var WHERE_PARAMS_PARAM = `params`;
+var EXPERIMENTAL_LIVE_SSE_QUERY_PARAM = `experimental_live_sse`;
 var FORCE_DISCONNECT_AND_REFRESH = `force-disconnect-and-refresh`;
+var PAUSE_STREAM = `pause-stream`;
 
 // src/fetch.ts
 var HTTP_RETRY_STATUS_CODES = [429];
@@ -292,7 +300,7 @@ var BackoffDefaults = {
   maxDelay: 1e4,
   multiplier: 1.3
 };
-function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
+function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults, sseMode = false) {
   const {
     initialDelay,
     maxDelay,
@@ -310,7 +318,11 @@ function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
       try {
         const result = yield fetchClient(...args);
         if (result.ok) return result;
-        else throw yield FetchError.fromResponse(result, url.toString());
+        const err = yield FetchError.fromResponse(result, url.toString());
+        if (err.status === 409 && sseMode) {
+          err.json = [err.json];
+        }
+        throw err;
       } catch (e) {
         onFailedAttempt == null ? void 0 : onFailedAttempt();
         if ((_a = options == null ? void 0 : options.signal) == null ? void 0 : _a.aborted) {
@@ -508,6 +520,9 @@ function noop() {
 }
 
 // src/client.ts
+import {
+  fetchEventSource
+} from "@microsoft/fetch-event-source";
 var RESERVED_PARAMS = /* @__PURE__ */ new Set([
   LIVE_CACHE_BUSTER_QUERY_PARAM,
   SHAPE_HANDLE_QUERY_PARAM,
@@ -552,15 +567,18 @@ function resolveHeaders(headers) {
     return Object.fromEntries(resolvedEntries);
   });
 }
-var _error, _fetchClient2, _messageParser, _subscribers, _started, _lastOffset, _liveCacheBuster, _lastSyncedAt, _isUpToDate, _connected, _shapeHandle, _schema, _onError, _requestAbortController, _isRefreshing, _tickPromise, _tickPromiseResolver, _tickPromiseRejecter, _ShapeStream_instances, start_fn, nextTick_fn, publish_fn, sendErrorToSubscribers_fn, reset_fn;
+var _error, _fetchClient2, _sseFetchClient, _messageParser, _subscribers, _started, _state, _lastOffset, _liveCacheBuster, _lastSyncedAt, _isUpToDate, _connected, _shapeHandle, _schema, _onError, _requestAbortController, _isRefreshing, _tickPromise, _tickPromiseResolver, _tickPromiseRejecter, _messageChain, _ShapeStream_instances, start_fn, requestShape_fn, constructUrl_fn, createAbortListener_fn, onInitialResponse_fn, onMessages_fn, fetchShape_fn, requestShapeLongPoll_fn, requestShapeSSE_fn, pause_fn, resume_fn, nextTick_fn, publish_fn, sendErrorToSubscribers_fn, subscribeToVisibilityChanges_fn, reset_fn;
 var ShapeStream = class {
+  // promise chain for incoming messages
   constructor(options) {
     __privateAdd(this, _ShapeStream_instances);
     __privateAdd(this, _error, null);
     __privateAdd(this, _fetchClient2);
+    __privateAdd(this, _sseFetchClient);
     __privateAdd(this, _messageParser);
     __privateAdd(this, _subscribers, /* @__PURE__ */ new Map());
     __privateAdd(this, _started, false);
+    __privateAdd(this, _state, `active`);
     __privateAdd(this, _lastOffset);
     __privateAdd(this, _liveCacheBuster);
     // Seconds since our Electric Epoch 😎
@@ -576,6 +594,7 @@ var ShapeStream = class {
     __privateAdd(this, _tickPromise);
     __privateAdd(this, _tickPromiseResolver);
     __privateAdd(this, _tickPromiseRejecter);
+    __privateAdd(this, _messageChain, Promise.resolve([]));
     var _a, _b, _c;
     this.options = __spreadValues({ subscribe: true }, options);
     validateOptions(this.options);
@@ -585,18 +604,31 @@ var ShapeStream = class {
     __privateSet(this, _messageParser, new MessageParser(options.parser));
     __privateSet(this, _onError, this.options.onError);
     const baseFetchClient = (_b = options.fetchClient) != null ? _b : (...args) => fetch(...args);
-    const fetchWithBackoffClient = createFetchWithBackoff(baseFetchClient, __spreadProps(__spreadValues({}, (_c = options.backoffOptions) != null ? _c : BackoffDefaults), {
+    const backOffOpts = __spreadProps(__spreadValues({}, (_c = options.backoffOptions) != null ? _c : BackoffDefaults), {
       onFailedAttempt: () => {
         var _a2, _b2;
         __privateSet(this, _connected, false);
         (_b2 = (_a2 = options.backoffOptions) == null ? void 0 : _a2.onFailedAttempt) == null ? void 0 : _b2.call(_a2);
       }
-    }));
+    });
+    const fetchWithBackoffClient = createFetchWithBackoff(
+      baseFetchClient,
+      backOffOpts
+    );
     __privateSet(this, _fetchClient2, createFetchWithConsumedMessages(
       createFetchWithResponseHeadersCheck(
         createFetchWithChunkBuffer(fetchWithBackoffClient)
       )
     ));
+    const sseFetchWithBackoffClient = createFetchWithBackoff(
+      baseFetchClient,
+      backOffOpts,
+      true
+    );
+    __privateSet(this, _sseFetchClient, createFetchWithResponseHeadersCheck(
+      createFetchWithChunkBuffer(sseFetchWithBackoffClient)
+    ));
+    __privateMethod(this, _ShapeStream_instances, subscribeToVisibilityChanges_fn).call(this);
   }
   get shapeHandle() {
     return __privateGet(this, _shapeHandle);
@@ -642,6 +674,9 @@ var ShapeStream = class {
   hasStarted() {
     return __privateGet(this, _started);
   }
+  isPaused() {
+    return __privateGet(this, _state) === `paused`;
+  }
   /**
    * Refreshes the shape stream.
    * This preemptively aborts any ongoing long poll and reconnects without
@@ -662,9 +697,11 @@ var ShapeStream = class {
 };
 _error = new WeakMap();
 _fetchClient2 = new WeakMap();
+_sseFetchClient = new WeakMap();
 _messageParser = new WeakMap();
 _subscribers = new WeakMap();
 _started = new WeakMap();
+_state = new WeakMap();
 _lastOffset = new WeakMap();
 _liveCacheBuster = new WeakMap();
 _lastSyncedAt = new WeakMap();
@@ -678,134 +715,14 @@ _isRefreshing = new WeakMap();
 _tickPromise = new WeakMap();
 _tickPromiseResolver = new WeakMap();
 _tickPromiseRejecter = new WeakMap();
+_messageChain = new WeakMap();
 _ShapeStream_instances = new WeakSet();
 start_fn = function() {
   return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e;
-    if (__privateGet(this, _started)) throw new Error(`Cannot start stream twice`);
+    var _a;
     __privateSet(this, _started, true);
     try {
-      while (!((_a = this.options.signal) == null ? void 0 : _a.aborted) && !__privateGet(this, _isUpToDate) || this.options.subscribe) {
-        const { url, signal } = this.options;
-        const [requestHeaders, params] = yield Promise.all([
-          resolveHeaders(this.options.headers),
-          this.options.params ? toInternalParams(convertWhereParamsToObj(this.options.params)) : void 0
-        ]);
-        if (params) {
-          validateParams(params);
-        }
-        const fetchUrl = new URL(url);
-        if (params) {
-          if (params.table)
-            setQueryParam(fetchUrl, TABLE_QUERY_PARAM, params.table);
-          if (params.where)
-            setQueryParam(fetchUrl, WHERE_QUERY_PARAM, params.where);
-          if (params.columns)
-            setQueryParam(fetchUrl, COLUMNS_QUERY_PARAM, params.columns);
-          if (params.replica)
-            setQueryParam(fetchUrl, REPLICA_PARAM, params.replica);
-          if (params.params)
-            setQueryParam(fetchUrl, WHERE_PARAMS_PARAM, params.params);
-          const customParams = __spreadValues({}, params);
-          delete customParams.table;
-          delete customParams.where;
-          delete customParams.columns;
-          delete customParams.replica;
-          delete customParams.params;
-          for (const [key, value] of Object.entries(customParams)) {
-            setQueryParam(fetchUrl, key, value);
-          }
-        }
-        fetchUrl.searchParams.set(OFFSET_QUERY_PARAM, __privateGet(this, _lastOffset));
-        if (__privateGet(this, _isUpToDate)) {
-          if (!__privateGet(this, _isRefreshing)) {
-            fetchUrl.searchParams.set(LIVE_QUERY_PARAM, `true`);
-          }
-          fetchUrl.searchParams.set(
-            LIVE_CACHE_BUSTER_QUERY_PARAM,
-            __privateGet(this, _liveCacheBuster)
-          );
-        }
-        if (__privateGet(this, _shapeHandle)) {
-          fetchUrl.searchParams.set(
-            SHAPE_HANDLE_QUERY_PARAM,
-            __privateGet(this, _shapeHandle)
-          );
-        }
-        fetchUrl.searchParams.sort();
-        __privateSet(this, _requestAbortController, new AbortController());
-        let abortListener;
-        if (signal) {
-          abortListener = () => {
-            var _a2;
-            (_a2 = __privateGet(this, _requestAbortController)) == null ? void 0 : _a2.abort(signal.reason);
-          };
-          signal.addEventListener(`abort`, abortListener, { once: true });
-          if (signal.aborted) {
-            (_b = __privateGet(this, _requestAbortController)) == null ? void 0 : _b.abort(signal.reason);
-          }
-        }
-        let response;
-        try {
-          response = yield __privateGet(this, _fetchClient2).call(this, fetchUrl.toString(), {
-            signal: __privateGet(this, _requestAbortController).signal,
-            headers: requestHeaders
-          });
-          __privateSet(this, _connected, true);
-        } catch (e) {
-          if ((e instanceof FetchError || e instanceof FetchBackoffAbortError) && __privateGet(this, _requestAbortController).signal.aborted && __privateGet(this, _requestAbortController).signal.reason === FORCE_DISCONNECT_AND_REFRESH) {
-            continue;
-          }
-          if (e instanceof FetchBackoffAbortError) break;
-          if (!(e instanceof FetchError)) throw e;
-          if (e.status == 409) {
-            const newShapeHandle = e.headers[SHAPE_HANDLE_HEADER];
-            __privateMethod(this, _ShapeStream_instances, reset_fn).call(this, newShapeHandle);
-            yield __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, e.json);
-            continue;
-          } else {
-            __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, e);
-            throw e;
-          }
-        } finally {
-          if (abortListener && signal) {
-            signal.removeEventListener(`abort`, abortListener);
-          }
-          __privateSet(this, _requestAbortController, void 0);
-        }
-        const { headers, status } = response;
-        const shapeHandle = headers.get(SHAPE_HANDLE_HEADER);
-        if (shapeHandle) {
-          __privateSet(this, _shapeHandle, shapeHandle);
-        }
-        const lastOffset = headers.get(CHUNK_LAST_OFFSET_HEADER);
-        if (lastOffset) {
-          __privateSet(this, _lastOffset, lastOffset);
-        }
-        const liveCacheBuster = headers.get(LIVE_CACHE_BUSTER_HEADER);
-        if (liveCacheBuster) {
-          __privateSet(this, _liveCacheBuster, liveCacheBuster);
-        }
-        const getSchema = () => {
-          const schemaHeader = headers.get(SHAPE_SCHEMA_HEADER);
-          return schemaHeader ? JSON.parse(schemaHeader) : {};
-        };
-        __privateSet(this, _schema, (_c = __privateGet(this, _schema)) != null ? _c : getSchema());
-        if (status === 204) {
-          __privateSet(this, _lastSyncedAt, Date.now());
-        }
-        const messages = (yield response.text()) || `[]`;
-        const batch = __privateGet(this, _messageParser).parse(messages, __privateGet(this, _schema));
-        if (batch.length > 0) {
-          const lastMessage = batch[batch.length - 1];
-          if (isUpToDateMessage(lastMessage)) {
-            __privateSet(this, _lastSyncedAt, Date.now());
-            __privateSet(this, _isUpToDate, true);
-          }
-          yield __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, batch);
-        }
-        (_d = __privateGet(this, _tickPromiseResolver)) == null ? void 0 : _d.call(this);
-      }
+      yield __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
     } catch (err) {
       __privateSet(this, _error, err);
       if (__privateGet(this, _onError)) {
@@ -826,10 +743,241 @@ start_fn = function() {
       throw err;
     } finally {
       __privateSet(this, _connected, false);
-      (_e = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _e.call(this);
+      (_a = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _a.call(this);
+    }
+  });
+};
+requestShape_fn = function() {
+  return __async(this, null, function* () {
+    var _a, _b;
+    if (__privateGet(this, _state) === `pause-requested`) {
+      __privateSet(this, _state, `paused`);
+      return;
+    }
+    if (!this.options.subscribe && (((_a = this.options.signal) == null ? void 0 : _a.aborted) || __privateGet(this, _isUpToDate))) {
+      return;
+    }
+    const resumingFromPause = __privateGet(this, _state) === `paused`;
+    __privateSet(this, _state, `active`);
+    const { url, signal } = this.options;
+    const { fetchUrl, requestHeaders } = yield __privateMethod(this, _ShapeStream_instances, constructUrl_fn).call(this, url, resumingFromPause);
+    const abortListener = yield __privateMethod(this, _ShapeStream_instances, createAbortListener_fn).call(this, signal);
+    const requestAbortController = __privateGet(this, _requestAbortController);
+    try {
+      yield __privateMethod(this, _ShapeStream_instances, fetchShape_fn).call(this, {
+        fetchUrl,
+        requestAbortController,
+        headers: requestHeaders,
+        resumingFromPause: true
+      });
+    } catch (e) {
+      if ((e instanceof FetchError || e instanceof FetchBackoffAbortError) && requestAbortController.signal.aborted && requestAbortController.signal.reason === FORCE_DISCONNECT_AND_REFRESH) {
+        return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
+      }
+      if (e instanceof FetchBackoffAbortError) {
+        if (requestAbortController.signal.aborted && requestAbortController.signal.reason === PAUSE_STREAM) {
+          __privateSet(this, _state, `paused`);
+        }
+        return;
+      }
+      if (!(e instanceof FetchError)) throw e;
+      if (e.status == 409) {
+        const newShapeHandle = e.headers[SHAPE_HANDLE_HEADER];
+        __privateMethod(this, _ShapeStream_instances, reset_fn).call(this, newShapeHandle);
+        yield __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, e.json);
+        return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
+      } else {
+        __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, e);
+        throw e;
+      }
+    } finally {
+      if (abortListener && signal) {
+        signal.removeEventListener(`abort`, abortListener);
+      }
+      __privateSet(this, _requestAbortController, void 0);
+    }
+    (_b = __privateGet(this, _tickPromiseResolver)) == null ? void 0 : _b.call(this);
+    return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
+  });
+};
+constructUrl_fn = function(url, resumingFromPause) {
+  return __async(this, null, function* () {
+    const [requestHeaders, params] = yield Promise.all([
+      resolveHeaders(this.options.headers),
+      this.options.params ? toInternalParams(convertWhereParamsToObj(this.options.params)) : void 0
+    ]);
+    if (params) {
+      validateParams(params);
+    }
+    const fetchUrl = new URL(url);
+    if (params) {
+      if (params.table) setQueryParam(fetchUrl, TABLE_QUERY_PARAM, params.table);
+      if (params.where) setQueryParam(fetchUrl, WHERE_QUERY_PARAM, params.where);
+      if (params.columns)
+        setQueryParam(fetchUrl, COLUMNS_QUERY_PARAM, params.columns);
+      if (params.replica) setQueryParam(fetchUrl, REPLICA_PARAM, params.replica);
+      if (params.params)
+        setQueryParam(fetchUrl, WHERE_PARAMS_PARAM, params.params);
+      const customParams = __spreadValues({}, params);
+      delete customParams.table;
+      delete customParams.where;
+      delete customParams.columns;
+      delete customParams.replica;
+      delete customParams.params;
+      for (const [key, value] of Object.entries(customParams)) {
+        setQueryParam(fetchUrl, key, value);
+      }
+    }
+    fetchUrl.searchParams.set(OFFSET_QUERY_PARAM, __privateGet(this, _lastOffset));
+    if (__privateGet(this, _isUpToDate)) {
+      if (!__privateGet(this, _isRefreshing) && !resumingFromPause) {
+        fetchUrl.searchParams.set(LIVE_QUERY_PARAM, `true`);
+      }
+      fetchUrl.searchParams.set(
+        LIVE_CACHE_BUSTER_QUERY_PARAM,
+        __privateGet(this, _liveCacheBuster)
+      );
+    }
+    if (__privateGet(this, _shapeHandle)) {
+      fetchUrl.searchParams.set(SHAPE_HANDLE_QUERY_PARAM, __privateGet(this, _shapeHandle));
+    }
+    fetchUrl.searchParams.sort();
+    return {
+      fetchUrl,
+      requestHeaders
+    };
+  });
+};
+createAbortListener_fn = function(signal) {
+  return __async(this, null, function* () {
+    var _a;
+    __privateSet(this, _requestAbortController, new AbortController());
+    if (signal) {
+      const abortListener = () => {
+        var _a2;
+        (_a2 = __privateGet(this, _requestAbortController)) == null ? void 0 : _a2.abort(signal.reason);
+      };
+      signal.addEventListener(`abort`, abortListener, { once: true });
+      if (signal.aborted) {
+        (_a = __privateGet(this, _requestAbortController)) == null ? void 0 : _a.abort(signal.reason);
+      }
+      return abortListener;
+    }
+  });
+};
+onInitialResponse_fn = function(response) {
+  return __async(this, null, function* () {
+    var _a;
+    const { headers, status } = response;
+    const shapeHandle = headers.get(SHAPE_HANDLE_HEADER);
+    if (shapeHandle) {
+      __privateSet(this, _shapeHandle, shapeHandle);
+    }
+    const lastOffset = headers.get(CHUNK_LAST_OFFSET_HEADER);
+    if (lastOffset) {
+      __privateSet(this, _lastOffset, lastOffset);
+    }
+    const liveCacheBuster = headers.get(LIVE_CACHE_BUSTER_HEADER);
+    if (liveCacheBuster) {
+      __privateSet(this, _liveCacheBuster, liveCacheBuster);
+    }
+    const getSchema = () => {
+      const schemaHeader = headers.get(SHAPE_SCHEMA_HEADER);
+      return schemaHeader ? JSON.parse(schemaHeader) : {};
+    };
+    __privateSet(this, _schema, (_a = __privateGet(this, _schema)) != null ? _a : getSchema());
+    if (status === 204) {
+      __privateSet(this, _lastSyncedAt, Date.now());
+    }
+  });
+};
+onMessages_fn = function(messages, schema, isSseMessage = false) {
+  return __async(this, null, function* () {
+    const batch = __privateGet(this, _messageParser).parse(messages, schema);
+    if (batch.length > 0) {
+      const lastMessage = batch[batch.length - 1];
+      if (isUpToDateMessage(lastMessage)) {
+        if (isSseMessage) {
+          const offset = getOffset(lastMessage);
+          if (offset) {
+            __privateSet(this, _lastOffset, offset);
+          }
+        }
+        __privateSet(this, _lastSyncedAt, Date.now());
+        __privateSet(this, _isUpToDate, true);
+      }
+      yield __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, batch);
+    }
+  });
+};
+fetchShape_fn = function(opts) {
+  return __async(this, null, function* () {
+    if (__privateGet(this, _isUpToDate) && this.options.experimentalLiveSse && !__privateGet(this, _isRefreshing) && !opts.resumingFromPause) {
+      opts.fetchUrl.searchParams.set(EXPERIMENTAL_LIVE_SSE_QUERY_PARAM, `true`);
+      return __privateMethod(this, _ShapeStream_instances, requestShapeSSE_fn).call(this, opts);
+    }
+    return __privateMethod(this, _ShapeStream_instances, requestShapeLongPoll_fn).call(this, opts);
+  });
+};
+requestShapeLongPoll_fn = function(opts) {
+  return __async(this, null, function* () {
+    const { fetchUrl, requestAbortController, headers } = opts;
+    const response = yield __privateGet(this, _fetchClient2).call(this, fetchUrl.toString(), {
+      signal: requestAbortController.signal,
+      headers
+    });
+    __privateSet(this, _connected, true);
+    yield __privateMethod(this, _ShapeStream_instances, onInitialResponse_fn).call(this, response);
+    const schema = __privateGet(this, _schema);
+    const res = yield response.text();
+    const messages = res || `[]`;
+    yield __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, messages, schema);
+  });
+};
+requestShapeSSE_fn = function(opts) {
+  return __async(this, null, function* () {
+    const { fetchUrl, requestAbortController, headers } = opts;
+    const fetch2 = __privateGet(this, _sseFetchClient);
+    try {
+      yield fetchEventSource(fetchUrl.toString(), {
+        headers,
+        fetch: fetch2,
+        onopen: (response) => __async(this, null, function* () {
+          __privateSet(this, _connected, true);
+          yield __privateMethod(this, _ShapeStream_instances, onInitialResponse_fn).call(this, response);
+        }),
+        onmessage: (event) => {
+          if (event.data) {
+            const messages = `[${event.data}]`;
+            const schema = __privateGet(this, _schema);
+            __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, messages, schema, true);
+          }
+        },
+        onerror: (error) => {
+          throw error;
+        },
+        signal: requestAbortController.signal
+      });
+    } catch (error) {
+      if (requestAbortController.signal.aborted) {
+        throw new FetchBackoffAbortError();
+      }
+      throw error;
     }
   });
 };
+pause_fn = function() {
+  var _a;
+  if (__privateGet(this, _started) && __privateGet(this, _state) === `active`) {
+    __privateSet(this, _state, `pause-requested`);
+    (_a = __privateGet(this, _requestAbortController)) == null ? void 0 : _a.abort(PAUSE_STREAM);
+  }
+};
+resume_fn = function() {
+  if (__privateGet(this, _started) && __privateGet(this, _state) === `paused`) {
+    __privateMethod(this, _ShapeStream_instances, start_fn).call(this);
+  }
+};
 nextTick_fn = function() {
   return __async(this, null, function* () {
     if (__privateGet(this, _tickPromise)) {
@@ -849,17 +997,20 @@ nextTick_fn = function() {
 };
 publish_fn = function(messages) {
   return __async(this, null, function* () {
-    yield Promise.all(
-      Array.from(__privateGet(this, _subscribers).values()).map((_0) => __async(this, [_0], function* ([callback, __]) {
-        try {
-          yield callback(messages);
-        } catch (err) {
-          queueMicrotask(() => {
-            throw err;
-          });
-        }
-      }))
-    );
+    __privateSet(this, _messageChain, __privateGet(this, _messageChain).then(
+      () => Promise.all(
+        Array.from(__privateGet(this, _subscribers).values()).map((_0) => __async(this, [_0], function* ([callback, __]) {
+          try {
+            yield callback(messages);
+          } catch (err) {
+            queueMicrotask(() => {
+              throw err;
+            });
+          }
+        }))
+      )
+    ));
+    return __privateGet(this, _messageChain);
   });
 };
 sendErrorToSubscribers_fn = function(error) {
@@ -867,6 +1018,18 @@ sendErrorToSubscribers_fn = function(error) {
     errorFn == null ? void 0 : errorFn(error);
   });
 };
+subscribeToVisibilityChanges_fn = function() {
+  if (typeof document === `object` && typeof document.hidden === `boolean` && typeof document.addEventListener === `function`) {
+    const visibilityHandler = () => {
+      if (document.hidden) {
+        __privateMethod(this, _ShapeStream_instances, pause_fn).call(this);
+      } else {
+        __privateMethod(this, _ShapeStream_instances, resume_fn).call(this);
+      }
+    };
+    document.addEventListener(`visibilitychange`, visibilityHandler);
+  }
+};
 /**
  * Resets the state of the stream, optionally with a provided
  * shape handle