@electric-sql/client 0.5.0 → 0.6.0

package/dist/index.legacy-esm.js

@@ -1,7 +1,12 @@
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -14,6 +19,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -26,6 +32,11 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/parser.ts
 var parseNumber = (value) => Number(value);
@@ -146,34 +157,11 @@ function isChangeMessage(message) {
 function isControlMessage(message) {
   return !isChangeMessage(message);
 }
+function isUpToDateMessage(message) {
+  return isControlMessage(message) && message.headers.control === `up-to-date`;
+}
 
-// src/client.ts
-var BackoffDefaults = {
-  initialDelay: 100,
-  maxDelay: 1e4,
-  multiplier: 1.3
-};
-var MessageProcessor = class {
-  constructor(callback) {
-    this.messageQueue = [];
-    this.isProcessing = false;
-    this.callback = callback;
-  }
-  process(messages) {
-    this.messageQueue.push(messages);
-    if (!this.isProcessing) {
-      this.processQueue();
-    }
-  }
-  async processQueue() {
-    this.isProcessing = true;
-    while (this.messageQueue.length > 0) {
-      const messages = this.messageQueue.shift();
-      await this.callback(messages);
-    }
-    this.isProcessing = false;
-  }
-};
+// src/error.ts
 var FetchError = class _FetchError extends Error {
   constructor(status, text, json, headers, url, message) {
     super(
@@ -200,320 +188,530 @@ var FetchError = class _FetchError extends Error {
     return new _FetchError(status, text, json, headers, url);
   }
 };
+var FetchBackoffAbortError = class extends Error {
+  constructor() {
+    super(`Fetch with backoff aborted`);
+  }
+};
+
+// src/constants.ts
+var SHAPE_ID_HEADER = `electric-shape-id`;
+var CHUNK_LAST_OFFSET_HEADER = `electric-chunk-last-offset`;
+var CHUNK_UP_TO_DATE_HEADER = `electric-chunk-up-to-date`;
+var SHAPE_SCHEMA_HEADER = `electric-schema`;
+var SHAPE_ID_QUERY_PARAM = `shape_id`;
+var OFFSET_QUERY_PARAM = `offset`;
+var WHERE_QUERY_PARAM = `where`;
+var LIVE_QUERY_PARAM = `live`;
+
+// src/fetch.ts
+var BackoffDefaults = {
+  initialDelay: 100,
+  maxDelay: 1e4,
+  multiplier: 1.3
+};
+function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
+  const {
+    initialDelay,
+    maxDelay,
+    multiplier,
+    debug = false,
+    onFailedAttempt
+  } = backoffOptions;
+  return async (...args) => {
+    var _a;
+    const url = args[0];
+    const options = args[1];
+    let delay = initialDelay;
+    let attempt = 0;
+    while (true) {
+      try {
+        const result = await fetchClient(...args);
+        if (result.ok) return result;
+        else throw await FetchError.fromResponse(result, url.toString());
+      } catch (e) {
+        onFailedAttempt == null ? void 0 : onFailedAttempt();
+        if ((_a = options == null ? void 0 : options.signal) == null ? void 0 : _a.aborted) {
+          throw new FetchBackoffAbortError();
+        } else if (e instanceof FetchError && e.status >= 400 && e.status < 500) {
+          throw e;
+        } else {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          delay = Math.min(delay * multiplier, maxDelay);
+          if (debug) {
+            attempt++;
+            console.log(`Retry attempt #${attempt} after ${delay}ms`);
+          }
+        }
+      }
+    }
+  };
+}
+var ChunkPrefetchDefaults = {
+  maxChunksToPrefetch: 2
+};
+function createFetchWithChunkBuffer(fetchClient, prefetchOptions = ChunkPrefetchDefaults) {
+  const { maxChunksToPrefetch } = prefetchOptions;
+  let prefetchQueue;
+  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 = await fetchClient(...args);
+    const nextUrl = getNextChunkUrl(url, response);
+    if (nextUrl) {
+      prefetchQueue = new PrefetchQueue({
+        fetchClient,
+        maxPrefetchedRequests: maxChunksToPrefetch,
+        url: nextUrl,
+        requestInit: args[1]
+      });
+    }
+    return response;
+  };
+  return prefetchClient;
+}
+var _fetchClient, _maxPrefetchedRequests, _prefetchQueue, _queueHeadUrl, _queueTailUrl, _PrefetchQueue_instances, prefetch_fn;
+var PrefetchQueue = class {
+  constructor(options) {
+    __privateAdd(this, _PrefetchQueue_instances);
+    __privateAdd(this, _fetchClient);
+    __privateAdd(this, _maxPrefetchedRequests);
+    __privateAdd(this, _prefetchQueue, /* @__PURE__ */ new Map());
+    __privateAdd(this, _queueHeadUrl);
+    __privateAdd(this, _queueTailUrl);
+    var _a;
+    __privateSet(this, _fetchClient, (_a = options.fetchClient) != null ? _a : (...args) => fetch(...args));
+    __privateSet(this, _maxPrefetchedRequests, options.maxPrefetchedRequests);
+    __privateSet(this, _queueHeadUrl, options.url.toString());
+    __privateSet(this, _queueTailUrl, __privateGet(this, _queueHeadUrl));
+    __privateMethod(this, _PrefetchQueue_instances, prefetch_fn).call(this, options.url, options.requestInit);
+  }
+  abort() {
+    __privateGet(this, _prefetchQueue).forEach(([_, aborter]) => aborter.abort());
+  }
+  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;
+    __privateGet(this, _prefetchQueue).delete(url);
+    request.then((response) => {
+      const nextUrl = getNextChunkUrl(url, response);
+      __privateSet(this, _queueHeadUrl, nextUrl);
+      if (!__privateGet(this, _prefetchQueue).has(__privateGet(this, _queueTailUrl))) {
+        __privateMethod(this, _PrefetchQueue_instances, prefetch_fn).call(this, __privateGet(this, _queueTailUrl), args[1]);
+      }
+    }).catch(() => {
+    });
+    return request;
+  }
+};
+_fetchClient = new WeakMap();
+_maxPrefetchedRequests = new WeakMap();
+_prefetchQueue = new WeakMap();
+_queueHeadUrl = new WeakMap();
+_queueTailUrl = new WeakMap();
+_PrefetchQueue_instances = new WeakSet();
+prefetch_fn = function(...args) {
+  var _a, _b;
+  const url = args[0].toString();
+  if (__privateGet(this, _prefetchQueue).size >= __privateGet(this, _maxPrefetchedRequests)) return;
+  const aborter = new AbortController();
+  try {
+    const request = __privateGet(this, _fetchClient).call(this, url, __spreadProps(__spreadValues({}, (_a = args[1]) != null ? _a : {}), {
+      signal: chainAborter(aborter, (_b = args[1]) == null ? void 0 : _b.signal)
+    }));
+    __privateGet(this, _prefetchQueue).set(url, [request, aborter]);
+    request.then((response) => {
+      if (!response.ok || aborter.signal.aborted) return;
+      const nextUrl = getNextChunkUrl(url, response);
+      if (!nextUrl || nextUrl === url) return;
+      __privateSet(this, _queueTailUrl, nextUrl);
+      return __privateMethod(this, _PrefetchQueue_instances, prefetch_fn).call(this, nextUrl, args[1]);
+    }).catch(() => {
+    });
+  } catch (_) {
+  }
+};
+function getNextChunkUrl(url, res) {
+  const shapeId = res.headers.get(SHAPE_ID_HEADER);
+  const lastOffset = res.headers.get(CHUNK_LAST_OFFSET_HEADER);
+  const isUpToDate = res.headers.has(CHUNK_UP_TO_DATE_HEADER);
+  if (!shapeId || !lastOffset || isUpToDate) return;
+  const nextUrl = new URL(url);
+  if (nextUrl.searchParams.has(LIVE_QUERY_PARAM)) return;
+  nextUrl.searchParams.set(SHAPE_ID_QUERY_PARAM, shapeId);
+  nextUrl.searchParams.set(OFFSET_QUERY_PARAM, lastOffset);
+  return nextUrl.toString();
+}
+function chainAborter(aborter, sourceSignal) {
+  if (!sourceSignal) return aborter.signal;
+  if (sourceSignal.aborted) aborter.abort();
+  else
+    sourceSignal.addEventListener(`abort`, () => aborter.abort(), {
+      once: true
+    });
+  return aborter.signal;
+}
+
+// src/client.ts
+var _fetchClient2, _messageParser, _subscribers, _upToDateSubscribers, _lastOffset, _lastSyncedAt, _isUpToDate, _connected, _shapeId, _schema, _ShapeStream_instances, publish_fn, sendErrorToSubscribers_fn, notifyUpToDateSubscribers_fn, sendErrorToUpToDateSubscribers_fn, reset_fn;
 var ShapeStream = class {
   constructor(options) {
-    this.subscribers = /* @__PURE__ */ new Map();
-    this.upToDateSubscribers = /* @__PURE__ */ new Map();
+    __privateAdd(this, _ShapeStream_instances);
+    __privateAdd(this, _fetchClient2);
+    __privateAdd(this, _messageParser);
+    __privateAdd(this, _subscribers, /* @__PURE__ */ new Map());
+    __privateAdd(this, _upToDateSubscribers, /* @__PURE__ */ new Map());
+    __privateAdd(this, _lastOffset);
+    __privateAdd(this, _lastSyncedAt);
     // unix time
-    this.isUpToDate = false;
-    this.connected = false;
+    __privateAdd(this, _isUpToDate, false);
+    __privateAdd(this, _connected, false);
+    __privateAdd(this, _shapeId);
+    __privateAdd(this, _schema);
     var _a, _b, _c;
-    this.validateOptions(options);
+    validateOptions(options);
     this.options = __spreadValues({ subscribe: true }, options);
-    this.lastOffset = (_a = this.options.offset) != null ? _a : `-1`;
-    this.shapeId = this.options.shapeId;
-    this.messageParser = new MessageParser(options.parser);
-    this.backoffOptions = (_b = options.backoffOptions) != null ? _b : BackoffDefaults;
-    this.fetchClient = (_c = options.fetchClient) != null ? _c : (...args) => fetch(...args);
+    __privateSet(this, _lastOffset, (_a = this.options.offset) != null ? _a : `-1`);
+    __privateSet(this, _shapeId, this.options.shapeId);
+    __privateSet(this, _messageParser, new MessageParser(options.parser));
+    const baseFetchClient = (_b = options.fetchClient) != null ? _b : (...args) => fetch(...args);
+    const fetchWithBackoffClient = createFetchWithBackoff(baseFetchClient, __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);
+      }
+    }));
+    __privateSet(this, _fetchClient2, createFetchWithChunkBuffer(fetchWithBackoffClient));
     this.start();
   }
