@calimero-network/mero-js 29.15.0 → 29.16.0

package/dist/cloud-v2/client.js

@@ -9,10 +9,9 @@
  * const { result } = await cloud.call(appId, 'set', { key: 'a', value: '1' });
  * ```
  */
-import { SealedTransportError, createSealedFetch } from '../sealed/sealed.js';
-import { fetchAttestedKey } from './attestation.js';
-import { DEFAULT_DIRECTORY, orderNodes, readDirectory } from './directory.js';
-import { CalimeroError, ConfirmCancelled, ConfirmPromptBlocked, ConfirmRequired, LoginRequired, OriginNotRegistered, UnavailableError, WrongNode, WrongRecoveryCode, errorFrom, } from './errors.js';
+import { DEFAULT_RETRY, NodeTransport, directoryTransport, newIdempotencyKey, refusal, retryDelayMs, } from '../runtime/transport.js';
+import { DEFAULT_DIRECTORY } from './directory.js';
+import { CalimeroError, LoginRequired, OriginNotRegistered, WrongRecoveryCode } from './errors.js';
 import { b64url, fromB64url } from './passkey.js';
 import { signRecovery } from './recovery.js';
 import { confirmationCode, pageQuery, pendingApprovalsFrom, } from './approvals.js';
@@ -55,135 +54,15 @@ export function pageDeployment(href) {
         return null;
     }
 }
-/**
- * The user verification a confirmation asks the passkey for: what the node's
- * `412` details name, if it names one WebAuthn knows, else `fallback` (the
- * flow's own requirement: `required` for a step-up, which the node takes only
- * with the user verified; `preferred` for the sign-up confirmation, which it
- * takes with the user present).
- */
-function userVerificationOf(named, fallback) {
-    return named === 'required' || named === 'preferred' || named === 'discouraged' ? named : fallback;
-}
-/**
- * What a failed confirmation prompt means to the caller. The browser or a
- * password manager refusing to show the prompt (the page not focused because
- * an extension's popup still holds focus, or another prompt still open) is
- * {@link ConfirmPromptBlocked}; the user dismissing it (`NotAllowedError`, or
- * `AbortError` when it was aborted) is {@link ConfirmCancelled}; anything
- * else is a real failure, passed through.
- */
-function promptFailure(error) {
-    const e = error;
-    const name = e?.name;
-    const message = typeof e?.message === 'string' ? e.message : '';
-    if (name === 'InvalidStateError' || /not focused|already pending/i.test(message)) {
-        return new ConfirmPromptBlocked(error);
-    }
-    if (name === 'NotAllowedError' || name === 'AbortError')
-        return new ConfirmCancelled(error);
-    return error;
-}
 /** One URL path segment, so an id cannot reach another route. */
 function seg(value) {
     return encodeURIComponent(value);
 }
-/**
- * The node refuses an envelope past its 64 MiB sealed cap with `413` in the
- * clear, before opening it, so the refusal arrives as the transport's. To the
- * caller it is the API's `TOO_LARGE`, as the Rust client reports it.
- */
-function sealedError(error) {
-    if (error instanceof SealedTransportError && error.status === 413) {
-        return errorFrom(413, {
-            error: 'TOO_LARGE',
-            message: error.message.replace(/^Sealed request refused: /, ''),
-        });
-    }
-    return error;
-}
-/** Read a refused response's body and map it ({@link errorFrom}). */
-async function refusal(response) {
-    const text = await response.text().catch(() => '');
-    let body = {};
-    try {
-        body = text ? JSON.parse(text) : {};
-    }
-    catch {
-        body = { message: text };
-    }
-    return errorFrom(response.status, body, response.headers.get('retry-after'));
-}
-/** Server-sent event frames from a response body: `{ id, kind, data }` each, `data` parsed as JSON when it is. */
-async function* sseFrames(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    for (;;) {
-        const { value, done } = await reader.read();
-        if (done)
-            return;
-        buffer += decoder.decode(value, { stream: true });
-        let cut;
-        while ((cut = buffer.indexOf('\n\n')) >= 0) {
-            const frame = buffer.slice(0, cut);
-            buffer = buffer.slice(cut + 2);
-            let id = '';
-            let kind = '';
-            let data = '';
-            for (const line of frame.split('\n')) {
-                if (line.startsWith('id:'))
-                    id = line.slice(3).trim();
-                else if (line.startsWith('event:'))
-                    kind = line.slice(6).trim();
-                else if (line.startsWith('data:'))
-                    data += line.slice(5).trim();
-            }
-            if (!kind && !data)
-                continue;
-            let parsed = data;
-            try {
-                parsed = JSON.parse(data);
-            }
-            catch {
-                /* plain text */
-            }
-            yield { id, kind, data: parsed };
-        }
-    }
-}
 /** Bytes as lower-case hex. */
 function toHex(bytes) {
     return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
 }
-/**
- * A key for a call the caller gave none, made once so every retry shares it:
- * `node:c-` and 16 random bytes in base64url without padding, as the Rust
- * client mints it. It only has to outlive this client's own retries, so it
- * takes the node's short-lived class: a key starting `node:` is kept 10
- * minutes, a caller's own key 24 hours.
- * `getRandomValues`, not `randomUUID`, which a page outside a secure context lacks.
- */
-function newIdempotencyKey() {
-    return `node:c-${b64url(crypto.getRandomValues(new Uint8Array(16)))}`;
-}
-export const DEFAULT_RETRY = { retries: 6, baseDelayMs: 200, maxDelayMs: 2000 };
-/** The backoff before retry `retry` (0 for the first): `baseDelayMs` doubling, at most `maxDelayMs`. */
-export function retryDelayMs(retry, options) {
-    return Math.min(options.baseDelayMs * 2 ** retry, options.maxDelayMs);
-}
-/**
- * The ceremonies that mint a session, which {@link CalimeroClient.send} never
- * repeats by itself: a sign-in or sign-up is started again by its caller (with
- * the passkey), and a refresh moves through the nodes in
- * {@link CalimeroClient.exchangeRefresh}. A node answers them `421 WRONG_NODE`
- * before it spends the challenge or the refresh token (core #4774).
- */
-function ceremony(path) {
-    return path === 'auth/refresh' || path.startsWith('auth/passkey/') || RECOVERY_CEREMONIES.has(path);
-}
-/** The signed-out halves of an account recovery: a `401` there is the code's, not a session's. */
-const RECOVERY_CEREMONIES = new Set(['auth/recovery/begin', 'auth/recovery/start', 'auth/recovery/finish']);
+export { DEFAULT_RETRY, retryDelayMs };
 export class CalimeroClient {
     /**
      * A client for the Calimero Cloud cluster named `cluster`: its node list read
@@ -196,28 +75,11 @@ export class CalimeroClient {
      * first request once the directory's `refreshAfterSeconds` has passed.
      */
     static async connect(options) {
-        const directory = options.directory ?? DEFAULT_DIRECTORY;
-        const random = options.random ?? Math.random;
-        const fetcher = options.fetch ?? ((input, init) => fetch(input, init));
-        const listing = await readDirectory(directory, options.cluster, fetcher);
-        const [baseUrl, ...nodes] = orderNodes(listing.nodes, options.zone, random);
-        const client = new CalimeroClient({ baseUrl, nodes, policy: options.policy, fetch: options.fetch, retry: options.retry });
-        client.source = {
-            directory,
-            cluster: options.cluster,
-            zone: options.zone,
-            random,
-            due: Date.now() + listing.refreshAfterSeconds * 1000,
-        };
-        return client;
+        const transport = await directoryTransport({ ...options, directory: options.directory ?? DEFAULT_DIRECTORY });
+        return new CalimeroClient(transport);
     }
+    /** A client of the nodes `options` names, or one sending through an existing `transport`. */
     constructor(options) {
-        /** The one in use: an index into {@link nodeUrls}. */
-        this.at = 0;
-        /** A sealed fetch per node, each attesting its own node on first use. */
-        this.channels = new Map();
-        /** Rejections of the underlying `fetch` itself: the node could not be reached or dropped the connection. */
-        this.networkFailures = new WeakSet();
         // ---------------------------------------------------------------- package origins
         /**
          * The web origins `{package}`'s managers registered so a frontend they host
@@ -239,246 +101,30 @@ export class CalimeroClient {
             }, passkey),
             remove: (pkg, origin, passkey) => this.confirmed('DELETE', `package-origins/${seg(pkg)}`, { origin }, passkey),
         };
-        const trim = (url) => url.replace(/\/+$/, '');
-        this.nodeUrls = [...new Set([options.baseUrl, ...(options.nodes ?? [])].map(trim))];
-        this.policy = options.policy;
-        this.retry = { ...DEFAULT_RETRY, ...options.retry };
-        const given = options.fetch ?? ((input, init) => fetch(input, init));
-        // `fetch` rejects with a `TypeError` when it gets no answer: the connection
-        // was refused, reset or dropped before the response. The sealed fetch passes
-        // that rejection on unchanged, so it is recognised here, at its source, and
-        // not by its type alone (a bad URL is a `TypeError` too, and is not retried).
-        const raw = async (input, init) => {
-            try {
-                return await given(input, init);
-            }
-            catch (error) {
-                if (error instanceof TypeError)
-                    this.networkFailures.add(error);
-                throw error;
-            }
-        };
-        this.raw = raw;
+        this.transport = options instanceof NodeTransport ? options : new NodeTransport(options);
     }
     /** The node requests go to now: `baseUrl`, until a `421 WRONG_NODE` or a failover moved the client on. */
     get nodeUrl() {
-        return this.nodeUrls[this.at];
+        return this.transport.nodeUrl;
     }
     /** Every node this client may use, in the order it moves through them. */
     get nodes() {
-        return [...this.nodeUrls];
-    }
-    /** The sealed channel to `url`, attested under the client's policy before its first request. */
-    channel(url) {
-        let sealed = this.channels.get(url);
-        if (!sealed) {
-            sealed = createSealedFetch({
-                baseUrl: url,
-                transportPublicKey: () => fetchAttestedKey(url, this.policy, this.raw),
-                fetch: this.raw,
-            });
-            this.channels.set(url, sealed);
-        }
-        return sealed;
-    }
-    /**
-     * Move on from node `from` (the one that answered `421 WRONG_NODE`) to the
-     * next one. False when there is no other. A request that saw the same node
-     * refuse after another request moved on already does not move again.
-     */
-    moveOn(from) {
-        if (this.nodeUrls.length < 2)
-            return false;
-        if (this.nodeUrl === from)
-            this.at = (this.at + 1) % this.nodeUrls.length;
-        return true;
-    }
-    /**
-     * Fail over from node `from`, where a request's retries ran out, to the next
-     * node it has not `tried`. False when it has tried them all. A request whose
-     * node another request moved away from already goes to that node, if untried.
-     */
-    failOver(from, tried) {
-        if (this.nodeUrl !== from && !tried.has(this.nodeUrl))
-            return true;
-        const count = this.nodeUrls.length;
-        for (let step = 1; step < count; step++) {
-            const next = (this.at + step) % count;
-            if (!tried.has(this.nodeUrls[next])) {
-                this.at = next;
-                this.reread();
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Read the node list again from the directory, in the background, for a
-     * client made by {@link connect}: the node in use stays first, then the
-     * directory's order; a node no longer listed is dropped. A failed read is
-     * ignored. One read at a time.
-     */
-    reread() {
-        const source = this.source;
-        if (!source || source.reading)
-            return;
-        source.reading = readDirectory(source.directory, source.cluster, this.raw)
-            .then((listing) => {
-            const current = this.nodeUrl;
-            const listed = orderNodes(listing.nodes, source.zone, source.random);
-            this.nodeUrls = [current, ...listed.filter((url) => url !== current)];
-            this.at = 0;
-            source.due = Date.now() + listing.refreshAfterSeconds * 1000;
-        })
-            .catch(() => undefined)
-            .finally(() => {
-            source.reading = undefined;
-        });
+        return this.transport.nodes;
     }
     /** Authenticate every request with an API key. */
     useApiKey(key) {
-        this.auth = key;
-        this.current = undefined;
+        this.transport.useApiKey(key);
     }
     useSession(session) {
-        this.auth = session.sessionToken;
-        this.current = session;
+        this.transport.useSession(session);
     }
     get session() {
-        return this.current;
-    }
-    /**
-     * Send one request to the node in use, with the credential held now, and
-     * answer the response, whatever its status. {@link send} judges it.
-     */
-    async request(method, path, body, raw, contentType = 'application/wasm', signal) {
-        const headers = {};
-        if (this.auth)
-            headers.authorization = `Bearer ${this.auth}`;
-        let payload;
-        if (raw) {
-            headers['content-type'] = contentType;
-            payload = raw;
-        }
-        else if (body !== undefined) {
-            headers['content-type'] = 'application/json';
-            payload = JSON.stringify(body);
-        }
-        if (this.source && Date.now() >= this.source.due)
-            this.reread();
-        const url = this.nodeUrl;
-        try {
-            return await this.channel(url)(`${url}/${path}`, { method, headers, body: payload, signal });
-        }
-        catch (error) {
-            throw sealedError(error);
-        }
+        return this.transport.session;
     }
-    /**
-     * {@link request}, answering what a lost issuing node or a node on the
-     * wrong release does to a session: a successful response, or the refusal as a
-     * typed error ({@link errorFrom}).
-     *
-     * - `401 UNAUTHENTICATED` to a request that carried a session: the node that
-     *   signed the session may be gone, replaced, or out of reach of the node
-     *   asked, which any node of the cluster answers with a refresh. The client
-     *   refreshes once, shared by every request that needs it at the same time
-     *   ({@link refresh}), and repeats the request once. A refresh that is
-     *   refused surfaces as {@link LoginRequired}.
-     * - `421 WRONG_NODE`: this node's release may not serve the account. The
-     *   client moves to the next node it knows and repeats the request once; with
-     *   none, the {@link WrongNode} reaches the caller.
-     *
-     * Repeating is safe even for a request that is not idempotent: the node
-     * answers `401` and `421` when it judges the credential, before it reads what
-     * the request asks, so the first attempt ran nothing. The exceptions are the
-     * ceremonies that mint a session ({@link ceremony}), never repeated here.
-     */
-    async send(method, path, body, raw, contentType, signal) {
-        let refreshed = false;
-        let moved = false;
-        for (;;) {
-            const [token, at] = [this.auth, this.nodeUrl];
-            const response = await this.request(method, path, body, raw, contentType, signal);
-            if (response.ok)
-                return response;
-            const error = await refusal(response);
-            if (error instanceof WrongNode && !moved) {
-                moved = true;
-                if (this.moveOn(at) && !ceremony(path))
-                    continue;
-            }
-            else if (error instanceof LoginRequired && !refreshed && this.mayRefresh(token, path)) {
-                refreshed = true;
-                await this.renew(token);
-                continue;
-            }
-            throw error;
-        }
-    }
-    /** Whether a `401` to a request sent with `token` is one a refresh may answer. */
-    mayRefresh(token, path) {
-        return token !== undefined && this.current !== undefined && !ceremony(path);
-    }
-    /**
-     * A fresh session in place of the one `token` belonged to: by the refresh
-     * another request already made, or by one this request starts.
-     */
-    async renew(token) {
-        if (this.auth !== token)
-            return;
-        await this.refresh();
-    }
-    async json(method, path, body, raw, contentType) {
-        const response = await this.send(method, path, body, raw, contentType);
-        const text = await response.text();
-        return (text ? JSON.parse(text) : {});
-    }
-    /**
-     * {@link json} for a call or a view (D70): while the node answers 503 or
-     * cannot be reached, the same request, with the same idempotency key, is sent
-     * again after {@link retryDelayMs} (or the pause the node asked for, if
-     * longer), at most `retries` times. Every other answer is final.
-     *
-     * When a node's retries run out, the request fails over to the next node the
-     * client knows and its retries start again there, with the same key: the
-     * key is kept in the app's replicated log, so the cluster answers it once
-     * whichever node it reaches. Each node is tried once per request. The last
-     * failure surfaces as {@link UnavailableError}: the node's 503, or reason
-     * `network` for a connection that failed, whose `committed` is `'unknown'`.
-     *
-     * `once` sends the request exactly once, to the node in use (the confirmed
-     * attempt of {@link callConfirmed}, whose challenge is single-use).
-     */
-    async retried(method, path, body, once = false) {
-        const retries = once ? 0 : this.retry.retries;
-        const tried = new Set();
-        for (;;) {
-            let unavailable;
-            let node = this.nodeUrl;
-            for (let attempt = 0;; attempt++) {
-                node = this.nodeUrl;
-                tried.add(node);
-                try {
-                    return await this.json(method, path, body);
-                }
-                catch (error) {
-                    if (error instanceof UnavailableError)
-                        unavailable = error;
-                    else if (error instanceof TypeError && this.networkFailures.has(error)) {
-                        unavailable = new UnavailableError('NETWORK', `the node could not be reached: ${error.message}`, {}, undefined, error);
-                    }
-                    else
-                        throw error;
-                }
-                if (attempt >= retries)
-                    break;
-                const backoff = retryDelayMs(attempt, this.retry);
-                await new Promise((resolve) => setTimeout(resolve, Math.max(backoff, (unavailable.retryAfter ?? 0) * 1000)));
-            }
-            if (once || !this.failOver(node, tried))
-                throw unavailable;
-        }
+    /** A JSON request, or a raw one when `raw` is given (as `contentType`, the transport's default when absent). */
+    json(method, path, body, raw, contentType) {
+        const options = raw ? { bytes: raw, ...(contentType === undefined ? {} : { contentType }) } : { body };
+        return this.transport.json(method, path, options);
     }
     post(path, body = {}) {
         return this.json('POST', path, body);
@@ -518,7 +164,7 @@ export class CalimeroClient {
         // the passkey with `preferred`: asking `required` here would refuse a
         // security key without a PIN after it has made the passkey, leaving a
         // passkey with no account.
-        const session = await this.confirmed('POST', 'auth/passkey/register/finish', { challengeId: begin.challengeId, registration, ...invite }, passkey, undefined, 'preferred', signal);
+        const session = await this.confirmed('POST', 'auth/passkey/register/finish', { challengeId: begin.challengeId, registration, ...invite }, passkey, 'preferred', signal);
         this.useSession(session);
         return session;
     }
@@ -559,7 +205,7 @@ export class CalimeroClient {
         const page = globalThis.location?.origin;
         if (!page || page === 'null')
             return undefined;
-        const nodes = new Set(this.nodeUrls.map((url) => {
+        const nodes = new Set(this.transport.nodes.map((url) => {
             try {
                 return new URL(url).origin;
             }
@@ -588,38 +234,7 @@ export class CalimeroClient {
      * same token again (which would revoke the session).
      */
     refresh() {
-        if (!this.refreshing) {
-            const pending = this.exchangeRefresh();
-            this.refreshing = pending;
-            const clear = () => {
-                if (this.refreshing === pending)
-                    this.refreshing = undefined;
-            };
-            pending.then(clear, clear);
-        }
-        return this.refreshing;
-    }
-    async exchangeRefresh() {
-        const current = this.current;
-        if (!current)
-            throw new Error('no session to refresh');
-        let session;
-        // A node that may not serve the account answers `421 WRONG_NODE` before it
-        // spends the refresh token (core #4774), so the same token goes to the next
-        // node (`send` moved there already): once per node, at most.
-        for (let tried = 1; session === undefined; tried++) {
-            try {
-                session = await this.post('auth/refresh', { refreshToken: current.refreshToken });
-            }
-            catch (error) {
-                if (!(error instanceof WrongNode) || tried >= this.nodeUrls.length)
-                    throw error;
-            }
-        }
-        // A sign-in or another session taken while this one was refreshing wins.
-        if (this.current === current)
-            this.useSession(session);
-        return session;
+        return this.transport.refresh();
     }
     /**
      * End this session. The client is signed out whether or not the node
@@ -680,8 +295,7 @@ export class CalimeroClient {
             await this.post(path);
         }
         finally {
-            this.auth = undefined;
-            this.current = undefined;
+            this.transport.signOut();
         }
     }
     /** Who the credential is: the account, how it signed in, and the package (`app`) and `origin` a session is bound to. */
@@ -781,9 +395,7 @@ export class CalimeroClient {
      */
     async attestation() {
         const nonce = toHex(crypto.getRandomValues(new Uint8Array(32)));
-        const response = await this.raw(`${this.nodeUrl}/attestation?nonce=${nonce}`);
-        if (!response.ok)
-            throw await refusal(response);
+        const response = await this.transport.unsealed('attestation', { query: { nonce } });
         return (await response.json());
     }
     /** The account's API keys (never the keys themselves). */
@@ -844,8 +456,9 @@ export class CalimeroClient {
      * app; `application/octet-stream` otherwise.
      */
     async blobContent(app, id, options = {}) {
-        const query = options.grant === undefined ? '' : `?grant=${encodeURIComponent(options.grant)}`;
-        const response = await this.send('GET', `apps/${seg(app)}/blobs/${seg(id)}${query}`);
+        const response = await this.transport.request('GET', `apps/${seg(app)}/blobs/${seg(id)}`, {
+            query: { grant: options.grant },
+        });
         return {
             data: new Uint8Array(await response.arrayBuffer()),
             contentType: response.headers.get('content-type') ?? 'application/octet-stream',
@@ -992,30 +605,12 @@ export class CalimeroClient {
     deleteConfirmed(path, passkey, body = {}) {
         return this.confirmed('DELETE', path, body, passkey);
     }
-    async confirmed(method, path, body, passkey, send = (b) => this.json(method, path, b), userVerification = 'required', signal) {
-        try {
-            return await send(body);
-        }
-        catch (error) {
-            if (!(error instanceof ConfirmRequired) || !passkey)
-                throw error;
-            const d = error.details;
-            let assertion;
-            try {
-                // A step-up is taken only with the user verified (PIN or biometric);
-                // `preferred` lets a password manager skip it, and the node then
-                // refuses. Only the sign-up confirmation passes `preferred`. A
-                // requirement the node names itself wins.
-                assertion = await passkey.get(fromB64url(d.challenge), d.rpId, d.allowCredentials, {
-                    userVerification: userVerificationOf(d.userVerification, userVerification),
-                    ...(signal ? { signal } : {}),
-                });
-            }
-            catch (declined) {
-                throw promptFailure(declined);
-            }
-            return send({ ...body, confirm: { challengeId: d.challengeId, assertion } });
-        }
+    /**
+     * `body` to `path`, answering a `412 CONFIRM_REQUIRED` with `passkey` when one
+     * is given; `signal` aborts only the passkey prompt.
+     */
+    confirmed(method, path, body, passkey, userVerification, signal) {
+        return this.transport.json(method, path, { body, passkey, userVerification, promptSignal: signal });
     }
     /**
      * Create an app instance from a bundle hash, or from a package release
@@ -1039,7 +634,7 @@ export class CalimeroClient {
      */
     call(app, method, args = {}, idempotencyKey) {
         const key = idempotencyKey ?? newIdempotencyKey();
-        return this.retried('POST', `apps/${seg(app)}/intents`, { method, args, idempotencyKey: key });
+        return this.transport.json('POST', `apps/${seg(app)}/intents`, { body: { method, args, idempotencyKey: key }, retry: true });
     }
     /**
      * Call a method that needs the account holder's approval: the node returns a
@@ -1051,27 +646,23 @@ export class CalimeroClient {
         const key = idempotencyKey ?? newIdempotencyKey();
         // The confirmed attempt goes out exactly once: its challenge is single-use,
         // so a resend would be refused on the challenge, not answered from the key.
-        return this.confirmed('POST', path, { method, args, idempotencyKey: key }, passkey, (body) => this.retried('POST', path, body, body.confirm !== undefined));
+        return this.transport.json('POST', path, { body: { method, args, idempotencyKey: key }, passkey, retry: true });
     }
     /** Run a read-only method: strong by default, or stale from any replica. */
     view(app, method, args = {}, options = {}) {
-        return this.retried('POST', `apps/${seg(app)}/views`, {
-            method,
-            args,
-            consistency: options.stale ? 'stale' : 'strong',
-            minIndex: options.minIndex ?? 0,
+        return this.transport.json('POST', `apps/${seg(app)}/views`, {
+            body: {
+                method,
+                args,
+                consistency: options.stale ? 'stale' : 'strong',
+                minIndex: options.minIndex ?? 0,
+            },
+            retry: true,
         });
     }
     /** Committed events from index `from`, then live, until `signal` aborts. */
     events(app, from = 0, signal) {
-        return this.stream(`apps/${seg(app)}/events?from=${from}`, signal);
-    }
-    /** A server-sent event stream on `path`, sealed like every other answer. */
-    async *stream(path, signal) {
-        const response = await this.send('GET', path, undefined, undefined, undefined, signal);
-        if (!response.body)
-            throw new CalimeroError(response.status, 'EVENTS', 'the event stream has no body');
-        yield* sseFrames(response.body);
+        return this.transport.events(`apps/${seg(app)}/events`, { query: { from }, signal });
     }
     // ---------------------------------------------------------------- presence
     /**
@@ -1092,7 +683,7 @@ export class CalimeroClient {
      * entries present), then a `presence` event (`data` one entry) per change.
      */
     presenceStream(app, signal) {
-        return this.stream(`apps/${seg(app)}/presence/stream`, signal);
+        return this.transport.events(`apps/${seg(app)}/presence/stream`, { signal });
     }
     // ---------------------------------------------------------------- aliases
     /** Name an app (its id or context id) for this account. */