Need to create index.html with a Canvas simulation: a rotating regular heptagon, 20 numbered balls, gravity, friction, ball-to-ball collisions, ball-to-rotating-wall collisions (impulse-based accounting for the wall's velocity), rotating numbers.

Let me think about the physics.

Heptagon: center (cx,cy), radius R, rotating with angle θ = 2π * t / 5s. Vertices at angle θ + k*2π/7.

Ball-to-wall collision: each edge is a line segment. For each ball, check against each edge: compute the inward-pointing normal (toward the center). If the ball's center is closer than the radius, push it back along the normal and reflect the velocity. Since the wall is rotating, the wall surface's velocity at the contact point: v_wall = ω × r (ω is perpendicular to the vector from center to contact point). In 2D: v_wall = ω * perp(contact - center), where perp(x,y) = (-y, x). Relative velocity v_rel = v_ball - v_wall. If the relative velocity along the normal is negative, reflect: v_rel' = v_rel - (1+e)(v_rel·n)n, then apply friction tangentially: reduce the tangential component. Then v_ball = v_rel' + v_wall.

Ball-to-ball collisions: standard impulse with equal mass (or mass proportional to r²). Positional correction.

Ball spin: track angular velocity ω_ball; when bouncing, impart spin based on the tangential velocity. Rendering: rotate the Canvas and draw the number.

Spawn: balls drop from the center — spawn from the center over time with slight offsets so they don't overlap. 20 balls, spawn a few per frame, or all with random small offsets? "drop from the center" — spawn sequentially from the center with a small random offset and small random velocity.

Fixed-timestep physics, substeps for stability.

Implementing edge collision: for each edge, define it with vertices A, B. Compute normal n pointing inward: n = normalize(center - midpoint) roughly, or use the perpendicular of the edge direction chosen so it points toward the center. Distance from ball center to the segment: project onto AB. Since the heptagon is convex and the ball is inside, the closest point is on the segment. Compute d = P - C (C = closest point). If |d| < r: normal = -d/|d| (push toward center... actually, the direction from the wall into the interior). Actually, the push direction is from the contact point toward the ball's center: n = d/|d| (direction from contact point to center). Position correction: P += n*(r - |d|). Wall velocity at the contact point C: v_w = ω * perp(C - O). Relative velocity. If v_rel·n < 0: impulse.

Tangential friction: t = perp(n). v_t = v_rel·t. Apply friction coefficient: reduce v_t by μ*|v_rel·n|, or use a simple coefficient. Also, the ball's spin couples with the tangential slip: ball surface velocity = v + ω_ball * perp(n)*r (sign). Let's keep it simpler: after collision, set the tangential component multiplied by (1 - friction), and adjust the ball's angular velocity: ω_ball_new based on slip.

Ball-to-ball: relative velocity along normal, impulse with coefficient of restitution e, equal mass: j = -(1+e)*vrel·n / 2 (mass 1 each, j = -(1+e)*vrel·n * m/2 ... with m=1: j = -(1+e)*vrel_n / (1/m1+1/m2) = -(1+e)*vrel_n/2). Apply ±j*n. Positional correction: separate by overlap/2 each. Also a small tangential friction for spin transfer: optionally compute.

Spin rendering: each ball has a rotation angle and angular velocity; draw the number rotated by the angle.

Damping: slight air friction, ground friction is... it's enclosed, so there's no floor; the balls eventually settle on the lowest wall.

Let me write the code. Canvas size e.g. 900x900, heptagon radius ~400. Ball radius ~14, 20 balls.

Spawning: every ~60ms spawn one ball from the center with a random small velocity. Physics substeps: run dt/4 substeps per frame.

Let me write it all out.

Code sketch:

const hept = {cx, cy, R, angle, omega: 2π/5}
each frame: hept.angle += omega*dt

For each ball:
- gravity vy += g*dt
- air friction: v *= (1 - airF*dt)
- integrate position
- collide with walls (per substep)
- pair collisions (per substep, iterate pairs; 20 balls = 190 pairs, no problem)

Wall collision details:

function collideWalls(b) {
 for k in 0..6:
  A = vertex(k), B = vertex(k+1)
  closest point C on segment AB to b.pos
  d = pos - C; dist = |d|
  if dist < r:
    n = d/dist (if dist==0 use inward normal)
    pos = C + n*r
    contact = C
    vwall = omega * perp(contact - center)
    rel = v - vwall
    vn = rel·n
    if vn < 0:
      // normal impulse with restitution
      rel -= n*(1+e)*vn
      // tangential friction
      t = (-n.y, n.x)
      vt = rel·t
      // ball surface velocity at contact point: tangential = vt + spin*r? For a ball, contact point on the ball is on the wall side (pos - n*r), so surface velocity from rotation = ω × rvec, where rvec = -n*r → v_surf = ω * perp(-n*r) = -ω*r*perp(n) = -ω*r*t (perp(n)=t). So tangential surface velocity = vt... wait, rel here is the velocity of the ball's center relative to the wall. Contact point velocity = center velocity + ω × rvec = v + ω*perp(-r n). perp(-n) = -perp(n) = -t. So v_contact_tangential = vt - ω*r. Slip = vt - ω_ball * r (per the signs above).
      friction: apply impulse proportional to normal impulse: jt = min(|μ*(-vn*(1+e))|, slip) in the direction opposing slip.
      Simplified: rel_t = t*(vt) ; target: reduce. Let's do:
      slip = vt - b.av * (-r)?? Let me carefully define.

Let's define perp(n) = (-n.y, n.x) = t.
Contact point relative to center: p = -r*n (contact is on the opposite side of n from the center).
Velocity from spin at the contact point: ω_ball × p, in 2D ω×p = ω*perp(p) = ω*r*perp(-n) = -ω_ball*r*t.
So the tangential velocity of the contact point relative to the center is -ω_ball * r.
Wall contact point velocity (tangential): vwall·t.
Slip = (v - vwall)·t - ω_ball*r ... wait, rel·t = vt (relative to wall center-velocity tangential), subtract the spin contribution -ω*r → slip = vt + ω_ball*r. Hmm: contact point velocity (ball) tangential = v·t + (ω×p)·t = vt_center + (-ω_ball r). Relative to the wall: rel_t = v·t - vwall·t - ω_ball*r = (rel·t) - ω_ball*r. So slip = rel_t - ω_ball*r, where rel_t = rel·t (after or before normal impulse — order barely matters, use pre-impulse rel).

Friction impulse magnitude: jt ≤ μ*|jn|, jn = (1+e)(-vn) (normal impulse magnitude). Reduce slip: new_slip = max(slip - sign(slip)*jt, 0). Distribute the impulse: change in linear tangential velocity = jt/2 (mass 1, I = 0.5*m*r², and adding rotational impulse: change in ω = jt/(I/r) = jt/(0.5*r) = 2*jt/r ... with m=1: jn is in units of m*v). Let's keep it approximate — just a visual thing anyway. Do this:
  let jt = Math.min(mu * jn, Math.abs(slip) * (1 + 2)); // effective combined inertia
  direction = -sign(slip)
  v += t * (direction * jt / 2)  ... signs are fiddly; simpler and more robust approach:

Simpler approach that looks realistic:
  // tangential damping with friction
  rel_t = rel·t
  vt_new = rel_t * (1 - mu)   // hmm, this is proportional
  b.v += t*(vt_new - rel_t)
  // spin coupling: target spin matches wall/roll: b.av += ((rel_t_after + b.av*r) ... )

To be safe and keep it "realistic-ish", I'll do:
  const jn = -(1+e)*vn;             // >0
  rel = rel - n*vn*(1+e);           // rel_t preserved
  let relt = rel·t;
  let slip = relt - b.av*r;         // wait, sign: contact spin velocity = -av*r along t, so contact point relative tangential velocity = relt + (-av*r) = relt - av*r. Yeah, slip = relt - av*r.
  let jt = mu*jn;
  let maxJt = Math.abs(slip)/(1 + 4); // mass terms: linear 1/... m=1, I=0.5*r²; 1/(m + r²/I) = 1/(1+2) = 1/3. Use /3.
  jt = Math.min(jt, Math.abs(slip)/3);
  let dir = -Math.sign(slip);
  b.v = b.v + t*(dir*jt/1);   // linear tangential impulse jt (full, since we're solving the combined inertia: linear Δvt = jt, Δav = jt/r, total slip change = jt(1 + 1)=2jt??

Let me redo properly: impulse P = dir*jt*t applied to ball at contact point. Δv = P/m = dir*jt*t. Δω = (p × P)/I, p = -r*n, P = jt*t (dir included). Cross product (p × P) z = (-r n_x)(jt t_y) - (-r n_y)(jt t_x) = -r jt (n_x t_y - n_y t_x) = -r jt (n × t), where n×t = n_x t_y - n_y t_x = n_x n_x + n_y n_y = 1. So Δω = -r*jt/I.

Change in slip: Δslip = Δv·t - Δω*r = dir*jt - (-r*jt/I)*r = dir*jt*(1 + r²/I) = dir*jt*(1+2) = 3*dir*jt (I = 0.5 r²). To cancel slip: jt = |slip|/3. Good, consistent.

So:
  jt = Math.min(mu*jn, Math.abs(slip)/3); dir=-sign(slip);
  b.vx += dir*jt*t.x; b.vy += dir*jt*t.y;
  b.av += -r*jt/I * ... wait, Δω = -r*P_z/I, where P includes dir: Δω = -r*(dir*jt)/I.

Wait, the sign in the impulse formula: Δω = (p×P)/I, p×P = -r*jt_total, where jt_total = dir*jt. So Δω = -r*dir*jt/I. OK.

But careful: rel is in wall-relative coordinates. Applying the impulse to b.v is fine since the wall is treated as infinite mass (moving with known velocity).

Rolling: after friction, slip ≈ 0, av is consistent. Good.

Ball-to-ball:
  for i<j:
   d = pj - pi, dist, if dist < 2r:
    n = d/dist
    overlap = 2r - dist
    pi -= n*overlap/2; pj += n*overlap/2
    rel = vi - vj; vn = rel·n; if vn > 0: // approaching (n from i to j, so approaching means vi - vj along n > 0)
     j = -(1+e)*vn/(1/mi+1/mj) ... equal mass: j = -(1+e)*vn/2
     vi += n*j/1 ... wait, sign: impulse on i is -j? Standard: apply impulse J = -(1+e) vn / (1/mi + 1/mj) * n to ...: vj += J/mj * n? Let's do: vi -= n*(j/2)?? Let me just define: vn = (vi - vj)·n, where n points from i to j. If vn > 0 they're approaching. Impulse magnitude jm = (1+e)*vn/2. Then vi = vi - n*jm; vj = vj + n*jm (m=1). Check: new (vi-vj)·n = vn - 2jm = vn - (1+e)vn = -e*vn. Good.
     // friction for spin:
     relt = (vi' - vj')·t where t = perp(n).
     Contact point: contact on i is at +r*n, on j at -r*n.
     i's surface velocity at contact = (vi) + ωi × (r n) → tangential: vi_t + ωi*r? perp(r n) = r t, so (ω×p)·t = ω*r. So slip = (vi_t - vj_t) + ωi*r - (-ωj*r)?? j's surface: p = -r n, (ω×p)·t = -ωj*r. Slip = (vi_t - vj_t) + ωi*r + ωj*r.
     jt = min(μ*|jm|, |slip|/3) (same inertia), dir = -sign(slip).
     Impulse on i: P = dir*jt*t applied at contact point p=r n:
       Δvi = P (m=1): vi += dir*jt*t
       Δωi = (p×P)/I, p×P = r n × (dir jt t) = r dir jt (n×t) = r dir jt. Δωi = r*dir*jt/I.
     Impulse on j: -P at p=-r n:
       Δvj = -dir*jt*t
       p×P' = (-r n)×(-dir jt t) = r*dir*jt. Δωj = r*dir*jt/I.

Gravity: pick a scale. Canvas 900, r=13, g ~ 2000 px/s²? Ball radius 14, 20 balls → area: heptagon area = 7/4 * R² * tan(π/7) ≈ 7*0.2367*R²*... = 2.04*R². R=380 → area ≈ 296k. 20 balls * π*14² ≈ 12.3k. Fine.

Spawn: staggered, one ball every 80ms, from center with small random offset (radius < 10) and small random velocity.

Rotation rendering: ctx.translate(b.x,b.y); ctx.rotate(b.rot); draw number centered; rotate back. Draw a small dot marker? Number rotation is enough.

Also, add a visual effect where the wall spins — draw the heptagon with a gradient, maybe with vertex markers.

Fixed timestep: accumulate, substep dt = 1/240 for stability, cap frame dt at 1/30.

Edge case: ball is outside the heptagon? Only spawn from the center; keep it inside.

Also, handle dist≈0 in wall collision.

Let me write index.html.

Vertex function: for k in 0..6: angle = hept.angle + k*2π/7; x = cx + R*cos, y = cy + R*sin.

Wall contact velocity: ω = 2π/5 ≈ 1.257 rad/s. v = ω * perp(C - O).

Timestep loop:
let last; function frame(ts){ dt = min((ts-last)/1000, 0.033); steps = ceil(dt/h) with h=1/240; while... standard accumulator.

Heptagon's angle also updated per substep.

Spawn logic also within the frame: keep an array; if spawned < 20 and time since lastSpawn > 0.08: spawn.

Let's write it.

Ball color: hue by number.

Draw number: font bold 13px, textAlign center, textBaseline middle.

Let me write the file.

Quick sanity check: no network resources, single file. Maybe I could verify the JS syntax with node? I can extract the script and run `node --check` on it.

Syntax is valid (node --check passed silently). Done.