@calimero-network/mero-js 13.0.0 → 13.1.0

package/dist/mero-js.d.ts

@@ -5,6 +5,7 @@ import type { AuthCallbackResult, AuthLoginOptions } from './auth/index.js';
 import { RpcClient } from './rpc/index.js';
 import { SseClient } from './events/sse.js';
 import { WsClient } from './events/ws.js';
+import { EphemeralClient } from './ephemeral/index.js';
 export interface MeroJsConfig {
     /** Base URL for the Calimero node */
     baseUrl: string;
@@ -48,6 +49,7 @@ export declare class MeroJs {
     private sseClient;
     private wsClient;
     private wsWarned;
+    private ephemeralClient?;
     constructor(config: MeroJsConfig);
     /**
      * Get the Auth API client
@@ -65,6 +67,13 @@ export declare class MeroJs {
      * Get the SSE event client (lazy initialized)
      */
     get events(): SseClient;
+    /**
+     * Get the ephemeral-presence client (lazy initialized).
+     *
+     * Shares this instance's SSE client, so `subscribe` reuses the one event
+     * stream rather than opening a second connection.
+     */
+    get ephemeral(): EphemeralClient;
     /**
      * Get the WebSocket event client (lazy initialized).
      * @experimental Use `events` (SSE) for production. WsClient is experimental.

package/dist/mero-js.js

@@ -5,6 +5,7 @@ import { parseAuthCallback, buildAuthLoginUrl } from './auth/index.js';
 import { RpcClient } from './rpc/index.js';
 import { SseClient } from './events/sse.js';
 import { WsClient } from './events/ws.js';
+import { EphemeralClient } from './ephemeral/index.js';
 /** Name of the Web Lock that serializes token refresh across tabs / webviews. */
 const REFRESH_LOCK_NAME = 'mero-js:token-refresh';
 /** Returns `navigator.locks` when the runtime supports the Web Locks API. */
@@ -141,6 +142,21 @@ export class MeroJs {
         }
         return this.sseClient;
     }
+    /**
+     * Get the ephemeral-presence client (lazy initialized).
+     *
+     * Shares this instance's SSE client, so `subscribe` reuses the one event
+     * stream rather than opening a second connection.
+     */
+    get ephemeral() {
+        if (!this.ephemeralClient) {
+            this.ephemeralClient = new EphemeralClient({
+                httpClient: this.httpClient,
+                sse: this.events,
+            });
+        }
+        return this.ephemeralClient;
+    }
     /**
      * Get the WebSocket event client (lazy initialized).
      * @experimental Use `events` (SSE) for production. WsClient is experimental.

package/dist/rpc/index.d.ts

@@ -17,6 +17,14 @@ export declare class RpcError extends Error {
     data?: unknown;
     constructor(code: number, message: string, data?: unknown, type?: string);
 }
+/**
+ * POST a JSON-RPC call and unwrap `result`, converting an `error` payload into
+ * an `RpcError`. The node returns `{ type, data }` (not always `{ code,
+ * message }`), so this is the one place that normalization lives — every
+ * JSON-RPC caller in this SDK shares it rather than re-deriving a bare
+ * `Error(message)` and dropping the typed detail.
+ */
+export declare function jsonRpcCall<T>(httpClient: HttpClient, method: string, params: unknown): Promise<T>;
 export declare class RpcClient {
     private httpClient;
     constructor(opts: {

package/dist/rpc/index.js

@@ -7,32 +7,40 @@ export class RpcError extends Error {
         this.type = type;
     }
 }
+/**
+ * POST a JSON-RPC call and unwrap `result`, converting an `error` payload into
+ * an `RpcError`. The node returns `{ type, data }` (not always `{ code,
+ * message }`), so this is the one place that normalization lives — every
+ * JSON-RPC caller in this SDK shares it rather than re-deriving a bare
+ * `Error(message)` and dropping the typed detail.
+ */
+export async function jsonRpcCall(httpClient, method, params) {
+    const response = await httpClient.post('/jsonrpc', {
+        jsonrpc: '2.0',
+        id: 1,
+        method,
+        params,
+    });
+    if (response.error) {
+        const err = response.error;
+        throw new RpcError(err.code ?? -1, err.message ?? err.type ?? 'RPC error', err.data, err.type);
+    }
+    return response.result;
+}
 export class RpcClient {
     constructor(opts) {
         this.httpClient = opts.httpClient;
     }
     async execute(params) {
-        const body = {
-            jsonrpc: '2.0',
-            id: 1,
-            method: 'execute',
-            params: {
-                contextId: params.contextId,
-                method: params.method,
-                argsJson: params.argsJson ?? {},
-            },
-        };
-        const response = await this.httpClient.post('/jsonrpc', body);
-        if (response.error) {
-            const err = response.error;
-            const code = err.code ?? -1;
-            const message = err.message ?? err.type ?? 'RPC error';
-            throw new RpcError(code, message, err.data, err.type);
-        }
-        if (response.result && 'output' in response.result) {
-            return response.result.output;
+        const result = await jsonRpcCall(this.httpClient, 'execute', {
+            contextId: params.contextId,
+            method: params.method,
+            argsJson: params.argsJson ?? {},
+        });
+        if (result && 'output' in result) {
+            return result.output;
         }
-        return response.result;
+        return result;
     }
     /**
      * One-tap owner-driven convert: re-signs the caller's identity-gated entries

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calimero-network/mero-js",
-  "version": "13.0.0",
+  "version": "13.1.0",
   "description": "Pure JavaScript SDK for Calimero",
   "type": "module",
   "exports": {