@sentdm/voice-client 0.0.0-stage → 0.1.1

package/invite.d.ts

@@ -0,0 +1,28 @@
+import type { Address, Call } from "./call.js";
+import { type SentVoiceError, TypedEmitter } from '@sentdm/voice-client-core';
+export interface CancelInfo {
+    error?: SentVoiceError;
+}
+export interface CallInviteEvents {
+    accepted: (call: Call) => void;
+    rejected: () => void;
+    cancelled: (info: CancelInfo) => void;
+}
+interface InviteProvider {
+    answer(): Promise<void>;
+    reject(): Promise<void>;
+    accepted(): void;
+}
+export declare class CallInvite extends TypedEmitter<CallInviteEvents> {
+    #private;
+    readonly from: Address;
+    readonly to: Address;
+    constructor(call: Call, provider: InviteProvider);
+    get state(): 'pending' | 'accepted' | 'rejected' | 'cancelled';
+    /** Answers the call, asking for microphone permission if it was not granted yet. */
+    accept(): Promise<Call>;
+    /** Declines the call; does nothing unless it is still pending. */
+    reject(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=invite.d.ts.map

package/invite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invite.d.ts","sourceRoot":"","sources":["src/invite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,kBAAe;AAC5C,OAAO,EAAmB,KAAK,cAAc,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE/F,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IAC/B,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,SAAS,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;CACvC;AAED,UAAU,cAAc;IACtB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,QAAQ,IAAI,IAAI,CAAC;CAClB;AAID,qBAAa,UAAW,SAAQ,YAAY,CAAC,gBAAgB,CAAC;;IAC5D,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;gBAMT,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc;IAahD,IAAI,KAAK,IAAI,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,CAE7D;IAED,oFAAoF;IAC9E,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAO7B,kEAAkE;IAC5D,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAmB9B"}

package/invite.js

@@ -0,0 +1,64 @@
+"use strict";
+var _CallInvite_instances, _CallInvite_call, _CallInvite_provider, _CallInvite_state, _CallInvite_accepting, _CallInvite_accept;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallInvite = void 0;
+const tslib_1 = require("./internal/tslib.js");
+const voice_client_core_1 = require("@sentdm/voice-client-core");
+const endedError = () => new voice_client_core_1.CallFailedError({ message: 'The call ended before it was answered.' });
+class CallInvite extends voice_client_core_1.TypedEmitter {
+    constructor(call, provider) {
+        super();
+        _CallInvite_instances.add(this);
+        _CallInvite_call.set(this, void 0);
+        _CallInvite_provider.set(this, void 0);
+        _CallInvite_state.set(this, 'pending');
+        _CallInvite_accepting.set(this, void 0);
+        this.from = call.from;
+        this.to = call.to;
+        tslib_1.__classPrivateFieldSet(this, _CallInvite_call, call, "f");
+        tslib_1.__classPrivateFieldSet(this, _CallInvite_provider, provider, "f");
+        call.on('disconnected', ({ error }) => {
+            if (tslib_1.__classPrivateFieldGet(this, _CallInvite_state, "f") !== 'pending')
+                return;
+            tslib_1.__classPrivateFieldSet(this, _CallInvite_state, 'cancelled', "f");
+            this.emit('cancelled', error ? { error } : {});
+        });
+    }
+    get state() {
+        return tslib_1.__classPrivateFieldGet(this, _CallInvite_state, "f");
+    }
+    /** Answers the call, asking for microphone permission if it was not granted yet. */
+    async accept() {
+        if (tslib_1.__classPrivateFieldGet(this, _CallInvite_state, "f") === 'accepted')
+            return tslib_1.__classPrivateFieldGet(this, _CallInvite_call, "f");
+        if (tslib_1.__classPrivateFieldGet(this, _CallInvite_state, "f") !== 'pending')
+            throw endedError();
+        tslib_1.__classPrivateFieldSet(this, _CallInvite_accepting, tslib_1.__classPrivateFieldGet(this, _CallInvite_accepting, "f") ?? tslib_1.__classPrivateFieldGet(this, _CallInvite_instances, "m", _CallInvite_accept).call(this).finally(() => (tslib_1.__classPrivateFieldSet(this, _CallInvite_accepting, undefined, "f"))), "f");
+        return tslib_1.__classPrivateFieldGet(this, _CallInvite_accepting, "f");
+    }
+    /** Declines the call; does nothing unless it is still pending. */
+    async reject() {
+        if (tslib_1.__classPrivateFieldGet(this, _CallInvite_state, "f") !== 'pending')
+            return;
+        tslib_1.__classPrivateFieldSet(this, _CallInvite_state, 'rejected', "f");
+        this.emit('rejected');
+        await tslib_1.__classPrivateFieldGet(this, _CallInvite_provider, "f").reject();
+    }
+}
+exports.CallInvite = CallInvite;
+_CallInvite_call = new WeakMap(), _CallInvite_provider = new WeakMap(), _CallInvite_state = new WeakMap(), _CallInvite_accepting = new WeakMap(), _CallInvite_instances = new WeakSet(), _CallInvite_accept = async function _CallInvite_accept() {
+    try {
+        await tslib_1.__classPrivateFieldGet(this, _CallInvite_provider, "f").answer();
+    }
+    catch (error) {
+        if (tslib_1.__classPrivateFieldGet(this, _CallInvite_state, "f") === 'pending')
+            throw error;
+    }
+    if (tslib_1.__classPrivateFieldGet(this, _CallInvite_state, "f") !== 'pending')
+        throw endedError();
+    tslib_1.__classPrivateFieldSet(this, _CallInvite_state, 'accepted', "f");
+    tslib_1.__classPrivateFieldGet(this, _CallInvite_provider, "f").accepted();
+    this.emit('accepted', tslib_1.__classPrivateFieldGet(this, _CallInvite_call, "f"));
+    return tslib_1.__classPrivateFieldGet(this, _CallInvite_call, "f");
+};
+//# sourceMappingURL=invite.js.map

package/invite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invite.js","sourceRoot":"","sources":["src/invite.ts"],"names":[],"mappings":";;;;;AACA,iEAA+F;AAkB/F,MAAM,UAAU,GAAG,GAAG,EAAE,CAAC,IAAI,mCAAe,CAAC,EAAE,OAAO,EAAE,wCAAwC,EAAE,CAAC,CAAC;AAEpG,MAAa,UAAW,SAAQ,gCAA8B;IAQ5D,YAAY,IAAU,EAAE,QAAwB;QAC9C,KAAK,EAAE,CAAC;;QANV,mCAAY;QACZ,uCAA0B;QAC1B,4BAA4D,SAAS,EAAC;QACtE,wCAAsC;QAIpC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QAClB,+BAAA,IAAI,oBAAS,IAAI,MAAA,CAAC;QAClB,+BAAA,IAAI,wBAAa,QAAQ,MAAA,CAAC;QAC1B,IAAI,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;YACpC,IAAI,+BAAA,IAAI,yBAAO,KAAK,SAAS;gBAAE,OAAO;YACtC,+BAAA,IAAI,qBAAU,WAAW,MAAA,CAAC;YAC1B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACjD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,KAAK;QACP,OAAO,+BAAA,IAAI,yBAAO,CAAC;IACrB,CAAC;IAED,oFAAoF;IACpF,KAAK,CAAC,MAAM;QACV,IAAI,+BAAA,IAAI,yBAAO,KAAK,UAAU;YAAE,OAAO,+BAAA,IAAI,wBAAM,CAAC;QAClD,IAAI,+BAAA,IAAI,yBAAO,KAAK,SAAS;YAAE,MAAM,UAAU,EAAE,CAAC;QAClD,gIAAoB,+BAAA,IAAI,iDAAQ,MAAZ,IAAI,CAAU,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,+BAAA,IAAI,yBAAc,SAAS,MAAA,CAAC,CAAC,MAAA,CAAC;QAChF,OAAO,+BAAA,IAAI,6BAAW,CAAC;IACzB,CAAC;IAED,kEAAkE;IAClE,KAAK,CAAC,MAAM;QACV,IAAI,+BAAA,IAAI,yBAAO,KAAK,SAAS;YAAE,OAAO;QACtC,+BAAA,IAAI,qBAAU,UAAU,MAAA,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACtB,MAAM,+BAAA,IAAI,4BAAU,CAAC,MAAM,EAAE,CAAC;IAChC,CAAC;CAcF;AArDD,gCAqDC;8MAZC,KAAK;IACH,IAAI,CAAC;QACH,MAAM,+BAAA,IAAI,4BAAU,CAAC,MAAM,EAAE,CAAC;IAChC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,+BAAA,IAAI,yBAAO,KAAK,SAAS;YAAE,MAAM,KAAK,CAAC;IAC7C,CAAC;IACD,IAAI,+BAAA,IAAI,yBAAO,KAAK,SAAS;QAAE,MAAM,UAAU,EAAE,CAAC;IAClD,+BAAA,IAAI,qBAAU,UAAU,MAAA,CAAC;IACzB,+BAAA,IAAI,4BAAU,CAAC,QAAQ,EAAE,CAAC;IAC1B,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,+BAAA,IAAI,wBAAM,CAAC,CAAC;IAClC,OAAO,+BAAA,IAAI,wBAAM,CAAC;AACpB,CAAC"}

package/invite.mjs

@@ -0,0 +1,60 @@
+var _CallInvite_instances, _CallInvite_call, _CallInvite_provider, _CallInvite_state, _CallInvite_accepting, _CallInvite_accept;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "./internal/tslib.mjs";
+import { CallFailedError, TypedEmitter } from '@sentdm/voice-client-core';
+const endedError = () => new CallFailedError({ message: 'The call ended before it was answered.' });
+export class CallInvite extends TypedEmitter {
+    constructor(call, provider) {
+        super();
+        _CallInvite_instances.add(this);
+        _CallInvite_call.set(this, void 0);
+        _CallInvite_provider.set(this, void 0);
+        _CallInvite_state.set(this, 'pending');
+        _CallInvite_accepting.set(this, void 0);
+        this.from = call.from;
+        this.to = call.to;
+        __classPrivateFieldSet(this, _CallInvite_call, call, "f");
+        __classPrivateFieldSet(this, _CallInvite_provider, provider, "f");
+        call.on('disconnected', ({ error }) => {
+            if (__classPrivateFieldGet(this, _CallInvite_state, "f") !== 'pending')
+                return;
+            __classPrivateFieldSet(this, _CallInvite_state, 'cancelled', "f");
+            this.emit('cancelled', error ? { error } : {});
+        });
+    }
+    get state() {
+        return __classPrivateFieldGet(this, _CallInvite_state, "f");
+    }
+    /** Answers the call, asking for microphone permission if it was not granted yet. */
+    async accept() {
+        if (__classPrivateFieldGet(this, _CallInvite_state, "f") === 'accepted')
+            return __classPrivateFieldGet(this, _CallInvite_call, "f");
+        if (__classPrivateFieldGet(this, _CallInvite_state, "f") !== 'pending')
+            throw endedError();
+        __classPrivateFieldSet(this, _CallInvite_accepting, __classPrivateFieldGet(this, _CallInvite_accepting, "f") ?? __classPrivateFieldGet(this, _CallInvite_instances, "m", _CallInvite_accept).call(this).finally(() => (__classPrivateFieldSet(this, _CallInvite_accepting, undefined, "f"))), "f");
+        return __classPrivateFieldGet(this, _CallInvite_accepting, "f");
+    }
+    /** Declines the call; does nothing unless it is still pending. */
+    async reject() {
+        if (__classPrivateFieldGet(this, _CallInvite_state, "f") !== 'pending')
+            return;
+        __classPrivateFieldSet(this, _CallInvite_state, 'rejected', "f");
+        this.emit('rejected');
+        await __classPrivateFieldGet(this, _CallInvite_provider, "f").reject();
+    }
+}
+_CallInvite_call = new WeakMap(), _CallInvite_provider = new WeakMap(), _CallInvite_state = new WeakMap(), _CallInvite_accepting = new WeakMap(), _CallInvite_instances = new WeakSet(), _CallInvite_accept = async function _CallInvite_accept() {
+    try {
+        await __classPrivateFieldGet(this, _CallInvite_provider, "f").answer();
+    }
+    catch (error) {
+        if (__classPrivateFieldGet(this, _CallInvite_state, "f") === 'pending')
+            throw error;
+    }
+    if (__classPrivateFieldGet(this, _CallInvite_state, "f") !== 'pending')
+        throw endedError();
+    __classPrivateFieldSet(this, _CallInvite_state, 'accepted', "f");
+    __classPrivateFieldGet(this, _CallInvite_provider, "f").accepted();
+    this.emit('accepted', __classPrivateFieldGet(this, _CallInvite_call, "f"));
+    return __classPrivateFieldGet(this, _CallInvite_call, "f");
+};
+//# sourceMappingURL=invite.mjs.map

package/invite.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"invite.mjs","sourceRoot":"","sources":["src/invite.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,eAAe,EAAuB,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAkB/F,MAAM,UAAU,GAAG,GAAG,EAAE,CAAC,IAAI,eAAe,CAAC,EAAE,OAAO,EAAE,wCAAwC,EAAE,CAAC,CAAC;AAEpG,MAAM,OAAO,UAAW,SAAQ,YAA8B;IAQ5D,YAAY,IAAU,EAAE,QAAwB;QAC9C,KAAK,EAAE,CAAC;;QANV,mCAAY;QACZ,uCAA0B;QAC1B,4BAA4D,SAAS,EAAC;QACtE,wCAAsC;QAIpC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QAClB,uBAAA,IAAI,oBAAS,IAAI,MAAA,CAAC;QAClB,uBAAA,IAAI,wBAAa,QAAQ,MAAA,CAAC;QAC1B,IAAI,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;YACpC,IAAI,uBAAA,IAAI,yBAAO,KAAK,SAAS;gBAAE,OAAO;YACtC,uBAAA,IAAI,qBAAU,WAAW,MAAA,CAAC;YAC1B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACjD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,KAAK;QACP,OAAO,uBAAA,IAAI,yBAAO,CAAC;IACrB,CAAC;IAED,oFAAoF;IACpF,KAAK,CAAC,MAAM;QACV,IAAI,uBAAA,IAAI,yBAAO,KAAK,UAAU;YAAE,OAAO,uBAAA,IAAI,wBAAM,CAAC;QAClD,IAAI,uBAAA,IAAI,yBAAO,KAAK,SAAS;YAAE,MAAM,UAAU,EAAE,CAAC;QAClD,gHAAoB,uBAAA,IAAI,iDAAQ,MAAZ,IAAI,CAAU,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,uBAAA,IAAI,yBAAc,SAAS,MAAA,CAAC,CAAC,MAAA,CAAC;QAChF,OAAO,uBAAA,IAAI,6BAAW,CAAC;IACzB,CAAC;IAED,kEAAkE;IAClE,KAAK,CAAC,MAAM;QACV,IAAI,uBAAA,IAAI,yBAAO,KAAK,SAAS;YAAE,OAAO;QACtC,uBAAA,IAAI,qBAAU,UAAU,MAAA,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACtB,MAAM,uBAAA,IAAI,4BAAU,CAAC,MAAM,EAAE,CAAC;IAChC,CAAC;CAcF;8MAZC,KAAK;IACH,IAAI,CAAC;QACH,MAAM,uBAAA,IAAI,4BAAU,CAAC,MAAM,EAAE,CAAC;IAChC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,uBAAA,IAAI,yBAAO,KAAK,SAAS;YAAE,MAAM,KAAK,CAAC;IAC7C,CAAC;IACD,IAAI,uBAAA,IAAI,yBAAO,KAAK,SAAS;QAAE,MAAM,UAAU,EAAE,CAAC;IAClD,uBAAA,IAAI,qBAAU,UAAU,MAAA,CAAC;IACzB,uBAAA,IAAI,4BAAU,CAAC,QAAQ,EAAE,CAAC;IAC1B,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,uBAAA,IAAI,wBAAM,CAAC,CAAC;IAClC,OAAO,uBAAA,IAAI,wBAAM,CAAC;AACpB,CAAC"}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@sentdm/voice-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Sent Voice Client for the web: calls and incoming calls inside your app",
+  "author": "Sent <support@sent.dm>",
+  "types": "./index.d.ts",
+  "main": "./index.js",
+  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sentdm/sent-dm-voice-typescript.git",
+    "directory": "packages/voice-client"
+  },
+  "license": "Apache-2.0",
+  "files": [
+    "**/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@sentdm/voice-client-core": "0.1.1",
+    "sinch-rtc": "2.49.11"
+  },
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "types": "./index.d.mts",
+      "default": "./index.mjs"
+    },
+    "./errors": {
+      "require": {
+        "types": "./errors.d.ts",
+        "default": "./errors.js"
+      },
+      "types": "./errors.d.mts",
+      "default": "./errors.mjs"
+    },
+    "./sw.js": "./sw.js"
+  }
 }

