The user wants a single-page web app with:
1. A rotating heptagon (7-sided polygon) that completes a full 360° rotation every 5 seconds
2. 20 numbered balls (1-20) dropping from the center
3. Physics: gravity, friction, ball-ball collisions, ball-wall collisions with rotating walls
4. Each ball should show its number, and the number should rotate with the ball (showing spin)
5. All collision detection implemented manually

Let me build this step by step:

- Canvas-based rendering
- Ball physics with gravity, friction, velocity, angular velocity
- Heptagon collision: for each rotating wall segment, check if a ball is outside the heptagon boundary and reflect it
- Ball-ball collision: circle-circle collision detection and response
- Ball spin visualization: rotate the number text based on the ball's angular velocity

Let me think about the physics carefully:

1. **Heptagon**: 7 vertices, rotating around center. Each wall is a line segment between adjacent vertices.

2. **Ball-wall collision**: For each wall of the rotating heptagon, find the closest point on the line segment to the ball center. If distance < ball radius, push ball out and reflect velocity. The wall has a tangential velocity due to rotation that should be considered for realistic bouncing.

3. **Ball-ball collision**: If distance between centers < sum of radii, resolve collision elastically with some energy loss.

4. **Ball spin**: Each ball has an angular velocity. When it collides with walls or other balls, the friction transfers some tangential velocity into spin.

Let me code this up.

For the rotating wall collision:
- Calculate wall velocity at the collision point due to rotation: v_wall = ω × r (perpendicular to radius)
- Relative velocity = v_ball - v_wall
- Reflect the normal component of relative velocity
- Add tangential friction that affects ball spin

Let me write the complete file.

The user wants a single-page web app with:
1. 20 numbered balls (1-20) dropping from the center of a heptagon
2. The heptagon spins 360 degrees every 5 seconds
3. Balls affected by gravity and friction
4. Balls collide with each other (ball-ball collision)
5. Balls bounce off the rotating walls of the heptagon
6. Each ball shows its number, rotated to show spin
7. All collision detection implemented manually
8. No external resources

Let me build this step by step:

- Canvas-based rendering
- Physics simulation with gravity, friction, ball-ball collisions, ball-wall collisions
- Rotating heptagon (7-sided polygon)
- Ball spin visualization (rotate the number based on ball's angular velocity)

Key physics:
- Gravity: constant downward acceleration
- Friction: velocity damping
- Ball-ball collision: elastic collision with proper momentum exchange
- Ball-wall collision: reflect velocity off the wall normal, accounting for wall rotation

For the rotating heptagon walls, I need to:
- Calculate the 7 vertices of the heptagon at the current rotation angle
- For each wall (edge), check if a ball is colliding with it
- Reflect the ball's velocity off the wall's normal, adding the wall's tangential velocity

Ball spin: I'll track angular velocity for each ball, update it based on friction and collisions, and rotate the number when drawing.

Let me code this up carefully.

Let me review what I've built and verify the file exists.

The implementation includes:
1. 20 numbered balls (1-20) dropping from center of heptagon
2. Heptagon that rotates 360 degrees every 5 seconds
3. Gravity pulling balls down
4. Air friction/damping
5. Ball-ball collisions with elastic collision physics and spin transfer
6. Ball-wall collisions against the rotating heptagon walls, accounting for wall velocity
7. Each ball's number rotates to show spin
8. All collision detection implemented manually
9. No external resources - fully self-contained

Let me verify the file is correct.

Let me review the code to make sure the collision detection and physics are correct. Let me re-read the file and think about potential issues.

Looking at the code, I see a few issues:
1. The `resolveBallWall` function has a logic issue - it checks `isInsideHeptagon` but that's not quite right for the collision response. The heptagon is the container, so balls should always be inside. I need to properly detect which wall the ball is closest to and push it away.

2. The ball spin via rotation of number - that's handled via `ball.angle` and the `ctx.rotate(ball.angle)` in `drawBall`.

3. The wall collision needs to be more robust. Let me think about this more carefully.

The key issue: the heptagon is a rotating container. Balls should be inside it. When a ball hits a wall from the inside, it should bounce. Let me fix the wall collision logic.

Actually, looking at the code more carefully, the issue is in `resolveBallWall`. The current logic tries to check if the ball is inside, but the collision response is wrong. The normal from the closest point on the segment to the ball might point the wrong way.

For a convex polygon container, the correct approach is:
1. For each edge, compute the normal pointing inward (or outward)
2. Check if the ball is on the correct side of the edge
3. If not, push it back and reflect velocity

Actually, let me reconsider. For a ball inside a rotating convex polygon, I should:
1. For each edge, compute the signed distance from the ball to the edge
2. If the ball is outside the edge (negative distance), push it back inside and reflect

Let me rewrite the collision detection to be more correct.

The main issues I want to fix:
1. Wall collision: properly compute inward-pointing normals and handle collisions from inside
2. Ensure the physics looks natural
3. Make sure ball spin from collisions is visible

Let me rewrite the file with a cleaner implementation.

The user asked me to build a single-page web app. I've created index.html with:

1. A rotating heptagon (360° every 5 seconds)
2. 20 numbered balls dropping from the center
3. Gravity, friction, ball-ball collisions, ball-wall collisions
4. Balls bounce off rotating walls realistically
5. Ball numbers rotate to show spin
6. All collision detection implemented manually
7. No external resources

The file is complete and present at /tmp/ws/index.html. The implementation includes:
- Proper rotating wall collision physics (wall velocity at contact point)
- Ball-ball elastic collisions with friction for spin
- Multiple collision resolution passes for stability
- Depth-sorted rendering
- Nice visual styling with gradients, shadows, and glow effects

The file is ready. Let me confirm it exists.