@calimero-network/mero-js 23.4.2 → 23.5.0

package/dist/cloud/account-ownership.d.ts

@@ -1,5 +1,8 @@
 import { type Signer } from '../signer/signer.js';
-/** The `ownership_proof` body for `POST /api/cloud/me/namespaces/{ns}/enable-ha`. */
+/**
+ * The `ownership_proof` body for `POST /api/cloud/me/namespaces/{ns}/enable-ha`
+ * and for `POST /api/cloud/accounts/{account}/namespaces/{ns}/enable-ha`.
+ */
 export interface AccountOwnershipProof {
     kind: 'account';
     /** hex `AccountProof<DeviceCert>`, the account's credential. */
@@ -9,15 +12,14 @@ export interface AccountOwnershipProof {
     /** base64 ed25519 by the certified device key. */
     signature: string;
 }
-export interface AccountOwnershipClaimInput {
+/** What every account claim needs; the audience and `subject` differ per route. */
+interface AccountClaimBase {
     /** The namespace, hex: the id `foundNamespace` returned. */
     namespaceId: string;
     /** The founding account, hex. */
     accountId: string;
     /** The salt `foundNamespace` returned, hex (32 bytes). */
     salt: string;
-    /** The cloud login's email: the claim is for this login only. */
-    subject: string;
     /** The account's credential, hex `AccountProof<DeviceCert>`. */
     credential: string;
     deviceSecret?: string;
@@ -27,4 +29,27 @@ export interface AccountOwnershipClaimInput {
     /** For tests. */
     now?: () => number;
 }
+export interface AccountOwnershipClaimInput extends AccountClaimBase {
+    /** The cloud login's email: the claim is for this login only. */
+    subject: string;
+}
+/**
+ * Input for {@link signAccountHaClaim}: the same as the session claim, minus
+ * `subject` — there is no login to bind it to.
+ */
+export type AccountHaClaimInput = AccountClaimBase;
+/** The audience of the session route's claim (`/api/cloud/me/...`). */
+export declare const ACCOUNT_OWNERSHIP_AUDIENCE = "mdma:enable-ha-namespace";
+/** The audience of the anonymous account route's claim (`/api/cloud/accounts/...`). */
+export declare const ACCOUNT_HA_AUDIENCE = "mdma:enable-ha-namespace-as-account";
+/** The founder's claim for the SESSION route, bound to one cloud login (`subject`). */
 export declare function signAccountOwnershipClaim(input: AccountOwnershipClaimInput): Promise<AccountOwnershipProof>;
+/**
+ * The founder's claim for the ANONYMOUS account route
+ * (`POST /api/cloud/accounts/{account}/namespaces/{ns}/enable-ha`): no cloud
+ * session, so no `subject`, and its own audience so a claim minted for one
+ * route can never be replayed on the other. The cloud finds the user to bill
+ * through the account's wallet link instead.
+ */
+export declare function signAccountHaClaim(input: AccountHaClaimInput): Promise<AccountOwnershipProof>;
+export {};

package/dist/cloud/account-ownership.js

@@ -19,6 +19,10 @@ const DOMAIN = new TextEncoder().encode('calimero.mdma.account-ownership-claim.v
 /** What the cloud accepts; it caps a claim's lifetime at five minutes. */
 const DEFAULT_TTL_MS = 60000;
 const MAX_TTL_MS = 5 * 60000;
+/** The audience of the session route's claim (`/api/cloud/me/...`). */
+export const ACCOUNT_OWNERSHIP_AUDIENCE = 'mdma:enable-ha-namespace';
+/** The audience of the anonymous account route's claim (`/api/cloud/accounts/...`). */
+export const ACCOUNT_HA_AUDIENCE = 'mdma:enable-ha-namespace-as-account';
 function base64(bytes) {
     let binary = '';
     for (const b of bytes)
@@ -30,22 +34,28 @@ const hex32 = (value, what) => {
         throw new Error(`${what} must be 64 hex characters`);
     return value.toLowerCase();
 };
-export async function signAccountOwnershipClaim(input) {
+/**
+ * Sign one claim. `subject` is spliced in after `salt` only when given, so the
+ * session claim keeps its exact field order and the account claim has no
+ * `subject` key at all (not a null one: the cloud tells the two apart by it).
+ */
+async function signClaim(input, audience, subject) {
     const ttl = input.ttlMs ?? DEFAULT_TTL_MS;
     if (!(ttl > 0 && ttl <= MAX_TTL_MS))
         throw new Error(`ttlMs must be in (0, ${MAX_TTL_MS}]`);
-    if (!input.subject)
-        throw new Error('subject must be the cloud login email');
+    const groupId = hex32(input.namespaceId, 'namespaceId');
+    const accountId = hex32(input.accountId, 'accountId');
+    const salt = hex32(input.salt, 'salt');
     const signer = await resolveSigner(input.deviceSecret, input.signer, 'deviceSecret');
     const issued = (input.now ?? Date.now)();
     const nonce = Array.from(crypto.getRandomValues(new Uint8Array(16)), (b) => b.toString(16).padStart(2, '0')).join('');
     const payload = new TextEncoder().encode(JSON.stringify({
         v: 1,
-        audience: 'mdma:enable-ha-namespace',
-        group_id: hex32(input.namespaceId, 'namespaceId'),
-        account_id: hex32(input.accountId, 'accountId'),
-        salt: hex32(input.salt, 'salt'),
-        subject: input.subject,
+        audience,
+        group_id: groupId,
+        account_id: accountId,
+        salt,
+        ...(subject === undefined ? {} : { subject }),
         nonce,
         issued_at_ms: issued,
         expires_at_ms: issued + ttl,
@@ -53,3 +63,19 @@ export async function signAccountOwnershipClaim(input) {
     const signature = await signer.sign(concat(DOMAIN, payload));
     return { kind: 'account', credential: input.credential, signed_payload: base64(payload), signature: base64(signature) };
 }
+/** The founder's claim for the SESSION route, bound to one cloud login (`subject`). */
+export async function signAccountOwnershipClaim(input) {
+    if (!input.subject)
+        throw new Error('subject must be the cloud login email');
+    return signClaim(input, ACCOUNT_OWNERSHIP_AUDIENCE, input.subject);
+}
+/**
+ * The founder's claim for the ANONYMOUS account route
+ * (`POST /api/cloud/accounts/{account}/namespaces/{ns}/enable-ha`): no cloud
+ * session, so no `subject`, and its own audience so a claim minted for one
+ * route can never be replayed on the other. The cloud finds the user to bill
+ * through the account's wallet link instead.
+ */
+export async function signAccountHaClaim(input) {
+    return signClaim(input, ACCOUNT_HA_AUDIENCE, undefined);
+}

package/dist/cloud/cloud-client.d.ts

@@ -24,8 +24,9 @@
  * ever sent, and would be a throughput bottleneck on a path that has no reason
  * to involve it.
  */
-import type { AccountOwnershipProof } from './account-ownership.js';
+import { type AccountOwnershipProof } from './account-ownership.js';
 import { type RootSource } from '../account/index.js';
+import { HTTPError } from '../http-client/web-client.js';
 import type { Signer } from '../signer/signer.js';
 import { type DiscoveryChallenge, type RoutingChallenge, type RoutingCredential } from './routing-proof.js';
 /**
@@ -365,6 +366,54 @@ export interface DisableHAOptions {
     contextId: string;
     redirectUrl?: string;
 }
+/** Options for {@link CloudClient.enableHaAsAccount}. */
+export interface EnableHaAsAccountOptions {
+    /** The namespace, hex: the id `foundNamespace` returned. */
+    namespaceId: string;
+    /** The salt `foundNamespace` returned, hex (32 bytes). */
+    salt: string;
+    /** The founding account, hex. */
+    accountId: string;
+    /** The account's credential, hex `AccountProof<DeviceCert>`. */
+    credential: string;
+    /** The certified device's secret, hex. Give this or `signer`. */
+    deviceSecret?: string;
+    signer?: Signer;
+    /** The claim's lifetime in ms; default one minute, at most five. */
+    ttlMs?: number;
+}
+/**
+ * The cloud's two refusals of {@link CloudClient.enableHaAsAccount} that a
+ * person can do something about. Both are `409`s with `{"error": code}`.
+ *
+ * Extends {@link HTTPError}, so `instanceof HTTPError` handling still catches it.
+ */
+export declare class AccountHaRefusedError extends HTTPError {
+    /** The cloud's `error` code, verbatim. */
+    readonly code: string;
+    name: string;
+    constructor(
+    /** The cloud's `error` code, verbatim. */
+    code: string, status: number, statusText: string, url: string, headers: Headers, bodyText?: string);
+}
+/**
+ * `account_not_linked`: the account was never linked to a cloud user through
+ * the wallet, so the cloud has nobody to host the namespace for. Linking it
+ * fixes this; retrying does not.
+ */
+export declare class AccountNotLinkedError extends AccountHaRefusedError {
+    name: string;
+    static readonly CODE = "account_not_linked";
+}
+/**
+ * `account_linked_to_several_users`: more than one cloud user linked this
+ * account, so the cloud cannot tell whose quota hosts the namespace. Unlink it
+ * from all but one.
+ */
+export declare class AccountLinkedToSeveralUsersError extends AccountHaRefusedError {
+    name: string;
+    static readonly CODE = "account_linked_to_several_users";
+}
 export declare class CloudClient {
     private baseUrl;
     private session;
@@ -610,6 +659,24 @@ export declare class CloudClient {
      * The login must be linked to that account.
      */
     enableFoundedNamespaceHa(namespaceId: string, ownershipProof: AccountOwnershipProof): Promise<unknown>;
+    /**
+     * Enable HA for a namespace this account founded, with **no cloud session**.
+     *
+     * The anonymous sibling of {@link enableFoundedNamespaceHa}: it signs the
+     * founder's claim itself ({@link signAccountHaClaim} — no `subject`, its own
+     * audience) and posts it to
+     * `/api/cloud/accounts/{accountId}/namespaces/{namespaceId}/enable-ha`. The
+     * cloud bills the user the account is linked to through the wallet, so the
+     * account must be linked to exactly one:
+     *
+     * - not linked at all → {@link AccountNotLinkedError};
+     * - linked to several → {@link AccountLinkedToSeveralUsersError}.
+     *
+     * A claim that does not verify is a `403` `HTTPError`; quota and the rest
+     * answer as the session route does. Returns the cloud's response body, the
+     * same shape the session route's enable-ha returns.
+     */
+    enableHaAsAccount(options: EnableHaAsAccountOptions): Promise<unknown>;
     /**
      * Stop hosting a claimed namespace.
      *

package/dist/cloud/cloud-client.js

@@ -24,6 +24,7 @@
  * ever sent, and would be a throughput bottleneck on a path that has no reason
  * to involve it.
  */
+import { signAccountHaClaim } from './account-ownership.js';
 import { resolveRoot, resolveRootPair, signAccountLink, signAccountLogin, } from '../account/index.js';
 import { HTTPError } from '../http-client/web-client.js';
 import { routingProofHeaders, } from './routing-proof.js';
@@ -65,6 +66,68 @@ function teeRoleOf(row) {
 export function pickExecutingRelay(relays) {
     return (relays.find((r) => r.canExecute && r.relayUrl !== null && r.executorAccount !== null) ?? null);
 }
+/**
+ * The cloud's two refusals of {@link CloudClient.enableHaAsAccount} that a
+ * person can do something about. Both are `409`s with `{"error": code}`.
+ *
+ * Extends {@link HTTPError}, so `instanceof HTTPError` handling still catches it.
+ */
+export class AccountHaRefusedError extends HTTPError {
+    constructor(
+    /** The cloud's `error` code, verbatim. */
+    code, status, statusText, url, headers, bodyText) {
+        super(status, statusText, url, headers, bodyText);
+        this.code = code;
+        this.name = 'AccountHaRefusedError';
+    }
+}
+/**
+ * `account_not_linked`: the account was never linked to a cloud user through
+ * the wallet, so the cloud has nobody to host the namespace for. Linking it
+ * fixes this; retrying does not.
+ */
+export class AccountNotLinkedError extends AccountHaRefusedError {
+    constructor() {
+        super(...arguments);
+        this.name = 'AccountNotLinkedError';
+    }
+}
+AccountNotLinkedError.CODE = 'account_not_linked';
+/**
+ * `account_linked_to_several_users`: more than one cloud user linked this
+ * account, so the cloud cannot tell whose quota hosts the namespace. Unlink it
+ * from all but one.
+ */
+export class AccountLinkedToSeveralUsersError extends AccountHaRefusedError {
+    constructor() {
+        super(...arguments);
+        this.name = 'AccountLinkedToSeveralUsersError';
+    }
+}
+AccountLinkedToSeveralUsersError.CODE = 'account_linked_to_several_users';
+/**
+ * The `error` code of a 409 body. Accepts `{"error": code}` (the contract) and
+ * FastAPI's `{"detail": code}` / `{"detail": {"error": code}}`, so how the
+ * route raises it does not change what a caller catches.
+ */
+function conflictCode(bodyText) {
+    if (!bodyText)
+        return undefined;
+    try {
+        const body = JSON.parse(bodyText);
+        if (typeof body?.error === 'string')
+            return body.error;
+        if (typeof body?.detail === 'string')
+            return body.detail;
+        const nested = body?.detail?.error;
+        if (typeof nested === 'string')
+            return nested;
+    }
+    catch {
+        // Not JSON: not one of ours.
+    }
+    return undefined;
+}
 /** Response headers MDMA uses to hand back a rolling-refreshed session. */
 const REFRESH_HEADER = 'x-mdma-session-refresh';
 const REFRESH_EXPIRES_HEADER = 'x-mdma-session-expires';
@@ -509,6 +572,55 @@ export class CloudClient {
     async enableFoundedNamespaceHa(namespaceId, ownershipProof) {
         return this.request('POST', `/api/cloud/me/namespaces/${encodeURIComponent(namespaceId)}/enable-ha`, { body: { groups: [], ownership_proof: ownershipProof } });
     }
+    /**
+     * Enable HA for a namespace this account founded, with **no cloud session**.
+     *
+     * The anonymous sibling of {@link enableFoundedNamespaceHa}: it signs the
+     * founder's claim itself ({@link signAccountHaClaim} — no `subject`, its own
+     * audience) and posts it to
+     * `/api/cloud/accounts/{accountId}/namespaces/{namespaceId}/enable-ha`. The
+     * cloud bills the user the account is linked to through the wallet, so the
+     * account must be linked to exactly one:
+     *
+     * - not linked at all → {@link AccountNotLinkedError};
+     * - linked to several → {@link AccountLinkedToSeveralUsersError}.
+     *
+     * A claim that does not verify is a `403` `HTTPError`; quota and the rest
+     * answer as the session route does. Returns the cloud's response body, the
+     * same shape the session route's enable-ha returns.
+     */
+    async enableHaAsAccount(options) {
+        const proof = await signAccountHaClaim({
+            namespaceId: options.namespaceId,
+            accountId: options.accountId,
+            salt: options.salt,
+            credential: options.credential,
+            deviceSecret: options.deviceSecret,
+            signer: options.signer,
+            ttlMs: options.ttlMs,
+        });
+        // The path carries the ids as the claim does — lowercase hex — so a caller
+        // that kept them uppercase does not address a different resource.
+        const account = options.accountId.toLowerCase();
+        const namespace = options.namespaceId.toLowerCase();
+        try {
+            return await this.request('POST', `/api/cloud/accounts/${encodeURIComponent(account)}/namespaces/${encodeURIComponent(namespace)}/enable-ha`, { body: { ownership_proof: proof }, anonymous: true });
+        }
+        catch (err) {
+            if (err instanceof HTTPError && err.status === 409) {
+                const code = conflictCode(err.bodyText);
+                const Typed = code === AccountNotLinkedError.CODE
+                    ? AccountNotLinkedError
+                    : code === AccountLinkedToSeveralUsersError.CODE
+                        ? AccountLinkedToSeveralUsersError
+                        : undefined;
+                if (Typed && code) {
+                    throw new Typed(code, err.status, err.statusText, err.url, err.headers, err.bodyText);
+                }
+            }
+            throw err;
+        }
+    }
     /**
      * Stop hosting a claimed namespace.
      *

package/dist/cloud/index.d.ts

@@ -1,5 +1,5 @@
-export { CloudClient, admitterAddrsFromNetworkStatus } from './cloud-client.js';
-export type { CloudClientConfig, CloudSession, CloudNamespace, CloudRelay, CloudAccountRelay, CloudNamespaceNode, CloudNamespaceRouting, CloudMachine, CloudMachineNamespace, CloudLinkedAccount, CloudLinkedAccounts, CloudAccountLink, AccountLinkChallenge, AccountLinkProof, AccountLinkHandoff, AccountLinkCallback, AccountLoginChallenge, AccountLoginProof, EnableHAOptions, DisableHAOptions, } from './cloud-client.js';
+export { CloudClient, admitterAddrsFromNetworkStatus, AccountHaRefusedError, AccountNotLinkedError, AccountLinkedToSeveralUsersError, } from './cloud-client.js';
+export type { CloudClientConfig, CloudSession, CloudNamespace, CloudRelay, CloudAccountRelay, CloudNamespaceNode, CloudNamespaceRouting, CloudMachine, CloudMachineNamespace, CloudLinkedAccount, CloudLinkedAccounts, CloudAccountLink, AccountLinkChallenge, AccountLinkProof, AccountLinkHandoff, AccountLinkCallback, AccountLoginChallenge, AccountLoginProof, EnableHAOptions, DisableHAOptions, EnableHaAsAccountOptions, } from './cloud-client.js';
 export { connectCloud, connectCloudWithAccount } from './connect.js';
 export type { ConnectCloudOptions, ConnectCloudWithAccountOptions, CloudConnection, } from './connect.js';
 export { signRoutingChallenge, routingProofHeaders } from './routing-proof.js';
@@ -8,5 +8,5 @@ export { cloudLinkUrl, beginCloudLink, readCloudLinkCallback, completeCloudLink,
 export type { BeginCloudLinkOptions, CloudLinkCallback, CompleteCloudLinkOptions, } from './link-redirect.js';
 export { deviceEnrolmentUrl, beginDeviceEnrolment, readEnrolmentCallback, completeDeviceEnrolment, callbackIsForeign, } from './enrol-redirect.js';
 export type { DeviceEnrolmentOptions, DeviceEnrolmentCallback, CompleteDeviceEnrolmentOptions, EnrolledDevice, } from './enrol-redirect.js';
-export { signAccountOwnershipClaim } from './account-ownership.js';
-export type { AccountOwnershipProof, AccountOwnershipClaimInput } from './account-ownership.js';
+export { signAccountOwnershipClaim, signAccountHaClaim, ACCOUNT_OWNERSHIP_AUDIENCE, ACCOUNT_HA_AUDIENCE, } from './account-ownership.js';
+export type { AccountOwnershipProof, AccountOwnershipClaimInput, AccountHaClaimInput, } from './account-ownership.js';

package/dist/cloud/index.js

@@ -1,4 +1,4 @@
-export { CloudClient, admitterAddrsFromNetworkStatus } from './cloud-client.js';
+export { CloudClient, admitterAddrsFromNetworkStatus, AccountHaRefusedError, AccountNotLinkedError, AccountLinkedToSeveralUsersError, } from './cloud-client.js';
 export { connectCloud, connectCloudWithAccount } from './connect.js';
 export { signRoutingChallenge, routingProofHeaders } from './routing-proof.js';
 // Linking an account to a cloud login from a browser — the redirect half the
@@ -7,4 +7,4 @@ export { cloudLinkUrl, beginCloudLink, readCloudLinkCallback, completeCloudLink,
 // Getting this app's device key certified by a wallet on another origin — the
 // redirect that keeps the account root out of the app's reach.
 export { deviceEnrolmentUrl, beginDeviceEnrolment, readEnrolmentCallback, completeDeviceEnrolment, callbackIsForeign, } from './enrol-redirect.js';
-export { signAccountOwnershipClaim } from './account-ownership.js';
+export { signAccountOwnershipClaim, signAccountHaClaim, ACCOUNT_OWNERSHIP_AUDIENCE, ACCOUNT_HA_AUDIENCE, } from './account-ownership.js';

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);