package/src/adapter/loader.ts

@@ -0,0 +1,4 @@
+import { loadSinchAdapter } from './sinch';
+import type { AdapterFactory } from './types';
+
+export const loadAdapter: AdapterFactory = loadSinchAdapter;

package/src/adapter/sinch.ts

@@ -0,0 +1,333 @@
+                           
+import type { Call, CallClient, CallListener, CallQualityWarningEvent, SinchClient } from 'sinch-rtc';
+import type { CallStats } from '../call';
+import {
+  CallFailedError,
+  CapabilityUnsupportedError,
+  MediaPermissionError,
+  NetworkError,
+  NotRegisteredError,
+  SentVoiceError,
+  readClaims,
+} from '@sentdm/voice-client-core';
+import type {
+  AdapterFactory,
+  AdapterOptions,
+  CallEvent,
+  CallTarget,
+  IncomingCall,
+  ProviderAdapter,
+} from './types';
+
+type Sinch = typeof import('sinch-rtc');
+type StatsCall = Call & { getPeerConnectionStats(): Promise<RTCStatsReport | null> };
+
+const environmentHost = 'ocra-euc1.api.sinch.com';
+const applicationPrefix = '//rtc.sinch.com/applications/';
+const answerThrottle = 1_500;
+
+const providerError = (error: unknown): SentVoiceError =>
+  error instanceof SentVoiceError ? error : (
+    new SentVoiceError({
+      code: 'UNKNOWN',
+      category: 'signaling',
+      retriable: false,
+      message: 'An unexpected calling error occurred.',
+      providerDetail: error,
+    })
+  );
+
+// The Sinch backend refuses a call it cannot set up with `Unable to connect call (<reason>)`, an HTTP
+// failure whose only discriminator is that text. The caller gets a stable code and Sent's wording; the
+// provider's reason is kept as provider detail, for telemetry.
+const setupRefusal = /^Unable to connect call(?: \((.+)\))?/;
+const setupRefusalMessages: Record<string, string> = {
+  'destination user not found': 'The destination is not registered.',
+};
+
+const callSetupError = (error: { message: string }): SentVoiceError | undefined => {
+  const match = setupRefusal.exec(error.message);
+  if (!match) return undefined;
+  const reason = match[1];
+  const message = reason === undefined ? undefined : setupRefusalMessages[reason];
+  return new CallFailedError({
+    message: message ?? 'The call could not be connected.',
+    providerDetail: error,
+  });
+};
+
+const rethrow = (error: unknown): never => {
+  throw providerError(error);
+};
+
+const guard = <T>(action: () => T): T => {
+  try {
+    return action();
+  } catch (error) {
+    return rethrow(error);
+  }
+};
+
+export const loadSinchAdapter: AdapterFactory = async (options) =>
+  new SinchAdapter(
+    await import('sinch-rtc').catch((error: unknown) => {
+      throw new NetworkError({ message: 'The calling provider could not be loaded.', providerDetail: error });
+    }),
+    options,
+  );
+
+class SinchAdapter implements ProviderAdapter {
+  #sinch: Sinch;
+  #options: AdapterOptions;
+  #client: SinchClient | undefined;
+  #token = '';
+  #inputDeviceId: string | undefined;
+  #audio: HTMLAudioElement | undefined;
+  #calls = new Map<string, Call>();
+  #answerRetryAt = new Map<string, number>();
+  #incomingListeners: Array<(call: IncomingCall) => void> = [];
+  #callEventListeners: Array<(event: CallEvent) => void> = [];
+
+  constructor(sinch: Sinch, options: AdapterOptions) {
+    this.#sinch = sinch;
+    this.#options = options;
+  }
+
+  async register(token: string): Promise<void> {
+    this.#token = token;
+    this.#client ??= await this.#start(token).catch(rethrow);
+  }
+
+  async unregister(): Promise<void> {
+    const client = this.#client;
+    this.#client = undefined;
+    if (client) await this.#stop(client).catch(rethrow);
+  }
+
+  async call(target: CallTarget): Promise<string> {
+    const { callClient } = this.#started();
+    return this.#placed(
+      target.kind === 'user' ? callClient.callUser(target.id) : callClient.callPhoneNumber(target.number),
+    );
+  }
+
+  async joinConference(room: string): Promise<string> {
+    return this.#placed(this.#started().callClient.callConference(room));
+  }
+
+  async answer(callId: string): Promise<void> {
+    const wait = (this.#answerRetryAt.get(callId) ?? 0) - Date.now();
+    if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
+    const call = this.#calls.get(callId);
+    if (!call) return;
+    this.#answerRetryAt.set(callId, Date.now() + answerThrottle);
+    await call.answer().catch((error: unknown) => {
+      throw new MediaPermissionError({ providerDetail: error });
+    });
+    this.#play(call);
+  }
+
+  async reject(callId: string): Promise<void> {
+    return this.hangup(callId);
+  }
+
+  async hangup(callId: string): Promise<void> {
+    guard(() => this.#calls.get(callId)?.hangup());
+  }
+
+  mute(callId: string, muted: boolean): void {
+    const call = this.#calls.get(callId);
+    if (muted) call?.mute();
+    else call?.unmute();
+  }
+
+  sendDigits(callId: string, digits: string): void {
+    guard(() => this.#calls.get(callId)?.sendDtmf(digits));
+  }
+
+  async getStats(callId: string): Promise<CallStats> {
+    const call = this.#calls.get(callId) as StatsCall | undefined;
+    const report = await call?.getPeerConnectionStats();
+    const stats = { jitter: 0, packetLoss: 0, rtt: 0 };
+    report?.forEach((entry) => {
+      if (entry.type === 'inbound-rtp' && entry.kind === 'audio') {
+        const lost = Math.max(0, entry.packetsLost ?? 0);
+        const packets = lost + (entry.packetsReceived ?? 0);
+        stats.jitter = (entry.jitter ?? 0) * 1000;
+        stats.packetLoss = packets > 0 ? lost / packets : 0;
+      } else if (entry.type === 'candidate-pair' && entry.state === 'succeeded') {
+        stats.rtt = (entry.currentRoundTripTime ?? 0) * 1000;
+      }
+    });
+    return stats;
+  }
+
+  onIncoming(listener: (call: IncomingCall) => void): void {
+    this.#incomingListeners.push(listener);
+  }
+
+  onCallEvent(listener: (event: CallEvent) => void): void {
+    this.#callEventListeners.push(listener);
+  }
+
+  async setInputDevice(deviceId: string): Promise<void> {
+    this.#inputDeviceId = deviceId;
+    if (this.#client?.isStarted()) this.#useInput(this.#client.callClient, deviceId);
+  }
+
+  async setOutputDevice(deviceId: string): Promise<void> {
+    const audio = this.#playback();
+    if (!('setSinkId' in audio)) {
+      throw new CapabilityUnsupportedError({
+        message: 'Choosing the audio output device is not supported by this browser.',
+      });
+    }
+    await audio.setSinkId(deviceId).catch(rethrow);
+  }
+
+  async #start(token: string): Promise<SinchClient> {
+    const { iss, sub } = readClaims(token) as Record<'iss' | 'sub', string>;
+    const client = this.#sinch.Sinch.getSinchClientBuilder()
+      .applicationKey(iss.slice(applicationPrefix.length))
+      .userId(sub.slice(`${iss}/users/`.length))
+      .environmentHost(environmentHost)
+      .build();
+    const { url, scope } = this.#options.serviceWorker ?? {};
+
+    try {
+      await new Promise<void>((resolve, reject) => {
+        client.addListener({
+          onCredentialsRequired: (_, registration) => void registration.register(this.#token),
+          onClientStarted: ({ callClient }) => {
+            callClient.addListener({ onIncomingCall: (_, call) => this.#receive(call) });
+            if (this.#inputDeviceId !== undefined) this.#useInput(callClient, this.#inputDeviceId);
+            resolve();
+          },
+          onClientFailed: (_, error) => reject(error),
+        });
+        client
+          .setSupportManagedPush(url, scope === undefined ? undefined : { scope })
+          .then(() => client.start(), reject);
+      });
+    } catch (error) {
+      await this.#stop(client).catch(() => {});
+      throw error;
+    }
+    return client;
+  }
+
+  async #stop(client: SinchClient): Promise<void> {
+    try {
+      await client.disableManagedPushSupport();
+    } finally {
+      client.terminate();
+    }
+  }
+
+  #started(): SinchClient {
+    if (!this.#client) throw new NotRegisteredError();
+    return this.#client;
+  }
+
+  #useInput(callClient: CallClient, deviceId: string): void {
+    callClient.setAudioTrackConstraints({ deviceId });
+  }
+
+  #playback(): HTMLAudioElement {
+    return (this.#audio ??= this.#options.audioElement ?? new Audio());
+  }
+
+  async #placed(placing: Promise<Call>): Promise<string> {
+    const call = await placing.catch(rethrow);
+    if (!call.outgoingStream?.getAudioTracks().length) {
+      guard(() => call.hangup());
+      throw new MediaPermissionError();
+    }
+    this.#play(call);
+    return this.#track(call);
+  }
+
+  #play(call: Call): void {
+    const audio = this.#playback();
+    audio.autoplay = true;
+    audio.srcObject = call.incomingStream ?? null;
+  }
+
+  #receive(call: Call): void {
+    this.#track(call);
+    for (const listener of this.#incomingListeners) listener({ callId: call.id, from: call.remoteUserId });
+  }
+
+  #track(call: Call): string {
+    const listener: CallListener = {
+      onCallProgressing: () => this.#emit({ callId: call.id, type: 'ringing' }),
+      onCallAnswered: () => this.#emit({ callId: call.id, type: 'answered' }),
+      onCallEstablished: () => this.#emit({ callId: call.id, type: 'connected' }),
+      onCallQualityWarningEvent: (_, warning) => {
+        const event = this.#warning(call.id, warning);
+        if (event) this.#emit(event);
+      },
+      onCallEnded: () => {
+        call.removeListener(listener);
+        this.#calls.delete(call.id);
+        this.#answerRetryAt.delete(call.id);
+        if (this.#audio && this.#audio.srcObject === call.incomingStream) this.#audio.srcObject = null;
+        this.#emit(this.#ended(call));
+      },
+    };
+    call.addListener(listener);
+    this.#calls.set(call.id, call);
+    return call.id;
+  }
+
+  #ended({ id: callId, details: { endCause, error } }: Call): CallEvent {
+    const { CallEndCause, ErrorType } = this.#sinch;
+    switch (endCause) {
+      case CallEndCause.Denied:
+        return { callId, type: 'ended', reason: 'busy' };
+      case CallEndCause.NoAnswer:
+      case CallEndCause.Timeout:
+        return { callId, type: 'ended', reason: 'noAnswer' };
+      case CallEndCause.Inactive:
+        return {
+          callId,
+          type: 'ended',
+          reason: 'failed',
+          error: new NetworkError({ providerDetail: error }),
+        };
+      case CallEndCause.Failure:
+        if (!error) return { callId, type: 'ended', reason: 'failed' };
+        return {
+          callId,
+          type: 'ended',
+          reason: 'failed',
+          error:
+            error.domain === ErrorType.Network ?
+              new NetworkError({ providerDetail: error })
+            : (callSetupError(error) ?? providerError(error)),
+        };
+      default:
+        return { callId, type: 'ended', reason: 'completed' };
+    }
+  }
+
+  #warning(callId: string, { name, type }: CallQualityWarningEvent): CallEvent | undefined {
+    const cleared = type === this.#sinch.CallQualityWarningEventType.Recover;
+    switch (name) {
+      case 'missingMediaStream':
+        return { callId, type: cleared ? 'reconnected' : 'reconnecting' };
+      case 'highInboundJitter':
+        return { callId, type: 'qualityWarning', warning: { metric: 'jitter', cleared } };
+      case 'highInboundPacketLoss':
+        return { callId, type: 'qualityWarning', warning: { metric: 'packetLoss', cleared } };
+      case 'highRemoteInboundRtt':
+        return { callId, type: 'qualityWarning', warning: { metric: 'rtt', cleared } };
+      default:
+        return undefined;
+    }
+  }
+
+  #emit(event: CallEvent): void {
+    for (const listener of this.#callEventListeners) listener(event);
+  }
+}

