@spatialwalk/avatarkit 1.0.0-beta.39 → 1.0.0-beta.40

package/dist/withJoi/src/utils/model-settings-utils.d.ts

@@ -0,0 +1,29 @@
+export interface PostprocessParams {
+    eyeBlink: number;
+    expressionWeight: number;
+    neckPose: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    neckPoseWeight: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    jawPose: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    jawPoseWeight: number;
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+
+export declare function loadPostprocessFromModelSettings(rawModelSettings: unknown, postprocess: PostprocessParams): void;
+
+export declare function buildModelSettingsFromPostprocess(postprocess: PostprocessParams, originalModelSettings: Record<string, unknown> | null): Record<string, unknown>;

package/dist/withJoi/src/utils/nanoid.d.ts

@@ -0,0 +1 @@
+export declare function nanoid(size?: number): string;

package/dist/withJoi/src/utils/posthog-tracker.d.ts

@@ -0,0 +1,74 @@
+export type EventCategory = 'connection' | 'audio' | 'vad' | 'sync' | 'playback' | 'wasm' | 'rendering' | 'user_action' | 'performance';
+
+export declare const PostHogTracker: {
+    connection: {
+        connectStart: (characterId: string) => void;
+        connectSuccess: (characterId: string, durationMs: number) => void;
+        connectFailed: (characterId: string, error: string, retryCount?: number) => void;
+        reconnectAttempt: (retryCount: number) => void;
+        reconnectFailed: (retryCount: number, error: string) => void;
+        messageSendError: (messageType: string, error: string) => void;
+        messageDecodeError: (error: string) => void;
+        serverError: (errorInfo: {
+            reqId?: string;
+            code?: number;
+            reason?: string;
+        }, characterId?: string, connectionId?: string) => void;
+        stateChange: (oldState: string, newState: string) => void;
+    };
+    audio: {
+        deviceAccessRequest: (deviceType: "microphone" | "speaker") => void;
+        deviceAccessGranted: (deviceType: "microphone" | "speaker") => void;
+        deviceAccessDenied: (deviceType: "microphone" | "speaker", error: string) => void;
+        bufferUnderrun: (bufferSize: number) => void;
+        decodeError: (error: string) => void;
+        contextInitFailed: (error: string) => void;
+        contextSuspended: () => void;
+        contextResumed: () => void;
+    };
+    vad: {
+        initializeStart: () => void;
+        initializeSuccess: (durationMs: number) => void;
+        initializeFailed: (error: string) => void;
+        speechStart: () => void;
+        speechEnd: (durationMs: number) => void;
+        speechReady: (audioDurationMs: number) => void;
+        blocked: (reason: string) => void;
+        unblocked: () => void;
+        restartFailed: (error: string) => void;
+    };
+    sync: {
+        bufferOverflow: (sessionId: string, bufferDurationMs: number) => void;
+        alignmentIssue: (sessionId: string, driftMs: number) => void;
+        sessionCreated: (sessionId: string) => void;
+        sessionCleanup: (sessionId: string, audioChunks: number, flameKeyframes: number) => void;
+        keyframeStarvation: (sessionId: string) => void;
+        audioChunkStarvation: (sessionId: string) => void;
+    };
+    playback: {
+        started: (sessionId: string) => void;
+        ended: (sessionId: string, durationMs: number, chunksPlayed: number) => void;
+        scheduleFailed: (sessionId: string, error: string) => void;
+        interrupted: (sessionId: string) => void;
+    };
+    wasm: {
+        computeError: (error: string) => void;
+        conversionError: (error: string) => void;
+        loadError: (error: string) => void;
+    };
+    rendering: {
+        renderLoopError: (error: string) => void;
+        splatLoadError: (error: string) => void;
+        textOnlyStateDetected: (durationMs: number) => void;
+    };
+    user: {
+        manualInterrupt: () => void;
+        textSent: (success: boolean, error?: string) => void;
+        speechSent: (success: boolean, error?: string) => void;
+        vadToggled: (enabled: boolean) => void;
+    };
+    performance: {
+        pageLoadTime: (pageType: "home" | "avatars" | "character_detail", durationMs: number, loadType?: "first_load" | "subsequent_load", characterId?: string) => void;
+        vadPreloadTime: (durationMs: number, success: boolean) => void;
+    };
+};

package/dist/withJoi/src/utils/postprocess-sdk-converter.d.ts

@@ -0,0 +1,4 @@
+import { PostProcessingConfig } from '@spatialwalk/avatarkit';
+import { PostprocessConfig } from './postprocess-transform';
+
+export declare function convertPostprocessToSDK(config: PostprocessConfig): PostProcessingConfig;

package/dist/withJoi/src/utils/postprocess-transform.d.ts

@@ -0,0 +1,25 @@
+export interface PostprocessConfig {
+    eyeBlink?: number;
+    expressionWeight?: number;
+    neckPose?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    neckPoseWeight?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    jawPose?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    jawPoseWeight?: number;
+    rotation?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}

package/dist/withJoi/src/utils/r2-upload.d.ts

@@ -0,0 +1,8 @@
+export interface R2UploadResult {
+    r2Key: string;
+    url: string;
+}
+
+export declare function uploadFileToR2WithPresignedURL(file: File): Promise<R2UploadResult>;
+
+export declare function uploadFileToR2(file: File): Promise<R2UploadResult>;

package/dist/withJoi/src/utils/resource-cache.d.ts

@@ -0,0 +1,25 @@
+declare class ResourceCacheManager {
+    private static instance;
+    private cache;
+    private totalCacheSize;
+    private constructor();
+    static getInstance(): ResourceCacheManager;
+    get(url: string): ArrayBuffer | null;
+    set(url: string, data: ArrayBuffer): void;
+    has(url: string): boolean;
+    delete(url: string): boolean;
+    clear(): void;
+    getStats(): {
+        entryCount: number;
+        totalSize: number;
+        totalSizeMB: number;
+        entries: Array<{
+            url: string;
+            size: number;
+            timestamp: number;
+        }>;
+    };
+}
+
+export declare const resourceCache: ResourceCacheManager;
+export {};

package/dist/withJoi/src/utils/sdk-preinit.d.ts

@@ -0,0 +1,3 @@
+export declare function preinitSDK(): Promise<void>;
+
+export declare function waitForSDKPreinit(): Promise<void>;

package/dist/withJoi/src/utils/toast.d.ts

@@ -0,0 +1,30 @@
+import { Component } from 'vue';
+
+export declare function errorToMessage(error: unknown): string;
+interface ToastOptions {
+    description?: string;
+    duration?: number;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+
+export declare const toast: {
+
+    success(message: string, options?: ToastOptions): string | number | undefined;
+    error(message: string, options?: ToastOptions): string | number | undefined;
+    fatal(message: string, options?: ToastOptions): string | number;
+    successAlways(message: string, options?: ToastOptions): string | number;
+    info(message: string, options?: ToastOptions): string | number | undefined;
+    warning(message: string, options?: ToastOptions): string | number | undefined;
+    loading(message: string, options?: ToastOptions): string | number | undefined;
+    dismiss(toastId?: string | number): void;
+    custom(component: Component, options?: ToastOptions): string | number | undefined;
+    promise<T>(promise: Promise<T>, options: {
+        loading?: string;
+        success?: string | ((data: T) => string);
+        error?: string | ((error: unknown) => string);
+    }): Promise<T>;
+};
+export {};

package/dist/withJoi/src/wasm/avatarCoreAdapter.d.ts

@@ -0,0 +1,101 @@
+import { TemplateResources } from './avatarCoreMemory';
+export interface AvatarCoreOptions {
+    logLevel?: 'basic' | 'verbose';
+    enableValidation?: boolean;
+    enablePerformanceMetrics?: boolean;
+    retryCount?: number;
+    baseAssetsPath?: string;
+    modelFolder?: string;
+    wasmConfig?: Record<string, unknown>;
+    wasmPath?: string;
+}
+export interface FlameInfo {
+    vertexCount: number;
+    faceCount: number;
+    jointCount: number;
+}
+export interface CharacterInfo {
+    pointCount: number;
+    hasAnimation: boolean;
+}
+export interface FlameParams {
+    shape_params?: number[];
+    expr_params?: number[];
+    rotation?: number[];
+    translation?: number[];
+    neck_pose?: number[];
+    jaw_pose?: number[];
+    eyes_pose?: number[];
+    eyelid?: number[];
+    has_eyelid?: boolean;
+}
+export declare class AvatarCoreAdapter {
+    private options;
+    private wasmConfig;
+    private wasmModule;
+    private memoryManager;
+    private coreHandle;
+    private characterHandle;
+    private animationHandle;
+    private totalFrames;
+    private isInitialized;
+    private isCharacterLoaded;
+    private api;
+    private performanceMetrics;
+    wasmTime: number;
+    private errorCodes;
+    private flameInfo?;
+    private characterInfo?;
+    private static sharedCoreHandle;
+    private static sharedIsInitialized;
+    constructor(options?: AvatarCoreOptions);
+    private static wasmModuleInstance;
+    private static wasmModuleLoadingPromise;
+    loadWASMModule(): Promise<void>;
+    private validateWASMModule;
+    private initializeMemoryViews;
+    private setupCAPIFunctions;
+    private initializeAvatarCore;
+    loadTemplateResourcesFromBuffers(templateResources: TemplateResources): Promise<boolean>;
+    loadCharacterFromBuffers(shapeBuffer: ArrayBuffer, pointCloudBuffer: ArrayBuffer): Promise<boolean>;
+    private loadAnimationFromData;
+    loadAnimationFromBuffer(animData: ArrayBuffer): Promise<number>;
+    switchAnimationFile(animationFile: string): Promise<number>;
+    getAnimationTotalFrames(): Promise<number>;
+    private getAnimationFrameParams;
+    setEyeTrackingConfig(config: {
+        enabled: boolean;
+        auto_eyelid_adjustment?: boolean;
+        eyelid_threshold?: number;
+    }): Promise<boolean>;
+    getCurrentFrameParams(frameIndex?: number): Promise<FlameParams>;
+    setGazeTarget(x: number, y: number, z: number): Promise<boolean>;
+    resetEyeTracking(): Promise<boolean>;
+    private queryFlameInfo;
+    private queryCharacterInfo;
+    private checkError;
+    private updateProgress;
+    getPerformanceMetrics(): {
+        memoryStats: {
+            allocatedPointers: number;
+            structPointers: number;
+            totalAllocatedMB: number;
+        } | undefined;
+        flameInfo: FlameInfo | undefined;
+        characterInfo: CharacterInfo | undefined;
+        version: any;
+        initTime: number;
+        loadTime: number;
+        computeFrames: number;
+        totalComputeTime: number;
+        averageComputeTime: number;
+    };
+    releaseCurrentCharacter(): void;
+    release(): void;
+    loadFlameModel(_modelData: ArrayBuffer): Promise<boolean>;
+    load3DGSData(_original3DGSPoints: ArrayBuffer, _binding: ArrayBuffer, _flameFaces: ArrayBuffer): Promise<boolean>;
+    computeCompleteFrameFlat(params?: {
+        frameIndex?: number;
+    }): Promise<Float32Array | null>;
+    computeFrameFlatFromParams(flameParams: FlameParams): Promise<Float32Array | null>;
+}

package/dist/withJoi/src/wasm/avatarCoreMemory.d.ts

@@ -0,0 +1,72 @@
+import { FlameParams } from './avatarCoreAdapter';
+
+interface WASMModule {
+    _malloc: (size: number) => number;
+    _free: (ptr: number) => void;
+    writeArrayToMemory: (array: Uint8Array, ptr: number) => void;
+    HEAPU8: Uint8Array;
+    HEAP32: Int32Array;
+    HEAPF32: Float32Array;
+    getValue: (ptr: number, type: string) => number;
+    setValue: (ptr: number, value: number, type: string) => void;
+}
+interface MemoryAllocation {
+    ptr: number;
+    size: number;
+}
+export interface TemplateResources {
+    flameModel: ArrayBuffer;
+    flameTemplate: ArrayBuffer;
+    teethPb: ArrayBuffer;
+    teethNpz: ArrayBuffer;
+}
+export interface CharacterData {
+    shape: ArrayBuffer;
+    pointCloud: ArrayBuffer;
+}
+export interface ExpressionParams {
+    expression?: number[];
+    jaw?: number[];
+    eyeR?: number[];
+    eyeL?: number[];
+    pose?: number[];
+    neck?: number[];
+    translation?: number[];
+}
+export interface ArrayMetadata {
+    ptr: number;
+    size: number;
+    dtype: string;
+}
+export declare class AvatarCoreMemoryManager {
+    private module;
+    private allocatedPointers;
+    private structPointers;
+    constructor(wasmModule: WASMModule);
+    allocateAndCopy(arrayBuffer: ArrayBuffer): MemoryAllocation;
+    createTemplateConfig(resources: TemplateResources): number;
+    createCharacterData(shapeBuffer: ArrayBuffer, plyBuffer: ArrayBuffer): number;
+    createFlameParams(params: FlameParams): number;
+    readFlameParams(paramsPtr: number): FlameParams;
+    readSplatPointFlatArray(arrayPtr: number): Float32Array | null;
+    readMeshData(outputPtr: number): {
+        vertices: Float32Array;
+        vertexCount: number;
+        faces: Uint32Array;
+        faceCount: number;
+        landmarks: Float32Array | null;
+        landmarkCount: number;
+        computeTime: number;
+    };
+    free(ptr: number): void;
+    freeStruct(name: string): void;
+    cleanupDataPointers(): void;
+    cleanupStructPointers(): void;
+    cleanup(): void;
+    getMemoryStats(): {
+        allocatedPointers: number;
+        structPointers: number;
+        totalAllocatedMB: number;
+    };
+}
+export {};

package/dist/withJoi/unocss.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('unocss').UserConfig<object>;
+export default _default;

package/dist/withJoi/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vite').UserConfig;
+export default _default;

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@spatialwalk/avatarkit",
   "type": "module",
-  "version": "1.0.0-beta.39",
-  "packageManager": "pnpm@10.18.2",
+  "version": "1.0.0-beta.40",
   "description": "SPAvatar SDK - 3D Gaussian Splatting Avatar Rendering SDK",
   "author": "SPAvatar Team",
   "license": "MIT",
@@ -32,16 +31,6 @@
     "CHANGELOG.md",
     "dist"
   ],
-  "scripts": {
-    "build": "SDK_BUILD=true vite build --mode library",
-    "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": "*"
   },
@@ -58,5 +47,15 @@
     "typescript": "^5.0.0",
     "vite": "^5.0.0",
     "vite-plugin-dts": "^4.5.4"
+  },
+  "scripts": {
+    "build": "SDK_BUILD=true vite build --mode library",
+    "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"
   }
-}
+}