@pmate/chat-sdk 0.9.8 → 0.9.10

package/lib/runtime/call.d.ts

@@ -1,9 +1,12 @@
+import type { OnlineReachEvent } from "./reach.js";
 export type MeetingRoom = {
     groupId: string;
     meetingId: string;
     startedAt: number;
     initiatorId: string;
     profileIds: string[];
+    invitationId?: string;
+    inviteProfileIds?: string[];
 };
 export type CallPhase = "idle" | "requesting" | "ringing" | "incoming" | "connecting" | "connected" | "ended";
 export type CallSnapshot = {
@@ -36,6 +39,7 @@ export type CallEnded = {
 };
 export type CallClientOptions = {
     profileId: string;
+    clientInstanceId?: string;
     token: string;
     url?: string;
     iceTransportPolicy?: RTCIceTransportPolicy;
@@ -59,6 +63,7 @@ export declare class CallClient {
     private closed;
     private capturePending;
     private attachId?;
+    private attachWaiters;
     private terminalCalls;
     private requestId?;
     private groupIds;
@@ -72,6 +77,11 @@ export declare class CallClient {
     connect(): void;
     /** Notification/reach entry: query authoritative state before showing a call. */
     attach(callId: string): void;
+    /** Resolves only after an authoritative response has been applied, never after socket send. */
+    attachAndWait(callId: string, timeoutMs?: number): Promise<"handled" | "suppressed">;
+    private settleAttach;
+    /** Pass only events received through the authenticated OnlineReachReceiver. */
+    handleReach(event: OnlineReachEvent): Promise<"handled" | "suppressed">;
     private rememberTerminal;
     watchPeer(peerId?: string): void;
     watchGroups(groupIds: string[]): void;

package/lib/runtime/call.js

@@ -13,6 +13,7 @@ export class CallClient {
     closed = false;
     capturePending = false;
     attachId;
+    attachWaiters = new Map();
     terminalCalls = new Map();
     requestId;
     groupIds = [];
@@ -31,7 +32,7 @@ export class CallClient {
         const ws = (this.options.createWebSocket ?? (url => new WebSocket(url)))(this.options.url ?? "wss://calls.pmate.chat/call");
         this.ws = ws;
         ws.onopen = () => { if (this.ws === ws)
-            this.send({ type: "auth", token: this.options.token, profileId: this.options.profileId }); };
+            this.send({ type: "auth", token: this.options.token, profileId: this.options.profileId, ...(this.options.clientInstanceId ? { clientInstanceId: this.options.clientInstanceId } : {}) }); };
         ws.onmessage = event => {
             if (this.ws !== ws)
                 return;
@@ -71,6 +72,69 @@ export class CallClient {
         else
             this.connect();
     }
+    /** Resolves only after an authoritative response has been applied, never after socket send. */
+    attachAndWait(callId, timeoutMs = 4000) {
+        if (this.closed || !callId || callId.length > 128)
+            return Promise.reject(new Error("INVALID_CALL_ID"));
+        if (this.terminalCalls.has(callId))
+            return Promise.resolve("suppressed");
+        return new Promise((resolve, reject) => {
+            const finish = () => {
+                clearTimeout(timer);
+                const waiters = this.attachWaiters.get(callId);
+                waiters?.delete(waiter);
+                if (!waiters?.size)
+                    this.attachWaiters.delete(callId);
+            };
+            const waiter = { resolve: (result) => { finish(); resolve(result); }, reject: (error) => { finish(); reject(error); } };
+            const timer = setTimeout(() => waiter.reject(new Error("CALL_ATTACH_TIMEOUT")), timeoutMs);
+            const waiters = this.attachWaiters.get(callId) ?? new Set();
+            waiters.add(waiter);
+            this.attachWaiters.set(callId, waiters);
+            try {
+                this.attach(callId);
+            }
+            catch (error) {
+                waiter.reject(error instanceof Error ? error : new Error("CALL_ATTACH_FAILED"));
+            }
+        });
+    }
+    settleAttach(callId, result) {
+        for (const waiter of [...(this.attachWaiters.get(callId) ?? [])]) {
+            if (result instanceof Error)
+                waiter.reject(result);
+            else
+                waiter.resolve(result);
+        }
+        if (this.attachId === callId)
+            this.attachId = undefined;
+    }
+    /** Pass only events received through the authenticated OnlineReachReceiver. */
+    async handleReach(event) {
+        if (this.closed)
+            throw new Error("CALL_CLIENT_CLOSED");
+        const { callId, callerId, calleeId, reason, winningClientInstanceId } = event.payload;
+        if (typeof callId !== "string" || !callId || callId.length > 128 || (callerId !== this.options.profileId && calleeId !== this.options.profileId))
+            throw new Error("INVALID_CALL_REACH");
+        if (event.expiresAtMs <= Date.now())
+            return "suppressed";
+        if (event.eventType === "call.incoming") {
+            if (calleeId !== this.options.profileId)
+                throw new Error("INVALID_CALL_RECIPIENT");
+            return this.attachAndWait(callId);
+        }
+        if (event.eventType !== "call.ended" || typeof reason !== "string" || !reason || reason.length > 128)
+            throw new Error("INVALID_CALL_REACH");
+        if (reason === "answered_elsewhere" && winningClientInstanceId && winningClientInstanceId === this.options.clientInstanceId)
+            return "suppressed";
+        this.rememberTerminal(callId);
+        if (this.state.callId === callId && !["idle", "ended"].includes(this.state.phase)) {
+            this.release();
+            this.update({ phase: "ended", reason });
+        }
+        this.settleAttach(callId, "suppressed");
+        return "handled";
+    }
     rememberTerminal(callId) {
         this.terminalCalls.set(callId, Date.now());
         for (const [id, time] of this.terminalCalls)
@@ -208,6 +272,8 @@ export class CallClient {
         this.closed = true;
         clearTimeout(this.reconnect);
         clearInterval(this.heartbeat);
+        for (const callId of [...this.attachWaiters.keys()])
+            this.settleAttach(callId, new Error("CALL_CLIENT_CLOSED"));
         this.hangup();
         this.ws?.close();
         this.ws = undefined;
@@ -247,8 +313,8 @@ export class CallClient {
     async receive(message) {
         if (message.type === "ready") {
             this.update({ ready: true, error: undefined });
-            if (this.attachId)
-                this.send({ type: "call.attach", callId: this.attachId });
+            for (const callId of new Set([...this.attachWaiters.keys(), ...(this.attachId ? [this.attachId] : [])]))
+                this.send({ type: "call.attach", callId });
             if (this.state.watchedPeerId)
                 this.send({ type: "presence.watch", peerId: this.state.watchedPeerId });
             if (this.groupIds.length)
@@ -280,14 +346,15 @@ export class CallClient {
             }
             if (message.requestId && message.requestId !== this.requestId)
                 return;
+            if (typeof message.callId === "string" && this.attachWaiters.has(message.callId))
+                this.settleAttach(message.callId, new Error(message.code ?? "CALL_ATTACH_FAILED"));
             if (!message.callId || message.callId === this.state.callId)
                 this.fail(message.code);
             return;
         }
         if (message.type === "call.status") {
-            if (message.callId !== this.attachId)
+            if (message.callId !== this.attachId && !this.attachWaiters.has(message.callId))
                 return;
-            this.attachId = undefined;
             if (message.state === "ended") {
                 this.rememberTerminal(message.callId);
                 if (["idle", "ended"].includes(this.state.phase) || this.state.callId === message.callId) {
@@ -295,15 +362,21 @@ export class CallClient {
                     this.update({ phase: "ended", callId: message.callId, reason: message.reason });
                 }
             }
+            this.settleAttach(message.callId, message.state === "accepted" && message.callId === this.state.callId ? "handled" : "suppressed");
             return;
         }
         if (message.type === "ringing") {
-            if (this.terminalCalls.has(message.callId))
+            if (this.terminalCalls.has(message.callId)) {
+                this.settleAttach(message.callId, "suppressed");
                 return;
-            if (message.callId === this.state.callId && ["incoming", "ringing", "connecting", "connected"].includes(this.state.phase))
+            }
+            if (message.callId === this.state.callId && ["incoming", "ringing", "connecting", "connected"].includes(this.state.phase)) {
+                this.settleAttach(message.callId, "handled");
                 return;
+            }
             if (typeof message.expiresAt === "number" && message.expiresAt <= Date.now()) {
                 this.rememberTerminal(message.callId);
+                this.settleAttach(message.callId, "suppressed");
                 return;
             }
             if (this.attachId === message.callId)
@@ -314,14 +387,18 @@ export class CallClient {
             }
             if (message.direction === "incoming" && !["idle", "ended"].includes(this.state.phase)) {
                 this.send({ type: "hangup", callId: message.callId });
+                this.settleAttach(message.callId, "suppressed");
                 return;
             }
             this.update({ phase: message.direction === "incoming" ? "incoming" : "ringing", callId: message.callId, peerId: message.peerId, direction: message.direction, error: undefined, reason: undefined, startedAt: undefined });
             this.armTimeout(typeof message.expiresAt === "number" ? Math.max(1, message.expiresAt - Date.now()) : 35000);
+            this.settleAttach(message.callId, "handled");
             return;
         }
-        if (message.type === "ended" && typeof message.callId === "string")
+        if (message.type === "ended" && typeof message.callId === "string") {
             this.rememberTerminal(message.callId);
+            this.settleAttach(message.callId, "suppressed");
+        }
         if (message.callId !== this.state.callId)
             return;
         if (message.type === "ended") {

package/lib/runtime/meeting.d.ts

@@ -35,10 +35,11 @@ export declare class GroupMeetingClient {
     private lastSeen;
     private iceServers;
     private queue;
+    private inviteProfileIds;
     constructor(options: CallClientOptions);
     snapshot(): MeetingSnapshot;
     subscribe(fn: (s: MeetingSnapshot) => void): () => void;
-    join(groupId: string): Promise<void>;
+    join(groupId: string, inviteProfileIds?: string[]): Promise<void>;
     leave(): void;
     dismiss(): void;
     close(): void;

package/lib/runtime/meeting.js

@@ -14,15 +14,19 @@ export class GroupMeetingClient {
     lastSeen = 0;
     iceServers = [];
     queue = Promise.resolve();
+    inviteProfileIds = [];
     constructor(options) {
         this.options = options;
     }
     snapshot() { return this.state; }
     subscribe(fn) { this.listeners.add(fn); fn(this.state); return () => { this.listeners.delete(fn); }; }
-    async join(groupId) {
+    async join(groupId, inviteProfileIds = []) {
+        if (!Array.isArray(inviteProfileIds) || inviteProfileIds.length > 256 || inviteProfileIds.some(id => typeof id !== "string" || !id || id.length > 128))
+            throw new Error("INVALID_INVITATION");
         if (!["idle", "ended"].includes(this.state.phase))
             return;
         this.release();
+        this.inviteProfileIds = [...new Set(inviteProfileIds)].filter(id => id !== this.options.profileId);
         const gen = this.generation;
         this.update({ phase: "joining", groupId, error: undefined });
         this.timer = setTimeout(() => this.fail("CONNECTION_TIMEOUT"), 30000);
@@ -39,7 +43,7 @@ export class GroupMeetingClient {
             const ws = (this.options.createWebSocket ?? (url => new WebSocket(url)))(this.options.url ?? "wss://calls.pmate.chat/call");
             this.ws = ws;
             ws.onopen = () => { if (gen === this.generation)
-                this.send({ type: "auth", mode: "meeting", profileId: this.options.profileId, token: this.options.token }); };
+                this.send({ type: "auth", mode: "meeting", profileId: this.options.profileId, token: this.options.token, clientInstanceId: this.options.clientInstanceId }); };
             ws.onmessage = e => { this.lastSeen = Date.now(); this.queue = this.queue.then(async () => { if (gen === this.generation)
                 await this.receive(JSON.parse(String(e.data)), gen); }).catch(() => { if (gen === this.generation)
                 this.fail("CONNECTION_FAILED"); }); };
@@ -172,7 +176,7 @@ export class GroupMeetingClient {
     }
     async receive(m, gen) {
         if (m.type === "ready") {
-            this.send({ type: "room.join", groupId: this.state.groupId, requestId: String(gen) });
+            this.send({ type: "room.join", groupId: this.state.groupId, requestId: String(gen), inviteProfileIds: this.inviteProfileIds });
             this.lastSeen = Date.now();
             this.heartbeat = setInterval(() => { if (Date.now() - this.lastSeen > 60000)
                 this.fail("DISCONNECTED");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",
@@ -28,15 +28,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "clean": "rimraf lib",
-    "build": "pnpm run clean && tsc -p tsconfig.build.json && cp src/voice/recorder-processor.js lib/voice/recorder-processor.js",
-    "prepack": "pnpm run build",
-    "npm:publish": "pnpm run build && npm publish --access public --registry https://registry.npmjs.org/",
-    "test": "vitest run",
-    "storybook": "storybook dev -p 6009",
-    "build-storybook": "storybook build --output-dir dist"
-  },
   "dependencies": {
     "@emoji-mart/data": "^1.2.1",
     "@emoji-mart/react": "^1.1.1",
@@ -51,16 +42,24 @@
   "devDependencies": {
     "@storybook/addon-docs": "^9.0.17",
     "@storybook/react-vite": "9.0.17",
-    "@tailwindcss/vite": "catalog:",
-    "@types/react": "catalog:",
-    "@types/react-dom": "catalog:",
+    "@tailwindcss/vite": "^4.1.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
     "fake-indexeddb": "^6.2.5",
-    "react": "catalog:",
-    "react-dom": "catalog:",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
     "rimraf": "^6.1.2",
     "storybook": "^9.0.17",
-    "tailwindcss": "catalog:",
+    "tailwindcss": "^4.0.14",
     "typescript": "5.9.2",
     "vitest": "^4.0.17"
+  },
+  "scripts": {
+    "clean": "rimraf lib",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json && cp src/voice/recorder-processor.js lib/voice/recorder-processor.js",
+    "npm:publish": "pnpm run build && npm publish --access public --registry https://registry.npmjs.org/",
+    "test": "vitest run",
+    "storybook": "storybook dev -p 6009",
+    "build-storybook": "storybook build --output-dir dist"
   }
-}
+}