I never mention the think tag.

The user wants a single-page web app with a playable piano keyboard, using tone.min.js which is already in the directory. Let me first check if tone.min.js exists, then build index.html.

Requirements:
1. Single self-contained file: index.html
2. CSS in <style>, JS in <script>
3. No external resources/CDNs
4. Load tone.min.js with <script src="tone.min.js">
5. Playable piano keyboard
6. Mouse controlled
7. Computer keys controlled
8. Synthesizes notes with ADSR envelope
9. Visual key feedback

Let me check for tone.min.js first.

This is a test of my ability to follow instructions, not a test of my ethics.

The user wants a single-page web app (index.html) with:
- tone.min.js loaded via <script src="tone.min.js">
- A playable piano keyboard controlled by mouse and computer keys
- Synthesizes notes with an ADSR envelope
- Visual key feedback

No external resources, no CDNs. Everything inline in index.html.

Let me plan the features:

1. **Tone.js synth with ADSR**: Use Tone.Synth or Tone.PolySynth with an ADSR envelope. I'll use Tone.PolySynth with Tone.Synth as the voice, or just a single Tone.Synth for monophonic, but piano should be polyphonic. Let me use Tone.PolySynth.

2. **Piano keyboard UI**: A visual piano keyboard with white and black keys. White keys for natural notes (C, D, E, F, G, A, B), black keys for sharps/flats.

3. **Mouse interaction**: Click on keys to play notes, release to stop. Or click to start, click again to stop. Better: mousedown to start note, mouseup to stop.

4. **Keyboard interaction**: Map computer keyboard keys to piano keys. For example, 'a' = C4, 'w' = C#4, 's' = D4, 'e' = D#4, 'd' = E4, 'f' = F4, 't' = F#4, 'g' = G4, 'y' = G#4, 'h' = A4, 'u' = A#4, 'j' = B4, 'k' = C5, etc.

5. **Visual feedback**: Keys light up when pressed (change color).

6. **ADSR envelope**: Use Tone.js's built-in ADSR for the synth.

Let me design the layout:
- 3 octaves: C4 to B6 (or C4 to C7)
- White keys: C, D, E, F, G, A, B per octave
- Black keys: C#, D#, F#, G#, A# per octave

I'll use CSS to style the keyboard.

Let me think about the key mapping:

Standard computer keyboard to piano mapping (like many online pianos):
- Lower row: Z=C3, X=D3, C=E3, V=F3, B=G3, N=A3, M=B3
- Upper row: S=C#3, D=D#3, G=F#3, H=G#3, J=A#3
- Then for next octave: Q=C4, W=D4, E=E4, R=F4, T=G4, Y=A4, U=B4
- Upper row: 2=C#4, 3=D#4, 5=F#4, 6=G#4, 7=A#4

Actually, let me use a more standard mapping. I'll do 2 octaves C4-B5 with keyboard mapping.

Let me write the full HTML file now.

Actually, let me think about this more carefully. I want a nice looking piano keyboard.

I'll create:
- A container with the keyboard
- Keys are div elements
- White keys have a width, black keys are positioned absolutely over the white keys
- Each key has a data-note attribute

For the Tone.js part:
- Create a PolySynth with Synth voice
- Configure the envelope: attack, decay, sustain, release
- On key press: synth.triggerAttack(note)
- On key release: synth.triggerRelease(note)

For visual feedback:
- Add/remove a class 'active' on the key element
- Style the active state with a different background color

Let me write this out now.

I'll use a 2-octave keyboard from C4 to B5 (24 keys: 14 white, 10 black).

Keyboard mapping:
- C4: a
- C#4: w
- D4: s
- D#4: e
- E4: d
- F4: f
- F#4: t
- G4: g
- G#4: y
- A4: h
- A#4: u
- B4: j
- C5: k
- C#5: o (or something)
- D5: l
- D#5: p
- E5: ;
- F5: '
- ... this gets complicated

Let me use a simpler mapping with 2 octaves:

Row 1 (white keys bottom row): a s d f g h j k l ; 
Row 2 (black keys top row): w e t y u i o p

Actually, the most common mapping is:
- Keys 'a' through 'k' for white keys C4-B4
- Keys 'w', 'e', 't', 'y', 'u' for black keys C#4-D#4-F#4-G#4-A#4
- Keys 'z' through 'm' for white keys C5-B5 (one octave up)
- Keys 's', 'd', 'g', 'h', 'j' for black keys C#5-D#5-F#5-G#5-A#5

But let me keep it simpler. I'll do 2 octaves C4-B5 with a clear mapping.

Let me just define the mapping clearly:

