The user wants a single self-contained HTML file with a physics simulation. This is a complex task. Let me build a comprehensive single-page web app.

Let me think about the requirements:

1. Large glass aquarium with side panel that develops a visible crack then bursts.
2. Water escaping through opening, flow strength based on water depth, decreasing as tank drains (Torricelli's law: v = sqrt(2*g*h)).
3. Curved water jet affected by gravity (parabolic trajectory).
4. Spreading puddle that collides with room boundaries.
5. Fish, rocks, plants, floating toy reacting differently per density, buoyancy, drag, current.
6. Objects transitioning underwater -> airborne -> floor collisions.
7. Fish attempting to swim against current before being swept through breach.
8. Glass fragments with angular velocity, collisions, water resistance.
9. Visible waterline that lowers continuously.
10. User drags crack vertically before triggering failure. Lower crack = stronger initial jet.

This is a big task. Let me build it with HTML5 canvas. I'll write a single index.html.

Let me design the architecture:

- Canvas 2D rendering.
- Coordinate system: simulate in pixels but with a scale.
- Tank: rectangular glass box on a floor (room). The room has boundaries (walls, floor).
- Water inside the tank: represented by a water level (height). For rendering, fill water region. For physics, water level decreases as it escapes.
- Crack: located on the left or right side panel at a vertical position (y). User drags it vertically before failure. On failure, the panel bursts: a hole opens, glass fragments fly.

Physics model:

Water escape: We model the tank water as having a level `waterLevel` (top of water). Opening at height `crackY`. The depth of water above the crack determines pressure. Flow rate Q proportional to aperture area * sqrt(2*g*depth). As tank drains, waterLevel drops; once below crackY, flow stops.

Jet: spawn particles at the opening with initial velocity horizontal (outward) plus some spread. Velocity magnitude ~ sqrt(2*g*depth) scaled. Gravity acts on them -> curved jet. They travel until hitting floor, then become puddle particles.

Puddle: particles on floor spread outward; accumulate and collide with room walls.

Objects in tank:
- Fish: buoyant? Actually fish are roughly neutral buoyancy, swim. They try to swim against current when near breach. Density ~ water. They have swim force, drag in water. When swept through breach (if water level low enough or current strong), go airborne and fall to floor.
- Rocks: dense (density > water), sink to bottom of tank, stay until water drains low enough then maybe fall? Rocks at bottom of tank. When water drains, the tank bottom is above floor, so rocks would stay on tank floor unless tank empties to floor level. Hmm. Actually the aquarium sits on the room floor. Rocks inside are on the tank floor. They don't get out unless the tank floor fails. So rocks just sit. But requirement says objects transition from underwater to airborne to floor. That applies to fish, floating toy maybe. Let me make floating toy (low density) float on waterline; when water drops, it stays at waterline until water gone? Actually floating toy floats on water surface. As water drains, toy descends with waterline. When water level reaches tank floor, toy sits on tank floor. Not airborne unless pushed out. Hmm.

Let me reconsider: The breach is on a side panel. Water and objects exit through the side breach horizontally at crack height. Fish and floating toy can be pushed out through the breach by current, then become airborne (outside tank) and fall to room floor.

Rocks: dense, sink to tank bottom, won't be pushed out easily unless current strong near bottom. Could be swept if crack is low enough and current strong. Let me allow rocks to be swept too if near breach.

Plants: anchored to tank floor (rooted), sway with current, don't move out. Or they could be uprooted. Let me make plants rooted but sway; maybe one gets uprooted under strong current. Keep simple: plants sway, anchored.

Let me define physics for each object:
- In water: buoyancy force = density_ratio * gravity (if density < water, net upward). Drag force proportional to (velocity - fluidVelocity) and a drag coefficient. Fish have swim force toward staying in tank / against current.
- Fluid velocity near breach: outward current. We can compute a current field: near the opening, velocity points outward strongly; elsewhere small.
- When object passes through opening (exits tank x beyond wall) and is outside, switch to airborne: gravity only, drag with air (lighter). Then floor collision with room floor: bounce/rest.

Let me think about coordinate geometry. Let me set up:
- Room: walls at x=0 (left), x=roomW (right), floor at y=roomFloorY. Top open (or ceiling irrelevant). The tank sits on floor.
- Tank: x from tankX to tankX+tankW, y from tankTopY to tankBottomY (tankBottomY = roomFloorY, resting on floor). Glass walls thickness.
- Water occupies tank interior below waterLevelY (top) down to tankBottomY.
- Crack on right side panel at crackY (between bottom and top of water). Opening = a gap on right wall at crackY, height = apertureH.

Let me place crack on the right side. Water flows rightward (out of tank) into the room. Room extends to the right.

Actually "side panel" — could be any side. Let's use the right side for jet going right, room to the right.

Let me reconsider room layout: tank on left portion, room extends to right so jet can travel and form puddle. Floor continuous.

Let me set canvas size, say 1100 x 700.

Coordinates: y increases downward (canvas standard). Let me define:
- floorY = 620 (room floor near bottom).
- ceiling not needed.
- Tank: left wall at x=120, right wall at x=520, top at y=120, bottom at y=620 (sitting on floor). Tank interior width 400-ish. Actually wall thickness; interior from x=130 to x=510.
- Water initially fills interior up to waterTopY = 150 (near top). So water column height ~ 470.
- Room extends from x=0 to x=1080.

Right side panel is the tank's right wall at x=510..520. Crack located at crackY somewhere between waterTopY and floorY. User drags it.

Jet exits to the right into room region x>520.

Glass fragments: when failure triggered, the right panel shatters: spawn many triangular shards at the panel location with outward+random velocities, angular velocity, affected by gravity, water resistance (when in water? but they're at the panel which is above floor; the lower part may be in water). They collide with floor and walls (bounce).

Puddle: water particles land on floorY and spread; accumulate horizontally, bounded by room walls x=0 and x=1080. Also puddle shouldn't go back into tank (left boundary at tank right wall? Actually tank occupies x<520 sitting on floor; the puddle from jet lands to the right of tank at floorY=620 which equals tank bottom. But tank bottom is solid, so puddle forms on floor to the right of tank (x>520). But also water could flow under? No. The floor is at 620, tank bottom at 620. Water exits at crack height (above floor) to the right, arcs, lands on floor to the right of tank. Good. Puddle spreads along floor from landing point, bounded by right wall x=1080 and by tank base (left) — can't go left of x=520 because tank base is there. So puddle region x in [520,1080].

Hmm but a "spreading puddle that collides with the room boundaries" — left boundary could be tank, right boundary wall. Good.

Waterline lowering: As water drains, waterLevelY increases (moves down). Render water fill from waterLevelY to floorY inside tank interior. Good, continuous.

Let me compute drain rate. Tank cross-section area A = interiorWidth * 1 (2D, treat unit depth). Opening area a = apertureH * 1. Torricelli: dV/dt = -a * sqrt(2 g h) where h = depth of water above opening = (waterLevelY_bottom - waterLevelY) ... in pixel terms h = (tankBottomY - waterLevelY) - (tankBottomY - crackY) = crackY - waterLevelY. Wait depth of water above crack = waterTop surface minus crackY = waterLevelY - crackY. Yes h = waterLevelY - crackY (if waterLevelY > crackY, i.e., water surface below crack? No—waterLevelY is the surface, smaller y = higher. Surface at waterLevelY (e.g., 150). Crack at crackY (e.g., 400). Water above crack means surface is above crack in real terms => surface y (150) < crackY (400). So depth of water above the crack = crackY - waterLevelY. Yes h = crackY - waterLevelY. When waterLevelY rises above crackY (surface drops below crack), h<0, no flow.

Velocity of jet = sqrt(2 g h). Scale to pixels. Let me pick g in px/s^2 ~ 900. Then v = sqrt(2*900*h). For h=250px => sqrt(450000)=671 px/s. That's reasonable for jet speed.

Spawn rate proportional to a * v. Number of particles per second ~ k * a * v.

Let me now think about rendering order and performance. Use requestAnimationFrame with dt.

I'll keep arrays: waterParticles (jet + puddle), glassFragments, fish[], rocks[], plants[], toy[].

Let me design water particle: {x,y,vx,vy, state:'jet'|'puddle', life}. Jet particles under gravity, when y>=floorY -> become puddle: set y=floorY, vy=0 maybe small, state puddle with horizontal velocity (vx) that decays via floor friction and spreads. Puddle particles move along floor, colliding with walls and tank base, and also piles up (height)? Simpler: puddle is a set of particles sliding on floor with friction; they spread. We can also render a puddle polygon with height based on accumulation. To show "spreading puddle that collides with room boundaries," particle approach with floor friction and wall bounce is fine, plus we render them as blue circles small, and maybe a translucent puddle layer whose height grows with total volume in puddle region. Hmm.

Maybe better: track puddle as a height field along the floor. But that's complex. Let me do particle-based puddle but also draw a translucent puddle shape by tracking min and max x and a thickness based on count. Simpler: just render many small water particles; they'll visually form a puddle. Collisions with walls: when puddle particle x goes beyond bounds, clamp and reverse vx*restitution. When collides with tank base (x <= 520 and y==floor and coming from right), clamp x=520.

Actually puddle should pile up maybe but let's keep flat on floor with slight stacking illusion via random y offset? Keep them at floorY with tiny random vertical for thickness.

Let me keep it visually acceptable: puddle particles get small random radius and slight vertical jitter to look like a spread sheet.

Now objects:

Fish: properties {x,y,vx,vy, len, angle, buoyancy ~1.0 (neutral), swimTarget}. In water, apply buoyancy ~ 0 (neutral) so they don't sink; they have swim behavior. Current field pushes them. They try to swim against current (to left, toward tank interior) when near breach. When they exit through opening (x > tankRightWall and within crack vertical range) and waterLevel still above? They then become airborne (gravity), then floor collision.

Actually fish inside tank: currently at various positions. The current near breach pushes right. Fish swim left (against current) to resist. But over time as water drains and current strong, they get pushed to the right, pass through breach (since the wall is gone there), and exit. Good.

Let me define current field: For water region (inside tank, below waterLevelY, x within interior), fluid velocity vx_fluid. Near breach (x close to right wall, y near crackY), vx_fluid large outward (positive x) magnitude ~ jet velocity * factor depending on distance. Also a general rightward drift near bottom? Let me make current strongest near the opening and decay with distance. Use something like:
fluidVx = jetSpeed * exp(-dist/scale) where dist from opening point (tankRightInteriorX, crackY). Also fluid has slight downward near opening? Keep horizontal.

Drag in water: F_drag = -c * (v - fluidV). Acceleration = F_drag/m + buoyancy/g forces.

Let me unify: each object has mass m, area, Cd, density. In water:
- weight = m*g (down).
- buoyancy = rho_water * V * g up. For fish ~ neutral => buoyancy ≈ weight. For rock density 2.5 => buoyancy = weight/2.5 (sinks). For toy density 0.3 => buoyancy = weight/0.3 (floats strongly). For plant ~ neutral but anchored.
- fluid drag = 0.5*rho*Cd*A*|vrel|*vrel.

In air (outside, above floor): weight only + air drag (same formula with rho_air). When hits floor, collide: if y+size>floorY, set y, vy = -vy*restitution, vx*=friction; if |vy| small, rest.

Transition: object is "in water" if x within tank interior and y between waterLevelY and floorY (i.e., submerged) OR floating on surface (y ~ waterLevelY for buoyant). Let me compute submersion: object considered in water if x in [tankLeftX, tankRightX] and y+size>=waterLevelY and y<=floorY. Actually simpler: define inTank = x in interiorX range and y > waterLevelY-? Let me handle: if object.x inside tank interior horizontally and below water surface (y >= waterLevelY) and above floor (y <= floorY): it's underwater. If y < waterLevelY (above water surface) but still inside tank horizontally: it's in air pocket (above water) — but tank is full of water initially so fish below surface. As water lowers, fish could be above water (air) inside tank if they don't follow. We'll let buoyancy bring them down with water level.

When object moves beyond tank right wall opening (x > tankRightX) at vertical range near crack (|y - crackY| < aperture/2 + margin) and waterLevel above floor: it exits into the "outside" region. Once x > tankRightExterior (i.e., past the glass), treat as outside: water no longer applies; if y >= floorY it's on floor (air), else airborne (falling). But note: outside but still above floor and to the right of tank — that's open room air (no water). So apply air physics + gravity. Good. So an object that exits the breach is in air; it then falls (gravity) and lands on floor.

But wait, between tank right wall (x=520) and the point where it lands, it's projectile. Fine.

Edge: object floating toy originally on water surface inside tank. As water drains, surface lowers; toy follows buoyancy down. It might also be pushed right by current and exit. Good.

Plants: anchored at tank floor at some x; they sway based on current. Represent as a vertical chain of segments with bending. They don't move out. Keep them simple, just visual + maybe slight reaction. We'll include them for requirement but anchored.

Rocks: dense, sink to tank bottom initially. They sit at floor inside tank. They could be pushed by current only if crack low enough that current at bottom is strong. With low crack, jet h large, current reaches bottom more. Let me allow rocks to be pushed if current strong near them. They might exit if crack near bottom. Let me just apply same physics; rocks heavy so mostly stay unless current strong. Possibly they tumble out if crack low. Good enough.

Now the crack drag interaction: Before failure (state 'intact'), user can click and drag vertically on the right panel to set crackY. Show a crack line drawn on the panel (jagged). A button or the same action triggers failure? Requirement: "Let the user drag the crack vertically before triggering the failure. A lower crack should initially produce a stronger jet." So we need a way to trigger failure. Provide a "Trigger Burst" button. Also allow dragging crack before. After trigger, panel bursts, glass fragments created, opening appears, water flows.

Also "side panel develops a visible crack" — maybe show crack appearing over time? Let me have the crack visible from start (the user positions it) and then on trigger it bursts (crack widens / shatters). Or have crack "develop" as a pre-animation: maybe a crack grows then bursts. I'll implement: while intact, user drags a crack indicator (a jagged line). On Trigger, we animate crack splitting and shatter into fragments, and opening forms.

Let me also let user drag only while intact. Provide instructions overlay.

Let me also add a reset button.

Now, the "curved water jet affected by gravity" — particles with gravity give parabola. Good.

Now let me implement carefully. This will be a large file. Let me write it.

Let me structure the code:

```
const canvas, ctx
const W=1100,H=700
// room
const room = {left:0,right:1080, floorY:620}
// tank
const tank = {left:120, right:520, top:120, bottom:620, wall:10}
interior: ix0=tank.left+wall=130, ix1=tank.right-wall=510, iy0=tank.top+wall=130, iy1=tank.bottom=620
waterTopY initial = 150 (surface). waterLevelY = 150 (surface y).
crackY = 380 initial, draggable in [iy0+20, iy1-20].
apertureH = 26 (height of opening after burst).
```

Physics constants:
g = 900 (px/s^2).
jetVelForDepth(h) returns sqrt(2*g*h) * pxScale. Actually sqrt(2*g*h) already in px/s if g, h in px. Good. Use factor maybe 1.0.

Spawn water particles at opening position: x = ix1 (480? wait ix1=510 is interior right). The wall is 510..520. Opening at x ~ 515, y = crackY + random in aperture. Initial vx = jetVel * (0.8..1.2), vy = small random upward/downward. jetVel depends on depth h = max(0, crackY - waterLevelY). When waterLevelY >= crackY, h=0 => no flow.

Drain: each frame, h = crackY - waterLevelY. if h>0: dV = apertureH * sqrt(2*g*h) * dt (pixels^3/s with unit depth). Volume decrease => waterLevelY += dV / interiorWidth. Also track total spilled for puddle maybe.

Spawn particle count: n = k * apertureH * sqrt(2 g h) * dt. Choose k so visually good, e.g., k=0.4. Cap.

Water particle update:
if state jet: vy += g*dt; x+=vx*dt; y+=vy*dt; if y>=floorY { y=floorY; state='puddle'; vy=0; vx*=0.6; small random}. Also if x>room.right-w: bounce. 
if puddle: x+=vx*dt; vx*=friction (0.985 per frame? use pow). collide with walls: if x< tank.right (520) and moving left => clamp x=520 (tank base) ; if x> room.right-w => clamp, vx=-vx*0.3. Also maybe pile: if many, raise? skip.

Actually puddle should also be bounded on left by tank base at x=520, but the jet lands at x>520 on floor; initial puddle vx to the right, then spreads both directions; left spread stops at 520. Good.

Render water:
- Inside tank: fill interior from waterLevelY to iy1 with translucent blue, plus a surface line.
- Jet: draw particles as small blue circles or a connected stream. Draw as circles radius ~3 with alpha.
- Puddle: draw particles as ellipses on floor; or draw a translucent layer. I'll draw particles.

Glass fragments:
when burst: create N shards along the right panel (x in [510,520], y in [top,bottom]). Each shard: polygon (triangle) with position, velocity (outward x positive + random), angular vel, rotation. They start embedded; on burst they get velocity = jetVel*0.4 outward + random, plus gravity. They experience water resistance when their y is below waterLevelY and x within tank? Actually shards fly outward to the right into air; lower ones may be in water initially. We'll apply: if shard.y between waterLevelY and floorY and x in interior range => water drag strong; else air drag. Simplify: drag proportional to fluid density depending on whether inside water. Let me just apply moderate drag always and gravity; collisions with floor (bounce) and walls (bounce) and tank base.

Actually fragments should also collide with room boundaries (walls, floor). Provide restitution.

Fish: array of fish with positions inside tank. Each fish has swim behavior: each frame compute target: in water, they try to stay near center / swim against current. Compute fluid velocity at fish position (current pushes right near breach). Fish apply force = swimForce toward left (against current) when current pushes them right, plus drag with fluid. They also have up/down wandering. Buoyancy neutral so they hover. Let them follow water level: if waterLevelY passes below them (surface dropped) and they're above surface, they'd be in air inside tank? That would make them fall. Actually as water drains, fish should be carried by water down? Fish swim, they can stay; but if water level drops below fish, fish would be in air (above water inside tank) and fall to surface then water. Hmm. To keep them in water, let buoyancy keep them at the water (they float at surface? fish neutral). Let me make fish maintain depth: they tend to stay at a fraction of water depth. Simplify: keep fish within water column: clamp fish.y between waterLevelY and iy1; if waterLevelY increases (lowers), fish get pushed down with it (they follow surface). Also current pushes them right toward breach.

When fish reaches x> ix1 (passes interior right boundary) while y within opening vertical band and water present: it's exiting. Then becomes airborne (outside). Set inWater=false. Then gravity, fall to floor, collide.

But the opening band: the wall is broken from crackY-aperture/2 to crackY+aperture/2. Fish only exit through that band. If fish at other y and pushed right, it hits the (remaining) wall — clamp x <= ix1. So fish must be near crackY to exit. Good: fish swim against current to avoid being at crack level. We can make fish avoid the crack region (they sense danger) and swim left/up/down away. But current sweeps them; eventually some pass through.

Let me implement fish AI: desired velocity = away from breach: if near right and within crack band, steer left strongly and vertically away. Plus wander. This makes them "attempt to swim against the current before being swept through." Over time water drains, current reduces, but they may still get swept when pushed to wall at crack height. Let me ensure some fish get swept: current near breach strong; if fish can't overcome, swept. Possibly make fish slightly less strong than max current so eventually swept. Let me tune.

Rocks: dense, at bottom. Apply gravity + buoyancy (sink) + drag + current. They basically sit; if crack low and current strong at bottom, get pushed right and exit at low opening. Could happen. Fine.

Toy (floating duck): density low, floats at surface. Apply buoyancy (up) + drag + current. It rides on waterLevelY. As water lowers, it descends. Current pushes right; if at crack height (when water level nears crack, the toy at surface near crackY) it can be pushed out. Actually when waterLevelY ~ crackY, the toy at surface is right at opening height -> gets pushed out -> airborne -> floor. Good, gives a nice toy swept out.

Plants: anchored at bottom, sway. Represent as a few segments; bend based on current near their x. They don't exit. Provide for ambiance and requirement "plants reacting." They react by bending (current). Keep anchored.

Now also "objects transitioning correctly from underwater motion to airborne motion and then to floor collisions" — fish, toy, rocks. Good.

Let me also ensure fish when airborne fall and then on floor flop (rest). Good.

Let me now write code. I'll be careful with performance: number of water particles cap ~ 1500. Glass fragments ~ 40. Fish ~ 6. Rocks ~ 5. Plants ~ 4. Toy 1.

Let me define fluidVelocityAt(x,y) for inside tank (water region):
Opening point Ox = ix1 (510), Oy = crackY.
If water present (waterLevelY < iy1) and x in [ix0, ix1] and y in [waterLevelY, iy1]:
 dist = hypot(x-Ox, y-Oy)
 jet = sqrt(2*g*h) where h=crackY-waterLevelY (current speed magnitude near opening)
 vx = jet * 1.0 * exp(-dist/120) * (x<=Ox?1:0.6)  // outward to right
 vy = -jet*0.15*exp(-dist/120)*( (y<Oy)?1:-1 ) // slight
 Actually fluid flows rightward out; inside the tank the current is toward the opening (rightward) and slightly toward crack height. So vx positive (toward breach), vy toward crack (sign). Let me do:
 vx = jet*exp(-dist/150)
 vy = (Oy - y) * jet * 0.003 * exp(-dist/150)  (pull toward crack height) bounded.
Return {vx,vy}. If no water or outside, {0,0} (or tiny).

For airborne region (outside tank, above floor), fluid velocity 0.

Now object integration generic:
For each object, determine environment:
- inWater = (x within interior X [ix0,ix1]) and (y between waterLevelY and iy1) and waterPresent. Also if floating at surface, y≈waterLevelY within. Let me define submerged if (x in [ix0-pad, ix1]) and (y+objSize > waterLevelY) and (y < iy1) and waterLevelY < iy1. Hmm for objects partially above surface (floating toy), treat as in water with buoyancy reducing by submersion fraction. Let me compute submersion fraction f = clamp((min(y+size, iy1) - waterLevelY)/size,0,1) for x in interior. If f>0 => partially in water. Buoyancy scales with f. Drag scales with f (water drag) plus air drag for the rest. This gives nice floating.

But also need "outside tank" detection for x>ix1: then inWater=false (it's air). Even if y<waterLevelY, outside tank there's no water. So inWater requires x in interior.

For x in interior but y<waterLevelY (above water surface, inside tank air pocket) => inWater false => falls under gravity (air). That's the scenario when water low and fish above surface. They'll fall to surface. Fine.

So env:
inWater = (x>ix0 && x<ix1 && y> waterLevelY-2 && y< iy1 && waterLevelY<iy1)
Actually y>waterLevelY means below surface (deeper). For floating we want partial. Let me compute submersion separately:
if x in interior and waterLevelY<iy1:
   subTop = y - size; subBot = y + size (object center y, half-size = size)
   submergedDepth = min(subBot, iy1) - max(subTop, waterLevelY)
   if submergedDepth>0: submersion = submergedDepth/(2*size), clamp.
   inWater = submersion>0
else inWater=false.

Use submersion to scale buoyancy and water drag.

Forces:
gravity: ay += g (down, +y).
buoyancy (water): Fb up = rho_w * V * g * submersion. Weight = rho_obj*V*g. Net buoyancy accel up = (rho_w - rho_obj)/rho_obj * g * submersion? Let me just compute net vertical from densities:
 buoyAccel = ( (rho_water - density) / density ) * g * submersion. (this is acceleration). If density<water => positive up. If rock density 2.5 => negative (sinks). Good. Use g.
Wait that's per unit? net force = (rho_w*V - rho_obj*V)*g = V*(rho_w-rho_obj)*g. accel = netforce/m = netforce/(rho_obj*V)= (rho_w-rho_obj)/rho_obj * g. Yes.

drag: relative velocity to fluid. fluidV = inWater? fluidVelocityAt(x,y) : {0,0}. Also water has horizontal current; air fluid 0.
 vrelx = vx - fluidVx; vrely = vy - fluidVy.
 dragMag = 0.5 * rho_fluid * Cd * A * speed * vrel (vector). 
 rho_fluid = water:1000 in water, air:1.2. Use ratio; let me just use coefficient kDragWater and kDragAir separately for simplicity.
 Let speed = hypot(vrel). 
 dragAccel_x = -dragCoef * speed * vrelx ; similarly y. Where dragCoef scaled by submersion for water part and (1-submersion) for air. Actually for partial submersion: waterDrag * submersion + airDrag*(1-submersion).
 Let me define per object dragK (depends on size). 

Simplify: a_drag_x = -(cw*submersion + ca*(1-submersion)) * speed * vrelx.

For fish add swim force: a_swim toward desired.

Integrate: vx += ax*dt; vy+=ay*dt; clamp max speed; x+=vx*dt; y+=vy*dt.

Collisions:
- Tank interior right wall (x <= ix1) unless within opening band where wall absent. If inWater and x>ix1 and not in opening band => clamp x=ix1, vx=0 (or bounce small). If within opening band and x>ix1 => exit (allowed). Actually we want fish to be able to exit only via opening. So: if x>ix1 and |y-crackY|>aperture/2 and y between waterLevelY..iy1 (in water region near wall) => blocked: clamp x=ix1, vx*=-0.2. If |y-crackY|<=aperture/2 => allow pass (exiting). But also ensure there's water (waterLevelY<crackY). If no water above crack, no flow anyway.
- Tank floor: if y+size>iy1 and x in interior => y=iy1-size, vy*=-0.3 (small bounce), vx*=0.8. (objects rest on tank bottom). Also they're in water still so buoyancy etc.
- Outside region: when x> ix1 (past wall) and y>waterLevelY (or just outside tank horizontally) => it's air. Apply air gravity + air drag. Floor collision at floorY: if y+size>floorY => y=floorY-size, vy*=-restitution, vx*=friction, if |vy|<small => rest (vy=0). Also wall collisions room.left/right: x bounds.
- When object exits and lands, it's on room floor to the right of tank.

But careful: an object at x just past ix1 but y still within tank vertical range and water present—outside tank there is no water (the room to the right of tank at that height is air, unless water has pooled? The puddle is only on floor). So treat as air. Good. So buoyancy 0 once x>ix1. It will fall (gravity) since air, land on floorY. Good, matches "airborne then floor."

But what about objects that exit but then the room floor at floorY=620 equals tank bottom iy1=620. So they land on same floor. Fine.

One more: While in water and near opening, the fish that exit—once x>ix1 we set inWater=false (because x not in interior). Good.

Let me also handle fish vertical so they don't sink to bottom and get stuck; buoyancy ~ neutral keeps them mid-water; swim wander keeps them moving.

Let me set densities:
- fish: 1.02 (slightly > water => slight sink) but swim compensates. Or 1.0 neutral. Let me use 1.0 so they hover; swim handles position.
- rock: 2.6
- toy: 0.35
- plant: 1.0 (anchored, ignore buoyancy physics; just visual).

Sizes: fish length ~ 34 (size=17 half). rock radius ~ 14 (size 14). toy ~ 18. 

Let me set initial positions: randomly in interior, fish y in mid, rocks near bottom, toy near surface (y≈waterLevelY-size).

Now fish swim: desired velocity:
- Avoid breach: if x> ix1-120 (near right) and |y-crackY|<aperture: steer left (vx desired negative) and away vertically.
- Wander: random small accel.
- Maintain horizontal: try to stay around center.
Compute desiredVx, desiredVy. Apply accel = (desired - v)*swimK. swimK ~ 6 (strong) but less than ability to overcome current at crack. Actually we want them to fail eventually. The current near opening can be up to jet speed ~600; fish max speed maybe 250. So they can't overcome near opening; but they avoid going there. They get swept when current pushes them to wall while at crack height. As water drains, h decreases, current weaker; but also water level drops bringing fish lower; if fish hover mid and water lowers, they descend; the crack stays at crackY; when waterLevelY (surface) passes below crackY, no more current, flow stops. Hmm then fish never swept? Let me think: fish hover relative to water? If they maintain depth fraction, as water lowers they go down. The crack fixed. When fish depth reaches crack height, and current still active (water above crack), they could exit. But if they avoid the band vertically, they stay above/below. But current pulls them toward crack height (vy toward Oy). Fish swim against that too. Eventually? Might be they resist indefinitely, that's fine—"attempting to swim against current before being swept." We can also make one or two fish get swept by random wander. To guarantee visual, I'll make some fish weaker (less swim) so they get swept. Mix.

Actually simpler narrative: Initially fish swim against current (visible). As tank drains, current weakens but the fish at the bottom region get pushed by the receding water? Eh. Let me just make current also create a rightward drift everywhere in tank (scaled), so even away from opening fish drift right slowly, accumulating at right wall. At the wall, if at crack height they exit; the avoidance pushes them vertically away from band, but they pile at wall above/below the opening. The opening band is limited (aperture ~26). Fish above or below band blocked by wall. So they'd be stuck at wall, not exit, until they wander into band. Over a minute they might. To ensure some exit, I'll make the aperture a bit larger (e.g., 30) and let fish wander into it, plus when current strong near band they get sucked. Some will exit. Good enough. Also the toy exits when water reaches crack level (surface near crack) — guaranteed.

Honestly for a simulation demo, having a few fish swept and the toy swept and rocks possibly, plus water jet and puddle and glass, satisfies requirements. Let me also let the user keep dragging? After burst, dragging disabled.

Let me also add: while intact, the crack is shown and user can drag; show label "Drag to set crack height, then press Burst". Provide buttons: Burst, Reset. Also maybe a slider? But requirement explicitly says drag the crack vertically. I'll implement mouse drag on canvas: if state intact and mouse near right panel, dragging sets crackY = clamp(mouseY). On mousedown near panel (x within ~30px of right wall, y within tank) start drag.

Now also "side panel develops a visible crack" before burst — show a jagged crack line at crackY on the panel, maybe with branches. Draw a zigzag.

On burst: change state to 'burst'. Create glass fragments along the right panel (replace panel with shards). The opening becomes clear (remove that part of panel). Water flows.

Let me also draw remaining glass panels (top, left, bottom, and right except opening) with translucency and highlights.

Let me now also handle the water inside tank rendering: from waterLevelY to iy1 fill. Surface line slightly wavy (use sine based on time) for nice effect.

Also draw room: floor, back wall, maybe a baseboard. Keep simple: floor rectangle, side walls lines.

Let me also draw a subtle background.

Now let me consider the puddle accumulation visual: I'll also maintain puddleLevel as a height field? Let me keep particle puddle but draw a translucent puddle polygon: compute leftmost and rightmost puddle particle and draw a thin rectangle from floorY upward by small height (based on count). Actually to show collision with boundaries clearly, particle approach with wall clamp is enough. I'll render puddle particles as soft blue ellipses, and also a base translucent layer along floor between min and max x with height = min(40, count*k). Hmm but as it spreads, height should decrease. Let me compute puddle volume = spilled water volume (track). puddle area = volume / puddleLength. puddleLength grows from landing point outward until hitting walls. I'll track puddle horizontally: puddleMinX, puddleMaxX starting at landingX, expanding as water particles spread; clamp at walls (520 left, 1080 right). puddleHeight = volume / (puddleMaxX-puddleMinX), capped. Draw translucent blue rectangle along floor of that height. That nicely shows spreading puddle colliding with boundaries. And also keep particles for jet.

Let me track spilledVolume (sum of dV). And puddle extends: each frame puddleMaxX moves right toward room.right at some rate; puddleMinX moves left toward 520. Once hits boundary, stops (collision). puddleHeight computed. This is a clean visual. I'll still draw jet particles.

Actually if I draw both a puddle rectangle and particles it's fine.

Let me code puddle:
puddle = {minX: landingX, maxX: landingX, vol:0, height:0}
On burst, landingX = something like 560 (jet lands a bit right of tank). Actually jet travels right and lands where? It depends on velocity & gravity. Let me just set minX=520 (tank base), maxX=560 initially, vol as spilled. Height = clamp(vol/(maxX-minX), 0, 60). Expand: targetMax = room.right-10; maxX += expandSpeed*dt until reach; minX -= toward 520 (already 520). Actually left bound is tank base 520; puddle can't go left of 520. So minX stays 520 (or initial landing). Let me set minX = 520 (tank right). maxX starts 520 and grows to room.right as vol increases / spreading. Simpler: maxX = min(room.right-10, 520 + sqrt(vol)*spreadK). As vol grows, puddle spreads right. Left fixed at 520 (tank base) — but that means puddle left edge at tank, good (collides with tank base). When water volume huge it would exceed room right; clamp => collision with right wall (puddle can't pass). Height capped.

That gives "spreading puddle that collides with the room boundaries" (left = tank base, right = room wall). Good. Also it would overflow if vol huge; cap height and if maxX hits right wall, height grows (flooding). Cap height at like 60.

Alright. Let me also make sure water inside tank lowering: waterLevelY increases over time as drained. Good.

Let me also ensure when water fully drained (waterLevelY>=iy1) stop flow, current 0.

Now glass fragments physics:
shard = {x,y, vx,vy, ang, av, verts:[...] relative, size, rest}
update: 
 inWater? if x in interior and y>waterLevelY and y<iy1 => water drag strong. else air.
 dragCoef = water? 3 : 0.5. 
 vx += (0 - vx)*dragCoef*dt? Actually apply drag: vx -= vx*dragK*dt; plus gravity vy+=g*dt.
 x+=vx*dt; y+=vy*dt; ang+=av*dt; av*=(1-0.5*dt) maybe.
 collisions: floor: if y+half> floorY => y=floorY-half; vy*=-0.4; vx*=0.6; av*=0.6. walls: x in [room.left+half, room.right-half] clamp bounce. tank base? shards to right of tank, base at 520; if x<half+? they could hit tank left side? Unlikely (they go right). Left wall room.left bound.
 Also shards that are in water initially (lower part) get slowed (water resistance) — requirement "water resistance." Good.

Glass fragments spawn: along right panel x from 510 to 520, y from iy0 to iy1, create maybe 36 shards each a small triangle. On burst they get initial velocity outward (vx positive 100-300) + slight up + random, av random.

But the panel also had the crack; after burst the whole right panel shatters. We'll not draw the right panel glass anymore (it's gone / replaced by shards). Actually we might keep a thin frame. Let me just not draw right panel post-burst, draw shards instead.

Now the crack drawing pre-burst: draw right panel glass, and a jagged crack line at crackY across the panel width, with a few branches. Add small "stress" marks.

Let me also show water level line visibly (already). And maybe a HUD showing water depth, drained %.

Let me also add instructions text and buttons as HTML overlay (buttons) for clarity. Use simple styled buttons.

Now, let me write the file. I'll be thorough but keep code organized. This is going to be long. Let me write it.

Let me define helper functions: clamp, rand, lerp, hypot.

Let me carefully manage coordinate of surface waviness for physics? Physics uses flat waterLevelY; rendering adds small sine for surface only. Fine.

Time stepping: use dt = min(0.033, (now-last)/1000). Possibly substep physics for stability (e.g., 2 substeps). Water particles fast; substeps help. I'll do fixed substeps: steps=2, h=dt/2.

Let me set scales and tune later mentally.

Let me compute approximate numbers. interiorWidth = ix1-ix0 = 510-130 = 380. h initial = crackY - waterLevelY. crackY=380, waterLevelY=150 => h=230. jet = sqrt(2*900*230)=sqrt(414000)=643 px/s. Good.

drain dV = apertureH * jet * dt. apertureH=30. dV=30*643*dt=19290*dt px^2/s? Actually volume per depth: interiorWidth*drop = dV => dWaterLevel = dV/interiorWidth = (apertureH*jet*dt)/380 = (30*643/380)*dt=50.8*dt px/s. So water drops ~50px/s initially. Over time as h decreases, slows. Time to drain significantly: to drop 230px at ~50px/s ~ maybe 10-15s with slowdown. Good, visible continuous lowering. 

Spawn particles: n = k*apertureH*jet*dt. With k=0.05 => n=0.05*30*643*dt=964*dt => at 60fps dt=0.016 => ~15 particles/frame. Over 15s ~ 15000 particles—too many. Cap total water particles at maybe 1200; recycle. Actually particles die when they become puddle and then after some time? Puddle particles persist; they accumulate. Let me cap puddle particles too, removing oldest. Or only keep jet particles limited and rely on puddle rectangle for puddle visual; puddle particles optional. Let me keep puddle particles but cap at 800, removing oldest when exceeding.

Let me set k so spawn ~ 6/frame. k=0.02 => n=0.02*30*643*0.016=6.15/frame. Good. Over time fewer as jet slows. Cap water particles (jet+puddle) at 1000; when exceeding, convert oldest puddle to just removed (we already have puddle rectangle). Actually simpler: keep particles but cap; when adding beyond cap, drop oldest puddle particle.

Let me just maintain array; on spawn if length>1200 remove from front (oldest). Fine.

Puddle rectangle handles the macro puddle; particles add detail. Good.

jet particle radius ~2.5, puddle particle radius ~3.

Let me now also make sure jet particles get spawned at opening with correct direction: vx = jet*(0.85+0.3*rand), vy = (-0.1+0.2*rand)*jet*0.2? Let me give slight spread: vy = (rand-0.5)*40. Good. Actually gravity will curve it down. With jet 643 px/s rightward, from x~515,y~380 to floor 620: time to fall 240px: 240=0.5*900*t^2 => t^2=0.533 => t=0.73s. horizontal distance=643*0.73=469px => lands at x~984. That's near right wall (1080). Good, puddle forms near right side. For lower crack (crackY larger, e.g., 520) h=370 => jet=sqrt(2*900*370)=815; lands further right maybe beyond wall -> hits wall, puddle collides. Good demonstration "lower crack stronger jet." Also higher crack (crackY=200) h=50 => jet=300, lands x~515+300*0.78=? t: fall from 200 to 620 =420px => t=0.97 => x=515+300*0.97=806. So lower crack => lands further right / stronger. Good.

Alright, let me write.

For fish exit detection and physics, let me define function updateObject(o, dt) handling states.

Let me define object.type and properties. I'll write a generic but with type-specific tweaks.

Let me define environment function getEnv(x,y,size):
returns {submersion, fluidVx, fluidVy, inTankInterior}
 ix0=130,ix1=510, iy1=620.
 inInteriorX = x>ix0-? Let me use x>ix0 && x<ix1. But objects have size; use center. Fine.
 if inInteriorX && waterLevelY<iy1:
   top=y-size, bot=y+size
   sub = clamp((Math.min(bot,iy1)-Math.max(top,waterLevelY))/(2*size),0,1)
 else sub=0
 fluidV: if sub>0 compute current toward opening:
   Ox=ix1, Oy=crackY
   dist=hypot(x-Ox,y-Oy)
   jet=Math.sqrt(2*g*Math.max(0,crackY-waterLevelY))
   f = Math.exp(-dist/160)
   fvx = jet*f
   fvy = (Oy - y)*jet*0.0025*f  // pull toward crack height
   but only if flowing (waterLevelY<crackY). if not flowing fvx small.
 else fvx=0,fvy=0 (air, no current). Also tiny ambient 0.

Return.

Now integrate per object:
 let env=getEnv(o.x,o.y,o.size)
 // buoyancy + gravity
 let ay = g  // gravity down
 let ax = 0
 if(o.type!=='plant'){
   // buoyancy
   ay += (rhoWater - o.density)/o.density * g * env.submersion
 }
 // drag
 let vxr = o.vx - env.fluidVx
 let vyr = o.vy - env.fluidVy
 let sp = Math.hypot(vxr,vyr)
 // water drag coef scaled by submersion, air drag by (1-sub)
 let cw = o.cdW, ca = o.cdA
 let drag = cw*env.submersion + ca*(1-env.submersion)
 ax -= drag*sp*vxr
 ay -= drag*sp*vyr
 // swim for fish
 if(o.type==='fish'){ ... add swim accel }
 // integrate
 o.vx += ax*dt; o.vy += ay*dt
 // clamp speed
 // collisions
 ...

Swim for fish: 
 // desired: stay away from right wall & crack band, mild wander
 let desiredVx = 0, desiredVy=0
 if(o.x > ix1-140){ desiredVx = -180 } else { desiredVx = (o.wanderX) } // tend left near breach
 if(Math.abs(o.y-crackY) < aperture/2+20 && o.x>ix1-160){ desiredVy = (o.y<crackY? -160:160) } // move away from band
 else desiredVy = o.wanderY
 // wander update
 o.wt -= dt; if(o.wt<=0){ o.wanderX=(rand-0.5)*120; o.wanderY=(rand-0.5)*120; o.wt=rand*1.5+0.5 }
 let swimK = o.swimK
 o.vx += (desiredVx - o.vx)*swimK*dt
 o.vy += (desiredVy - o.vy)*swimK*dt

But this swim competes with drag & current. Near opening current fvx up to ~jet(600). swimK*dt changes vx by (desired - vx)*swimK*dt. With swimK=4, dt=0.016 => 0.064 fraction per frame; effective max additional speed ~ desired*swimK? Actually steady state when accel from swim = drag: (desired-v)*swimK = drag*sp*vrel... messy. Let me just make fish strong but max speed limited; they can hold against moderate current but near opening lose. Fine; they mostly avoid. Some get swept. Good.

Clamp speed: maxSpeed per type (fish 260, rock 400, toy 300). After integrate clamp.

Collisions order:
 // tank interior walls (only when in interior horizontally)
 if(o.x>ix0 && o.x<ix1){
    // right wall unless opening band and flowing
    if(o.x>ix1-o.size){
       if(state==='burst' && Math.abs(o.y-crackY)<aperture/2 && waterLevelY<crackY){
          // allowed to exit; do nothing (will cross)
       } else {
          o.x=ix1-o.size; if(o.vx>0)o.vx*=-0.2;
       }
    }
    if(o.x<ix0+o.size){ o.x=ix0+o.size; if(o.vx<0)o.vx*=-0.2; }
    // floor of tank
    if(o.y+o.size>iy1){ o.y=iy1-o.size; if(o.vy>0)o.vy*=-0.25; o.vx*=0.85; }
    // also can't go above tank top (ceiling) interior
    if(o.y-o.size<iy0){ o.y=iy0+o.size; if(o.vy<0)o.vy*=-0.2; }
 }
 // outside tank: floor = room floor (same as iy1=620) but only for x>ix1 region; also left bound is tank base (x>=520) for outside
 // Determine if outside: x>ix1 (past right wall) OR (x<ix0) etc. Mainly right.
 if(o.x>=ix1){
    // room floor collision
    if(o.y+o.size>floorY){ o.y=floorY-o.size; if(o.vy>0)o.vy*=-0.3; o.vx*=0.7; if(Math.abs(o.vy)<30)o.vy=0; }
    // left bound = tank base at x=520 (can't go left of tank into tank? actually it could re-enter, but wall gone only at band; to keep simple allow re-enter only via band). Let me clamp x>=520 so they stay outside.
    if(o.x<520){ o.x=520; if(o.vx<0)o.vx*=-0.3; }
    // right wall room
    if(o.x+o.size>room.right){ o.x=room.right-o.size; if(o.vx>0)o.vx*=-0.3; }
 }
 // general room left wall for anything (not needed since tank on left)
 if(o.x-o.size<room.left){ o.x=room.left+o.size; if(o.vx<0)o.vx*=-0.3; }

Wait when object is exactly at opening band and exits, x becomes >ix1; then the outside block handles floor and left clamp at 520. But a fish exiting at crackY=380, x>510, falls to floorY=620 => airborne then floor. Good. But the left clamp x>=520 would push it back if x<520; but it's exiting to the right (x>510 going right), so x>520 quickly. However right after crossing, x maybe 511 <520 => clamp to 520 and vx reversed? That would prevent exiting! Problem. The left clamp at 520 is meant to stop puddle/objects from going left of tank base back under tank. But a freshly exiting fish at x=511 shouldn't be clamped. Hmm. The issue: the tank base occupies x in [510,520] at floor? Actually tank wall thickness 10 (510-520). The tank exterior right face is at x=520. An object exiting through the breach travels right from x=510 outward; the wall (510-520) is now shattered, so it can occupy x in 510..520 and beyond. So left clamp should be at x=510 (the interior right edge), not 520. But the puddle/tank base visual: tank base is the bottom slab from x=120..520 at floor. An object outside on the floor to the right should have x>520 (right of tank). But it could be at x between 510 and 520 only transiently while passing through the (shattered) wall region. After passing, x>520. The floor at x in [510,520] is the tank's bottom wall thickness; an airborne object passing there would be above floor anyway. Let me set outside left bound at x = ix1 (510). So clamp x>=510 when x>=ix1. Then fish exiting at x=511 stays >510 fine, continues right past 520. Good. Remove the 520.

But then puddle on floor: puddle minX should be 520 (right face of tank) since floor left of 520 is tank base (solid, can't have puddle on top of tank base? Actually tank base top is at floorY=620, same level; the tank base is a solid block from x120..520 sitting on room floor. The puddle forms on room floor to the right of the tank, i.e., x>520. So puddle minX = 520. But objects (fish) that landed are at x>520 too. Consistent. Good. So set outside left bound x>=520 for floor-resting? But a fish mid-air at x=515 (within wall region) shouldn't be clamped to 520 (that would push it into tank base region). Let me allow x in [ix1, room.right] for outside, and for floor resting, if x<520 it's within tank base footprint—should rest on tank base top (also floorY). So just use floorY collision for any x; and left bound = ix1 (510). The tank base visual is just drawn; physically objects can be at x 510..520 at floor (on top of base) - fine, negligible.

Simplify: outside region = x>=ix1. Collisions: floor at floorY for all (room floor and tank base top same y). Left bound x>=ix1 (so can't go back into tank interior left of wall). Right bound room.right. Good. Puddle rectangle minX=520 though (drawn). Slight mismatch fine.

Actually wait, if left bound is ix1=510, a fish that exits and falls might be at x between 510 and 520 at floor, which is on top of tank base (correct, it's the tank's exterior base). Fine.

Now interior right wall clamp uses ix1=510 interior; opening band allows x>510. Good.

Edge: when fish exactly at band and flowing, it crosses to x>510; then outside block applies; good. But note the interior block also runs because x>ix0 && x<ix1 is false once x>ix1. Good.

But there is a subtlety: an object inside near right wall but above water or below band gets clamped at x=ix1-size, can't exit. Good.

Now toy: floats at surface; as water lowers, surface lowers, toy follows because buoyancy with submersion>0 keeps it up; but if water surface drops below toy (toy above surface, submersion 0 => no buoyancy => falls until submersion>0 again). So toy tracks surface. Good. When waterLevelY approaches crackY (surface near crack), toy at surface near crackY => it's at opening band height and water flowing => current pushes it right through opening => exits => airborne => floor. 

Rocks: density 2.6, sink to tank floor (iy1). They rest there. Current at bottom near opening: if crack low (crackY near bottom), dist from rock (at bottom, y=iy1=620) to opening (crackY) is |620-crackY|; if crackY=520, dist=100 => f=exp(-100/160)=0.53 => current ~0.53*jet horizontal at bottom => could push rock right to wall at crack band? But rock at bottom y=620, band is crackY±15; if crackY=520, band 505..535, rock at 620 not in band => blocked by wall, stays. If crackY near bottom e.g., 600, band 585..615, rock at 620-14=606 within band => exits! So low crack can sweep rocks. Nice, satisfies "reacting differently according to density" and "swept."

Good.

Plants: anchored at bottom; just draw bending based on current at their location; no physics movement. Provide for ambiance.

Let me also ensure fish "attempting to swim against the current" visible: near breach they swim left (against rightward current). Good.

Now rendering details. Let me write draw functions:
- drawRoom: floor gradient, back wall, baseboard, maybe a window. Keep simple.
- drawTank: draw left, top, bottom panels glass (translucent), and right panel if state==='intact' (with crack). If burst, draw frame edges only (no right panel) and draw shards separately. Draw water inside.
- drawWaterInside: clip to interior, fill from waterLevelY to iy1 with vertical gradient blue, draw wavy surface line, draw subtle caustics maybe.
- drawObjects inside: plants (behind water? draw before water for submerged look? Let me draw plants & rocks & fish inside water with slight tint by drawing them then water overlay translucent. Order: draw tank back, draw interior background, draw plants, rocks, fish, toy, then draw water overlay translucent on top (so they appear submerged), then glass front. That gives nice underwater look.
- drawJet: particles.
- drawPuddle: rectangle + particles.
- drawShards.
- drawHUD.

For submerged look, drawing a translucent water rectangle over everything inside gives tint. But then fish behind glass—fine.

Let me set order each frame:
1. clear, draw room background (floor, walls).
2. draw tank exterior (back panels): left, top, bottom glass with translucency and reflections. Actually draw the glass panels as semi-transparent so we see through to room behind. Room behind tank is just wall; fine.
3. Draw water-inside fill (so interior shows water). Then draw submerged objects (plants, rocks, fish, toy) — but if we draw water fill then objects on top, objects not tinted. To tint, draw a second translucent water layer over objects. Let me: draw water fill (opaque-ish base), draw objects, draw translucent water overlay (alpha 0.25) to tint, then draw front glass highlights. Also draw surface line.
4. draw jet particles (in front of tank, in room).
5. draw puddle.
6. draw shards.
7. draw HUD, instructions.

For objects outside tank (landed on floor), draw them in the room (after tank). I'll draw all objects: those inside get tinted by overlay; those outside drawn normally over room. Simplest: draw objects in two passes? Let me just draw all objects after water fill but before overlay; overlay tints everyone including outside ones (outside wouldn't have water, but overlay only drawn within interior clip region). I'll clip overlay to interior so outside objects not tinted. Good.

Let me implement clipping for water fill and overlay to interior rect [ix0,ix1]x[iy0,iy1] but water fill only below surface, so clip to [ix0,ix1] x [waterLevelY, iy1].

Let me code.

I'll write the HTML now. Let me be careful and complete.

Let me define constants at top of script.

Let me also add a "spreading puddle that collides with room boundaries": puddle rectangle minX=520, maxX grows to room.right-10 (collision), height limited. Also if volume too high height capped at 70, and it would "collide" meaning can't spread further (maxX stops at wall). Good.

Let me compute puddle height from volume: height = min(70, vol / (maxX-minX) ). vol in px^2 (area). Initially vol small. As drains, vol grows. Area = vol; height = vol/length. length = maxX-minX. So height = vol/length. Initially length small ~40 => height = vol/40. Could be large initially if vol grows; but vol grows with time; length grows too. Let me make maxX expand rate proportional to incoming flow: when water spawns, also push maxX right by some amount, and when hits wall stop. Let me do: maxX = min(room.right-10, 520 + Math.sqrt(vol)*1.2). vol in px^2; sqrt gives length-ish. For vol=10000 => sqrt=100 => maxX=520+120=640. For vol=1e5 => sqrt=316 => maxX=520+379=899. For vol=4e5 => sqrt=632 => maxX=520+758=1278>1070 => capped at 1070 (collision). height = vol/(maxX-520). At vol=4e5,length=550 => height=727 -> capped 70. So puddle floods to 70 high at right wall. Reasonable.

But note interiorWidth*drop gives vol: total drainable vol = 380*(waterTopY..). initial h surface 150 to bottom 620 => full vol = 380*470=178600. So max vol ~178600. sqrt~422 => maxX would be 520+506=1026 <1070, so reaches near right wall but maybe not collide unless crack low landing further. Anyway height capped 70. Good. Actually with vol 178600 and length ~500 => height 357 capped 70. So puddle height 70, spreading to ~1026. Could collide with right wall if we set expansion larger. Let me make sqrt factor 1.6 => vol 178600 sqrt 422*1.6=675 => maxX=1195>1070 clamp => collides! Good, demonstrates collision with right wall. Let me use factor 1.6 and also ensure min length so height not insane early: height=min(70, vol/Math.max(40,maxX-520)). Fine.

Now also puddle should start at the jet landing area, not at tank base necessarily. But for simplicity base at tank. The jet lands further right; puddle rectangle from 520 covers under landing. Acceptable.

Let me also display water drained %.

Alright, also need "visible waterline that lowers continuously rather than disappearing all at once" — our waterLevelY rises smoothly. Good.

Let me write the code now. I'll include comments.

One more: fish should be drawn as simple fish shape (ellipse body + tail triangle), oriented by velocity. Rocks as gray circles with shading. Toy as a rubber duck (yellow body + orange beak) or a ball. Plants as green wavy strands.

Let me code drawFish(o): compute angle from vx,vy. Save/translate/rotate. Draw body ellipse, tail.

Let me handle when fish outside (on floor) still draw same.

Let me start writing.

I'll also add substepping for water particle physics to avoid tunneling through floor at high speed: with dt up to 0.033 and vy up to ~900 => move 30px/frame, floor detection fine (we check y>=floorY). OK.

Let me write the full file.

For performance, water particle count cap 1200. Spawn rate moderate.

Let me also limit shards count ~ 40.

Let me write.

I need to be mindful: The script must be inside index.html. Let me write everything.

Let me also implement pointer events for dragging crack: on pointerdown, if state==='intact' and pointer near right panel (within 40px of x in [510,520] and y in tank vertical) -> dragging=true. On pointermove update crackY = clamp(y, iy0+20, iy1-20). pointerup -> dragging=false. Also allow clicking anywhere on right panel region.

Now burst button triggers if state==='intact': set state='burst', spawn shards, set water flowing.

Reset button: reinitialize everything.

Let me code init() to set up fish, rocks, toy, plants, water, shards cleared, state='intact', crackY default 360.

Let me define arrays globally and reset.

Now let me write the code fully.

Let me make sure variable floorY = iy1 = 620. room.right=1080, room.left=20 maybe (leave margin). Let me set canvas 1100x700. Tank left=130? earlier ix0=130. Let me finalize:

W=1100,H=700
room.left=20, room.right=1080, floorY=620
tank.left=130, tank.right=520, tank.top=110, tank.bottom=620, wall=10
ix0=140, ix1=510, iy0=120, iy1=620
waterTopY=150
crackY default = 360 (clamp iy0+20=140 .. iy1-20=600)
aperture=30

Hmm tank.right=520, ix1=510 (interior right). Good.

room.right=1080, so puddle maxX up to 1070. Good.

Let me also draw a back wall behind tank within room.

Alright writing now. Let me also add a soft gradient background and floor.

Let me write the file.

I'll now produce the code. Given length, I'll write carefully.

For water fill gradient: from lighter at top (surface) to deeper blue at bottom.

Let me include caustic-like wobble on surface: a sine path.

drawSurface: moveTo(ix0, waterLevelY + sin...). 

Let me write.

Let me also handle the case where waterLevelY > iy1 (fully drained): clamp waterLevelY=iy1, stop flow.

Let me also reduce fish count to 7, rocks 5, plants 4.

Now, about fish initial positions: x random in [ix0+30, ix1-30], y random in [waterLevelY+30, iy1-60]. Rocks near bottom y=iy1-size. Toy y=waterLevelY-size (on surface). Plants at bottom x spread.

Let me write final.

I'll write the script with requestAnimationFrame loop.

Let me also add slight randomization to spawn jet vy to make a spray.

Also "curved water jet affected by gravity" satisfied.

Also note: requirement "Water escaping through the opening with flow strength based on water depth and decreasing as the tank drains" — our dV and jet scale with h=crackY-waterLevelY, decreasing as waterLevelY rises. Good.

"lower crack should initially produce a stronger jet than a higher crack" — h larger for lower crack => stronger jet. Good.

Let me write now. I'll produce the whole file in one go.

Let me also make sure to draw the crack visibly and an arrow/hint.

Let me write the HTML.

I'll be done. Let me also add CSS for buttons and layout, center canvas.

Let me write.

Potential bug: In updateObject for fish swim, when outside (x>=ix1), we probably shouldn't apply swim (no water) — but swim still applies; harmless (they flop). Could disable swim when not in water. I'll gate swim by env.submersion>0 (in water). Outside submersion 0 => no swim. Good.

Also plants: skip physics, just draw with bend based on current at their base x. Compute current magnitude at (px, waterLevelY+something). I'll compute a bend factor = clamp(fluid at base). Use fluidVelocityAt maybe. I'll just approximate using jet & distance.

Let me write a function currentAt(x,y) returning speed for plants.

Alright. Writing now.

Let me also ensure we draw objects that are "outside" after puddle so they appear on floor in room. I'll just draw all objects in the objects pass after water overlay; outside ones drawn over room correctly (they're at x>510). Since water overlay clipped to interior, outside not tinted. Good. But the tank glass front (right panel gone) — fine.

Order final:
- clear bg
- draw room (back wall, floor)
- draw tank glass back panels (left, top, bottom) translucent + reflections, and right panel if intact (with crack)
- draw water fill (clipped interior, below surface)
- draw submerged scene: plants, rocks, fish, toy (all, including those possibly outside? those outside not in interior but we still draw them here; they'd be tinted only if overlay covers—but they're outside so overlay clip won't cover them, so they'd appear without tint even though drawn before overlay—fine)
- draw water overlay (translucent, clipped interior) to tint interior objects
- draw surface line & ripples
- draw jet particles
- draw puddle rectangle + particles
- draw shards (glass)
- draw HUD / instructions

Wait objects outside drawn in submerged pass but before overlay; overlay clip interior won't tint them. But they'd be drawn before jet/puddle so a fish that landed on floor (outside) would be behind puddle rectangle (drawn later). That might cover fish. Puddle rectangle is translucent; fish behind slightly visible. Could be okay but better draw outside objects after puddle. Let me split: draw interior objects (x<ix1) in submerged pass; draw outside objects (x>=ix1) after puddle. I'll just, for each object, decide. Simpler: draw all objects after puddle (so on top). Then interior tint lost. To keep tint, I'll draw interior objects in submerged pass (before overlay) and outside objects in a separate pass after puddle. I'll iterate objects twice with a filter. Fine.

Let me implement drawObjectsInside (clip not needed; just those with x<ix1 and not yet exited) and drawObjectsOutside.

Actually a fish in interior but above water (submersion 0) still inside tank; draw in inside pass (no tint needed since overlay covers interior regardless of submersion—overlay tints whole interior region including above water? overlay clipped to interior full height, so above-water interior also tinted slightly; that's like glass tint, fine).

OK let me just do: for objects with x <= ix1+0.5 draw in inside pass (before overlay), else outside pass (after puddle). Good enough.

Now writing the code. Let me produce it.

Given complexity, I'll write and then maybe open to sanity check via node? Can't run browser. I'll just review logic.

Let me write the file now.

I'll keep numbers as decided.

Let me write drag coefficients:
cdW (water drag per (speed)): choose so terminal velocities reasonable. For rock sinking: weight accel = (rho_w - rho)/rho * g = (1-2.6)/2.6*900 = -0.615*900=-553 (down). drag accel = -cdW*sp*vrel. terminal when cdW*sp^2 = 553 => sp=sqrt(553/cdW). want terminal ~ 400 => cdW=553/160000=0.0035. Let me set cdW=0.004. For fish with swim fine. For toy floating, buoyancy small, drag keeps it calm.
cdA (air drag) much smaller: 0.0008.

But drag formula a = -drag*sp*vrel where sp=|vrel|. Units: drag*sp has 1/s? drag ~0.004, sp~400 => 1.6 /s * vrel => strong. terminal as computed. Good.

For fish max speed clamp 260. rocks clamp 500. toy 300.

SwimK: 3.5.

Let me also add buoyancy for fish density 1.0 => net 0 (neutral), good they need swim to stay up; but neutral means they keep depth, fine. They might slowly drift; wander handles.

Actually neutral buoyancy with no vertical swim => they keep current vy. Fine.

Let me set fish density 1.0, rocks 2.6, toy 0.4.

Let me write.

For the jet spawn we add particles; also reduce water level. Let me ensure waterLevelY only increases (lowers) never decreases.

Also when state burst and waterLevelY<crackY and h>0 spawn.

Let me code spawnWater(dt):
 if(state!=='burst') return
 let h = crackY - waterLevelY
 if(h<=0) return
 let jet = Math.sqrt(2*g*h)
 let dV = aperture * jet * dt
 // update water level
 waterLevelY += dV / interiorWidth
 spilledVol += dV
 // spawn particles
 let n = Math.floor(0.02 * aperture * jet * dt)  // could be fractional; accumulate
 spawnAccum += 0.02*aperture*jet*dt
 while(spawnAccum>=1){ spawnAccum--; spawnParticle(jet); }
 // also clamp waterLevelY
 if(waterLevelY>iy1){waterLevelY=iy1}

spawnParticle(jet): x=ix1+rand*4, y=crackY+(rand-0.5)*aperture*0.8, vx=jet*(0.8+0.4*rand), vy=(rand-0.5)*60 - 20, state 'jet', r=2+rand*1.5.

Update water particles:
 for p: if jet: p.vy+=g*dt; p.x+=p.vx*dt; p.y+=p.vy*dt; if(p.y>=floorY){p.y=floorY; p.state='puddle'; p.vy=0; p.vx*=0.5;} Also if p.x>room.right-p.r clamp.
   if puddle: p.x+=p.vx*dt; p.vx*=Math.pow(puddleFric, dt*60)? use p.vx -= p.vx*2*dt; if(|vx|<2)vx=0; collide: if p.x<puddleMin clamp to puddleMin (520) and vx=0; if p.x>room.right-p.r clamp and vx=0; also pile: small vy? keep at floor. Could add slight upward to simulate splash but skip.

puddleMin=520. puddleMax tracked separately for rectangle.

Let me also have puddle particles spread; their vx initial from jet horizontal at landing (the horizontal component preserved, with friction). Good, they'll spread.

Now shards spawn on burst:
 for i in 0..N: along y from iy0 to iy1, x in [510,520]. create triangle verts random small (size 6-14). vx = 60+jet*0.5*rand + rand*80 (outward), vy = -100*rand - 50 (slightly up then gravity) + (rand-0.5)*100, av=(rand-0.5)*20. Actually lower shards are in water => water resistance slows. We'll compute in update.

Shard update:
 inWater = (x>ix0&&x<ix1&&y>waterLevelY&&y<iy1)
 drag = inWater? 2.5 : 0.4
 vx -= vx*drag*dt; vy -= vy*drag*dt
 vy += g*dt
 x+=vx*dt; y+=vy*dt; ang+=av*dt; av-=av*0.5*dt
 collisions: if y+size>floorY {y=floorY-size; vy*=-0.4; vx*=0.6; av*=0.6} ; if x-size<room.left{x=room.left+size; vx*=-0.4} ; if x+size>room.right{x=room.right-size; vx*=-0.4}; if y-size<iy0? not needed.

size ~ max vert extent.

Good.

Now let me also make the right panel crack drawing: a jagged polyline from top of panel to bottom passing through crackY with zigzag, plus small branches. I'll precompute crack path when crackY changes (regenerate). Provide function buildCrack() creating points.

Let me build crack as vertical jagged line near x=515 from y=iy0 to iy1, with main horizontal emphasis at crackY (a wider gap). Actually a side-panel crack is typically a line; emphasize at crackY. I'll draw a branching crack: a main vertical jagged line across panel, plus a horizontal stress at crackY, plus small offshoots. Good enough visually.

Let me just draw a jagged vertical crack line across the panel and a thicker highlighted segment at crackY with "stress" lines. Provide visual that user can see crack and drag it.

Implementation: crackPoints = generate once for panel; but it should move with crackY (the weak point). Let me make crack a function of crackY: draw vertical jagged line from iy0 to iy1 at x~515 with random offsets; highlight region around crackY with a bigger opening (two diverging lines) to indicate the failure point, and draw small arrows/handle.

Keep moderate.

Now HUD: show state, water depth (h), drained %, instructions.

Let me write everything now. This is large but let me produce.

I'll write the file via the write tool.

Let me carefully craft the script.

Let me define interiorWidth = ix1-ix0 = 370.

Let me finalize constants:
W=1100,H=700
room={left:20,right:1080,floorY:620}
g=900
tank={left:130,right:520,top:110,bottom:620,wall:10}
ix0=140, ix1=510, iy0=120, iy1=620
interiorWidth=370
waterTopY=150
crackY=360 (mutable)
aperture=30
rhoWater=1.0

Let me write init objects.

Fish: for i in 7: {type:'fish', x:rand(ix0+40,ix1-40), y:rand(waterTopY+40,iy1-80), vx:0,vy:0, size:14, density:1.0, cdW:0.004, cdA:0.0008, max:260, swimK:3.5, wt:0, wanderX:0,wanderY:0, hue: rand hue for color, tail phase}.
Rocks: 5: {type:'rock', x:rand(ix0+30,ix1-30), y:iy1-size, vx:0,vy:0, size:rand(12,18), density:2.6, cdW:0.004, cdA:0.0008, max:500, shade}. y rest on floor: iy1-size.
Toy: 1: {type:'toy', x:rand(ix0+60,ix1-60), y:waterTopY-16, vx:0,vy:0, size:18, density:0.4, cdW:0.003, cdA:0.0006, max:300, kind:'duck'}.
Plants: 4: {type:'plant', x:rand(ix0+30,ix1-30), base:iy1, height:rand(120,200), segs:..., phase}. anchored.

Let me code plant draw with bend using current at base.

Now let me write final code. I'll include everything.

Let me also make sure to not break when waterLevelY between; objects above water inside tank fall; fine.

Let me write the HTML file.

I think it's ready to write. Let me produce it.

I'll write carefully with consistent variable names.

Let me also add requestAnimationFrame and dt clamp.

One concern: performance of clipping each frame with many ops—fine.

Let me write now.

For drawFish orientation angle = atan2(vy,vx). Body length = size*2.2, height=size*1.1. Tail at back.

Let me write.

Also need to draw water overlay tint color rgba(40,130,200,0.22).

Let me also draw subtle bubbles? skip.

Let me write the file.

I'll include a title and instructions overlay via HTML div.

Let me produce the code.

After writing, I'll do a quick read to verify no obvious syntax errors, maybe run node -c? Node can check JS syntax if I extract, but it's embedded. I could run a quick check by copying script to a .js and node --check. Let me after writing, extract script and node --check. Actually simpler: I'll write a separate temp check. But the script uses browser globals; node --check only checks syntax, not runtime, so fine. Let me do that to catch syntax errors.

Let me write the file then validate syntax.

Let me write.

Let me validate the JS syntax by extracting the script and running node --check. Let me extract the script portion.

Actually simpler: I'll write a small node check that reads the file, extracts content between <script> and </script>, writes to a temp .js, and runs node --check. But node --check needs a file. Let me do it via bash with a node one-liner that uses vm or just `new Function`. Actually `new Function(code)` will throw on syntax errors without executing. Let me do that.

But the code uses an IIFE with "use strict" and browser globals only inside functions, not at top-level execution except init() and requestAnimationFrame which would run. Using new Function won't execute, just parse. Good. Let me extract and parse

Syntax is OK. Let me do a quick logic review of a few critical things.

1. The `integrateBody` for objects outside: when `o.x >= ix1`, the outside block runs. But note the interior block `inInt = o.x > ix0 && o.x < ix1`. For o.x exactly ix1, inInt false; outside block runs (o.x >= ix1 true). Good. For o.x slightly above ix1 and in the opening band while flowing, it passes through. Good.

2. Fish initially at x in [ix0+50, ix1-50], so inside. Good.

3. The water particles spawn at ix1 and travel right. Good.

4. Puddle: puddleMinX = tank.right = 520. puddleMaxX grows. Good.

5. One concern: objects that exit through the breach—when fish at opening band, inInt true, open true so not clamped, x increases past ix1. Then outside block: but also there's the final `if (o.x - o.size < room.left)` — fine.

But wait: when fish is at opening band and x just above ix1, the interior right wall check is skipped (open). Good. Then it keeps going. But also note when x is between ix1 and ix1+something, `inInt` is false, so interior floor/wall checks skipped, and outside block applies. Good.

6. Potential issue: a fish inside near right wall but NOT in opening band gets clamped to ix1 - size. Good, can't exit. Good.

7. The toy floating: density 0.4, so buoyancy strong up. Initially y=waterTopY-16 (above surface, sub=0 since above water). Wait initial toy y = waterTopY - 16 = 134, which is above surface (waterLevelY=150). So submersion: top = y-size = 134-18=116, bot=134+18=152. subPix = min(152, iy1) - max(116, waterLevelY=150) = 152-150 = 2. sub = 2/36 = 0.055. Small positive. Buoyancy pushes up strongly but surface clamp: there's no top-of-water clamp for floating; the toy will rise until sub=0 (fully above) then fall back until sub>0 — it oscillates around surface. Good, it floats at surface. Actually with strong buoyancy and drag, it settles at surface (half submerged). Good.

But will it sink through? buoyancy up net = (1-0.4)/0.4 * g * sub = 1.5*900*sub = 1350*sub upward. At sub=0.055 => ~74 up, gravity 900 down => net down 826... wait that means even at sub 0.055 net is down? Let me recompute: ay = g + (rhoW - density)/density * g * sub = g*(1 + (1-0.4)/0.4 * sub) = g*(1 + 1.5*sub). At sub=0.055: 1+0.0825=1.0825 => ay positive (down) ~ 974. So it sinks! That's wrong—toy should float.

Bug: buoyancy formula. Net vertical accel from gravity + buoyancy = g - (rhoW/rho)*g*sub? Let me reconsider. Weight = density*V*g (down). Buoyant force = rhoW*V*g*sub (up). Net down accel = (weight - buoy)/ (density*V) = (density*g - rhoW*g*sub)/density = g - (rhoW/density)*g*sub = g*(1 - (rhoW/density)*sub).

I wrote ay += ((rhoWater - o.density)/o.density) * g * env.sub, and started with ay = g. So total ay = g + (rhoW - density)/density * g * sub = g*(1 + (rhoW-density)/density * sub) = g*(1 + rhoW/density*sub - sub) = g*(1 - sub + rhoW/density*sub).

For floating toy rhoW/density = 1/0.4 = 2.5. At sub=1 (fully submerged): ay = g*(1 - 1 + 2.5*1) = 2.5g up. Good floats fully submerged? It should rise to surface. At sub small, ay still up if rhoW/density*sub > (1-sub) => 2.5*sub > 1-sub => 3.5 sub > 1 => sub > 0.285. So for sub < 0.285 net is DOWN. That means toy sinks until sub reaches 0.285 then rises. Equilibrium sub = 0.285 (partially submerged) — it floats with 28% submerged. That's correct for a 0.4 density object! (Fraction submerged = density/rhoW = 0.4.) 

I made an algebra error above. Let me recompute correctly: ay = g*(1 - sub + (rhoW/density)*sub). For density 0.4: ay = g*(1 - sub + 2.5 sub) = g*(1 + 1.5 sub). That's always positive (down)! 

Wait that contradicts. Let me recompute (rhoW - density)/density = (1-0.4)/0.4 = 0.6/0.4 = 1.5. So ay = g + 1.5 g sub = g(1+1.5 sub) > 0 down. That means buoyant term I added is DOWNWARD. Sign error!

The buoyancy should be UP (negative y). I added ay += positive. That's wrong. Buoyancy up means subtract. Let me fix: the net buoyancy acceleration is ((rhoWater - density)/density)*g*sub but with UP = negative. So I should do ay += ((rhoWater - density)/density) * g * env.sub only if that's the net... but gravity already added as +g (down). The correct net vertical accel = g*(down) + buoyancy(up). Buoyancy accel = -(rhoW/density)*g*sub (up is negative). Net = g - (rhoW/density)*g*sub = g*(1 - (rhoW/density)*sub).

My expression ay = g + ((rhoW - density)/density)*g*sub = g + g*sub*(rhoW-density)/density = g*(1 + sub*(rhoW-density)/density) = g*(1 + sub*rhoW/density - sub) = g*(1 - sub + sub*rhoW/density) = g*(1 - sub*(1 - rhoW/density)) = g*(1 - sub + sub*rhoW/density). 

For rhoW/density = 2.5, density 0.4: ay = g*(1 - sub + 2.5 sub) = g*(1 + 1.5 sub). Positive => down. So toy sinks. BUG confirmed.

The correct net: g*(1 - (rhoW/density)*sub). For density 0.4: g*(1 - 2.5 sub). At sub=1 => -1.5g (up, floats up). At sub=0 => g down. Equilibrium sub=0.4. 

So my formula should be: ay = g*(1 - (rhoWater/density)*sub). Let me rewrite buoyancy as: ay -= (rhoWater/density) * g * sub; (since gravity already +g). That gives ay = g - (rhoW/density)*g*sub = g*(1 - (rhoW/density)*sub). Correct!

So I need to change the buoyancy line from `ay += ((rhoWater - o.density)/o.density) * g * env.sub;` to `ay -= (rhoWater / o.density) * g * env.sub;`.

Let me verify with rock density 2.6: ay = g - (1/2.6)*g*sub = g*(1 - 0.385 sub). At sub=1 => 0.615 g down (sinks). Good. At sub=0 => g down. Good, sinks to bottom. 

Fish density 1.0: ay = g - (1/1)*g*sub = g*(1-sub). At sub=1 => 0 (neutral, hovers). At sub=0.5 => 0.5g down (sinks a bit, but swim/buoyancy balances). Neutral buoyancy, good—fish hover and swim. Good.

So fix needed. Let me edit.

Also check: objects above water (sub=0) get full gravity => fall, correct (airborne).

Now also the toy floating at surface: with corrected formula, at sub=0.4 net zero, floats with 40% submerged. Good. As water lowers, surface lowers, toy follows down (buoyancy keeps it at surface). When surface near crackY, toy at opening band, pushed right by current through breach. Good.

Let me also double check fish won't all sink to bottom. With neutral buoyancy (sub=1 => ay=0), but fish need to stay at a depth; gravity pulls them down only when sub<1 (i.e., near surface) — when fully submerged ay=0, so they maintain velocity (inertia) with drag. Good, they hover. With downward drag and wander they move. Fine. But note: if a fish is fully submerged and has vy=0, ay=0, stays. Good. They won't sink to bottom. Good.

But initial fish y in [waterTopY+50, iy1-90] = [200, 530], all submerged (waterLevelY=150). sub=1 => neutral. Good.

Now fix the buoyancy line.

Also, I realize there may be an issue: when fish fully submerged and water level is high, they're neutral and just hover with wander. Good. But the "swim against current" only triggers when near breach. Good.

Let me also reconsider drag magnitude with corrected buoyancy for fish neutral — drag keeps them calm. Good.

Another check: the fish exit. When a fish is pushed to opening band and flows out, once x>ix1 it's outside, sub=0, gravity pulls down, falls to floor. Good "airborne then floor collision."

Let me also verify rocks at bottom: sub=1 => ay = 0.615g down, but floor collision clamps y=iy1-size and vy bounce. So they rest on tank floor. Good. With current at bottom (if crack low), fluidAt near bottom: if crackY near bottom, the pull pushes them; inX true, y between waterLevelY and iy1. They could get horizontal velocity and move right; if at opening band exit. Good.

Now let me apply the buoyancy fix.

Also, I want to double check the `drawWaterOverlay` tints whole interior including fish that are above water (sub=0) — that's fine (glass tint).

Let me also reconsider: the "spreading puddle that collides with the room boundaries" — puddleMaxX clamps at room.right-8. Good. puddleMinX = tank.right (520) = tank base. Good collision with tank.

One more: water particles as puddle are drawn even when state burst and inside puddle region; fine.

Let me fix buoyancy now.

Now let me re-validate syntax and also do a quick sanity simulation in node by stubbing out canvas to ensure no runtime errors in the core physics (without rendering). Actually rendering uses ctx heavily; I can't easily run. But I can at least run the physics update functions in isolation by re-implementing? That's a lot. 

Better: create a headless test by mocking canvas/ctx/document and window, then require the script, and step a few frames to ensure no exceptions. The script is an IIFE that auto-runs init and requestAnimationFrame. I can mock requestAnimationFrame to call frame a few times manually, and mock ctx with no-op methods, document.getElementById returns fake elements, performance.now, etc. Let me do that to catch runtime errors in physics + render calls.

Let me write a node harness.

The frames stepped without error in intact state. But I need to test the burst path too. The burst is triggered by a button click, which registers a handler on elStub via addEventListener (noop), so not captured. I need to capture the burst handler. Let me make elStub.addEventListener capture handlers, and capture the button by id. Then simulate a click to call burst, and step frames to test the drain/spawn/puddle/shards/objects-exiting paths.

Let me redo the harness: elStub.addEventListener stores handlers; getElementById returns distinct objects for 'burst' and 'reset' and 'c','hud'. Provide addEventListener that records by event type. Then after load, find burst element and call its 'click' handler.

Let me rewrite harness

All paths run without exceptions. The burst path exercised spawning, draining, puddle, shards, objects, etc., for 12 seconds, plus reset.

Let me also verify some behavior numerically by instrumenting: I want to confirm that the water level actually lowers, jet speed is higher for a lower crack, and that objects exit. But these are internal closure variables not exposed. I could add a quick debug by reading them — but they're not exposed. I'm fairly confident given the logic. 

However, let me double-check one subtle thing: when crack is placed LOW (crackY=560), depth h = 560 - 150 = 410, jet = sqrt(2*900*410)= sqrt(738000)=859 px/s. Good strong. Higher crack (e.g., 200): h=50, jet=300. Good, lower => stronger. Correct.

Also after enough draining waterLevelY rises to crackY and flow stops. With low crack 560, surface starts at 150, drains until waterLevelY reaches 560. Time: dV = aperture*jet*dt, drop rate = aperture*jet/interiorW = 30*859/370 = 69.6 px/s initially, decreasing as jet decreases. To drop 410px, roughly integral; plenty within 12s? Let's see, as it drains h shrinks, jet shrinks, drop slows. At h=410 drop 69px/s; at h=200 jet=600 drop 48; h=100 jet=424 drop 34; h=40 jet=268 drop 21. Approx time to reach 560: integrate roughly. Over first 2s drops ~ 410-... Let me approximate cumulative. Hard but 12s likely enough to drain most. The test ran 720 frames=11.5s and no error. Good.

Now, one more consideration: the puddle rectangle height = spilledVol/max(40,len). spilledVol accumulates dV = aperture*jet*dt. Over full drain, total vol = interiorW*(iy1 - waterTopY) approx? Actually dV each step = (actual water drop)*interiorW, so spilledVol ≈ interiorW*(waterTopY - ... ) no: spilledVol += dV where dV = aperture*jet*dt = (waterLevelY increase)*interiorW. So spilledVol ≈ interiorW * (waterLevelY - waterTopY). At full drain waterLevelY-150 = 470, interiorW=370 => spilledVol ≈ 173900. puddleMaxX = min(1072, 520 + sqrt(173900)*1.6) = 520 + 417*1.6=520+667=1187 -> clamps to 1072 (collision with right wall). len = 552. height = 173900/552 = 315 capped to 70. So puddle floods to 70 high and hits the right wall. Good, demonstrates both boundary collisions (tank base left, room wall right). 

Everything looks consistent. Let me also make sure the HUD updates and that the burst button disables. That's fine.

Let me clean up temp harness files (they're in /tmp, not in /tmp/ws, so fine). The index.html is in /tmp/ws as required.

Let me do a final read of the key physics section to be sure the edit is in place and nothing else broken.

Actually, I'm fairly confident. Let me just confirm the buoyancy edit is present.