+  get shapeId() {
+    return __privateGet(this, _shapeId);
+  }
+  get isUpToDate() {
+    return __privateGet(this, _isUpToDate);
+  }
   async start() {
     var _a;
-    this.isUpToDate = false;
+    __privateSet(this, _isUpToDate, false);
     const { url, where, signal } = this.options;
     try {
-      while (!(signal == null ? void 0 : signal.aborted) && !this.isUpToDate || this.options.subscribe) {
+      while (!(signal == null ? void 0 : signal.aborted) && !__privateGet(this, _isUpToDate) || this.options.subscribe) {
         const fetchUrl = new URL(url);
-        if (where) fetchUrl.searchParams.set(`where`, where);
-        fetchUrl.searchParams.set(`offset`, this.lastOffset);
-        if (this.isUpToDate) {
-          fetchUrl.searchParams.set(`live`, `true`);
+        if (where) fetchUrl.searchParams.set(WHERE_QUERY_PARAM, where);
+        fetchUrl.searchParams.set(OFFSET_QUERY_PARAM, __privateGet(this, _lastOffset));
+        if (__privateGet(this, _isUpToDate)) {
+          fetchUrl.searchParams.set(LIVE_QUERY_PARAM, `true`);
         }
-        if (this.shapeId) {
-          fetchUrl.searchParams.set(`shape_id`, this.shapeId);
+        if (__privateGet(this, _shapeId)) {
+          fetchUrl.searchParams.set(SHAPE_ID_QUERY_PARAM, __privateGet(this, _shapeId));
         }
         let response;
         try {
-          const maybeResponse = await this.fetchWithBackoff(fetchUrl);
-          if (maybeResponse) response = maybeResponse;
-          else break;
+          response = await __privateGet(this, _fetchClient2).call(this, fetchUrl.toString(), { signal });
+          __privateSet(this, _connected, true);
         } catch (e) {
+          if (e instanceof FetchBackoffAbortError) break;
           if (!(e instanceof FetchError)) throw e;
           if (e.status == 400) {
-            this.reset();
-            this.publish(e.json);
+            __privateMethod(this, _ShapeStream_instances, reset_fn).call(this);
+            await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, e.json);
             continue;
           } else if (e.status == 409) {
-            const newShapeId = e.headers[`x-electric-shape-id`];
-            this.reset(newShapeId);
-            this.publish(e.json);
+            const newShapeId = e.headers[SHAPE_ID_HEADER];
+            __privateMethod(this, _ShapeStream_instances, reset_fn).call(this, newShapeId);
+            await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, e.json);
             continue;
           } else if (e.status >= 400 && e.status < 500) {
-            this.sendErrorToUpToDateSubscribers(e);
-            this.sendErrorToSubscribers(e);
+            __privateMethod(this, _ShapeStream_instances, sendErrorToUpToDateSubscribers_fn).call(this, e);
+            __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, e);
             throw e;
           }
         }
         const { headers, status } = response;
-        const shapeId = headers.get(`X-Electric-Shape-Id`);
+        const shapeId = headers.get(SHAPE_ID_HEADER);
         if (shapeId) {
-          this.shapeId = shapeId;
+          __privateSet(this, _shapeId, shapeId);
         }
-        const lastOffset = headers.get(`X-Electric-Chunk-Last-Offset`);
+        const lastOffset = headers.get(CHUNK_LAST_OFFSET_HEADER);
         if (lastOffset) {
-          this.lastOffset = lastOffset;
+          __privateSet(this, _lastOffset, lastOffset);
         }
         const getSchema = () => {
-          const schemaHeader = headers.get(`X-Electric-Schema`);
+          const schemaHeader = headers.get(SHAPE_SCHEMA_HEADER);
           return schemaHeader ? JSON.parse(schemaHeader) : {};
         };
-        this.schema = (_a = this.schema) != null ? _a : getSchema();
+        __privateSet(this, _schema, (_a = __privateGet(this, _schema)) != null ? _a : getSchema());
         const messages = status === 204 ? `[]` : await response.text();
         if (status === 204) {
-          this.lastSyncedAt = Date.now();
+          __privateSet(this, _lastSyncedAt, Date.now());
         }
-        const batch = this.messageParser.parse(messages, this.schema);
+        const batch = __privateGet(this, _messageParser).parse(messages, __privateGet(this, _schema));
         if (batch.length > 0) {
+          const prevUpToDate = __privateGet(this, _isUpToDate);
           const lastMessage = batch[batch.length - 1];
-          if (isControlMessage(lastMessage) && lastMessage.headers.control === `up-to-date`) {
-            this.lastSyncedAt = Date.now();
-            if (!this.isUpToDate) {
-              this.isUpToDate = true;
-              this.notifyUpToDateSubscribers();
-            }
+          if (isUpToDateMessage(lastMessage)) {
+            __privateSet(this, _lastSyncedAt, Date.now());
+            __privateSet(this, _isUpToDate, true);
+          }
+          await __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, batch);
+          if (!prevUpToDate && __privateGet(this, _isUpToDate)) {
+            __privateMethod(this, _ShapeStream_instances, notifyUpToDateSubscribers_fn).call(this);
           }
-          this.publish(batch);
         }
       }
     } finally {
-      this.connected = false;
+      __privateSet(this, _connected, false);
     }
   }
   subscribe(callback, onError) {
     const subscriptionId = Math.random();
-    const subscriber = new MessageProcessor(callback);
-    this.subscribers.set(subscriptionId, [subscriber, onError]);
+    __privateGet(this, _subscribers).set(subscriptionId, [callback, onError]);
     return () => {
-      this.subscribers.delete(subscriptionId);
+      __privateGet(this, _subscribers).delete(subscriptionId);
     };
   }
   unsubscribeAll() {
-    this.subscribers.clear();
-  }
-  publish(messages) {
-    this.subscribers.forEach(([subscriber, _]) => {
-      subscriber.process(messages);
-    });
-  }
-  sendErrorToSubscribers(error) {
-    this.subscribers.forEach(([_, errorFn]) => {
-      errorFn == null ? void 0 : errorFn(error);
-    });
+    __privateGet(this, _subscribers).clear();
   }
   subscribeOnceToUpToDate(callback, error) {
     const subscriptionId = Math.random();
-    this.upToDateSubscribers.set(subscriptionId, [callback, error]);
+    __privateGet(this, _upToDateSubscribers).set(subscriptionId, [callback, error]);
     return () => {
-      this.upToDateSubscribers.delete(subscriptionId);
+      __privateGet(this, _upToDateSubscribers).delete(subscriptionId);
     };
   }
   unsubscribeAllUpToDateSubscribers() {
-    this.upToDateSubscribers.clear();
+    __privateGet(this, _upToDateSubscribers).clear();
+  }
+  /** Unix time at which we last synced. Undefined when `isLoading` is true. */
+  lastSyncedAt() {
+    return __privateGet(this, _lastSyncedAt);
   }
   /** Time elapsed since last sync (in ms). Infinity if we did not yet sync. */
   lastSynced() {
-    if (this.lastSyncedAt === void 0) return Infinity;
-    return Date.now() - this.lastSyncedAt;
+    if (__privateGet(this, _lastSyncedAt) === void 0) return Infinity;
+    return Date.now() - __privateGet(this, _lastSyncedAt);
   }
