@picovoice/eagle-web 0.1.1 → 0.2.0

package/src/eagle.ts

@@ -25,7 +25,15 @@ import {
 
 import { simd } from 'wasm-feature-detect';
 
-import { EagleModel, EagleProfile, EagleProfilerEnrollResult } from './types';
+import {
+  EagleModel,
+  EagleProfile,
+  EagleProfilerEnrollResult,
+  PvStatus
+} from './types';
+
+import * as EagleErrors from './eagle_errors';
+import { pvStatusToException } from './eagle_errors';
 
 /**
  * WebAssembly function types
@@ -74,6 +82,12 @@ type pv_eagle_frame_length_type = () => Promise<number>;
 type pv_eagle_version_type = () => Promise<number>;
 type pv_sample_rate_type = () => Promise<number>;
 type pv_status_to_string_type = (status: number) => Promise<number>;
+type pv_set_sdk_type = (sdk: number) => Promise<void>;
+type pv_get_error_stack_type = (
+  messageStack: number,
+  messageStackDepth: number
+) => Promise<number>;
+type pv_free_error_stack_type = (messageStack: number) => Promise<void>;
 
 type EagleBaseWasmOutput = {
   memory: WebAssembly.Memory;
@@ -84,7 +98,13 @@ type EagleBaseWasmOutput = {
   sampleRate: number;
   version: string;
 
+  messageStackAddressAddressAddress: number;
+  messageStackDepthAddress: number;
+
   pvStatusToString: pv_status_to_string_type;
+  pvGetErrorStack: pv_get_error_stack_type;
+  pvFreeErrorStack: pv_free_error_stack_type;
+
   exports: any;
 };
 
@@ -120,16 +140,20 @@ class EagleBase {
   protected _wasmMemory: WebAssembly.Memory | undefined;
   protected readonly _alignedAlloc: CallableFunction;
   protected readonly _pvFree: pv_free_type;
-  protected readonly _memoryBuffer: Int16Array;
-  protected readonly _memoryBufferUint8: Uint8Array;
-  protected readonly _memoryBufferView: DataView;
   protected readonly _functionMutex: Mutex;
 
+  protected readonly _pvGetErrorStack: pv_get_error_stack_type;
+  protected readonly _pvFreeErrorStack: pv_free_error_stack_type;
+
+  protected readonly _messageStackAddressAddressAddress: number;
+  protected readonly _messageStackDepthAddress: number;
+
   protected static _sampleRate: number;
   protected static _version: string;
 
   protected static _wasm: string;
   protected static _wasmSimd: string;
+  protected static _sdk: string = 'web';
 
   protected static _eagleMutex = new Mutex();
 
@@ -146,9 +170,11 @@ class EagleBase {
     this._pvFree = handleWasm.pvFree;
     this._pvError = handleWasm.pvError;
 
-    this._memoryBuffer = new Int16Array(handleWasm.memory.buffer);
-    this._memoryBufferUint8 = new Uint8Array(handleWasm.memory.buffer);
-    this._memoryBufferView = new DataView(handleWasm.memory.buffer);
+    this._pvGetErrorStack = handleWasm.pvGetErrorStack;
+    this._pvFreeErrorStack = handleWasm.pvFreeErrorStack;
+
+    this._messageStackAddressAddressAddress = handleWasm.messageStackAddressAddressAddress;
+    this._messageStackDepthAddress = handleWasm.messageStackDepthAddress;
 
     this._functionMutex = new Mutex();
   }
@@ -187,6 +213,10 @@ class EagleBase {
     }
   }
 
+  public static setSdk(sdk: string): void {
+    EagleBase._sdk = sdk;
+  }
+
   protected static async _initBaseWasm(
     wasmBase64: string,
     wasmMemorySize: number
@@ -203,6 +233,11 @@ class EagleBase {
     const pv_sample_rate = exports.pv_sample_rate as pv_sample_rate_type;
     const pv_status_to_string =
       exports.pv_status_to_string as pv_status_to_string_type;
+    const pv_set_sdk = exports.pv_set_sdk as pv_set_sdk_type;
+    const pv_get_error_stack =
+      exports.pv_get_error_stack as pv_get_error_stack_type;
+    const pv_free_error_stack =
+      exports.pv_free_error_stack as pv_free_error_stack_type;
 
     const sampleRate = await pv_sample_rate();
     const versionAddress = await pv_eagle_version();
@@ -211,6 +246,40 @@ class EagleBase {
       versionAddress
     );
 
+    const sdkEncoded = new TextEncoder().encode(this._sdk);
+    const sdkAddress = await aligned_alloc(
+      Uint8Array.BYTES_PER_ELEMENT,
+      (sdkEncoded.length + 1) * Uint8Array.BYTES_PER_ELEMENT
+    );
+    if (!sdkAddress) {
+      throw new EagleErrors.EagleOutOfMemoryError(
+        'malloc failed: Cannot allocate memory'
+      );
+    }
+    memoryBufferUint8.set(sdkEncoded, sdkAddress);
+    memoryBufferUint8[sdkAddress + sdkEncoded.length] = 0;
+    await pv_set_sdk(sdkAddress);
+
+    const messageStackDepthAddress = await aligned_alloc(
+      Int32Array.BYTES_PER_ELEMENT,
+      Int32Array.BYTES_PER_ELEMENT
+    );
+    if (!messageStackDepthAddress) {
+      throw new EagleErrors.EagleOutOfMemoryError(
+        'malloc failed: Cannot allocate memory'
+      );
+    }
+
+    const messageStackAddressAddressAddress = await aligned_alloc(
+      Int32Array.BYTES_PER_ELEMENT,
+      Int32Array.BYTES_PER_ELEMENT
+    );
+    if (!messageStackAddressAddressAddress) {
+      throw new EagleErrors.EagleOutOfMemoryError(
+        'malloc failed: Cannot allocate memory'
+      );
+    }
+
     return {
       memory: memory,
       alignedAlloc: aligned_alloc,
@@ -220,10 +289,67 @@ class EagleBase {
       sampleRate: sampleRate,
       version: version,
 
+      messageStackAddressAddressAddress: messageStackAddressAddressAddress,
+      messageStackDepthAddress: messageStackDepthAddress,
+
       pvStatusToString: pv_status_to_string,
+      pvGetErrorStack: pv_get_error_stack,
+      pvFreeErrorStack: pv_free_error_stack,
+
       exports: exports,
     };
   }
+
+  /**
+   * Releases resources acquired by Eagle
+   */
+  public async release(): Promise<void> {
+    await this._pvFree(this._messageStackAddressAddressAddress);
+    await this._pvFree(this._messageStackDepthAddress);
+  }
+
+  protected static async getMessageStack(
+    pv_get_error_stack: pv_get_error_stack_type,
+    pv_free_error_stack: pv_free_error_stack_type,
+    messageStackAddressAddressAddress: number,
+    messageStackDepthAddress: number,
+    memoryBufferView: DataView,
+    memoryBufferUint8: Uint8Array
+  ): Promise<string[]> {
+    const status = await pv_get_error_stack(
+      messageStackAddressAddressAddress,
+      messageStackDepthAddress
+    );
+    if (status !== PvStatus.SUCCESS) {
+      throw pvStatusToException(status, 'Unable to get Eagle error state');
+    }
+
+    const messageStackAddressAddress = memoryBufferView.getInt32(
+      messageStackAddressAddressAddress,
+      true
+    );
+
+    const messageStackDepth = memoryBufferView.getInt32(
+      messageStackDepthAddress,
+      true
+    );
+    const messageStack: string[] = [];
+    for (let i = 0; i < messageStackDepth; i++) {
+      const messageStackAddress = memoryBufferView.getInt32(
+        messageStackAddressAddress + i * Int32Array.BYTES_PER_ELEMENT,
+        true
+      );
+      const message = arrayBufferToStringAtIndex(
+        memoryBufferUint8,
+        messageStackAddress
+      );
+      messageStack.push(message);
+    }
+
+    await pv_free_error_stack(messageStackAddressAddress);
+
+    return messageStack;
+  }
 }
 
 /**
@@ -296,7 +422,7 @@ export class EagleProfiler extends EagleBase {
     modelPath: string
   ): Promise<EagleProfiler> {
     if (!isAccessKeyValid(accessKey)) {
-      throw new Error('Invalid AccessKey');
+      throw new EagleErrors.EagleInvalidArgumentError('Invalid AccessKey');
     }
 
     return new Promise<EagleProfiler>((resolve, reject) => {
@@ -346,11 +472,11 @@ export class EagleProfiler extends EagleBase {
    */
   public async enroll(pcm: Int16Array): Promise<EagleProfilerEnrollResult> {
     if (!(pcm instanceof Int16Array)) {
-      throw new Error("The argument 'pcm' must be provided as an Int16Array");
+      throw new EagleErrors.EagleInvalidArgumentError("The argument 'pcm' must be provided as an Int16Array");
     }
 
     if (pcm.length > EagleProfiler._maxEnrollSamples) {
-      throw new Error(
+      throw new EagleErrors.EagleInvalidArgumentError(
         `'pcm' size must be smaller than ${EagleProfiler._maxEnrollSamples}`
       );
     }
@@ -359,7 +485,7 @@ export class EagleProfiler extends EagleBase {
       this._functionMutex
         .runExclusive(async () => {
           if (this._wasmMemory === undefined) {
-            throw new Error('Attempted to call `.enroll()` after release');
+            throw new EagleErrors.EagleInvalidStateError('Attempted to call `.enroll()` after release');
           }
 
           const pcmAddress = await this._alignedAlloc(
@@ -367,24 +493,24 @@ export class EagleProfiler extends EagleBase {
             pcm.length * Int16Array.BYTES_PER_ELEMENT
           );
 
-          const memoryBufferInt16 = new Int16Array(this._wasmMemory.buffer);
-          memoryBufferInt16.set(pcm, pcmAddress / Int16Array.BYTES_PER_ELEMENT);
-
           const feedbackAddress = await this._alignedAlloc(
             Int32Array.BYTES_PER_ELEMENT,
             Int32Array.BYTES_PER_ELEMENT
           );
           if (feedbackAddress === 0) {
-            throw new Error('malloc failed: Cannot allocate memory');
+            throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
           }
           const percentageAddress = await this._alignedAlloc(
             Int32Array.BYTES_PER_ELEMENT,
             Int32Array.BYTES_PER_ELEMENT
           );
           if (percentageAddress === 0) {
-            throw new Error('malloc failed: Cannot allocate memory');
+            throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
           }
 
+          const memoryBufferInt16 = new Int16Array(this._wasmMemory.buffer);
+          memoryBufferInt16.set(pcm, pcmAddress / Int16Array.BYTES_PER_ELEMENT);
+
           const status = await this._pvEagleProfilerEnroll(
             this._objectAddress,
             pcmAddress,
@@ -397,24 +523,34 @@ export class EagleProfiler extends EagleBase {
             await this._pvFree(feedbackAddress);
             await this._pvFree(percentageAddress);
 
-            throw new Error(
-              `enroll failed with status ${arrayBufferToStringAtIndex(
-                this._memoryBufferUint8,
-                await this._pvStatusToString(status)
-              )}`
+            const memoryBufferView = new DataView(this._wasmMemory.buffer);
+            const memoryBufferUint8 = new Uint8Array(this._wasmMemory.buffer);
+
+            const messageStack = await EagleProfiler.getMessageStack(
+              this._pvGetErrorStack,
+              this._pvFreeErrorStack,
+              this._messageStackAddressAddressAddress,
+              this._messageStackDepthAddress,
+              memoryBufferView,
+              memoryBufferUint8
             );
+
+            throw pvStatusToException(status, "EagleProfiler enroll failed", messageStack);
           }
 
-          const feedback = this._memoryBufferView.getInt32(
+          const memoryBufferView = new DataView(this._wasmMemory.buffer);
+
+          const feedback = memoryBufferView.getInt32(
             feedbackAddress,
             true
           );
-          await this._pvFree(feedbackAddress);
 
-          const percentage = this._memoryBufferView.getFloat32(
+          const percentage = memoryBufferView.getFloat32(
             percentageAddress,
             true
           );
+
+          await this._pvFree(feedbackAddress);
           await this._pvFree(percentageAddress);
 
           return { feedback, percentage };
@@ -439,7 +575,7 @@ export class EagleProfiler extends EagleBase {
       this._functionMutex
         .runExclusive(async () => {
           if (this._wasmMemory === undefined) {
-            throw new Error('Attempted to call `.export()` after release');
+            throw new EagleErrors.EagleInvalidStateError('Attempted to call `.export()` after release');
           }
 
           const profileAddress = await this._alignedAlloc(
@@ -453,15 +589,25 @@ export class EagleProfiler extends EagleBase {
           );
           if (status !== PV_STATUS_SUCCESS) {
             await this._pvFree(profileAddress);
-            throw new Error(
-              `export failed with status ${arrayBufferToStringAtIndex(
-                this._memoryBufferUint8,
-                await this._pvStatusToString(status)
-              )}`
+
+            const memoryBufferView = new DataView(this._wasmMemory.buffer);
+            const memoryBufferUint8 = new Uint8Array(this._wasmMemory.buffer);
+
+            const messageStack = await EagleProfiler.getMessageStack(
+              this._pvGetErrorStack,
+              this._pvFreeErrorStack,
+              this._messageStackAddressAddressAddress,
+              this._messageStackDepthAddress,
+              memoryBufferView,
+              memoryBufferUint8
             );
+
+            throw pvStatusToException(status, "EagleProfiler export failed", messageStack);
           }
 
-          const profile = this._memoryBufferUint8.slice(
+          const memoryBufferUint8 = new Uint8Array(this._wasmMemory.buffer);
+
+          const profile = memoryBufferUint8.slice(
             profileAddress / Uint8Array.BYTES_PER_ELEMENT,
             profileAddress / Uint8Array.BYTES_PER_ELEMENT +
               EagleProfiler._profileSize
@@ -488,17 +634,24 @@ export class EagleProfiler extends EagleBase {
       this._functionMutex
         .runExclusive(async () => {
           if (this._wasmMemory === undefined) {
-            throw new Error('Attempted to call `.reset()` after release');
+            throw new EagleErrors.EagleInvalidStateError('Attempted to call `.reset()` after release');
           }
 
           const status = await this._pvEagleProfilerReset(this._objectAddress);
           if (status !== PV_STATUS_SUCCESS) {
-            throw new Error(
-              `reset failed with status ${arrayBufferToStringAtIndex(
-                this._memoryBufferUint8,
-                await this._pvStatusToString(status)
-              )}`
+            const memoryBufferView = new DataView(this._wasmMemory.buffer);
+            const memoryBufferUint8 = new Uint8Array(this._wasmMemory.buffer);
+
+            const messageStack = await EagleProfiler.getMessageStack(
+              this._pvGetErrorStack,
+              this._pvFreeErrorStack,
+              this._messageStackAddressAddressAddress,
+              this._messageStackDepthAddress,
+              memoryBufferView,
+              memoryBufferUint8
             );
+
+            throw pvStatusToException(status, "EagleProfiler reset failed", messageStack);
           }
         })
         .then(() => {
@@ -514,6 +667,7 @@ export class EagleProfiler extends EagleBase {
    * Releases resources acquired by Eagle Profiler
    */
   public async release(): Promise<void> {
+    await super.release();
     await this._pvEagleProfilerDelete(this._objectAddress);
     delete this._wasmMemory;
     this._wasmMemory = undefined;
@@ -548,7 +702,7 @@ export class EagleProfiler extends EagleBase {
       Int32Array.BYTES_PER_ELEMENT
     );
     if (objectAddressAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
 
     const accessKeyAddress = await baseWasmOutput.alignedAlloc(
@@ -556,7 +710,7 @@ export class EagleProfiler extends EagleBase {
       (accessKey.length + 1) * Uint8Array.BYTES_PER_ELEMENT
     );
     if (accessKeyAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
     for (let i = 0; i < accessKey.length; i++) {
       memoryBufferUint8[accessKeyAddress + i] = accessKey.charCodeAt(i);
@@ -569,7 +723,7 @@ export class EagleProfiler extends EagleBase {
       (modelPathEncoded.length + 1) * Uint8Array.BYTES_PER_ELEMENT
     );
     if (modelPathAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
     memoryBufferUint8.set(modelPathEncoded, modelPathAddress);
     memoryBufferUint8[modelPathAddress + modelPathEncoded.length] = 0;
@@ -581,18 +735,22 @@ export class EagleProfiler extends EagleBase {
     );
     await baseWasmOutput.pvFree(accessKeyAddress);
     await baseWasmOutput.pvFree(modelPathAddress);
-    if (status !== PV_STATUS_SUCCESS) {
-      const msg = `'pv_eagle_profiler_init' failed with status ${arrayBufferToStringAtIndex(
-        memoryBufferUint8,
-        await baseWasmOutput.pvStatusToString(status)
-      )}`;
 
-      throw new Error(
-        `${msg}\nDetails: ${baseWasmOutput.pvError.getErrorString()}`
+    const memoryBufferView = new DataView(baseWasmOutput.memory.buffer);
+
+    if (status !== PV_STATUS_SUCCESS) {
+      const messageStack = await EagleProfiler.getMessageStack(
+        baseWasmOutput.pvGetErrorStack,
+        baseWasmOutput.pvFreeErrorStack,
+        baseWasmOutput.messageStackAddressAddressAddress,
+        baseWasmOutput.messageStackDepthAddress,
+        memoryBufferView,
+        memoryBufferUint8
       );
+
+      throw pvStatusToException(status, "EagleProfiler init failed", messageStack, baseWasmOutput.pvError);
     }
 
-    const memoryBufferView = new DataView(baseWasmOutput.memory.buffer);
     const objectAddress = memoryBufferView.getInt32(objectAddressAddress, true);
     await baseWasmOutput.pvFree(objectAddressAddress);
 
@@ -601,7 +759,7 @@ export class EagleProfiler extends EagleBase {
       Int32Array.BYTES_PER_ELEMENT
     );
     if (minEnrollSamplesAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
 
     status = await pv_eagle_profiler_enroll_min_audio_length_samples(
@@ -609,14 +767,18 @@ export class EagleProfiler extends EagleBase {
       minEnrollSamplesAddress
     );
     if (status !== PV_STATUS_SUCCESS) {
-      const msg = `'pv_eagle_profiler_enroll_min_audio_length_samples' failed with status ${arrayBufferToStringAtIndex(
-        memoryBufferUint8,
-        await baseWasmOutput.pvStatusToString(status)
-      )}`;
-      throw new Error(
-        `${msg}\nDetails: ${baseWasmOutput.pvError.getErrorString()}`
+      const messageStack = await EagleProfiler.getMessageStack(
+        baseWasmOutput.pvGetErrorStack,
+        baseWasmOutput.pvFreeErrorStack,
+        baseWasmOutput.messageStackAddressAddressAddress,
+        baseWasmOutput.messageStackDepthAddress,
+        memoryBufferView,
+        memoryBufferUint8
       );
+
+      throw pvStatusToException(status, "EagleProfiler failed to get min enroll audio length", messageStack, baseWasmOutput.pvError);
     }
+
     const minEnrollSamples = memoryBufferView.getInt32(
       minEnrollSamplesAddress,
       true
@@ -628,7 +790,7 @@ export class EagleProfiler extends EagleBase {
       Int32Array.BYTES_PER_ELEMENT
     );
     if (profileSizeAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
 
     status = await pv_eagle_profiler_export_size(
@@ -636,13 +798,16 @@ export class EagleProfiler extends EagleBase {
       profileSizeAddress
     );
     if (status !== PV_STATUS_SUCCESS) {
-      const msg = `'pv_eagle_profiler_export_size' failed with status ${arrayBufferToStringAtIndex(
-        memoryBufferUint8,
-        await baseWasmOutput.pvStatusToString(status)
-      )}`;
-      throw new Error(
-        `${msg}\nDetails: ${baseWasmOutput.pvError.getErrorString()}`
+      const messageStack = await EagleProfiler.getMessageStack(
+        baseWasmOutput.pvGetErrorStack,
+        baseWasmOutput.pvFreeErrorStack,
+        baseWasmOutput.messageStackAddressAddressAddress,
+        baseWasmOutput.messageStackDepthAddress,
+        memoryBufferView,
+        memoryBufferUint8
       );
+
+      throw pvStatusToException(status, "EagleProfiler failed to get export size", messageStack, baseWasmOutput.pvError);
     }
 
     const profileSize = memoryBufferView.getInt32(profileSizeAddress, true);
@@ -702,7 +867,7 @@ export class Eagle extends EagleBase {
   /**
    * Creates an instance of the Picovoice Eagle Speaker Recognition Engine.
    *
-   * @param accessKey: AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
+   * @param accessKey AccessKey obtained from Picovoice Console (https://console.picovoice.ai/)
    * @param model Eagle model options.
    * @param model.base64 The model in base64 string to initialize Eagle.
    * @param model.publicPath The model path relative to the public directory.
@@ -737,11 +902,11 @@ export class Eagle extends EagleBase {
     speakerProfiles: EagleProfile[]
   ): Promise<Eagle> {
     if (!isAccessKeyValid(accessKey)) {
-      throw new Error('Invalid AccessKey');
+      throw new EagleErrors.EagleInvalidArgumentError('Invalid AccessKey');
     }
 
     if (!speakerProfiles || speakerProfiles.length === 0) {
-      throw new Error('No speaker profiles provided');
+      throw new EagleErrors.EagleInvalidArgumentError('No speaker profiles provided');
     }
 
     return new Promise<Eagle>((resolve, reject) => {
@@ -777,11 +942,11 @@ export class Eagle extends EagleBase {
    */
   public async process(pcm: Int16Array): Promise<number[]> {
     if (!(pcm instanceof Int16Array)) {
-      throw new Error("The argument 'pcm' must be provided as an Int16Array");
+      throw new EagleErrors.EagleInvalidArgumentError("The argument 'pcm' must be provided as an Int16Array");
     }
 
     if (pcm.length !== Eagle._frameLength) {
-      throw new Error(
+      throw new EagleErrors.EagleInvalidArgumentError(
         `Length of input frame (${pcm.length}) does not match required frame length (${Eagle._frameLength})`
       );
     }
@@ -790,7 +955,7 @@ export class Eagle extends EagleBase {
       this._functionMutex
         .runExclusive(async () => {
           if (this._wasmMemory === undefined) {
-            throw new Error('Attempted to call `.process` after release');
+            throw new EagleErrors.EagleInvalidStateError('Attempted to call `.process` after release');
           }
 
           const pcmAddress = await this._alignedAlloc(
@@ -808,18 +973,27 @@ export class Eagle extends EagleBase {
           );
           await this._pvFree(pcmAddress);
           if (status !== PV_STATUS_SUCCESS) {
-            throw new Error(
-              `process failed with status ${arrayBufferToStringAtIndex(
-                this._memoryBufferUint8,
-                await this._pvStatusToString(status)
-              )}`
+            const memoryBufferView = new DataView(this._wasmMemory.buffer);
+            const memoryBufferUint8 = new Uint8Array(this._wasmMemory.buffer);
+
+            const messageStack = await EagleProfiler.getMessageStack(
+              this._pvGetErrorStack,
+              this._pvFreeErrorStack,
+              this._messageStackAddressAddressAddress,
+              this._messageStackDepthAddress,
+              memoryBufferView,
+              memoryBufferUint8
             );
+
+            throw pvStatusToException(status, "Eagle process failed", messageStack);
           }
 
+          const memoryBufferView = new DataView(this._wasmMemory.buffer);
+
           const scores: number[] = [];
           for (let i = 0; i < this._numSpeakers; i++) {
             scores.push(
-              this._memoryBufferView.getFloat32(
+              memoryBufferView.getFloat32(
                 this._scoresAddress + i * Float32Array.BYTES_PER_ELEMENT,
                 true
               )
@@ -847,17 +1021,24 @@ export class Eagle extends EagleBase {
       this._functionMutex
         .runExclusive(async () => {
           if (this._wasmMemory === undefined) {
-            throw new Error('Attempted to call `.reset` after release');
+            throw new EagleErrors.EagleInvalidStateError('Attempted to call `.reset` after release');
           }
 
           const status = await this._pvEagleReset(this._objectAddress);
           if (status !== PV_STATUS_SUCCESS) {
-            throw new Error(
-              `reset failed with status ${arrayBufferToStringAtIndex(
-                this._memoryBufferUint8,
-                await this._pvStatusToString(status)
-              )}`
+            const memoryBufferView = new DataView(this._wasmMemory.buffer);
+            const memoryBufferUint8 = new Uint8Array(this._wasmMemory.buffer);
+
+            const messageStack = await EagleProfiler.getMessageStack(
+              this._pvGetErrorStack,
+              this._pvFreeErrorStack,
+              this._messageStackAddressAddressAddress,
+              this._messageStackDepthAddress,
+              memoryBufferView,
+              memoryBufferUint8
             );
+
+            throw pvStatusToException(status, "Eagle reset failed", messageStack);
           }
         })
         .then(() => {
@@ -873,6 +1054,7 @@ export class Eagle extends EagleBase {
    * Releases resources acquired by Eagle
    */
   public async release(): Promise<void> {
+    await super.release();
     await this._pvFree(this._scoresAddress);
     await this._pvEagleDelete(this._objectAddress);
     delete this._wasmMemory;
@@ -905,7 +1087,7 @@ export class Eagle extends EagleBase {
       Int32Array.BYTES_PER_ELEMENT
     );
     if (objectAddressAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
 
     const accessKeyAddress = await baseWasmOutput.alignedAlloc(
@@ -913,7 +1095,7 @@ export class Eagle extends EagleBase {
       (accessKey.length + 1) * Uint8Array.BYTES_PER_ELEMENT
     );
     if (accessKeyAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
     for (let i = 0; i < accessKey.length; i++) {
       memoryBufferUint8[accessKeyAddress + i] = accessKey.charCodeAt(i);
@@ -926,7 +1108,7 @@ export class Eagle extends EagleBase {
       (modelPathEncoded.length + 1) * Uint8Array.BYTES_PER_ELEMENT
     );
     if (modelPathAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
     memoryBufferUint8.set(modelPathEncoded, modelPathAddress);
     memoryBufferUint8[modelPathAddress + modelPathEncoded.length] = 0;
@@ -937,7 +1119,7 @@ export class Eagle extends EagleBase {
       numSpeakers * Int32Array.BYTES_PER_ELEMENT
     );
     if (profilesAddressAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
     const profilesAddressList: number[] = [];
     for (const profile of speakerProfiles) {
@@ -946,7 +1128,7 @@ export class Eagle extends EagleBase {
         profile.bytes.length * Uint8Array.BYTES_PER_ELEMENT
       );
       if (profileAddress === 0) {
-        throw new Error('malloc failed: Cannot allocate memory');
+        throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
       }
       memoryBufferUint8.set(profile.bytes, profileAddress);
       profilesAddressList.push(profileAddress);
@@ -965,18 +1147,22 @@ export class Eagle extends EagleBase {
     await baseWasmOutput.pvFree(accessKeyAddress);
     await baseWasmOutput.pvFree(modelPathAddress);
     await baseWasmOutput.pvFree(profilesAddressAddress);
-    if (status !== PV_STATUS_SUCCESS) {
-      const msg = `'pv_eagle_init' failed with status ${arrayBufferToStringAtIndex(
-        memoryBufferUint8,
-        await baseWasmOutput.pvStatusToString(status)
-      )}`;
 
-      throw new Error(
-        `${msg}\nDetails: ${baseWasmOutput.pvError.getErrorString()}`
+    const memoryBufferView = new DataView(baseWasmOutput.memory.buffer);
+
+    if (status !== PV_STATUS_SUCCESS) {
+      const messageStack = await EagleProfiler.getMessageStack(
+        baseWasmOutput.pvGetErrorStack,
+        baseWasmOutput.pvFreeErrorStack,
+        baseWasmOutput.messageStackAddressAddressAddress,
+        baseWasmOutput.messageStackDepthAddress,
+        memoryBufferView,
+        memoryBufferUint8
       );
+
+      throw pvStatusToException(status, "Eagle init failed", messageStack, baseWasmOutput.pvError);
     }
 
-    const memoryBufferView = new DataView(baseWasmOutput.memory.buffer);
     const objectAddress = memoryBufferView.getInt32(objectAddressAddress, true);
     await baseWasmOutput.pvFree(objectAddressAddress);
 
@@ -985,7 +1171,7 @@ export class Eagle extends EagleBase {
       numSpeakers * Float32Array.BYTES_PER_ELEMENT
     );
     if (scoresAddress === 0) {
-      throw new Error('malloc failed: Cannot allocate memory');
+      throw new EagleErrors.EagleOutOfMemoryError('malloc failed: Cannot allocate memory');
     }
 
     const frameLength = await pv_eagle_frame_length();