@calimero-network/mero-js 2.0.0-beta.1 → 2.0.1

package/README.md

@@ -1,464 +1,481 @@
-# Mero.js v2 — Pure JavaScript SDK for Calimero
+# Mero.js - Pure JavaScript SDK for Calimero
 
-A lightweight, universal JavaScript SDK for interacting with Calimero nodes. Works in browsers, Node.js, React Native, and Tauri.
+A lightweight, universal JavaScript SDK for Calimero that works in both browser and Node.js environments using Web Standards.
+
+> **🚨 Breaking Change (v1.0.0)**: This version removes all legacy Axios-based code. The package now uses only Web Standards (`fetch`, `AbortController`) with zero external dependencies.
 
 ## Features
 
-- 🌐 **Universal** — Browser, Node.js, React Native, Tauri
-- 📦 **Zero Dependencies** — Built on Web Standards (`fetch`, `AbortController`)
-- 🔐 **Smart Token Management** — Automatic refresh on 401, preemptive refresh before expiry
-- 💾 **Pluggable Storage** — Bring your own `TokenStorage` (localStorage, AsyncStorage, Keychain)
-- 🔄 **Real-time** — WebSocket and SSE clients for event subscriptions
-- ⚡ **JSON-RPC** — Execute queries and mutations on contexts
-- 🛡️ **Type Safe** — Full TypeScript definitions
-- ✅ **Tested** — 236 unit tests, E2E with Merobox
+- 🌐 **Web Standards First**: Built on `fetch`, `AbortController`, and other Web APIs
+- 🔄 **Universal**: Works in browsers, Node.js, and edge runtimes
+- 📦 **Zero Dependencies**: No external dependencies, uses native Web APIs
+- 🔧 **Dependency Injection**: Flexible and testable architecture
+- ⚡ **Modern**: ES2020+ with TypeScript support
+- 🛡️ **Type Safe**: Full TypeScript definitions
+- 🔄 **Smart Retry**: Distinguishes user aborts vs timeouts for intelligent retry logic
+- 🎯 **Advanced Cancellation**: Signal combination and proper timeout handling
 
-## Installation
+## Behavior
 
-```bash
-npm install @calimero-network/mero-js
-# or
-pnpm add @calimero-network/mero-js
-```
+### Error Model (Throwing)
 
-## Quick Start
+The client **throws** `HTTPError` on any `!response.ok` status. Network/timeout/abort errors are re-thrown as-is:
 
 ```typescript
-import { MeroJs } from '@calimero-network/mero-js';
+try {
+  const data = await httpClient.get('/api/data');
+  // Success - data is the parsed response
+} catch (error) {
+  if (error instanceof HTTPError) {
+    console.log(`HTTP ${error.status}: ${error.statusText}`);
+    console.log('URL:', error.url);
+    console.log('Headers:', error.headers);
+    console.log('Body:', error.bodyText); // Up to 64KB
+  } else if (error.name === 'TimeoutError') {
+    // Request timed out
+  } else if (error.name === 'AbortError') {
+    // Request was cancelled
+  }
+}
+```
 
-const mero = new MeroJs({
-  baseUrl: 'http://localhost:2428',
-  credentials: {
-    username: 'admin',
-    password: 'your-password',
-  },
-});
+### Parsing Defaults & Override
 
-// Authenticate
-await mero.authenticate();
+Each method accepts optional `{ parse?: 'json'|'text'|'blob'|'arrayBuffer'|'response' }`:
 
-// Use the Admin API
-const apps = await mero.admin.applications.listApplications();
-const contexts = await mero.admin.contexts.listContexts();
+**Default parsing rules:**
 