+  /** Indicates if we are connected to the Electric sync service. */
   isConnected() {
-    return this.connected;
+    return __privateGet(this, _connected);
   }
   /** True during initial fetch. False afterwise.  */
   isLoading() {
     return !this.isUpToDate;
   }
-  notifyUpToDateSubscribers() {
-    this.upToDateSubscribers.forEach(([callback]) => {
-      callback();
-    });
+};
+_fetchClient2 = new WeakMap();
+_messageParser = new WeakMap();
+_subscribers = new WeakMap();
+_upToDateSubscribers = new WeakMap();
+_lastOffset = new WeakMap();
+_lastSyncedAt = new WeakMap();
+_isUpToDate = new WeakMap();
+_connected = new WeakMap();
+_shapeId = new WeakMap();
+_schema = new WeakMap();
+_ShapeStream_instances = new WeakSet();
+publish_fn = async function(messages) {
+  await Promise.all(
+    Array.from(__privateGet(this, _subscribers).values()).map(async ([callback, __]) => {
+      try {
+        await callback(messages);
+      } catch (err) {
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+    })
+  );
+};
+sendErrorToSubscribers_fn = function(error) {
+  __privateGet(this, _subscribers).forEach(([_, errorFn]) => {
+    errorFn == null ? void 0 : errorFn(error);
+  });
+};
+notifyUpToDateSubscribers_fn = function() {
+  __privateGet(this, _upToDateSubscribers).forEach(([callback]) => {
+    callback();
+  });
+};
+sendErrorToUpToDateSubscribers_fn = function(error) {
+  __privateGet(this, _upToDateSubscribers).forEach(
+    ([_, errorCallback]) => errorCallback(error)
+  );
+};
+/**
+ * Resets the state of the stream, optionally with a provided
+ * shape ID
+ */
+reset_fn = function(shapeId) {
+  __privateSet(this, _lastOffset, `-1`);
+  __privateSet(this, _shapeId, shapeId);
+  __privateSet(this, _isUpToDate, false);
+  __privateSet(this, _connected, false);
+  __privateSet(this, _schema, void 0);
+};
+function validateOptions(options) {
+  if (!options.url) {
+    throw new Error(`Invalid shape option. It must provide the url`);
   }
-  sendErrorToUpToDateSubscribers(error) {
-    this.upToDateSubscribers.forEach(
-      ([_, errorCallback]) => errorCallback(error)
+  if (options.signal && !(options.signal instanceof AbortSignal)) {
+    throw new Error(
+      `Invalid signal option. It must be an instance of AbortSignal.`
     );
   }
-  /**
-   * Resets the state of the stream, optionally with a provided
-   * shape ID
-   */
-  reset(shapeId) {
-    this.lastOffset = `-1`;
-    this.shapeId = shapeId;
-    this.isUpToDate = false;
-    this.connected = false;
-    this.schema = void 0;
-  }
-  validateOptions(options) {
-    if (!options.url) {
-      throw new Error(`Invalid shape option. It must provide the url`);
-    }
-    if (options.signal && !(options.signal instanceof AbortSignal)) {
-      throw new Error(
-        `Invalid signal option. It must be an instance of AbortSignal.`
-      );
-    }
-    if (options.offset !== void 0 && options.offset !== `-1` && !options.shapeId) {
-      throw new Error(
-        `shapeId is required if this isn't an initial fetch (i.e. offset > -1)`
-      );
-    }
-  }
-  async fetchWithBackoff(url) {
-    const { initialDelay, maxDelay, multiplier } = this.backoffOptions;
-    const signal = this.options.signal;
-    let delay = initialDelay;
-    let attempt = 0;
-    while (true) {
-      try {
-        const result = await this.fetchClient(url.toString(), { signal });
-        if (result.ok) {
-          if (this.options.subscribe) {
-            this.connected = true;
-          }
-          return result;
-        } else throw await FetchError.fromResponse(result, url.toString());
-      } catch (e) {
-        this.connected = false;
-        if (signal == null ? void 0 : signal.aborted) {
-          return void 0;
-        } else if (e instanceof FetchError && e.status >= 400 && e.status < 500) {
-          throw e;
-        } else {
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          delay = Math.min(delay * multiplier, maxDelay);
-          attempt++;
-          console.log(`Retry attempt #${attempt} after ${delay}ms`);
-        }
-      }
-    }
+  if (options.offset !== void 0 && options.offset !== `-1` && !options.shapeId) {
+    throw new Error(
+      `shapeId is required if this isn't an initial fetch (i.e. offset > -1)`
+    );
   }
-};
+  return;
+}
+
+// src/shape.ts
+var _stream, _data, _subscribers2, _hasNotifiedSubscribersUpToDate, _error, _Shape_instances, process_fn, handleError_fn, notify_fn;
 var Shape = class {
   constructor(stream) {
-    this.data = /* @__PURE__ */ new Map();
-    this.subscribers = /* @__PURE__ */ new Map();
-    this.error = false;
-    this.hasNotifiedSubscribersUpToDate = false;
-    this.stream = stream;
-    this.stream.subscribe(this.process.bind(this), this.handleError.bind(this));
-    const unsubscribe = this.stream.subscribeOnceToUpToDate(
+    __privateAdd(this, _Shape_instances);
+    __privateAdd(this, _stream);
+    __privateAdd(this, _data, /* @__PURE__ */ new Map());
+    __privateAdd(this, _subscribers2, /* @__PURE__ */ new Map());
+    __privateAdd(this, _hasNotifiedSubscribersUpToDate, false);
+    __privateAdd(this, _error, false);
+    __privateSet(this, _stream, stream);
+    __privateGet(this, _stream).subscribe(
+      __privateMethod(this, _Shape_instances, process_fn).bind(this),
+      __privateMethod(this, _Shape_instances, handleError_fn).bind(this)
+    );
+    const unsubscribe = __privateGet(this, _stream).subscribeOnceToUpToDate(
       () => {
         unsubscribe();
       },
       (e) => {
-        this.handleError(e);
+        __privateMethod(this, _Shape_instances, handleError_fn).call(this, e);
         throw e;
       }
     );
   }
-  lastSynced() {
-    return this.stream.lastSynced();
-  }
-  isConnected() {
-    return this.stream.isConnected();
-  }
-  /** True during initial fetch. False afterwise. */
-  isLoading() {
-    return this.stream.isLoading();
+  get isUpToDate() {
+    return __privateGet(this, _stream).isUpToDate;
   }
   get value() {
-    return new Promise((resolve) => {
-      if (this.stream.isUpToDate) {
+    return new Promise((resolve, reject) => {
+      if (__privateGet(this, _stream).isUpToDate) {
         resolve(this.valueSync);
       } else {
-        const unsubscribe = this.stream.subscribeOnceToUpToDate(
-          () => {
-            unsubscribe();
-            resolve(this.valueSync);
-          },
-          (e) => {
-            throw e;
-          }
-        );
+        const unsubscribe = this.subscribe((shapeData) => {
+          unsubscribe();
+          if (__privateGet(this, _error)) reject(__privateGet(this, _error));
+          resolve(shapeData);
+        });
       }
     });
   }
   get valueSync() {
-    return this.data;
+    return __privateGet(this, _data);
+  }
+  get error() {
+    return __privateGet(this, _error);
+  }
+  /** Unix time at which we last synced. Undefined when `isLoading` is true. */
+  lastSyncedAt() {
+    return __privateGet(this, _stream).lastSyncedAt();
+  }
+  /** Time elapsed since last sync (in ms). Infinity if we did not yet sync. */
+  lastSynced() {
+    return __privateGet(this, _stream).lastSynced();
+  }
+  /** True during initial fetch. False afterwise.  */
+  isLoading() {
+    return __privateGet(this, _stream).isLoading();
+  }
+  /** Indicates if we are connected to the Electric sync service. */
+  isConnected() {
+    return __privateGet(this, _stream).isConnected();
   }
   subscribe(callback) {
     const subscriptionId = Math.random();
-    this.subscribers.set(subscriptionId, callback);
+    __privateGet(this, _subscribers2).set(subscriptionId, callback);
     return () => {
-      this.subscribers.delete(subscriptionId);
+      __privateGet(this, _subscribers2).delete(subscriptionId);
     };
   }
   unsubscribeAll() {
-    this.subscribers.clear();
+    __privateGet(this, _subscribers2).clear();
   }
   get numSubscribers() {
-    return this.subscribers.size;
-  }
-  process(messages) {
-    let dataMayHaveChanged = false;
-    let isUpToDate = false;
-    let newlyUpToDate = false;
-    messages.forEach((message) => {
-      if (isChangeMessage(message)) {
-        dataMayHaveChanged = [`insert`, `update`, `delete`].includes(
-          message.headers.operation
-        );
-        switch (message.headers.operation) {
-          case `insert`:
-            this.data.set(message.key, message.value);
-            break;
-          case `update`:
-            this.data.set(message.key, __spreadValues(__spreadValues({}, this.data.get(message.key)), message.value));
-            break;
-          case `delete`:
-            this.data.delete(message.key);
-            break;
-        }
-      }
-      if (isControlMessage(message)) {
-        switch (message.headers.control) {
-          case `up-to-date`:
-            isUpToDate = true;
-            if (!this.hasNotifiedSubscribersUpToDate) {
-              newlyUpToDate = true;
-            }
-            break;
-          case `must-refetch`:
-            this.data.clear();
-            this.error = false;
-            isUpToDate = false;
-            newlyUpToDate = false;
-            break;
-        }
+    return __privateGet(this, _subscribers2).size;
+  }
+};
+_stream = new WeakMap();
+_data = new WeakMap();
+_subscribers2 = new WeakMap();
+_hasNotifiedSubscribersUpToDate = new WeakMap();
+_error = new WeakMap();
+_Shape_instances = new WeakSet();
+process_fn = function(messages) {
+  let dataMayHaveChanged = false;
+  let isUpToDate = false;
+  let newlyUpToDate = false;
+  messages.forEach((message) => {
+    if (isChangeMessage(message)) {
+      dataMayHaveChanged = [`insert`, `update`, `delete`].includes(
+        message.headers.operation
+      );
+      switch (message.headers.operation) {
+        case `insert`:
+          __privateGet(this, _data).set(message.key, message.value);
+          break;
+        case `update`:
+          __privateGet(this, _data).set(message.key, __spreadValues(__spreadValues({}, __privateGet(this, _data).get(message.key)), message.value));
+          break;
+        case `delete`:
+          __privateGet(this, _data).delete(message.key);
+          break;
       }
-    });
-    if (newlyUpToDate || isUpToDate && dataMayHaveChanged) {
-      this.hasNotifiedSubscribersUpToDate = true;
-      this.notify();
     }
-  }
-  handleError(e) {
-    if (e instanceof FetchError) {
-      this.error = e;
-      this.notify();
+    if (isControlMessage(message)) {
+      switch (message.headers.control) {
+        case `up-to-date`:
+          isUpToDate = true;
+          if (!__privateGet(this, _hasNotifiedSubscribersUpToDate)) {
+            newlyUpToDate = true;
+          }
+          break;
+        case `must-refetch`:
+          __privateGet(this, _data).clear();
+          __privateSet(this, _error, false);
+          isUpToDate = false;
+          newlyUpToDate = false;
+          break;
+      }
     }
+  });
+  if (newlyUpToDate || isUpToDate && dataMayHaveChanged) {
+    __privateSet(this, _hasNotifiedSubscribersUpToDate, true);
+    __privateMethod(this, _Shape_instances, notify_fn).call(this);
   }
-  notify() {
-    this.subscribers.forEach((callback) => {
-      callback(this.valueSync);
-    });
+};
+handleError_fn = function(e) {
+  if (e instanceof FetchError) {
+    __privateSet(this, _error, e);
+    __privateMethod(this, _Shape_instances, notify_fn).call(this);
   }
 };
+notify_fn = function() {
+  __privateGet(this, _subscribers2).forEach((callback) => {
+    callback(this.valueSync);
+  });
+};
 export {
   BackoffDefaults,
   FetchError,