@calimero-network/mero-js 23.4.2 → 23.4.3

package/dist/ephemeral/index.js

@@ -81,6 +81,16 @@ export function subscribePresence(sse, contextId, handler, codec = jsonCodec())
         handler(entry);
     };
     sse.on('event', listener);
+    // On a context this connection already holds, the node's one-time replay
+    // went to whichever listener came first: seed this one from what the
+    // client has kept, as the replay would have. (A context not held yet is
+    // replayed by the node on the subscribe below.) Optional: a test double
+    // or another event source may not keep presence.
+    if (sse.isSubscribed?.(contextId)) {
+        for (const data of sse.presenceSeed?.(contextId) ?? []) {
+            listener({ contextId, type: 'Ephemeral', data });
+        }
+    }
     // Errors surface via the SSE client's own 'error' event; nothing more to
     // do with them here.
     void sse.connect().catch(() => undefined);

package/dist/events/sse.d.ts

@@ -41,6 +41,14 @@ export declare class SseClient {
     private reconnectTimer;
     private subscribedContextIds;
     private subscribedGroupIds;
+    /**
+     * The current presence of each subscribed context, as the node's replay and
+     * its live deltas left it: author → that author's last `Ephemeral` data and
+     * when it arrived. The node replays a context's presence once, when the
+     * context is first subscribed on this connection, so a presence listener
+     * that comes later would never see it; {@link presenceSeed} gives it this.
+     */
+    private presence;
     private closed;
     private listeners;
     private fetchImpl;
@@ -87,6 +95,15 @@ export declare class SseClient {
         contextIds?: string[];
         groupIds?: string[];
     }): Promise<void>;
+    /** Whether this connection holds `contextId`'s events. */
+    isSubscribed(contextId: string): boolean;
+    /**
+     * The presence currently known for `contextId`, as `Ephemeral` event data,
+     * each entry's `ageMs` advanced by how long ago it arrived. Empty for a
+     * context this connection does not hold.
+     */
+    presenceSeed(contextId: string): Array<Record<string, unknown>>;
+    private notePresence;
     unsubscribe(idsOrOpts: string[] | {
         contextIds?: string[];
         groupIds?: string[];

package/dist/events/sse.js

@@ -39,6 +39,14 @@ export class SseClient {
         this.reconnectTimer = null;
         this.subscribedContextIds = new Set();
         this.subscribedGroupIds = new Set();
+        /**
+         * The current presence of each subscribed context, as the node's replay and
+         * its live deltas left it: author → that author's last `Ephemeral` data and
+         * when it arrived. The node replays a context's presence once, when the
+         * context is first subscribed on this connection, so a presence listener
+         * that comes later would never see it; {@link presenceSeed} gives it this.
+         */
+        this.presence = new Map();
         this.closed = false;
         this.listeners = { connect: [], event: [], error: [] };
         this.baseUrl = opts.baseUrl.replace(/\/+$/, '');
@@ -227,6 +235,9 @@ export class SseClient {
             if (msg.type === 'connect' && msg.session_id) {
                 this.sessionId = msg.session_id;
                 this.emit('connect', msg.session_id);
+                // A new connection gets a new replay when it re-subscribes; what the
+                // old one said may name authors who have since gone.
+                this.presence.clear();
                 // Re-subscribe after reconnect
                 if (this.subscribedContextIds.size > 0 || this.subscribedGroupIds.size > 0) {
                     this.sendSubscription('subscribe', {
@@ -252,6 +263,8 @@ export class SseClient {
             }
             // Context event message
             if (msg.result.contextId) {
+                if (msg.result.type === 'Ephemeral')
+                    this.notePresence(msg.result.contextId, eventData);
                 this.emit('event', {
                     contextId: msg.result.contextId,
                     // Forward the event tag (sibling of `data` in core's flattened
@@ -289,12 +302,43 @@ export class SseClient {
             await this.sendSubscription('subscribe', { contextIds: newContextIds, groupIds: newGroupIds });
         }
     }
+    /** Whether this connection holds `contextId`'s events. */
+    isSubscribed(contextId) {
+        return this.subscribedContextIds.has(contextId);
+    }
+    /**
+     * The presence currently known for `contextId`, as `Ephemeral` event data,
+     * each entry's `ageMs` advanced by how long ago it arrived. Empty for a
+     * context this connection does not hold.
+     */
+    presenceSeed(contextId) {
+        const now = Date.now();
+        return [...(this.presence.get(contextId)?.values() ?? [])].map(({ data, at }) => ({
+            ...data,
+            ageMs: (typeof data.ageMs === 'number' ? data.ageMs : 0) + (now - at),
+        }));
+    }
+    notePresence(contextId, data) {
+        if (!this.subscribedContextIds.has(contextId))
+            return;
+        const d = data;
+        if (!d || typeof d.author !== 'string')
+            return;
+        let byAuthor = this.presence.get(contextId);
+        if (!byAuthor)
+            this.presence.set(contextId, (byAuthor = new Map()));
+        if (d.removed)
+            byAuthor.delete(d.author);
+        else
+            byAuthor.set(d.author, { data: d, at: Date.now() });
+    }
     async unsubscribe(idsOrOpts) {
         const opts = Array.isArray(idsOrOpts) ? { contextIds: idsOrOpts } : idsOrOpts;
         const hadContextIds = (opts.contextIds ?? []).filter(id => this.subscribedContextIds.has(id));
         const hadGroupIds = (opts.groupIds ?? []).filter(id => this.subscribedGroupIds.has(id));
         for (const id of opts.contextIds ?? []) {
             this.subscribedContextIds.delete(id);
+            this.presence.delete(id);
         }
         for (const id of opts.groupIds ?? []) {
             this.subscribedGroupIds.delete(id);