@rozek/sds-sync-engine 0.0.1

package/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2026-present Andreas Rozek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,196 @@
+# @rozek/sds-sync-engine
+
+The orchestration layer of the **shareable-data-store** (SDS) family. `SDS_SyncEngine` wires an `SDS_DataStore` to a persistence provider, a network provider, and a presence provider, and manages the full lifecycle: startup restore, offline patch queuing, automatic checkpointing, large-value transfer, and presence heartbeats.
+
+---
+
+## Installation
+
+```bash
+pnpm add @rozek/sds-sync-engine
+```
+
+---
+
+## Concepts
+
+### Startup restore
+
+When `start()` is called, the engine loads the latest snapshot from the persistence provider and replays all patches recorded since that snapshot. The store is in a consistent, up-to-date state before `start()` resolves.
+
+### Offline queue
+
+While the network connection is in `'disconnected'` or `'reconnecting'` state, outgoing patches are queued in memory. As soon as the connection transitions to `'connected'`, the queue is flushed in order.
+
+### Automatic checkpointing
+
+Every local mutation's patch bytes are accumulated. When the total crosses **512 KB**, the engine writes a new snapshot and prunes all patches up to that point. A final checkpoint is also written on `stop()` if there are any un-checkpointed patches.
+
+### Large-Value Transfer
+
+When a data's value changes to a reference kind (`'literal-reference'` or `'binary-reference'`), the engine sends the blob to the network provider. When the store receives a patch referencing an unknown blob hash, the engine requests the blob from the network provider.
+
+### Presence Heartbeat
+
+The engine periodically re-broadcasts the local presence state so that remote peers can detect stale entries (timeout controlled by `PresenceTimeoutMs`).
+
+### BroadcastChannel (Browser / Tauri)
+
+When running in a browser or Tauri context, the engine optionally uses a `BroadcastChannel` to relay patches and presence frames between tabs opened on the same origin, without going through the server.
+
+---
+
+## API Reference
+
+### `SDS_SyncEngine`
+
+```typescript
+import { SDS_SyncEngine } from '@rozek/sds-sync-engine'
+
+class SDS_SyncEngine {
+  constructor (Store:SDS_DataStore, Options?:SDS_SyncEngineOptions)
+
+/**** Lifecycle ****/
+
+  start ():Promise<void>   // restore, wire providers
+  stop ():Promise<void>    // flush queue, write checkpoint, close providers
+
+/**** Network ****/
+
+  connectTo (URL:string, Options:SDS_ConnectionOptions):Promise<void>
+  disconnect ():void
+  reconnect ():Promise<void>
+
+  get ConnectionState ():SDS_ConnectionState
+  onConnectionChange (Callback:(State:SDS_ConnectionState) => void):() => void
+
+/**** Presence ****/
+
+  readonly PeerId:string   // unique identifier for this engine instance (UUID)
+
+  setPresenceTo (State:SDS_LocalPresenceState):void
+  readonly PeerSet:ReadonlyMap<string, SDS_RemotePresenceState>
+  onPresenceChange(
+    Callback:(
+      PeerId:string,
+      State: SDS_RemotePresenceState | undefined,
+      Origin:'local' | 'remote'
+    ) => void
+  ):() => void
+}
+```
+
+### `SDS_SyncEngineOptions`
+
+```typescript
+interface SDS_SyncEngineOptions {
+  PersistenceProvider?:SDS_PersistenceProvider  // SQLite or IndexedDB
+  NetworkProvider?:    SDS_NetworkProvider       // WebSocket or WebRTC
+  PresenceProvider?:   SDS_PresenceProvider      // often the same as NetworkProvider
+  BroadcastChannel?:   boolean                   // cross-tab relay (default: true in browser)
+  PresenceTimeoutMs?:  number                    // peer inactivity timeout (default: 120 000 ms)
+}
+```
+
+All providers are optional. You can use any combination — for example persistence only (no network), or network only (no persistence).
+
+### Error codes
+
+| Code | Thrown by | Reason |
+| --- | --- | --- |
+| `'no-network-provider'` | `connectTo()` | No `NetworkProvider` was configured |
+| `'not-yet-connected'` | `reconnect()` | `connectTo()` has never been called successfully |
+
+---
+
+## Usage
+
+### Persistence only — offline-capable local Store
+
+```typescript
+import { SDS_DataStore }                  from '@rozek/sds-core'
+import { SDS_DesktopPersistenceProvider } from '@rozek/sds-persistence-node'
+import { SDS_SyncEngine }                 from '@rozek/sds-sync-engine'
+
+const DataStore   = SDS_DataStore.fromScratch()
+const Persistence = new SDS_DesktopPersistenceProvider('./data', 'my-store')
+
+const engine = new SDS_SyncEngine(DataStore, { PersistenceProvider:Persistence })
+await engine.start()
+
+const data = DataStore.newItemAt('text/plain', DataStore.RootItem)
+data.Label = 'This data survives restarts'
+
+await engine.stop()  // writes checkpoint, closes DB
+```
+
+### Full Stack — Persistence + WebSocket + Presence
+
+```typescript
+import { SDS_DataStore }                  from '@rozek/sds-core'
+import { SDS_BrowserPersistenceProvider } from '@rozek/sds-persistence-browser'
+import { SDS_WebSocketProvider }          from '@rozek/sds-network-websocket'
+import { SDS_SyncEngine }                 from '@rozek/sds-sync-engine'
+
+const DataStore   = SDS_DataStore.fromScratch()
+const Persistence = new SDS_BrowserPersistenceProvider('my-store')
+const Network     = new SDS_WebSocketProvider('my-store')
+
+const SyncEngine = new SDS_SyncEngine(DataStore, {
+  PersistenceProvider:Persistence,
+  NetworkProvider: Network,
+  PresenceProvider:Network,
+})
+
+await SyncEngine.start()
+await SyncEngine.connectTo('wss://my-server.example.com', { Token:'<jwt>' })
+
+SyncEngine.onConnectionChange((ConnectionState) => {
+  if (ConnectionState === 'connected')    console.log('Online — syncing')
+  if (ConnectionState === 'reconnecting') console.log('Offline — patches queued')
+})
+```
+
+### Presence — show Collaborators
+
+```typescript
+// announce yourself
+SyncEngine.setPresenceTo({
+  UserName: 'Alice',
+  UserColor:'#3498db',
+  UserFocus:{ EntryId:data.Id, Property:'Value', Cursor:{ from:4, to:4 } },
+})
+
+// react to any peer change (local or remote)
+SyncEngine.onPresenceChange((PeerId,PeerState,Origin) => {
+  if (PeerState == null) {
+    // peer timed out
+    removeAvatarFor(PeerId)
+  } else if (Origin === 'remote') {
+    showAvatarFor(PeerId,PeerState)
+  }
+})
+
+// snapshot of all currently active peers
+for (const [PeerId,PeerState] of SyncEngine.PeerSet) {
+  console.log(PeerId, PeerState.UserName, PeerState.UserFocus)
+}
+```
+
+### Reconnect after a planned disconnect
+
+```typescript
+await SyncEngine.connectTo('wss://my-server.example.com', { Token:'<jwt>' })
+
+// … later …
+SyncEngine.disconnect()
+
+// … reconnect using the same URL and token
+await SyncEngine.reconnect()
+```
+
+---
+
+## License
+
+MIT © Andreas Rozek

