@graffy/client 0.19.0 → 0.19.1-alpha.1

package/Socket.js

@@ -0,0 +1,149 @@
+/*
+  This class implements a self-healing wrapper around a WebSocket, with
+  a higher level concept of "requests". Requests are retried when a connection
+  reconnects.
+
+  This implements reconnection with exponential backoff that is designed to
+  work reasonably well on platforms that may "forget" long-running timers
+  such as React Native.
+
+  The isAlive exported function may be called in situations such as the app
+  being restored, where timers may have been forgotten.
+*/
+import { makeId } from '@graffy/common';
+import debug from 'debug';
+const log = debug('graffy:client:socket');
+log.log = console.log.bind(console);
+const MIN_DELAY = 1000;
+const MAX_DELAY = 300000;
+const DELAY_GROWTH = 1.5;
+const INTERVAL = 2000;
+const PING_TIMEOUT = 40000; // Make this greater than server interval.
+const RESET_TIMEOUT = 10000;
+export default function Socket(url, { onUnhandled = undefined, onStatusChange = undefined } = {}) {
+    const handlers = {};
+    const buffer = [];
+    let isOpen = false;
+    let isConnecting = false;
+    let socket;
+    let lastAlive;
+    let lastAttempt;
+    let attempts = 0;
+    let connectTimer;
+    let aliveTimer;
+    function start(params, callback) {
+        const id = makeId();
+        const request = [id, ...params];
+        handlers[id] = { request, callback };
+        if (isAlive())
+            send(request);
+        return id;
+    }
+    function stop(id, params) {
+        delete handlers[id];
+        if (params)
+            send([id, ...params]);
+    }
+    function connect() {
+        log('Trying to connect to', url);
+        isOpen = false;
+        isConnecting = true;
+        lastAttempt = Date.now();
+        attempts++;
+        socket = new globalThis.WebSocket(url);
+        socket.onmessage = received;
+        socket.onerror = closed;
+        socket.onclose = closed;
+        socket.onopen = opened;
+    }
+    function received(event) {
+        const [id, ...data] = JSON.parse(event.data);
+        setAlive();
+        if (id === ':ping') {
+            send([':pong']);
+        }
+        else if (handlers[id]) {
+            handlers[id].callback(...data);
+        }
+        else {
+            // We received an unexpected push.
+            onUnhandled?.(id, ...data);
+        }
+    }
+    function closed(_event) {
+        log('Closed');
+        if (isOpen && onStatusChange)
+            onStatusChange(false);
+        const wasOpen = isOpen;
+        isOpen = false;
+        isConnecting = false;
+        lastAttempt = Date.now();
+        if (wasOpen && !attempts) {
+            // Quick reconnect path if we previously had a stable connection.
+            connect();
+            return;
+        }
+        maybeConnect();
+    }
+    function maybeConnect() {
+        const connDelay = lastAttempt +
+            Math.min(MAX_DELAY, MIN_DELAY * DELAY_GROWTH ** attempts) -
+            Date.now();
+        log('Will reconnect in', connDelay, 'ms');
+        if (connDelay <= 0) {
+            connect();
+            return;
+        }
+        clearTimeout(connectTimer);
+        connectTimer = setTimeout(connect, connDelay);
+    }
+    function opened() {
+        log('Connected', buffer.length, Object.keys(handlers).length);
+        isOpen = true;
+        isConnecting = false;
+        lastAttempt = Date.now();
+        setAlive();
+        if (onStatusChange)
+            onStatusChange(true);
+        for (const id in handlers)
+            send(handlers[id].request);
+        while (buffer.length)
+            send(buffer.shift());
+    }
+    function setAlive() {
+        lastAlive = Date.now();
+        log('Set alive', lastAlive - lastAttempt);
+        if (lastAlive - lastAttempt > RESET_TIMEOUT)
+            attempts = 0;
+    }
+    function isAlive() {
+        log('Liveness check', isOpen ? 'open' : 'closed', Date.now() - lastAlive);
+        clearTimeout(aliveTimer);
+        aliveTimer = setTimeout(isAlive, INTERVAL);
+        if (!isOpen) {
+            if (!isConnecting)
+                maybeConnect();
+            return false;
+        }
+        if (Date.now() - lastAlive < PING_TIMEOUT)
+            return true;
+        log('Ping timeout, closing', lastAlive);
+        socket.close();
+        return false;
+    }
+    function send(req) {
+        if (isAlive()) {
+            socket.send(JSON.stringify(req));
+        }
+        else {
+            buffer.push(req);
+        }
+    }
+    connect();
+    aliveTimer = setTimeout(isAlive, INTERVAL);
+    return {
+        start,
+        stop,
+        isAlive,
+    };
+}

