farvex 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,3 +1,4 @@
+import { parsePhoneNumberFromString } from 'libphonenumber-js';
 import { Centrifuge, UnauthorizedError } from 'centrifuge';
 
 // src/api/generated/core/bodySerializer.gen.ts
@@ -802,7 +803,7 @@ var apiClient = (config) => {
 var unwrap = async (result, auth) => {
   const response = await result;
   if (response.error !== void 0) {
-    if (response.response?.status === 401) {
+    if (response.response?.status === 401 || response.response?.status === 403) {
       await auth?.onUnauthorized?.();
     }
     throw errorFrom(response.error, response.response?.status);
@@ -941,9 +942,23 @@ var createEmitter = () => {
     emit
   };
 };
-var createRealtime = (client2, auth, store, emitter) => {
+var normalizeE164Phone = (phone, defaultCountry = "NG") => {
+  const trimmed = phone.trim();
+  const parsed = parsePhoneNumberFromString(trimmed);
+  if (parsed?.isValid() && parsed.country) {
+    return parsed.number;
+  }
+  const fallback = parsePhoneNumberFromString(trimmed, defaultCountry);
+  if (fallback?.isValid()) {
+    return fallback.number;
+  }
+  throw new Error("Enter a valid phone number");
+};
+var createRealtime = (client2, auth, store, emitter, recover) => {
   let rt = null;
+  let connectPromise = null;
   let disposed = false;
+  let attempt = 0;
   const fetchToken = async () => unwrap(getRealtimeToken({ client: client2 }), auth);
   const refreshToken = async () => {
     try {
@@ -980,6 +995,8 @@ var createRealtime = (client2, auth, store, emitter) => {
     emitter.emit("status", status);
   };
   const disconnect = async () => {
+    attempt += 1;
+    connectPromise = null;
     rt?.disconnect();
     rt = null;
     if (!disposed) {
@@ -988,33 +1005,50 @@ var createRealtime = (client2, auth, store, emitter) => {
   };
   return {
     connect: async () => {
+      if (connectPromise) {
+        return connectPromise;
+      }
       if (rt) {
         return;
       }
       disposed = false;
-      setStatus("connecting");
-      try {
+      const currentAttempt = ++attempt;
+      const promise = (async () => {
+        setStatus("connecting");
         const first = await fetchToken();
-        rt = new Centrifuge(first.url, {
+        if (disposed || currentAttempt !== attempt) {
+          return;
+        }
+        const next = new Centrifuge(first.url, {
           token: first.token,
           getToken: refreshToken
         });
-        rt.on("connecting", () => {
-          const next = store.getStatus() === "ready" ? "reconnecting" : "connecting";
-          setStatus(next);
+        rt = next;
+        next.on("connecting", () => {
+          const status = store.getStatus() === "ready" ? "reconnecting" : "connecting";
+          setStatus(status);
         });
-        rt.on("connected", () => {
+        next.on("connected", () => {
+          const shouldRecover = store.getStatus() === "reconnecting" || store.getStatus() === "offline";
           setStatus("ready");
+          if (shouldRecover && recover) {
+            void recover().catch((err) => {
+              emitter.emit(
+                "error",
+                err instanceof Error ? err : new Error("Realtime recovery failed")
+              );
+            });
+          }
         });
-        rt.on("disconnected", () => {
+        next.on("disconnected", () => {
           if (!disposed) {
             setStatus("offline");
           }
         });
-        rt.on("error", (ctx) => {
+        next.on("error", (ctx) => {
           emitter.emit("error", new Error(ctx.error.message));
         });
-        rt.on("publication", (ctx) => {
+        next.on("publication", (ctx) => {
           try {
             const message = parseMessage(ctx.data);
             if (message) {
@@ -1024,16 +1058,34 @@ var createRealtime = (client2, auth, store, emitter) => {
             emitter.emit("error", err instanceof Error ? err : new Error("Realtime event failed"));
           }
         });
-        rt.connect();
-        await rt.ready();
+        next.connect();
+        await next.ready();
+        if (disposed || currentAttempt !== attempt) {
+          next.disconnect();
+          if (rt === next) {
+            rt = null;
+          }
+        }
+      })();
+      connectPromise = promise;
+      try {
+        await promise;
       } catch (err) {
-        await disconnect();
+        if (currentAttempt === attempt) {
+          await disconnect();
+        }
         throw err;
+      } finally {
+        if (connectPromise === promise) {
+          connectPromise = null;
+        }
       }
     },
     disconnect,
     dispose: async () => {
       disposed = true;
+      attempt += 1;
+      connectPromise = null;
       rt?.disconnect();
       rt = null;
       setStatus("disposed");
@@ -1045,24 +1097,453 @@ var parseMessage = (value) => {
     return null;
   }
   const message = value;
-  if (message.event === "session.upsert" && message.data) {
-    return message;
+  if (message.event === "session.upsert" && isVoiceSession(message.data)) {
+    return { event: "session.upsert", data: message.data };
   }
-  if (message.event === "session.remove" && message.data) {
-    return message;
+  if (message.event === "session.remove" && isRemovePayload(message.data)) {
+    return { event: "session.remove", data: message.data };
   }
   return null;
 };
+var isVoiceSession = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const session = value;
+  return typeof session.id === "string" && typeof session.vendor === "string" && typeof session.version === "number" && (session.state === "ringing" || session.state === "active" || session.state === "ended") && Array.isArray(session.participants);
+};
+var isRemovePayload = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const payload = value;
+  return typeof payload.id === "string" && (payload.vendor === void 0 || typeof payload.vendor === "string") && (payload.version === void 0 || typeof payload.version === "number");
+};
+
+// src/core/session.ts
+var createCurrentSessionController = (deps) => {
+  const subscribers = /* @__PURE__ */ new Set();
+  const cleanup = [];
+  let current = null;
+  let pending = null;
+  let op = 0;
+  let mediaConnected = false;
+  let snapshot = {
+    current,
+    incoming: deps.store.invites(),
+    busy: false
+  };
+  const publish = () => {
+    const next = {
+      current,
+      incoming: deps.store.invites(),
+      busy: pending !== null || isBusy(current)
+    };
+    if (snapshot.current === next.current && snapshot.incoming === next.incoming && snapshot.busy === next.busy) {
+      return;
+    }
+    snapshot = next;
+    for (const fn of subscribers) {
+      fn();
+    }
+    deps.emitter.emit("session.current.changed", snapshot);
+  };
+  const commit = (next) => {
+    const prev = current;
+    current = next;
+    publish();
+    if (!next) {
+      return;
+    }
+    if (!prev || prev.sessionId !== next.sessionId) {
+      deps.emitter.emit("session.current.started", next);
+    }
+    if (prev?.phase !== "active" && next.phase === "active") {
+      deps.emitter.emit("session.current.connected", next);
+    }
+    if (prev?.phase !== "ended" && next.phase === "ended") {
+      deps.emitter.emit("session.current.ended", next);
+    }
+    if (prev?.phase !== "failed" && next.phase === "failed" && next.error) {
+      deps.emitter.emit("session.current.failed", { session: next, error: next.error });
+    }
+  };
+  const commitFailed = (session, err) => {
+    const error = toCallpadError(err);
+    if (session) {
+      commit(
+        fromSession(session, {
+          phase: "failed",
+          join: null,
+          participantId: null,
+          startedBy: current?.startedBy ?? "join",
+          error
+        })
+      );
+    } else {
+      deps.emitter.emit("session.current.failed", { session: current, error });
+      publish();
+    }
+    return error;
+  };
+  const nextOp = () => {
+    op += 1;
+    return op;
+  };
+  const run = (kind, task) => {
+    if (pending) {
+      if (kind === "end" && pending.kind === "end") {
+        return pending.promise;
+      }
+      return Promise.reject(busyError());
+    }
+    const id = nextOp();
+    const promise = task(id).finally(() => {
+      if (pending?.op === id) {
+        pending = null;
+        publish();
+      }
+    });
+    pending = { kind, op: id, promise };
+    publish();
+    return promise;
+  };
+  const assertFresh = (id) => {
+    if (id !== op) {
+      throw new CallpadError("session.command_stale", "Session command was superseded");
+    }
+  };
+  const canReplaceCurrent = (replaceCurrent) => {
+    return replaceCurrent === true || !isBusy(current);
+  };
+  const reconcile = () => {
+    if (!current) {
+      publish();
+      return;
+    }
+    const session = deps.store.get(current.sessionId);
+    if (!session) {
+      mediaConnected = false;
+      commit({
+        ...current,
+        phase: "ended",
+        session: null,
+        join: null,
+        endedAt: current.endedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return;
+    }
+    const next = reconcileCurrent(current, session, mediaConnected);
+    if (next !== current) {
+      if (isTerminal(next.phase)) {
+        mediaConnected = false;
+      }
+      commit(next);
+      return;
+    }
+    publish();
+  };
+  cleanup.push(deps.store.subscribe("sessions", reconcile));
+  cleanup.push(deps.store.subscribe("invites", publish));
+  const start = (input, options = {}) => {
+    const behavior = options.behavior ?? "rejectWhileBusy";
+    if (behavior !== "allowParallel" && isBusy(current)) {
+      if (behavior === "focusExisting") {
+        const existing = findTargetSession(deps.store.list(), input.target);
+        if (existing) {
+          return join(existing.id, { replaceCurrent: true });
+        }
+      }
+      return Promise.reject(busyError());
+    }
+    return run("start", async (id) => {
+      try {
+        const started = await deps.start(input);
+        assertFresh(id);
+        const next = fromStarted(started, "start", options.media);
+        mediaConnected = false;
+        commit(next);
+        if (next.phase === "failed" && next.error) {
+          throw next.error;
+        }
+        return next;
+      } catch (err) {
+        if (shouldRethrowCommandError(err)) {
+          throw err;
+        }
+        throw commitFailed(null, err);
+      }
+    });
+  };
+  const accept = (input, options = {}) => {
+    if (!canReplaceCurrent(options.replaceCurrent)) {
+      return Promise.reject(busyError());
+    }
+    return run("accept", async (id) => {
+      try {
+        const started = await deps.accept(input);
+        assertFresh(id);
+        const next = fromStarted(started, "accept", options.media);
+        mediaConnected = false;
+        commit(next);
+        if (next.phase === "failed" && next.error) {
+          throw next.error;
+        }
+        return next;
+      } catch (err) {
+        if (shouldRethrowCommandError(err)) {
+          throw err;
+        }
+        throw commitFailed(deps.store.get(input.sessionId), err);
+      }
+    });
+  };
+  const join = (sessionId, options = {}) => {
+    if (!canReplaceCurrent(options.replaceCurrent)) {
+      return Promise.reject(busyError());
+    }
+    const session = deps.store.get(sessionId);
+    if (!session) {
+      return Promise.reject(new CallpadError("session.not_found", "Session was not found"));
+    }
+    return run("join", async (id) => {
+      try {
+        const grant = await deps.join(sessionId);
+        assertFresh(id);
+        const latest = deps.store.get(sessionId) ?? session;
+        const next = fromSession(latest, {
+          phase: latest.state === "active" ? "active" : "connecting",
+          join: grant,
+          participantId: grant.participantId,
+          startedBy: "join",
+          error: null
+        });
+        mediaConnected = next.phase === "active";
+        commit(next);
+        return next;
+      } catch (err) {
+        if (shouldRethrowCommandError(err)) {
+          throw err;
+        }
+        throw commitFailed(session, err);
+      }
+    });
+  };
+  const end = async () => {
+    const target = current;
+    if (!target || isTerminal(target.phase)) {
+      return;
+    }
+    await run("end", async (id) => {
+      const session = deps.store.get(target.sessionId);
+      commit({ ...target, phase: "ending" });
+      try {
+        if (session && deps.end && deps.store.can(session, "end")) {
+          await deps.end(target.sessionId);
+        } else {
+          await deps.leave(target.sessionId);
+        }
+        assertFresh(id);
+        mediaConnected = false;
+        const ended = deps.store.get(target.sessionId);
+        commit({
+          ...target,
+          phase: "ended",
+          session: ended,
+          join: null,
+          endedAt: ended?.endedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch (err) {
+        if (shouldRethrowCommandError(err)) {
+          throw err;
+        }
+        throw commitFailed(session, err);
+      }
+    });
+  };
+  const clear = () => {
+    nextOp();
+    pending = null;
+    mediaConnected = false;
+    commit(null);
+  };
+  const mediaConnectedFor = (sessionId) => {
+    if (!current || sessionId && current.sessionId !== sessionId || isTerminal(current.phase)) {
+      return;
+    }
+    mediaConnected = true;
+    const session = deps.store.get(current.sessionId);
+    commit({
+      ...current,
+      phase: "active",
+      session,
+      answeredAt: session?.answeredAt ?? current.answeredAt
+    });
+  };
+  const mediaDisconnectedFor = (sessionId) => {
+    if (!current || sessionId && current.sessionId !== sessionId || isTerminal(current.phase)) {
+      return;
+    }
+    mediaConnected = false;
+    const session = deps.store.get(current.sessionId);
+    if (session?.state === "ended") {
+      reconcile();
+      return;
+    }
+    commit({
+      ...current,
+      phase: current.join ? "connecting" : current.direction === "inbound" ? "incoming" : "outgoing",
+      session
+    });
+  };
+  const mediaFailedFor = (error, sessionId) => {
+    if (!current || sessionId && current.sessionId !== sessionId || isTerminal(current.phase)) {
+      return;
+    }
+    mediaConnected = false;
+    commit({
+      ...current,
+      phase: "failed",
+      join: null,
+      error: toCallpadError(error, "session.media_failed")
+    });
+  };
+  return {
+    get: () => snapshot,
+    start,
+    accept,
+    join,
+    end,
+    clear,
+    mediaConnected: mediaConnectedFor,
+    mediaDisconnected: mediaDisconnectedFor,
+    mediaFailed: mediaFailedFor,
+    subscribe: (fn) => {
+      subscribers.add(fn);
+      return () => {
+        subscribers.delete(fn);
+      };
+    },
+    dispose: () => {
+      for (const unsubscribe of cleanup) {
+        unsubscribe();
+      }
+      subscribers.clear();
+    }
+  };
+};
+var fromStarted = (started, startedBy, media = "required") => {
+  if (!started.join && media === "required") {
+    return fromSession(started.session, {
+      phase: "failed",
+      join: null,
+      participantId: null,
+      startedBy,
+      error: new CallpadError(
+        "session.join_unavailable",
+        "Session did not include a browser media join grant"
+      )
+    });
+  }
+  const phase = started.join ? started.session.state === "active" ? "active" : "connecting" : started.session.direction === "inbound" ? "incoming" : "outgoing";
+  return fromSession(started.session, {
+    phase,
+    join: started.join,
+    participantId: started.join?.participantId ?? null,
+    startedBy,
+    error: null
+  });
+};
+var fromSession = (session, values) => ({
+  phase: values.phase,
+  direction: session.direction,
+  sessionId: session.id,
+  participantId: values.participantId,
+  session,
+  join: values.join,
+  startedBy: values.startedBy,
+  error: values.error,
+  createdAt: session.createdAt,
+  answeredAt: session.answeredAt,
+  endedAt: session.endedAt
+});
+var reconcileCurrent = (current, session, mediaConnected) => {
+  if (session.state === "ended") {
+    return {
+      ...current,
+      phase: "ended",
+      session,
+      join: null,
+      answeredAt: session.answeredAt,
+      endedAt: session.endedAt ?? current.endedAt
+    };
+  }
+  if (isTerminal(current.phase)) {
+    return {
+      ...current,
+      session,
+      answeredAt: session.answeredAt,
+      endedAt: session.endedAt
+    };
+  }
+  const phase = mediaConnected || session.state === "active" ? "active" : current.join ? "connecting" : current.phase === "ending" ? "ending" : session.direction === "inbound" ? "incoming" : "outgoing";
+  if (current.phase === phase && current.session === session && current.answeredAt === session.answeredAt && current.endedAt === session.endedAt) {
+    return current;
+  }
+  return {
+    ...current,
+    phase,
+    session,
+    answeredAt: session.answeredAt,
+    endedAt: session.endedAt
+  };
+};
+var findTargetSession = (sessions, target) => {
+  const normalized = normalizeTarget(target);
+  return sessions.find(
+    (session) => session.state !== "ended" && session.participants.some((participant) => {
+      if (normalized.type === "vendor_user") {
+        return participant.kind === "vendor_user" && participant.userId === normalized.userId;
+      }
+      if (normalized.type === "customer") {
+        return participant.kind === "customer" && participant.userId === normalized.userId;
+      }
+      if (normalized.type === "contact") {
+        return participant.contactId === normalized.contactId;
+      }
+      return participant.phone === normalized.phone;
+    })
+  ) ?? null;
+};
+var normalizeTarget = (target) => {
+  if (target.type === "phone") {
+    return { ...target, phone: normalizeE164Phone(target.phone) };
+  }
+  return target;
+};
+var isBusy = (session) => session !== null && !isTerminal(session.phase);
+var isTerminal = (phase) => phase === "ended" || phase === "failed";
+var busyError = () => new CallpadError("session.busy", "A session is already active");
+var shouldRethrowCommandError = (err) => err instanceof CallpadError && (err.code === "session.join_unavailable" || err.code === "session.command_stale");
+var toCallpadError = (err, code = "session.failed") => {
+  if (err instanceof CallpadError) {
+    return err;
+  }
+  if (err instanceof Error) {
+    return new CallpadError(code, err.message);
+  }
+  return new CallpadError(code, "Session command failed");
+};
 
 // src/core/store.ts
 var createSessionStore = (userId) => {
   const sessions = /* @__PURE__ */ new Map();
   const subscribers = /* @__PURE__ */ new Map();
   let status = "idle";
-  let activeId = null;
   let listCache = [];
   let invitesCache = [];
   let inviteKey = "";
+  let inviteExpiryTimer = null;
   const emit = (topic) => {
     const fns = subscribers.get(topic);
     if (!fns) {
@@ -1090,18 +1571,11 @@ var createSessionStore = (userId) => {
     listCache = Array.from(sessions.values()).sort(
       (a, b) => b.createdAt.localeCompare(a.createdAt)
     );
-    if (activeId) {
-      const active = sessions.get(activeId);
-      if (!active || active.state === "ended") {
-        activeId = null;
-      }
-    }
-    if (!activeId) {
-      activeId = listCache.find((session) => session.state !== "ended")?.id ?? null;
-    }
   };
   const refreshInvites = () => {
-    const invites = listCache.map((session) => inviteFrom(session, userId)).filter((invite) => invite !== null);
+    const now = Date.now();
+    const invites = listCache.map((session) => inviteFrom(session, userId, now)).filter((invite) => invite !== null);
+    scheduleInviteExpiry(invites, now);
     const nextKey = invites.map(
       (invite) => `${invite.session.id}:${invite.participant.id}:${invite.participant.state}:${invite.participant.inviteExpiresAt ?? ""}`
     ).join("|");
@@ -1113,6 +1587,35 @@ var createSessionStore = (userId) => {
     invitesCache = invites;
     return true;
   };
+  const clearInviteExpiryTimer = () => {
+    if (inviteExpiryTimer) {
+      globalThis.clearTimeout(inviteExpiryTimer);
+      inviteExpiryTimer = null;
+    }
+  };
+  const scheduleInviteExpiry = (invites, now) => {
+    clearInviteExpiryTimer();
+    const nextExpiry = invites.reduce((min, invite) => {
+      const expiresAt = inviteExpiryMs(invite.participant);
+      if (expiresAt === null) {
+        return min;
+      }
+      return min === null ? expiresAt : Math.min(min, expiresAt);
+    }, null);
+    if (nextExpiry === null) {
+      return;
+    }
+    inviteExpiryTimer = globalThis.setTimeout(
+      () => {
+        inviteExpiryTimer = null;
+        if (refreshInvites()) {
+          emit("invites");
+          emit("sessions");
+        }
+      },
+      Math.max(0, nextExpiry - now)
+    );
+  };
   const notifySessionChange = (sessionId) => {
     refresh();
     const invitesChanged = refreshInvites();
@@ -1122,15 +1625,7 @@ var createSessionStore = (userId) => {
       emit("invites");
     }
   };
-  const get = (sessionId) => {
-    if (sessionId) {
-      return sessions.get(sessionId) ?? null;
-    }
-    if (!activeId) {
-      return null;
-    }
-    return sessions.get(activeId) ?? null;
-  };
+  const get = (sessionId) => sessions.get(sessionId) ?? null;
   const upsert = (session, mode = "event") => {
     const prev = sessions.get(session.id);
     const stale = prev ? mode === "command" ? session.version < prev.version : session.version <= prev.version : false;
@@ -1154,18 +1649,33 @@ var createSessionStore = (userId) => {
     get,
     invites: () => invitesCache,
     invite: (sessionId) => invitesCache.find((invite) => invite.session.id === sessionId) ?? null,
-    sync: (items) => {
+    sync: (items, options) => {
+      const changedIds = /* @__PURE__ */ new Set();
       for (const session of items) {
         const prev = sessions.get(session.id);
         if (!prev || session.version >= prev.version) {
           sessions.set(session.id, session);
+          changedIds.add(session.id);
+        }
+      }
+      const removedIds = [];
+      if (options?.mode === "replaceVisible" && options.shouldReplace) {
+        const visibleIds = new Set(items.map((session) => session.id));
+        for (const session of sessions.values()) {
+          if (!visibleIds.has(session.id) && options.shouldReplace(session)) {
+            sessions.delete(session.id);
+            removedIds.push(session.id);
+          }
         }
       }
       refresh();
       const invitesChanged = refreshInvites();
       emit("sessions");
-      for (const session of items) {
-        emit(`session:${session.id}`);
+      for (const sessionId of changedIds) {
+        emit(`session:${sessionId}`);
+      }
+      for (const sessionId of removedIds) {
+        emit(`session:${sessionId}`);
       }
       if (invitesChanged) {
         emit("invites");
@@ -1199,13 +1709,17 @@ var createSessionStore = (userId) => {
       return next;
     },
     can: (session, action) => can(session, userId, action),
+    dispose: () => {
+      clearInviteExpiryTimer();
+      subscribers.clear();
+    },
     subscribe
   };
 };
 var selfParticipant = (session, userId) => session.participants.find((participant) => participant.userId === userId) ?? null;
-var inviteFrom = (session, userId) => {
+var inviteFrom = (session, userId, now) => {
   const participant = selfParticipant(session, userId);
-  if (!participant || participant.state !== "invited") {
+  if (!participant || session.state === "ended" || !isActiveInvite(participant, now)) {
     return null;
   }
   return { session, participant };
@@ -1218,7 +1732,7 @@ var can = (session, userId, action) => {
   switch (action) {
     case "accept":
     case "reject":
-      return self.state === "invited";
+      return isActiveInvite(self);
     case "join":
       return self.transport === "webrtc" && (self.state === "accepted" || self.state === "joined");
     case "leave":
@@ -1233,60 +1747,113 @@ var can = (session, userId, action) => {
       return isHost(self) && session.recording.status === "recording";
   }
 };
+var isActiveInvite = (participant, now = Date.now()) => {
+  const expiresAt = inviteExpiryMs(participant);
+  return participant.state === "invited" && expiresAt !== null && expiresAt > now;
+};
+var inviteExpiryMs = (participant) => {
+  if (!participant.inviteExpiresAt) {
+    return null;
+  }
+  const expiresAt = Date.parse(participant.inviteExpiresAt);
+  return Number.isFinite(expiresAt) ? expiresAt : null;
+};
 var isHost = (participant) => participant.role === "host" && (participant.kind === "agent" || participant.kind === "vendor_user");
 
 // src/core/client.ts
 var createSessionClient = (config) => {
   const core = createCore(config);
+  const sessions = {
+    ...createCommonSessions(core),
+    start: (input) => startSession(core, input.vendor, input.target)
+  };
+  const session = createCurrentSessionController({
+    store: core.store,
+    emitter: core.emitter,
+    start: sessions.start,
+    accept: sessions.accept,
+    join: sessions.join,
+    leave: sessions.leave
+  });
   return {
     kind: "session",
     get status() {
       return core.store.getStatus();
     },
-    sessions: {
-      ...createCommonSessions(core),
-      start: (input) => startSession(core, input.vendor, input.target)
-    },
+    sessions,
     invites: {
       list: core.store.invites,
       get: core.store.invite
     },
+    session,
     connect: core.connect,
     disconnect: core.realtime.disconnect,
-    dispose: core.realtime.dispose,
+    dispose: async () => {
+      session.dispose();
+      await core.dispose();
+    },
     on: core.emitter.on,
     subscribe: core.store.subscribe
   };
 };
 var createHostClient = (config) => {
   const core = createCore(config);
+  const sessions = {
+    ...createCommonSessions(core),
+    start: (input) => startSession(core, config.vendor, input.target)
+  };
+  const host = createHostControls(core);
+  const session = createCurrentSessionController({
+    store: core.store,
+    emitter: core.emitter,
+    start: sessions.start,
+    accept: sessions.accept,
+    join: sessions.join,
+    leave: sessions.leave,
+    end: host.end
+  });
   return {
     kind: "host",
     vendor: config.vendor,
     get status() {
       return core.store.getStatus();
     },
-    sessions: {
-      ...createCommonSessions(core),
-      start: (input) => startSession(core, config.vendor, input.target)
-    },
+    sessions,
     invites: {
       list: core.store.invites,
       get: core.store.invite
     },
-    host: createHostControls(core),
+    session,
+    host,
     connect: core.connect,
     disconnect: core.realtime.disconnect,
-    dispose: core.realtime.dispose,
+    dispose: async () => {
+      session.dispose();
+      await core.dispose();
+    },
     on: core.emitter.on,
     subscribe: core.store.subscribe
   };
 };
+var normalizePhoneTarget = (target) => {
+  if (target.type === "phone") {
+    return { ...target, phone: normalizeE164Phone(target.phone) };
+  }
+  return target;
+};
 var createCore = (config) => {
   const api = apiClient(config);
   const store = createSessionStore(config.userId);
   const emitter = createEmitter();
-  const realtime = createRealtime(api, config.auth, store, emitter);
+  const syncActive = async () => {
+    const query = { state: "active" };
+    const response = await unwrap(listSessions({ client: api, query }), config.auth);
+    store.sync(response.items, {
+      mode: "replaceVisible",
+      shouldReplace: (session) => matchesVisibleQuery(session, query)
+    });
+  };
+  const realtime = createRealtime(api, config.auth, store, emitter, syncActive);
   const applySession = (session, mode = "event") => {
     const change = store.upsert(session, mode);
     if (change === "added") {
@@ -1316,6 +1883,10 @@ var createCore = (config) => {
       throw err;
     }
   };
+  const dispose = async () => {
+    await realtime.dispose();
+    store.dispose();
+  };
   return {
     api,
     auth: config.auth,
@@ -1323,6 +1894,7 @@ var createCore = (config) => {
     emitter,
     realtime,
     connect,
+    dispose,
     applySession,
     applyStarted,
     patchRecording
@@ -1331,9 +1903,12 @@ var createCore = (config) => {
 var createCommonSessions = (core) => ({
   list: core.store.list,
   get: core.store.get,
-  sync: async (query) => {
+  sync: async (query, options) => {
     const response = await unwrap(listSessions({ client: core.api, query }), core.auth);
-    core.store.sync(response.items);
+    core.store.sync(response.items, {
+      mode: options?.mode,
+      shouldReplace: options?.mode === "replaceVisible" && canReplaceVisibleQuery(query) ? (session) => matchesVisibleQuery(session, query) : void 0
+    });
     return core.store.list();
   },
   join: (sessionId) => unwrap(createSessionToken({ client: core.api, path: { sessionId } }), core.auth),
@@ -1381,7 +1956,7 @@ var createHostControls = (core) => ({
       addSessionParticipant({
         client: core.api,
         path: { sessionId: input.sessionId },
-        body: { target: input.target }
+        body: { target: normalizePhoneTarget(input.target) }
       }),
       core.auth
     ),
@@ -1412,12 +1987,28 @@ var startSession = async (core, vendor, target) => core.applyStarted(
     createSession({
       client: core.api,
       path: { vendor },
-      body: { target }
+      body: { target: normalizePhoneTarget(target) }
     }),
     core.auth
   ),
   "command"
 );
+var matchesVisibleQuery = (session, query) => {
+  if (query?.vendor && session.vendor !== query.vendor) {
+    return false;
+  }
+  const state = query?.state ?? "active";
+  if (state === "all") {
+    return true;
+  }
+  if (state === "ended") {
+    return session.state === "ended";
+  }
+  return session.state !== "ended";
+};
+var canReplaceVisibleQuery = (query) => {
+  return !query?.before && query?.limit === void 0;
+};
 
 export { CallpadError, createHostClient, createSessionClient };
 //# sourceMappingURL=index.js.map