@absolutejs/sync 0.0.1 → 0.2.0

package/dist/client/index.js

@@ -1,4 +1,74 @@
-// src/client/index.ts
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, name) => {
+  Object.defineProperty(target, "name", {
+    value: name,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+};
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+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 __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+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);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
+    done._ = 1;
+    if (k ^ 4 || it === undefined)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+
+// src/client/subscriber.ts
 var createSyncSubscriber = ({
   topics,
   onEvent,
@@ -33,9 +103,1035 @@ var createSyncSubscriber = ({
     source
   };
 };
+// src/reactiveHub.ts
+var SYNC_OPEN_TOPIC = "@absolutejs/sync:open";
+
+// src/client/liveQuery.ts
+var createLiveQuery = (options) => {
+  const hasSeed = options.initialData !== undefined;
+  let state = {
+    data: options.initialData,
+    error: undefined,
+    loading: !options.manual && !hasSeed,
+    fetching: false
+  };
+  const listeners = new Set;
+  const setState = (patch) => {
+    state = { ...state, ...patch };
+    for (const listener of listeners) {
+      listener(state);
+    }
+  };
+  let requestSeq = 0;
+  let inFlight;
+  let closed = false;
+  const refetch = async () => {
+    if (closed) {
+      return;
+    }
+    const seq = requestSeq += 1;
+    inFlight?.abort();
+    const controller = new AbortController;
+    inFlight = controller;
+    setState({ fetching: true });
+    try {
+      const data = await options.fetcher(controller.signal);
+      if (seq !== requestSeq) {
+        return;
+      }
+      setState({
+        data,
+        error: undefined,
+        loading: false,
+        fetching: false
+      });
+    } catch (error) {
+      if (controller.signal.aborted || seq !== requestSeq) {
+        return;
+      }
+      setState({ error, loading: false, fetching: false });
+      options.onError?.(error);
+    } finally {
+      if (inFlight === controller) {
+        inFlight = undefined;
+      }
+    }
+  };
+  let debounceTimer;
+  const scheduleRefetch = () => {
+    if (closed) {
+      return;
+    }
+    if (!options.debounceMs) {
+      refetch();
+      return;
+    }
+    if (debounceTimer !== undefined) {
+      return;
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = undefined;
+      refetch();
+    }, options.debounceMs);
+  };
+  let opened = false;
+  const onEvent = (event) => {
+    if (event.topic === SYNC_OPEN_TOPIC) {
+      if (opened) {
+        scheduleRefetch();
+      }
+      opened = true;
+      return;
+    }
+    scheduleRefetch();
+  };
+  const subscriber = createSyncSubscriber({
+    topics: options.topics,
+    onEvent,
+    url: options.url,
+    withCredentials: options.withCredentials,
+    eventSourceImpl: options.eventSourceImpl
+  });
+  if (!options.manual && !hasSeed) {
+    refetch();
+  }
+  const close = () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    subscriber.close();
+    inFlight?.abort();
+    if (debounceTimer !== undefined) {
+      clearTimeout(debounceTimer);
+      debounceTimer = undefined;
+    }
+    listeners.clear();
+  };
+  return {
+    get: () => state,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    refetch,
+    close
+  };
+};
+var jsonFetcher = (url, init) => async (signal) => {
+  const response = await fetch(url, { ...init, signal });
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`);
+  }
+  return await response.json();
+};
+// src/client/syncCollection.ts
+var localStorageMutationStorage = (key) => ({
+  load: () => {
+    const raw = globalThis.localStorage?.getItem(key);
+    return raw ? JSON.parse(raw) : [];
+  },
+  save: (records) => {
+    globalThis.localStorage?.setItem(key, JSON.stringify(records));
+  }
+});
+var SUBSCRIPTION_ID = "s";
+var createSyncCollection = (options) => {
+  const key = options.key ?? ((row) => row.id);
+  const reconnectMs = options.reconnectMs ?? 500;
+  const maxReconnectMs = options.maxReconnectMs ?? 1e4;
+  const Impl = options.webSocketImpl ?? globalThis.WebSocket;
+  if (!Impl) {
+    throw new Error("createSyncCollection requires WebSocket. Run in a browser or pass webSocketImpl.");
+  }
+  const confirmed = new Map;
+  const pending = [];
+  let mutationSeq = 0;
+  let state = {
+    data: [],
+    status: "connecting",
+    error: undefined
+  };
+  const listeners = new Set;
+  const setState = (patch) => {
+    state = { ...state, ...patch };
+    for (const listener of listeners) {
+      listener(state);
+    }
+  };
+  const recompute = (patch = {}) => {
+    const working = new Map(confirmed);
+    const draft = {
+      set: (row) => working.set(key(row), row),
+      delete: (rowKey) => working.delete(rowKey)
+    };
+    for (const mutation of pending) {
+      mutation.optimistic?.(draft);
+    }
+    setState({ ...patch, data: [...working.values()] });
+  };
+  let socket;
+  let connected = false;
+  let closed = false;
+  let attempt = 0;
+  let reconnectTimer;
+  let appliedVersion = 0;
+  const persist = () => {
+    options.storage?.save(pending.map((mutation) => ({
+      mutationId: mutation.mutationId,
+      name: mutation.name,
+      args: mutation.args
+    })));
+  };
+  const settlePending = (mutationId) => {
+    const index = pending.findIndex((mutation2) => mutation2.mutationId === mutationId);
+    if (index === -1) {
+      return;
+    }
+    const [mutation] = pending.splice(index, 1);
+    persist();
+    return mutation;
+  };
+  const applyFrame = (frame) => {
+    if (frame.type === "snapshot") {
+      confirmed.clear();
+      for (const row of frame.rows) {
+        confirmed.set(key(row), row);
+      }
+      if (frame.version !== undefined) {
+        appliedVersion = frame.version;
+      }
+      recompute({ status: "ready", error: undefined });
+    } else if (frame.type === "diff") {
+      for (const row of frame.removed) {
+        confirmed.delete(key(row));
+      }
+      for (const row of frame.added) {
+        confirmed.set(key(row), row);
+      }
+      for (const row of frame.changed) {
+        confirmed.set(key(row), row);
+      }
+      if (frame.version !== undefined) {
+        appliedVersion = Math.max(appliedVersion, frame.version);
+      }
+      recompute();
+    } else if (frame.type === "error") {
+      setState({ error: frame.message });
+      options.onError?.(frame.message);
+    } else if (frame.type === "ack") {
+      const mutation = settlePending(frame.mutationId);
+      if (mutation !== undefined) {
+        recompute();
+        mutation.resolve(frame.result);
+      }
+    } else if (frame.type === "reject") {
+      const mutation = settlePending(frame.mutationId);
+      if (mutation !== undefined) {
+        recompute();
+        mutation.reject(new Error(String(frame.message)));
+      }
+    }
+  };
+  const sendMutate = (mutation) => {
+    if (connected) {
+      socket?.send(JSON.stringify({
+        type: "mutate",
+        mutationId: mutation.mutationId,
+        name: mutation.name,
+        args: mutation.args
+      }));
+    }
+  };
+  const connect = () => {
+    if (closed) {
+      return;
+    }
+    setState({ status: "connecting" });
+    const ws = new Impl(options.url);
+    socket = ws;
+    ws.onopen = () => {
+      attempt = 0;
+      connected = true;
+      ws.send(JSON.stringify({
+        type: "subscribe",
+        id: SUBSCRIPTION_ID,
+        collection: options.collection,
+        params: options.params,
+        since: appliedVersion > 0 ? appliedVersion : undefined
+      }));
+      for (const mutation of pending) {
+        sendMutate(mutation);
+      }
+    };
+    ws.onmessage = (event) => {
+      try {
+        applyFrame(JSON.parse(event.data));
+      } catch {}
+    };
+    ws.onclose = () => {
+      connected = false;
+      if (closed || reconnectMs <= 0) {
+        return;
+      }
+      const delay = Math.min(reconnectMs * 2 ** attempt, maxReconnectMs);
+      attempt += 1;
+      reconnectTimer = setTimeout(connect, delay);
+    };
+  };
+  connect();
+  const hydratePersisted = async () => {
+    if (options.storage === undefined) {
+      return;
+    }
+    const records = await options.storage.load();
+    for (const record of records) {
+      if (pending.some((m) => m.mutationId === record.mutationId)) {
+        continue;
+      }
+      pending.push({
+        mutationId: record.mutationId,
+        name: record.name,
+        args: record.args,
+        resolve: () => {},
+        reject: () => {}
+      });
+      mutationSeq = Math.max(mutationSeq, record.mutationId);
+    }
+    if (connected) {
+      for (const mutation of pending) {
+        sendMutate(mutation);
+      }
+    }
+  };
+  hydratePersisted();
+  return {
+    get: () => state,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    mutate: (mutateOptions) => new Promise((resolve, reject) => {
+      const mutation = {
+        mutationId: mutationSeq += 1,
+        name: mutateOptions.name,
+        args: mutateOptions.args,
+        optimistic: mutateOptions.optimistic,
+        resolve: (result) => resolve(result),
+        reject
+      };
+      pending.push(mutation);
+      persist();
+      recompute();
+      sendMutate(mutation);
+    }),
+    close: () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      connected = false;
+      if (reconnectTimer !== undefined) {
+        clearTimeout(reconnectTimer);
+      }
+      try {
+        socket?.send(JSON.stringify({ type: "unsubscribe", id: SUBSCRIPTION_ID }));
+        socket?.close();
+      } catch {}
+      for (const mutation of pending.splice(0)) {
+        mutation.reject(new Error("sync collection closed"));
+      }
+      persist();
+      setState({ status: "closed" });
+      listeners.clear();
+    }
+  };
+};
+// src/client/presence.ts
+var createPresence = (options) => {
+  const reconnectMs = options.reconnectMs ?? 500;
+  const maxReconnectMs = options.maxReconnectMs ?? 1e4;
+  const Impl = options.webSocketImpl ?? globalThis.WebSocket;
+  if (!Impl) {
+    throw new Error("createPresence requires WebSocket. Run in a browser or pass webSocketImpl.");
+  }
+  const id = options.memberId ?? globalThis.crypto?.randomUUID?.() ?? `m${Math.random()}`;
+  const members = new Map;
+  let state = options.state;
+  let snapshot = [];
+  const listeners = new Set;
+  const emit = () => {
+    snapshot = [...members].map(([memberId, memberState]) => ({
+      id: memberId,
+      state: memberState
+    }));
+    for (const listener of listeners) {
+      listener(snapshot);
+    }
+  };
+  let socket;
+  let connected = false;
+  let closed = false;
+  let attempt = 0;
+  let reconnectTimer;
+  const send = (frame) => {
+    if (connected) {
+      socket?.send(JSON.stringify(frame));
+    }
+  };
+  const connect = () => {
+    if (closed) {
+      return;
+    }
+    const ws = new Impl(options.url);
+    socket = ws;
+    ws.onopen = () => {
+      attempt = 0;
+      connected = true;
+      ws.send(JSON.stringify({
+        type: "presence-join",
+        room: options.room,
+        memberId: id,
+        state
+      }));
+    };
+    ws.onmessage = (event) => {
+      let frame;
+      try {
+        frame = JSON.parse(event.data);
+      } catch {
+        return;
+      }
+      if (frame.type !== "presence" || frame.room !== options.room) {
+        return;
+      }
+      for (const member of frame.joined ?? []) {
+        members.set(member.id, member.state);
+      }
+      for (const member of frame.updated ?? []) {
+        members.set(member.id, member.state);
+      }
+      for (const memberId of frame.left ?? []) {
+        members.delete(memberId);
+      }
+      emit();
+    };
+    ws.onclose = () => {
+      connected = false;
+      if (closed || reconnectMs <= 0) {
+        return;
+      }
+      const delay = Math.min(reconnectMs * 2 ** attempt, maxReconnectMs);
+      attempt += 1;
+      reconnectTimer = setTimeout(connect, delay);
+    };
+  };
+  connect();
+  return {
+    id,
+    get: () => snapshot,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      listener(snapshot);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    set: (next) => {
+      state = next;
+      send({ type: "presence-set", room: options.room, state: next });
+    },
+    close: () => {
+      closed = true;
+      if (reconnectTimer !== undefined) {
+        clearTimeout(reconnectTimer);
+      }
+      send({ type: "presence-leave", room: options.room });
+      socket?.close();
+      members.clear();
+    }
+  };
+};
+// src/client/syncClient.ts
+var createSyncClient = (options) => {
+  const reconnectMs = options.reconnectMs ?? 500;
+  const maxReconnectMs = options.maxReconnectMs ?? 1e4;
+  const Impl = options.webSocketImpl ?? globalThis.WebSocket;
+  if (!Impl) {
+    throw new Error("createSyncClient requires WebSocket. Run in a browser or pass webSocketImpl.");
+  }
+  const entries = new Map;
+  const mutationOwner = new Map;
+  let nextEntryId = 0;
+  let mutationSeq = 0;
+  let socket;
+  let connected = false;
+  let closed = false;
+  let attempt = 0;
+  let reconnectTimer;
+  const notify = (entry) => {
+    for (const listener of entry.listeners) {
+      listener(entry.state);
+    }
+  };
+  const rebuild = (entry, patch = {}) => {
+    const working = new Map(entry.confirmed);
+    const draft = {
+      set: (row) => working.set(entry.key(row), row),
+      delete: (rowKey) => working.delete(rowKey)
+    };
+    for (const mutation of entry.pending) {
+      mutation.optimistic?.(draft);
+    }
+    entry.state = {
+      ...entry.state,
+      ...patch,
+      data: [...working.values()]
+    };
+  };
+  const recompute = (entry, patch = {}) => {
+    rebuild(entry, patch);
+    notify(entry);
+  };
+  const applyDiffToConfirmed = (entry, diff) => {
+    for (const row of diff.removed) {
+      entry.confirmed.delete(entry.key(row));
+    }
+    for (const row of diff.added) {
+      entry.confirmed.set(entry.key(row), row);
+    }
+    for (const row of diff.changed) {
+      entry.confirmed.set(entry.key(row), row);
+    }
+  };
+  const settlePending = (mutationId) => {
+    const entry = mutationOwner.get(mutationId);
+    mutationOwner.delete(mutationId);
+    if (entry === undefined) {
+      return;
+    }
+    const index = entry.pending.findIndex((mutation2) => mutation2.mutationId === mutationId);
+    if (index === -1) {
+      return;
+    }
+    const [mutation] = entry.pending.splice(index, 1);
+    return { entry, mutation };
+  };
+  const applyFrame = (frame) => {
+    if (frame.type === "snapshot") {
+      const entry = entries.get(frame.id);
+      if (entry === undefined) {
+        return;
+      }
+      entry.confirmed.clear();
+      for (const row of frame.rows) {
+        entry.confirmed.set(entry.key(row), row);
+      }
+      if (frame.version !== undefined) {
+        entry.appliedVersion = frame.version;
+      }
+      recompute(entry, { status: "ready", error: undefined });
+    } else if (frame.type === "diff") {
+      const entry = entries.get(frame.id);
+      if (entry === undefined) {
+        return;
+      }
+      applyDiffToConfirmed(entry, frame);
+      if (frame.version !== undefined) {
+        entry.appliedVersion = Math.max(entry.appliedVersion, frame.version);
+      }
+      recompute(entry);
+    } else if (frame.type === "frame") {
+      const affected = new Set;
+      for (const diff of frame.diffs) {
+        const entry = entries.get(diff.id);
+        if (entry === undefined) {
+          continue;
+        }
+        applyDiffToConfirmed(entry, diff);
+        if (frame.version !== undefined) {
+          entry.appliedVersion = Math.max(entry.appliedVersion, frame.version);
+        }
+        rebuild(entry);
+        affected.add(entry);
+      }
+      for (const entry of affected) {
+        notify(entry);
+      }
+    } else if (frame.type === "error") {
+      if (frame.id !== undefined) {
+        const entry = entries.get(frame.id);
+        if (entry !== undefined) {
+          recompute(entry, { error: frame.message });
+        }
+      }
+      options.onError?.(frame.message);
+    } else if (frame.type === "ack") {
+      const settled = settlePending(frame.mutationId);
+      if (settled !== undefined) {
+        recompute(settled.entry);
+        settled.mutation.resolve(frame.result);
+      }
+    } else if (frame.type === "reject") {
+      const settled = settlePending(frame.mutationId);
+      if (settled !== undefined) {
+        recompute(settled.entry);
+        settled.mutation.reject(new Error(String(frame.message)));
+      }
+    }
+  };
+  const sendSubscribe = (entry) => {
+    socket?.send(JSON.stringify({
+      type: "subscribe",
+      id: entry.id,
+      collection: entry.collection,
+      params: entry.params,
+      since: entry.appliedVersion > 0 ? entry.appliedVersion : undefined
+    }));
+  };
+  const sendMutate = (mutation) => {
+    if (connected) {
+      socket?.send(JSON.stringify({
+        type: "mutate",
+        mutationId: mutation.mutationId,
+        name: mutation.name,
+        args: mutation.args
+      }));
+    }
+  };
+  const connect = () => {
+    if (closed) {
+      return;
+    }
+    const ws = new Impl(options.url);
+    socket = ws;
+    ws.onopen = () => {
+      attempt = 0;
+      connected = true;
+      for (const entry of entries.values()) {
+        sendSubscribe(entry);
+      }
+      for (const entry of entries.values()) {
+        for (const mutation of entry.pending) {
+          sendMutate(mutation);
+        }
+      }
+    };
+    ws.onmessage = (event) => {
+      try {
+        applyFrame(JSON.parse(event.data));
+      } catch {}
+    };
+    ws.onclose = () => {
+      connected = false;
+      if (closed || reconnectMs <= 0) {
+        return;
+      }
+      const delay = Math.min(reconnectMs * 2 ** attempt, maxReconnectMs);
+      attempt += 1;
+      reconnectTimer = setTimeout(connect, delay);
+    };
+  };
+  connect();
+  const collection = (handleOptions) => {
+    const entryId = `c${nextEntryId}`;
+    nextEntryId += 1;
+    const entry = {
+      id: entryId,
+      collection: handleOptions.collection,
+      params: handleOptions.params,
+      key: handleOptions.key ?? ((row) => row.id),
+      confirmed: new Map,
+      pending: [],
+      state: { data: [], status: "connecting", error: undefined },
+      listeners: new Set,
+      appliedVersion: 0,
+      closed: false
+    };
+    entries.set(entryId, entry);
+    if (connected) {
+      sendSubscribe(entry);
+    }
+    return {
+      get: () => entry.state,
+      subscribe: (listener) => {
+        const typed = listener;
+        entry.listeners.add(typed);
+        listener(entry.state);
+        return () => {
+          entry.listeners.delete(typed);
+        };
+      },
+      mutate: (mutateOptions) => new Promise((resolve, reject) => {
+        mutationSeq += 1;
+        const mutation = {
+          mutationId: mutationSeq,
+          name: mutateOptions.name,
+          args: mutateOptions.args,
+          optimistic: mutateOptions.optimistic,
+          resolve: (result) => resolve(result),
+          reject
+        };
+        entry.pending.push(mutation);
+        mutationOwner.set(mutation.mutationId, entry);
+        recompute(entry);
+        sendMutate(mutation);
+      }),
+      close: () => {
+        if (entry.closed) {
+          return;
+        }
+        entry.closed = true;
+        entries.delete(entryId);
+        if (connected) {
+          socket?.send(JSON.stringify({ type: "unsubscribe", id: entryId }));
+        }
+      }
+    };
+  };
+  const close = () => {
+    closed = true;
+    if (reconnectTimer !== undefined) {
+      clearTimeout(reconnectTimer);
+    }
+    socket?.close();
+    entries.clear();
+    mutationOwner.clear();
+  };
+  return { collection, close };
+};
+// src/client/syncStore.ts
+var SUBSCRIPTION_ID2 = "s";
+var syncStore = (options) => {
+  const key = options.key ?? ((row) => row.id);
+  const reconnectMs = options.reconnectMs ?? 500;
+  const maxReconnectMs = options.maxReconnectMs ?? 1e4;
+  const reconcileGraceMs = options.reconcileGraceMs ?? 3000;
+  const mutations = options.mutations ?? {};
+  const Impl = options.webSocketImpl ?? globalThis.WebSocket;
+  if (!Impl) {
+    throw new Error("syncStore requires WebSocket. Run in a browser or pass webSocketImpl.");
+  }
+  const confirmed = new Map;
+  const pending = [];
+  let mutationSeq = 0;
+  let state = {
+    data: options.initialData ? [...options.initialData] : [],
+    status: "connecting",
+    error: undefined
+  };
+  if (options.initialData) {
+    for (const row of options.initialData) {
+      confirmed.set(key(row), row);
+    }
+  }
+  const listeners = new Set;
+  const setState = (patch) => {
+    state = { ...state, ...patch };
+    for (const listener of listeners) {
+      listener(state);
+    }
+  };
+  const recompute = (patch = {}) => {
+    const working = new Map(confirmed);
+    const draft = {
+      set: (row) => working.set(key(row), row),
+      delete: (rowKey) => working.delete(rowKey)
+    };
+    for (const mutation of pending) {
+      mutation.optimistic?.(draft);
+    }
+    setState({ ...patch, data: [...working.values()] });
+  };
+  const persist = () => {
+    options.storage?.save(pending.map((mutation) => ({
+      mutationId: mutation.id,
+      name: mutation.name,
+      args: mutation.args
+    })));
+  };
+  const dropPending = (mutation) => {
+    const index = pending.indexOf(mutation);
+    if (index !== -1) {
+      pending.splice(index, 1);
+    }
+    if (mutation.graceTimer !== undefined) {
+      clearTimeout(mutation.graceTimer);
+    }
+  };
+  const reconcileSettled = () => {
+    let changed = false;
+    for (const mutation of [...pending]) {
+      if (!mutation.settled) {
+        continue;
+      }
+      let reflected = true;
+      for (const [rowKey, kind] of mutation.touched) {
+        const present = confirmed.has(rowKey);
+        if (kind === "set" ? !present : present) {
+          reflected = false;
+          break;
+        }
+      }
+      if (reflected) {
+        dropPending(mutation);
+        changed = true;
+      }
+    }
+    if (changed) {
+      recompute();
+    }
+  };
+  let socket;
+  let connected = false;
+  let closed = false;
+  let attempt = 0;
+  let reconnectTimer;
+  let appliedVersion = 0;
+  const applyFrame = (frame) => {
+    if (frame.type === "snapshot") {
+      confirmed.clear();
+      for (const row of frame.rows) {
+        confirmed.set(key(row), row);
+      }
+      if (frame.version !== undefined) {
+        appliedVersion = frame.version;
+      }
+      recompute({ status: "ready", error: undefined });
+      reconcileSettled();
+    } else if (frame.type === "diff") {
+      for (const row of frame.removed) {
+        confirmed.delete(key(row));
+      }
+      for (const row of frame.added) {
+        confirmed.set(key(row), row);
+      }
+      for (const row of frame.changed) {
+        confirmed.set(key(row), row);
+      }
+      if (frame.version !== undefined) {
+        appliedVersion = Math.max(appliedVersion, frame.version);
+      }
+      recompute();
+      reconcileSettled();
+    } else if (frame.type === "error") {
+      setState({ error: frame.message });
+      options.onError?.(frame.message);
+    }
+  };
+  const runMutation = async (mutation) => {
+    if (mutation.inFlight || mutation.settled) {
+      return;
+    }
+    const run = mutations[mutation.name];
+    if (run === undefined) {
+      dropPending(mutation);
+      recompute();
+      mutation.reject(new Error(`Unknown mutation "${mutation.name}"`));
+      return;
+    }
+    mutation.inFlight = true;
+    try {
+      const result = await run(mutation.args);
+      mutation.inFlight = false;
+      mutation.settled = true;
+      mutation.resolve(result);
+      persist();
+      reconcileSettled();
+      if (pending.includes(mutation)) {
+        mutation.graceTimer = setTimeout(() => {
+          dropPending(mutation);
+          recompute();
+        }, reconcileGraceMs);
+      }
+    } catch (error) {
+      mutation.inFlight = false;
+      if (connected) {
+        dropPending(mutation);
+        recompute();
+        persist();
+        mutation.reject(error);
+      } else {
+        options.onError?.(error);
+      }
+    }
+  };
+  const connect = () => {
+    if (closed) {
+      return;
+    }
+    setState({ status: "connecting" });
+    const ws = new Impl(options.url);
+    socket = ws;
+    ws.onopen = () => {
+      attempt = 0;
+      connected = true;
+      ws.send(JSON.stringify({
+        type: "subscribe",
+        id: SUBSCRIPTION_ID2,
+        collection: options.collection,
+        params: options.params,
+        since: appliedVersion > 0 ? appliedVersion : undefined
+      }));
+      for (const mutation of pending) {
+        if (!mutation.settled && !mutation.inFlight) {
+          runMutation(mutation);
+        }
+      }
+    };
+    ws.onmessage = (event) => {
+      try {
+        applyFrame(JSON.parse(event.data));
+      } catch {}
+    };
+    ws.onclose = () => {
+      connected = false;
+      if (closed || reconnectMs <= 0) {
+        return;
+      }
+      const delay = Math.min(reconnectMs * 2 ** attempt, maxReconnectMs);
+      attempt += 1;
+      reconnectTimer = setTimeout(connect, delay);
+    };
+  };
+  const eagerHydrate = async () => {
+    if (options.hydrate === undefined || options.initialData !== undefined) {
+      return;
+    }
+    try {
+      const rows = await options.hydrate();
+      if (state.status !== "ready") {
+        confirmed.clear();
+        for (const row of rows) {
+          confirmed.set(key(row), row);
+        }
+        recompute({ status: "ready" });
+      }
+    } catch (error) {
+      options.onError?.(error);
+    }
+  };
+  const hydratePersisted = async () => {
+    if (options.storage === undefined) {
+      return;
+    }
+    const records = await options.storage.load();
+    for (const record of records) {
+      if (pending.some((m) => m.id === record.mutationId)) {
+        continue;
+      }
+      pending.push({
+        id: record.mutationId,
+        name: record.name,
+        args: record.args,
+        touched: new Map,
+        settled: false,
+        inFlight: false,
+        resolve: () => {},
+        reject: () => {}
+      });
+      mutationSeq = Math.max(mutationSeq, record.mutationId);
+    }
+    if (connected) {
+      for (const mutation of pending) {
+        runMutation(mutation);
+      }
+    }
+  };
+  connect();
+  eagerHydrate();
+  hydratePersisted();
+  const collectTouched = (optimistic) => {
+    const touched = new Map;
+    optimistic?.({
+      set: (row) => touched.set(key(row), "set"),
+      delete: (rowKey) => touched.set(rowKey, "delete")
+    });
+    return touched;
+  };
+  return {
+    get: () => state,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    mutate: (name, args, mutateOptions) => new Promise((resolve, reject) => {
+      const mutation = {
+        id: mutationSeq += 1,
+        name,
+        args,
+        touched: collectTouched(mutateOptions?.optimistic),
+        optimistic: mutateOptions?.optimistic,
+        settled: false,
+        inFlight: false,
+        resolve,
+        reject
+      };
+      pending.push(mutation);
+      persist();
+      recompute();
+      runMutation(mutation);
+    }),
+    refetch: async () => {
+      if (options.hydrate === undefined) {
+        return;
+      }
+      const rows = await options.hydrate();
+      confirmed.clear();
+      for (const row of rows) {
+        confirmed.set(key(row), row);
+      }
+      recompute({ status: "ready" });
+    },
+    close: () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      connected = false;
+      if (reconnectTimer !== undefined) {
+        clearTimeout(reconnectTimer);
+      }
+      try {
+        socket?.send(JSON.stringify({ type: "unsubscribe", id: SUBSCRIPTION_ID2 }));
+        socket?.close();
+      } catch {}
+      for (const mutation of pending.splice(0)) {
+        if (mutation.graceTimer !== undefined) {
+          clearTimeout(mutation.graceTimer);
+        }
+        mutation.reject(new Error("sync store closed"));
+      }
+      persist();
+      setState({ status: "closed" });
+      listeners.clear();
+    }
+  };
+};
+var unwrapEden = async (response) => {
+  const { data, error } = await response;
+  if (error !== null && error !== undefined) {
+    throw error;
+  }
+  return data;
+};
 export {
-  createSyncSubscriber
+  unwrapEden,
+  syncStore,
+  localStorageMutationStorage,
+  jsonFetcher,
+  createSyncSubscriber,
+  createSyncCollection,
+  createSyncClient,
+  createPresence,
+  createLiveQuery
 };
 
-//# debugId=10D2496AED02ED9364756E2164756E21
+//# debugId=E83DAC6C389DAA6A64756E2164756E21
 //# sourceMappingURL=index.js.map