@spatialwalk/avatarkit 1.0.0-beta.6 → 1.0.0-beta.61

package/dist/config/app-config.d.ts

@@ -2,11 +2,7 @@ export declare const APP_CONFIG: {
     testEnv: boolean;
     readonly debug: boolean;
     rendering: {
-        /**
-         * 排序模式
-         * - 'balance': 性能优先，首帧排序后复用（默认）
-         * - 'quality': 质量优先，每帧重新排序
-         */
+
         sortMode: "balance" | "quality";
     };
     camera: {
@@ -41,4 +37,3 @@ export declare const APP_CONFIG: {
         enablePerformanceMetrics: boolean;
     };
 };
-//# sourceMappingURL=app-config.d.ts.map

package/dist/config/constants.d.ts

@@ -1,29 +1,15 @@
 import { Environment } from '../types';
-export declare const CLS_TRACK_EVENTS: boolean;
-/**
- * 获取 CLS 配置（需要传入环境）
- */
-export declare function getCLSConfig(environment: Environment): {
-    endpoint: string;
-    topicId: string;
-    secretId: string;
-    secretKey: string;
-    token: string;
-};
-export declare const CLS_CONFIG: {
-    endpoint: string;
-    topicId: string;
-    secretId: string;
-    secretKey: string;
-    token: string;
+export declare const POSTHOG_HOST_CN: string;
+export declare const POSTHOG_API_KEY_CN: string;
+export declare const POSTHOG_HOST_INTL: string;
+export declare const POSTHOG_API_KEY_INTL: string;
+export declare const POSTHOG_TRACK_EVENTS: boolean;
+export declare const POSTHOG_PROJECT_NAME: string;
+export declare function getPostHogConfig(_environment: Environment): {
+    host: string;
+    apiKey: string;
+    disableCompression: boolean;
 };
 export declare const ENV_TEST: boolean;
-/**
- * Comprehensive debug mode check
- * Returns true if:
- * - VITE_ENV_TEST is 'true', OR
- * - Running in DEV mode, OR
- * - URL has debug=1 parameter
- */
+
 export declare function isDebugMode(): boolean;
-//# sourceMappingURL=constants.d.ts.map

package/dist/config/sdk-config-loader.d.ts

@@ -1,12 +1,7 @@
 import { Environment } from '../types';
-/**
- * 从远程配置接口获取 SDK 配置
- * @param version SDK 版本号
- * @returns 解析后的配置映射
- */
+
+export declare const DEFAULT_SDK_CONFIG: Partial<Record<Environment, string>>;
+
 export declare function fetchSdkConfig(version: string): Promise<Partial<Record<Environment, string>>>;
-/**
- * 清除配置缓存（用于测试或重新加载）
- */
+
 export declare function clearSdkConfigCache(): void;
-//# sourceMappingURL=sdk-config-loader.d.ts.map

package/dist/core/Avatar.d.ts

@@ -4,20 +4,6 @@ export declare class Avatar {
     readonly id: string;
     private characterMeta;
     private resources;
-    /**
-     * 构造函数（内部使用）
-     * @param id 数字人 ID
-     * @param characterMeta 角色元数据
-     * @param resources 资源数据
-     */
     constructor(id: string, characterMeta: CharacterMeta, resources: PreloadResult);
-    /**
-     * 获取角色元数据（内部使用）
-     */
     getCharacterMeta(): CharacterMeta;
-    /**
-     * 获取资源数据（内部使用）
-     */
-    getResources(): PreloadResult;
 }
-//# sourceMappingURL=Avatar.d.ts.map

package/dist/core/AvatarController.d.ts

@@ -1,10 +1,10 @@
 import { Flame } from '../generated/driveningress/v1/driveningress';
 import { Avatar } from './Avatar';
 import { AnimationPlayer } from '../audio/AnimationPlayer';
-import { AvatarState, ConnectionState, AvatarPlaybackMode } from '../types';
+import { AvatarState, ConnectionState, DrivingServiceMode, ConversationState, PostProcessingConfig } from '../types';
 export declare class AvatarController {
     private networkLayer?;
-    readonly playbackMode: AvatarPlaybackMode;
+    private readonly playbackMode;
     protected avatar: Avatar;
     protected animationPlayer: AnimationPlayer | null;
     protected currentKeyframes: Flame[];
@@ -13,140 +13,68 @@ export declare class AvatarController {
         isLast: boolean;
     }>;
     protected isPlaying: boolean;
+    private isStartingPlayback;
     protected isConnected: boolean;
     protected currentState: AvatarState;
+    private currentConversationId;
+    private reqEnd;
     onConnectionState: ((state: ConnectionState) => void) | null;
-    onAvatarState: ((state: AvatarState) => void) | null;
+    onConversationState: ((state: ConversationState) => void) | null;
     onError: ((error: Error) => void) | null;
     private eventListeners;
     private renderCallback?;
-    private transitionCompleteCallback?;
+    private characterHandle;
+    private characterId;
+    private postProcessingConfig;
     private playbackLoopId;
     private lastRenderedFrameIndex;
+    private keyframesOffset;
+    private readonly MAX_KEYFRAMES;
+    private readonly KEYFRAMES_CLEANUP_THRESHOLD;
+    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?: {
-        playbackMode?: AvatarPlaybackMode;
+        playbackMode?: DrivingServiceMode;
     });
-    /**
-     * 获取 Avatar ID（供 NetworkLayer 使用）
-     */
-    getAvatarId(): string;
-    /**
-     * 获取播放状态（供 NetworkLayer 使用）
-     */
-    getIsPlaying(): boolean;
-    /**
-     * 设置连接状态（供 NetworkLayer 使用）
-     */
-    setConnected(connected: boolean): void;
-    /**
-     * 获取连接状态
-     */
-    get connected(): boolean;
-    /**
-     * 获取当前状态
-     */
-    get state(): AvatarState;
-    /**
-     * 获取动画播放器实例
-     * @internal
-     */
-    getAnimationPlayer(): AnimationPlayer | null;
-    /**
-     * 启动服务（仅网络模式）
-     */
+    getCurrentConversationId(): string | null;
     start(): Promise<void>;
-    /**
-     * 发送音频到服务器（仅网络模式）
-     * 同时缓存到数据层用于播放
-     */
-    send(audioData: ArrayBuffer, end?: boolean): void;
-    /**
-     * 关闭服务（仅网络模式）
-     */
+    send(audioData: ArrayBuffer, end?: boolean): string | null;
     close(): void;
-    /**
-     * 开始播放（外部数据模式）
-     * 必须先调用此方法，传入初始数据开始播放
-     */
-    play(initialAudioChunks?: Array<{
-        data: Uint8Array;
-        isLast: boolean;
-    }>, initialKeyframes?: Flame[]): Promise<void>;
-    /**
-     * 发送音频数据（外部数据模式）
-     * 在 play() 之后流式添加剩余音频数据
-     */
-    sendAudioChunk(data: Uint8Array, isLast?: boolean): void;
-    /**
-     * 发送动画关键帧（外部数据模式或网络模式）
-     * 在 play() 之后流式添加剩余动画数据
-     */
-    sendKeyframes(keyframes: Flame[]): void;
-    /**
-     * 打断当前播放
-     */
+    yieldAudioData(data: Uint8Array, isLast?: boolean): string | null;
+    yieldFramesData(keyframesDataArray: (Uint8Array | ArrayBuffer)[], conversationId: string): void;
+    yieldKeyframes(keyframes: Flame[], conversationId: string): void;
+    pause(): void;
+    resume(): Promise<void>;
     interrupt(): void;
-    /**
-     * 清理所有数据和资源
-     */
     clear(): void;
-    /**
-     * 开始流式播放（内部方法，由 NetworkLayer 或 play() 调用）
-     */
-    startStreamingPlayback(): Promise<void>;
-    /**
-     * 设置渲染回调（由 AvatarView 调用）
-     */
-    setRenderCallback(callback: (splatData: Float32Array, frameIndex: number) => void): void;
-    /**
-     * 设置过渡完成回调（由 AvatarView 调用）
-     */
-    setTransitionCompleteCallback(callback: () => void): void;
-    /**
-     * 过渡完成通知（由 AvatarView 调用）
-     */
-    onTransitionComplete(): void;
-    /**
-     * 为 AvatarView 提供注册内部事件的接口
-     * @internal
-     */
-    setupInternalEventListeners(callbacks: {
-        onKeyframesUpdate?: (keyframes: Flame[]) => void;
-        onStartRendering?: () => void;
-        onStopRendering?: () => void;
-        onInterrupt?: () => void;
-    }): void;
-    /**
-     * 开始流式播放（内部实现）
-     */
+    private generateAndLogNewConversationId;
+    private clearPlaybackData;
+    private resetConversationIdState;
+    private getEffectiveConversationId;
+    getPointCount(): number | null;
+    setPostProcessingConfig(config: PostProcessingConfig | null): void;
+    private setEyeTrackingConfig;
+    private rerenderCurrentFrame;
+    setVolume(volume: number): void;
+    getVolume(): number;
     private startStreamingPlaybackInternal;
-    /**
-     * 播放循环：根据音频时间计算动画帧，通知渲染层渲染
-     */
     private startPlaybackLoop;
-    /**
-     * 停止播放循环
-     */
     private stopPlaybackLoop;
-    /**
-     * 停止播放
-     */
+    private enableAudioOnlyMode;
+    private startAudioOnlyPlayback;
+    private startAudioMonitoringLoop;
     protected stopPlayback(): void;
-    /**
-     * 清理播放器
-     */
     protected cleanupPlayers(): void;
-    /**
-     * 添加音频块到缓冲区
-     */
     private addAudioChunkToBuffer;
-    /**
-     * 事件系统
-     */
     private registerEventListener;
-    /**
-     * 触发事件
-     */
     protected emit(event: string, data?: any): void;
+    private applyPostProcessingToParams;
+    private reportDrivingServiceLatency;
 }
-//# sourceMappingURL=AvatarController.d.ts.map

package/dist/core/AvatarDownloader.d.ts

@@ -1,100 +1,5 @@
-import { CharacterMeta, PreloadCameraSettings } from '../types/character';
-import { CharacterSettings } from '../types/character-settings';
-interface ProgressInfo {
-    stage: string;
-    filename: string;
-    loaded: number;
-    total: number;
-    progress: number;
-}
-type ProgressCallback = (info: ProgressInfo) => void;
-interface TemplateResources {
-    [key: string]: ArrayBuffer;
-}
-interface FlameResources {
-    flameModel?: {
-        remote?: string;
-    };
-    flameTemplate?: {
-        remote?: string;
-    };
-    teethPb?: {
-        remote?: string;
-    };
-    teethNpz?: {
-        remote?: string;
-    };
-}
-interface CharacterDataResult {
-    shape: ArrayBuffer;
-    pointCloud: ArrayBuffer;
-    idleAnimation?: ArrayBuffer;
-    monoAnimation?: ArrayBuffer;
-    monoAudioUrl?: string;
-}
-export interface PreloadResult {
-    templateResources: TemplateResources;
-    characterData: CharacterDataResult;
-    preloadCameraSettings?: PreloadCameraSettings;
-    characterSettings?: CharacterSettings;
-}
 export declare class AvatarDownloader {
     private baseAssetsPath;
-    private characterAssets;
     constructor(baseAssetsPath?: string);
-    /**
-     * Load template resources from CharacterMeta flame CDN URLs
-     * Falls back to global CDN config if not provided by API
-     */
-    loadTemplateResources(flameResources?: FlameResources, progressCallback?: ProgressCallback | null): Promise<TemplateResources>;
-    /**
-     * Load global FLAME template resources from CDN
-     * Uses centralized FLAME CDN config (shared across all characters)
-     */
-    private loadGlobalFlameResources;
-    /**
-     * Load camera settings from CharacterMeta (optional)
-     */
-    loadCameraSettings(characterMeta: CharacterMeta): Promise<PreloadCameraSettings | undefined>;
-    /**
-     * Load character data from CharacterMeta (iOS compatible)
-     */
-    loadCharacterData(characterMeta: CharacterMeta, options?: {
-        loadMonologue?: boolean;
-        progressCallback?: ProgressCallback | null;
-    }): Promise<CharacterDataResult>;
-    /**
-     * Preload all resources (template + character data + camera info + settings)
-     */
-    preloadResources(characterMeta: CharacterMeta, options?: {
-        loadMonologue?: boolean;
-        progressCallback?: ProgressCallback | null;
-    }): Promise<PreloadResult>;
-    /**
-     * Get loaded character asset by key
-     */
-    getCharacterAsset(key: string): ArrayBuffer | undefined;
-    /**
-     * Clear cached assets
-     */
-    clear(): void;
-    /**
-     * Get Main App API Client (enjoi.spatialwalk.top)
-     * Used for: character list, auth, customization, etc.
-     */
-    private getMainAppClient;
-    /**
-     * Get SPAvatarKit SDK API Client (api.spatialwalk.top)
-     * Used for: character details and resource URLs (public endpoints, no auth required)
-     */
     private getSdkApiClient;
-    /**
-     * Get single character by ID from SPAvatarKit SDK API (v2, iOS compatible)
-     * Domain: api.spatialwalk.top
-     * Auth: Public endpoint, no authentication required
-     * Returns CharacterMeta with nested resource structure
-     */
-    getCharacterById(characterId: string): Promise<CharacterMeta>;
 }
-export {};
-//# sourceMappingURL=AvatarDownloader.d.ts.map

package/dist/core/AvatarManager.d.ts

@@ -3,24 +3,16 @@ import { Avatar } from './Avatar';
 export declare class AvatarManager {
     private static _instance;
     private avatarDownloader;
-    private _templateInitialized;
-    /**
-     * 通过全局单例来访问
-     */
+    private avatarCache;
+    private loadingPromises;
+    private downloadQueue;
+    private isDownloading;
     static get shared(): AvatarManager;
-    /**
-     * 加载数字人
-     * @param id 数字人 ID
-     * @param onProgress 进度回调
-     * @param options 加载选项
-     * @returns Promise<Avatar>
-     */
-    load(id: string, onProgress?: (progress: LoadProgressInfo) => void, options?: {
-        enableMonologue?: boolean;
-    }): Promise<Avatar>;
-    /**
-     * 清理资源加载器缓存
-     */
+    load(id: string, onProgress?: (progress: LoadProgressInfo) => void): Promise<Avatar>;
+    private processDownloadQueue;
+    private doLoad;
+    retrieve(id: string): Avatar | undefined;
+    clear(id: string): void;
+    clearAll(): void;
     clearCache(): void;
 }
-//# sourceMappingURL=AvatarManager.d.ts.map

package/dist/core/AvatarSDK.d.ts

@@ -0,0 +1,21 @@
+import { Configuration } from '../types';
+export declare class AvatarSDK {
+    private static _isInitialized;
+    private static _configuration;
+    private static readonly _version;
+    private static _avatarCore;
+    private static _dynamicSdkConfig;
+    static initialize(appId: string, configuration: Configuration): Promise<void>;
+    private static initializeWASMModule;
+    private static initializeTemplateResources;
+    static setSessionToken(token: string): void;
+    static setUserId(userId: string): void;
+    static get isInitialized(): boolean;
+    static get appId(): string | null;
+    static get configuration(): Configuration | null;
+    static get sessionToken(): string | null;
+    static get userId(): string | null;
+    static get version(): string;
+    static cleanup(): void;
+    private static _fetchSdkConfig;
+}

package/dist/core/AvatarView.d.ts

@@ -1,156 +1,80 @@
-import { CameraConfig, RenderPerformanceStats, AvatarViewOptions, AvatarPlaybackMode } from '../types';
+import { Flame } from '../generated/driveningress/v1/driveningress';
 import { Avatar } from './Avatar';
 import { AvatarController } from './AvatarController';
 export declare class AvatarView {
     private readonly avatarController;
-    readonly playbackMode: AvatarPlaybackMode;
     private readonly avatar;
+    onFirstRendering?: () => void;
     private canvas;
     private renderSystem;
     private isInitialized;
     private cameraConfig;
-    private isRealtimePlaying;
+    private renderingState;
     private currentKeyframes;
     private lastRenderedFrameIndex;
     private lastRealtimeProtoFrame;
-    private idleResumeIndexPending;
     private idleAnimationLoopId;
     private realtimeAnimationLoopId;
     private resizeObserver;
     private onWindowResize;
+    private frameCount;
+    private lastFpsUpdate;
+    private currentFPS;
     private transitionKeyframes;
-    private isTransitioning;
     private transitionStartTime;
     private readonly transitionDurationMs;
-    private endToIdleAfterTransition;
     private cachedIdleFirstFrame;
     private idleCurrentFrameIndex;
-    /**
-     * 对齐两端 Flame 维度：标量统一长度，expression 取最大长度并零填充
-     */
+    private characterHandle;
+    private characterId;
+    private isPureRenderingMode;
+    private avatarActiveTimer;
+    private readonly AVATAR_ACTIVE_INTERVAL;
     private alignFlamePair;
-    /**
-     * 判断是否为空 Flame（用于跳过 isLast=true 的哨兵帧）
-     */
-    private isEmptyFlame;
-    /**
-     * 生成并对齐过渡帧，确保首尾帧与起止帧完全一致
-     */
     private generateAndAlignTransitionFrames;
-    /**
-     * 获取缓存的 Idle 首帧，如果未缓存则获取并缓存
-     */
     private getCachedIdleFirstFrame;
-    /**
-     * 构造函数
-     * 创建统一的 AvatarController，内部根据配置自动组合网络层
-     */
-    constructor(avatar: Avatar, options?: AvatarViewOptions);
-    /**
-     * 获取控制器（公共接口）
-     */
+    constructor(avatar: Avatar, container: HTMLElement);
     get controller(): AvatarController;
-    /**
-     * 创建canvas元素
-     */
     private createCanvas;
-    /**
-     * 获取canvas元素（供外部访问）
-     */
-    getCanvas(): HTMLCanvasElement;
-    /**
-     * 初始化视图系统
-     */
     private initializeView;
-    /**
-     * 初始化渲染系统
-     */
     private initializeRenderSystem;
-    /**
-     * 获取默认相机配置
-     */
     private getDefaultCameraConfig;
-    /**
-     * 根据资源解析最终的相机配置，优先使用角色设置，其次 camera.json
-     */
     private resolveCameraConfig;
-    /**
-     * 从角色设置中推导相机配置
-     */
     private deriveCameraConfigFromSettings;
-    /**
-     * 渲染第一帧
-     */
     private renderFirstFrame;
-    /**
-     * 开始idle动画循环
-     */
+    private updateFPS;
+    private initFPS;
     private startIdleAnimationLoop;
-    /**
-     * 开始实时对话动画循环
-     */
     private startRealtimeAnimationLoop;
-    /**
-     * 停止idle动画循环
-     */
     private stopIdleAnimationLoop;
-    /**
-     * 停止实时对话动画循环
-     */
     private stopRealtimeAnimationLoop;
-    /**
-     * 停止所有动画循环
-     */
     private stopAllAnimationLoops;
-    /**
-     * 渲染实时帧（由播放层回调调用）
-     */
     private renderRealtimeFrame;
-    /**
-     * 过渡完成回调（通知播放层启动音频）
-     */
-    private onTransitionComplete;
-    /**
-     * 处理打断
-     */
+    private setState;
+    private get isRealtimePlaying();
+    private get isTransitioning();
+    private get endToIdleAfterTransition();
     private handleInterrupt;
-    /**
-     * 设置 AvatarController 事件监听器
-     */
     private setupControllerEventListeners;
-    /**
-     * 准备实时渲染（生成 Idle -> Speaking 过渡）
-     */
     private prepareRealtimeRendering;
-    /**
-     * 开始实时渲染循环
-     */
     private startRealtimeRendering;
-    /**
-     * 停止实时对话渲染
-     */
     private stopRealtimeRendering;
-    /**
-     * 清理视图资源
-     * 关闭 avatarController 并清理所有相关资源
-     */
     dispose(): void;
-    /**
-     * 获取相机配置
-     */
-    getCameraConfig(): CameraConfig | null;
-    /**
-     * 更新相机配置
-     */
-    updateCameraConfig(cameraConfig: CameraConfig): void;
-    /**
-     * 处理尺寸变化：通知渲染系统更新视口与投影
-     */
+    renderFlame(flame: Flame, enableIdleRendering?: boolean): Promise<void>;
+    generateTransitionFromIdle(toFlame: Flame, frameCount: number): Promise<Flame[]>;
+    private rerenderCurrentFrameWithNewCamera;
     private handleResize;
-    /**
-     * 获取渲染性能统计
-     * @returns 渲染性能统计数据，如果渲染系统未初始化则返回 null
-     */
-    getPerformanceStats(): RenderPerformanceStats | null;
+    get transform(): {
+        x: number;
+        y: number;
+        scale: number;
+    };
+    set transform(value: {
+        x: number;
+        y: number;
+        scale: number;
+    });
+    private reportAvatarActive;
+    private startAvatarActiveHeartbeat;
+    private stopAvatarActiveHeartbeat;
 }
-//# sourceMappingURL=AvatarView.d.ts.map