node-web-audio-api 0.20.0 → 0.21.0

package/js/AudioWorkletNode.js

@@ -0,0 +1,290 @@
+/* eslint-disable no-unused-vars */
+const conversions = require('webidl-conversions');
+const {
+  toSanitizedSequence,
+} = require('./lib/cast.js');
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  kNapiObj,
+  kProcessorRegistered,
+  kGetParameterDescriptors,
+  kPrivateConstructor,
+  kCreateProcessor,
+} = require('./lib/symbols.js');
+const {
+  kEnumerableProperty,
+} = require('./lib/utils.js');
+const {
+  propagateEvent,
+} = require('./lib/events.js');
+const {
+  ErrorEvent,
+} = require('./Events.js');
+
+/* eslint-enable no-unused-vars */
+
+const AudioNode = require('./AudioNode.js');
+const AudioParamMap = require('./AudioParamMap.js');
+const IMPLEMENTATION_MAX_NUMBER_OF_CHANNELS = 32;
+
+module.exports = (jsExport, nativeBinding) => {
+  class AudioWorkletNode extends AudioNode {
+    #port = null;
+    #parameters = {};
+
+    constructor(context, name, options) {
+      if (arguments.length < 2) {
+        throw new TypeError(`Failed to construct 'AudioWorkletNode': 2 arguments required, but only ${arguments.length} present`);
+      }
+
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'AudioWorkletNode': argument 1 is not of type BaseAudioContext`);
+      }
+
+      const parsedName = conversions['DOMString'](name, {
+        context: `Failed to construct 'AudioWorkletNode': The given 'AudioWorkletProcessor' name`,
+      });
+
+      if (!context.audioWorklet[kProcessorRegistered](parsedName)) {
+        throw new DOMException(`Failed to construct 'AudioWorkletNode': processor '${parsedName}' is not registered in 'AudioWorklet'`, 'InvalidStateError');
+      }
+
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
+
+      if (options && (typeof options !== 'object' || options === null)) {
+        throw new TypeError('Failed to construct \'AudioWorkletNode\': argument 3 is not of type \'AudioWorkletNodeOptions\'');
+      }
+
+      if (options && options.numberOfInputs !== undefined) {
+        parsedOptions.numberOfInputs = conversions['unsigned long'](options.numberOfInputs, {
+          enforceRange: true,
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'numberOfInputs' property from AudioWorkletNodeOptions: The provided value (${options.numberOfInputs}})`,
+        });
+      } else {
+        parsedOptions.numberOfInputs = 1;
+      }
+
+      if (options && options.numberOfOutputs !== undefined) {
+        parsedOptions.numberOfOutputs = conversions['unsigned long'](options.numberOfOutputs, {
+          enforceRange: true,
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'numberOfOutputs' property from AudioWorkletNodeOptions: The provided value (${options.numberOfOutputs}})`,
+        });
+      } else {
+        parsedOptions.numberOfOutputs = 1;
+      }
+
+      // If outputChannelCount exists,
+      // - If any value in outputChannelCount is zero or greater than the implementation’s maximum number of channels, throw a NotSupportedError and abort the remaining steps.
+      // - If the length of outputChannelCount does not equal numberOfOutputs, throw an IndexSizeError and abort the remaining steps.
+      // - If both numberOfInputs and numberOfOutputs are 1, set the channel count of the node output to the one value in outputChannelCount.
+      // - Otherwise set the channel count of the kth output of the node to the kth element of outputChannelCount sequence and return.
+      if (options && options.outputChannelCount !== undefined) {
+        try {
+          parsedOptions.outputChannelCount = toSanitizedSequence(options.outputChannelCount, Uint32Array);
+        } catch (err) {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Failed to read the 'outputChannelCount' property from AudioWorkletNodeOptions: The provided value ${err.message}`);
+        }
+
+        parsedOptions.outputChannelCount.forEach((value, index) => {
+          if (value <= 0 || value > IMPLEMENTATION_MAX_NUMBER_OF_CHANNELS) {
+            throw new DOMException(`Failed to construct 'AudioWorkletNode': Invalid 'outputChannelCount' property from AudioWorkletNodeOptions: Value at index ${index} in outside supported range [1, 32]`, 'NotSupportedError');
+          }
+        });
+
+        if (parsedOptions.numberOfOutputs !== parsedOptions.outputChannelCount.length) {
+          throw new DOMException(`Failed to construct 'AudioWorkletNode': Invalid 'outputChannelCount' property from AudioWorkletNodeOptions: 'outputChannelCount' length (${parsedOptions.outputChannelCount.length}) does not equal 'numberOfOutputs' (${parsedOptions.numberOfOutputs})`, 'IndexSizeError');
+        }
+      } else {
+        // If outputChannelCount does not exists,
+        // - If both numberOfInputs and numberOfOutputs are 1, set the initial channel count of the node output to 1 and return.
+        //   NOTE: For this case, the output chanel count will change to computedNumberOfChannels dynamically based on the input and the channelCountMode at runtime.
+        // - Otherwise set the channel count of each output of the node to 1 and return.
+
+        // @note - not sure what this means, let's go simple
+        parsedOptions.outputChannelCount = new Uint32Array(parsedOptions.numberOfOutputs);
+        parsedOptions.outputChannelCount.fill(1);
+      }
+
+      // @todo
+      // - This should be a "record", let's treat it as a raw object of now
+      // - Check if this needs to checked against the declared `parameterDescriptors`
+      if (options && options.parameterData !== undefined) {
+        if (typeof options.parameterData === 'object' && options.parameterData !== null) {
+          parsedOptions.parameterData = {};
+
+          for (let [key, value] in Object.entries(options.parameterData)) {
+            const parsedKey = conversions['DOMString'](key, {
+              context: `Failed to construct 'AudioWorkletNode': Invalid 'parameterData' property from AudioWorkletNodeOptions: Invalid key (${key})`,
+            });
+
+            const parsedValue = conversions['double'](value, {
+              context: `Failed to construct 'AudioWorkletNode': Invalid 'parameterData' property from AudioWorkletNodeOptions: Invalid value for key ${parsedKey}`,
+            });
+
+            parsedOptions.parameterData[parsedKey] = parsedValue;
+          }
+        } else {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Invalid 'parameterData' property from AudioWorkletNodeOptions: 'outputChannelCount' length (${parsedOptions.outputChannelCount.length}) does not equal 'numberOfOutputs' (${parsedOptions.numberOfOutputs})`);
+        }
+      } else {
+        parsedOptions.parameterData = {};
+      }
+
+      // These ones are for the JS processor
+      if (options && options.processorOptions !== undefined) {
+        if (typeof options.processorOptions === 'object' && options.processorOptions !== null) {
+          parsedOptions.processorOptions = Object.assign({}, options.processorOptions);
+        } else {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Invalid 'processorOptions' property from AudioWorkletNodeOptions: 'processorOptions' is not an object`);
+        }
+      } else {
+        parsedOptions.processorOptions = {};
+      }
+
+      // AudioNodeOptions
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'channelCount' property from AudioWorkletNodeOptions: The provided value '${options.channelCount}'`,
+        });
+
+        // if we delegate this check to Rust, this can poison a Mutex
+        // (probably the `audio_param_descriptor_channel` one)
+        if (parsedOptions.channelCount <= 0 || parsedOptions.channelCount > IMPLEMENTATION_MAX_NUMBER_OF_CHANNELS) {
+          throw new DOMException(`Failed to construct 'AudioWorkletNode': Invalid 'channelCount' property: Number of channels: ${parsedOptions.channelCount} is outside range [1, 32]`, 'NotSupportedError')
+        }
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        if (!['max', 'clamped-max', 'explicit'].includes(options.channelCountMode)) {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Failed to read the 'channelCountMode' property from 'AudioNodeOptions': The provided value '${options.channelCountMode}' is not a valid enum value of type ChannelCountMode`);
+        }
+
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'channelCount' property from AudioWorkletNodeOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        if (!['speakers', 'discrete'].includes(options.channelInterpretation)) {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Failed to read the 'channelInterpretation' property from 'AudioNodeOptions': The provided value '${options.channelInterpretation}' is not a valid enum value of type ChannelCountMode`);
+        }
+
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'channelInterpretation' property from AudioWorkletNodeOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      // Create NapiAudioWorkletNode
+      const parameterDescriptors = context.audioWorklet[kGetParameterDescriptors](parsedName);
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.AudioWorkletNode(
+          context[kNapiObj],
+          parsedName,
+          parsedOptions,
+          parameterDescriptors,
+        );
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+      let parameters = new Map();
+
+      for (let name in this[kNapiObj].parameters) {
+        const audioParam = new jsExport.AudioParam({
+          [kNapiObj]: this[kNapiObj].parameters[name],
+        });
+
+        parameters.set(name, audioParam);
+      }
+
+      this.#parameters = new AudioParamMap({
+        [kPrivateConstructor]: true,
+        parameters,
+      });
+
+      // Create JS processor
+      this.#port = context.audioWorklet[kCreateProcessor](
+        parsedName,
+        parsedOptions,
+        napiObj.id,
+      );
+
+      this.#port.on('message', msg => {
+        // ErrorEvent named processorerror
+        switch (msg.cmd) {
+          case 'node-web-audio-api:worklet:ctor-error': {
+            const message = `Failed to construct '${parsedName}' AudioWorkletProcessor: ${msg.err.message}`;
+            const event = new ErrorEvent('processorerror', { message, error: msg.err });
+            propagateEvent(this, event);
+            break;
+          }
+          case 'node-web-audio-api:worklet:process-invalid': {
+            const message = `Failed to execute 'process' on '${parsedName}' AudioWorkletProcessor: ${msg.err.message}`;
+            const error = new TypeError(message);
+            error.stack = msg.err.stack.replace(msg.err.message, message);
+
+            const event = new ErrorEvent('processorerror', { message, error });
+            propagateEvent(this, event);
+            break;
+          }
+          case 'node-web-audio-api:worklet:process-error': {
+            const message = `Failed to execute 'process' on '${parsedName}' AudioWorkletProcessor: ${msg.err.message}`;
+            const event = new ErrorEvent('processorerror', { message, error: msg.err });
+            propagateEvent(this, event);
+            break;
+          }
+        }
+      });
+    }
+
+    get parameters() {
+      if (!(this instanceof AudioWorkletNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioWorkletNode\'');
+      }
+
+      return this.#parameters;
+    }
+
+    get port() {
+      if (!(this instanceof AudioWorkletNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioWorkletNode\'');
+      }
+
+      return this.#port;
+    }
+  }
+
+  Object.defineProperties(AudioWorkletNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 2,
+    },
+  });
+
+  Object.defineProperties(AudioWorkletNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'AudioWorkletNode',
+    },
+    parameters: kEnumerableProperty,
+    port: kEnumerableProperty,
+  });
+
+  return AudioWorkletNode;
+};

package/js/BaseAudioContext.js

@@ -24,12 +24,16 @@ const {
 } = require('./lib/utils.js');
 const {
   kNapiObj,
+  kPrivateConstructor,
 } = require('./lib/symbols.js');
 
+const AudioWorklet = require('./AudioWorklet.js');
+
 module.exports = (jsExport, _nativeBinding) => {
   class BaseAudioContext extends EventTarget {
-    #listener = null;
+    #audioWorklet = null;
     #destination = null;
+    #listener = null;
 
     constructor(options) {
       // Make constructor "private"
@@ -47,24 +51,23 @@ module.exports = (jsExport, _nativeBinding) => {
         ...kHiddenProperty,
       });
 
-      this.#listener = null; // lazily instanciated
+      this.#audioWorklet = new AudioWorklet({
+        [kPrivateConstructor]: true,
+        workletId: this[kNapiObj].workletId,
+        sampleRate: this[kNapiObj].sampleRate,
+      });
+
       this.#destination = new jsExport.AudioDestinationNode(this, {
         [kNapiObj]: this[kNapiObj].destination,
       });
     }
 
-    get listener() {
+    get audioWorklet() {
       if (!(this instanceof BaseAudioContext)) {
         throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
       }
 
-      if (this.#listener === null) {
-        this.#listener = new jsExport.AudioListener({
-          [kNapiObj]: this[kNapiObj].listener,
-        });
-      }
-
-      return this.#listener;
+      return this.#audioWorklet;
     }
 
     get destination() {
@@ -75,6 +78,20 @@ module.exports = (jsExport, _nativeBinding) => {
       return this.#destination;
     }
 
+    get listener() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      if (this.#listener === null) {
+        this.#listener = new jsExport.AudioListener({
+          [kNapiObj]: this[kNapiObj].listener,
+        });
+      }
+
+      return this.#listener;
+    }
+
     get sampleRate() {
       if (!(this instanceof BaseAudioContext)) {
         throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
@@ -91,6 +108,15 @@ module.exports = (jsExport, _nativeBinding) => {
       return this[kNapiObj].currentTime;
     }
 
+    // @todo - implement in upstream crate + pass to AudioWorkletGlobalScope
+    // get renderQuantumSize() {
+    //   if (!(this instanceof BaseAudioContext)) {
+    //     throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'BaseAudioContext'");
+    //   }
+
+    //   return this[kNapiObj].renderQuantumSize;
+    // }
+
     get state() {
       if (!(this instanceof BaseAudioContext)) {
         throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
@@ -99,9 +125,6 @@ module.exports = (jsExport, _nativeBinding) => {
       return this[kNapiObj].state;
     }
 
-    // renderQuantumSize
-    // audioWorklet
-
     get onstatechange() {
       if (!(this instanceof BaseAudioContext)) {
         throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');

package/js/Events.js

@@ -6,8 +6,12 @@ class OfflineAudioCompletionEvent extends Event {
   constructor(type, eventInitDict) {
     super(type);
 
-    if (typeof eventInitDict !== 'object' || eventInitDict === null || !('renderedBuffer' in eventInitDict)) {
-      throw TypeError(`Failed to construct 'OfflineAudioCompletionEvent': Failed to read the 'renderedBuffer' property from 'OfflineAudioCompletionEvent': Required member is undefined.`);
+    if (
+      typeof eventInitDict !== 'object'
+      || eventInitDict === null
+      || !('renderedBuffer' in eventInitDict)
+    ) {
+      throw TypeError(`Failed to construct 'OfflineAudioCompletionEvent': Invalid 'OfflineAudioCompletionEventInit' dict given`);
     }
 
     this.#renderedBuffer = eventInitDict.renderedBuffer;
@@ -26,7 +30,6 @@ Object.defineProperties(OfflineAudioCompletionEvent.prototype, {
     configurable: true,
     value: 'OfflineAudioCompletionEvent',
   },
-
   renderedBuffer: kEnumerableProperty,
 });
 
@@ -43,7 +46,7 @@ class AudioProcessingEvent extends Event {
       || !('inputBuffer' in eventInitDict)
       || !('outputBuffer' in eventInitDict)
     ) {
-      throw TypeError(`Failed to construct 'AudioProcessingEvent': Invalid 'AudioProcessingEventInit' given`);
+      throw TypeError(`Failed to construct 'AudioProcessingEvent': Invalid 'AudioProcessingEventInit' dict given`);
     }
 
     super(type);
@@ -74,11 +77,154 @@ Object.defineProperties(AudioProcessingEvent.prototype, {
     configurable: true,
     value: 'AudioProcessingEvent',
   },
-
   playbackTime: kEnumerableProperty,
   inputBuffer: kEnumerableProperty,
   outputBuffer: kEnumerableProperty,
 });
 
+class AudioRenderCapacityEvent extends Event {
+  #timestamp = 0;
+  #averageLoad = 0;
+  #peakLoad = 0;
+  #underrunRatio = 0;
+
+  constructor(type, eventInitDict) {
+    if (
+      typeof eventInitDict !== 'object'
+      || eventInitDict === null
+      || !('timestamp' in eventInitDict)
+      || !('averageLoad' in eventInitDict)
+      || !('peakLoad' in eventInitDict)
+      || !('underrunRatio' in eventInitDict)
+    ) {
+      throw TypeError(`Failed to construct 'AudioRenderCapacityEvent': Invalid 'AudioRenderCapacityEventInit' dict given`);
+    }
+
+    super(type);
+
+    this.#timestamp = eventInitDict.timestamp;
+    this.#averageLoad = eventInitDict.averageLoad;
+    this.#peakLoad = eventInitDict.peakLoad;
+    this.#underrunRatio = eventInitDict.underrunRatio;
+  }
+
+  get timestamp() {
+    return this.#timestamp;
+  }
+
+  get averageLoad() {
+    return this.#averageLoad;
+  }
+
+  get peakLoad() {
+    return this.#peakLoad;
+  }
+
+  get underrunRatio() {
+    return this.#underrunRatio;
+  }
+}
+
+Object.defineProperties(AudioRenderCapacityEvent.prototype, {
+  [Symbol.toStringTag]: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 'AudioRenderCapacityEvent',
+  },
+  timestamp: kEnumerableProperty,
+  averageLoad: kEnumerableProperty,
+  peakLoad: kEnumerableProperty,
+  underrunRatio: kEnumerableProperty,
+});
+
+// https://html.spec.whatwg.org/multipage/webappapis.html#errorevent
+// interface ErrorEvent : Event {
+//   constructor(DOMString type, optional ErrorEventInit eventInitDict = {});
+
+//   readonly attribute DOMString message;
+//   readonly attribute USVString filename;
+//   readonly attribute unsigned long lineno;
+//   readonly attribute unsigned long colno;
+//   readonly attribute any error;
+// };
+
+// dictionary ErrorEventInit : EventInit {
+//   DOMString message = "";
+//   USVString filename = "";
+//   unsigned long lineno = 0;
+//   unsigned long colno = 0;
+//   any error;
+// };
+class ErrorEvent extends Event {
+  #message = '';
+  #filename = '';
+  #lineno = 0;
+  #colno = 0;
+  #error = undefined;
+
+  constructor(type, eventInitDict = {}) {
+    super(type);
+
+    if (eventInitDict && typeof eventInitDict.message === 'string') {
+      this.#message = eventInitDict.message;
+    }
+
+    if (eventInitDict && typeof eventInitDict.filename === 'string') {
+      this.#filename = eventInitDict.filename;
+    }
+
+    if (eventInitDict && Number.isFinite(eventInitDict.lineno)) {
+      this.#lineno = eventInitDict.lineno;
+    }
+
+    if (eventInitDict && Number.isFinite(eventInitDict.colno)) {
+      this.#colno = eventInitDict.colno;
+    }
+
+    if (eventInitDict && eventInitDict.error instanceof Error) {
+      this.#error = eventInitDict.error;
+    }
+  }
+
+  get message() {
+    return this.#message;
+  }
+
+  get filename() {
+    return this.#filename;
+  }
+
+  get lineno() {
+    return this.#lineno;
+  }
+
+  get colno() {
+    return this.#colno;
+  }
+
+  get error() {
+    return this.#error;
+  }
+}
+
+Object.defineProperties(ErrorEvent.prototype, {
+  [Symbol.toStringTag]: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 'ErrorEvent',
+  },
+  message: kEnumerableProperty,
+  filename: kEnumerableProperty,
+  lineno: kEnumerableProperty,
+  colno: kEnumerableProperty,
+  error: kEnumerableProperty,
+});
+
 module.exports.OfflineAudioCompletionEvent = OfflineAudioCompletionEvent;
 module.exports.AudioProcessingEvent = AudioProcessingEvent;
+module.exports.AudioRenderCapacityEvent = AudioRenderCapacityEvent;
+module.exports.ErrorEvent = ErrorEvent;

package/js/OfflineAudioContext.js

@@ -12,8 +12,10 @@ const {
 } = require('./lib/utils.js');
 const {
   kNapiObj,
+  kWorkletRelease,
   kOnStateChange,
   kOnComplete,
+  kCheckProcessorsCreated,
 } = require('./lib/symbols.js');
 
 module.exports = function patchOfflineAudioContext(jsExport, nativeBinding) {
@@ -140,6 +142,9 @@ module.exports = function patchOfflineAudioContext(jsExport, nativeBinding) {
         throw new TypeError(`Invalid Invocation: Value of 'this' must be of type 'OfflineAudioContext'`);
       }
 
+      // ensure all AudioWorkletProcessor have finished their instanciation
+      await this.audioWorklet[kCheckProcessorsCreated]();
+
       let nativeAudioBuffer;
 
       try {
@@ -148,7 +153,10 @@ module.exports = function patchOfflineAudioContext(jsExport, nativeBinding) {
         throwSanitizedError(err);
       }
 
-      // @fixme: workaround the fact that this event seems to be triggered before
+      // release audio worklet, if any
+      await this.audioWorklet[kWorkletRelease]();
+
+      // workaround the fact that this event seems to be triggered before
       // startRendering fulfills and that we want to return the exact same instance
       if (this.#renderedBuffer === null) {
         this.#renderedBuffer = new jsExport.AudioBuffer({ [kNapiObj]: nativeAudioBuffer });

package/js/lib/symbols.js

@@ -1,6 +1,11 @@
 module.exports.kNapiObj = Symbol('node-web-audio-api:napi-obj');
 module.exports.kAudioBuffer = Symbol('node-web-audio-api:audio-buffer');
-
+module.exports.kPrivateConstructor = Symbol('node-web-audio-api:private-constructor');
+module.exports.kCreateProcessor = Symbol('node-web-audio-api:create-processor');
+module.exports.kProcessorRegistered = Symbol('node-web-audio-api:processor-registered');
+module.exports.kGetParameterDescriptors = Symbol('node-web-audio-api:get-parameter-descriptors');
+module.exports.kWorkletRelease = Symbol('node-web-audio-api:worklet-release');
+module.exports.kCheckProcessorsCreated = Symbol('node-web-audio-api:check-processor-created');
 
 // semi-private keys for events listeners
 
@@ -17,4 +22,5 @@ module.exports.kOnComplete = Symbol.for('node-web-audio-api:oncomplete');
 module.exports.kOnEnded = Symbol.for('node-web-audio-api:onended');
 // # ScriptProcessorNode
 module.exports.kOnAudioProcess = Symbol.for('node-web-audio-api:onaudioprocess');
-
+// # AudioRenderCapacity
+module.exports.kOnUpdate = Symbol.for('node-web-audio-api:onupdate');