package/{types/httpClient.d.ts → httpClient.d.ts}

@@ -1,4 +1,3 @@
-export default httpClient;
 /**
  *
  * @param {string} baseUrl
@@ -9,8 +8,9 @@ export default httpClient;
  * } | undefined} options
  * @returns {(store: any) => void}
  */
-declare function httpClient(baseUrl: string, { getOptions, watch, connInfoPath, }?: {
-    getOptions?: (op: string, options: any) => Promise<void>;
-    watch?: "sse" | "none" | "hang";
+declare const httpClient: (baseUrl: any, { getOptions, watch, connInfoPath, }?: {
+    getOptions?: () => Promise<void>;
+    watch?: string;
     connInfoPath?: string;
-} | undefined): (store: any) => void;
+}) => (store: any) => void;
+export default httpClient;

package/httpClient.js

@@ -0,0 +1,126 @@
+import { add, pack, unpack } from '@graffy/common';
+import { makeStream } from '@graffy/stream';
+function getOptionsParam(options) {
+    if (!options)
+        return '';
+    return encodeURIComponent(JSON.stringify(options));
+}
+const aggregateQueries = {};
+class AggregateQuery {
+    constructor(url) {
+        this.combinedQuery = [];
+        this.readers = [];
+        this.timer = null;
+        this.url = url;
+    }
+    add(query) {
+        add(this.combinedQuery, query);
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => this.doFetch(), 0);
+        return new Promise((resolve, reject) => {
+            this.readers.push({ query, resolve, reject });
+        });
+    }
+    async doFetch() {
+        delete aggregateQueries[this.url];
+        const response = await fetch(this.url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(pack(this.combinedQuery)),
+        });
+        if (response.status !== 200) {
+            const message = await response.text();
+            const err = new Error(message);
+            for (const reader of this.readers) {
+                reader.reject(err);
+            }
+            return;
+        }
+        try {
+            const data = unpack(JSON.parse(await response.text()));
+            for (const reader of this.readers)
+                reader.resolve(data);
+        }
+        catch (e) {
+            for (const reader of this.readers)
+                reader.reject(e);
+        }
+    }
+}
+function makeQuery(url, query) {
+    if (!aggregateQueries[url])
+        aggregateQueries[url] = new AggregateQuery(url);
+    return aggregateQueries[url].add(query);
+}
+/**
+ *
+ * @param {string} baseUrl
+ * @param {{
+ *    getOptions?: (op: string, options: any) => Promise<void>,
+ *    watch?: 'sse' | 'none' | 'hang',
+ *    connInfoPath?: string,
+ * } | undefined} options
+ * @returns {(store: any) => void}
+ */
+const httpClient = (baseUrl, { getOptions = async () => { }, watch = 'sse', connInfoPath = 'connection', } = {}) => (store) => {
+    store.onWrite(connInfoPath, ({ url }) => {
+        baseUrl = url;
+        return { url };
+    });
+    store.onRead(connInfoPath, () => ({ url: baseUrl }));
+    store.on('read', async (query, options) => {
+        if (!fetch)
+            throw Error('client.fetch.unavailable');
+        const optionsParam = getOptionsParam(await getOptions('read', options));
+        const url = `${baseUrl}?opts=${optionsParam}&op=read`;
+        return makeQuery(url, query);
+    });
+    store.on('watch', async function* (query, options) {
+        if (watch === 'none')
+            throw Error('client.no_watch');
+        if (watch === 'hang') {
+            yield* makeStream((push) => {
+                push(undefined);
+            });
+            return;
+        }
+        if (!EventSource)
+            throw Error('client.sse.unavailable');
+        const optionsParam = getOptionsParam(await getOptions('watch', options));
+        const url = `${baseUrl}?q=${encodeURIComponent(JSON.stringify(pack(query)))}&opts=${optionsParam}`;
+        const source = new EventSource(url);
+        yield* makeStream((push, end) => {
+            source.onmessage = ({ data }) => {
+                push(unpack(JSON.parse(data)));
+            };
+            source.onerror = (e) => {
+                end(Error(`client.sse.transport: ${e}`));
+            };
+            source.addEventListener('graffyerror', (e) => {
+                end(Error(`server.${e.data}`));
+            });
+            return () => {
+                source.close();
+            };
+        });
+    });
+    store.on('write', async (change, options) => {
+        if (!fetch)
+            throw Error('client.fetch.unavailable');
+        const optionsParam = getOptionsParam(await getOptions('write', options));
+        const url = `${baseUrl}?opts=${optionsParam}&op=write`;
+        return fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(pack(change)),
+        }).then(async (res) => {
+            if (res.status === 200)
+                return unpack(JSON.parse(await res.text()));
+            return res.text().then((message) => {
+                throw Error(`server.${message}`);
+            });
+        });
+    });
+};
+export default httpClient;

