@goodganglabs/lipsync-wasm-v1 0.3.0

package/lipsync-wasm-wrapper.js

@@ -0,0 +1,377 @@
+/**
+ * @goodganglabs/lipsync-wasm-v1
+ * Audio-to-blendshape lip sync engine (111-dim ARKit, phoneme model)
+ * @module lipsync-wasm-v1
+ */
+
+const WASM_MODULE_PATH = './lipsync_wasm_v1.js';
+const TARGET_SAMPLE_RATE = 16000;
+const BLENDSHAPE_DIM = 111;
+const ONNX_INPUT_NAME = 'input1';
+const ONNX_OUTPUT_NAME = 'dense_8';
+
+// ── License Constants ──
+const LICENSE_API_BASE = 'https://api.goodganglabs.com/v1/license';
+const TRIAL_STORAGE_KEY = '__ggl_lipsync_trial';
+const TOKEN_CACHE_KEY = '__ggl_lipsync_token_v1';
+const TRIAL_DURATION_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+const TOKEN_CACHE_DURATION_MS = 23 * 60 * 60 * 1000; // 23h (buffer before 24h expiry)
+
+export class LipSyncWasmWrapper {
+    #wasmPath;
+    #wasmModule = null;
+    #engine = null;
+    #onnxSession = null;
+    #ready = false;
+    #streaming = false;
+    #mode = null;
+
+    constructor(options = {}) {
+        this.#wasmPath = options.wasmPath || WASM_MODULE_PATH;
+    }
+
+    get ready() { return this.#ready; }
+    get modelVersion() { return 'v1'; }
+    get blendshapeDim() { return BLENDSHAPE_DIM; }
+    get mode() { return this.#mode; }
+    get wasmModule() { return this.#wasmModule; }
+
+    async init(options = {}) {
+        const { licenseKey, onProgress, preset = true } = options;
+
+        onProgress?.('wasm', 0);
+        this.#wasmModule = await import(this.#wasmPath);
+        await this.#wasmModule.default();
+        this.#engine = new this.#wasmModule.LipSyncWasm();
+        onProgress?.('wasm', 100);
+
+        onProgress?.('license', 0);
+        const token = await this.#obtainLicenseToken(licenseKey);
+        onProgress?.('license', 100);
+
+        onProgress?.('onnx', 0);
+        try {
+            if (typeof ort === 'undefined') throw new Error('onnxruntime-web not available');
+            ort.env.wasm.numThreads = 1;
+            onProgress?.('decrypt', 0);
+            const nowSecs = Math.floor(Date.now() / 1000);
+            const modelBytes = this.#wasmModule.get_onnx_model_licensed(token, nowSecs);
+            onProgress?.('decrypt', 100);
+            this.#onnxSession = await ort.InferenceSession.create(modelBytes.buffer, {
+                executionProviders: ['wasm'],
+                graphOptimizationLevel: 'all',
+            });
+            onProgress?.('onnx', 100);
+        } catch (err) {
+            console.warn('[lipsync-v1] ONNX unavailable, using heuristic fallback:', err.message);
+            this.#onnxSession = null;
+            onProgress?.('onnx-fallback', 100);
+        }
+
+        // Mark license as validated for heuristic mode gate
+        this.#engine.set_license_validated();
+
+        await this.#loadPreset(preset);
+        this.#ready = true;
+        this.#mode = this.#onnxSession ? 'onnx' : 'heuristic';
+        return { mode: this.#mode };
+    }
+
+    // ── Batch Processing ──
+
+    async processAudio(audio) {
+        this.#assertReady();
+
+        if (this.#onnxSession) {
+            const input = this.#engine.prepare_onnx_input(audio);
+            const output = await this.#runInference(input.mfcc_data, [1, input.num_frames, input.mfcc_dim]);
+            const result = this.#engine.assemble_and_postprocess(output);
+            return { ...result, mode: 'onnx' };
+        }
+
+        return { ...this.#engine.process_audio_with_animation(audio), mode: 'heuristic' };
+    }
+
+    async processAudioBuffer(audioBuffer) {
+        return this.processAudio(resampleToMono(audioBuffer, TARGET_SAMPLE_RATE));
+    }
+
+    async processFile(file) {
+        const arrayBuffer = await file.arrayBuffer();
+        const ctx = new OfflineAudioContext(1, 1, TARGET_SAMPLE_RATE);
+        const audioBuffer = await ctx.decodeAudioData(arrayBuffer);
+        return this.processAudioBuffer(audioBuffer);
+    }
+
+    // ── Streaming ──
+
+    async processAudioChunk(audioChunk, isLast = false) {
+        this.#assertReady();
+
+        if (!this.#onnxSession) {
+            return { ...this.#engine.process_audio_with_animation(audioChunk), mode: 'heuristic' };
+        }
+
+        if (!this.#streaming) {
+            this.#engine.start_streaming();
+            this.#streaming = true;
+        }
+
+        const state = this.#engine.feed_audio_chunk(audioChunk);
+        const flushState = isLast ? this.#engine.flush_audio_buffer() : null;
+        const pending = state.ready ? state : (flushState?.ready ? flushState : null);
+
+        if (!pending) {
+            if (isLast) this.#endStreamingSession();
+            return null;
+        }
+
+        const output = await this.#runInference(pending.mfcc_data, [1, pending.num_frames, pending.mfcc_dim]);
+        const processed = this.#engine.feed_onnx_result(output, pending.num_classes);
+
+        if (isLast) this.#endStreamingSession();
+        return { ...processed, mode: 'streaming-onnx' };
+    }
+
+    // ── Frame Extraction ──
+
+    getFrame(result, frameIndex) {
+        if (!result?.blendshapes) return new Array(BLENDSHAPE_DIM).fill(0);
+
+        if (Array.isArray(result.blendshapes) && typeof result.blendshapes[0] === 'number') {
+            const offset = frameIndex * BLENDSHAPE_DIM;
+            return result.blendshapes.slice(offset, offset + BLENDSHAPE_DIM);
+        }
+
+        return result.blendshapes[frameIndex] || new Array(BLENDSHAPE_DIM).fill(0);
+    }
+
+    // ── Utilities ──
+
+    getVrmaBytes() {
+        this.#assertReady();
+        return {
+            idle: this.#engine.get_idle_vrma_bytes(),
+            speaking: this.#engine.get_speaking_vrma_bytes(),
+        };
+    }
+
+    reset() {
+        if (this.#streaming) this.#endStreamingSession();
+        this.#engine?.reset();
+    }
+
+    dispose() {
+        this.reset();
+        if (this.#engine) { this.#engine.free(); this.#engine = null; }
+        this.#onnxSession = null;
+        this.#wasmModule = null;
+        this.#ready = false;
+    }
+
+    // ── Private ──
+
+    #assertReady() {
+        if (!this.#ready || !this.#engine) {
+            throw new Error('[lipsync-v1] Not initialized. Call init() first.');
+        }
+    }
+
+    #endStreamingSession() {
+        this.#engine.end_streaming();
+        this.#streaming = false;
+    }
+
+    async #runInference(inputData, shape) {
+        const tensor = new ort.Tensor('float32', new Float32Array(inputData), shape);
+        const results = await this.#onnxSession.run({ [ONNX_INPUT_NAME]: tensor });
+        return new Float32Array(results[ONNX_OUTPUT_NAME].data);
+    }
+
+    async #loadPreset(preset) {
+        if (preset === true) {
+            this.#engine.load_default_preset();
+        } else if (typeof preset === 'string') {
+            const response = await fetch(preset);
+            if (!response.ok) throw new Error(`[lipsync-v1] Preset fetch failed: ${response.status}`);
+            const { blendshape } = await response.json();
+            if (!blendshape?.length) throw new Error('[lipsync-v1] Invalid preset format');
+            const rows = blendshape.length;
+            const cols = blendshape[0].length;
+            const flat = new Float32Array(rows * cols);
+            for (let i = 0; i < rows; i++) flat.set(blendshape[i], i * cols);
+            this.#engine.load_preset(flat, rows, cols);
+        }
+    }
+
+    // ── License Orchestration ──
+
+    async #obtainLicenseToken(licenseKey) {
+        // 1. Check cached token (sessionStorage)
+        const cached = this.#getCachedToken();
+        if (cached) return cached;
+
+        // 2. License key provided → validate with server
+        if (licenseKey) {
+            const token = await this.#validateLicenseKey(licenseKey);
+            this.#cacheToken(token);
+            return token;
+        }
+
+        // 3. Trial flow
+        return this.#handleTrialFlow();
+    }
+
+    async #validateLicenseKey(licenseKey) {
+        const fingerprint = await this.#getFingerprint();
+        const res = await fetch(`${LICENSE_API_BASE}/validate`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${licenseKey}`,
+            },
+            body: JSON.stringify({ pkg: 'lipsync-wasm-v1', fingerprint }),
+        });
+
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`[lipsync-v1] License validation failed (${res.status}): ${body}`);
+        }
+
+        const { token } = await res.json();
+        if (!token) throw new Error('[lipsync-v1] License server returned no token');
+        return token;
+    }
+
+    async #handleTrialFlow() {
+        const fingerprint = await this.#getFingerprint();
+        let trialData = null;
+
+        try {
+            const stored = localStorage.getItem(TRIAL_STORAGE_KEY);
+            if (stored) trialData = JSON.parse(stored);
+        } catch { /* localStorage unavailable or corrupted */ }
+
+        if (!trialData) {
+            // First use → start trial
+            const res = await fetch(`${LICENSE_API_BASE}/trial/start`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ pkg: 'lipsync-wasm-v1', fingerprint }),
+            });
+
+            if (!res.ok) {
+                const body = await res.text().catch(() => '');
+                throw new Error(`[lipsync-v1] Trial start failed (${res.status}): ${body}`);
+            }
+
+            const { token } = await res.json();
+            if (!token) throw new Error('[lipsync-v1] Trial server returned no token');
+
+            try {
+                localStorage.setItem(TRIAL_STORAGE_KEY, JSON.stringify({
+                    start: Date.now(),
+                    fingerprint,
+                }));
+            } catch { /* localStorage unavailable */ }
+
+            this.#cacheToken(token);
+            return token;
+        }
+
+        // Existing trial → check expiry
+        const elapsed = Date.now() - (trialData.start || 0);
+        if (elapsed > TRIAL_DURATION_MS) {
+            throw new Error(
+                '[lipsync-v1] Trial period expired (30 days). ' +
+                'Pass a licenseKey to init(): new LipSyncWasmWrapper().init({ licenseKey: "ggl_..." })'
+            );
+        }
+
+        // Trial still valid → renew token
+        const res = await fetch(`${LICENSE_API_BASE}/trial/validate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ pkg: 'lipsync-wasm-v1', fingerprint }),
+        });
+
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`[lipsync-v1] Trial validation failed (${res.status}): ${body}`);
+        }
+
+        const { token } = await res.json();
+        if (!token) throw new Error('[lipsync-v1] Trial server returned no token');
+
+        this.#cacheToken(token);
+        return token;
+    }
+
+    async #getFingerprint() {
+        const raw = [
+            navigator.userAgent || '',
+            navigator.language || '',
+            screen?.width || 0,
+            screen?.height || 0,
+            Intl?.DateTimeFormat()?.resolvedOptions()?.timeZone || '',
+        ].join('|');
+
+        if (typeof crypto?.subtle?.digest === 'function') {
+            const buf = new TextEncoder().encode(raw);
+            const hash = await crypto.subtle.digest('SHA-256', buf);
+            return Array.from(new Uint8Array(hash)).map(b => b.toString(16).padStart(2, '0')).join('');
+        }
+
+        // Fallback: simple hash
+        let h = 0;
+        for (let i = 0; i < raw.length; i++) {
+            h = ((h << 5) - h + raw.charCodeAt(i)) | 0;
+        }
+        return 'f' + Math.abs(h).toString(16);
+    }
+
+    #getCachedToken() {
+        try {
+            const stored = sessionStorage.getItem(TOKEN_CACHE_KEY);
+            if (!stored) return null;
+            const { token, cachedAt } = JSON.parse(stored);
+            if (Date.now() - cachedAt > TOKEN_CACHE_DURATION_MS) {
+                sessionStorage.removeItem(TOKEN_CACHE_KEY);
+                return null;
+            }
+            return token;
+        } catch {
+            return null;
+        }
+    }
+
+    #cacheToken(token) {
+        try {
+            sessionStorage.setItem(TOKEN_CACHE_KEY, JSON.stringify({
+                token,
+                cachedAt: Date.now(),
+            }));
+        } catch { /* sessionStorage unavailable */ }
+    }
+}
+
+// ── Module-level Helpers ──
+
+function resampleToMono(audioBuffer, targetRate) {
+    const data = audioBuffer.getChannelData(0);
+    if (audioBuffer.sampleRate === targetRate) return data;
+
+    const ratio = targetRate / audioBuffer.sampleRate;
+    const length = Math.round(data.length * ratio);
+    const output = new Float32Array(length);
+
+    for (let i = 0; i < length; i++) {
+        const srcPos = i / ratio;
+        const lo = Math.floor(srcPos);
+        const hi = Math.min(lo + 1, data.length - 1);
+        const frac = srcPos - lo;
+        output[i] = data[lo] + frac * (data[hi] - data[lo]);
+    }
+
+    return output;
+}

