How to use the virtual-audio-graph.gain function in virtual-audio-graph

1: oscillator(0, {
    detune: carrierDetune,
    frequency,
    startTime,
    stopTime,
    type: carrierOscType,
  }),
  2: gainNode({destination: 'frequency', key: 1}, {gain: 1024}),
  3: oscillator(2, {
    detune: modulatorDetune,
    frequency: frequency * modulatorRatio,
    startTime,
    stopTime,
    type: modulatorOscType,
  }),
  masterGain: gainNode(['output'], {gain: masterGain}),
  masterPan: stereoPanner(['masterGain'], {pan: masterPan}),
}))

const updateAudioGraph = virtualAudioGraph => ({
  delayTime,
  dryLevel,
  feedback,
  highCut,
  lowCut,
  pingPong,
  wetLevel,
}) => virtualAudioGraph.update({
  0: gain('output', {gain: wetLevel}),
  1: stereoPanner(0, {pan: -1}),
  2: stereoPanner(0, {pan: 1}),
  3: delay([2, 8], {delayTime, maxDelayTime}),
  4: gain(3, {gain: feedback}),
  5: delay(pingPong ? [1, 3] : [0, 8], {delayTime, maxDelayTime}),
  6: biquadFilter(5, {frequency: highCut}),
  7: biquadFilter(6, {frequency: lowCut, type: 'highpass'}),
  8: gain(7, {gain: feedback}),
  9: gain('output', {gain: dryLevel}),
  input: gain([8, 9], {gain: 1}, 'input'),
})

bufferPromise.then(buffer => virtualAudioGraph.update({
    0: gain('output', {gain: dryLevel}),
    1: biquadFilter('output', {frequency: highCut}),
    2: biquadFilter(1, {frequency: lowCut, type: 'highpass'}),
    3: gain(2, {gain: wetLevel}),
    4: gain(3, {gain: 0.5}),
    5: convolver(4, {buffer}, 'input'),
    input: gain([0, 5]),
  }))
  reverbTypeToBufferPromise[reverbType] = bufferPromise

notes.reduce((acc, {frequency, gain, id, startTime, stopTime}) => {
    const noteGainId = `noteGain-${id}`
    acc[noteGainId] = gainNode('filter', {gain})

    for (let i = 0; i < oscillatorSingles.length; i++) {
      const oscillatorSingle = oscillatorSingles[i]
      acc[`oscSingle-${oscillatorSingle.id}-${id}`] = osc(noteGainId, Object.assign({}, oscillatorSingle, {frequency, startTime, stopTime}))
    }

    for (let i = 0; i < oscillatorSupers.length; i++) {
      const oscillatorSuper = oscillatorSupers[i]
      const {numberOfOscillators, type} = oscillatorSuper
      for (let j = 0; j < numberOfOscillators; j++) {
        acc[`oscSuper-${oscillatorSuper.id}-${j}-${id}`] = osc(noteGainId, {
          detune: oscillatorSuper.detune + (j - Math.floor(numberOfOscillators / 2)) * oscillatorSuper.spread,
          frequency,
          gain: oscillatorSuper.gain,
          pan: oscillatorSuper.pan,
          pitch: oscillatorSuper.pitch,

feedback,
  highCut,
  lowCut,
  pingPong,
  wetLevel,
}) => virtualAudioGraph.update({
  0: gain('output', {gain: wetLevel}),
  1: stereoPanner(0, {pan: -1}),
  2: stereoPanner(0, {pan: 1}),
  3: delay([2, 8], {delayTime, maxDelayTime}),
  4: gain(3, {gain: feedback}),
  5: delay(pingPong ? [1, 3] : [0, 8], {delayTime, maxDelayTime}),
  6: biquadFilter(5, {frequency: highCut}),
  7: biquadFilter(6, {frequency: lowCut, type: 'highpass'}),
  8: gain(7, {gain: feedback}),
  9: gain('output', {gain: dryLevel}),
  input: gain([8, 9], {gain: 1}, 'input'),
})

bufferPromise.then(buffer => virtualAudioGraph.update({
    0: gain('output', {gain: dryLevel}),
    1: biquadFilter('output', {frequency: highCut}),
    2: biquadFilter(1, {frequency: lowCut, type: 'highpass'}),
    3: gain(2, {gain: wetLevel}),
    4: gain(3, {gain: 0.5}),
    5: convolver(4, {buffer}, 'input'),
    input: gain([0, 5]),
  }))
  reverbTypeToBufferPromise[reverbType] = bufferPromise

const oscBank = createNode(({
  carrierDetune,
  carrierOscType,
  gain,
  frequency,
  masterGain,
  masterPan,
  modulatorDetune,
  modulatorOscType,
  modulatorRatio,
  startTime,
  stopTime,
}) => ({
  0: gainNode(['masterPan'], {gain}),
  1: oscillator(0, {
    detune: carrierDetune,
    frequency,
    startTime,
    stopTime,
    type: carrierOscType,
  }),
  2: gainNode({destination: 'frequency', key: 1}, {gain: 1024}),
  3: oscillator(2, {
    detune: modulatorDetune,
    frequency: frequency * modulatorRatio,
    startTime,
    stopTime,
    type: modulatorOscType,
  }),
  masterGain: gainNode(['output'], {gain: masterGain}),

const updateAudioGraph = virtualAudioGraph => ({
  delayTime,
  dryLevel,
  feedback,
  highCut,
  lowCut,
  pingPong,
  wetLevel,
}) => virtualAudioGraph.update({
  0: gain('output', {gain: wetLevel}),
  1: stereoPanner(0, {pan: -1}),
  2: stereoPanner(0, {pan: 1}),
  3: delay([2, 8], {delayTime, maxDelayTime}),
  4: gain(3, {gain: feedback}),
  5: delay(pingPong ? [1, 3] : [0, 8], {delayTime, maxDelayTime}),
  6: biquadFilter(5, {frequency: highCut}),
  7: biquadFilter(6, {frequency: lowCut, type: 'highpass'}),
  8: gain(7, {gain: feedback}),
  9: gain('output', {gain: dryLevel}),
  input: gain([8, 9], {gain: 1}, 'input'),
})

const osc = createNode(({detune, frequency, gain, pan, pitch, startTime, stopTime, type}) => ({
  0: gainNode('output', {gain}),
  1: stereoPanner(0, {pan}),
  2: oscillator(1, {
    detune,
    frequency: pitchToFrequency(frequencyToPitch(frequency) + pitch),
    startTime,
    stopTime,
    type,
  }),
}))

const paramsToGraph = ({tapeSpeed, feedbackAmount, reader1Position, audioBuffer, mix, lowpass}) => {
  //ensure a new node is created each time
  const bufferSourceDry = `bufferSourceDry${new Date().getTime()}`;
  const bufferSourceWet = `bufferSourceWet${new Date().getTime()}`;
  return {
    master: gain('output', {gain: 0.7}),
    dry: gain('master', {gain: normDry(mix)}),
    wet: gain('master', {gain: normWet(mix)}),
    feedback: gain(['delay'], {gain: normFeedback(feedbackAmount)}),
    lowpass: biquadFilter(['feedback', 'wet'], {type: 'lowpass', frequency: normFrequency(lowpass)}),
    delay: delay('lowpass', {delayTime: normDelay(reader1Position)}),
    [bufferSourceDry]: bufferSource('dry', {buffer: audioBuffer, loop: true}),
    [bufferSourceWet]: bufferSource('delay', {buffer: audioBuffer, loop: true, playbackRate: normSpeed(tapeSpeed)}),
  };
};