package/dist/sds-sync-engine.d.ts

@@ -0,0 +1,44 @@
+import { SDS_ConnectionOptions } from '@rozek/sds-core';
+import { SDS_ConnectionState } from '@rozek/sds-core';
+import { SDS_DataStore } from '@rozek/sds-core';
+import { SDS_LocalPresenceState } from '@rozek/sds-core';
+import { SDS_NetworkProvider } from '@rozek/sds-core';
+import { SDS_PersistenceProvider } from '@rozek/sds-core';
+import { SDS_PresenceProvider } from '@rozek/sds-core';
+import { SDS_RemotePresenceState } from '@rozek/sds-core';
+
+export declare class SDS_SyncEngine {
+    #private;
+    readonly PeerId: string;
+    constructor(Store: SDS_DataStore, Options?: SDS_SyncEngineOptions);
+    /**** start ****/
+    start(): Promise<void>;
+    /**** stop ****/
+    stop(): Promise<void>;
+    /**** connectTo ****/
+    connectTo(URL: string, Options: SDS_ConnectionOptions): Promise<void>;
+    /**** disconnect ****/
+    disconnect(): void;
+    /**** reconnect ****/
+    reconnect(): Promise<void>;
+    /**** ConnectionState ****/
+    get ConnectionState(): SDS_ConnectionState;
+    /**** onConnectionChange ****/
+    onConnectionChange(Callback: (State: SDS_ConnectionState) => void): () => void;
+    /**** setPresenceTo ****/
+    setPresenceTo(State: Omit<SDS_LocalPresenceState, never>): void;
+    /**** PeerSet (remote peers only) ****/
+    get PeerSet(): ReadonlyMap<string, SDS_RemotePresenceState>;
+    /**** onPresenceChange ****/
+    onPresenceChange(Callback: (PeerId: string, State: SDS_RemotePresenceState | undefined, Origin: 'local' | 'remote') => void): () => void;
+}
+
+export declare interface SDS_SyncEngineOptions {
+    PersistenceProvider?: SDS_PersistenceProvider;
+    NetworkProvider?: SDS_NetworkProvider;
+    PresenceProvider?: SDS_PresenceProvider;
+    BroadcastChannel?: boolean;
+    PresenceTimeoutMs?: number;
+}
+
+export { }

