@electric-sql/client 1.2.1 → 1.3.0

package/dist/index.mjs

@@ -45,26 +45,6 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     return __privateGet(obj, member, getter);
   }
 });
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 
 // src/error.ts
 var FetchError = class _FetchError extends Error {
@@ -79,22 +59,20 @@ var FetchError = class _FetchError extends Error {
     this.json = json;
     this.headers = headers;
   }
-  static fromResponse(response, url) {
-    return __async(this, null, function* () {
-      const status = response.status;
-      const headers = Object.fromEntries([...response.headers.entries()]);
-      let text = void 0;
-      let json = void 0;
-      const contentType = response.headers.get(`content-type`);
-      if (!response.bodyUsed) {
-        if (contentType && contentType.includes(`application/json`)) {
-          json = yield response.json();
-        } else {
-          text = yield response.text();
-        }
+  static async fromResponse(response, url) {
+    const status = response.status;
+    const headers = Object.fromEntries([...response.headers.entries()]);
+    let text = void 0;
+    let json = void 0;
+    const contentType = response.headers.get(`content-type`);
+    if (!response.bodyUsed) {
+      if (contentType && contentType.includes(`application/json`)) {
+        json = await response.json();
+      } else {
+        text = await response.text();
       }
-      return new _FetchError(status, text, json, headers, url);
-    });
+    }
+    return new _FetchError(status, text, json, headers, url);
   }
 };
 var FetchBackoffAbortError = class extends Error {
@@ -292,6 +270,10 @@ function makeNullableParser(parser, columnInfo, columnName) {
 }
 
 // src/column-mapper.ts
+function quoteIdentifier(identifier) {
+  const escaped = identifier.replace(/"/g, `""`);
+  return `"${escaped}"`;
+}
 function snakeToCamel(str) {
   var _a, _b, _c, _d;
   const leadingUnderscores = (_b = (_a = str.match(/^_+/)) == null ? void 0 : _a[0]) != null ? _b : ``;
@@ -447,11 +429,9 @@ function isUpToDateMessage(message) {
   return isControlMessage(message) && message.headers.control === `up-to-date`;
 }
 function getOffset(message) {
+  if (message.headers.control != `up-to-date`) return;
   const lsn = message.headers.global_last_seen_lsn;
-  if (!lsn) {
-    return;
-  }
-  return `${lsn}_0`;
+  return lsn ? `${lsn}_0` : void 0;
 }
 function isVisibleInSnapshot(txid, snapshot) {
   const xid = BigInt(txid);
@@ -534,7 +514,7 @@ function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
     onFailedAttempt,
     maxRetries = Infinity
   } = backoffOptions;
-  return (...args) => __async(this, null, function* () {
+  return async (...args) => {
     var _a;
     const url = args[0];
     const options = args[1];
@@ -542,11 +522,11 @@ function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
     let attempt = 0;
     while (true) {
       try {
-        const result = yield fetchClient(...args);
+        const result = await fetchClient(...args);
         if (result.ok) {
           return result;
         }
-        const err = yield FetchError.fromResponse(result, url.toString());
+        const err = await FetchError.fromResponse(result, url.toString());
         throw err;
       } catch (e) {
         onFailedAttempt == null ? void 0 : onFailedAttempt();
@@ -574,24 +554,24 @@ function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
               `Retry attempt #${attempt} after ${waitMs}ms (${source}, serverMin=${serverMinimumMs}ms, clientBackoff=${clientBackoffMs}ms)`
             );
           }
-          yield new Promise((resolve) => setTimeout(resolve, waitMs));
+          await new Promise((resolve) => setTimeout(resolve, waitMs));
           delay = Math.min(delay * multiplier, maxDelay);
         }
       }
     }
-  });
+  };
 }
 var NO_BODY_STATUS_CODES = [201, 204, 205];
 function createFetchWithConsumedMessages(fetchClient) {
-  return (...args) => __async(this, null, function* () {
+  return async (...args) => {
     var _a, _b;
     const url = args[0];
-    const res = yield fetchClient(...args);
+    const res = await fetchClient(...args);
     try {
       if (res.status < 200 || NO_BODY_STATUS_CODES.includes(res.status)) {
         return res;
       }
-      const text = yield res.text();
+      const text = await res.text();
       return new Response(text, res);
     } catch (err) {
       if ((_b = (_a = args[1]) == null ? void 0 : _a.signal) == null ? void 0 : _b.aborted) {
@@ -606,7 +586,7 @@ function createFetchWithConsumedMessages(fetchClient) {
         err instanceof Error ? err.message : typeof err === `string` ? err : `failed to read body`
       );
     }
-  });
+  };
 }
 var ChunkPrefetchDefaults = {
   maxChunksToPrefetch: 2
@@ -614,14 +594,15 @@ var ChunkPrefetchDefaults = {
 function createFetchWithChunkBuffer(fetchClient, prefetchOptions = ChunkPrefetchDefaults) {
   const { maxChunksToPrefetch } = prefetchOptions;
   let prefetchQueue;
-  const prefetchClient = (...args) => __async(this, null, function* () {
+  const prefetchClient = async (...args) => {
     const url = args[0].toString();
     const prefetchedRequest = prefetchQueue == null ? void 0 : prefetchQueue.consume(...args);
     if (prefetchedRequest) {
       return prefetchedRequest;
     }
     prefetchQueue == null ? void 0 : prefetchQueue.abort();
-    const response = yield fetchClient(...args);
+    prefetchQueue = void 0;
+    const response = await fetchClient(...args);
     const nextUrl = getNextChunkUrl(url, response);
     if (nextUrl) {
       prefetchQueue = new PrefetchQueue({
@@ -632,7 +613,7 @@ function createFetchWithChunkBuffer(fetchClient, prefetchOptions = ChunkPrefetch
       });
     }
     return response;
-  });
+  };
   return prefetchClient;
 }
 var requiredElectricResponseHeaders = [
@@ -642,8 +623,8 @@ var requiredElectricResponseHeaders = [
 var requiredLiveResponseHeaders = [`electric-cursor`];
 var requiredNonLiveResponseHeaders = [`electric-schema`];
 function createFetchWithResponseHeadersCheck(fetchClient) {
-  return (...args) => __async(this, null, function* () {
-    const response = yield fetchClient(...args);
+  return async (...args) => {
+    const response = await fetchClient(...args);
     if (response.ok) {
       const headers = response.headers;
       const missingHeaders = [];
@@ -673,7 +654,7 @@ function createFetchWithResponseHeadersCheck(fetchClient) {
       }
     }
     return response;
-  });
+  };
 }
 var _fetchClient, _maxPrefetchedRequests, _prefetchQueue, _queueHeadUrl, _queueTailUrl, _PrefetchQueue_instances, prefetch_fn;
 var PrefetchQueue = class {
@@ -693,12 +674,17 @@ var PrefetchQueue = class {
   }
   abort() {
     __privateGet(this, _prefetchQueue).forEach(([_, aborter]) => aborter.abort());
+    __privateGet(this, _prefetchQueue).clear();
   }
   consume(...args) {
-    var _a;
     const url = args[0].toString();
-    const request = (_a = __privateGet(this, _prefetchQueue).get(url)) == null ? void 0 : _a[0];
-    if (!request || url !== __privateGet(this, _queueHeadUrl)) return;
+    const entry = __privateGet(this, _prefetchQueue).get(url);
+    if (!entry || url !== __privateGet(this, _queueHeadUrl)) return;
+    const [request, aborter] = entry;
+    if (aborter.signal.aborted) {
+      __privateGet(this, _prefetchQueue).delete(url);
+      return;
+    }
     __privateGet(this, _prefetchQueue).delete(url);
     request.then((response) => {
       const nextUrl = getNextChunkUrl(url, response);
@@ -1021,43 +1007,35 @@ var RESERVED_PARAMS = /* @__PURE__ */ new Set([
   LIVE_QUERY_PARAM,
   OFFSET_QUERY_PARAM
 ]);
-function resolveValue(value) {
-  return __async(this, null, function* () {
-    if (typeof value === `function`) {
-      return value();
-    }
-    return value;
-  });
+async function resolveValue(value) {
+  if (typeof value === `function`) {
+    return value();
+  }
+  return value;
 }
-function toInternalParams(params) {
-  return __async(this, null, function* () {
-    const entries = Object.entries(params);
-    const resolvedEntries = yield Promise.all(
-      entries.map((_0) => __async(this, [_0], function* ([key, value]) {
-        if (value === void 0) return [key, void 0];
-        const resolvedValue = yield resolveValue(value);
-        return [
-          key,
-          Array.isArray(resolvedValue) ? resolvedValue.join(`,`) : resolvedValue
-        ];
-      }))
-    );
-    return Object.fromEntries(
-      resolvedEntries.filter(([_, value]) => value !== void 0)
-    );
-  });
+async function toInternalParams(params) {
+  const entries = Object.entries(params);
+  const resolvedEntries = await Promise.all(
+    entries.map(async ([key, value]) => {
+      if (value === void 0) return [key, void 0];
+      const resolvedValue = await resolveValue(value);
+      return [
+        key,
+        Array.isArray(resolvedValue) ? resolvedValue.join(`,`) : resolvedValue
+      ];
+    })
+  );
+  return Object.fromEntries(
+    resolvedEntries.filter(([_, value]) => value !== void 0)
+  );
 }
-function resolveHeaders(headers) {
-  return __async(this, null, function* () {
-    if (!headers) return {};
-    const entries = Object.entries(headers);
-    const resolvedEntries = yield Promise.all(
-      entries.map((_0) => __async(this, [_0], function* ([key, value]) {
-        return [key, yield resolveValue(value)];
-      }))
-    );
-    return Object.fromEntries(resolvedEntries);
-  });
+async function resolveHeaders(headers) {
+  if (!headers) return {};
+  const entries = Object.entries(headers);
+  const resolvedEntries = await Promise.all(
+    entries.map(async ([key, value]) => [key, await resolveValue(value)])
+  );
+  return Object.fromEntries(resolvedEntries);
 }
 function canonicalShapeKey(url) {
   const cleanUrl = new URL(url.origin + url.pathname);
@@ -1219,16 +1197,14 @@ var ShapeStream = class {
    * long polling, ensuring that the stream receives an up to date message with the
    * latest LSN from Postgres at that point in time.
    */
-  forceDisconnectAndRefresh() {
-    return __async(this, null, function* () {
-      var _a, _b;
-      __privateSet(this, _isRefreshing, true);
-      if (__privateGet(this, _isUpToDate) && !((_a = __privateGet(this, _requestAbortController)) == null ? void 0 : _a.signal.aborted)) {
-        (_b = __privateGet(this, _requestAbortController)) == null ? void 0 : _b.abort(FORCE_DISCONNECT_AND_REFRESH);
-      }
-      yield __privateMethod(this, _ShapeStream_instances, nextTick_fn).call(this);
-      __privateSet(this, _isRefreshing, false);
-    });
+  async forceDisconnectAndRefresh() {
+    var _a, _b;
+    __privateSet(this, _isRefreshing, true);
+    if (__privateGet(this, _isUpToDate) && !((_a = __privateGet(this, _requestAbortController)) == null ? void 0 : _a.signal.aborted)) {
+      (_b = __privateGet(this, _requestAbortController)) == null ? void 0 : _b.abort(FORCE_DISCONNECT_AND_REFRESH);
+    }
+    await __privateMethod(this, _ShapeStream_instances, nextTick_fn).call(this);
+    __privateSet(this, _isRefreshing, false);
   }
   /**
    * Request a snapshot for subset of data and inject it into the subscribed data stream.
@@ -1244,40 +1220,39 @@ var ShapeStream = class {
    * @param opts - The options for the snapshot request.
    * @returns The metadata and the data for the snapshot.
    */
-  requestSnapshot(opts) {
-    return __async(this, null, function* () {
-      if (__privateGet(this, _mode) === `full`) {
-        throw new Error(
-          `Snapshot requests are not supported in ${__privateGet(this, _mode)} mode, as the consumer is guaranteed to observe all data`
-        );
+  async requestSnapshot(opts) {
+    if (__privateGet(this, _mode) === `full`) {
+      throw new Error(
+        `Snapshot requests are not supported in ${__privateGet(this, _mode)} mode, as the consumer is guaranteed to observe all data`
+      );
+    }
+    if (!__privateGet(this, _started)) await __privateMethod(this, _ShapeStream_instances, start_fn).call(this);
+    await __privateMethod(this, _ShapeStream_instances, waitForStreamEnd_fn).call(this);
+    __privateWrapper(this, _activeSnapshotRequests)._++;
+    try {
+      if (__privateGet(this, _activeSnapshotRequests) === 1) {
+        __privateMethod(this, _ShapeStream_instances, pause_fn).call(this);
       }
-      if (!__privateGet(this, _started)) yield __privateMethod(this, _ShapeStream_instances, start_fn).call(this);
-      yield __privateMethod(this, _ShapeStream_instances, waitForStreamEnd_fn).call(this);
-      __privateWrapper(this, _activeSnapshotRequests)._++;
-      try {
-        if (__privateGet(this, _activeSnapshotRequests) === 1) {
-          __privateMethod(this, _ShapeStream_instances, pause_fn).call(this);
-        }
-        const { metadata, data } = yield this.fetchSnapshot(opts);
-        const dataWithEndBoundary = data.concat([
-          { headers: __spreadValues({ control: `snapshot-end` }, metadata) }
-        ]);
-        __privateGet(this, _snapshotTracker).addSnapshot(
-          metadata,
-          new Set(data.map((message) => message.key))
-        );
-        __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, dataWithEndBoundary, false);
-        return {
-          metadata,
-          data
-        };
-      } finally {
-        __privateWrapper(this, _activeSnapshotRequests)._--;
-        if (__privateGet(this, _activeSnapshotRequests) === 0) {
-          __privateMethod(this, _ShapeStream_instances, resume_fn).call(this);
-        }
+      const { metadata, data } = await this.fetchSnapshot(opts);
+      const dataWithEndBoundary = data.concat([
+        { headers: __spreadValues({ control: `snapshot-end` }, metadata) },
+        { headers: __spreadValues({ control: `subset-end` }, opts) }
+      ]);
+      __privateGet(this, _snapshotTracker).addSnapshot(
+        metadata,
+        new Set(data.map((message) => message.key))
+      );
+      __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, dataWithEndBoundary, false);
+      return {
+        metadata,
+        data
+      };
+    } finally {
+      __privateWrapper(this, _activeSnapshotRequests)._--;
+      if (__privateGet(this, _activeSnapshotRequests) === 0) {
+        __privateMethod(this, _ShapeStream_instances, resume_fn).call(this);
       }
-    });
+    }
   }
   /**
    * Fetch a snapshot for subset of data.
@@ -1286,36 +1261,34 @@ var ShapeStream = class {
    * @param opts - The options for the snapshot request.
    * @returns The metadata and the data for the snapshot.
    */
-  fetchSnapshot(opts) {
-    return __async(this, null, function* () {
-      var _a;
-      const { fetchUrl, requestHeaders } = yield __privateMethod(this, _ShapeStream_instances, constructUrl_fn).call(this, this.options.url, true, opts);
-      const response = yield __privateGet(this, _fetchClient2).call(this, fetchUrl.toString(), {
-        headers: requestHeaders
-      });
-      if (!response.ok) {
-        throw new FetchError(
-          response.status,
-          void 0,
-          void 0,
-          Object.fromEntries([...response.headers.entries()]),
-          fetchUrl.toString()
-        );
-      }
-      const schema = (_a = __privateGet(this, _schema)) != null ? _a : getSchemaFromHeaders(response.headers, {
-        required: true,
-        url: fetchUrl.toString()
-      });
-      const { metadata, data: rawData } = yield response.json();
-      const data = __privateGet(this, _messageParser).parseSnapshotData(
-        rawData,
-        schema
+  async fetchSnapshot(opts) {
+    var _a;
+    const { fetchUrl, requestHeaders } = await __privateMethod(this, _ShapeStream_instances, constructUrl_fn).call(this, this.options.url, true, opts);
+    const response = await __privateGet(this, _fetchClient2).call(this, fetchUrl.toString(), {
+      headers: requestHeaders
+    });
+    if (!response.ok) {
+      throw new FetchError(
+        response.status,
+        void 0,
+        void 0,
+        Object.fromEntries([...response.headers.entries()]),
+        fetchUrl.toString()
       );
-      return {
-        metadata,
-        data
-      };
+    }
+    const schema = (_a = __privateGet(this, _schema)) != null ? _a : getSchemaFromHeaders(response.headers, {
+      required: true,
+      url: fetchUrl.toString()
     });
+    const { metadata, data: rawData } = await response.json();
+    const data = __privateGet(this, _messageParser).parseSnapshotData(
+      rawData,
+      schema
+    );
+    return {
+      metadata,
+      data
+    };
   }
 };
 _error = new WeakMap();
@@ -1359,366 +1332,361 @@ _ShapeStream_instances = new WeakSet();
 replayMode_get = function() {
   return __privateGet(this, _lastSeenCursor) !== void 0;
 };
-start_fn = function() {
-  return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e;
-    __privateSet(this, _started, true);
-    try {
-      yield __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
-    } catch (err) {
-      __privateSet(this, _error, err);
-      if (__privateGet(this, _onError)) {
-        const retryOpts = yield __privateGet(this, _onError).call(this, err);
-        if (retryOpts && typeof retryOpts === `object`) {
-          if (retryOpts.params) {
-            this.options.params = __spreadValues(__spreadValues({}, (_a = this.options.params) != null ? _a : {}), retryOpts.params);
-          }
-          if (retryOpts.headers) {
-            this.options.headers = __spreadValues(__spreadValues({}, (_b = this.options.headers) != null ? _b : {}), retryOpts.headers);
-          }
-          __privateSet(this, _error, null);
-          __privateSet(this, _started, false);
-          yield __privateMethod(this, _ShapeStream_instances, start_fn).call(this);
-          return;
+start_fn = async function() {
+  var _a, _b, _c, _d, _e;
+  __privateSet(this, _started, true);
+  try {
+    await __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
+  } catch (err) {
+    __privateSet(this, _error, err);
+    if (__privateGet(this, _onError)) {
+      const retryOpts = await __privateGet(this, _onError).call(this, err);
+      if (retryOpts && typeof retryOpts === `object`) {
+        if (retryOpts.params) {
+          this.options.params = __spreadValues(__spreadValues({}, (_a = this.options.params) != null ? _a : {}), retryOpts.params);
         }
-        if (err instanceof Error) {
-          __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, err);
+        if (retryOpts.headers) {
+          this.options.headers = __spreadValues(__spreadValues({}, (_b = this.options.headers) != null ? _b : {}), retryOpts.headers);
         }
-        __privateSet(this, _connected, false);
-        (_c = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _c.call(this);
+        __privateSet(this, _error, null);
+        __privateSet(this, _started, false);
+        await __privateMethod(this, _ShapeStream_instances, start_fn).call(this);
         return;
       }
       if (err instanceof Error) {
         __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, err);
       }
       __privateSet(this, _connected, false);
-      (_d = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _d.call(this);
-      throw err;
+      (_c = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _c.call(this);
+      return;
+    }
+    if (err instanceof Error) {
+      __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, err);
     }
     __privateSet(this, _connected, false);
-    (_e = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _e.call(this);
-  });
+    (_d = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _d.call(this);
+    throw err;
+  }
+  __privateSet(this, _connected, false);
+  (_e = __privateGet(this, _tickPromiseRejecter)) == null ? void 0 : _e.call(this);
 };
-requestShape_fn = function() {
-  return __async(this, null, function* () {
-    var _a, _b;
-    if (__privateGet(this, _state) === `pause-requested`) {
-      __privateSet(this, _state, `paused`);
-      return;
+requestShape_fn = async 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 } = await __privateMethod(this, _ShapeStream_instances, constructUrl_fn).call(this, url, resumingFromPause);
+  const abortListener = await __privateMethod(this, _ShapeStream_instances, createAbortListener_fn).call(this, signal);
+  const requestAbortController = __privateGet(this, _requestAbortController);
+  try {
+    await __privateMethod(this, _ShapeStream_instances, fetchShape_fn).call(this, {
+      fetchUrl,
+      requestAbortController,
+      headers: requestHeaders,
+      resumingFromPause
+    });
+  } 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 (!this.options.subscribe && (((_a = this.options.signal) == null ? void 0 : _a.aborted) || __privateGet(this, _isUpToDate))) {
+    if (e instanceof FetchBackoffAbortError) {
+      const currentState = __privateGet(this, _state);
+      if (requestAbortController.signal.aborted && requestAbortController.signal.reason === PAUSE_STREAM && currentState === `pause-requested`) {
+        __privateSet(this, _state, `paused`);
+      }
       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
-      });
-    } 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 FetchError)) throw e;
+    if (e.status == 409) {
+      if (__privateGet(this, _shapeHandle)) {
+        const shapeKey = canonicalShapeKey(fetchUrl);
+        expiredShapesCache.markExpired(shapeKey, __privateGet(this, _shapeHandle));
       }
-      if (e instanceof FetchBackoffAbortError) {
-        const currentState = __privateGet(this, _state);
-        if (requestAbortController.signal.aborted && requestAbortController.signal.reason === PAUSE_STREAM && currentState === `pause-requested`) {
-          __privateSet(this, _state, `paused`);
-        }
-        return;
-      }
-      if (!(e instanceof FetchError)) throw e;
-      if (e.status == 409) {
-        if (__privateGet(this, _shapeHandle)) {
-          const shapeKey = canonicalShapeKey(fetchUrl);
-          expiredShapesCache.markExpired(shapeKey, __privateGet(this, _shapeHandle));
-        }
-        const newShapeHandle = e.headers[SHAPE_HANDLE_HEADER] || `${__privateGet(this, _shapeHandle)}-next`;
-        __privateMethod(this, _ShapeStream_instances, reset_fn).call(this, newShapeHandle);
-        yield __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, Array.isArray(e.json) ? e.json : [e.json]);
-        return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
-      } else {
-        throw e;
-      }
-    } finally {
-      if (abortListener && signal) {
-        signal.removeEventListener(`abort`, abortListener);
-      }
-      __privateSet(this, _requestAbortController, void 0);
+      const newShapeHandle = e.headers[SHAPE_HANDLE_HEADER] || `${__privateGet(this, _shapeHandle)}-next`;
+      __privateMethod(this, _ShapeStream_instances, reset_fn).call(this, newShapeHandle);
+      await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, Array.isArray(e.json) ? e.json : [e.json]);
+      return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
+    } else {
+      throw e;
     }
-    (_b = __privateGet(this, _tickPromiseResolver)) == null ? void 0 : _b.call(this);
-    return __privateMethod(this, _ShapeStream_instances, requestShape_fn).call(this);
-  });
+  } 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, subsetParams) {
-  return __async(this, null, function* () {
-    var _a, _b, _c;
-    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 && typeof params.where === `string`) {
-        const encodedWhere = encodeWhereClause(
-          params.where,
-          (_a = this.options.columnMapper) == null ? void 0 : _a.encode
-        );
-        setQueryParam(fetchUrl, WHERE_QUERY_PARAM, encodedWhere);
-      }
-      if (params.columns)
+constructUrl_fn = async function(url, resumingFromPause, subsetParams) {
+  var _a, _b, _c, _d;
+  const [requestHeaders, params] = await 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 && typeof params.where === `string`) {
+      const encodedWhere = encodeWhereClause(
+        params.where,
+        (_a = this.options.columnMapper) == null ? void 0 : _a.encode
+      );
+      setQueryParam(fetchUrl, WHERE_QUERY_PARAM, encodedWhere);
+    }
+    if (params.columns) {
+      const originalColumns = await resolveValue((_b = this.options.params) == null ? void 0 : _b.columns);
+      if (Array.isArray(originalColumns)) {
+        let encodedColumns = originalColumns.map(String);
+        if (this.options.columnMapper) {
+          encodedColumns = encodedColumns.map(
+            this.options.columnMapper.encode
+          );
+        }
+        const serializedColumns = encodedColumns.map(quoteIdentifier).join(`,`);
+        setQueryParam(fetchUrl, COLUMNS_QUERY_PARAM, serializedColumns);
+      } else {
         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);
       }
     }
-    if (subsetParams) {
-      if (subsetParams.where && typeof subsetParams.where === `string`) {
-        const encodedWhere = encodeWhereClause(
-          subsetParams.where,
-          (_b = this.options.columnMapper) == null ? void 0 : _b.encode
-        );
-        setQueryParam(fetchUrl, SUBSET_PARAM_WHERE, encodedWhere);
-      }
-      if (subsetParams.params)
-        fetchUrl.searchParams.set(
-          SUBSET_PARAM_WHERE_PARAMS,
-          JSON.stringify(subsetParams.params)
-        );
-      if (subsetParams.limit)
-        setQueryParam(fetchUrl, SUBSET_PARAM_LIMIT, subsetParams.limit);
-      if (subsetParams.offset)
-        setQueryParam(fetchUrl, SUBSET_PARAM_OFFSET, subsetParams.offset);
-      if (subsetParams.orderBy && typeof subsetParams.orderBy === `string`) {
-        const encodedOrderBy = encodeWhereClause(
-          subsetParams.orderBy,
-          (_c = this.options.columnMapper) == null ? void 0 : _c.encode
-        );
-        setQueryParam(fetchUrl, SUBSET_PARAM_ORDER_BY, encodedOrderBy);
-      }
+    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));
-    fetchUrl.searchParams.set(LOG_MODE_QUERY_PARAM, __privateGet(this, _mode));
-    const isSnapshotRequest = subsetParams !== void 0;
-    if (__privateGet(this, _isUpToDate) && !isSnapshotRequest) {
-      if (!__privateGet(this, _isRefreshing) && !resumingFromPause) {
-        fetchUrl.searchParams.set(LIVE_QUERY_PARAM, `true`);
-      }
-      fetchUrl.searchParams.set(
-        LIVE_CACHE_BUSTER_QUERY_PARAM,
-        __privateGet(this, _liveCacheBuster)
+  }
+  if (subsetParams) {
+    if (subsetParams.where && typeof subsetParams.where === `string`) {
+      const encodedWhere = encodeWhereClause(
+        subsetParams.where,
+        (_c = this.options.columnMapper) == null ? void 0 : _c.encode
       );
+      setQueryParam(fetchUrl, SUBSET_PARAM_WHERE, encodedWhere);
     }
-    if (__privateGet(this, _shapeHandle)) {
-      fetchUrl.searchParams.set(SHAPE_HANDLE_QUERY_PARAM, __privateGet(this, _shapeHandle));
+    if (subsetParams.params)
+      fetchUrl.searchParams.set(
+        SUBSET_PARAM_WHERE_PARAMS,
+        JSON.stringify(subsetParams.params)
+      );
+    if (subsetParams.limit)
+      setQueryParam(fetchUrl, SUBSET_PARAM_LIMIT, subsetParams.limit);
+    if (subsetParams.offset)
+      setQueryParam(fetchUrl, SUBSET_PARAM_OFFSET, subsetParams.offset);
+    if (subsetParams.orderBy && typeof subsetParams.orderBy === `string`) {
+      const encodedOrderBy = encodeWhereClause(
+        subsetParams.orderBy,
+        (_d = this.options.columnMapper) == null ? void 0 : _d.encode
+      );
+      setQueryParam(fetchUrl, SUBSET_PARAM_ORDER_BY, encodedOrderBy);
     }
-    const shapeKey = canonicalShapeKey(fetchUrl);
-    const expiredHandle = expiredShapesCache.getExpiredHandle(shapeKey);
-    if (expiredHandle) {
-      fetchUrl.searchParams.set(EXPIRED_HANDLE_QUERY_PARAM, expiredHandle);
+  }
+  fetchUrl.searchParams.set(OFFSET_QUERY_PARAM, __privateGet(this, _lastOffset));
+  fetchUrl.searchParams.set(LOG_MODE_QUERY_PARAM, __privateGet(this, _mode));
+  const isSnapshotRequest = subsetParams !== void 0;
+  if (__privateGet(this, _isUpToDate) && !isSnapshotRequest) {
+    if (!__privateGet(this, _isRefreshing) && !resumingFromPause) {
+      fetchUrl.searchParams.set(LIVE_QUERY_PARAM, `true`);
     }
-    fetchUrl.searchParams.sort();
-    return {
-      fetchUrl,
-      requestHeaders
-    };
-  });
+    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));
+  }
+  const shapeKey = canonicalShapeKey(fetchUrl);
+  const expiredHandle = expiredShapesCache.getExpiredHandle(shapeKey);
+  if (expiredHandle) {
+    fetchUrl.searchParams.set(EXPIRED_HANDLE_QUERY_PARAM, expiredHandle);
+  }
+  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;
+createAbortListener_fn = async function(signal) {
+  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);
-    }
-    __privateSet(this, _schema, (_a = __privateGet(this, _schema)) != null ? _a : getSchemaFromHeaders(headers));
-    if (status === 204) {
-      __privateSet(this, _lastSyncedAt, Date.now());
-    }
-  });
+onInitialResponse_fn = async function(response) {
+  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);
+  }
+  __privateSet(this, _schema, (_a = __privateGet(this, _schema)) != null ? _a : getSchemaFromHeaders(headers));
+  if (status === 204) {
+    __privateSet(this, _lastSyncedAt, Date.now());
+  }
 };
-onMessages_fn = function(batch, isSseMessage = false) {
-  return __async(this, null, function* () {
-    var _a;
-    if (batch.length > 0) {
-      __privateSet(this, _isMidStream, true);
-      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);
-        __privateSet(this, _isMidStream, false);
-        (_a = __privateGet(this, _midStreamPromiseResolver)) == null ? void 0 : _a.call(this);
-        if (__privateGet(this, _ShapeStream_instances, replayMode_get) && !isSseMessage) {
-          const currentCursor = __privateGet(this, _liveCacheBuster);
-          if (currentCursor === __privateGet(this, _lastSeenCursor)) {
-            return;
-          }
-        }
-        __privateSet(this, _lastSeenCursor, void 0);
-        if (__privateGet(this, _currentFetchUrl)) {
-          const shapeKey = canonicalShapeKey(__privateGet(this, _currentFetchUrl));
-          upToDateTracker.recordUpToDate(shapeKey, __privateGet(this, _liveCacheBuster));
+onMessages_fn = async function(batch, isSseMessage = false) {
+  var _a;
+  if (batch.length > 0) {
+    __privateSet(this, _isMidStream, true);
+    const lastMessage = batch[batch.length - 1];
+    if (isUpToDateMessage(lastMessage)) {
+      if (isSseMessage) {
+        const offset = getOffset(lastMessage);
+        if (offset) {
+          __privateSet(this, _lastOffset, offset);
         }
       }
-      const messagesToProcess = batch.filter((message) => {
-        if (isChangeMessage(message)) {
-          return !__privateGet(this, _snapshotTracker).shouldRejectMessage(message);
+      __privateSet(this, _lastSyncedAt, Date.now());
+      __privateSet(this, _isUpToDate, true);
+      __privateSet(this, _isMidStream, false);
+      (_a = __privateGet(this, _midStreamPromiseResolver)) == null ? void 0 : _a.call(this);
+      if (__privateGet(this, _ShapeStream_instances, replayMode_get) && !isSseMessage) {
+        const currentCursor = __privateGet(this, _liveCacheBuster);
+        if (currentCursor === __privateGet(this, _lastSeenCursor)) {
+          return;
         }
-        return true;
-      });
-      yield __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, messagesToProcess);
-    }
-  });
-};
-fetchShape_fn = function(opts) {
-  return __async(this, null, function* () {
-    var _a;
-    __privateSet(this, _currentFetchUrl, opts.fetchUrl);
-    if (!__privateGet(this, _isUpToDate) && !__privateGet(this, _ShapeStream_instances, replayMode_get)) {
-      const shapeKey = canonicalShapeKey(opts.fetchUrl);
-      const lastSeenCursor = upToDateTracker.shouldEnterReplayMode(shapeKey);
-      if (lastSeenCursor) {
-        __privateSet(this, _lastSeenCursor, lastSeenCursor);
+      }
+      __privateSet(this, _lastSeenCursor, void 0);
+      if (__privateGet(this, _currentFetchUrl)) {
+        const shapeKey = canonicalShapeKey(__privateGet(this, _currentFetchUrl));
+        upToDateTracker.recordUpToDate(shapeKey, __privateGet(this, _liveCacheBuster));
       }
     }
-    const useSse = (_a = this.options.liveSse) != null ? _a : this.options.experimentalLiveSse;
-    if (__privateGet(this, _isUpToDate) && useSse && !__privateGet(this, _isRefreshing) && !opts.resumingFromPause && !__privateGet(this, _sseFallbackToLongPolling)) {
-      opts.fetchUrl.searchParams.set(EXPERIMENTAL_LIVE_SSE_QUERY_PARAM, `true`);
-      opts.fetchUrl.searchParams.set(LIVE_SSE_QUERY_PARAM, `true`);
-      return __privateMethod(this, _ShapeStream_instances, requestShapeSSE_fn).call(this, opts);
+    const messagesToProcess = batch.filter((message) => {
+      if (isChangeMessage(message)) {
+        return !__privateGet(this, _snapshotTracker).shouldRejectMessage(message);
+      }
+      return true;
+    });
+    await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, messagesToProcess);
+  }
+};
+fetchShape_fn = async function(opts) {
+  var _a;
+  __privateSet(this, _currentFetchUrl, opts.fetchUrl);
+  if (!__privateGet(this, _isUpToDate) && !__privateGet(this, _ShapeStream_instances, replayMode_get)) {
+    const shapeKey = canonicalShapeKey(opts.fetchUrl);
+    const lastSeenCursor = upToDateTracker.shouldEnterReplayMode(shapeKey);
+    if (lastSeenCursor) {
+      __privateSet(this, _lastSeenCursor, lastSeenCursor);
     }
-    return __privateMethod(this, _ShapeStream_instances, requestShapeLongPoll_fn).call(this, opts);
-  });
+  }
+  const useSse = (_a = this.options.liveSse) != null ? _a : this.options.experimentalLiveSse;
+  if (__privateGet(this, _isUpToDate) && useSse && !__privateGet(this, _isRefreshing) && !opts.resumingFromPause && !__privateGet(this, _sseFallbackToLongPolling)) {
+    opts.fetchUrl.searchParams.set(EXPERIMENTAL_LIVE_SSE_QUERY_PARAM, `true`);
+    opts.fetchUrl.searchParams.set(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 || `[]`;
-    const batch = __privateGet(this, _messageParser).parse(messages, schema);
-    yield __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, batch);
+requestShapeLongPoll_fn = async function(opts) {
+  const { fetchUrl, requestAbortController, headers } = opts;
+  const response = await __privateGet(this, _fetchClient2).call(this, fetchUrl.toString(), {
+    signal: requestAbortController.signal,
+    headers
   });
+  __privateSet(this, _connected, true);
+  await __privateMethod(this, _ShapeStream_instances, onInitialResponse_fn).call(this, response);
+  const schema = __privateGet(this, _schema);
+  const res = await response.text();
+  const messages = res || `[]`;
+  const batch = __privateGet(this, _messageParser).parse(messages, schema);
+  await __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, batch);
 };
-requestShapeSSE_fn = function(opts) {
-  return __async(this, null, function* () {
-    const { fetchUrl, requestAbortController, headers } = opts;
-    const fetch2 = __privateGet(this, _sseFetchClient);
-    __privateSet(this, _lastSseConnectionStartTime, Date.now());
-    const sseHeaders = __spreadProps(__spreadValues({}, headers), {
-      Accept: `text/event-stream`
-    });
-    try {
-      let buffer = [];
-      yield fetchEventSource(fetchUrl.toString(), {
-        headers: sseHeaders,
-        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 schema = __privateGet(this, _schema);
-            const message = __privateGet(this, _messageParser).parse(
-              event.data,
-              schema
-            );
-            buffer.push(message);
-            if (isUpToDateMessage(message)) {
-              __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, buffer, true);
-              buffer = [];
-            }
-          }
-        },
-        onerror: (error) => {
-          throw error;
-        },
-        signal: requestAbortController.signal
-      });
-    } catch (error) {
-      if (requestAbortController.signal.aborted) {
-        throw new FetchBackoffAbortError();
-      }
-      throw error;
-    } finally {
-      const connectionDuration = Date.now() - __privateGet(this, _lastSseConnectionStartTime);
-      const wasAborted = requestAbortController.signal.aborted;
-      if (connectionDuration < __privateGet(this, _minSseConnectionDuration) && !wasAborted) {
-        __privateWrapper(this, _consecutiveShortSseConnections)._++;
-        if (__privateGet(this, _consecutiveShortSseConnections) >= __privateGet(this, _maxShortSseConnections)) {
-          __privateSet(this, _sseFallbackToLongPolling, true);
-          console.warn(
-            `[Electric] SSE connections are closing immediately (possibly due to proxy buffering or misconfiguration). Falling back to long polling. Your proxy must support streaming SSE responses (not buffer the complete response). Configuration: Nginx add 'X-Accel-Buffering: no', Caddy add 'flush_interval -1' to reverse_proxy. Note: Do NOT disable caching entirely - Electric uses cache headers to enable request collapsing for efficiency.`
-          );
-        } else {
-          const maxDelay = Math.min(
-            __privateGet(this, _sseBackoffMaxDelay),
-            __privateGet(this, _sseBackoffBaseDelay) * Math.pow(2, __privateGet(this, _consecutiveShortSseConnections))
+requestShapeSSE_fn = async function(opts) {
+  const { fetchUrl, requestAbortController, headers } = opts;
+  const fetch2 = __privateGet(this, _sseFetchClient);
+  __privateSet(this, _lastSseConnectionStartTime, Date.now());
+  const sseHeaders = __spreadProps(__spreadValues({}, headers), {
+    Accept: `text/event-stream`
+  });
+  try {
+    let buffer = [];
+    await fetchEventSource(fetchUrl.toString(), {
+      headers: sseHeaders,
+      fetch: fetch2,
+      onopen: async (response) => {
+        __privateSet(this, _connected, true);
+        await __privateMethod(this, _ShapeStream_instances, onInitialResponse_fn).call(this, response);
+      },
+      onmessage: (event) => {
+        if (event.data) {
+          const schema = __privateGet(this, _schema);
+          const message = __privateGet(this, _messageParser).parse(
+            event.data,
+            schema
           );
-          const delayMs = Math.floor(Math.random() * maxDelay);
-          yield new Promise((resolve) => setTimeout(resolve, delayMs));
+          buffer.push(message);
+          if (isUpToDateMessage(message)) {
+            __privateMethod(this, _ShapeStream_instances, onMessages_fn).call(this, buffer, true);
+            buffer = [];
+          }
         }
-      } else if (connectionDuration >= __privateGet(this, _minSseConnectionDuration)) {
-        __privateSet(this, _consecutiveShortSseConnections, 0);
+      },
+      onerror: (error) => {
+        throw error;
+      },
+      signal: requestAbortController.signal
+    });
+  } catch (error) {
+    if (requestAbortController.signal.aborted) {
+      throw new FetchBackoffAbortError();
+    }
+    throw error;
+  } finally {
+    const connectionDuration = Date.now() - __privateGet(this, _lastSseConnectionStartTime);
+    const wasAborted = requestAbortController.signal.aborted;
+    if (connectionDuration < __privateGet(this, _minSseConnectionDuration) && !wasAborted) {
+      __privateWrapper(this, _consecutiveShortSseConnections)._++;
+      if (__privateGet(this, _consecutiveShortSseConnections) >= __privateGet(this, _maxShortSseConnections)) {
+        __privateSet(this, _sseFallbackToLongPolling, true);
+        console.warn(
+          `[Electric] SSE connections are closing immediately (possibly due to proxy buffering or misconfiguration). Falling back to long polling. Your proxy must support streaming SSE responses (not buffer the complete response). Configuration: Nginx add 'X-Accel-Buffering: no', Caddy add 'flush_interval -1' to reverse_proxy. Note: Do NOT disable caching entirely - Electric uses cache headers to enable request collapsing for efficiency.`
+        );
+      } else {
+        const maxDelay = Math.min(
+          __privateGet(this, _sseBackoffMaxDelay),
+          __privateGet(this, _sseBackoffBaseDelay) * Math.pow(2, __privateGet(this, _consecutiveShortSseConnections))
+        );
+        const delayMs = Math.floor(Math.random() * maxDelay);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
       }
+    } else if (connectionDuration >= __privateGet(this, _minSseConnectionDuration)) {
+      __privateSet(this, _consecutiveShortSseConnections, 0);
     }
-  });
+  }
 };
 pause_fn = function() {
   var _a;
@@ -1728,65 +1696,63 @@ pause_fn = function() {
   }
 };
 resume_fn = function() {
+  var _a;
   if (__privateGet(this, _started) && (__privateGet(this, _state) === `paused` || __privateGet(this, _state) === `pause-requested`)) {
+    if ((_a = this.options.signal) == null ? void 0 : _a.aborted) {
+      return;
+    }
     if (__privateGet(this, _state) === `pause-requested`) {
       __privateSet(this, _state, `active`);
     }
     __privateMethod(this, _ShapeStream_instances, start_fn).call(this);
   }
 };
-nextTick_fn = function() {
-  return __async(this, null, function* () {
-    if (__privateGet(this, _tickPromise)) {
-      return __privateGet(this, _tickPromise);
-    }
-    __privateSet(this, _tickPromise, new Promise((resolve, reject) => {
-      __privateSet(this, _tickPromiseResolver, resolve);
-      __privateSet(this, _tickPromiseRejecter, reject);
-    }));
-    __privateGet(this, _tickPromise).finally(() => {
-      __privateSet(this, _tickPromise, void 0);
-      __privateSet(this, _tickPromiseResolver, void 0);
-      __privateSet(this, _tickPromiseRejecter, void 0);
-    });
+nextTick_fn = async function() {
+  if (__privateGet(this, _tickPromise)) {
     return __privateGet(this, _tickPromise);
+  }
+  __privateSet(this, _tickPromise, new Promise((resolve, reject) => {
+    __privateSet(this, _tickPromiseResolver, resolve);
+    __privateSet(this, _tickPromiseRejecter, reject);
+  }));
+  __privateGet(this, _tickPromise).finally(() => {
+    __privateSet(this, _tickPromise, void 0);
+    __privateSet(this, _tickPromiseResolver, void 0);
+    __privateSet(this, _tickPromiseRejecter, void 0);
   });
+  return __privateGet(this, _tickPromise);
 };
-waitForStreamEnd_fn = function() {
-  return __async(this, null, function* () {
-    if (!__privateGet(this, _isMidStream)) {
-      return;
-    }
-    if (__privateGet(this, _midStreamPromise)) {
-      return __privateGet(this, _midStreamPromise);
-    }
-    __privateSet(this, _midStreamPromise, new Promise((resolve) => {
-      __privateSet(this, _midStreamPromiseResolver, resolve);
-    }));
-    __privateGet(this, _midStreamPromise).finally(() => {
-      __privateSet(this, _midStreamPromise, void 0);
-      __privateSet(this, _midStreamPromiseResolver, void 0);
-    });
+waitForStreamEnd_fn = async function() {
+  if (!__privateGet(this, _isMidStream)) {
+    return;
+  }
+  if (__privateGet(this, _midStreamPromise)) {
     return __privateGet(this, _midStreamPromise);
+  }
+  __privateSet(this, _midStreamPromise, new Promise((resolve) => {
+    __privateSet(this, _midStreamPromiseResolver, resolve);
+  }));
+  __privateGet(this, _midStreamPromise).finally(() => {
+    __privateSet(this, _midStreamPromise, void 0);
+    __privateSet(this, _midStreamPromiseResolver, void 0);
   });
+  return __privateGet(this, _midStreamPromise);
 };
-publish_fn = function(messages) {
-  return __async(this, null, function* () {
-    __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);
-  });
+publish_fn = async function(messages) {
+  __privateSet(this, _messageChain, __privateGet(this, _messageChain).then(
+    () => Promise.all(
+      Array.from(__privateGet(this, _subscribers).values()).map(async ([callback, __]) => {
+        try {
+          await callback(messages);
+        } catch (err) {
+          queueMicrotask(() => {
+            throw err;
+          });
+        }
+      })
+    )
+  ));
+  return __privateGet(this, _messageChain);
 };
 sendErrorToSubscribers_fn = function(error) {
   __privateGet(this, _subscribers).forEach(([_, errorFn]) => {
@@ -1958,13 +1924,11 @@ var Shape = class {
    * Request a snapshot for subset of data. Only available when mode is changes_only.
    * Returns void; data will be emitted via the stream and processed by this Shape.
    */
-  requestSnapshot(params) {
-    return __async(this, null, function* () {
-      const key = JSON.stringify(params);
-      __privateGet(this, _requestedSubSnapshots).add(key);
-      yield __privateMethod(this, _Shape_instances, awaitUpToDate_fn).call(this);
-      yield this.stream.requestSnapshot(params);
-    });
+  async requestSnapshot(params) {
+    const key = JSON.stringify(params);
+    __privateGet(this, _requestedSubSnapshots).add(key);
+    await __privateMethod(this, _Shape_instances, awaitUpToDate_fn).call(this);
+    await this.stream.requestSnapshot(params);
   }
   subscribe(callback) {
     const subscriptionId = Math.random();
@@ -2046,38 +2010,34 @@ process_fn = function(messages) {
   });
   if (shouldNotify) __privateMethod(this, _Shape_instances, notify_fn).call(this);
 };
-reexecuteSnapshots_fn = function() {
-  return __async(this, null, function* () {
-    yield __privateMethod(this, _Shape_instances, awaitUpToDate_fn).call(this);
-    yield Promise.all(
-      Array.from(__privateGet(this, _requestedSubSnapshots)).map((jsonParams) => __async(this, null, function* () {
-        try {
-          const snapshot = JSON.parse(jsonParams);
-          yield this.stream.requestSnapshot(snapshot);
-        } catch (_) {
-        }
-      }))
-    );
-  });
+reexecuteSnapshots_fn = async function() {
+  await __privateMethod(this, _Shape_instances, awaitUpToDate_fn).call(this);
+  await Promise.all(
+    Array.from(__privateGet(this, _requestedSubSnapshots)).map(async (jsonParams) => {
+      try {
+        const snapshot = JSON.parse(jsonParams);
+        await this.stream.requestSnapshot(snapshot);
+      } catch (_) {
+      }
+    })
+  );
 };
-awaitUpToDate_fn = function() {
-  return __async(this, null, function* () {
-    if (this.stream.isUpToDate) return;
-    yield new Promise((resolve) => {
-      const check = () => {
-        if (this.stream.isUpToDate) {
-          clearInterval(interval);
-          unsub();
-          resolve();
-        }
-      };
-      const interval = setInterval(check, 10);
-      const unsub = this.stream.subscribe(
-        () => check(),
-        () => check()
-      );
-      check();
-    });
+awaitUpToDate_fn = async function() {
+  if (this.stream.isUpToDate) return;
+  await new Promise((resolve) => {
+    const check = () => {
+      if (this.stream.isUpToDate) {
+        clearInterval(interval);
+        unsub();
+        resolve();
+      }
+    };
+    const interval = setInterval(check, 10);
+    const unsub = this.stream.subscribe(
+      () => check(),
+      () => check()
+    );
+    check();
   });
 };
 updateShapeStatus_fn = function(status) {