-// Execute JSON-RPC calls
-const result = await mero.rpc.query(
-  'context-id',
-  'get',
-  { key: 'myKey' },
-  'ed25519:executor-public-key'
-);
-```
+- `Content-Type: application/json` → parse as JSON
+- `Content-Type: text/*` → parse as text
+- Other types → parse as `arrayBuffer`
 
-## Token Persistence
+**Override:**
 
-By default, tokens are stored in-memory. Provide a `TokenStorage` to persist across sessions:
+```typescript
+// Get raw Response object
+const response = await httpClient.get('/api/data', { parse: 'response' });
+```
 
-### Browser (localStorage)
+### Retry Policy (`withRetry`)
 
-```typescript
-const mero = new MeroJs({
-  baseUrl: 'http://localhost:2428',
-  credentials: { username: 'admin', password: 'password' },
-  tokenStorage: {
-    async get() {
-      const data = localStorage.getItem('mero-token');
-      return data ? JSON.parse(data) : null;
-    },
-    async set(token) {
-      localStorage.setItem('mero-token', JSON.stringify(token));
-    },
-    async clear() {
-      localStorage.removeItem('mero-token');
-    },
-  },
-});
+The `withRetry` helper retries on:
 
-// Load stored tokens on startup
-await mero.init();
+- `HTTPError` with status `429` or `>= 500`
+- `TimeoutError` (internal timeouts)
+- `TypeError` (network failures)
 
-if (!mero.isAuthenticated()) {
-  await mero.authenticate();
-}
-```
+**Never retries:**
 
-### React Native (AsyncStorage)
+- `AbortError` (user/caller aborts)
 
 ```typescript
-import AsyncStorage from '@react-native-async-storage/async-storage';
-
-const mero = new MeroJs({
-  baseUrl: 'http://localhost:2428',
-  credentials: { username: 'admin', password: 'password' },
-  tokenStorage: {
-    async get() {
-      const data = await AsyncStorage.getItem('mero-token');
-      return data ? JSON.parse(data) : null;
-    },
-    async set(token) {
-      await AsyncStorage.setItem('mero-token', JSON.stringify(token));
-    },
-    async clear() {
-      await AsyncStorage.removeItem('mero-token');
-    },
-  },
-});
+import { withRetry } from '@calimero-network/mero-js';
+
+const data = await withRetry(
+  (attempt) => httpClient.get('/api/data'),
+  { attempts: 3 }, // Default: 3 attempts
+);
 ```
 
-### Tauri (Secure Store)
+### Signal Composition
+
+The client combines caller signals with internal timeouts:
 
 ```typescript
-import { Store } from '@tauri-apps/plugin-store';
-
-const store = new Store('.tokens.dat');
-
-const mero = new MeroJs({
-  baseUrl: 'http://localhost:2428',
-  requestCredentials: 'omit', // Required for Tauri
-  tokenStorage: {
-    async get() {
-      return await store.get('mero-token');
-    },
-    async set(token) {
-      await store.set('mero-token', token);
-      await store.save();
-    },
-    async clear() {
-      await store.delete('mero-token');
-      await store.save();
-    },
-  },
+const userSignal = new AbortController().signal;
+const data = await httpClient.get('/api/data', {
+  signal: userSignal,
+  timeoutMs: 5000,
 });
 ```
 
-## Token Refresh
+### Header Precedence & Authorization
 
-The SDK automatically handles token refresh in two ways:
+- **Caller headers win**: Request-level headers override client defaults
+- **Authorization rules**: Only set `Authorization: Bearer ${token}` if caller didn't provide any `authorization` header (case-insensitive)
 
-1. **Preemptive** — Refreshes 5 minutes before expiry
-2. **Reactive** — On 401 with `x-auth-error: token_expired`, automatically refreshes and retries
+### FormData Handling
 
-```
-┌─────────────────────────────────────────────────┐
-│                Token Lifecycle                  │
-├─────────────────────────────────────────────────┤
-│  authenticate() ──> Token stored                │
-│                     │                           │
-│  API Request ───────┼──> Token valid? ──yes──>  │
-│                     │         │                 │
-│                     │        no (within 5min)   │
-│                     │         │                 │
-│                     │         ▼                 │
-│                     │    Refresh token          │
-│                     │         │                 │
-│  401 + expired ─────┼─────────┘                 │
-│                     │                           │
-│  clearToken() ──────┼──> Token cleared          │
-└─────────────────────────────────────────────────┘
+For `FormData` bodies, the client does **not** set `content-type` (lets browser/undici add the boundary):
+
+```typescript
+const formData = new FormData();
+formData.append('file', file);
+await httpClient.post('/api/upload', formData);
+// No content-type header is set by the client
 ```
 
-## API Reference
+### Credentials
 
-### MeroJs Class
+No implicit `same-origin` default. Credentials are only set if explicitly provided:
 
 ```typescript
-interface MeroJsConfig {
-  baseUrl: string;              // Node URL
-  authBaseUrl?: string;         // Auth service URL (if separate)
-  credentials?: { username: string; password: string };
-  timeoutMs?: number;           // Default: 10000
-  requestCredentials?: RequestCredentials;
-  tokenStorage?: TokenStorage;  // For persistence
-}
-
-const mero = new MeroJs(config);
-
-// Lifecycle
-await mero.init();              // Load tokens from storage
-await mero.authenticate();      // Get new tokens
-await mero.clearToken();        // Clear tokens
-mero.isAuthenticated();         // Check auth status
-mero.getTokenData();            // Get current tokens
+const client = createBrowserHttpClient({
+  baseUrl: 'https://api.example.com',
+  credentials: 'include', // Only if you want to include credentials
+});
+```
 
-// API Clients
-mero.auth                       // Auth API
-mero.admin                      // Admin API
-mero.rpc                        // JSON-RPC client
+## Installation
 
-// Real-time
-mero.createWebSocket();         // WebSocket client
-mero.createSse();               // SSE client
+```bash
+npm install @calimero-network/mero-js
 ```
 
-### Admin API
+## Quick Start
+
+### Browser Usage
 
 ```typescript
-// Applications
-await mero.admin.applications.listApplications();
-await mero.admin.applications.getApplication(appId);
-await mero.admin.applications.installApplication({ url, metadata });
-await mero.admin.applications.uninstallApplication(appId);
-
-// Contexts
-await mero.admin.contexts.listContexts();
-await mero.admin.contexts.createContext({ applicationId, contextSeed });
-await mero.admin.contexts.getContext(contextId);
-await mero.admin.contexts.deleteContext(contextId);
-await mero.admin.contexts.joinContext({ contextId, invitationPayload });
-
-// Blobs
-await mero.admin.blobs.listBlobs();
-await mero.admin.blobs.uploadBlob(data);
-await mero.admin.blobs.getBlob(blobId);
-await mero.admin.blobs.deleteBlob(blobId);
-
-// Identity
-await mero.admin.identity.generateContextIdentity();
-
-// Network
-await mero.admin.network.getPeersCount();
-
-// Public (no auth required)
-await mero.admin.public.health();
-await mero.admin.public.isAuthed();
-```
+import { createBrowserHttpClient } from '@calimero-network/mero-js';
 
-### Auth API
+const httpClient = createBrowserHttpClient({
+  baseUrl: 'https://api.calimero.network',
+  getAuthToken: async () => localStorage.getItem('access_token'),
+  onTokenRefresh: async (newToken) =>
+    localStorage.setItem('access_token', newToken),
+});
 
-```typescript
-// Health & Info
-await mero.auth.getHealth();
-await mero.auth.getIdentity();
-await mero.auth.getProviders();
-
-// Tokens
-await mero.auth.getToken(request);
-await mero.auth.refreshToken({ refresh_token });
-await mero.auth.validateToken({ token });
-
-// Keys
-await mero.auth.listRootKeys();
-await mero.auth.createRootKey(request);
-await mero.auth.deleteRootKey(publicKey);
-await mero.auth.listClientKeys();
-await mero.auth.generateClientKey(request);
-await mero.auth.deleteClientKey(publicKey);
+// Make requests
+try {
+  const data = await httpClient.get<{ message: string }>('/api/hello');
+  console.log(data.message);
+} catch (error) {
+  console.error('Request failed:', error);
+}
 ```
 
-### JSON-RPC
+### Node.js Usage
 
 ```typescript
-// Query (read-only)
-const result = await mero.rpc.query(
-  'context-id',
-  'get',
-  { key: 'myKey' },
-  'ed25519:executor-public-key'
-);
+import { createNodeHttpClient } from '@calimero-network/mero-js';
+// For Node.js < 18, install undici: npm install undici
+import { fetch as undiciFetch } from 'undici';
+
+const httpClient = createNodeHttpClient({
+  baseUrl: 'https://api.calimero.network',
+  fetch: undiciFetch, // Required for Node.js < 18
+  getAuthToken: async () => process.env.ACCESS_TOKEN,
+});
 
-// Mutate (write)
-const result = await mero.rpc.mutate(
-  'context-id',
-  'set',
-  { key: 'myKey', value: 'myValue' },
-  'ed25519:executor-public-key'
-);
+const data = await httpClient.get<{ message: string }>('/api/hello');
+console.log(data.message);
+```
 
-// Generic execute
-const result = await mero.rpc.execute({
-  contextId: 'context-id',
-  method: 'myMethod',
-  args: { foo: 'bar' },
-  executorPublicKey: 'ed25519:...',
+### Universal Usage
+
+```typescript
+import { createUniversalHttpClient } from '@calimero-network/mero-js';
+
+const httpClient = createUniversalHttpClient({
+  baseUrl: 'https://api.calimero.network',
+  getAuthToken: async () => {
+    return typeof window !== 'undefined'
+      ? localStorage.getItem('access_token')
+      : process.env.ACCESS_TOKEN;
+  },
 });
 ```
 
-### WebSocket (Real-time Events)
+## API Reference
 
-```typescript
-const ws = mero.createWebSocket();
+### Factory Functions
 
-await ws.connect();
+#### `createBrowserHttpClient(options)`
 
-ws.onEvent((event) => {
-  console.log('Event:', event);
-});
+Creates an HTTP client optimized for browser environments.
 
-ws.onError((error) => {
-  console.error('Error:', error);
-});
+#### `createNodeHttpClient(options)`
+
+Creates an HTTP client for Node.js environments.
 
-await ws.subscribe(['context-id-1', 'context-id-2']);
+#### `createUniversalHttpClient(options)`
 
-// Later...
-await ws.unsubscribe(['context-id-1']);
-ws.disconnect();
+Creates an HTTP client that works in both browser and Node.js.
+
+### Options
+
+```typescript
+interface HttpClientOptions {
+  baseUrl: string; // Base URL for all requests
+  fetch?: typeof fetch; // Custom fetch implementation (Node.js)
+  getAuthToken?: () => Promise<string | undefined>; // Token getter
+  onTokenRefresh?: (token: string) => Promise<void>; // Token refresh callback
+  defaultHeaders?: Record<string, string>; // Default headers
+  timeoutMs?: number; // Request timeout (default: 30000)
+  credentials?: RequestCredentials; // CORS credentials (default: 'same-origin' for browser)
+  defaultAbortSignal?: AbortSignal; // Default abort signal for all requests
+}
 ```
 
-### SSE (Server-Sent Events)
+### HTTP Methods
 
 ```typescript
-const sse = mero.createSse();
+// GET request
+const response = await httpClient.get<T>('/api/endpoint', init?);
 
-const sessionId = await sse.connect();
+// POST request
+const response = await httpClient.post<T>('/api/endpoint', body?, init?);
 
-sse.onEvent((event) => {
-  console.log('Event:', event);
-});
+// PUT request
+const response = await httpClient.put<T>('/api/endpoint', body?, init?);
 
-await sse.subscribe(['context-id-1']);
+// DELETE request
+const response = await httpClient.delete<T>('/api/endpoint', init?);
 
-// Get session info
-const session = await sse.getSession();
+// PATCH request
+const response = await httpClient.patch<T>('/api/endpoint', body?, init?);
 
-// Later...
-sse.disconnect();
-```
+// HEAD request
+const response = await httpClient.head<T>('/api/endpoint', init?);
 
-## Deep Imports
+// Generic request
+const response = await httpClient.request<T>('/api/endpoint', init?);
+```
 
-For tree-shaking or direct access:
+### Request Options
 
 ```typescript
-// Main SDK
-import { MeroJs } from '@calimero-network/mero-js';
-
-// HTTP Client only
-import { createBrowserHttpClient } from '@calimero-network/mero-js/http-client';
-
-// Specific API clients
-import { AdminApiClient } from '@calimero-network/mero-js/api/admin';
-import { AuthApiClient } from '@calimero-network/mero-js/api/auth';
-import { RpcClient } from '@calimero-network/mero-js/api/rpc';
-import { WebSocketClient } from '@calimero-network/mero-js/api/ws';
-import { SseClient } from '@calimero-network/mero-js/api/sse';
+interface RequestOptions extends RequestInit {
+  parse?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'response';
+  timeoutMs?: number;
+}
 ```
 
-## HTTP Client (Low-Level)
+### Response Format
 
-For custom use cases, use the HTTP client directly:
+All methods return the parsed data directly or throw errors:
 
 ```typescript
-import { createBrowserHttpClient, HTTPError } from '@calimero-network/mero-js';
-
-const http = createBrowserHttpClient({
-  baseUrl: 'https://api.example.com',
-  getAuthToken: async () => myTokenStore.getToken(),
-  refreshToken: async () => {
-    const newToken = await myRefreshLogic();
-    return newToken;
-  },
-  onTokenRefresh: async (token) => {
-    await myTokenStore.setToken(token);
-  },
-  timeoutMs: 10000,
-});
+// Success - returns parsed data
+const data: T = await httpClient.get<T>('/api/data');
 
+// Error - throws HTTPError or other errors
 try {
-  const data = await http.get<MyType>('/api/endpoint');
+  const data = await httpClient.get('/api/data');
 } catch (error) {
   if (error instanceof HTTPError) {
-    console.log(`HTTP ${error.status}: ${error.bodyText}`);
+    console.log(`HTTP ${error.status}: ${error.statusText}`);
+    console.log('URL:', error.url);
+    console.log('Headers:', error.headers);
+    console.log('Body:', error.bodyText);
   }
 }
 ```
 
-## Error Handling
+## Advanced Usage
+
+### Custom Transport
 
 ```typescript
-import { HTTPError, ApiResponseError } from '@calimero-network/mero-js';
+import { createHttpClient, Transport } from '@calimero-network/mero-js';
+
+const transport: Transport = {
+  fetch: customFetch,
+  baseUrl: 'https://api.example.com',
+  getAuthToken: async () => 'your-token',
+  timeoutMs: 5000,
+};
 
+const httpClient = createHttpClient(transport);
+```
+
+### Error Handling
+
+```typescript
 try {
-  await mero.admin.contexts.getContext('invalid-id');
+  const data = await httpClient.get('/api/data');
+  // Success - data is the parsed response
+  console.log(data);
 } catch (error) {
   if (error instanceof HTTPError) {
-    // HTTP-level error (4xx, 5xx)
-    console.log(`HTTP ${error.status}: ${error.statusText}`);
-    console.log('Body:', error.bodyText);
-  } else if (error instanceof ApiResponseError) {
-    // API-level error (in response body)
-    console.log(`API Error: ${error.message}`);
-    console.log('Type:', error.type);
-    console.log('Code:', error.code);
-  } else if (error.name === 'AbortError') {
-    // Request was cancelled
+    // HTTP error (4xx, 5xx)
+    console.error(`HTTP ${error.status}: ${error.statusText}`);
+    console.error('URL:', error.url);
+    console.error('Body:', error.bodyText);
   } else if (error.name === 'TimeoutError') {
     // Request timed out
+    console.error('Request timed out');
+  } else if (error.name === 'AbortError') {
+    // Request was cancelled
+    console.error('Request was cancelled');
+  } else {
+    // Network or other errors
+    console.error('Request failed:', error);
   }
 }
 ```
 
-## Testing
+### Custom Headers
 
-```bash
-# Unit tests (236 tests)
-pnpm test
+```typescript
+const data = await httpClient.post('/api/data', body, {
+  headers: {
+    'Content-Type': 'application/json',
+    'X-Custom-Header': 'value',
+  },
+});
+```
 
-# E2E tests with Merobox
-pnpm test:e2e
+### Request Cancellation
 
-# Full test suite
-pnpm test:all
+```typescript
+const abortController = new AbortController();
+
+// Cancel request after 5 seconds
+setTimeout(() => abortController.abort(), 5000);
+
+const data = await httpClient.get('/api/slow-endpoint', {
+  signal: abortController.signal,
+});
 ```
 
-## Development
+### FormData Support
 
-```bash
-# Install dependencies
-pnpm install
+```typescript
+const formData = new FormData();
+formData.append('file', fileInput.files[0]);
+formData.append('name', 'John Doe');
 
-# Build (with strict mode)
-pnpm build
+const data = await httpClient.post('/api/upload', formData);
+// Content-Type is set by the browser/undici with proper boundary
+```
 
-# Lint
-pnpm lint
+### Response Parsing
 
-# Type check
-pnpm typecheck
+```typescript
+// Explicit parsing
+const jsonData = await httpClient.get('/api/data', { parse: 'json' });
+const textData = await httpClient.get('/api/text', { parse: 'text' });
+const blobData = await httpClient.get('/api/file', { parse: 'blob' });
 
-# Generate MSW handlers from OpenAPI
-pnpm generate:msw
+// Auto-detection based on Content-Type (default)
+const autoData = await httpClient.get('/api/data');
 ```
 
-## Bundle Sizes
+### Retry with Exponential Backoff
+
+```typescript
+import { withRetry } from '@calimero-network/mero-js';
+
+const data = await withRetry(
+  (attempt) => httpClient.get('/api/unreliable-endpoint'),
+  { attempts: 3 }, // Default: 3 attempts
+);
+```
+
+### Signal Combination
+
+```typescript
+import { combineSignals, createTimeoutSignal } from '@calimero-network/mero-js';
+
+// Combine multiple abort signals
+const userSignal = new AbortController().signal;
+const timeoutSignal = createTimeoutSignal(5000);
+const combinedSignal = combineSignals([userSignal, timeoutSignal]);
+
+const data = await httpClient.get('/api/endpoint', {
+  signal: combinedSignal,
+});
+```
+
+### CORS and Credentials
+
+```typescript
+const httpClient = createBrowserHttpClient({
+  baseUrl: 'https://api.example.com',
+  credentials: 'include', // Include cookies in CORS requests
+});
+
+// For APIs that require credentials
+const data = await httpClient.get('/api/protected', {
+  credentials: 'include',
+});
+```
+
+## Migration from Axios
+
+If you're migrating from an Axios-based client:
 
-| Format | Size | Gzipped |
-|--------|------|---------|
-| ESM | ~57kb | ~15kb |
-| CJS | ~59kb | ~16kb |
-| Browser (minified) | ~29kb | ~9kb |
+1. **Replace imports**: Use the factory functions instead of direct class instantiation
+2. **Update method signatures**: Methods now use `RequestInit` instead of custom options
+3. **Handle responses**: Methods now return parsed data directly or throw errors (no more `ResponseData<T>`)
+4. **Token management**: Use the `getAuthToken` and `onTokenRefresh` callbacks
 
 ## Browser Support
 
-- Modern browsers with `fetch` (Chrome 42+, Firefox 39+, Safari 10.1+)
-- Node.js 18+ (native fetch) or 16+ with `undici`
-- React Native with `fetch` polyfill
-- Tauri (set `requestCredentials: 'omit'`)
+- Modern browsers with `fetch` support (Chrome 42+, Firefox 39+, Safari 10.1+)
+- Node.js 18+ (native fetch) or Node.js 16+ with `undici`
+
+## Bundle Sizes
+
+- **ESM**: ~9.4kb (gzipped: ~3.2kb)
+- **CJS**: ~10.5kb (gzipped: ~3.6kb)
+
+## Examples
+
+See the `examples/` directory for complete usage examples:
+
+- `browser-example.ts` - Browser-specific usage (designed for browser environments)
+- `node-example.ts` - Node.js-specific usage (designed for Node.js environments)
+- `universal-example.ts` - Universal usage (works in both browser and Node.js)
+
+**Note**: Run `npm run build` before running the examples, as they import from the built library.
+
+## Admin API
+
+The `AdminApiClient` provides methods for managing Calimero node resources:
+
+### Namespaces (application instances)
+```typescript
+const namespaces = await admin.listNamespaces();
+const identity = await admin.getNamespaceIdentity(namespaceId);
+const appNamespaces = await admin.listNamespacesForApplication(appId);
+```
 
-## Migration from v1.x
+### Groups (governance boundaries)
+```typescript
+const groups = await admin.listGroups();
+const group = await admin.createGroup({ applicationId: '...' });
+const info = await admin.getGroupInfo(groupId);
+const members = await admin.listGroupMembers(groupId);
+const contexts = await admin.listGroupContexts(groupId);
+```
 
-### Breaking Changes
+### Contexts (WASM execution instances)
+```typescript
+// Single-service app
+const ctx = await admin.createContext({ applicationId: '...' });
 
-1. **`clearToken()` is now async**
-   ```typescript
-   // Before
-   mero.clearToken();
-   
-   // After
-   await mero.clearToken();
-   ```
+// Multi-service app -- specify which service to run
+const ctx = await admin.createContext({
+  applicationId: '...',
+  serviceName: 'chat',
+});
+```
 
-2. **HTTP client wiring** — Token refresh callbacks are now wired automatically
+### Cloud (TEE High Availability)
+```typescript
+import { CloudClient } from '@calimero-network/mero-js';
+const cloud = new CloudClient();
+cloud.enableHA({ groupId, contextId, redirectUrl });
+```
 
-### New Features
+## Development
 
-- `TokenStorage` interface for persistence
-- `init()` method to load stored tokens
-- Automatic 401 token refresh with retry
-- WebSocket and SSE clients
-- JSON-RPC client
-- Lazy-loaded Admin API sub-clients
-- Enhanced `unwrap()` with RPC error detection
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Test
+pnpm test
+
+# Lint
+pnpm lint
+```
 
 ## License