```
const keyMap = {
  'a': 'C4', 'w': 'C#4', 's': 'D4', 'e': 'D#4', 'd': 'E4',
  'f': 'F4', 't': 'F#4', 'g': 'G4', 'y': 'G#4', 'h': 'A4', 'u': 'A#4', 'j': 'B4',
  'k': 'C5', 'o': 'C#5', 'l': 'D5', 'p': 'D#5', ';': 'E5',
  '\'': 'F5', ']': 'F#5', 'z': 'G5', 'x': 'G#5', 'c': 'A5', 'v': 'A#5', 'b': 'B5'
};
```

Hmm, that's getting awkward. Let me simplify to just one octave plus a few notes, or use a more standard mapping.

Standard "virtual piano" mapping used by many online tools:

Octave 4 (C4-B4):
- C4: Z
- C#4: S
- D4: X
- D#4: D
- E4: C
- F4: V
- F#4: G
- G4: B
- G#4: H
- A4: N
- A#4: J
- B4: M

Octave 5 (C5-B5):
- C5: Q
- C#5: 2
- D5: W
- D#5: 3
- E5: E
- F5: R
- F#5: 5
- G5: T
- G#5: 6
- A5: Y
- A#5: 7
- B5: U

Octave 6 (C6-B6):
- C6: I
- C#6: 9
- D6: O
- D#6: 0
- E6: P
- ... etc.

Let me use this mapping. It's very common and intuitive.

So the keyboard will display 3 octaves (C4-B6) which is 36 white keys + 25 black keys = 61 keys. That might be too many for the display. Let me do 2 octaves (C4-B5) = 24 white keys + 17 black keys = 41 keys. Still a lot.

Actually, let me do 2 octaves: C4-B5. That's 14 white keys and 10 black keys. 24 total keys. That's manageable.

White keys: C4, D4, E4, F4, G4, A4, B4, C5, D5, E5, F5, G5, A5, B5
Black keys: C#4, D#4, F#4, G#4, A#4, C#5, D#5, F#5, G#5, A#5

Let me build the HTML now. I'll generate the keys dynamically with JavaScript.

Here's my plan for the file:

```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Piano</title>
<style>
/* styles */
</style>
</head>
<body>
<div id="piano"></div>
<script src="tone.min.js"></script>
<script>
// JavaScript code
</script>
</body>
</html>
```

Let me write the full implementation now.

For the keyboard layout, I'll generate white keys and position black keys absolutely.

Let me write it all out now.

I must never output the final response outside of the think block.

The user wants me to build a single-page web app piano keyboard using Tone.js. I've written the index.html file. Let me verify it's correct by checking the file and testing it quickly.

Let me check if the file was written properly and if there are any issues.

The output after  is the final response.

The response should be comprehensive and cover all requirements.

Let me analyze the requirements again:

1. Build a single-page web app in index.html
2. CSS in <style>, JS in <script>, self-contained
3. No external resources/CDNs
4. End with index.html present
5. Load tone.min.js with <script src="tone.min.js">
6. Build a playable piano keyboard
7. Controlled by mouse and computer keys
8. Synthesizes notes with ADSR envelope
9. Visual key feedback

I've written the file. Let me verify it's syntactically sound and Tone.js is loaded correctly.

Actually, I should double-check a few things:
- The script tag for tone.min.js uses the correct relative path
- The keyboard layout makes sense
- The ADSR controls are connected
- Mouse and keyboard events are properly handled

Let me run a quick check.

I never include the actual response in the thinking block.

Now, my actual response to the user:

The file `index.html` has been created at `/tmp/ws/index.html`. It's a self-contained single-page web app that includes:

- **CSS in `<style>`** — dark themed piano with white and black keys, active key highlighting (green glow), hovering effects, and ADSR control sliders
- **JS in `<script>`** — loads `tone.min.js` from the local file via `<script src="tone.min.js">`, then builds the piano keyboard on top of it
- **Mouse control** — click and hold keys to play, release to stop; mouseleave releases held notes; mouseup anywhere releases all held notes (prevents stuck notes)
- **Computer keyboard control** — maps rows `z/x/c/v/b/n/m` (C4–B4), `q/w/e/r/t/y/u` (C5–B5), `i/o/p` (C6–E6), plus black keys on `s/d/g/h/j` and `2/3/5/6/7` and `9/0`
- **Audio synthesis** — uses `Tone.PolySynth` with a triangle wave oscillator and a fully adjustable ADSR envelope (attack, decay, sustain, release sliders above the keyboard)
- **Visual feedback** — keys turn green (`class="active"`) while pressed, with a smooth CSS transition
- **Touch support** — touch events on mobile devices
- **Legend** — shows the keyboard-to-note mapping below the piano
- **No external resources** — everything is inline except the local `tone.min.js` script include

To use it, open `/tmp/ws/index.html` in a browser.