package/index.js

@@ -0,0 +1,9 @@
+import httpClient from "./httpClient.js";
+import wsClient from "./wsClient.js";
+const WSRE = /^wss?:\/\//;
+export default function GraffyClient(baseUrl, options) {
+    if (WSRE.test(baseUrl)) {
+        return wsClient(baseUrl, options);
+    }
+    return httpClient(baseUrl, options);
+}

package/package.json

@@ -2,22 +2,27 @@
   "name": "@graffy/client",
   "description": "Graffy client library for the browser, usin the `fetch()` or `WebSocket` APIs. This module is intended to be used with a Node.js server running Graffy Server.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.19.0",
-  "main": "./index.cjs",
+  "version": "0.19.1-alpha.1",
+  "main": "./cjs/index.js",
   "exports": {
-    "import": "./index.mjs",
-    "require": "./index.cjs"
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./*": {
+      "import": "./*.js",
+      "types": "./*.d.ts"
+    }
   },
-  "module": "./index.mjs",
-  "types": "./types/index.d.ts",
+  "types": "./index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/usegraffy/graffy.git"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.19.0",
-    "@graffy/stream": "0.19.0",
+    "@graffy/common": "0.19.1-alpha.1",
+    "@graffy/stream": "0.19.1-alpha.1",
     "debug": "^4.4.3"
   }
 }

package/{types/wsClient.d.ts → wsClient.d.ts}

@@ -1,6 +1,6 @@
-export default wsClient;
-declare function wsClient(url: any, { getOptions, watch, connInfoPath, }?: {
+declare const wsClient: (url: any, { getOptions, watch, connInfoPath, }?: {
     getOptions?: (..._: any[]) => boolean;
     watch?: any;
     connInfoPath?: string;
-}): (store: any) => void;
+}) => (store: any) => void;
+export default wsClient;

package/wsClient.js

@@ -0,0 +1,52 @@
+import { makeWatcher, pack, unpack } from '@graffy/common';
+import { makeStream } from '@graffy/stream';
+import Socket from "./Socket.js";
+const wsClient = (url, { getOptions = (..._) => false, watch = undefined, connInfoPath = 'connection', } = {}) => (store) => {
+    if (!WebSocket)
+        throw Error('client.websocket.unavailable');
+    const socket = Socket(url, { onUnhandled, onStatusChange });
+    let status = false;
+    const statusWatcher = makeWatcher();
+    function onUnhandled(id) {
+        socket.stop(id, ['unwatch']);
+    }
+    function onStatusChange(newStatus) {
+        status = newStatus;
+        statusWatcher.write({ status });
+    }
+    function once(op, payload, options) {
+        return new Promise((resolve, reject) => {
+            const id = socket.start([op, pack(payload), getOptions(op, options) || {}], (error, result) => {
+                socket.stop(id);
+                error ? reject(Error(`server.${error}`)) : resolve(unpack(result));
+            });
+        });
+    }
+    store.onWrite(connInfoPath, () => {
+        status = socket.isAlive();
+        return { status };
+    });
+    store.onRead(connInfoPath, () => ({ status }));
+    store.onWatch(connInfoPath, () => statusWatcher.watch({ status }));
+    store.on('read', (query, options) => once('read', query, options));
+    store.on('write', (change, options) => once('write', change, options));
+    store.on('watch', (query, options) => {
+        if (watch === 'none')
+            throw Error('client.no_watch');
+        const op = 'watch';
+        return makeStream((push, end) => {
+            const id = socket.start([op, pack(query), getOptions(op, options) || {}], (error, result) => {
+                if (error) {
+                    socket.stop(id);
+                    end(Error(`server.${error}`));
+                    return;
+                }
+                push(unpack(result));
+            });
+            return () => {
+                socket.stop(id, ['unwatch']);
+            };
+        });
+    });
+};
+export default wsClient;

package/index.cjs

@@ -1,296 +0,0 @@
-"use strict";
-const common = require("@graffy/common");
-const stream = require("@graffy/stream");
-const debug = require("debug");
-function getOptionsParam(options) {
-  if (!options) return "";
-  return encodeURIComponent(JSON.stringify(options));
-}
-const aggregateQueries = {};
-class AggregateQuery {
-  combinedQuery = [];
-  readers = [];
-  timer = null;
-  constructor(url) {
-    this.url = url;
-  }
-  add(query) {
-    common.add(this.combinedQuery, query);
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = setTimeout(() => this.doFetch(), 0);
-    return new Promise((resolve, reject) => {
-      this.readers.push({ query, resolve, reject });
-    });
-  }
-  async doFetch() {
-    delete aggregateQueries[this.url];
-    const response = await fetch(this.url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(common.pack(this.combinedQuery))
-    });
-    if (response.status !== 200) {
-      const message = await response.text();
-      const err = new Error(message);
-      for (const reader of this.readers) {
-        reader.reject(err);
-      }
-      return;
-    }
-    try {
-      const data = common.unpack(JSON.parse(await response.text()));
-      for (const reader of this.readers) reader.resolve(data);
-    } catch (e) {
-      for (const reader of this.readers) reader.reject(e);
-    }
-  }
-}
-function makeQuery(url, query) {
-  if (!aggregateQueries[url]) aggregateQueries[url] = new AggregateQuery(url);
-  return aggregateQueries[url].add(query);
-}
-const httpClient = (baseUrl, {
-  getOptions = async () => {
-  },
-  watch = "sse",
-  connInfoPath = "connection"
-} = {}) => (store) => {
-  store.onWrite(connInfoPath, ({ url }) => {
-    baseUrl = url;
-    return { url };
-  });
-  store.onRead(connInfoPath, () => ({ url: baseUrl }));
-  store.on("read", async (query, options) => {
-    if (!fetch) throw Error("client.fetch.unavailable");
-    const optionsParam = getOptionsParam(await getOptions("read", options));
-    const url = `${baseUrl}?opts=${optionsParam}&op=read`;
-    return makeQuery(url, query);
-  });
-  store.on("watch", async function* (query, options) {
-    if (watch === "none") throw Error("client.no_watch");
-    if (watch === "hang") {
-      yield* stream.makeStream((push) => {
-        push(void 0);
-      });
-      return;
-    }
-    if (!EventSource) throw Error("client.sse.unavailable");
-    const optionsParam = getOptionsParam(await getOptions("watch", options));
-    const url = `${baseUrl}?q=${encodeURIComponent(
-      JSON.stringify(common.pack(query))
-    )}&opts=${optionsParam}`;
-    const source = new EventSource(url);
-    yield* stream.makeStream((push, end) => {
-      source.onmessage = ({ data }) => {
-        push(common.unpack(JSON.parse(data)));
-      };
-      source.onerror = (e) => {
-        end(Error(`client.sse.transport: ${e}`));
-      };
-      source.addEventListener("graffyerror", (e) => {
-        end(Error(`server.${e.data}`));
-      });
-      return () => {
-        source.close();
-      };
-    });
-  });
-  store.on("write", async (change, options) => {
-    if (!fetch) throw Error("client.fetch.unavailable");
-    const optionsParam = getOptionsParam(await getOptions("write", options));
-    const url = `${baseUrl}?opts=${optionsParam}&op=write`;
-    return fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(common.pack(change))
-    }).then(async (res) => {
-      if (res.status === 200) return common.unpack(JSON.parse(await res.text()));
-      return res.text().then((message) => {
-        throw Error(`server.${message}`);
-      });
-    });
-  });
-};
-const log = debug("graffy:client:socket");
-log.log = console.log.bind(console);
-const MIN_DELAY = 1e3;
-const MAX_DELAY = 3e5;
-const DELAY_GROWTH = 1.5;
-const INTERVAL = 2e3;
-const PING_TIMEOUT = 4e4;
-const RESET_TIMEOUT = 1e4;
-function Socket(url, { onUnhandled = void 0, onStatusChange = void 0 } = {}) {
-  const handlers = {};
-  const buffer = [];
-  let isOpen = false;
-  let isConnecting = false;
-  let socket;
-  let lastAlive;
-  let lastAttempt;
-  let attempts = 0;
-  let connectTimer;
-  let aliveTimer;
-  function start(params, callback) {
-    const id = common.makeId();
-    const request = [id, ...params];
-    handlers[id] = { request, callback };
-    if (isAlive()) send(request);
-    return id;
-  }
-  function stop(id, params) {
-    delete handlers[id];
-    if (params) send([id, ...params]);
-  }
-  function connect() {
-    log("Trying to connect to", url);
-    isOpen = false;
-    isConnecting = true;
-    lastAttempt = Date.now();
-    attempts++;
-    socket = new globalThis.WebSocket(url);
-    socket.onmessage = received;
-    socket.onerror = closed;
-    socket.onclose = closed;
-    socket.onopen = opened;
-  }
-  function received(event) {
-    const [id, ...data] = JSON.parse(event.data);
-    setAlive();
-    if (id === ":ping") {
-      send([":pong"]);
-    } else if (handlers[id]) {
-      handlers[id].callback(...data);
-    } else {
-      onUnhandled?.(id, ...data);
-    }
-  }
-  function closed(_event) {
-    log("Closed");
-    if (isOpen && onStatusChange) onStatusChange(false);
-    const wasOpen = isOpen;
-    isOpen = false;
-    isConnecting = false;
-    lastAttempt = Date.now();
-    if (wasOpen && !attempts) {
-      connect();
-      return;
-    }
-    maybeConnect();
-  }
-  function maybeConnect() {
-    const connDelay = lastAttempt + Math.min(MAX_DELAY, MIN_DELAY * DELAY_GROWTH ** attempts) - Date.now();
-    log("Will reconnect in", connDelay, "ms");
-    if (connDelay <= 0) {
-      connect();
-      return;
-    }
-    clearTimeout(connectTimer);
-    connectTimer = setTimeout(connect, connDelay);
-  }
-  function opened() {
-    log("Connected", buffer.length, Object.keys(handlers).length);
-    isOpen = true;
-    isConnecting = false;
-    lastAttempt = Date.now();
-    setAlive();
-    if (onStatusChange) onStatusChange(true);
-    for (const id in handlers) send(handlers[id].request);
-    while (buffer.length) send(buffer.shift());
-  }
-  function setAlive() {
-    lastAlive = Date.now();
-    log("Set alive", lastAlive - lastAttempt);
-    if (lastAlive - lastAttempt > RESET_TIMEOUT) attempts = 0;
-  }
-  function isAlive() {
-    log("Liveness check", isOpen ? "open" : "closed", Date.now() - lastAlive);
-    clearTimeout(aliveTimer);
-    aliveTimer = setTimeout(isAlive, INTERVAL);
-    if (!isOpen) {
-      if (!isConnecting) maybeConnect();
-      return false;
-    }
-    if (Date.now() - lastAlive < PING_TIMEOUT) return true;
-    log("Ping timeout, closing", lastAlive);
-    socket.close();
-    return false;
-  }
-  function send(req) {
-    if (isAlive()) {
-      socket.send(JSON.stringify(req));
-    } else {
-      buffer.push(req);
-    }
-  }
-  connect();
-  aliveTimer = setTimeout(isAlive, INTERVAL);
-  return {
-    start,
-    stop,
-    isAlive
-  };
-}
-const wsClient = (url, {
-  getOptions = (..._) => false,
-  watch = void 0,
-  connInfoPath = "connection"
-} = {}) => (store) => {
-  if (!WebSocket) throw Error("client.websocket.unavailable");
-  const socket = Socket(url, { onUnhandled, onStatusChange });
-  let status = false;
-  const statusWatcher = common.makeWatcher();
-  function onUnhandled(id) {
-    socket.stop(id, ["unwatch"]);
-  }
-  function onStatusChange(newStatus) {
-    status = newStatus;
-    statusWatcher.write({ status });
-  }
-  function once(op, payload, options) {
-    return new Promise((resolve, reject) => {
-      const id = socket.start(
-        [op, common.pack(payload), getOptions(op, options) || {}],
-        (error, result) => {
-          socket.stop(id);
-          error ? reject(Error(`server.${error}`)) : resolve(common.unpack(result));
-        }
-      );
-    });
-  }
-  store.onWrite(connInfoPath, () => {
-    status = socket.isAlive();
-    return { status };
-  });
-  store.onRead(connInfoPath, () => ({ status }));
-  store.onWatch(connInfoPath, () => statusWatcher.watch({ status }));
-  store.on("read", (query, options) => once("read", query, options));
-  store.on("write", (change, options) => once("write", change, options));
-  store.on("watch", (query, options) => {
-    if (watch === "none") throw Error("client.no_watch");
-    const op = "watch";
-    return stream.makeStream((push, end) => {
-      const id = socket.start(
-        [op, common.pack(query), getOptions(op, options) || {}],
-        (error, result) => {
-          if (error) {
-            socket.stop(id);
-            end(Error(`server.${error}`));
-            return;
-          }
-          push(common.unpack(result));
-        }
-      );
-      return () => {
-        socket.stop(id, ["unwatch"]);
-      };
-    });
-  });
-};
-const WSRE = /^wss?:\/\//;
-function GraffyClient(baseUrl, options) {
-  if (WSRE.test(baseUrl)) {
-    return wsClient(baseUrl, options);
-  }
-  return httpClient(baseUrl, options);
-}
-module.exports = GraffyClient;

package/index.mjs

@@ -1,297 +0,0 @@
-import { pack, unpack, add, makeId, makeWatcher } from "@graffy/common";
-import { makeStream } from "@graffy/stream";
-import debug from "debug";
-function getOptionsParam(options) {
-  if (!options) return "";
-  return encodeURIComponent(JSON.stringify(options));
-}
-const aggregateQueries = {};
-class AggregateQuery {
-  combinedQuery = [];
-  readers = [];
-  timer = null;
-  constructor(url) {
-    this.url = url;
-  }
-  add(query) {
-    add(this.combinedQuery, query);
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = setTimeout(() => this.doFetch(), 0);
-    return new Promise((resolve, reject) => {
-      this.readers.push({ query, resolve, reject });
-    });
-  }
-  async doFetch() {
-    delete aggregateQueries[this.url];
-    const response = await fetch(this.url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(pack(this.combinedQuery))
-    });
-    if (response.status !== 200) {
-      const message = await response.text();
-      const err = new Error(message);
-      for (const reader of this.readers) {
-        reader.reject(err);
-      }
-      return;
-    }
-    try {
-      const data = unpack(JSON.parse(await response.text()));
-      for (const reader of this.readers) reader.resolve(data);
-    } catch (e) {
-      for (const reader of this.readers) reader.reject(e);
-    }
-  }
-}
-function makeQuery(url, query) {
-  if (!aggregateQueries[url]) aggregateQueries[url] = new AggregateQuery(url);
-  return aggregateQueries[url].add(query);
-}
-const httpClient = (baseUrl, {
-  getOptions = async () => {
-  },
-  watch = "sse",
-  connInfoPath = "connection"
-} = {}) => (store) => {
-  store.onWrite(connInfoPath, ({ url }) => {
-    baseUrl = url;
-    return { url };
-  });
-  store.onRead(connInfoPath, () => ({ url: baseUrl }));
-  store.on("read", async (query, options) => {
-    if (!fetch) throw Error("client.fetch.unavailable");
-    const optionsParam = getOptionsParam(await getOptions("read", options));
-    const url = `${baseUrl}?opts=${optionsParam}&op=read`;
-    return makeQuery(url, query);
-  });
-  store.on("watch", async function* (query, options) {
-    if (watch === "none") throw Error("client.no_watch");
-    if (watch === "hang") {
-      yield* makeStream((push) => {
-        push(void 0);
-      });
-      return;
-    }
-    if (!EventSource) throw Error("client.sse.unavailable");
-    const optionsParam = getOptionsParam(await getOptions("watch", options));
-    const url = `${baseUrl}?q=${encodeURIComponent(
-      JSON.stringify(pack(query))
-    )}&opts=${optionsParam}`;
-    const source = new EventSource(url);
-    yield* makeStream((push, end) => {
-      source.onmessage = ({ data }) => {
-        push(unpack(JSON.parse(data)));
-      };
-      source.onerror = (e) => {
-        end(Error(`client.sse.transport: ${e}`));
-      };
-      source.addEventListener("graffyerror", (e) => {
-        end(Error(`server.${e.data}`));
-      });
-      return () => {
-        source.close();
-      };
-    });
-  });
-  store.on("write", async (change, options) => {
-    if (!fetch) throw Error("client.fetch.unavailable");
-    const optionsParam = getOptionsParam(await getOptions("write", options));
-    const url = `${baseUrl}?opts=${optionsParam}&op=write`;
-    return fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(pack(change))
-    }).then(async (res) => {
-      if (res.status === 200) return unpack(JSON.parse(await res.text()));
-      return res.text().then((message) => {
-        throw Error(`server.${message}`);
-      });
-    });
-  });
-};
-const log = debug("graffy:client:socket");
-log.log = console.log.bind(console);
-const MIN_DELAY = 1e3;
-const MAX_DELAY = 3e5;
-const DELAY_GROWTH = 1.5;
-const INTERVAL = 2e3;
-const PING_TIMEOUT = 4e4;
-const RESET_TIMEOUT = 1e4;
-function Socket(url, { onUnhandled = void 0, onStatusChange = void 0 } = {}) {
-  const handlers = {};
-  const buffer = [];
-  let isOpen = false;
-  let isConnecting = false;
-  let socket;
-  let lastAlive;
-  let lastAttempt;
-  let attempts = 0;
-  let connectTimer;
-  let aliveTimer;
-  function start(params, callback) {
-    const id = makeId();
-    const request = [id, ...params];
-    handlers[id] = { request, callback };
-    if (isAlive()) send(request);
-    return id;
-  }
-  function stop(id, params) {
-    delete handlers[id];
-    if (params) send([id, ...params]);
-  }
-  function connect() {
-    log("Trying to connect to", url);
-    isOpen = false;
-    isConnecting = true;
-    lastAttempt = Date.now();
-    attempts++;
-    socket = new globalThis.WebSocket(url);
-    socket.onmessage = received;
-    socket.onerror = closed;
-    socket.onclose = closed;
-    socket.onopen = opened;
-  }
-  function received(event) {
-    const [id, ...data] = JSON.parse(event.data);
-    setAlive();
-    if (id === ":ping") {
-      send([":pong"]);
-    } else if (handlers[id]) {
-      handlers[id].callback(...data);
-    } else {
-      onUnhandled?.(id, ...data);
-    }
-  }
-  function closed(_event) {
-    log("Closed");
-    if (isOpen && onStatusChange) onStatusChange(false);
-    const wasOpen = isOpen;
-    isOpen = false;
-    isConnecting = false;
-    lastAttempt = Date.now();
-    if (wasOpen && !attempts) {
-      connect();
-      return;
-    }
-    maybeConnect();
-  }
-  function maybeConnect() {
-    const connDelay = lastAttempt + Math.min(MAX_DELAY, MIN_DELAY * DELAY_GROWTH ** attempts) - Date.now();
-    log("Will reconnect in", connDelay, "ms");
-    if (connDelay <= 0) {
-      connect();
-      return;
-    }
-    clearTimeout(connectTimer);
-    connectTimer = setTimeout(connect, connDelay);
-  }
-  function opened() {
-    log("Connected", buffer.length, Object.keys(handlers).length);
-    isOpen = true;
-    isConnecting = false;
-    lastAttempt = Date.now();
-    setAlive();
-    if (onStatusChange) onStatusChange(true);
-    for (const id in handlers) send(handlers[id].request);
-    while (buffer.length) send(buffer.shift());
-  }
-  function setAlive() {
-    lastAlive = Date.now();
-    log("Set alive", lastAlive - lastAttempt);
-    if (lastAlive - lastAttempt > RESET_TIMEOUT) attempts = 0;
-  }
-  function isAlive() {
-    log("Liveness check", isOpen ? "open" : "closed", Date.now() - lastAlive);
-    clearTimeout(aliveTimer);
-    aliveTimer = setTimeout(isAlive, INTERVAL);
-    if (!isOpen) {
-      if (!isConnecting) maybeConnect();
-      return false;
-    }
-    if (Date.now() - lastAlive < PING_TIMEOUT) return true;
-    log("Ping timeout, closing", lastAlive);
-    socket.close();
-    return false;
-  }
-  function send(req) {
-    if (isAlive()) {
-      socket.send(JSON.stringify(req));
-    } else {
-      buffer.push(req);
-    }
-  }
-  connect();
-  aliveTimer = setTimeout(isAlive, INTERVAL);
-  return {
-    start,
-    stop,
-    isAlive
-  };
-}
-const wsClient = (url, {
-  getOptions = (..._) => false,
-  watch = void 0,
-  connInfoPath = "connection"
-} = {}) => (store) => {
-  if (!WebSocket) throw Error("client.websocket.unavailable");
-  const socket = Socket(url, { onUnhandled, onStatusChange });
-  let status = false;
-  const statusWatcher = makeWatcher();
-  function onUnhandled(id) {
-    socket.stop(id, ["unwatch"]);
-  }
-  function onStatusChange(newStatus) {
-    status = newStatus;
-    statusWatcher.write({ status });
-  }
-  function once(op, payload, options) {
-    return new Promise((resolve, reject) => {
-      const id = socket.start(
-        [op, pack(payload), getOptions(op, options) || {}],
-        (error, result) => {
-          socket.stop(id);
-          error ? reject(Error(`server.${error}`)) : resolve(unpack(result));
-        }
-      );
-    });
-  }
-  store.onWrite(connInfoPath, () => {
-    status = socket.isAlive();
-    return { status };
-  });
-  store.onRead(connInfoPath, () => ({ status }));
-  store.onWatch(connInfoPath, () => statusWatcher.watch({ status }));
-  store.on("read", (query, options) => once("read", query, options));
-  store.on("write", (change, options) => once("write", change, options));
-  store.on("watch", (query, options) => {
-    if (watch === "none") throw Error("client.no_watch");
-    const op = "watch";
-    return makeStream((push, end) => {
-      const id = socket.start(
-        [op, pack(query), getOptions(op, options) || {}],
-        (error, result) => {
-          if (error) {
-            socket.stop(id);
-            end(Error(`server.${error}`));
-            return;
-          }
-          push(unpack(result));
-        }
-      );
-      return () => {
-        socket.stop(id, ["unwatch"]);
-      };
-    });
-  });
-};
-const WSRE = /^wss?:\/\//;
-function GraffyClient(baseUrl, options) {
-  if (WSRE.test(baseUrl)) {
-    return wsClient(baseUrl, options);
-  }
-  return httpClient(baseUrl, options);
-}
-export {
-  GraffyClient as default
-};