@kaltura-sdk/avatars 1.21.0 → 1.21.2

package/index.esm.js

@@ -1,4 +1,4 @@
-import { UnisphereLoggerFactory, TinyDataStore, TinyPubSub, performanceMonitor, getOrCreateGlobalUnisphere } from '@unisphere/core';
+import { UnisphereLoggerFactory, TinyDataStore, TinyPubSub, performanceMonitor, getOrCreateGlobalTinyDataStore } from '@unisphere/core';
 import { getPartnerIdFromKs } from '@unisphere/runtime-js';
 import { DisconnectReasons, getAvatarDefaultCapabilities, resolveActiveContextType, AvatarConnectionStatus } from '@unisphere/genie-types';
 import { z as z$1 } from 'zod/mini';
@@ -1920,18 +1920,6 @@ PERFORMANCE OF THIS SOFTWARE.
 /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -23840,240 +23828,12 @@ const avatarConnectionMachine = setup({
   }
 });
 
-const NAMESPACE = 'unisphere-global-tiny-data-store';
-const REGISTRY_KEY = 'globalTinyDataStore';
-function getRegistry(logger) {
-  return getOrCreateGlobalUnisphere(REGISTRY_KEY, logger, {
-    windowId: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`,
-    // null prototype: ids come off the wire, `__proto__`/`constructor` must be plain keys
-    entries: Object.create(null),
-    listening: false,
-    lastTs: 0
-  }).value;
-}
-// `length`/`frames` are readable cross-origin, so this reaches every frame
-// regardless of nesting depth or origin; we can't know which one holds an avatar.
-function collectWindows(root) {
-  const result = [];
-  const visit = w => {
-    result.push(w);
-    let count = 0;
-    try {
-      count = w.length;
-    } catch (_a) {
-      return;
-    }
-    for (let i = 0; i < count; i++) {
-      try {
-        visit(w.frames[i]);
-      } catch (_b) {
-        // frame navigated away or became inaccessible while enumerating
-      }
-    }
-  };
-  visit(root);
-  return result;
-}
-// Cache frames seen by this window so a `pagehide` message dispatched by an iframe
-// just before removal is still recognized even after `contentWindow` detaches from the DOM.
-const knownFrames = new WeakSet();
-function getPageWindows(win) {
-  var _a;
-  const current = collectWindows((_a = win.top) !== null && _a !== void 0 ? _a : win);
-  for (const w of current) {
-    knownFrames.add(w);
-  }
-  return current;
-}
-function isKnownPageWindow(win, source) {
-  if (getPageWindows(win).includes(source)) {
-    return true;
-  }
-  return knownFrames.has(source);
-}
-function post(target, message) {
-  try {
-    // '*' because the host topology (and origins) are unknown. The payload is
-    // non-sensitive and receivers only accept messages from this page's frames.
-    target.postMessage(message, '*');
-  } catch (_a) {
-    // target is gone
-  }
-}
-function broadcast(win, message) {
-  for (const target of getPageWindows(win)) {
-    if (target !== win) {
-      post(target, message);
-    }
-  }
-}
-function compareRevisions(a, b) {
-  if (a.ts !== b.ts) {
-    return a.ts - b.ts;
-  }
-  return a.origin < b.origin ? -1 : a.origin > b.origin ? 1 : 0;
-}
-function isRevision(rev) {
-  return !!rev && typeof rev.ts === 'number' && typeof rev.origin === 'string';
-}
-function handleMessage(win, registry, logger, event) {
-  const data = event.data;
-  if (!data || data.ns !== NAMESPACE || typeof data.id !== 'string') {
-    return;
-  }
-  const source = event.source;
-  if (!source || source === win || !isKnownPageWindow(win, source)) {
-    logger.debug('ignored message from a window outside this page', {
-      data: {
-        id: data.id,
-        kind: data.kind
-      }
-    });
-    return;
-  }
-  const entry = registry.entries[data.id];
-  if (data.kind === 'request-sync') {
-    if (entry === null || entry === void 0 ? void 0 : entry.rev) {
-      logger.debug('answering sync request', {
-        data: {
-          id: data.id
-        }
-      });
-      post(source, {
-        ns: NAMESPACE,
-        from: registry.windowId,
-        kind: 'update',
-        id: data.id,
-        value: entry.store.getData(),
-        rev: entry.rev
-      });
-    }
-    return;
-  }
-  if (data.kind !== 'update' || !isRevision(data.rev)) {
-    return;
-  }
-  // Lamport-style: a write made after observing this one must sort after it,
-  // even within the same millisecond.
-  registry.lastTs = Math.max(registry.lastTs, data.rev.ts);
-  if (!entry) {
-    logger.debug('stored update for an id nobody here listens to yet', {
-      data: {
-        id: data.id,
-        rev: data.rev
-      }
-    });
-    registry.entries[data.id] = {
-      store: new TinyDataStore({
-        initialValue: data.value,
-        compare: 'deep'
-      }),
-      rev: data.rev
-    };
-    return;
-  }
-  // Equal/older revisions are what stops echoes between frames.
-  if (entry.rev && compareRevisions(data.rev, entry.rev) <= 0) {
-    logger.debug('dropped stale or duplicate update', {
-      data: {
-        id: data.id,
-        rev: data.rev
-      }
-    });
-    return;
-  }
-  logger.debug('applied update from another frame', {
-    data: {
-      id: data.id,
-      value: data.value,
-      rev: data.rev
-    }
-  });
-  entry.rev = data.rev;
-  entry.store.setData(() => data.value);
-}
-// The listener is installed once per window by whichever bundle listens first,
-// so it keeps that bundle's logger.
-function ensureListener(win, registry, logger) {
-  if (registry.listening) {
-    return;
-  }
-  registry.listening = true;
-  win.addEventListener('message', event => handleMessage(win, registry, logger, event));
-}
-/**
- * A `TinyDataStore` shared by id between every workspace in this window and,
- * via `postMessage`, every other frame on the page (parent, siblings, nested).
- * Last write wins (timestamp, then window id as tie-break).
- */
-function listenToGlobalTinyDataStore({
-  id,
-  initialValue,
-  onChanges,
-  logger = avatarClientLoggerFactory.getOrCreateLogger('service', 'global-tiny-data-store')
-}) {
-  const win = window;
-  const registry = getRegistry(logger);
-  ensureListener(win, registry, logger);
-  let entry = registry.entries[id];
-  const isNew = !entry;
-  if (!entry) {
-    entry = registry.entries[id] = {
-      store: new TinyDataStore({
-        initialValue,
-        compare: 'deep'
-      }),
-      rev: null
-    };
-  }
-  const store = entry.store;
-  const unsubscribe = store.onChanges(onChanges, {
-    replayLastValue: false
-  });
-  logger.debug('listening to global store', {
-    data: {
-      id,
-      isNew
-    }
-  });
-  if (isNew) {
-    broadcast(win, {
-      ns: NAMESPACE,
-      from: registry.windowId,
-      kind: 'request-sync',
-      id
-    });
-  }
-  return {
-    unsubscribe,
-    getData: () => store.getData(),
-    setData: value => {
-      const rev = {
-        ts: registry.lastTs = Math.max(Date.now(), registry.lastTs + 1),
-        origin: registry.windowId
-      };
-      logger.debug('updating global store', {
-        data: {
-          id,
-          value,
-          rev
-        }
-      });
-      entry.rev = rev;
-      store.setData(() => value);
-      broadcast(win, {
-        ns: NAMESPACE,
-        from: registry.windowId,
-        kind: 'update',
-        id,
-        value,
-        rev
-      });
-    }
-  };
-}
-
 const ACTIVE_SESSION_STORE_ID = 'agenticExperienceAvatar';
+const PROBE_STORE_ID = 'agenticExperienceAvatarProbe';
+const HEARTBEAT_INTERVAL_MS = 2000;
+const HEARTBEAT_STALE_AFTER_MS = 6000;
+// A live owner answers within one postMessage round trip; this only has to outlast a busy main thread.
+const PROBE_TIMEOUT_MS = 1000;
 function createId() {
   return typeof crypto !== 'undefined' && crypto.randomUUID ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
@@ -24082,32 +23842,44 @@ function createId() {
  * just overwriting the shared record: the previous owner sees an id that is
  * no longer its own and ends its own call (a close callback could not cross
  * frames).
+ *
+ * `pagehide` can't be trusted to release (crashed/frozen tabs, an iframe the
+ * host removes while the avatar is mid-call), so the owner also refreshes
+ * `heartbeatAt` and everyone else ignores a record that stopped refreshing.
+ * `verifyConflictOwner()` shortcuts that wait: a removed iframe can't answer a ping.
  */
 class ActiveSessionCoordinator {
   constructor(_options) {
     this._options = _options;
     this.id = createId();
     this._owns = false;
+    // Heartbeats change every record, so only `id`/`preventDisconnections` count as a change.
     this._conflict = new TinyDataStore({
       initialValue: null,
-      compare: 'deep'
+      compare: (a, b) => (a === null || a === void 0 ? void 0 : a.id) === (b === null || b === void 0 ? void 0 : b.id) && (a === null || a === void 0 ? void 0 : a.preventDisconnections) === (b === null || b === void 0 ? void 0 : b.preventDisconnections)
     });
+    // Owners that failed a probe, keyed to the heartbeat they were last seen with; a newer heartbeat revives them.
+    this._abandoned = new Map();
+    this._pendingProbe = null;
     this._win = window;
     this._onPageHide = () => this.release();
-    const _a = listenToGlobalTinyDataStore({
-        id: ACTIVE_SESSION_STORE_ID,
-        initialValue: null,
-        onChanges: value => this._handle(value),
-        logger: _options.logger
-      }),
-      {
-        unsubscribe
-      } = _a,
-      global = __rest(_a, ["unsubscribe"]);
+    this._heartbeatTimer = null;
+    this._expiryTimer = null;
     this._logger = _options.logger;
-    this._global = global;
-    this._unsubscribe = unsubscribe;
-    this._handle(global.getData());
+    this._global = getOrCreateGlobalTinyDataStore({
+      id: ACTIVE_SESSION_STORE_ID,
+      initialValue: null,
+      logger: _options.logger
+    });
+    this._unsubscribe = this._global.onChanges(value => this._handle(value));
+    this._probe = getOrCreateGlobalTinyDataStore({
+      id: PROBE_STORE_ID,
+      initialValue: null,
+      logger: _options.logger
+    });
+    this._unsubscribeProbe = this._probe.onChanges(probe => this._handleProbe(probe), {
+      replayLastValue: false
+    });
     // A closed iframe must not leave the page locked.
     this._win.addEventListener('pagehide', this._onPageHide);
   }
@@ -24127,46 +23899,148 @@ class ActiveSessionCoordinator {
         preventDisconnections
       }
     });
-    this._global.setData({
-      id: this.id,
-      preventDisconnections
-    });
+    this._publish(preventDisconnections);
+    this._startHeartbeat();
   }
   /** Republishes the flag only while this avatar owns the call; never claims an idle one */
   updateFlag(preventDisconnections) {
     var _a, _b;
     if (this._owns && ((_a = this._global.getData()) === null || _a === void 0 ? void 0 : _a.id) === this.id && ((_b = this._global.getData()) === null || _b === void 0 ? void 0 : _b.preventDisconnections) !== preventDisconnections) {
-      this._global.setData({
-        id: this.id,
-        preventDisconnections
-      });
+      this._publish(preventDisconnections);
+    }
+  }
+  /**
+   * Pings the avatar that owns the call. No answer within `PROBE_TIMEOUT_MS`
+   * (removed iframe, crashed tab) marks it abandoned so `conflict` clears
+   * instead of waiting for its heartbeat to go stale.
+   */
+  verifyConflictOwner() {
+    const record = this._global.getData();
+    if (!record || record.id === this.id || this._pendingProbe) {
+      return;
     }
+    const nonce = createId();
+    const timer = setTimeout(() => {
+      var _a;
+      this._pendingProbe = null;
+      const current = this._global.getData();
+      // A newer heartbeat in the meantime proves the owner is alive.
+      if ((current === null || current === void 0 ? void 0 : current.id) === record.id && current.heartbeatAt === record.heartbeatAt) {
+        (_a = this._logger) === null || _a === void 0 ? void 0 : _a.log('active avatar session owner did not answer, treating it as abandoned', {
+          data: {
+            id: record.id
+          }
+        });
+        this._abandoned.set(record.id, record.heartbeatAt);
+        this._handle(current);
+      }
+    }, PROBE_TIMEOUT_MS);
+    this._pendingProbe = {
+      nonce,
+      timer
+    };
+    this._probe.setData(() => ({
+      nonce,
+      ownerId: record.id,
+      reply: false
+    }));
   }
   /** Clears the record only if it is still ours, so a taken-over avatar can't wipe the new owner */
   release() {
     var _a, _b;
     this._owns = false;
+    this._stopHeartbeat();
     if (((_a = this._global.getData()) === null || _a === void 0 ? void 0 : _a.id) === this.id) {
       (_b = this._logger) === null || _b === void 0 ? void 0 : _b.log('releasing the active avatar session', {
         data: {
           id: this.id
         }
       });
-      this._global.setData(null);
+      this._global.setData(() => null);
     }
   }
   dispose() {
     this.release();
     this._unsubscribe();
+    this._unsubscribeProbe();
+    this._clearExpiryTimer();
+    this._clearPendingProbe();
     this._win.removeEventListener('pagehide', this._onPageHide);
   }
-  _handle(value) {
+  _publish(preventDisconnections) {
+    this._global.setData(() => ({
+      id: this.id,
+      preventDisconnections,
+      heartbeatAt: Date.now()
+    }));
+  }
+  _startHeartbeat() {
+    if (this._heartbeatTimer) {
+      return;
+    }
+    this._heartbeatTimer = setInterval(() => {
+      const current = this._global.getData();
+      if (this._owns && (current === null || current === void 0 ? void 0 : current.id) === this.id) {
+        this._publish(current.preventDisconnections);
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  _stopHeartbeat() {
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+  }
+  _clearPendingProbe() {
+    if (this._pendingProbe) {
+      clearTimeout(this._pendingProbe.timer);
+      this._pendingProbe = null;
+    }
+  }
+  _handleProbe(probe) {
     var _a;
-    const other = value && value.id !== this.id ? value : null;
+    if (!probe) {
+      return;
+    }
+    if (!probe.reply && probe.ownerId === this.id && this._owns) {
+      this._probe.setData(() => Object.assign(Object.assign({}, probe), {
+        reply: true
+      }));
+    } else if (probe.reply && probe.nonce === ((_a = this._pendingProbe) === null || _a === void 0 ? void 0 : _a.nonce)) {
+      this._clearPendingProbe();
+    }
+  }
+  _clearExpiryTimer() {
+    if (this._expiryTimer) {
+      clearTimeout(this._expiryTimer);
+      this._expiryTimer = null;
+    }
+  }
+  _handle(value) {
+    var _a, _b, _c;
+    this._clearExpiryTimer();
+    // A record without `heartbeatAt` (older bundle in another frame) never expires.
+    const staleIn = value && typeof value.heartbeatAt === 'number' ? value.heartbeatAt + HEARTBEAT_STALE_AFTER_MS - Date.now() : Infinity;
+    const isAbandoned = !!value && value.heartbeatAt !== undefined && value.heartbeatAt <= ((_a = this._abandoned.get(value.id)) !== null && _a !== void 0 ? _a : -Infinity);
+    const isStale = !!value && (staleIn < 0 || isAbandoned);
+    if (isStale && value.id !== this.id) {
+      (_b = this._logger) === null || _b === void 0 ? void 0 : _b.log('ignoring an abandoned active avatar session', {
+        data: {
+          id: value.id,
+          heartbeatAt: value.heartbeatAt
+        }
+      });
+    }
+    const other = value && value.id !== this.id && !isStale ? value : null;
     this._conflict.setData(() => other);
+    if (other && Number.isFinite(staleIn)) {
+      // Nothing is written when the owner dies, so re-evaluate once its record would go stale.
+      this._expiryTimer = setTimeout(() => this._handle(this._global.getData()), staleIn + 1);
+    }
     if (other && this._owns) {
       this._owns = false;
-      (_a = this._logger) === null || _a === void 0 ? void 0 : _a.log('active avatar session taken over by another avatar', {
+      this._stopHeartbeat();
+      (_c = this._logger) === null || _c === void 0 ? void 0 : _c.log('active avatar session taken over by another avatar', {
         data: {
           id: this.id,
           by: other.id
@@ -24489,6 +24363,19 @@ class AvatarClientManager extends ActorManager {
         preventDisconnections: (_b = (_a = this._config.runtimeSettings.multipleAvatarBehavior) === null || _a === void 0 ? void 0 : _a.preventDisconnections) !== null && _b !== void 0 ? _b : false
       };
     });
+    // The call that held our connect is gone (ended, abandoned): the user already asked to start, so just start.
+    this._activeSession.conflict.onChanges(conflict => {
+      if (conflict || !this._isTakeoverPending.getData()) {
+        return;
+      }
+      const options = this._pendingTakeoverOptions;
+      this._pendingTakeoverOptions = undefined;
+      this._isTakeoverPending.setData(() => false);
+      this._logger.log('Resuming the held connect: the other avatar call is gone');
+      this.connect(options);
+    }, {
+      replayLastValue: false
+    });
     this._status.onChanges(status => {
       if (status === AvatarConnectionStatus.NotConnected || status === AvatarConnectionStatus.Disconnected || status === AvatarConnectionStatus.Error) {
         this._activeSession.release();
@@ -24711,6 +24598,8 @@ class AvatarClientManager extends ActorManager {
       });
       this._pendingTakeoverOptions = options;
       this._isTakeoverPending.setData(() => true);
+      // An owner that is already gone (removed iframe, crashed tab) can't answer, so don't make the user wait out its heartbeat.
+      this._activeSession.verifyConflictOwner();
       return;
     }
     this._activeSession.claim(this._multipleAvatarBehavior.getData().preventDisconnections);
@@ -25086,4 +24975,4 @@ class AvatarClientManager extends ActorManager {
   }
 }
 
-export { ApplicationFeatures, AvatarClientManager, AvatarConnectionMachineEventTypes, AvatarConnectionMachineId, AvatarNotificationCode, ButtonNames, PageNames, agentRawTextClientToolDeltaSchema, agentRawTextDeltaSchema, agentRawTextSchema, agentTurnToTalkSchema, askPermissionsSchema, avatarClientLoggerFactory, avatarConnectionMachine, avatarRTCClientManager, clientConfigurationSchema, conversationEndedSchema, conversationTimeWarningSchema, createTinyPubsubEventsHandler, createTinyPubsubEventsSource, generatingSpeechSchema, getAvatarDisconnectNotificationVariant, getQueryParam, initializeLogsCollectionIfNeeded, isMappedAvatarDisconnectReason, isMobileDevice, joinCompleteSchema, listenToGlobalTinyDataStore, noAgentSchema, onServerConnectedSchema, pauseExpiryWarningSchema, resetWebsocketClientTeardownState, showAgentSchema, showStartSpeechSchema, stvFinishedTalkingSchema, stvNewSessionSchema, stvSpeechChunkSchema, stvStartedTalkingSchema, timingTracker, unsupportedClientSchema, websocketClientManager, websocketDebugInfo, websocketMessage, websocketNonRecoveredReconnect, websocketRecoveryState, websocketSystemMessage };
+export { ApplicationFeatures, AvatarClientManager, AvatarConnectionMachineEventTypes, AvatarConnectionMachineId, AvatarNotificationCode, ButtonNames, PageNames, agentRawTextClientToolDeltaSchema, agentRawTextDeltaSchema, agentRawTextSchema, agentTurnToTalkSchema, askPermissionsSchema, avatarClientLoggerFactory, avatarConnectionMachine, avatarRTCClientManager, clientConfigurationSchema, conversationEndedSchema, conversationTimeWarningSchema, createTinyPubsubEventsHandler, createTinyPubsubEventsSource, generatingSpeechSchema, getAvatarDisconnectNotificationVariant, getQueryParam, initializeLogsCollectionIfNeeded, isMappedAvatarDisconnectReason, isMobileDevice, joinCompleteSchema, noAgentSchema, onServerConnectedSchema, pauseExpiryWarningSchema, resetWebsocketClientTeardownState, showAgentSchema, showStartSpeechSchema, stvFinishedTalkingSchema, stvNewSessionSchema, stvSpeechChunkSchema, stvStartedTalkingSchema, timingTracker, unsupportedClientSchema, websocketClientManager, websocketDebugInfo, websocketMessage, websocketNonRecoveredReconnect, websocketRecoveryState, websocketSystemMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaltura-sdk/avatars",
-  "version": "1.21.0",
+  "version": "1.21.2",
   "author": "kaltura",
   "license": "AGPL-3.0",
   "repository": {
@@ -12,8 +12,8 @@
     "@kaltura-sdk/rtc-avatar": "^1.33.4",
     "@kaltura-sdk/rtc-core": "^1.26.2",
     "@local/genie-shared-utils": "^1.0.0",
-    "@unisphere/core": "^1.99.0",
-    "@unisphere/genie-types": "^1.47.0",
+    "@unisphere/core": "^1.101.2",
+    "@unisphere/genie-types": "^1.47.1",
     "@unisphere/notifications-core": "^1.25.0",
     "@unisphere/runtime": "^1.98.0",
     "@unisphere/runtime-js": "^1.98.0",

package/src/index.d.ts

@@ -1,6 +1,5 @@
 export * from './lib/avatar-client-manager';
 export * from './lib/server';
-export * from './lib/global-tiny-data-store';
 export * from './lib/timing-tracker';
 export * from './lib/analytics';
 export * from './lib/utils';

package/src/lib/avatar-client-manager/utils/active-session-coordinator.d.ts

@@ -1,11 +1,19 @@
 import { UnisphereLoggerType } from '@unisphere/core';
 import type { ActiveAvatarSession } from '@unisphere/genie-types';
 export declare const ACTIVE_SESSION_STORE_ID = "agenticExperienceAvatar";
+export declare const HEARTBEAT_INTERVAL_MS = 2000;
+export declare const HEARTBEAT_STALE_AFTER_MS = 6000;
+export declare const PROBE_TIMEOUT_MS = 1000;
 /**
  * Page-wide "who owns the call" record for one avatar manager. Takeover is
  * just overwriting the shared record: the previous owner sees an id that is
  * no longer its own and ends its own call (a close callback could not cross
  * frames).
+ *
+ * `pagehide` can't be trusted to release (crashed/frozen tabs, an iframe the
+ * host removes while the avatar is mid-call), so the owner also refreshes
+ * `heartbeatAt` and everyone else ignores a record that stopped refreshing.
+ * `verifyConflictOwner()` shortcuts that wait: a removed iframe can't answer a ping.
  */
 export declare class ActiveSessionCoordinator {
     private readonly _options;
@@ -13,10 +21,16 @@ export declare class ActiveSessionCoordinator {
     private _owns;
     private readonly _conflict;
     private readonly _global;
+    private readonly _probe;
     private readonly _unsubscribe;
+    private readonly _unsubscribeProbe;
+    private readonly _abandoned;
+    private _pendingProbe;
     private readonly _win;
     private readonly _onPageHide;
     private readonly _logger?;
+    private _heartbeatTimer;
+    private _expiryTimer;
     constructor(_options: {
         onTakenOver: () => void;
         logger?: UnisphereLoggerType;
@@ -26,8 +40,20 @@ export declare class ActiveSessionCoordinator {
     claim(preventDisconnections: boolean): void;
     /** Republishes the flag only while this avatar owns the call; never claims an idle one */
     updateFlag(preventDisconnections: boolean): void;
+    /**
+     * Pings the avatar that owns the call. No answer within `PROBE_TIMEOUT_MS`
+     * (removed iframe, crashed tab) marks it abandoned so `conflict` clears
+     * instead of waiting for its heartbeat to go stale.
+     */
+    verifyConflictOwner(): void;
     /** Clears the record only if it is still ours, so a taken-over avatar can't wipe the new owner */
     release(): void;
     dispose(): void;
+    private _publish;
+    private _startHeartbeat;
+    private _stopHeartbeat;
+    private _clearPendingProbe;
+    private _handleProbe;
+    private _clearExpiryTimer;
     private _handle;
 }

package/src/lib/test-utils/create-frame-api.d.ts

@@ -1,15 +1,9 @@
 import type { ActiveSessionCoordinator } from '../avatar-client-manager/utils/active-session-coordinator';
-import type { listenToGlobalTinyDataStore } from '../global-tiny-data-store';
 type CoordinatorOptions = ConstructorParameters<typeof ActiveSessionCoordinator>[0];
 export declare function getRealTopWindow(): Window;
 export declare function addFrame(parent: Window): Window;
 export declare function installBrowserLikePostMessage(windows: Window[]): void;
 export declare function createFrameApi(win: Window): Promise<{
-    listen: (options: Parameters<typeof listenToGlobalTinyDataStore>[0]) => {
-        unsubscribe: () => void;
-        getData: () => unknown;
-        setData: (value: unknown) => void;
-    };
     createCoordinator: (options: CoordinatorOptions) => ActiveSessionCoordinator;
     cleanup: () => void;
 }>;

package/src/lib/global-tiny-data-store/index.d.ts

@@ -1 +0,0 @@
-export * from './listen-to-global-tiny-data-store';

package/src/lib/global-tiny-data-store/listen-to-global-tiny-data-store.d.ts

@@ -1,16 +0,0 @@
-import { UnisphereLoggerType } from '@unisphere/core';
-/**
- * A `TinyDataStore` shared by id between every workspace in this window and,
- * via `postMessage`, every other frame on the page (parent, siblings, nested).
- * Last write wins (timestamp, then window id as tie-break).
- */
-export declare function listenToGlobalTinyDataStore<T>({ id, initialValue, onChanges, logger, }: {
-    id: string;
-    initialValue: T;
-    onChanges: (value: T) => void;
-    logger?: UnisphereLoggerType;
-}): {
-    unsubscribe: () => void;
-    getData: () => T;
-    setData: (value: T) => void;
-};