package/lipsync_wasm_v1.d.ts

@@ -0,0 +1,302 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Idle 상태에서 눈 깜빡임 + 미세 표정을 생성하는 구조체
+ *
+ * V2의 add_blinks 로직을 재활용하여, idle 상태에서도
+ * 자연스러운 표정 변화가 나오도록 한다.
+ */
+export class IdleExpressionGenerator {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * elapsed_time(초)에 해당하는 52-dim 블렌드쉐입 프레임 반환
+     */
+    get_frame(elapsed_time: number): Float32Array;
+    constructor();
+    /**
+     * 상태 초기화
+     */
+    reset(): void;
+}
+
+/**
+ * 메인 LipSync WASM 클래스
+ */
+export class LipSyncWasm {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 배치 모드: ONNX 결과 조립 + 후처리
+     *
+     * phoneme_probs: ONNX 출력 (flatten, N * 61)
+     */
+    assemble_and_postprocess(phoneme_probs: Float32Array): any;
+    /**
+     * 프리셋 제거
+     */
+    clear_preset(): void;
+    /**
+     * 스트리밍 모드 종료
+     */
+    end_streaming(): void;
+    /**
+     * MFCC 추출 (JS에서 onnxruntime-web 추론에 사용)
+     */
+    extract_mfcc(audio: Float32Array): Float32Array;
+    /**
+     * 스트리밍: 오디오 청크에서 MFCC 추출
+     *
+     * 반환: flatten MFCC (N * 13)
+     */
+    extract_mfcc_chunk(audio: Float32Array): Float32Array;
+    /**
+     * 스트리밍: 오디오 청크를 입력받아 MFCC 추출 + 버퍼링
+     *
+     * 내부 버퍼에 MFCC를 축적하고, 30프레임 이상 도달 시
+     * MFCC 데이터를 반환 (JS에서 ONNX 추론 수행).
+     */
+    feed_audio_chunk(audio: Float32Array): any;
+    /**
+     * 스트리밍: ONNX 추론 결과로 블렌드쉐입 생성
+     *
+     * phoneme_probs: ONNX 출력 (flatten, N * num_classes)
+     */
+    feed_onnx_result(phoneme_probs: Float32Array, num_classes: number): any;
+    /**
+     * 스트리밍: 잔여 버퍼 플러시 (마지막 청크에서 호출)
+     */
+    flush_audio_buffer(): any;
+    /**
+     * 후보정 상태 조회
+     */
+    get_corrections_enabled(): boolean;
+    /**
+     * 특정 프레임의 블렌드쉐입 추출
+     */
+    get_frame(result: any, frame_index: number): Float32Array;
+    /**
+     * 프레임 수 조회
+     */
+    get_frame_count(): number;
+    /**
+     * 내장 idle VRMA 원본 바이트 반환
+     */
+    get_idle_vrma_bytes(): Uint8Array;
+    /**
+     * 내장 speaking VRMA 원본 바이트 반환
+     */
+    get_speaking_vrma_bytes(): Uint8Array;
+    /**
+     * 프리셋 로드 여부
+     */
+    has_preset(): boolean;
+    /**
+     * 라이선스 검증 여부 조회
+     */
+    is_license_validated(): boolean;
+    /**
+     * 스트리밍 모드 여부 조회
+     */
+    is_streaming(): boolean;
+    /**
+     * 내장 기본 프리셋 로드 (jc01)
+     */
+    load_default_preset(): void;
+    /**
+     * 프리셋 애니메이션 로드
+     */
+    load_preset(data: Float32Array, num_frames: number, num_dims: number): void;
+    /**
+     * 새 LipSync 인스턴스 생성
+     */
+    constructor();
+    /**
+     * 배치 모드: ONNX 입력 준비 (MFCC 추출)
+     *
+     * JS에서 ONNX 추론 후 assemble_and_postprocess()로 전달.
+     * V1은 chunking 불필요 (가변 길이 MFCC → ONNX).
+     */
+    prepare_onnx_input(audio: Float32Array): any;
+    /**
+     * 오디오 처리 (휴리스틱 폴백 모드)
+     */
+    process_audio(audio: Float32Array): any;
+    /**
+     * 오디오 + 프리셋 블렌딩 (휴리스틱 애니메이션 모드)
+     */
+    process_audio_with_animation(audio: Float32Array): any;
+    /**
+     * 음소 확률에서 블렌드쉐입 생성 (ONNX 추론 결과 사용)
+     */
+    process_phonemes(phoneme_probs: Float32Array, num_classes: number): any;
+    /**
+     * 스트리밍: 음소 확률에서 블렌드쉐입 생성 (ONNX 추론 결과)
+     *
+     * OneEuroFilter가 시간 오프셋을 유지하여 청크 간 연속성 보장.
+     */
+    process_phonemes_chunk(phoneme_probs: Float32Array, num_classes: number): any;
+    /**
+     * 스트리밍: 음소 확률 + 프리셋 블렌딩
+     */
+    process_phonemes_chunk_with_animation(phoneme_probs: Float32Array, num_classes: number): any;
+    /**
+     * 음소 확률 + 프리셋 블렌딩 (애니메이션 모드)
+     */
+    process_phonemes_with_animation(phoneme_probs: Float32Array, num_classes: number): any;
+    /**
+     * 필터 상태 리셋
+     */
+    reset(): void;
+    /**
+     * 후보정 활성화/비활성화
+     */
+    set_corrections_enabled(enabled: boolean): void;
+    /**
+     * 라이선스 검증 완료 표시 (JS wrapper에서 get_onnx_model_licensed 성공 후 호출)
+     */
+    set_license_validated(): void;
+    /**
+     * 스트리밍 모드 시작
+     */
+    start_streaming(): void;
+}
+
+/**
+ * RMS 에너지 기반 음성 활동 감지기 (V1/V2 공통)
+ *
+ * 마이크 스트리밍 시 말하는 중인지 판단하여
+ * idle<->speaking 본 애니메이션 전환을 제어한다.
+ */
+export class VoiceActivityDetector {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 오디오 샘플을 입력받아 speaking 여부를 반환
+     *
+     * RMS 에너지 > threshold -> speaking, 아니면 hold_time 이후 silent
+     */
+    feed_audio(samples: Float32Array): boolean;
+    /**
+     * 현재 speaking 상태 조회
+     */
+    is_speaking(): boolean;
+    constructor(threshold: number, hold_time: number);
+    /**
+     * 상태 초기화
+     */
+    reset(): void;
+    /**
+     * hold_time 변경
+     */
+    set_hold_time(hold_time: number): void;
+    /**
+     * RMS 임계값 변경
+     */
+    set_threshold(threshold: number): void;
+}
+
+/**
+ * [Deprecated] 구 API — 라이선스 없이 모델 접근 불가
+ *
+ * get_onnx_model_licensed(token, timestamp)를 사용하세요.
+ */
+export function get_onnx_model(): Uint8Array;
+
+/**
+ * 라이선스 검증 + ONNX 모델 복호화 (원자적 실행)
+ *
+ * Ed25519 서명 검증 통과 후에만 AES-256-GCM 복호화 수행.
+ *
+ * # Arguments
+ * * `token` - 서버에서 발급받은 라이선스 토큰 (EdDSA 서명)
+ * * `current_timestamp_secs` - 현재 Unix timestamp (초)
+ */
+export function get_onnx_model_licensed(token: string, current_timestamp_secs: number): Uint8Array;
+
+/**
+ * WASM 초기화 시 panic hook 설정
+ */
+export function start(): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_lipsyncwasm_free: (a: number, b: number) => void;
+    readonly get_onnx_model: () => [number, number, number, number];
+    readonly get_onnx_model_licensed: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly lipsyncwasm_assemble_and_postprocess: (a: number, b: number, c: number) => [number, number, number];
+    readonly lipsyncwasm_clear_preset: (a: number) => void;
+    readonly lipsyncwasm_end_streaming: (a: number) => void;
+    readonly lipsyncwasm_extract_mfcc: (a: number, b: number, c: number) => [number, number];
+    readonly lipsyncwasm_extract_mfcc_chunk: (a: number, b: number, c: number) => [number, number];
+    readonly lipsyncwasm_feed_audio_chunk: (a: number, b: number, c: number) => [number, number, number];
+    readonly lipsyncwasm_feed_onnx_result: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly lipsyncwasm_flush_audio_buffer: (a: number) => [number, number, number];
+    readonly lipsyncwasm_get_corrections_enabled: (a: number) => number;
+    readonly lipsyncwasm_get_frame: (a: number, b: any, c: number) => [number, number, number, number];
+    readonly lipsyncwasm_get_frame_count: (a: number) => number;
+    readonly lipsyncwasm_get_idle_vrma_bytes: (a: number) => [number, number];
+    readonly lipsyncwasm_get_speaking_vrma_bytes: (a: number) => [number, number];
+    readonly lipsyncwasm_has_preset: (a: number) => number;
+    readonly lipsyncwasm_is_license_validated: (a: number) => number;
+    readonly lipsyncwasm_is_streaming: (a: number) => number;
+    readonly lipsyncwasm_load_default_preset: (a: number) => [number, number];
+    readonly lipsyncwasm_load_preset: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly lipsyncwasm_new: () => [number, number, number];
+    readonly lipsyncwasm_prepare_onnx_input: (a: number, b: number, c: number) => [number, number, number];
+    readonly lipsyncwasm_process_audio: (a: number, b: number, c: number) => [number, number, number];
+    readonly lipsyncwasm_process_audio_with_animation: (a: number, b: number, c: number) => [number, number, number];
+    readonly lipsyncwasm_process_phonemes: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly lipsyncwasm_process_phonemes_chunk: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly lipsyncwasm_process_phonemes_chunk_with_animation: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly lipsyncwasm_process_phonemes_with_animation: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly lipsyncwasm_reset: (a: number) => void;
+    readonly lipsyncwasm_set_corrections_enabled: (a: number, b: number) => void;
+    readonly lipsyncwasm_set_license_validated: (a: number) => void;
+    readonly lipsyncwasm_start_streaming: (a: number) => void;
+    readonly start: () => void;
+    readonly __wbg_idleexpressiongenerator_free: (a: number, b: number) => void;
+    readonly idleexpressiongenerator_get_frame: (a: number, b: number) => [number, number];
+    readonly idleexpressiongenerator_new: () => number;
+    readonly idleexpressiongenerator_reset: (a: number) => void;
+    readonly __wbg_voiceactivitydetector_free: (a: number, b: number) => void;
+    readonly voiceactivitydetector_feed_audio: (a: number, b: number, c: number) => number;
+    readonly voiceactivitydetector_is_speaking: (a: number) => number;
+    readonly voiceactivitydetector_new: (a: number, b: number) => number;
+    readonly voiceactivitydetector_reset: (a: number) => void;
+    readonly voiceactivitydetector_set_hold_time: (a: number, b: number) => void;
+    readonly voiceactivitydetector_set_threshold: (a: number, b: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;