package/src/adapter/types.ts

@@ -0,0 +1,63 @@
+                           
+import type { CallStats, QualityWarning } from '../call';
+import { type SentVoiceError } from '@sentdm/voice-client-core';
+
+/**
+ * The seam between the SDK core and a calling provider. It covers only what the public surface
+ * needs and must never be reachable from a public entry point.
+ *
+ * - Ids are wire ids: the core adds and strips the tenant prefix, so user ids, room names and
+ *   incoming `from` values are already namespaced.
+ * - `register` while registered hands the provider a fresh token.
+ * - Every failure is a `SentVoiceError`. A provider error without a mapping becomes one with code
+ *   `UNKNOWN`, category `signaling` and the raw error kept as provider detail, which only telemetry reads.
+ * - Calls are identified by the provider call id. Their events start once the id is known from
+ *   `call`, `joinConference` or `onIncoming`, and `ended` is the last event of every call,
+ *   including one ended by `reject` or `hangup`.
+ * - `reject` declines an incoming call that has not been answered.
+ * - Stats report jitter and rtt in milliseconds and packetLoss as a fraction between 0 and 1.
+ */
+export interface ProviderAdapter {
+  register(token: string): Promise<void>;
+  unregister(): Promise<void>;
+  call(target: CallTarget): Promise<string>;
+  joinConference(room: string): Promise<string>;
+  answer(callId: string): Promise<void>;
+  reject(callId: string): Promise<void>;
+  hangup(callId: string): Promise<void>;
+  mute(callId: string, muted: boolean): void;
+  sendDigits(callId: string, digits: string): void;
+  getStats(callId: string): Promise<CallStats>;
+  onIncoming(listener: (call: IncomingCall) => void): void;
+  onCallEvent(listener: (event: CallEvent) => void): void;
+  setInputDevice(deviceId: string): Promise<void>;
+  setOutputDevice(deviceId: string): Promise<void>;
+}
+
+export type AdapterFactory = (options: AdapterOptions) => Promise<ProviderAdapter>;
+
+export interface AdapterOptions {
+  serviceWorker?: { url?: string | undefined; scope?: string | undefined } | undefined;
+  audioElement?: HTMLAudioElement | undefined;
+}
+
+export type CallTarget = { kind: 'user'; id: string } | { kind: 'number'; number: string };
+
+export interface IncomingCall {
+  callId: string;
+  from: string;
+}
+
+export type CallEvent =
+  | { callId: string; type: 'ringing' }
+  | { callId: string; type: 'answered' }
+  | { callId: string; type: 'connected' }
+  | { callId: string; type: 'reconnecting' }
+  | { callId: string; type: 'reconnected' }
+  | { callId: string; type: 'qualityWarning'; warning: QualityWarning }
+  | {
+      callId: string;
+      type: 'ended';
+      reason: 'completed' | 'failed' | 'busy' | 'noAnswer';
+      error?: SentVoiceError;
+    };