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

package/dist/playground/apps/web/src/stores/vad.d.ts

@@ -0,0 +1,73 @@
+export interface VADConfig {
+    speechThreshold: number;
+    exitThreshold: number;
+    minSilenceDurationMs: number;
+    openThresholdDb: number;
+    closeThresholdDb: number;
+    attackMs: number;
+    releaseMs: number;
+    holdMs: number;
+    highPassHz: number;
+}
+export interface VADRuntimeState {
+    isInitialized: boolean;
+    isActive: boolean;
+    isSpeaking: boolean;
+    volume: number;
+    isInitializing: boolean;
+    rmsDb?: number;
+    gateOpen?: boolean;
+    isPaused: boolean;
+}
+export declare const useVADStore: import('pinia').StoreDefinition<"vad", Pick<{
+    config: import('@vueuse/core').RemovableRef<VADConfig>;
+    state: {
+        isInitialized: boolean;
+        isActive: boolean;
+        isSpeaking: boolean;
+        volume: number;
+        isInitializing: boolean;
+        rmsDb?: number | undefined;
+        gateOpen?: boolean | undefined;
+        isPaused: boolean;
+    };
+    updateConfig: (newConfig: Partial<VADConfig>) => void;
+    updateState: (newState: Partial<VADRuntimeState>) => void;
+    resetConfig: () => void;
+    resetState: () => void;
+    applyPreset: (preset: "default" | "conservative" | "aggressive" | "sensitive") => void;
+}, "state" | "config">, Pick<{
+    config: import('@vueuse/core').RemovableRef<VADConfig>;
+    state: {
+        isInitialized: boolean;
+        isActive: boolean;
+        isSpeaking: boolean;
+        volume: number;
+        isInitializing: boolean;
+        rmsDb?: number | undefined;
+        gateOpen?: boolean | undefined;
+        isPaused: boolean;
+    };
+    updateConfig: (newConfig: Partial<VADConfig>) => void;
+    updateState: (newState: Partial<VADRuntimeState>) => void;
+    resetConfig: () => void;
+    resetState: () => void;
+    applyPreset: (preset: "default" | "conservative" | "aggressive" | "sensitive") => void;
+}, never>, Pick<{
+    config: import('@vueuse/core').RemovableRef<VADConfig>;
+    state: {
+        isInitialized: boolean;
+        isActive: boolean;
+        isSpeaking: boolean;
+        volume: number;
+        isInitializing: boolean;
+        rmsDb?: number | undefined;
+        gateOpen?: boolean | undefined;
+        isPaused: boolean;
+    };
+    updateConfig: (newConfig: Partial<VADConfig>) => void;
+    updateState: (newState: Partial<VADRuntimeState>) => void;
+    resetConfig: () => void;
+    resetState: () => void;
+    applyPreset: (preset: "default" | "conservative" | "aggressive" | "sensitive") => void;
+}, "updateConfig" | "updateState" | "resetConfig" | "resetState" | "applyPreset">>;

package/dist/playground/apps/web/src/types/avatar.d.ts

@@ -0,0 +1,17 @@
+export interface FlatSplatData {
+    positions: Float32Array;
+    scales: Float32Array;
+    rotations: Float32Array;
+    colors: Float32Array;
+    opacities: Float32Array;
+    pointCount: number;
+}
+export interface CameraConfig {
+    position: [number, number, number];
+    target: [number, number, number];
+    fov: number;
+    near: number;
+    far: number;
+    up?: [number, number, number];
+    aspect?: number;
+}

package/dist/playground/apps/web/src/types/character-settings.d.ts

@@ -0,0 +1,18 @@
+export interface EyefocusSettings {
+    auto_eyelid_adjustment: boolean;
+    enabled: boolean;
+    eyelid_threshold: number;
+    targets: number[];
+}
+export interface CameraSettings {
+    fovXRadians: number;
+    fovYRadians: number;
+    rotation: number;
+    translationX: number;
+    translationY: number;
+    translationZ: number;
+}
+export interface CharacterSettings {
+    eyefocus: EyefocusSettings;
+    camera: CameraSettings;
+}

package/dist/playground/apps/web/src/types/character.d.ts

@@ -0,0 +1,34 @@
+import { CharacterAsset, Resource } from '../../../../generated/driveningress/v2/driveningress';
+import { CameraSettings, CharacterSettings } from './character-settings';
+
+export type CharacterMeta = CharacterAsset & {
+    characterSettings?: CharacterSettings;
+};
+export type PreloadResources<T> = {
+    version: string;
+} & T;
+export type PreloadCameraSettings = PreloadResources<{
+    camera: CameraSettings;
+}>;
+
+export interface FlameResources {
+    flameModel?: Resource;
+    flameTemplate?: Resource;
+    teethPb?: Resource;
+    teethNpz?: Resource;
+}
+
+export declare enum ResourceType {
+    CAMERA = "camera",
+    ANIMATION_IDLE = "frameIdle",
+    ANIMATION_MONO = "frameMono",
+    AUDIO_MONO = "audioMono",
+    MODEL_SHAPE = "shape",
+    MODEL_GS = "gsStandard"
+}
+
+export declare function extractResourceUrls(meta: CharacterMeta): Record<ResourceType, string | null>;
+
+export declare function hasMonologue(meta: CharacterMeta): boolean;
+
+export declare function hasMonologueFromModelInfo(modelInfo: string): boolean;

