@spatialwalk/avatarkit 1.0.0-beta.46 → 1.0.0-beta.48

package/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.0-beta.48] - 2025-01-05
+
+### ✨ New Features
+- **PWA Cache Management** - Added automatic PWA cache management for character and template resources to improve loading performance
+
+### 🔧 Performance Improvements
+- **Cache Hit Rate Metrics** - Resource downloads now report cache status for analytics
+
+## [1.0.0-beta.47] - 2025-12-29
+
+### 🐛 Bugfix
+- **Avatar Meta Update** - Fixed issue where cached Avatar instances would return stale character metadata even when the latest metadata was fetched. Now the character metadata is always updated to the latest version when loading an avatar, even if the version number hasn't changed.
+
 ## [1.0.0-beta.46] - 2025-12-29
 
 ### 🐛 Bugfix

package/dist/{StreamingAudioPlayer-BlY4b-HD.js → StreamingAudioPlayer-BCUbWwGa.js}

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { A as APP_CONFIG, e as errorToMessage, l as logEvent, a as logger } from "./index-DJMm01Eu.js";
+import { A as APP_CONFIG, e as errorToMessage, l as logEvent, a as logger } from "./index-C0EU_1kt.js";
 class StreamingAudioPlayer {
   constructor(options) {
     __publicField(this, "audioContext", null);

package/dist/core/AvatarController.d.ts

@@ -32,6 +32,10 @@ export declare class AvatarController {
     private lastSyncLogTime;
     private lastOutOfBoundsState;
     private isAudioOnlyMode;
+    private playbackStuckCheckState;
+    private readonly MAX_AUDIO_TIME_ZERO_COUNT;
+    private readonly MAX_AUDIO_TIME_STUCK_COUNT;
+    private readonly AUDIO_TIME_STUCK_THRESHOLD;
     private hostModeMetrics;
     private readonly audioBytesPerSecond;
     constructor(avatar: Avatar, options?: {

package/dist/{index-DJMm01Eu.js → index-C0EU_1kt.js}

@@ -13,6 +13,9 @@ class Avatar {
   getCharacterMeta() {
     return this.characterMeta;
   }
+  updateCharacterMeta(newMeta) {
+    this.characterMeta = newMeta;
+  }
   getResources() {
     return this.resources;
   }
@@ -7573,7 +7576,7 @@ const _AnimationPlayer = class _AnimationPlayer {
     if (this.streamingPlayer) {
       return;
     }
-    const { StreamingAudioPlayer } = await import("./StreamingAudioPlayer-BlY4b-HD.js");
+    const { StreamingAudioPlayer } = await import("./StreamingAudioPlayer-BCUbWwGa.js");
     const { AvatarSDK: AvatarSDK2 } = await Promise.resolve().then(() => AvatarSDK$1);
     const audioFormat = AvatarSDK2.getAudioFormat();
     this.streamingPlayer = new StreamingAudioPlayer({
@@ -8963,7 +8966,7 @@ class AvatarSDK {
 }
 __publicField(AvatarSDK, "_isInitialized", false);
 __publicField(AvatarSDK, "_configuration", null);
-__publicField(AvatarSDK, "_version", "1.0.0-beta.46");
+__publicField(AvatarSDK, "_version", "1.0.0-beta.48");
 __publicField(AvatarSDK, "_avatarCore", null);
 __publicField(AvatarSDK, "_dynamicSdkConfig", null);
 const AvatarSDK$1 = Object.freeze(Object.defineProperty({
@@ -10632,6 +10635,15 @@ class AvatarController {
     __publicField(this, "lastSyncLogTime", 0);
     __publicField(this, "lastOutOfBoundsState", false);
     __publicField(this, "isAudioOnlyMode", false);
+    __publicField(this, "playbackStuckCheckState", {
+      audioTimeZeroCount: 0,
+      lastAudioTime: 0,
+      audioTimeStuckCount: 0,
+      reported: false
+    });
+    __publicField(this, "MAX_AUDIO_TIME_ZERO_COUNT", 60);
+    __publicField(this, "MAX_AUDIO_TIME_STUCK_COUNT", 60);
+    __publicField(this, "AUDIO_TIME_STUCK_THRESHOLD", 1e-3);
     __publicField(this, "hostModeMetrics", {
       accumulatedBytes: 0,
       startTimestamp: 0,
@@ -11237,6 +11249,68 @@ class AvatarController {
       this.isPlaying = false;
     }
   }
+  checkPlaybackStuck(audioTime) {
+    var _a, _b, _c, _d, _e2, _f;
+    const streamingPlayer = (_a = this.animationPlayer) == null ? void 0 : _a.getStreamingPlayer();
+    if (!streamingPlayer) {
+      return false;
+    }
+    const state = this.playbackStuckCheckState;
+    const hasAnimationData = this.currentKeyframes.length > 0;
+    const hasAudioData = ((_b = streamingPlayer.audioChunks) == null ? void 0 : _b.length) > 0;
+    const isNotPaused = this.currentState !== AvatarState.paused;
+    if (!hasAnimationData || !hasAudioData || this.currentState === AvatarState.paused) {
+      state.audioTimeZeroCount = 0;
+      state.audioTimeStuckCount = 0;
+      state.lastAudioTime = 0;
+      state.reported = false;
+      return false;
+    }
+    if (state.reported) {
+      return true;
+    }
+    const audioContextState = ((_c = streamingPlayer.audioContext) == null ? void 0 : _c.state) || "unknown";
+    const isAudioContextSuspended = audioContextState === "suspended";
+    const activeSourcesCount = ((_d = streamingPlayer.activeSources) == null ? void 0 : _d.size) || 0;
+    const scheduledChunks = streamingPlayer.scheduledChunks || 0;
+    const hasScheduledButNoActive = scheduledChunks > 0 && activeSourcesCount === 0;
+    if (audioTime === 0) {
+      state.audioTimeZeroCount++;
+    } else {
+      state.audioTimeZeroCount = 0;
+    }
+    if (Math.abs(audioTime - state.lastAudioTime) < this.AUDIO_TIME_STUCK_THRESHOLD) {
+      state.audioTimeStuckCount++;
+    } else {
+      state.audioTimeStuckCount = 0;
+    }
+    state.lastAudioTime = audioTime;
+    const shouldReport = state.audioTimeZeroCount > this.MAX_AUDIO_TIME_ZERO_COUNT || state.audioTimeStuckCount > this.MAX_AUDIO_TIME_STUCK_COUNT || isAudioContextSuspended && this.isPlaying || hasScheduledButNoActive && this.isPlaying;
+    if (shouldReport && isNotPaused) {
+      state.reported = true;
+      logEvent("character_player", "error", {
+        event: "playback_stuck_after_transition",
+        avatar_id: this.avatar.id,
+        conversationId: ((_e2 = this.networkLayer) == null ? void 0 : _e2.getCurrentConversationId()) || void 0,
+        audioContextState,
+        isAudioContextSuspended,
+        audioTime,
+        audioTimeZero: audioTime === 0,
+        audioTimeZeroCount: state.audioTimeZeroCount,
+        audioTimeStuck: state.audioTimeStuckCount > this.MAX_AUDIO_TIME_STUCK_COUNT,
+        audioTimeStuckCount: state.audioTimeStuckCount,
+        hasScheduledButNoActive,
+        isPlaying: this.isPlaying,
+        currentState: this.currentState,
+        animationFramesCount: this.currentKeyframes.length,
+        audioChunksCount: ((_f = streamingPlayer.audioChunks) == null ? void 0 : _f.length) || 0,
+        scheduledChunks,
+        activeSourcesCount
+      });
+      return true;
+    }
+    return false;
+  }
   startPlaybackLoop() {
     if (this.playbackLoopId) {
       return;
@@ -11245,14 +11319,23 @@ class AvatarController {
     const playLoop = async () => {
       if (!this.isPlaying || this.currentState === AvatarState.paused || !this.animationPlayer) {
         this.playbackLoopId = null;
+        this.playbackStuckCheckState.audioTimeZeroCount = 0;
+        this.playbackStuckCheckState.audioTimeStuckCount = 0;
+        this.playbackStuckCheckState.lastAudioTime = 0;
+        this.playbackStuckCheckState.reported = false;
         return;
       }
       try {
         const audioTime = this.animationPlayer.getCurrentTime();
+        this.checkPlaybackStuck(audioTime);
         if (audioTime === 0) {
           this.playbackLoopId = requestAnimationFrame(playLoop);
           return;
         }
+        if (audioTime > 0 && Math.abs(audioTime - this.playbackStuckCheckState.lastAudioTime) >= this.AUDIO_TIME_STUCK_THRESHOLD) {
+          this.playbackStuckCheckState.audioTimeZeroCount = 0;
+          this.playbackStuckCheckState.audioTimeStuckCount = 0;
+        }
         let frameIndex = Math.floor(audioTime * fps);
         if (frameIndex < 0) frameIndex = 0;
         let arrayIndex = frameIndex - this.keyframesOffset;
@@ -11555,13 +11638,197 @@ function errorToMessage(err) {
   }
   return String(err);
 }
-async function downloadResource(url) {
+const _PwaCacheManager = class _PwaCacheManager {
+  static isSupported() {
+    return typeof caches !== "undefined";
+  }
+  static getCharacterCacheName(characterId) {
+    return `${_PwaCacheManager.CHARACTER_CACHE_PREFIX}${characterId}${_PwaCacheManager.CHARACTER_CACHE_SUFFIX}`;
+  }
+  static async getCharacterResource(characterId, url) {
+    if (!_PwaCacheManager.isSupported()) {
+      return null;
+    }
+    try {
+      const cacheName = _PwaCacheManager.getCharacterCacheName(characterId);
+      const cache = await caches.open(cacheName);
+      const response = await cache.match(url);
+      if (response) {
+        const arrayBuffer = await response.arrayBuffer();
+        logger.log(`[PwaCacheManager] Character resource cache hit: ${url}`);
+        return arrayBuffer;
+      }
+      return null;
+    } catch (error) {
+      logger.warn(`[PwaCacheManager] Failed to get character resource from cache:`, error);
+      return null;
+    }
+  }
+  static async putCharacterResource(characterId, url, data) {
+    if (!_PwaCacheManager.isSupported()) {
+      return;
+    }
+    try {
+      const cacheName = _PwaCacheManager.getCharacterCacheName(characterId);
+      const cache = await caches.open(cacheName);
+      const keys = await cache.keys();
+      if (keys.length >= _PwaCacheManager.MAX_CHARACTER_CACHE_ENTRIES) {
+        const oldestKey = keys[0];
+        await cache.delete(oldestKey);
+        logger.log(`[PwaCacheManager] Character cache full, deleted oldest entry: ${oldestKey.url}`);
+      }
+      await cache.put(url, new Response(data));
+      logger.log(`[PwaCacheManager] Character resource cached: ${url}`);
+    } catch (error) {
+      logger.warn(`[PwaCacheManager] Failed to put character resource to cache:`, error);
+    }
+  }
+  static async getTemplateResource(url) {
+    if (!_PwaCacheManager.isSupported()) {
+      return null;
+    }
+    try {
+      const cache = await caches.open(_PwaCacheManager.TEMPLATE_CACHE_NAME);
+      const response = await cache.match(url);
+      if (response) {
+        const arrayBuffer = await response.arrayBuffer();
+        logger.log(`[PwaCacheManager] Template resource cache hit: ${url}`);
+        return arrayBuffer;
+      }
+      return null;
+    } catch (error) {
+      logger.warn(`[PwaCacheManager] Failed to get template resource from cache:`, error);
+      return null;
+    }
+  }
+  static async putTemplateResource(url, data) {
+    if (!_PwaCacheManager.isSupported()) {
+      return;
+    }
+    try {
+      const cache = await caches.open(_PwaCacheManager.TEMPLATE_CACHE_NAME);
+      await cache.put(url, new Response(data));
+      logger.log(`[PwaCacheManager] Template resource cached: ${url}`);
+    } catch (error) {
+      logger.warn(`[PwaCacheManager] Failed to put template resource to cache:`, error);
+    }
+  }
+  static async clearCharacterCache(characterId) {
+    if (!_PwaCacheManager.isSupported()) {
+      return;
+    }
+    try {
+      const cacheName = _PwaCacheManager.getCharacterCacheName(characterId);
+      await caches.delete(cacheName);
+      logger.log(`[PwaCacheManager] Character cache cleared: ${characterId}`);
+    } catch (error) {
+      logger.warn(`[PwaCacheManager] Failed to clear character cache:`, error);
+    }
+  }
+  static async checkTemplateCacheVersion(newVersion) {
+    if (!_PwaCacheManager.isSupported()) {
+      return false;
+    }
+    try {
+      const storedVersion = localStorage.getItem(_PwaCacheManager.TEMPLATE_VERSION_STORAGE_KEY);
+      if (storedVersion !== newVersion) {
+        await caches.delete(_PwaCacheManager.TEMPLATE_CACHE_NAME);
+        localStorage.setItem(_PwaCacheManager.TEMPLATE_VERSION_STORAGE_KEY, newVersion);
+        logger.log(`[PwaCacheManager] Template cache version changed: ${storedVersion} -> ${newVersion}, cache cleared`);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      logger.warn(`[PwaCacheManager] Failed to check template cache version:`, error);
+      return false;
+    }
+  }
+};
+__publicField(_PwaCacheManager, "TEMPLATE_CACHE_VERSION", "v1");
+__publicField(_PwaCacheManager, "TEMPLATE_CACHE_NAME", `spatialwalk-sdk-template-cache-${_PwaCacheManager.TEMPLATE_CACHE_VERSION}`);
+__publicField(_PwaCacheManager, "TEMPLATE_VERSION_STORAGE_KEY", "spatialwalk-sdk-template-cache-version");
+__publicField(_PwaCacheManager, "CHARACTER_CACHE_PREFIX", "spatialwalk-sdk-character-");
+__publicField(_PwaCacheManager, "CHARACTER_CACHE_SUFFIX", "-cache");
+__publicField(_PwaCacheManager, "MAX_CHARACTER_CACHE_ENTRIES", 1e3);
+let PwaCacheManager = _PwaCacheManager;
+const pwaCacheManager = Object.freeze(Object.defineProperty({
+  __proto__: null,
+  PwaCacheManager
+}, Symbol.toStringTag, { value: "Module" }));
+function getCacheInfo(url, response) {
+  var _a;
+  const resourceTiming = performance.getEntriesByName(url, "resource")[0];
+  const transferSize = (resourceTiming == null ? void 0 : resourceTiming.transferSize) ?? 0;
+  const deliveryType = resourceTiming == null ? void 0 : resourceTiming.deliveryType;
+  const hasServiceWorker = typeof navigator !== "undefined" && ((_a = navigator.serviceWorker) == null ? void 0 : _a.controller) !== null;
+  const isPwaCache = transferSize === 0 && hasServiceWorker && (deliveryType === "cache" || deliveryType === "serviceworker") && (resourceTiming == null ? void 0 : resourceTiming.duration) !== void 0 && resourceTiming.duration > 0;
+  const isBrowserCache = transferSize === 0 && !isPwaCache && (!hasServiceWorker || deliveryType === "cache") && (resourceTiming == null ? void 0 : resourceTiming.duration) !== void 0 && resourceTiming.duration > 0;
+  const cfCacheStatus = response.headers.get("cf-cache-status");
+  const xCache = response.headers.get("x-cache");
+  const xSwiftCacheTime = response.headers.get("x-swift-cache-time");
+  const age = response.headers.get("age");
+  const cdnCacheStatus = cfCacheStatus || xCache || xSwiftCacheTime;
+  const isCdnCache = cdnCacheStatus && (cdnCacheStatus.toLowerCase() === "hit" || cdnCacheStatus.toLowerCase() === "hits" || cdnCacheStatus.toLowerCase().includes("hit")) || age && parseInt(age, 10) > 0;
+  let cacheHit = false;
+  let cacheType = "none";
+  if (isPwaCache) {
+    cacheHit = true;
+    cacheType = "pwa";
+  } else if (isBrowserCache) {
+    cacheHit = true;
+    cacheType = "browser";
+  } else if (isCdnCache) {
+    cacheHit = true;
+    cacheType = "cdn";
+  }
+  return {
+    cacheHit,
+    cacheType,
+    transferSize,
+    cdnCacheStatus: cdnCacheStatus || void 0
+  };
+}
+async function downloadResource(url, options) {
   try {
+    let cached = null;
+    let pwaCacheSubtype = void 0;
+    if (options == null ? void 0 : options.characterId) {
+      cached = await PwaCacheManager.getCharacterResource(options.characterId, url);
+      if (cached) {
+        pwaCacheSubtype = "character";
+      }
+    } else if ((options == null ? void 0 : options.resourceType) === "template") {
+      cached = await PwaCacheManager.getTemplateResource(url);
+      if (cached) {
+        pwaCacheSubtype = "template";
+      }
+    }
+    if (cached) {
+      const response2 = new Response(cached);
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      const cacheInfo2 = getCacheInfo(url, response2);
+      cacheInfo2.cacheHit = true;
+      cacheInfo2.cacheType = "pwa";
+      cacheInfo2.pwaCacheSubtype = pwaCacheSubtype;
+      return { data: cached, cacheInfo: cacheInfo2 };
+    }
     const response = await fetch(url);
     if (!response.ok) {
       throw new Error(`HTTP ${response.status} ${response.statusText}`);
     }
-    return await response.arrayBuffer();
+    const arrayBuffer = await response.arrayBuffer();
+    if (options == null ? void 0 : options.characterId) {
+      PwaCacheManager.putCharacterResource(options.characterId, url, arrayBuffer).catch((err) => {
+        logger.warn(`[downloadResource] Failed to cache character resource:`, err);
+      });
+    } else if ((options == null ? void 0 : options.resourceType) === "template") {
+      PwaCacheManager.putTemplateResource(url, arrayBuffer).catch((err) => {
+        logger.warn(`[downloadResource] Failed to cache template resource:`, err);
+      });
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 0));
+    const cacheInfo = getCacheInfo(url, response);
+    return { data: arrayBuffer, cacheInfo };
   } catch (err) {
     const msg = errorToMessage(err);
     throw new Error(`[downloadResource] ${url} → ${msg}`);
@@ -11574,6 +11841,8 @@ class AvatarDownloader {
   }
   async loadTemplateResources(flameResources, progressCallback = null) {
     var _a, _b, _c, _d;
+    const sdkVersion2 = AvatarSDK.version;
+    await PwaCacheManager.checkTemplateCacheVersion(sdkVersion2);
     const useApiResources = flameResources && Object.keys(flameResources).length > 0;
     if (!useApiResources) {
       logger.log("Template resources not provided in CharacterMeta, using global CDN config");
@@ -11620,15 +11889,26 @@ class AvatarDownloader {
       }
       updateProgress(resourceName, false);
       logger.log(`📥 Loading ${key} from API CDN: ${url}`);
-      const buffer = await downloadResource(url);
+      const { data: buffer, cacheInfo } = await downloadResource(url, { resourceType: "template" });
       logger.log(`✅ ${key} loaded: ${buffer.byteLength} bytes`);
       templateResources[key] = buffer;
       updateProgress(resourceName, true);
+      logEvent("resource_download", "info", {
+        resource_type: "template",
+        resource_name: resourceName,
+        cache_hit: cacheInfo.cacheHit,
+        cache_type: cacheInfo.cacheType,
+        pwa_cache_subtype: cacheInfo.pwaCacheSubtype,
+        transfer_size: cacheInfo.transferSize,
+        cdn_cache_status: cacheInfo.cdnCacheStatus
+      });
     });
     await Promise.all(promises);
     return templateResources;
   }
   async loadGlobalFlameResources(progressCallback = null) {
+    const sdkVersion2 = AvatarSDK.version;
+    await PwaCacheManager.checkTemplateCacheVersion(sdkVersion2);
     const startTime = Date.now();
     const { cdnBaseUrl, resources } = APP_CONFIG.flame;
     const templateFiles = {
@@ -11669,10 +11949,19 @@ class AvatarDownloader {
       const promises = Object.entries(templateFiles).map(async ([key, { url, resourceName }]) => {
         updateProgress(resourceName, false);
         logger.log(`📥 Loading ${key} from global CDN: ${url}`);
-        const buffer = await downloadResource(url);
+        const { data: buffer, cacheInfo } = await downloadResource(url, { resourceType: "template" });
         logger.log(`✅ ${key} loaded: ${buffer.byteLength} bytes`);
         templateResources[key] = buffer;
         updateProgress(resourceName, true);
+        logEvent("resource_download", "info", {
+          resource_type: "template",
+          resource_name: resourceName,
+          cache_hit: cacheInfo.cacheHit,
+          cache_type: cacheInfo.cacheType,
+          pwa_cache_subtype: cacheInfo.pwaCacheSubtype,
+          transfer_size: cacheInfo.transferSize,
+          cdn_cache_status: cacheInfo.cdnCacheStatus
+        });
       });
       await Promise.all(promises);
       const duration = Date.now() - startTime;
@@ -11694,11 +11983,21 @@ class AvatarDownloader {
     }
     try {
       logger.log(`📥 Loading camera info from: ${cameraUrl}`);
-      const response = await fetch(cameraUrl);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch camera info: ${response.statusText}`);
-      }
-      const cameraSettings = await response.json();
+      const { data: arrayBuffer, cacheInfo } = await downloadResource(cameraUrl, {
+        characterId: characterMeta.characterId ?? void 0,
+        resourceType: "character"
+      });
+      const text = new TextDecoder().decode(arrayBuffer);
+      const cameraSettings = JSON.parse(text);
+      logEvent("resource_download", "info", {
+        resource_type: "camera_settings",
+        resource_name: "camera.json",
+        cache_hit: cacheInfo.cacheHit,
+        cache_type: cacheInfo.cacheType,
+        pwa_cache_subtype: cacheInfo.pwaCacheSubtype,
+        transfer_size: cacheInfo.transferSize,
+        cdn_cache_status: cacheInfo.cdnCacheStatus
+      });
       logger.log("✅ Camera info loaded:", cameraSettings);
       return cameraSettings;
     } catch (error) {
@@ -11748,7 +12047,10 @@ class AvatarDownloader {
     const downloadPromises = filesToLoad.map(async ({ key, url, filename, optional }) => {
       updateProgress(filename, false);
       try {
-        const arrayBuffer = await downloadResource(url);
+        const { data: arrayBuffer, cacheInfo } = await downloadResource(url, {
+          characterId: characterMeta.characterId ?? void 0,
+          resourceType: "character"
+        });
         if (key === "shape") {
           characterData.shape = arrayBuffer;
         } else if (key === "pointCloud") {
@@ -11757,6 +12059,15 @@ class AvatarDownloader {
           characterData.idleAnimation = arrayBuffer;
         }
         updateProgress(filename, true);
+        logEvent("resource_download", "info", {
+          resource_type: "character_asset",
+          resource_name: filename,
+          cache_hit: cacheInfo.cacheHit,
+          cache_type: cacheInfo.cacheType,
+          pwa_cache_subtype: cacheInfo.pwaCacheSubtype,
+          transfer_size: cacheInfo.transferSize,
+          cdn_cache_status: cacheInfo.cdnCacheStatus
+        });
         return { key, success: true, size: arrayBuffer.byteLength };
       } catch (error) {
         if (!optional) {
@@ -11946,11 +12257,14 @@ const _AvatarManager = class _AvatarManager {
       const cachedVersion = cachedMeta.version;
       const newVersion = newCharacterMeta.version;
       if (cachedVersion === newVersion) {
-        logger.log(`[AvatarManager] Avatar ${id} found in cache with same version (${cachedVersion}), returning cached`);
+        logger.log(`[AvatarManager] Avatar ${id} found in cache with same version (${cachedVersion}), updating meta and returning cached`);
+        cached.updateCharacterMeta(newCharacterMeta);
         return cached;
       } else {
         logger.log(`[AvatarManager] Avatar ${id} version mismatch: cached=${cachedVersion}, new=${newVersion}, reloading...`);
         this.avatarCache.delete(id);
+        const { PwaCacheManager: PwaCacheManager2 } = await Promise.resolve().then(() => pwaCacheManager);
+        await PwaCacheManager2.clearCharacterCache(id);
       }
     }
     logger.log(`[AvatarManager] Queuing avatar download for id: ${id}`);

package/dist/index.js

@@ -1,4 +1,4 @@
-import { b, c, f, d, j, g, C, i, D, E, k, h, L, R, S, m } from "./index-DJMm01Eu.js";
+import { b, c, f, d, j, g, C, i, D, E, k, h, L, R, S, m } from "./index-C0EU_1kt.js";
 export {
   b as Avatar,
   c as AvatarController,

package/dist/utils/pwa-cache-manager.d.ts

@@ -0,0 +1,16 @@
+export declare class PwaCacheManager {
+    private static readonly TEMPLATE_CACHE_VERSION;
+    private static readonly TEMPLATE_CACHE_NAME;
+    private static readonly TEMPLATE_VERSION_STORAGE_KEY;
+    private static readonly CHARACTER_CACHE_PREFIX;
+    private static readonly CHARACTER_CACHE_SUFFIX;
+    private static readonly MAX_CHARACTER_CACHE_ENTRIES;
+    static isSupported(): boolean;
+    private static getCharacterCacheName;
+    static getCharacterResource(characterId: string, url: string): Promise<ArrayBuffer | null>;
+    static putCharacterResource(characterId: string, url: string, data: ArrayBuffer): Promise<void>;
+    static getTemplateResource(url: string): Promise<ArrayBuffer | null>;
+    static putTemplateResource(url: string, data: ArrayBuffer): Promise<void>;
+    static clearCharacterCache(characterId: string): Promise<void>;
+    static checkTemplateCacheVersion(newVersion: string): Promise<boolean>;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@spatialwalk/avatarkit",
   "type": "module",
-  "version": "1.0.0-beta.46",
+  "version": "1.0.0-beta.48",
   "packageManager": "pnpm@10.18.2",
   "description": "SPAvatar SDK - 3D Gaussian Splatting Avatar Rendering SDK",
   "author": "SPAvatar Team",