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

package/CHANGELOG.md

@@ -5,6 +5,14 @@ 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

package/dist/{StreamingAudioPlayer-dNR3u0Z_.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-DBmQDc73.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-DBmQDc73.js → index-C0EU_1kt.js}

@@ -7576,7 +7576,7 @@ const _AnimationPlayer = class _AnimationPlayer {
     if (this.streamingPlayer) {
       return;
     }
-    const { StreamingAudioPlayer } = await import("./StreamingAudioPlayer-dNR3u0Z_.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({
@@ -8966,7 +8966,7 @@ class AvatarSDK {
 }
 __publicField(AvatarSDK, "_isInitialized", false);
 __publicField(AvatarSDK, "_configuration", null);
-__publicField(AvatarSDK, "_version", "1.0.0-beta.47");
+__publicField(AvatarSDK, "_version", "1.0.0-beta.48");
 __publicField(AvatarSDK, "_avatarCore", null);
 __publicField(AvatarSDK, "_dynamicSdkConfig", null);
 const AvatarSDK$1 = Object.freeze(Object.defineProperty({
@@ -10635,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,
@@ -11240,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;
@@ -11248,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;
@@ -11558,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}`);
@@ -11577,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");
@@ -11623,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 = {
@@ -11672,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;
@@ -11697,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) {
@@ -11751,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") {
@@ -11760,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) {
@@ -11955,6 +12263,8 @@ const _AvatarManager = class _AvatarManager {
       } 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-DBmQDc73.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.47",
+  "version": "1.0.0-beta.48",
   "packageManager": "pnpm@10.18.2",
   "description": "SPAvatar SDK - 3D Gaussian Splatting Avatar Rendering SDK",
   "author": "SPAvatar Team",