package/dist/playground/apps/web/src/utils/animation-interpolation.d.ts

@@ -0,0 +1,7 @@
+import { Flame } from '../../../../generated/realtime/v1/messages';
+
+export declare function linearLerp(from: Flame, to: Flame, progress: number): Flame;
+
+export declare function generateTransitionFrames(from: Flame, to: Flame, durationMs: number, fps?: number): Flame[];
+
+export declare function createNeutralFlame(): Flame;

package/dist/playground/apps/web/src/utils/api-client.d.ts

@@ -0,0 +1,7 @@
+export declare function doRequest<T>(requestFn: () => Promise<T>, errorContext: string): Promise<T>;
+
+export declare function getMainAppClient(options?: {
+    requireAuth?: boolean;
+}): import('ofetch').$Fetch;
+
+export declare function getSdkApiClient(): import('ofetch').$Fetch;

package/dist/playground/apps/web/src/utils/api-error.d.ts

@@ -0,0 +1,13 @@
+import { ErrorObject } from '../../../../generated/jsonapi/v1/base';
+export declare class ApiError extends Error {
+    readonly errorObject: ErrorObject;
+    constructor(errorObject: ErrorObject);
+    get status(): number;
+    get code(): string;
+    get title(): string;
+    get detail(): string;
+    get id(): string;
+    isStatus(status: number): boolean;
+    isUnauthorized(): boolean;
+    isForbidden(): boolean;
+}

package/dist/playground/apps/web/src/utils/dynamic-resource-loader.d.ts

@@ -0,0 +1,43 @@
+import { CharacterMeta, FlameResources, PreloadCameraSettings } from '../types/character';
+import { CharacterSettings } from '../types/character-settings';
+import { TemplateResources } from '../wasm/avatarCoreMemory';
+interface ProgressInfo {
+    stage: string;
+    filename: string;
+    loaded: number;
+    total: number;
+    progress: number;
+}
+type ProgressCallback = (info: ProgressInfo) => void;
+export 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 DynamicResourceLoader {
+    private baseAssetsPath;
+    private characterAssets;
+    constructor(baseAssetsPath?: string);
+    loadTemplateResources(flameResources?: FlameResources, progressCallback?: ProgressCallback | null): Promise<TemplateResources>;
+    private loadGlobalFlameResources;
+    loadCameraSettings(characterMeta: CharacterMeta): Promise<PreloadCameraSettings | undefined>;
+    loadCharacterData(characterMeta: CharacterMeta, options?: {
+        loadMonologue?: boolean;
+        progressCallback?: ProgressCallback | null;
+    }): Promise<CharacterDataResult>;
+    preloadResources(characterMeta: CharacterMeta, options?: {
+        loadMonologue?: boolean;
+        progressCallback?: ProgressCallback | null;
+    }): Promise<PreloadResult>;
+    getCharacterAsset(key: string): ArrayBuffer | undefined;
+    clear(): void;
+}
+export {};

package/dist/playground/apps/web/src/utils/error-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function errorToMessage(err: unknown): string;
+
+export declare function errorToDetailedMessage(err: unknown): string;
+
+export declare class PermissionTimeoutError extends Error {
+    constructor(message?: string);
+}

package/dist/playground/apps/web/src/utils/image-optimizer.d.ts

@@ -0,0 +1,17 @@
+export interface ImageOptimizeOptions {
+    width?: number;
+    height?: number;
+    quality?: number;
+    format?: 'auto' | 'webp' | 'jpg' | 'png';
+    mode?: 1 | 2 | 3 | 4 | 5;
+}
+
+export declare function optimizeImageUrl(url: string, options?: ImageOptimizeOptions): string;
+
+export declare function optimizeCharacterCoverUrl(url: string): string;
+
+export declare function optimizeCharacterDetailCoverUrl(url: string): string;
+
+export declare function optimizeBackgroundImageUrl(url: string): string;
+
+export declare function optimizeCharacterAvatarUrl(url: string): string;

package/dist/playground/apps/web/src/utils/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: import('@guiiai/logg').Logg;

package/dist/playground/apps/web/src/utils/memory-tracker.d.ts

@@ -0,0 +1,23 @@
+interface MemorySnapshot {
+    timestamp: number;
+    used: number;
+    total: number;
+    limit: number;
+    cycle?: number;
+}
+declare class EnhancedMemoryTracker {
+    private snapshots;
+    private cycleCount;
+    private isEnabled;
+    constructor();
+    private setupGlobalHelpers;
+    takeSnapshot(label: string): MemorySnapshot | null;
+    analyze(): void;
+    compare(index1: number, index2: number): void;
+    list(): void;
+    private formatMemory;
+    clear(): void;
+}
+export declare const memoryTracker: EnhancedMemoryTracker;
+export declare function useMemoryTracker(): EnhancedMemoryTracker;
+export {};

package/dist/playground/apps/web/src/utils/nanoid.d.ts

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

package/dist/playground/apps/web/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/playground/apps/web/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/playground/apps/web/src/utils/sdk-preinit.d.ts

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

package/dist/playground/apps/web/src/utils/toast.d.ts

@@ -0,0 +1,31 @@
+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;
+    warningAlways(message: string, options?: ToastOptions): string | number;
+    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/playground/apps/web/vite.config.d.ts

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

package/dist/playground/bump.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Partial<import('bumpp').VersionBumpOptions>;
+export default _default;

package/dist/playground/eslint.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;