This is a complex simulation request. Let me build a comprehensive single-file HTML aquarium simulation with canvas and JavaScript. Let me think through the physics and rendering carefully.

Key features:
1. Aquarium with glass panels, water inside
2. User drags a crack vertically on the side panel
3. On trigger, crack bursts open
4. Water flows out based on depth pressure (lower crack = stronger jet)
5. Curved jet affected by gravity
6. Spreading puddle with boundary collisions
7. Fish, rocks, plants, floating toy with different physics (density, buoyancy, drag, current)
8. Objects transition underwater -> airborne -> floor
9. Fish swim against current before being swept out
10. Glass fragments with angular velocity, collisions, water resistance
11. Waterline lowers continuously

Let me design this carefully.

I'll use a 2D canvas. Side view of aquarium. The aquarium is a rectangle. The crack is on the right side panel. User drags crack position vertically. Then clicks "burst" button.

Physics approach:
- Water as particles? Could be heavy. Let me use a combination: a waterline (surface) that lowers, plus particle-based jet and puddle.
- Water volume decreases as it drains. Flow rate proportional to sqrt(depth above hole) (Torricelli's law). Lower hole = more depth above = stronger jet, and also the jet velocity v = sqrt(2 g h).
- Jet particles spawn at the breach with horizontal velocity based on pressure, then gravity curves them down.
- Puddle: particles that hit the floor spread, collide with room boundaries (walls).

Objects:
- Fish: buoyancy slightly positive, swim (apply force toward a target, against current). When current exceeds swim strength, swept out. Once airborne, gravity. Once on floor, flop.
- Rocks: dense, sink, stay at bottom, may get pushed by current near breach. Mostly stay.
- Plants: anchored to bottom, sway with current. If uprooted, drift.
- Floating toy: low density, floats on surface, bobs. As waterline lowers, toy lowers. If near breach, gets sucked out.

Glass fragments: when burst, create triangular shards with angular velocity, fly out with initial velocity, affected by gravity and air drag, collide with floor and each other, water resistance if in water.

Let me think about the waterline lowering. I'll track water volume. The aquarium has a width W and the water height H. Volume = W*H (per unit depth). Flow rate Q = C * A * sqrt(2 g (H - h_hole)) where h_hole is height of hole above bottom. As water drains, H decreases, so depth above hole decreases, flow decreases. When H <= h_hole, flow stops (hole above waterline).

Actually lower crack = the hole is lower, so depth above hole (H - h_hole) is larger = stronger jet. Good, matches requirement.

Let me also model the jet: particles emitted from breach with velocity v_x = sqrt(2 g (H - h_hole)), v_y = 0 initially. Gravity pulls down. They land on floor forming puddle.

Puddle: I'll track puddle water as particles on the floor that spread with some velocity, colliding with room walls. Or simpler: a puddle height map along the floor. Let me do a 1D heightmap for the puddle on the floor — cells along x. Incoming water adds to nearest cell, then spreads to neighbors. Collides with room boundaries (left wall, right wall) by stopping spread.

That's cleaner. Let me do puddle as a heightmap array across floor width.

For visual waterline in tank: draw rectangle from floor to waterline height, blue translucent.

Let me structure:

Canvas size: 1000 x 650. Room: full canvas. Aquarium positioned within, say left side, with some floor space to the right for puddle to spread.

Aquarium: left wall at x=80, right wall at x=520, floor at y=520 (aquarium bottom). Top at y=80. So aquarium interior width 440, height 440.

Room floor at y=600 (below aquarium, the aquarium sits on a stand? Let me put aquarium floor at the room floor). Actually let me make aquarium sit on the room floor. Room floor at y=600. Aquarium floor at y=600, aquarium top at y=120. Walls x=100 and x=540.

Hmm, but water jet exits right side at x=540 and falls to floor y=600, then puddle spreads along floor from x=540 to the right wall and also can flow left under the aquarium? Let me keep it simple: puddle spreads along room floor to the right (and a bit left). Room right wall at x=980.

Actually water could also spread left under/around. Let me just have puddle heightmap from x=0 to x=1000. Aquarium occupies x=100..540. Water exits at right side x=540 at the crack height. Falls to floor, lands around that x. Then spreads both directions along floor, but the aquarium base blocks... hmm the aquarium floor is at y=600 = room floor, so water on floor would be outside aquarium walls. The aquarium walls go down to floor. So puddle to the right of x=540 and to the left of x=100. In between (under aquarium) there's the aquarium glass. Actually the aquarium sits on the floor, water can't go under it. So puddle on the right side (x>540) and left side (x<100) separately. Most goes right.

Let me just make the room floor from x=0 to x=1000, and the aquarium is a box sitting on it. Puddle accumulates to the right primarily. Collides with right wall at x=980.

Let me make the heightmap cover the whole floor width but the aquarium base region (x 100..540) is blocked (water can't accumulate there, it's under the tank). Actually water falling right next to the tank will hit floor at x≈540 and spread right. Some might splash left but blocked by tank wall. Fine.

Let me simplify: puddle heightmap from x=540 to x=980 (to the right of the tank). 440px wide. Cells of 4px = 110 cells.

Glass crack: on the right wall (x=540). User drags a marker up/down to set crack y position. The crack is a small segment. On burst, that segment breaks out as glass fragments, creating an opening. Water jets out.

Opening size: fixed, say 40px tall. The crack center y is draggable. Lower = stronger.

Let me now think about rendering and the loop.

State:
- waterLevel (y coordinate of water surface inside tank), starts near top (y=140).
- tank geometry.
- crackY: center of crack, draggable.
- burst: bool.
- opening: {x, y, height} after burst.
- particles: water jet particles.
- puddle: heightmap array + velocities.
- fragments: glass shards.
- objects: fish, rocks, plants, toy.
- drained volume tracking.

Drainage: compute depth above hole = (floorY - crackY is hole height above floor)... let me define waterDepth = floorY - waterLevel (water column height). Hole height above floor = floorY - crackY. Depth above hole = waterDepth - (floorY - crackY) = crackY - waterLevel... wait.

floorY = 600. waterLevel = 140 (surface). waterDepth = 600-140 = 460. crackY = 400 (crack is at y=400, height above floor = 200). Depth of water above crack = waterLevel... no. The water pressure at the crack depends on how much water is above the crack = crackY - waterLevel? No: water above the crack means from crack up to surface. Crack at y=400, surface at y=140. Water above crack height = 400-140 = 260. Lower crack (crackY larger, e.g. 500) => water above = 500-140=360, more pressure. Yes! Lower crack = more depth above = stronger. 

So head h = crackY - waterLevel (positive when crack below surface). Jet speed v = sqrt(2 g h). Flow rate Q ∝ v * openingArea. As water drains, waterLevel increases (goes down, y increases), so h decreases, flow decreases. When waterLevel >= crackY (surface below crack), h<=0, no flow.

Volume: tankWidth * (floorY - waterLevel). dVolume/dt = -Q. So d(waterLevel)/dt = Q / tankWidth. waterLevel rises (increases y) as drains.

Good.

Objects inside tank are affected by current. Current near breach points outward (to the right, out the hole). Current magnitude scales with flow. Objects near the breach get pushed toward and out. Far objects less.

Let me model current as a velocity field: primarily near the breach, horizontal rightward, decreasing with distance. Also a general inward flow toward breach (draining pulls water from the bulk toward the hole).

Simplify: each object in water experiences current = strength * direction(from object toward breach) / distance factor, plus the jet rightward at the breach.

For fish: they swim against current. Fish have a swim velocity they can achieve (e.g., 60 px/s). If current > swim, they get swept. They attempt to swim left (away from breach) / toward center. Add some random.

Let me just implement: fish apply thrust opposite to local current direction, capped at swimSpeed. Net velocity = current + swimthrust... actually forces. Let me use simple velocity integration with drag.

Object physics (in water):
- buoyancy: a_y = -buoyancyAccel * (densityFactor). If object less dense than water, positive buoyancy (up). Fish ~ neutral (slightly buoyant, they adjust). Rocks dense -> sink. Toy very buoyant -> float to surface.
- gravity always applies.
- drag: velocity *= (1 - drag*dt) in water (high drag).
- current: velocity += currentField * dt (advection).

Net: in water, effective gravity = (1 - waterDensity/objectDensity)*g. For floating objects they rise until at surface then float.

Object physics (in air, once exits tank):
- gravity full g.
- air drag small.
- Once hits floor: bounce with restitution, then settle. Fish flop a bit.

Transitions: object is "in water" if inside tank and below waterline and y < floorY and between walls. Once it moves outside tank x range (x> rightWall - small, near breach) and is at breach height, it's "airborne". Actually once x > rightWall, it's in air (exited). Then falls.

But objects need to actually travel out through the breach. The current pushes them right; when they reach the right wall at the breach y, they pass through (the opening). Above/below opening, the glass blocks. So objects hitting the right wall away from opening get stopped (collide with glass). Near opening, they exit.

Let me implement: right wall at x=540. If object x > 540 and within opening y-range -> pass through, become airborne. If object hits x=540 outside opening -> collide (bounce/stop). After burst, opening exists.

Also the water itself: water only exits through opening. Objects ride the water jet out.

Let me handle the jet: water particles spawn at opening with velocity (vx = jetSpeed, vy small). They follow projectile motion. When they hit floor (y>=floorY), convert to puddle (add to heightmap at their x, remove particle). Puddle spreads.

Puddle heightmap: array puddleH[i] for cells. Each frame, water from landed particles adds to cells. Then diffusion: each cell shares with neighbors. Boundaries: clamp at walls (no flow past x=540 left side of puddle region and x=980 right wall). Actually left boundary is the tank wall at 540, right boundary room wall at 980.

Let me also let puddle have a velocity field for spreading: simpler diffusion each step: newH[i] = H[i] + d*(H[i-1]-2H[i]+H[i+1]). This spreads. Boundaries: H[-1] treated as wall (no flux) or 0? For wall, reflect: H[left-1] = H[left] (Neumann). That keeps water from flowing into wall, building up. Good - "collides with room boundaries".

Now objects in puddle: objects that have fallen to floor sit in puddle. Floating toy if on floor in puddle... buoyancy in puddle: if puddle depth > object, object floats. Eh, let me handle: objects on floor check puddle height at their x; if submerged, apply buoyancy to lift them (toy floats up in puddle, rocks stay). 

This is getting complex but let me just implement reasonably.

Let me think about what's visually essential and make it look good:
- Nice glass aquarium with translucent water, gradient.
- Sand/gravel at bottom.
- Plants swaying.
- Fish swimming (simple shapes, tails).
- Rocks at bottom.
- Floating toy (rubber duck-ish circle) on surface.
- Crack marker draggable, shows a crack line.
- Burst button.
- On burst: glass shards fly, water jet, splashing, puddle grows, fish swept out flailing, etc.

Let me code it.

I'll write the full file. Let me be thorough but manage complexity.

Let me define constants and write classes.

Let me write the code now.

Canvas: 1000x650.
Room: floor at y=600, walls at x=10 and x=990.
Aquarium: sits on floor. Left wall x=120, right wall x=560, bottom y=600, top y=110. Glass thickness ~8px. Interior: water from y=140 (surface) to y=596 (above gravel). Gravel at bottom y=580..596.

Crack on right wall. crackY draggable between y=160 (high) and y=560 (low). Opening height 36px after burst.

g = 980 (px/s^2) scaled. Let me use g=1200 for visual.

Jet speed: v = k*sqrt(2*g*head). k ~ 1. Let me tune: head up to ~450px. sqrt(2*1200*450)=sqrt(1,080,000)=1038 px/s. That's fast. Maybe scale down: v = 0.6*sqrt(2*g*head). For head 450 -> 620 px/s. Reasonable, arcs nicely.

Flow rate: Q = v * openingHeight (per unit depth into screen). Volume lost = Q*dt. waterLevel rise = Q*dt/tankWidth.

Let me also cap particle emission rate.

Let me code.

For fish swimming against current: compute local current at fish position. Fish tries to swim opposite. If |current| < swimSpeed, fish holds position (velocity ~ opposite, net ~0, maybe drifts slowly). If |current| > swimSpeed, fish swept = current - swimSpeed*dir.

Implement fish velocity: 
currentVec = currentAt(fish).
swimDir = -normalize(currentVec) (against current), if current small, swim randomly/wander.
fish.vel += (currentVec) [advection] ; fish applies swim: fish.vel += swimDir*swimAccel*dt with max swimSpeed; drag.
Simplify: fish.vel = currentVec*(1-drag) + swimVel where swimVel capped. Hmm.

Let me do forces:
fish.acc = buoyancy(0, neutral) + currentForce + swimThrust + drag.
currentForce = (currentVec - fish.vel) * coupling (water drags fish toward current velocity).
swimThrust = swimDir * swimPower, capped so fish can counter current up to swimSpeed.

So net steady state in current c (horizontal): fish moves at c if |c|<swimSpeed (fish cancels by swimming against), or moves at c - sign(c)*swimSpeed if |c|>swimSpeed.

Set coupling strong so fish quickly matches. swimSpeed ~ 80 px/s. Near breach current ~ 200+, so fish swept. Far from breach current small, fish swims normally.

Good.

Plants: anchored at base. Sway: angle influenced by current and a sine. Each plant segment. If current very strong near breach and plant is near breach, uproot (base detaches) and plant drifts with current/out. Simplify: plants far from breach just sway; the plant nearest breach gets uprooted and swept out.

Rocks: dense, sit on gravel. Current might nudge but high friction; mostly stay. A small rock near breach could get pushed out if current strong — let me allow small rocks to be swept.

Toy: floats at surface (waterLevel). Bobs. As water drains, follows surface down. If near breach and surface drops below... actually toy floats on surface; if breach is above surface no exit. If breach below surface, water flows out but toy is at surface (above breach) so toy stays until waterline reaches breach level, then toy near breach might get sucked out. Let me have toy drift toward breach slowly due to surface current, and if it reaches breach it exits.

OK let me just write it. I'll make it visually rich.

Let me write the HTML file.

I'll include:
- Canvas
- UI: instructions, burst button (also trigger by clicking), reset.
- Drag crack: pointer events on canvas.

Let me write.

For dragging crack: before burst, user drags on the right wall area to set crackY. Show crack as a jagged line. Show "Burst" button. After burst, simulation runs.

Let me add a hint text.

Let me code carefully.

I'll write the file now.

Let me define drawing for water with the lowering line: draw water rect from waterLevel to floor (inside tank), with translucent blue gradient. Surface line highlighted.

Also as water drains, draw the "dry" upper part of tank lighter.

Particles: blue circles with alpha, smaller, with motion blur.

Puddle: draw filled blue shape following heightmap (slightly translucent), with surface line.

Glass fragments: polygons (triangles/quads) with rotation, semi-transparent cyan/white, with highlight.

Fish: ellipse body + tail triangle, colored. When airborne, rotate/flail. Eye.

Let me implement fish orientation based on velocity.

Plants: wavy stem (several segments) with leaves, green.

Rocks: gray polygons.

Toy: rubber duck - yellow ellipse + head + orange beak. Simple. Or a boat. Let me do a duck.

Alright, writing now. This will be long.

Let me handle the object exit detection:
An object is in-tank if x in [leftWall+glass, rightWall-glass] and y in [waterRegion]. Once x >= rightWall - glass and within opening y-range, allow exit: object.vel.x gets boosted by jet, becomes airborne (state air). Once x>rightWall, it's outside, falls.

If object hits right wall glass (not opening), bounce back (vel.x negated, damping).

Let me set opening y-range: [crackY - openH/2, crackY + openH/2].

Objects can only exit after burst.

Let me track object.state: 'water', 'air', 'floor'.

Transitions:
- water->air: when x > rightWall (passed opening) OR y above tank top (won't happen). Also if object pushed out bottom? no.
- Actually object exits when it crosses the right wall plane within opening. Let me detect: if state water and x+radius >= rightWallInner and openingActive and |y-crackY|<openH/2: set state air, and boost vel.x to at least jet speed.
- water-> stays water while in tank.
- air->floor: when y >= floorY - radius (puddle surface or floor): state floor, bounce.
- floor: settle, maybe bob in puddle.

For objects still in water as waterline drops below them (water drained past them): they become air? No—an object resting on gravel stays on gravel even if water drains below it (it's on floor). A fish in water when water drains below it: fish is now in air -> flops to floor. So: if state water and y < waterLevel (above surface) and object is not resting on floor: it's now in air (stranded). Set state air, it falls. Fish flops.

Actually if waterLevel (surface y) > fish.y (fish is above surface), fish is out of water. Set state air (or floor if on gravel).

Let me implement: in water state, require waterLevel < y < floorY to be submerged. If y <= waterLevel (above surface), object is in air -> but it might be a floating toy at surface (toy stays at surface). For toy: keep at surface (y = waterLevel - toyHeight/2). For fish: if stranded above water, become air and fall.

Let me handle toy specially: toy always tries to float at surface. If water present (waterLevel<floorY), toy.y -> waterLevel - toyRadius. If water gone, toy rests on floor/grav el. Toy exits via breach if pushed to breach.

OK, enough planning. Let me write.

I'll keep tuning constants reasonable.

Let me write the code in one go.

One concern: performance with many particles. Limit particles to ~600. Emit based on flow.

Let me write.

For current field inside tank: 
At a point (x,y) in water, current magnitude depends on distance to breach and overall drain rate.
Let breach point B = (rightWallInner, crackY).
currentDir = normalize(B - pos). 
strength = drainStrength * (1/(1+dist/100)) ... plus stronger near breach.
drainStrength scales with flow rate (so when flowing, current exists; when stops, current ~0).
Also vertical component near surface toward breach (surface draws water). Let me keep mostly horizontal toward breach with slight downward for draining.

Simplify: current = drainK * flowFactor * dir, where dir points from object to breach, magnitude ~ flowFactor/(dist+50). flowFactor ∝ current jet speed. Add a cap.

Let me make current mainly affect objects within some range; far objects barely move (just gentle drift). Good.

Also the water near the breach moves fastest. The "plug flow" toward the hole.

Let me set: 
flowFactor = clamp(v_jet / 600, 0, 1) * (waterLevel < crackY ? active : 0).
currentAt(pos): d = dist(pos, breach); mag = flowFactor * 220 / (1 + d/60); vec = mag * normalize(breach-pos). Cap mag at ~300.

This gives strong current near breach, weak far away. Fish near breach swept, far fish swim fine.

Alright, writing the file.

I'll also make the water jet spawn particles at the opening with vel.x = v_jet * (0.9..1.1), vel.y = small random. And the jet direction slightly downward? At the hole, water exits horizontally perpendicular to wall (rightward). Gravity curves down. Good.

Also spawn mist/spray small particles.

Let me write now. Final code.

I need to also ensure the waterline lowers continuously — yes via volume integration.

Let me also visually show water level lowering: recompute each frame.

For the "visible waterline that lowers continuously rather than disappearing all at once" — handled by continuous drainage.

Let me write the file.

I'll add requestAnimationFrame loop with dt clamp.

Let me write helper functions for drawing.

Code:

```
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Aquarium Burst</title>
<style>
  body { margin:0; background:#1a1d24; font-family:system-ui,sans-serif; color:#ddd; display:flex; flex-direction:column; align-items:center; }
  #wrap { margin-top:10px; }
  canvas { display:block; background:linear-gradient(#2b2f3a,#3a3f4d); border-radius:8px; box-shadow:0 10px 40px #000; cursor:ns-resize; }
  #ui { margin:8px; display:flex; gap:10px; align-items:center; }
  button { background:#3b82f6; color:#fff; border:none; padding:8px 16px; border-radius:6px; cursor:pointer; font-weight:600; }
  button:hover{ background:#2f6fe0; }
  .hint { font-size:13px; color:#9aa; max-width:900px; text-align:center; }
</style>
</head>
<body>
<div id="wrap">
  <canvas id="c" width="1000" height="650"></canvas>
  <div id="ui">
    <button id="burst">Burst!</button>
    <button id="reset">Reset</button>
    <span class="hint" id="hint">Drag the crack up & down on the right glass panel, then press Burst. Lower crack = stronger jet.</span>
  </div>
</div>
<script>
... 
</script>
</body>
</html>
```

Now the JS. Let me write it.

I'll keep it organized.

Let me define everything.

Let me write the JS now carefully and completely.

I think I have enough plan. Writing.

For glass fragments: on burst, create ~14 shards from the opening region. Each shard: polygon vertices relative to center, pos at opening, vel = (random rightward + jet influence, random up/down), angularVel random, color glassy. They fly out, gravity, air drag, rotation, collide with floor (bounce), and if they land in puddle/water get water resistance (slow). Some shards may fall inside tank too (inward). Let me have some fly out right, some inward-left into water.

Shard physics: in air: gravity, drag low. On floor: bounce with restitution 0.3, friction, angular damping. If in puddle (puddle height > shard.y area): extra drag (water resistance) and buoyancy-ish slow.

Let me finalize and write. I'll write the whole thing now.

Let me write the puddle heightmap. Range x from tankRight(560) to roomRight(990). Width 430. cell size 5px => 86 cells. Also allow puddle to extend left of tank? Water could splash left of tank too but unlikely. Keep right side. Also maybe left side small. I'll just do right side region [560,990].

But the jet exits at x=560 going right, lands maybe at x=600-900 depending on speed. Lands on floor y=600. Add to heightmap at landing x. Good. Puddle builds to the right and left within [560,990], colliding with tank wall (left, x=560) and room wall (right, x=990).

Heightmap spread: diffusion each frame with clamped boundaries (Neumann at both ends -> water piles at walls = "collides with room boundaries"). Good.

Now objects falling to floor within puddle region: check puddle height at their x; if object bottom below puddle surface, buoyancy. Toy floats on puddle. Fish on floor in puddle might float up? Fish slightly buoyant -> could float in puddle. Let me let stranded fish lie on floor (they're "flopping"). Keep simple: on floor, objects rest; toy floats if puddle deep enough.

Let me write now for real.

I'll write the code. Given length, I'll be careful.

Let me define object types with properties.

Fish:
{ type:'fish', x,y,vx,vy, angle, size, color, state, flap (tail anim), swimTarget, panic }
Rocks: { type:'rock', x,y,vx,vy, angle, angVel, verts, size, density, state }
Plants: { type:'plant', baseX, baseY, height, segments, sway, uprooted, x,y,vx,vy, state }
Toy: { type:'toy', x,y,vx,vy, size, state, bob }

Let me init a few: 4 fish, 3 rocks, 3 plants, 1 toy.

Now code. Writing the file via write tool.

Let me make sure to implement pointer drag for crack: on canvas, if not burst and pointer x near right wall (x in [540,580]) and within tank height, set crackY = pointer y clamped. Show crack.

Also allow drag anywhere to set crackY (vertical) for ease: if pointer within right wall column. I'll detect pointer near right wall.

Let me write.

Let me also draw the crack as a jagged lightning line on the glass that the user drags. Before burst, water still inside (no leak) — or maybe a tiny drip? Keep sealed until burst. Actually "develops a visible crack and then bursts" — crack visible first (drag to position), then burst. Fine.

Now writing.

Let me handle dt: use performance.now, dt in seconds, clamp to 0.032.

I'll write now. Final.

Let me make jet speed scale and water physics constants:

G = 1400 (px/s^2) gravity for visuals (a bit strong for snappy arcs).
Actually real g 9.8 m/s; if 1px=1cm, g=980px/s^2. Let me use G=900.

head = crackY - waterLevel (px). v_jet = 0.7*sqrt(2*G*max(head,0)). For head=400: sqrt(2*900*400)=sqrt(720000)=848*0.7=594 px/s. Good.
flowArea = openH (per unit). Q = v_jet * openH (px^2/s per unit depth). Volume = tankInnerW * waterDepth. dVol = Q*dt. d(waterLevel) = dVol/tankInnerW = v_jet*openH*dt/tankInnerW. tankInnerW=420. openH=36. So dLevel per sec = v_jet*36/420 = v_jet*0.0857. For v=600 -> 51 px/s drain. Tank 460 tall -> drains in ~9s. Reasonable. As head drops, slows. Good.

Emit particles: n = floor(Q * dt * particleDensity). particleDensity ~ 0.02. For Q=600*36=21600, dt=0.016 => per frame n=21600*0.016*0.02=6.9 -> ~7 particles/frame. Over 9s ~ 3780 particles total but they get removed on landing. Live particles maybe ~200-400. OK. Let me cap live particles at 700.

Let me increase particleDensity to 0.04 for richer jet -> ~14/frame.

Alright. Writing the file.

I'll now produce the final HTML.

Let me also add sound? No external. Skip.

Writing.

For fish drawing with orientation: angle from velocity (when moving) or facing swimDir. Body ellipse rotated. Tail wagging.

Let me write draw functions.

Let me write it all.

I'll write the complete file now.

Regarding current affecting fish swimming against: implement as described. Fish panic when current strong (fast tail, try to swim against). When swept to breach and out, become airborne, flail (random spin), fall, flop on floor.

Let me code fish update:
if state water:
  cur = currentAt(x,y)
  // swim against current
  curMag = |cur|
  if curMag > 5: swimDir = -cur/curMag; else swimDir = wander (change slowly)
  swimAccel = 260 (px/s^2)
  // water drag couples fish to current
  dragK = 2.2
  ax = (cur.x - vx)*dragK + swimDir.x*swimAccel
  ay = (cur.y - vy)*dragK + swimDir.y*swimAccel + buoyancy
  buoyancy: fish near neutral: small upward if below desired depth, else 0. Let me give fish slight positive buoyancy so they don't sink: ay_buoy = -G*0.04 (rises slowly) but they swim to maintain. Simplify: target depth (some y), if below target rise, if above sink. Let me just add gentle vertical wander and near-neutral buoyancy so they hover. Use ay += -G*0.02 (slight rise) + swimDir.y*accel.
  Integrate. cap speed at ~ swimSpeed+ something.
  Exit detection.
  If stranded (y < waterLevel-2 and not near floor): state=air.

if state air:
  ay=G; ax=airdrag; rotate (flail: angVel += rand). 
  if y+radius >= floorY: state floor, bounce.

if state floor:
  friction, settle, occasional flop if fish alive (small jump) for a moment. Reduce flops over time.

Let me implement angle: face direction of motion; if slow, face swimDir.

OK writing now, final.

Let me also make sure objects in water that are rocks (dense): high gravity, low buoyancy, sink to gravel, high friction so current barely moves unless strong. Small rocks might tumble.

Rock update water:
  cur = currentAt; dragK=1.5; ax=(cur.x-vx)*dragK; ay=G*0.6 (net sink, density 2.5 => effective ~0.6g) ; on gravel (y+radius>=gravelY): normal force, friction vx*=0.9, can be pushed if cur strong. Exit detection near breach (small rocks can be pushed out).

Plants: if anchored, sway angle = baseSway + currentInfluence*sin. If uprooted (triggered when current near breach very strong & plant near breach), become object with water physics (drift), can exit.

Toy: floats. target y = waterLevel - radius. vy toward. vx from surface current (reduced). If at breach & water flowing & breach below surface: gets sucked, exits. After exit airborne then floor; if in puddle floats.

Let me code toy: in water state, y -> surface, x drifts with surface current (toward breach). When x near rightWall and breach open & breach below surface: exit.

Alright. Writing now, for real, the complete file.

I'll be generous with code. Let me produce it.

Given the complexity, let me write and then maybe test by opening? Can't open browser. I'll just write carefully.

Let me write.

Let me verify the file is valid by checking it briefly.

The JS parses fine. The file is complete. Let me give a brief summary.