Let me start by checking what version of Tone.js is available and its API, then build the pentatonic pad grid app.

Let me first look at the tone.min.js file to understand what's available.

Good, tone.min.js is present (349KB). Now let me build a pentatonic pad grid app. I'll create a single index.html file with:

1. A grid of pentatonic notes (e.g., C4 to C6 in a pentatonic scale)
2. Clickable pads that trigger a synth voice with reverb
3. A play/stop button for an arpeggiator sequence
4. Adjustable tempo slider
5. All sounds synthesized using Tone.js (PolySynth, Reverb, etc.)
6. No external resources

Pentatonic scale: C, D, E, G, A (and their octaves)

I'll use Tone.js API:
- Tone.PolySynth for the synth voice
- Tone.Reverb for reverb
- Tone.Arpeggiator or manual sequence for arpeggiation
- Tone.Transport for timing

Let me design the grid:
- Pentatonic notes across 2-3 octaves
- C4, D4, E4, G4, A4, C5, D5, E5, G5, A5 - that's 10 pads in a 5x2 grid
- Or better: 3 octaves worth: C4-C5-C6 range: C4 D4 E4 G4 A4 C5 D5 E5 G5 A5 C6 D6 E6 G6 A6 = 15 notes in 3x5 grid

Let me build a visually appealing grid with a dark theme.

For the arpeggiator: I'll create a pattern that cycles through some of the pentatonic notes and plays them in sequence. The tempo can be adjusted with a slider.

Let me write the full HTML file:

Structure:
- Header with title
- A grid of pads (5 columns x 3 rows for 3 octaves)
- Transport controls (Play/Stop button + Tempo slider)
- Maybe a pattern selector or indicator

Actually, let me think about the layout more carefully:
- Top: title
- Middle: pad grid (could be 5 columns, 3 rows for C4-A4, C5-A5, C6-A6)
- Bottom: controls - play/stop button, tempo slider, maybe a note display showing the arpeggiator sequence

For the synth:
- PolySynth with a warm pad-like sound
- Connect through Reverb
- Use Tone.Destination

For the arpeggiator:
- I'll use Tone.Transport.scheduleRepeat to play a sequence
- The sequence can be a preset pattern of pentatonic notes
- Play/Stop toggles the transport

Let me also add:
- Visual feedback on pads (highlight when played)
- Current step indicator for the arpeggiator
- Maybe allow clicking pads to add/remove them from the sequence

Actually, let me keep it simpler and focus on what was asked:
1. Clickable pentatonic pad grid - clicking a pad triggers a synth voice with reverb
2. Play/stop button that runs an arpeggiator sequence
3. Adjustable tempo

Let me make the arpeggiator sequence editable by clicking pads. When the user clicks pads while arpeggiator mode is active, they add notes to the sequence. Or, I can have a pre-set sequence and let the user modify it.

I'll go with: a preset arpeggiator pattern that the user can customize by clicking pads. Or even simpler: the arpeggiator just cycles through the pentatonic notes in order, and the user can change which notes are active.

Let me think... I'll make each pad toggleable for the arpeggiator sequence. Bright pads are "active" in the sequence, dimmed pads are skipped. The arpeggiator cycles through all active pads in order. When clicked in "play" mode, pads toggle their active state and also sound. When clicked in "stop" mode, pads just sound.

Actually, let me keep it clean:
- Clicking any pad always triggers the sound with reverb (immediate feedback)
- The arpeggiator has its own set of "active" notes. I'll add a small indicator on each pad showing if it's part of the arpeggiator sequence.
- Right-clicking or shift-clicking toggles whether a note is in the arpeggiator sequence.
- Or I'll use a separate row of toggle buttons.

Let me simplify: all pads are part of the arpeggiator by default. The arpeggiator cycles through them. The user can adjust tempo.

Actually, let me just make it beautiful and functional. I'll have:
- The pad grid: each pad plays a note on click
- The arpeggiator: a looping sequence that plays through selected notes
- I'll add toggle switches on each pad for arpeggiator inclusion
- Tempo slider
- Play/Stop button

Let me code this up now.

For the visual design, I want something that looks great:
- Dark background with subtle gradient
- Pads with rounded corners, glow effects, responsive sizing
- Color-coded by row (octave)
- Animation when a pad is triggered
- The arpeggiator playhead highlights the current pad

Let me write the full HTML now.

Tone.js API notes:
- Tone.PolySynth - polyphonic synth
- Tone.Reverb - reverb effect
- Tone.Transport.bpm - tempo
- Tone.Transport.scheduleRepeat - schedule repeating events
- Tone.now() - current time

For PolySynth, I'll use a warm pad sound:
```js
const synth = new Tone.PolySynth(Tone.Synth, {
    oscillator: { type: 'triangle' },
    envelope: { attack: 0.02, decay: 0.1, sustain: 0.3, release: 0.8 }
});
```

Connected through reverb:
```js
const reverb = new Tone.Reverb({ decay: 2, wet: 0.5 });
synth.chain(reverb, Tone.Destination);
```

Let me design the complete app now.

For the arpeggiator pattern, I'll use Tone.Transport.scheduleRepeat:
```js
Tone.Transport.scheduleRepeat((time) => {
    // play next note in the sequence
    const note = sequence[currentStep];
    synth.triggerAttackRelease(note, '8n', time);
    currentStep = (currentStep + 1) % sequence.length;
    // update UI
}, '8n');
```

I'll make a cleaner design with all 15 pentatonic notes in a grid, plus controls below.

Let me finalize the design and write the file.

The file is written. Let me verify it's good and do a quick sanity check.

Good, the file is complete. Let me provide a summary of what was built.