@spatialwalk/avatarkit 1.0.0-beta.72 → 1.0.0-beta.74

package/CHANGELOG.md

@@ -5,6 +5,16 @@ 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.74] - 2026-01-22
+
+### 🔧 Improvements
+- **Transition API** - Replaced `generateTransitionFromIdle` with `generateTransition` (options-based API: `from`, `to`, `frameCount`, `useLinear`)
+
+## [1.0.0-beta.73] - 2026-01-22
+
+### ✨ New Features
+- **Local Log Upload** - Automatic local log upload functionality
+
 ## [1.0.0-beta.72] - 2026-01-17
 
 ### 📚 Documentation

package/dist/{StreamingAudioPlayer-fV-zTOrl.js → StreamingAudioPlayer-BDIgU70Y.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, l as logger, e as errorToMessage, a as logEvent } from "./index-BginsqFH.js";
+import { A as APP_CONFIG, l as logger, e as errorToMessage, a as logEvent } from "./index-CXzGTmFB.js";
 class StreamingAudioPlayer {
   // Mark if AudioContext is being resumed, avoid concurrent resume requests
   constructor(options) {

package/dist/core/AvatarView.d.ts

@@ -55,14 +55,12 @@ export declare class AvatarView {
      * @param enableIdleRendering - Whether to enable idle loop rendering. true: Enable idle rendering and return immediately (skip this keyframe); false: Disable idle rendering and process keyframe (default)
      */
     renderFlame(keyframeData: KeyframeData, enableIdleRendering?: boolean): Promise<void>;
-    /**
-     * Generate transition frame array from current idle frame to target keyframe (pure rendering mode)
-     * @param toKeyframeData - Target keyframe data
-     * @param frameCount - Number of transition frames
-     * @param transitionType - Transition type: 'start' means Idle -> toKeyframeData (start transition), 'end' means toKeyframeData -> Idle (end transition)
-     * @returns Transition frame array with length of frameCount
-     */
-    generateTransitionFromIdle(toKeyframeData: KeyframeData, frameCount: number, transitionType?: 'start' | 'end'): Promise<KeyframeData[]>;
+    generateTransition(options: {
+        from?: KeyframeData;
+        to?: KeyframeData;
+        frameCount: number;
+        useLinear?: boolean;
+    }): Promise<KeyframeData[]>;
     /**
      * Get or set avatar transform in canvas
      *

package/dist/{index-BginsqFH.js → index-CXzGTmFB.js}

@@ -7350,74 +7350,249 @@ class AvatarError extends Error {
     this.name = "AvatarError";
   }
 }
-{
-  setGlobalLogLevel(LogLevel$1.Warning);
-}
-const logger = useLogger("Web").withErrorProcessor((err) => {
-  captureErrorContext("error", err);
-  return err;
-}).useGlobalConfig();
-let originalLogger = null;
-function setLogLevel(level) {
-  switch (level) {
-    case LogLevel.off:
-      if (!originalLogger) {
-        originalLogger = { ...logger };
+const _LogSink = class _LogSink {
+  constructor() {
+    __publicField(this, "db", null);
+    __publicField(this, "dbName", "avatarkit_logs");
+    __publicField(this, "storeName", "logs");
+    __publicField(this, "version", 1);
+    __publicField(this, "trimThreshold", 5e3);
+    __publicField(this, "trimBufferSize", 1e3);
+    __publicField(this, "isFlushing", false);
+  }
+  static getInstance() {
+    if (!_LogSink.instance) {
+      _LogSink.instance = new _LogSink();
+    }
+    return _LogSink.instance;
+  }
+  /**
+   * Initialize IndexedDB
+   */
+  async initialize() {
+    if (this.db) {
+      return;
+    }
+    return new Promise((resolve2, reject) => {
+      const request = indexedDB.open(this.dbName, this.version);
+      request.onerror = () => {
+        reject(new Error("Failed to open IndexedDB"));
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve2();
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          const store = db.createObjectStore(this.storeName, { keyPath: "id", autoIncrement: true });
+          store.createIndex("ts", "ts", { unique: false });
+        }
+      };
+    });
+  }
+  /**
+   * Append log entry to IndexedDB
+   */
+  async append(entry) {
+    if (!this.db) {
+      try {
+        await this.initialize();
+      } catch {
+        return;
       }
-      Object.assign(logger, {
-        debug: () => {
-        },
-        verbose: () => {
-        },
-        log: () => {
-        },
-        warn: () => {
-        },
-        error: () => {
-        },
-        errorWithError: () => {
+    }
+    if (!this.db) {
+      return;
+    }
+    try {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      await new Promise((resolve2, reject) => {
+        const request = store.add(entry);
+        request.onsuccess = () => resolve2();
+        request.onerror = () => reject(new Error("Failed to add log"));
+      });
+      this.getCount().then((count) => {
+        if (count > this.trimThreshold) {
+          this.trim().catch(() => {
+          });
         }
+      }).catch(() => {
       });
-      break;
-    case LogLevel.error:
-      if (originalLogger) {
-        Object.assign(logger, originalLogger);
-        originalLogger = null;
+    } catch (error) {
+    }
+  }
+  /**
+   * Get total log count
+   */
+  async getCount() {
+    if (!this.db) {
+      return 0;
+    }
+    return new Promise((resolve2, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.count();
+      request.onsuccess = () => {
+        resolve2(request.result);
+      };
+      request.onerror = () => {
+        reject(new Error("Failed to count logs"));
+      };
+    });
+  }
+  /**
+   * Trim logs to keep only recent entries
+   */
+  async trim() {
+    if (!this.db || this.isFlushing) {
+      return;
+    }
+    try {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const getAllRequest = store.getAll();
+      const entries = await new Promise((resolve2, reject) => {
+        getAllRequest.onsuccess = () => {
+          resolve2(getAllRequest.result);
+        };
+        getAllRequest.onerror = () => {
+          reject(new Error("Failed to get logs"));
+        };
+      });
+      const keepCount = this.trimThreshold - this.trimBufferSize;
+      if (entries.length <= keepCount) {
+        return;
       }
-      setGlobalLogLevel(LogLevel$1.Error);
-      break;
-    case LogLevel.warning:
-      if (originalLogger) {
-        Object.assign(logger, originalLogger);
-        originalLogger = null;
+      entries.sort((a2, b2) => a2.ts - b2.ts);
+      const toDelete = entries.slice(0, entries.length - keepCount);
+      for (const entry of toDelete) {
+        if (entry.id !== void 0) {
+          await new Promise((resolve2, reject) => {
+            const deleteRequest = store.delete(entry.id);
+            deleteRequest.onsuccess = () => resolve2();
+            deleteRequest.onerror = () => reject(new Error("Failed to delete log"));
+          });
+        }
       }
-      setGlobalLogLevel(LogLevel$1.Warning);
-      break;
-    case LogLevel.all:
-      if (originalLogger) {
-        Object.assign(logger, originalLogger);
-        originalLogger = null;
+    } catch (error) {
+    }
+  }
+  /**
+   * Flush logs to server
+   */
+  async flush() {
+    if (!this.db || this.isFlushing) {
+      return;
+    }
+    this.isFlushing = true;
+    try {
+      const transaction = this.db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const getAllRequest = store.getAll();
+      const entries = await new Promise((resolve2, reject) => {
+        getAllRequest.onsuccess = () => {
+          resolve2(getAllRequest.result);
+        };
+        getAllRequest.onerror = () => {
+          reject(new Error("Failed to get logs"));
+        };
+      });
+      if (entries.length === 0) {
+        this.isFlushing = false;
+        return;
       }
-      setGlobalLogLevel(LogLevel$1.Debug);
-      break;
-    default:
-      if (originalLogger) {
-        Object.assign(logger, originalLogger);
-        originalLogger = null;
+      const entriesWithPlatform = entries.map((entry) => ({
+        ...entry,
+        extra: {
+          ...entry.extra,
+          platform: "Web"
+        }
+      }));
+      const requestBody = { logs: entriesWithPlatform };
+      const jsonData = JSON.stringify(requestBody);
+      const gzippedData = await this.gzip(jsonData);
+      const response = await fetch("https://hogtool.spatialwalk.ai/batch-upload-log", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Encoding": "gzip"
+        },
+        body: gzippedData,
+        signal: AbortSignal.timeout(15e3)
+        // 15 second timeout
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to upload logs: ${response.status} ${response.statusText}`);
       }
-      setGlobalLogLevel(LogLevel$1.Warning);
-      break;
+      await this.clearFirst(entries.length);
+    } catch (error) {
+      console.warn("[LogSink] Failed to flush logs:", error);
+      throw error;
+    } finally {
+      this.isFlushing = false;
+    }
   }
-}
-function captureErrorContext(level, error) {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  trackEvent("logger_error", level, {
-    error: errorMessage,
-    timestamp: Date.now(),
-    environment: "library",
-    user_agent: typeof navigator !== "undefined" ? navigator.userAgent : ""
-  });
-}
+  /**
+   * Clear first N log entries
+   */
+  async clearFirst(count) {
+    if (!this.db || count <= 0) {
+      return;
+    }
+    try {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const getAllRequest = store.getAll();
+      const entries = await new Promise((resolve2, reject) => {
+        getAllRequest.onsuccess = () => {
+          resolve2(getAllRequest.result);
+        };
+        getAllRequest.onerror = () => {
+          reject(new Error("Failed to get logs"));
+        };
+      });
+      entries.sort((a2, b2) => a2.ts - b2.ts);
+      const toDelete = entries.slice(0, count);
+      for (const entry of toDelete) {
+        if (entry.id !== void 0) {
+          await new Promise((resolve2, reject) => {
+            const deleteRequest = store.delete(entry.id);
+            deleteRequest.onsuccess = () => resolve2();
+            deleteRequest.onerror = () => reject(new Error("Failed to delete log"));
+          });
+        }
+      }
+    } catch (error) {
+    }
+  }
+  /**
+   * Gzip string data
+   */
+  async gzip(data) {
+    try {
+      const encoder = new TextEncoder();
+      const encoded = encoder.encode(data);
+      const readableStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(encoded);
+          controller.close();
+        }
+      });
+      const compressedStream = readableStream.pipeThrough(new CompressionStream("gzip"));
+      const response = new Response(compressedStream);
+      const blob = await response.blob();
+      return blob;
+    } catch (error) {
+      console.error("[LogSink] gzip() error:", error);
+      throw error;
+    }
+  }
+};
+__publicField(_LogSink, "instance", null);
+let LogSink = _LogSink;
+const logSink = LogSink.getInstance();
 const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
 let random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
 let customRandom = (alphabet, defaultSize, getRandom) => {
@@ -7579,6 +7754,176 @@ class IdManager {
   }
 }
 const idManager = new IdManager();
+const ALGORITHM_TERMS = [
+  "flame",
+  "keyframe",
+  "keyframes",
+  "splat",
+  "splats",
+  "covariance",
+  "gaussian",
+  "cov6",
+  "packeddata",
+  "sortorder",
+  "sortindex",
+  "avatar_core",
+  "emscripten",
+  "wasm",
+  "blendshape",
+  "expressionparam",
+  "rig"
+];
+const ALGORITHM_REG = new RegExp(
+  `\\b(${ALGORITHM_TERMS.join("|")})\\b`,
+  "gi"
+);
+const CHINESE_REG = /[\u4e00-\u9fff\u3400-\u4dbf\uf900-\ufaff]/;
+const SENSITIVE_PATTERNS = [
+  { reg: /\b(token|sessiontoken|accesstoken|apikey|apisecret|secret|password|auth)=([^\s,}\]'"]+)/gi, replacement: "$1=***" },
+  { reg: /\b(conversationid|connectionid|clientid|sessionid)=([^\s,}\]'"]+)/gi, replacement: "$1=***" },
+  { reg: /\b(appid|app_id)=([^\s,}\]'"]+)/gi, replacement: "$1=***" },
+  { reg: /\b(userid|user_id)=([^\s,}\]'"]+)/gi, replacement: "$1=***" },
+  { reg: /(https?:\/\/)[^\s,}\]'"]+/gi, replacement: "$1***" },
+  { reg: /(wss?:\/\/)[^\s,}\]'"]+/gi, replacement: "$1***" }
+];
+function hasChinese(msg) {
+  return CHINESE_REG.test(msg);
+}
+function hasAlgorithmTerms(msg) {
+  return ALGORITHM_REG.test(msg);
+}
+function redactSensitive(msg) {
+  let out = msg;
+  for (const { reg, replacement } of SENSITIVE_PATTERNS) {
+    out = out.replace(reg, replacement);
+  }
+  return out;
+}
+function sanitizeForLocalLog(message) {
+  if (hasChinese(message) || hasAlgorithmTerms(message)) {
+    return { shouldPersist: false, sanitized: message };
+  }
+  return {
+    shouldPersist: true,
+    sanitized: redactSensitive(message)
+  };
+}
+{
+  setGlobalLogLevel(LogLevel$1.Warning);
+}
+const baseLogger = useLogger("Web").withErrorProcessor((err) => {
+  captureErrorContext("error", err);
+  return err;
+}).useGlobalConfig();
+logSink.initialize().catch(() => {
+});
+let currentLogLevel = LogLevel.off;
+async function writeToLocalLog(message, level, extra = {}) {
+  try {
+    const { shouldPersist, sanitized } = sanitizeForLocalLog(message);
+    if (!shouldPersist) {
+      return;
+    }
+    const { AvatarSDK: AvatarSDK2 } = await Promise.resolve().then(() => AvatarSDK$1);
+    const version = AvatarSDK2.version;
+    const appId = idManager.getAppId();
+    const userId = idManager.getUserId();
+    const logEntry = {
+      level,
+      ts: Date.now(),
+      msg: sanitized,
+      extra: {
+        ...extra,
+        _category: "Web",
+        sdk_version: version || "",
+        app_id: appId || "",
+        user_id: userId || "",
+        platform: "Web",
+        framework: "",
+        framework_version: ""
+      }
+    };
+    await logSink.append(logEntry);
+  } catch {
+  }
+}
+function formatConsoleMessage(message) {
+  return `[AvatarKit] ${message}`;
+}
+const logger = {
+  debug: (message, ...args) => {
+    writeToLocalLog(message, "info", {}).catch(() => {
+    });
+    if (currentLogLevel === LogLevel.all) {
+      baseLogger.debug(formatConsoleMessage(message), ...args);
+    }
+  },
+  verbose: (message, ...args) => {
+    writeToLocalLog(message, "info", {}).catch(() => {
+    });
+    if (currentLogLevel === LogLevel.all) {
+      baseLogger.verbose(formatConsoleMessage(message), ...args);
+    }
+  },
+  log: (message, ...args) => {
+    writeToLocalLog(message, "info", {}).catch(() => {
+    });
+    if (currentLogLevel === LogLevel.all) {
+      baseLogger.log(formatConsoleMessage(message), ...args);
+    }
+  },
+  warn: (message, ...args) => {
+    writeToLocalLog(message, "warn", {}).catch(() => {
+    });
+    if (currentLogLevel === LogLevel.warning || currentLogLevel === LogLevel.all) {
+      baseLogger.warn(formatConsoleMessage(message), ...args);
+    }
+  },
+  error: (message, ..._args) => {
+    writeToLocalLog(message, "error", {}).catch(() => {
+    });
+    if (currentLogLevel !== LogLevel.off) {
+      baseLogger.error(formatConsoleMessage(message));
+    }
+  },
+  errorWithError: (message, error) => {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    writeToLocalLog(`${message}: ${errorMessage}`, "error", {}).catch(() => {
+    });
+    if (currentLogLevel !== LogLevel.off) {
+      baseLogger.errorWithError(formatConsoleMessage(message), error);
+    }
+  }
+};
+function setLogLevel(level) {
+  currentLogLevel = level;
+  switch (level) {
+    case LogLevel.off:
+      setGlobalLogLevel(LogLevel$1.Error);
+      break;
+    case LogLevel.error:
+      setGlobalLogLevel(LogLevel$1.Error);
+      break;
+    case LogLevel.warning:
+      setGlobalLogLevel(LogLevel$1.Warning);
+      break;
+    case LogLevel.all:
+      setGlobalLogLevel(LogLevel$1.Debug);
+      break;
+    default:
+      setGlobalLogLevel(LogLevel$1.Warning);
+      break;
+  }
+}
+function captureErrorContext(level, error) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  trackEvent("logger_error", level, {
+    error: errorMessage,
+    timestamp: Date.now(),
+    environment: "library",
+    user_agent: typeof navigator !== "undefined" ? navigator.userAgent : ""
+  });
+}
 let sdkVersion = "1.0.0";
 let currentEnvironment = null;
 let isInitialized = false;
@@ -7593,10 +7938,26 @@ function shouldFilterHostname() {
   const hostname = window.location.hostname;
   return FILTERED_HOSTNAMES.includes(hostname);
 }
+function getCommonFields() {
+  const logContext = idManager.getLogContext();
+  return {
+    platform: "Web",
+    sdk_version: sdkVersion,
+    environment: currentEnvironment || "unknown",
+    app_id: logContext.app_id || "",
+    user_id: logContext.user_id || "",
+    // 没有就传空字符串
+    client_id: logContext.client_id,
+    framework: "",
+    // Web native 传空字符串
+    framework_version: ""
+    // Web native 传空字符串
+  };
+}
 function initializePostHog(environment, version) {
-  if (shouldFilterHostname()) {
-    logger.log(`[PostHog] Tracking disabled due to filtered hostname: ${window.location.hostname}`);
-    return;
+  const isHostnameFiltered = shouldFilterHostname();
+  if (isHostnameFiltered) {
+    logger.log(`[PostHog] Event tracking disabled due to filtered hostname: ${window.location.hostname}, but PostHog will still be initialized for feature flags`);
   }
   const { host, apiKey, disableCompression } = getPostHogConfig();
   if (isInitialized) {
@@ -7624,23 +7985,13 @@ function initializePostHog(environment, version) {
         logger.log(`[PostHog] Initialized successfully - environment: ${environment}, host: ${host}, instance: ${SDK_POSTHOG_INSTANCE_NAME}`);
         isInitialized = true;
         sdkPosthogInstance = posthogInstance;
+        const userProperties = getCommonFields();
         if (logContext.user_id) {
-          posthogInstance.identify(logContext.user_id, {
-            app_id: logContext.app_id,
-            client_id: logContext.client_id,
-            sdk_version: sdkVersion,
-            platform: "Web",
-            environment
-          });
+          posthogInstance.identify(logContext.user_id, userProperties);
         } else {
-          posthogInstance.register({
-            app_id: logContext.app_id,
-            client_id: logContext.client_id,
-            sdk_version: sdkVersion,
-            platform: "Web",
-            environment
-          });
+          posthogInstance.register(userProperties);
         }
+        posthogInstance.setPersonPropertiesForFlags(userProperties);
         flushEventQueue();
       }
     }, SDK_POSTHOG_INSTANCE_NAME);
@@ -7660,6 +8011,50 @@ function getSdkPosthogInstance() {
     return null;
   }
 }
+async function getLogsFeatureFlag() {
+  let instance = getSdkPosthogInstance();
+  if (!instance) {
+    const maxWaitTime = 5e3;
+    const checkInterval = 100;
+    const startTime = Date.now();
+    while (!instance && Date.now() - startTime < maxWaitTime) {
+      await new Promise((resolve2) => setTimeout(resolve2, checkInterval));
+      instance = getSdkPosthogInstance();
+    }
+  }
+  if (!instance) {
+    logger.log("[PostHog] PostHog not initialized after waiting, logs feature flag disabled (default: false)");
+    return false;
+  }
+  try {
+    const commonFields = getCommonFields();
+    instance.setPersonPropertiesForFlags(commonFields);
+    instance.reloadFeatureFlags();
+    await new Promise((resolve2) => {
+      instance.onFeatureFlags((_flags, _variants, { errorsLoading } = {}) => {
+        if (errorsLoading) {
+          logger.warn("[PostHog] Error loading feature flags");
+        }
+        resolve2();
+      });
+    });
+    const flagValue = instance.isFeatureEnabled("logs_feature_flag");
+    const isEnabled = flagValue === true;
+    logger.log(`[PostHog] Logs feature flag: ${isEnabled ? "enabled" : "disabled"}`);
+    return isEnabled;
+  } catch (error) {
+    logger.warn("[PostHog] Failed to get logs feature flag:", error instanceof Error ? error.message : String(error));
+    return false;
+  }
+}
+function updatePostHogPersonPropertiesForFlags() {
+  const instance = getSdkPosthogInstance();
+  if (!instance) {
+    return;
+  }
+  const commonFields = getCommonFields();
+  instance.setPersonPropertiesForFlags(commonFields);
+}
 function flushEventQueue() {
   if (!sdkPosthogInstance || eventQueue.length === 0) {
     return;
@@ -7669,15 +8064,11 @@ function flushEventQueue() {
     for (const { event, level, contents } of eventQueue) {
       try {
         const logContext = idManager.getLogContext();
+        const commonFields = getCommonFields();
         const properties = {
-          service_module: "sdk",
-          platform: "Web",
-          sdk_version: sdkVersion,
+          ...commonFields,
           level,
-          environment: currentEnvironment || "unknown",
-          app_id: logContext.app_id,
-          user_id: logContext.user_id,
-          client_id: logContext.client_id,
+          service_module: "sdk",
           timestamp: Date.now(),
           ...contents
         };
@@ -7704,20 +8095,12 @@ function trackEvent(event, level = "info", contents = {}) {
   sdkPosthogInstance = instance;
   try {
     const logContext = idManager.getLogContext();
+    const commonFields = getCommonFields();
     const properties = {
-      // Basic properties
-      service_module: "sdk",
-      platform: "Web",
-      sdk_version: sdkVersion,
+      ...commonFields,
       level,
-      environment: currentEnvironment || "unknown",
-      // ID information
-      app_id: logContext.app_id,
-      user_id: logContext.user_id,
-      client_id: logContext.client_id,
-      // Timestamp
+      service_module: "sdk",
       timestamp: Date.now(),
-      // Custom contents
       ...contents
     };
     if (logContext.connection_id) {
@@ -7860,7 +8243,7 @@ const _AnimationPlayer = class _AnimationPlayer {
     if (this.streamingPlayer) {
       return;
     }
-    const { StreamingAudioPlayer } = await import("./StreamingAudioPlayer-fV-zTOrl.js");
+    const { StreamingAudioPlayer } = await import("./StreamingAudioPlayer-BDIgU70Y.js");
     const { AvatarSDK: AvatarSDK2 } = await Promise.resolve().then(() => AvatarSDK$1);
     const audioFormat = AvatarSDK2.getAudioFormat();
     this.streamingPlayer = new StreamingAudioPlayer({
@@ -9331,6 +9714,10 @@ class AvatarSDK {
         });
       }
       logger.log(`[AvatarSDK] Successfully initialized`);
+      setTimeout(() => {
+        this.flushLogsIfNeeded().catch(() => {
+        });
+      }, 0);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       logger.error("Failed to initialize AvatarSDK:", errorMessage);
@@ -9422,6 +9809,7 @@ class AvatarSDK {
    */
   static setUserId(userId) {
     idManager.setUserId(userId);
+    updatePostHogPersonPropertiesForFlags();
   }
   // 只读属性
   static get isInitialized() {
@@ -9528,10 +9916,27 @@ class AvatarSDK {
       driveningressWsUrl
     };
   }
+  /**
+   * Flush logs if feature flag is enabled (private method)
+   * First fetches latest feature flag from server, then decides whether to upload logs
+   * @internal
+   */
+  static async flushLogsIfNeeded() {
+    try {
+      const isEnabled = await getLogsFeatureFlag();
+      if (!isEnabled) {
+        return;
+      }
+      await logSink.flush();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.warn("[AvatarSDK] Failed to flush logs:", errorMessage);
+    }
+  }
 }
 __publicField(AvatarSDK, "_isInitialized", false);
 __publicField(AvatarSDK, "_configuration", null);
-__publicField(AvatarSDK, "_version", "1.0.0-beta.72");
+__publicField(AvatarSDK, "_version", "1.0.0-beta.74");
 __publicField(AvatarSDK, "_avatarCore", null);
 __publicField(AvatarSDK, "_dynamicSdkConfig", null);
 const AvatarSDK$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -11407,8 +11812,7 @@ class AvatarController {
       tap1Timestamp: 0,
       tap2Timestamp: 0,
       recvFirstFlameTimestamp: 0,
-      didRecvFirstFlame: false,
-      didReportLatency: false
+      didRecvFirstFlame: false
     });
     __publicField(this, "audioBytesPerSecond", 16e3 * 2);
     this.avatar = avatar;
@@ -11820,10 +12224,6 @@ class AvatarController {
       if (this.playbackMode === DrivingServiceMode.host && !this.hostModeMetrics.didRecvFirstFlame) {
         this.hostModeMetrics.didRecvFirstFlame = true;
         this.hostModeMetrics.recvFirstFlameTimestamp = Date.now();
-        if (conversationId && !this.hostModeMetrics.didReportLatency) {
-          this.reportDrivingServiceLatency(conversationId);
-          this.hostModeMetrics.didReportLatency = true;
-        }
       }
     } else {
       this.currentKeyframes.push(...flameKeyframes);
@@ -11952,8 +12352,7 @@ class AvatarController {
         tap1Timestamp: 0,
         tap2Timestamp: 0,
         recvFirstFlameTimestamp: 0,
-        didRecvFirstFlame: false,
-        didReportLatency: false
+        didRecvFirstFlame: false
       };
     }
   }
@@ -11976,8 +12375,7 @@ class AvatarController {
         tap1Timestamp: 0,
         tap2Timestamp: 0,
         recvFirstFlameTimestamp: 0,
-        didRecvFirstFlame: false,
-        didReportLatency: false
+        didRecvFirstFlame: false
       };
     }
   }
@@ -12672,30 +13070,6 @@ class AvatarController {
     }
     return result2;
   }
-  /**
-   * Report driving_service_latency event (Host mode)
-   * Report once per session (when first frame is received)
-   * @internal
-   */
-  reportDrivingServiceLatency(conversationId) {
-    if (!conversationId || this.playbackMode !== DrivingServiceMode.host) {
-      return;
-    }
-    const metrics = this.hostModeMetrics;
-    logEvent("driving_service_latency", "info", {
-      req_id: conversationId,
-      dsm: "host",
-      // Host 模式
-      tap_0: metrics.startTimestamp || 0,
-      // 必须有非零值
-      tap_1: metrics.tap1Timestamp || 0,
-      // 缺省值为 0
-      tap_2: metrics.tap2Timestamp || 0,
-      // 缺省值为 0
-      tap_f: metrics.recvFirstFlameTimestamp || 0
-      // 必须有非零值
-    });
-  }
 }
 function errorToMessage(err) {
   if (err instanceof Error) {
@@ -16305,17 +16679,11 @@ class AvatarView {
       throw error;
     }
   }
-  /**
-   * Generate transition frame array from current idle frame to target keyframe (pure rendering mode)
-   * @param toKeyframeData - Target keyframe data
-   * @param frameCount - Number of transition frames
-   * @param transitionType - Transition type: 'start' means Idle -> toKeyframeData (start transition), 'end' means toKeyframeData -> Idle (end transition)
-   * @returns Transition frame array with length of frameCount
-   */
-  async generateTransitionFromIdle(toKeyframeData, frameCount, transitionType = "start") {
+  async generateTransition(options) {
     if (!this.isInitialized) {
       throw new Error("AvatarView not initialized");
     }
+    const { from, to: to2, frameCount, useLinear = false } = options;
     if (frameCount <= 0) {
       throw new Error("Frame count must be greater than 0");
     }
@@ -16324,32 +16692,31 @@ class AvatarView {
       throw new Error("AvatarCore not available");
     }
     try {
-      const idleParams = await avatarCore.getCurrentFrameParams(this.idleCurrentFrameIndex, this.characterId);
-      const idleFrameProto = convertWasmParamsToProtoFlame(idleParams);
-      const toFlame = toKeyframeData;
-      const toFlameWithPostProcessing = this.avatarController.applyPostProcessingToFlame(toFlame);
-      const aligned = this.alignFlamePair(idleFrameProto, toFlameWithPostProcessing);
-      const from = transitionType === "start" ? aligned.from : aligned.to;
-      const to2 = transitionType === "start" ? aligned.to : aligned.from;
+      let fromFrame;
+      if (from) {
+        fromFrame = from;
+      } else {
+        const idleParams = await avatarCore.getCurrentFrameParams(this.idleCurrentFrameIndex, this.characterId);
+        fromFrame = convertWasmParamsToProtoFlame(idleParams);
+      }
+      let toFrame;
+      if (to2) {
+        toFrame = this.avatarController.applyPostProcessingToFlame(to2);
+      } else {
+        const idleFirstParams = await avatarCore.getCurrentFrameParams(0, this.characterId);
+        toFrame = convertWasmParamsToProtoFlame(idleFirstParams);
+      }
+      const aligned = this.alignFlamePair(fromFrame, toFrame);
+      const alignedFrom = aligned.from;
+      const alignedTo = aligned.to;
       const fps = APP_CONFIG.animation.fps;
       const durationMs = frameCount / fps * 1e3;
-      const useLinear = transitionType === "start";
-      const transitionFrames = useLinear ? generateTransitionFramesLinear(
-        from,
-        to2,
-        durationMs,
-        fps
-      ) : generateTransitionFrames(
-        from,
-        to2,
-        durationMs,
-        fps
-      );
-      transitionFrames[0] = from;
-      transitionFrames[transitionFrames.length - 1] = to2;
+      const transitionFrames = useLinear ? generateTransitionFramesLinear(alignedFrom, alignedTo, durationMs, fps) : generateTransitionFrames(alignedFrom, alignedTo, durationMs, fps);
+      transitionFrames[0] = alignedFrom;
+      transitionFrames[transitionFrames.length - 1] = alignedTo;
       return transitionFrames;
     } catch (error) {
-      logger.error("[AvatarView] Failed to generate transition from idle:", error instanceof Error ? error.message : String(error));
+      logger.error("[AvatarView] Failed to generate transition:", error instanceof Error ? error.message : String(error));
       throw error;
     }
   }

package/dist/index.js

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

package/dist/utils/log-sanitizer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Log sanitizer for local log persistence.
+ * Ensures: no sensitive content, no Chinese, no algorithm/internal terms (e.g. Flame, splat).
+ * @internal
+ */
+export interface SanitizeResult {
+    shouldPersist: boolean;
+    sanitized: string;
+}
+/**
+ * Sanitize a log message for local persistence.
+ * - Do not persist if message contains Chinese or algorithm terms.
+ * - Otherwise persist, but redact sensitive content first.
+ */
+export declare function sanitizeForLocalLog(message: string): SanitizeResult;

package/dist/utils/log-sink.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Log Sink - Local log storage and upload
+ * Stores logs in IndexedDB and provides upload functionality
+ * @internal
+ */
+declare class LogSink {
+    private static instance;
+    private db;
+    private readonly dbName;
+    private readonly storeName;
+    private readonly version;
+    private readonly trimThreshold;
+    private readonly trimBufferSize;
+    private isFlushing;
+    private constructor();
+    static getInstance(): LogSink;
+    /**
+     * Initialize IndexedDB
+     */
+    initialize(): Promise<void>;
+    /**
+     * Append log entry to IndexedDB
+     */
+    append(entry: LogEntry): Promise<void>;
+    /**
+     * Get total log count
+     */
+    private getCount;
+    /**
+     * Trim logs to keep only recent entries
+     */
+    private trim;
+    /**
+     * Flush logs to server
+     */
+    flush(): Promise<void>;
+    /**
+     * Clear first N log entries
+     */
+    private clearFirst;
+    /**
+     * Gzip string data
+     */
+    private gzip;
+}
+export declare const logSink: LogSink;
+export {};

package/dist/utils/logger.d.ts

@@ -1,26 +1,25 @@
-import { LogLevel as GuiiaiLogLevel } from '@guiiai/logg';
-export declare const logger: import('@guiiai/logg').Logg;
+/**
+ * Logger Utility
+ * Environment-aware logger wrapper with local log persistence
+ * - Always writes to local log file (IndexedDB) regardless of logLevel
+ * - Console output is controlled by logLevel
+ * - Errors and warnings are always reported to PostHog (when enabled)
+ *
+ * Usage: Replace `console.log()` with `logger.log()`
+ */
+export declare const logger: {
+    debug: (message: string, ...args: unknown[]) => void;
+    verbose: (message: string, ...args: unknown[]) => void;
+    log: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ..._args: unknown[]) => void;
+    errorWithError: (message: string, error: Error | unknown) => void;
+};
 export declare const loggerWithUnknown: {
     error: (message: string, error?: unknown) => void;
     warn: (message: string, error?: unknown) => void;
-    useGlobalConfig: () => import('@guiiai/logg').Logg;
-    child: (fields?: Record<string, any>) => import('@guiiai/logg').Logg;
-    withContext: (context: string) => import('@guiiai/logg').Logg;
-    withLogLevel: (logLevel: GuiiaiLogLevel) => import('@guiiai/logg').Logg;
-    withLogLevelString: (logLevelString: import('@guiiai/logg').LogLevelString) => import('@guiiai/logg').Logg;
-    withFormat: (format: import('@guiiai/logg').Format) => import('@guiiai/logg').Logg;
-    withFields: (fields: Record<string, any>) => import('@guiiai/logg').Logg;
-    withField: (key: string, value: any) => import('@guiiai/logg').Logg;
-    withError: (err: Error | unknown) => import('@guiiai/logg').Logg;
-    withCallStack: (errorLike: {
-        message: string;
-        stack?: string;
-    }) => import('@guiiai/logg').Logg;
-    debug: (message: any, ...optionalParams: [...any, string?]) => void;
-    verbose: (message: any, ...optionalParams: [...any, string?]) => void;
-    log: (message: any, ...optionalParams: any[]) => void;
-    errorWithError: (message: any, err: Error | unknown, ...optionalParams: any[]) => void;
-    withTimeFormat: (format: string) => import('@guiiai/logg').Logg;
-    withTimeFormatter: (fn: (inputDate: Date) => string) => import('@guiiai/logg').Logg;
-    withErrorProcessor: (fn: (err: Error | unknown) => Error | unknown) => import('@guiiai/logg').Logg;
+    debug: (message: string, ...args: unknown[]) => void;
+    verbose: (message: string, ...args: unknown[]) => void;
+    log: (message: string, ...args: unknown[]) => void;
+    errorWithError: (message: string, error: Error | unknown) => void;
 };

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@spatialwalk/avatarkit",
   "type": "module",
-  "version": "1.0.0-beta.72",
-  "packageManager": "pnpm@10.18.2",
+  "version": "1.0.0-beta.74",
   "description": "AvatarKit SDK - 3D Gaussian Splatting Avatar Rendering SDK",
   "author": "AvatarKit Team",
   "license": "MIT",
@@ -38,17 +37,6 @@
     "vite.js",
     "vite.d.ts"
   ],
-  "scripts": {
-    "build": "SDK_BUILD=true vite build --mode library && npm run build:vite-plugin",
-    "build:vite-plugin": "tsc vite.ts --outDir . --module esnext --target es2020 --moduleResolution bundler --esModuleInterop --skipLibCheck --declaration --declarationMap",
-    "dev": "vite build --mode library --watch",
-    "clean": "rm -rf dist",
-    "typecheck": "tsc --noEmit",
-    "test": "cd tests && pnpm test",
-    "test:watch": "cd tests && pnpm run test:watch",
-    "test:e2e": "cd tests && pnpm run test:e2e",
-    "test:perf": "cd tests && pnpm run test:perf"
-  },
   "peerDependencies": {
     "@webgpu/types": "*",
     "vite": "^5.0.0"
@@ -66,5 +54,16 @@
     "typescript": "^5.0.0",
     "vite": "^5.0.0",
     "vite-plugin-dts": "^4.5.4"
+  },
+  "scripts": {
+    "build": "SDK_BUILD=true vite build --mode library && npm run build:vite-plugin",
+    "build:vite-plugin": "tsc vite.ts --outDir . --module esnext --target es2020 --moduleResolution bundler --esModuleInterop --skipLibCheck --declaration --declarationMap",
+    "dev": "vite build --mode library --watch",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "test": "cd tests && pnpm test",
+    "test:watch": "cd tests && pnpm run test:watch",
+    "test:e2e": "cd tests && pnpm run test:e2e",
+    "test:perf": "cd tests && pnpm run test:perf"
   }
-}
+}