package/dist/sds-sync-engine.js

@@ -0,0 +1,321 @@
+var st = Object.defineProperty;
+var z = (n) => {
+  throw TypeError(n);
+};
+var it = (n, e, s) => e in n ? st(n, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : n[e] = s;
+var F = (n, e, s) => it(n, typeof e != "symbol" ? e + "" : e, s), A = (n, e, s) => e.has(n) || z("Cannot " + s);
+var t = (n, e, s) => (A(n, e, "read from private field"), s ? s.call(n) : e.get(n)), r = (n, e, s) => e.has(n) ? z("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(n) : e.set(n, s), c = (n, e, s, i) => (A(n, e, "write to private field"), i ? i.call(n, s) : e.set(n, s), s), v = (n, e, s) => (A(n, e, "access private method"), s);
+var G = (n, e, s, i) => ({
+  set _(o) {
+    c(n, e, o, s);
+  },
+  get _() {
+    return t(n, e, i);
+  }
+});
+import { SDS_Error as U } from "@rozek/sds-core";
+const ot = 512 * 1024;
+var u, d, a, P, k, L, N, _, H, M, C, D, T, b, B, S, m, w, x, R, g, y, h, J, K, W, X, Y, Q, Z, I, O, tt, j;
+class at {
+  //----------------------------------------------------------------------------//
+  //                                Constructor                                 //
+  //----------------------------------------------------------------------------//
+  constructor(e, s = {}) {
+    r(this, h);
+    r(this, u);
+    r(this, d);
+    r(this, a);
+    r(this, P);
+    r(this, k);
+    F(this, "PeerId", crypto.randomUUID());
+    r(this, L);
+    r(this, N);
+    r(this, _, []);
+    // outgoing patch queue (patches created while disconnected)
+    r(this, H, 0);
+    // accumulated patch bytes since last checkpoint
+    r(this, M, 0);
+    // sequence number of the last saved snapshot
+    r(this, C, 0);
+    // current patch sequence # (append-monotonic counter, managed by SyncEngine)
+    // CRDT cursor captured after the last processed local change;
+    // passed to Store.exportPatch() to retrieve exactly that one change.
+    // Initialised to an empty cursor; updated in #loadAndRestore and after
+    // each local mutation.  Backend-agnostic: the DataStore owns the format.
+    r(this, D, new Uint8Array(0));
+    // heartbeat timer
+    r(this, T);
+    r(this, b);
+    // presence peer tracking
+    r(this, B, /* @__PURE__ */ new Map());
+    r(this, S, /* @__PURE__ */ new Map());
+    r(this, m, /* @__PURE__ */ new Set());
+    // BroadcastChannel (optional, browser/tauri only)
+    r(this, w);
+    // connection state mirror
+    r(this, x, "disconnected");
+    r(this, R, /* @__PURE__ */ new Set());
+    // unsubscribe functions for registered handlers
+    r(this, g, []);
+    // tracks entryId → blob hash for all entries whose value is in a *-reference kind;
+    // used to call releaseValue() when the entry's value changes or the entry is purged
+    r(this, y, /* @__PURE__ */ new Map());
+    c(this, u, e), c(this, d, s.PersistenceProvider ?? void 0), c(this, a, s.NetworkProvider ?? void 0), c(this, P, s.PresenceProvider ?? s.NetworkProvider ?? void 0), c(this, k, s.PresenceTimeoutMs ?? 12e4), (s.BroadcastChannel ?? !0) && typeof BroadcastChannel < "u" && t(this, a) != null && c(this, w, new BroadcastChannel(`sns:${t(this, a).StoreId}`));
+  }
+  //----------------------------------------------------------------------------//
+  //                                 Lifecycle                                  //
+  //----------------------------------------------------------------------------//
+  /**** start ****/
+  async start() {
+    t(this, d) != null && t(this, u).setValueBlobLoader(
+      (e) => t(this, d).loadValue(e)
+    ), await v(this, h, J).call(this), v(this, h, K).call(this), v(this, h, W).call(this), v(this, h, X).call(this), v(this, h, Y).call(this), t(this, a) != null && t(this, a).onConnectionChange((e) => {
+      c(this, x, e);
+      for (const s of t(this, R))
+        try {
+          s(e);
+        } catch {
+        }
+      e === "connected" && v(this, h, Z).call(this);
+    });
+  }
+  /**** stop ****/
+  async stop() {
+    var e, s, i;
+    t(this, T) != null && (clearInterval(t(this, T)), c(this, T, void 0));
+    for (const o of t(this, S).values())
+      clearTimeout(o);
+    t(this, S).clear();
+    for (const o of t(this, g))
+      try {
+        o();
+      } catch {
+      }
+    c(this, g, []), (e = t(this, w)) == null || e.close(), c(this, w, void 0), (s = t(this, a)) == null || s.disconnect(), t(this, d) != null && t(this, H) > 0 && await v(this, h, Q).call(this), await ((i = t(this, d)) == null ? void 0 : i.close());
+  }
+  //----------------------------------------------------------------------------//
+  //                             Network Connection                             //
+  //----------------------------------------------------------------------------//
+  /**** connectTo ****/
+  async connectTo(e, s) {
+    if (t(this, a) == null)
+      throw new U("no-network-provider", "no NetworkProvider configured");
+    c(this, L, e), c(this, N, s), await t(this, a).connect(e, s);
+  }
+  /**** disconnect ****/
+  disconnect() {
+    if (t(this, a) == null)
+      throw new U("no-network-provider", "no NetworkProvider configured");
+    t(this, a).disconnect();
+  }
+  /**** reconnect ****/
+  async reconnect() {
+    if (t(this, a) == null)
+      throw new U("no-network-provider", "no NetworkProvider configured");
+    if (t(this, L) == null)
+      throw new U(
+        "not-yet-connected",
+        "connectTo() has not been called yet; cannot reconnect"
+      );
+    await t(this, a).connect(t(this, L), t(this, N));
+  }
+  /**** ConnectionState ****/
+  get ConnectionState() {
+    return t(this, x);
+  }
+  /**** onConnectionChange ****/
+  onConnectionChange(e) {
+    return t(this, R).add(e), () => {
+      t(this, R).delete(e);
+    };
+  }
+  //----------------------------------------------------------------------------//
+  //                                  Presence                                  //
+  //----------------------------------------------------------------------------//
+  /**** setPresenceTo ****/
+  setPresenceTo(e) {
+    var i, o;
+    c(this, b, e);
+    const s = { ...e, PeerId: this.PeerId };
+    (i = t(this, P)) == null || i.sendLocalState(e), (o = t(this, w)) == null || o.postMessage({ type: "presence", payload: e });
+    for (const l of t(this, m))
+      try {
+        l(this.PeerId, s, "local");
+      } catch (f) {
+        console.error("SDS: presence handler failed", f);
+      }
+  }
+  /**** PeerSet (remote peers only) ****/
+  get PeerSet() {
+    return t(this, B);
+  }
+  /**** onPresenceChange ****/
+  onPresenceChange(e) {
+    return t(this, m).add(e), () => {
+      t(this, m).delete(e);
+    };
+  }
+}
+u = new WeakMap(), d = new WeakMap(), a = new WeakMap(), P = new WeakMap(), k = new WeakMap(), L = new WeakMap(), N = new WeakMap(), _ = new WeakMap(), H = new WeakMap(), M = new WeakMap(), C = new WeakMap(), D = new WeakMap(), T = new WeakMap(), b = new WeakMap(), B = new WeakMap(), S = new WeakMap(), m = new WeakMap(), w = new WeakMap(), x = new WeakMap(), R = new WeakMap(), g = new WeakMap(), y = new WeakMap(), h = new WeakSet(), J = async function() {
+  if (t(this, d) == null)
+    return;
+  await t(this, d).loadSnapshot();
+  const e = await t(this, d).loadPatchesSince(t(this, M));
+  for (const s of e)
+    try {
+      t(this, u).applyRemotePatch(s);
+    } catch {
+    }
+  e.length > 0 && c(this, C, t(this, M) + e.length), c(this, D, t(this, u).currentCursor);
+}, //----------------------------------------------------------------------------//
+//                                   Wiring                                   //
+//----------------------------------------------------------------------------//
+/**** #wireStoreToProviders — subscribes to local store changes and routes them to persistence and network ****/
+K = function() {
+  const e = t(this, u).onChangeInvoke((s, i) => {
+    var f, q;
+    if (s === "external") {
+      v(this, h, I).call(this, i, "request").catch(() => {
+      });
+      return;
+    }
+    const o = t(this, D);
+    G(this, C)._++;
+    const l = t(this, u).exportPatch(o);
+    c(this, D, t(this, u).currentCursor), l.byteLength !== 0 && (t(this, d) != null && (t(this, d).appendPatch(l, t(this, C)).catch(() => {
+    }), c(this, H, t(this, H) + l.byteLength), t(this, H) >= ot && v(this, h, Q).call(this).catch(() => {
+    })), ((f = t(this, a)) == null ? void 0 : f.ConnectionState) === "connected" ? (t(this, a).sendPatch(l), (q = t(this, w)) == null || q.postMessage({ type: "patch", payload: l })) : t(this, _).push(l), v(this, h, I).call(this, i, "send").catch(() => {
+    }));
+  });
+  t(this, g).push(e);
+}, /**** #wireNetworkToStore — subscribes to incoming network patches and presence events ****/
+W = function() {
+  if (t(this, a) != null) {
+    const s = t(this, a).onPatch((o) => {
+      try {
+        t(this, u).applyRemotePatch(o);
+      } catch {
+      }
+    });
+    t(this, g).push(s);
+    const i = t(this, a).onValue(async (o, l) => {
+      var f;
+      t(this, u).storeValueBlob(o, l), await ((f = t(this, d)) == null ? void 0 : f.saveValue(o, l));
+    });
+    t(this, g).push(i);
+  }
+  const e = t(this, P);
+  if (e != null) {
+    const s = e.onRemoteState((i, o) => {
+      v(this, h, O).call(this, i, o);
+    });
+    t(this, g).push(s);
+  }
+}, /**** #wirePresenceHeartbeat — starts a periodic timer to re-broadcast local presence state ****/
+X = function() {
+  const e = t(this, k) / 4;
+  c(this, T, setInterval(() => {
+    var s, i;
+    t(this, b) != null && ((s = t(this, P)) == null || s.sendLocalState(t(this, b)), (i = t(this, w)) == null || i.postMessage({ type: "presence", payload: t(this, b) }));
+  }, e));
+}, /**** #wireBroadcastChannel — wires the BroadcastChannel for cross-tab patch and presence relay ****/
+Y = function() {
+  t(this, w) != null && (t(this, w).onmessage = (e) => {
+    var i;
+    const s = e.data;
+    switch (!0) {
+      case s.type === "patch":
+        try {
+          t(this, u).applyRemotePatch(s.payload);
+        } catch (o) {
+          console.error("SDS: failed to apply remote patch from BroadcastChannel", o);
+        }
+        break;
+      case s.type === "presence":
+        (i = t(this, P)) == null || i.sendLocalState(s.payload);
+        break;
+    }
+  });
+}, Q = async function() {
+  t(this, d) != null && (await t(this, d).saveSnapshot(t(this, u).asBinary()), await t(this, d).prunePatches(t(this, C)), c(this, M, t(this, C)), c(this, H, 0));
+}, //----------------------------------------------------------------------------//
+//                            Offline Queue Flush                             //
+//----------------------------------------------------------------------------//
+/**** #flushOfflineQueue — sends all queued offline patches to the network ****/
+Z = function() {
+  var s;
+  const e = t(this, _).splice(0);
+  for (const i of e)
+    try {
+      (s = t(this, a)) == null || s.sendPatch(i);
+    } catch (o) {
+      console.error("SDS: failed to send queued patch", o);
+    }
+}, I = async function(e, s) {
+  var i, o, l;
+  for (const [f, q] of Object.entries(e)) {
+    const $ = q;
+    if ($.has("Existence")) {
+      const V = t(this, y).get(f);
+      V != null && (await ((i = t(this, d)) == null ? void 0 : i.releaseValue(V)), t(this, y).delete(f));
+    }
+    if (!$.has("Value"))
+      continue;
+    const E = t(this, y).get(f), p = t(this, u)._getValueRefOf(f), et = p == null ? void 0 : p.Hash;
+    if (E != null && E !== et && (await ((o = t(this, d)) == null ? void 0 : o.releaseValue(E)), t(this, y).delete(f)), p != null) {
+      if (t(this, a) == null) {
+        t(this, y).set(f, p.Hash);
+        continue;
+      }
+      if (s === "send") {
+        const V = t(this, u).getValueBlobByHash(p.Hash);
+        V != null && (await ((l = t(this, d)) == null ? void 0 : l.saveValue(p.Hash, V)), t(this, y).set(f, p.Hash), t(this, a).ConnectionState === "connected" && t(this, a).sendValue(p.Hash, V));
+      } else
+        t(this, y).set(f, p.Hash), !t(this, u).hasValueBlob(p.Hash) && t(this, a).ConnectionState === "connected" && t(this, a).requestValue(p.Hash);
+    }
+  }
+}, //----------------------------------------------------------------------------//
+//                              Remote Presence                               //
+//----------------------------------------------------------------------------//
+/**** #handleRemotePresence — updates the peer set and notifies handlers when a presence update arrives ****/
+O = function(e, s) {
+  if (s == null) {
+    v(this, h, j).call(this, e);
+    return;
+  }
+  const i = { ...s, _lastSeen: Date.now() };
+  t(this, B).set(e, i), v(this, h, tt).call(this, e);
+  for (const o of t(this, m))
+    try {
+      o(e, s, "remote");
+    } catch (l) {
+      console.error("SDS: presence handler failed", l);
+    }
+}, /**** #resetPeerTimeout — arms a timeout to remove a peer if no heartbeat arrives within PresenceTimeoutMs ****/
+tt = function(e) {
+  const s = t(this, S).get(e);
+  s != null && clearTimeout(s);
+  const i = setTimeout(
+    () => {
+      v(this, h, j).call(this, e);
+    },
+    t(this, k)
+  );
+  t(this, S).set(e, i);
+}, /**** #removePeer — removes a peer from the peer set and notifies presence change handlers ****/
+j = function(e) {
+  if (!t(this, B).has(e))
+    return;
+  t(this, B).delete(e);
+  const s = t(this, S).get(e);
+  s != null && (clearTimeout(s), t(this, S).delete(e));
+  for (const i of t(this, m))
+    try {
+      i(e, void 0, "remote");
+    } catch (o) {
+      console.error("SDS: presence handler failed", o);
+    }
+};
+export {
+  at as SDS_SyncEngine
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@rozek/sds-sync-engine",
+  "description": "Coordinates persistence, network and presence for shareable-data-store",
+  "version": "0.0.1",
+  "author": "Andreas Rozek",
+  "homepage": "https://github.com/rozek/shareable-data-store#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rozek/shareable-data-store.git",
+    "directory": "packages/sync-engine"
+  },
+  "bugs": {
+    "url": "https://github.com/rozek/shareable-data-store/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/sds-sync-engine.js",
+  "module": "./dist/sds-sync-engine.js",
+  "types": "./dist/sds-sync-engine.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/sds-sync-engine.js",
+      "types": "./dist/sds-sync-engine.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@rozek/sds-core": "0.0.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2",
+    "vite": "^6.0.0",
+    "vite-plugin-dts": "^4.0.0",
+    "vitest": "^2.0.0",
+    "@rozek/sds-core-jj": "0.0.1",
+    "@rozek/sds-core": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "vite build --watch",
+    "build": "vite build",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}