@xmov/avatar 2.0.0-alpha.38

package/dist/types/frame-data.d.ts

@@ -0,0 +1,107 @@
+import type { IWidget } from "./event";
+import { IBRAnimationFrameData_NN } from "../utils/DataInterface";
+export declare enum EFrameDataType {
+    AUDIO = "tts_audio",
+    BODY = "body_data",
+    FACE = "face_data",
+    EVENT = "event_data",
+    AA_FRAME = "aa_frame",
+    SYNC_FRAME = "sync_frame"
+}
+export declare const FRAME_SOURCE_SOURCE = "xmov_avatar_js_sdk";
+/** socket.io 原数据格式 */
+export interface IRawBaseFrameData {
+    sf: number;
+    ef: number;
+}
+export interface IRawBodyFrameData extends IRawBaseFrameData {
+    hfd: boolean;
+    aef: number;
+    asf: number;
+    id: number;
+    n: string;
+    s: string;
+    body_id: number;
+    x_offset: Uint8Array;
+}
+/**
+ * tts下发的face数据
+ */
+export interface ITtsFaceFrameData {
+    body_id: number;
+    bsw: number[];
+    ef: number;
+    htmi?: number[];
+    htpw?: number[];
+    id: number;
+    mjt?: number[][];
+    s: string;
+    sf: number;
+    cs: string;
+    ttmi?: number[];
+    ttpw?: number[];
+    ms: {
+        index: number;
+        weights: number[];
+    }[];
+    js: {
+        translate: number[];
+        rotate: number[];
+    }[];
+    face_frame_type: number;
+    asf?: number;
+    aef?: number;
+    n?: string;
+}
+export interface IRawFaceFrameData extends IRawBaseFrameData {
+    FaceFrameData: IBRAnimationFrameData_NN;
+    frameIndex: number;
+    state: string;
+    id: number;
+    body_id: number;
+    cs: string;
+    face_frame_type: number;
+}
+export interface IRawAudioFrameData extends IRawBaseFrameData {
+    ad: any;
+    id: number;
+    sid: number;
+    multi_turn_conversation_id: string;
+}
+export interface IRawWidgetData {
+    type: string;
+    data?: IWidget;
+    text?: string;
+    speech_id?: number;
+    client_speak_id?: number;
+}
+export interface IRawEventFrameData extends IRawBaseFrameData {
+    id: number;
+    s: string;
+    e: IRawWidgetData[];
+}
+export type IRawFrameData = IRawBodyFrameData | ITtsFaceFrameData | IRawFaceFrameData | IRawAudioFrameData | IRawEventFrameData;
+export interface SYNC_FRAME_DATA {
+    server_time: number;
+    client_time: number;
+    server_client_frame: number;
+    source: string;
+}
+export type bodyFile = {
+    name: string;
+    id: number;
+    frameState: string;
+    start: number;
+    end: number;
+    data: ArrayBuffer;
+    hfd: boolean;
+    startFrameIndex: number;
+    endFrameIndex: number;
+    body_id: number;
+    x_offset: any;
+};
+export interface StateChangeInfo {
+    state: string;
+    params: object;
+    start_frame: number;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,187 @@
+import type XmovAvatar from "../index";
+import type { IRawWidgetData } from "./frame-data";
+import type { SDKError } from "./error";
+import type { TDownloadProgress } from "../modules/ResourceManager";
+import { FPSStats } from "../utils/fpsTracker";
+export { ERROR_CODE_MAP, ERROR_NAME_MAP } from './error';
+export type { CapabilitySeverity, CapabilityName, ICapabilityCheckItem, ICapabilityCheckReport, } from './capability';
+export declare enum AvatarStatus {
+    online = 0,
+    offline = 1,
+    network_on = 2,
+    network_off = 3,
+    close = 4,
+    visible = 5,
+    invisible = 6,
+    stopped = 7
+}
+/**
+ * 渲染状态枚举
+ * 用于表示渲染器的状态，与数字人状态（AvatarStatus）分离
+ */
+export declare enum RenderState {
+    init = "init",
+    rendering = "rendering",
+    pausing = "pausing",
+    paused = "paused",
+    resumed = "resumed",
+    stopped = "stopped"
+}
+/**
+ * 网络情况
+ * @params downlink 下载速率（Mbps）
+ * @params rtt 延迟（毫秒）
+ */
+export interface INetworkInfo {
+    downlink: number;
+    rtt: number;
+    networkStatus: boolean;
+}
+export declare enum InitModel {
+    normal = "normal",
+    invisible = "invisible"
+}
+export interface IInitParams {
+    scaleDownBy?: any;
+    useAlphaMask?: any;
+    initModel?: InitModel;
+    onDownloadProgress: TDownloadProgress;
+}
+export interface IAvatarOptions {
+    sdkInstance?: XmovAvatar;
+    containerId: string;
+    container?: HTMLElement;
+    appId: string;
+    appSecret: string;
+    gatewayServer: string;
+    tag?: string;
+    gateway_type?: string;
+    asr_id?: number;
+    llm_id?: number;
+    session_speak_req_id?: 0 | 1;
+    headers?: Record<string, string>;
+    cacheServer?: string;
+    env?: string;
+    config?: any;
+    hardwareAcceleration?: string;
+    enableClientInterrupt?: boolean;
+    enableLogger?: boolean;
+    enableDebugger?: boolean;
+    audioOnlyMode?: boolean;
+    renderMode?: 'client' | 'server';
+    streamingServer?: string;
+    useAlphaMask?: boolean;
+    scaleDownBy?: number;
+    onMessage: (error: SDKError) => void;
+    onStartSessionWarning?: (message: Object) => void;
+    onAAFrameHandle?: (data: any) => void;
+    onNetworkInfo?(networkInfo: INetworkInfo): void;
+    onWidgetEvent?(data: IRawWidgetData): void;
+    proxyWidget?: {
+        [key: string]: (data: any) => void;
+    };
+    onStateChange?(state: string): void;
+    onStateRenderChange?(state: string, duration: number): void;
+    onSpeakStateChange?(state: string, client_speak_id: string | number): void;
+    onRenderChange?(state: RenderState): void;
+    onVoiceStateChange?(state: string, duration?: number, client_speak_id?: string | number): void;
+    onStatusChange?(status: AvatarStatus): void;
+    onWalkStateChange?(state: string): void;
+    onFPSUpdate?(stats: FPSStats): void;
+    /**
+     * 数字人音频实时播放数据回调
+     * - MSE/WebM 模式（raw_audio=false）：通过 AudioWorklet + WebCodecs 捕获和编码
+     * - PCM 模式（raw_audio=true）：通过 capture worklet + WebCodecs/MediaRecorder 编码
+     * 两种模式输出格式完全一致（WebM/Opus），业务侧无需区分
+     */
+    onAudioPlaybackData?(data: IAudioPlaybackData): void;
+    /**
+     * 每帧数据回调
+     * 返回当前帧的 face + body 原始数据（帧号、body_id 等）
+     */
+    onFrameDataUpdate?(data: IFrameDataUpdate): void;
+}
+/**
+ * 音频播放数据回调参数（farend 格式）
+ * 用于 ASR 回声消除（AEC），由 Agent 封装为 AU v1 farend Binary 帧
+ */
+export interface IAudioPlaybackData {
+    data: ArrayBuffer;
+    codec: string;
+    isFirstChunk: boolean;
+    sampleRate: number;
+    samples: number;
+    timestamp: number;
+    speech_id: number;
+}
+/**
+ * 帧数据回调参数
+ * 用于返回每一帧的 face + body 原始数据（不包含渲染数据）
+ */
+export interface IFrameDataUpdate {
+    /** 客户端帧号 */
+    frameIndex: number;
+    /** body 数据 */
+    body: {
+        /** body_id */
+        body_id: number;
+        /** 视频名称 */
+        name: string;
+        /** 视频内帧号（相对于视频起始的帧偏移） */
+        video_frame: number;
+        /** 起始帧号 */
+        sf: number;
+        /** 当前状态 */
+        state: string;
+    } | null;
+    /** face 数据（不包含骨骼渲染数据） */
+    face: {
+        /** body_id */
+        body_id: number;
+        /** 起始帧号 */
+        sf: number;
+        /** 结束帧号 */
+        ef: number;
+        /** 状态 */
+        state: string;
+        /** face 帧类型：0=原始数据，1=实时数据 */
+        face_frame_type: number;
+    } | null;
+}
+export interface DeviceInfo {
+    device_id: string;
+    device_brand: string;
+    device_model: string;
+    os_version: string;
+    browser: string;
+    browser_version: string;
+    browser_ua: string;
+    sdk_version: string;
+    resolution: {
+        width: number;
+        height: number;
+    };
+    download_speed: number;
+    decode_speed: number;
+    render_speed: number;
+}
+export interface Layout {
+    container: {
+        size: number[];
+    };
+    avatar: {
+        v_align: string;
+        h_align: string;
+        scale: number | string;
+        offset_x: number;
+        offset_y: number;
+    };
+}
+export interface WalkConfig {
+    min_x_offset: number;
+    max_x_offset: number;
+    walk_points: {
+        [key: string]: number;
+    };
+    init_point?: number;
+}

package/dist/types/render.d.ts

@@ -0,0 +1,18 @@
+export interface IBackgroundRender {
+    render(): HTMLElement;
+}
+export interface IImgRender {
+    render(): HTMLElement;
+}
+export interface ITextRender {
+    render(): HTMLElement;
+}
+export interface IVideoRender {
+    render(): HTMLElement;
+}
+export interface I3DRender {
+    render(): HTMLCanvasElement;
+}
+export interface ISubtitleRender {
+    render(): HTMLElement;
+}

package/dist/utils/DataInterface.d.ts

@@ -0,0 +1,113 @@
+import * as GLMath from "./Math";
+export interface DataViewWithCustomOffset {
+    offset: number;
+    dataview: DataView;
+}
+declare const TensorDataTypeMap: {
+    B: Uint8ArrayConstructor;
+    b: Int8ArrayConstructor;
+    H: Uint16ArrayConstructor;
+    h: Int16ArrayConstructor;
+    I: Uint32ArrayConstructor;
+    i: Int32ArrayConstructor;
+    L: BigUint64ArrayConstructor;
+    l: BigInt64ArrayConstructor;
+    f: Float32ArrayConstructor;
+    d: Float64ArrayConstructor;
+};
+type ValueOf<T> = T[keyof T];
+export type TensorDataConstructorType = ValueOf<typeof TensorDataTypeMap>;
+export type TensorDataType = InstanceType<TensorDataConstructorType>;
+export declare class Tensor {
+    size: number[];
+    data: TensorDataType;
+    constructor(size: number[], data: TensorDataType);
+    itemSize(): number;
+    byteSize(): number;
+    static zeros(size: number[], dataType?: TensorDataConstructorType): Tensor;
+    part(...index: number[]): Tensor;
+    static deserialize(buffer: ArrayBuffer | DataViewWithCustomOffset): Tensor;
+}
+export declare class CameraConfig {
+    focalLength: number;
+    filmAperture: [number, number];
+    translation: GLMath.vec3;
+    rotation: GLMath.vec3;
+    getIntrinsicMatrix(resolution: [number, number]): GLMath.mat3;
+    getProjMatrix(resolution: [number, number], near?: number, far?: number): GLMath.mat4;
+    getExtrinsicMatrix(): GLMath.mat4;
+    static deserialize(buffer: ArrayBuffer | DataViewWithCustomOffset): CameraConfig;
+}
+export declare class RigidTransform {
+    translation: GLMath.vec3;
+    rotQuaternion: GLMath.vec4;
+    constructor(translation?: GLMath.vec3, rotQuaternion?: GLMath.vec4);
+    apply(x: GLMath.vec3 | RigidTransform): GLMath.vec3 | RigidTransform;
+    inv(): RigidTransform;
+    matrix(): GLMath.mat3;
+    homogeneous_matrix(): GLMath.mat4;
+    static deserialize(buffer: ArrayBuffer | DataViewWithCustomOffset): RigidTransform;
+}
+export interface JointInfo {
+    parent: number | null;
+    local_transform: RigidTransform;
+}
+export interface IBRMeshInfoSpec {
+    version: [number, number, number];
+    maxJointsPerVertex: number;
+    blendshapeIndices?: number[];
+    archivedItems?: unknown[];
+}
+export declare class IBRMeshInfo {
+    genMask: boolean;
+    vertices: Tensor;
+    opacity?: Tensor;
+    triangles: Tensor;
+    UVCoord: Tensor;
+    blendshapeIndices: number[];
+    blendshapes: Tensor;
+    jointIndex: Uint8Array;
+    jointWeight: Float32Array;
+    textureModels: {
+        data: Tensor;
+        scalingFactor?: Tensor;
+    }[];
+    constructor(buffer: ArrayBuffer | DataViewWithCustomOffset, spec: IBRMeshInfoSpec);
+}
+export declare class IBRMeshFrameInfo {
+    textureModelIndex: number;
+    texturePCAWeights: Float32Array;
+    constructor(textureModelIndex: number, texturePCAWeights: Float32Array);
+    static deserialize(buffer: ArrayBuffer | DataViewWithCustomOffset, char_data: IBRMeshInfo): IBRMeshFrameInfo;
+}
+export declare class IBRAnimationGeneratorCharInfo_NN {
+    cameraConfig: CameraConfig;
+    blendshapeCount: number;
+    mesh: IBRMeshInfo[];
+    skeleton: JointInfo[];
+    jointEvalOrder: number[];
+    movableJoints: number[];
+    maxJointsPerVertex: number;
+    constructor(buffer: ArrayBuffer | DataViewWithCustomOffset, spec?: {
+        blendshapeMap?: number[][];
+    });
+    evalSkeleton(): RigidTransform[];
+    evalSkeletonFromMovable(movableJointTransforms: RigidTransform[]): RigidTransform[];
+}
+export declare class IBRAnimationFrameData_NN {
+    mesh: IBRMeshFrameInfo[];
+    blendshapeWeights: Float32Array;
+    movableJointTransforms: RigidTransform[];
+    constructor();
+    static deserialize(buffer: ArrayBuffer | DataViewWithCustomOffset, char_data: IBRAnimationGeneratorCharInfo_NN, version: [number, number, number]): IBRAnimationFrameData_NN;
+    static interp(frame1: IBRAnimationFrameData_NN, frame2: IBRAnimationFrameData_NN, frameJointRef: IBRAnimationFrameData_NN, t: number, jointEvalOrder: [number, number][]): IBRAnimationFrameData_NN;
+}
+export declare function unpackIBRAnimation(buffer: ArrayBuffer | DataViewWithCustomOffset, char_data: IBRAnimationGeneratorCharInfo_NN): IBRAnimationFrameData_NN[];
+export declare class TextureFloat_3D {
+    size: [number, number, number, number];
+    data: Float32Array;
+    constructor(buffer: ArrayBuffer | DataViewWithCustomOffset);
+}
+export declare function transformMJT(mjt: number[][]): RigidTransform[];
+export declare function formatMJT(a1: number[], a2: number[]): RigidTransform;
+export {};

package/dist/utils/GLDevice.d.ts

@@ -0,0 +1,46 @@
+export declare class GLDevice {
+    private _ElementTypeMap_JS2GL;
+    private _FormatTypeMap_Ext2Int;
+    private _FormatTypeMap_Ext2Str;
+    private shaderStage;
+    private running;
+    private syncMedia;
+    private syncMediaTime;
+    private _lost_context_sim;
+    canvas: HTMLCanvasElement;
+    gl: WebGL2RenderingContext;
+    frameID: number | null;
+    cbRender: (device: GLDevice) => void;
+    private _isDestroyed;
+    private _onContextLost;
+    private _onContextRestored;
+    private _onContextCreationError;
+    constructor(canvas: HTMLCanvasElement);
+    compileShaderProgram(shaders: {
+        readonly [index: string]: string;
+    }): WebGLProgram;
+    getShaderProgramUniformLocation(program: WebGLProgram, attribNames: Array<string>): {
+        [index: string]: WebGLUniformLocation;
+    };
+    getShaderProgramUniformBlockLocation(program: WebGLProgram, attribNames: Array<string>): {
+        [index: string]: GLint;
+    };
+    getShaderProgramAttribLocation(program: WebGLProgram, attribNames: Array<string>): {
+        [index: string]: GLint;
+    };
+    getGLArrayElementType(arr: ArrayBufferView<ArrayBufferLike>): number | null;
+    getGLTexInternalFormat(externalFormat: number, elementType: number): number | null;
+    texImage2D(target: number, level: number, width: number, height: number, format: number, srcData: ArrayBufferView<ArrayBufferLike>): void;
+    texImage3D(target: number, level: number, width: number, height: number, depth: number, format: number, srcData: ArrayBufferView<ArrayBufferLike>): void;
+    run(fn: (device: GLDevice) => void, syncMedia?: HTMLVideoElement): void;
+    refresh(): void;
+    getSyncMediaTime(): number | null;
+    stop(): void;
+    simulateContextFault(contextAvailable: boolean): void;
+    captureFrame(): {
+        width: number;
+        height: number;
+        data: Uint8ClampedArray;
+    };
+    destroy(): void;
+}

package/dist/utils/GLPipeline.d.ts

@@ -0,0 +1,84 @@
+import { GLDevice } from './GLDevice';
+import { IBRAnimationGeneratorCharInfo_NN, IBRAnimationFrameData_NN, TextureFloat_3D } from './DataInterface';
+import { vec3, mat3 } from './Math';
+export interface ScaleTranslate2D {
+    offsetX: number;
+    offsetY: number;
+    scaleX: number;
+    scaleY: number;
+}
+export interface GLPipelineCharData {
+    char: IBRAnimationGeneratorCharInfo_NN | null;
+    LUT: TextureFloat_3D | null;
+    transform: ScaleTranslate2D;
+    multisample: number | null;
+}
+export interface GLPipelineFrameData {
+    backgroundTexture: HTMLImageElement | HTMLVideoElement | null;
+    charBodyTexture: HTMLImageElement | HTMLVideoElement;
+    data: IBRAnimationFrameData_NN | null;
+    fx: {
+        [index: string]: unknown;
+    } | null;
+    onPostRender: (pipeline: GLPipeline) => GLPipelineFrameData | null;
+}
+export interface GLPipelineFXShadow {
+    refPos: vec3;
+    light: vec3;
+    lightType: "point" | "directional";
+    intensity: number;
+    blurRadius: number;
+    tint: vec3;
+}
+interface GLPipelineFXShadowGeometryInfo {
+    Mat_ShadowImage2World: mat3;
+    Mat_World2ObjImage: mat3;
+}
+export declare class GLPipeline {
+    readonly device: GLDevice;
+    private compat_features;
+    private charData;
+    private backgroundPipelineInfo;
+    private backgroundVAO;
+    private backgroundBuffers;
+    private backgroundTextures;
+    private backgroundTextureSrc;
+    private meshPipelineInfo;
+    private maskPipelineInfo;
+    private meshInfos;
+    private meshStatistics;
+    private FrameTexture_meshColor;
+    private FrameTexture_meshAlpha;
+    private LUTTexture;
+    private FrameBuffer_mesh;
+    private FrameBuffer_meshColor;
+    private FrameBuffer_meshAlpha;
+    private initSkeletonStatus;
+    private frameDataCallback;
+    private currentGamma;
+    private currentColorBalance;
+    private _ub_shadow_fx_data;
+    private _ub_rig_info_data;
+    private _ub_pca_info_data;
+    private first_webgl_render;
+    private sendSdkPoint;
+    private assembleBackgroundPipeline;
+    assembleMeshPipelines(data: GLPipelineCharData): void;
+    private getProjMat;
+    private initFrame;
+    private renderBackground;
+    private renderMesh;
+    constructor(device: GLDevice, sendSdkPoint: (point: string, data: any) => void);
+    reinitialize(): void;
+    setSyncMedia(syncMedia?: HTMLVideoElement): void;
+    setCharData(charData?: GLPipelineCharData): void;
+    setFrameDataCallback(cb: () => GLPipelineFrameData | null): void;
+    setGamma(gammaR: number, gammaG: number, gammaB: number): void;
+    setColorBalance(rc: number, gm: number, by: number): void;
+    getBillboardTransform2D(pos_orig: vec3, pos_new: vec3): ScaleTranslate2D;
+    getBillboardShadowGeometryInfo(pos_orig: vec3, light: vec3, point_src: boolean): GLPipelineFXShadowGeometryInfo;
+    private render;
+    renderFrame(frame: GLPipelineFrameData): void;
+    destroy(): void;
+}
+export {};

package/dist/utils/GLPipelineDebugTools.d.ts

@@ -0,0 +1,5 @@
+import { GLPipelineCharData } from './GLPipeline';
+import { IBRAnimationFrameData_NN } from './DataInterface';
+export declare function getVertices(data: GLPipelineCharData, frame_data: IBRAnimationFrameData_NN): number[][][];
+export declare function getPCATextures(data: GLPipelineCharData, frame_data: IBRAnimationFrameData_NN): ImageData[];
+export declare function getWavefrontObjFromVertices(data: GLPipelineCharData, vertices: number[][][]): string;

package/dist/utils/Math.d.ts

@@ -0,0 +1,21 @@
+export type vec3 = [number, number, number];
+export type vec4 = [number, number, number, number];
+export type mat3 = [vec3, vec3, vec3];
+export type mat4 = [vec4, vec4, vec4, vec4];
+export declare function length(vec: number[]): number;
+export declare function normalize(vec: number[]): number[];
+export declare function mvmul(lhs: number[][], rhs: number[]): number[];
+export declare function mmul(lhs: number[][], rhs: number[][]): number[][];
+export declare function transpose(mat: number[][]): number[][];
+export declare function identity(size: number): number[][];
+export declare function det3(mat: mat3): number;
+export declare function inv3(mat: mat3): mat3;
+export declare function inv4(mat: mat4): mat4;
+export declare function quaternion_conj(q: vec4): vec4;
+export declare function quaternion_mul(lhs: vec4, rhs: vec4): vec4;
+export declare function quaternion_to_mat(q: vec4): mat3;
+export declare function mat_to_quaternion(mat: mat3 | mat4): vec4;
+export declare function GivensTransform(mat: number[][], row0: number, row1: number, angle: number): void;
+export declare function Euler_to_mat(angles: [number, number, number], order?: string): mat3;
+export declare function make_homogeneous(mat: mat3, translation: vec3): mat4;
+export declare function flatten(mat: number[][]): number[];

package/dist/utils/__tests__/capability-checker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/audio-session.d.ts

@@ -0,0 +1,11 @@
+export type WebAudioSessionType = "playback" | "play-and-record";
+type WebAudioPlaybackSessionRestoredListener = () => void;
+/**
+ * Keep Web Audio audible through the iOS Ring/Silent switch. Do not override
+ * a play-and-record session that may belong to an active microphone track.
+ */
+export declare function configureWebAudioPlaybackSession(target?: Navigator): boolean;
+export declare function beginWebAudioCaptureSession(target?: Navigator): boolean;
+export declare function subscribeWebAudioPlaybackSessionRestored(listener: WebAudioPlaybackSessionRestoredListener, target?: Navigator): () => void;
+export declare function endWebAudioCaptureSession(target?: Navigator): boolean;
+export {};

package/dist/utils/audio.d.ts

@@ -0,0 +1 @@
+export declare function pcmToWav(pcmData: Uint8Array): ArrayBufferLike;

package/dist/utils/capability-checker.d.ts

@@ -0,0 +1,23 @@
+import type { ICapabilityCheckReport } from '../types/capability';
+/**
+ * 同步检查所有浏览器能力（用于 constructor 快速校验）
+ *
+ * 检查项：
+ * - secureContext：安全上下文（HTTPS / localhost）
+ * - webgl2：WebGL2 渲染能力
+ * - audio：音频播放能力（PCM 或 MSE 任一可用即可）
+ * - webcodecs：WebCodecs API 存在性
+ * - worker：Web Worker 支持
+ *
+ * 音频检查逻辑：SDK 有两种音频播放器（PCM 和 MSE），只需其中一种可用即可
+ * - PCM 播放器依赖：AudioContext + AudioWorkletNode
+ * - MSE 播放器依赖：MediaSource
+ * - 两者都不可用时，音频能力检查失败
+ */
+export declare function checkCapabilitySync(audioOnlyMode?: boolean): ICapabilityCheckReport;
+/**
+ * 异步检查所有浏览器能力（详细版，用于 init 阶段详细探测）
+ *
+ * 包含更详细的编解码器探测和 Worker 执行测试
+ */
+export declare function checkCapability(audioOnlyMode?: boolean): Promise<ICapabilityCheckReport>;

package/dist/utils/encodeToken.d.ts

@@ -0,0 +1,7 @@
+export interface Headers {
+    [key: string]: string;
+}
+export declare function headersNeedSign(ak: string, sk: string, method: string, url: string, data: Record<string, any>): {
+    headers: Headers;
+    data: Record<string, any>;
+};

package/dist/utils/face.d.ts

@@ -0,0 +1 @@
+export declare const translateBufferToFloatArray: (buf: any) => number[];

package/dist/utils/float32-decoder.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 服务端 floats_to_scaled_int16_bytes 反向函数：Base64 → float32 数组
+ * 核心逻辑：Base64→int16字节流→int16数值（兼容round+clip）→÷0x7FFF→float32
+ * @param base64Str 服务端返回的 Base64 编码字符串
+ * @returns float32 精度的浮点数数组（与服务端原始 floats 一致）
+ */
+export function scaledInt16BytesToFloat32(base64Str: any): number[];
+/**
+ * 可选：带平滑滤波的版本（解决“脸色闪”问题，优化视觉效果）
+ * @param base64Str 服务端 Base64 字符串
+ * @param lastData 上一帧数据（用于平滑）
+ * @param alpha 平滑系数（0~1，默认0.2，越大响应越快，越小越平滑）
+ * @returns 平滑后的 float32 数组
+ */
+export function scaledInt16BytesToSmoothFloat32(base64Str: any, lastData?: any[], alpha?: number): number[];
+/**
+ * 解析后端传输的 float32 字节流为普通数组
+ * @param {string|ArrayBuffer|Uint8Array} bytes - 后端传来的二进制数据（注意格式兼容）
+ * @returns {number[]} 解析后的浮点数组（空数据返回空数组）
+ */
+/**
+ * 从 Uint8Array 解析出 float32 数组（核心修复版）
+ * @param {Uint8Array} uint8Arr - 后端传来的 Uint8Array 原始字节
+ * @returns {number[]} 解析后的浮点数组
+ */
+export function parseUint8ToFloat32(uint8Arr: Uint8Array): number[];