The user wants a large glass aquarium simulation with a crack that develops and bursts. Let me build a self-contained HTML file with all the physics simulation.

Let me plan the features:
1. A large glass aquarium with a side panel
2. User drags a crack vertically before triggering
3. Crack develops, then bursts
4. Water escapes through opening, flow strength based on water depth (Torricelli's law)
5. Curved water jet affected by gravity
6. Spreading puddle colliding with room boundaries
7. Fish, rocks, plants, floating toy with different density, buoyancy, drag, current
8. Objects transitioning underwater -> airborne -> floor collisions
9. Fish swim against current before being swept through breach
10. Glass fragments with angular velocity, collisions, water resistance
11. Visible waterline lowering continuously

Let me write this as a single HTML file with canvas-based rendering.

I'll create a comprehensive physics simulation. Let me think about the architecture:

- Canvas 2D rendering
- Water in aquarium tracked as a level (y position of waterline)
- Tank with a glass wall, side panel on right side where crack forms
- Water flow out through crack: velocity based on sqrt(2*g*h) Torricelli, and area based on crack opening size. Flow rate = area * velocity. This decreases tank water level over time.
- Water jet: particles or a stream that follows projectile motion (parabolic) from the crack
- Puddle: accumulates on floor, spreads out until hitting walls
- Fish: swim with AI, trying to swim against current when current present. Once swept to crack, go through with the water jet, transition to airborne then floor.
- Objects: fish, rocks (dense, sink), plants (buoyant-ish), floating toy (light, floats)
- Glass fragments: break when burst, angular velocity, gravity, collision with floor/walls, water resistance when in water

Let me design the physics engine.

Coordinate system: y down positive. Room of certain size. Tank at left portion. Floor at bottom.

Let me think about the phases:
1. Idle/Setup phase: User drags crack position vertically on the side panel.
2. User clicks "Trigger" or "Crack" button. Crack develops (grows/creeps) for a moment.
3. Burst: crack opens fully, water escapes, glass fragments fly, jet forms, puddle spreads.

Let me implement:

Tank: positioned at x0, y0 (top-left), width TW, height TH. Glass thickness. The right side panel is the one that cracks. Actually "side panel develops a visible crack" - let me make the right side panel the crack location. The crack is dragged vertically along the right side panel.

Actually let me allow dragging crack vertically - the crack position along the height of the right panel. Lower crack → stronger jet.

Water level: tank water height W (from tank bottom). waterline at y = tankBottom - W.

Flow: Torricelli. Hole area based on crack opening height times crack width (narrow slit). Velocity v = C * sqrt(2 g h) where h is depth of water above crack center. If crack is fully open, hole height = crack height. But if waterline below top of crack, effective hole height limited to submerged portion.

Flow rate Q = area * v. This reduces tank water volume. Tank area is cross-section width * (into screen depth). Let's use 2D but we need volume. Assume tank depth (into screen) = some value. Actually for 2D puddle area, let's just track volume in units of area. 

Let me simplify: tank has a "depth" dz constant. Water volume V = tankWidth * waterHeight * dz. Flow out reduces V. Puddle volume increases.

Flow rate through crack: Q = crackArea * v, crackArea = effectiveHoleHeight * crackWidth * dz... crackWidth is into screen (small). Hmm, this is getting complex. Let me just make it 2D-like but track volume in consistent units.

Let me define: dz (into screen depth) = 1 unit for tank width, and crack width into screen small. Actually let's keep it simple with area-based.

I'll track water volume V (px^3 using dz). Tank interior width = TW. Tank depth dz = say 300. Tank water volume = TW * waterHeight * dz.

Crack is a slit of narrow width w_c (into screen, e.g. 20) and height h_c (crack vertical extent). Effective area = w_c * effectiveHoleHeight. Velocity v = 0.6 * sqrt(2 g h). Q = area * v. Decrease V by Q*dt.

waterHeight = V / (TW * dz). Waterline y = tankBottom - waterHeight.

The jet issues from the crack at depth h (water depth above crack center). v horizontal = velocity from Torricelli. Then gravity acts, parabolic path.

Puddle: accumulates on floor, spreads as a disk until hitting walls. Track puddle volume, radius, height. Spread by some factor and collision with walls.

Let me set the room: floor at y = ROOM_H, left wall x=0, right wall x=ROOM_W. Tank sits on floor at left.

Let me design the rendering and objects.

Objects:
- Fish: semi-buoyant (neutral buoyancy, can swim). Has position, velocity, angle. In water, moves with slight buoyancy, swims. When current in tank (as water drains, water moves toward crack), fish tries to swim against current (toward left). When fish reaches crack opening region and current strong, it gets swept through.
- Rock: dense, sinks to bottom of tank, stays on floor. Could be swept if... no, rocks stay. Maybe rock sits at bottom. When water drains, rock remains. Not swept through crack (too big/dense). Actually could a rock go through? The crack is a narrow slit. Let's say crack width into screen small so only fish and small stuff and toy can fit. Rocks stay.
- Plants: rooted/buoyant. They sway. Might get swept if loose. Let me make plants anchored (attached to bottom) so they stay and sway with current. Maybe a loose plant leaf can be swept. Let's keep plants anchored but swaying.
- Floating toy: light, buoyant, floats on surface. Can be swept through crack and carried by jet.

Current: In tank, water flows toward the crack as it drains. Current strength depends on flow rate. We can represent current as a velocity field, e.g., horizontal velocity toward crack increasing near the crack and with flow rate. 

For objects, buoyancy: 
- In water, submerged objects experience buoyant force F_b = rho_water * V_obj * g. Net weight = (rho_obj - rho_water)*V*g.
- Drag in water: F_d = 0.5 * C_d * rho * A * v_rel^2 in direction opposing relative velocity (object vs water).
- Drag in air: similar with rho_air.

Objects transition: when in water, apply water physics (buoyancy + water drag + current). When out of water (above waterline but within tank... actually when airborne), apply air drag + gravity. When hitting floor, collide.

Fish swimming: fish has speed; swims toward a target (e.g., toward left/away from crack, or random). With current push.

Let me now think about the water jet rendering: emit particles from crack along the jet direction. Each particle has velocity initial = jet velocity + maybe spread, subject to gravity, air drag. Particles that hit floor become part of puddle / splash.

Also fish swept through crack: follows jet path, lands in puddle on floor, flops around.

Glass fragments: at burst, generate several fragments from the crack area with random velocities (outward/down), angular velocity, gravity, collision with floor and walls, water resistance (drag in air). Fragments are small shards.

Waterline: lowered continuously as V decreases.

Let me also show the crack being draggable with a marker, and a "Trigger Failure" button.

Let me code this. I'll keep it reasonably performant.

Let me set up dimensions:
- Canvas W = 1200, H = 700.
- Room: floor at y = 680. left wall x=20, right wall x=1180.
- Tank: on floor. Tank width TW=560, tank interior height TH=380. Tank bottom at floor y=680, top at 300. Tank left x=60. Right panel at x=60+TW=620. Tank depth into screen dz.

Actually let me give the tank some height and thickness.

Let me define:
- TANK_X = 80, TANK_W = 520, so right wall at x=600.
- TANK_BOTTOM = 660 (a bit above floor so tank has legs? no, sits on floor). Let me set TANK_BOTTOM = 680 = floor, TANK_TOP = 680 - 400 = 280.
- Glass thickness ~ 12.

Crack on right panel at x=600. Vertical extent crackH (say 90 initially, or user sets by dragging). Position: center at crackY.

User drags: click on the right panel and drag up/down to set crack center y. A handle shown.

Water initial: near full. TANK water height init = 360, so waterline at y = 680-360 = 320.

Jet from crack center.

Let me write flow physics:
- g = 980 (px/s^2)
- rho_water etc. Just use consistent units.

Torricelli v = 0.62 * sqrt(2*g*h), h = depth of water above crack top... Let me use h = distance from waterline to crack top (top of opening). Effective opening height = crack height but clipped to submerged portion (from crackTop to min(crackBottom, waterline)). Actually the opening is the crack slit; water exits from entire submerged slit. The jet speed varies with depth but approximate using center depth or use a single average. For simplicity use h = waterline - crackTop (top of opening) as pressure head at top; the effective area submerged.

Let me compute:
- crackTop = crackY - crackH/2, crackBottom = crackY + crackH/2.
- submergedTop = max(crackTop, 0), submergedBottom = min(crackBottom, waterline).
- effH = submergedBottom - submergedTop (could be <=0 if above water).
- If effH <= 0, no flow.
- h = submergedBottom - submergedTop = effH (depth of submerged opening height). Actually pressure head should be waterline - crackTop. Let me use h_head = waterline - crackTop. If crack entirely submerged, h_head = waterline - crackTop. Jet speed v = 0.62*sqrt(2 g h_head). Hmm but that makes lower crack have bigger h_head → stronger jet. Good, matches requirement.

Actually the requirement: "A lower crack should initially produce a stronger jet than a higher crack." Yes because h_head (depth above crack) larger. Good.

- Flow area A = crackDepth * effH, crackDepth into screen = say 24.
- Q = A * v.
- Reduce tank water volume: V -= Q*dt. waterHeight = V/(TANK_W*dz). 

Wait crackDepth and dz (tank depth) are both into screen. Let me set dz = 260 (tank depth). crackDepth = 40 (crack slit width into screen). So the tank is a box of depth dz; the crack on right panel is a vertical slit with depth 40 (opening width). That makes sense.

Tank volume initial = TANK_W * waterHeight * dz = 520*360*260.

Flow Q in px^3/s.

Puddle volume += Q*dt. Puddle on floor is a shallow disk. Puddle radius grows until hitting walls (left/right). Puddle height = V_puddle / area. As puddle spreads, gets thinner. Puddle max spread determined by room width and floor.

Let me model puddle as spreading: given volume, compute area = V_puddle / height. Start with small height and increase radius. Spread radius r = sqrt(area/pi) but clipped to room bounds (so it becomes a rectangle-ish shape). Simpler: puddle is a rectangle across floor width between walls, with height determined by volume / floorArea where floorArea = floorWidth*floorDepth. As volume increases, puddle height rises until overflow... but it's a puddle spreading thin. 

Let me do: puddle height increases as water flows out, but caps; puddle spreads to fill room floor. Model: puddleBaseArea grows over time to a max, puddleHeight = V/(area). Let me define max area = roomWidth * dz_floor (floor depth = dz). Then puddleHeight = V_puddle/(roomWidth*dz). Once it reaches this full area it just gets deeper. Actually water should spread out wide and thin. Let me have puddle spread radius grow quickly. I'll just compute puddle as filling the floor rectangle of width roomWidth, depth dz. So puddleHeight = V_puddle / (roomWidth * dz). It grows from 0. That reads as the whole floor getting water that rises. That's acceptable and shows water spreading across the room. But it'd be nicer to show it spreading from the jet. I'll add a visual spreading front: a waterline front that moves outward from tank toward both walls, and behind it water. 

Let me implement puddle with a "front" that spreads at some speed, max at room width. Water fills region between front and tank outward. puddleHeight = V/(floorArea). Render puddle water across the width that's been covered.

OK, let me not over-engineer. I'll render puddle as a rectangle covering floor from left wall to right wall once it spreads, with height puddleHeight, and a front that moves outward. Given volume conserved it should look fine.

Let me now write the code. This is large. Let me structure:

HTML:
- canvas
- overlay panel with title, instructions, trigger button, reset button
- status readout maybe

JS:
- Setup canvas, room, tank, crack state
- Input: drag on canvas to set crackY; click Trigger
- Simulation loop
- Objects arrays: fish, rocks, plants, toys, fragments, jet particles
- Rendering functions

Let me code.

I'll make crack drag: mousedown near right panel region sets dragging, mousemove updates crackY, mouseup ends. Also allow before trigger only. After trigger, fixed.

Let me define state machine: mode = 'setup' | 'cracking' | 'burst'.

- setup: user drags crack. Press Trigger → mode='cracking'.
- cracking: crack grows for ~0.8s (crack lines spread), then burst.
- burst: water escapes, jet, fragments, etc.

Let me write it.

Let me define helper for crack visual: a zigzag vertical line.

Let me now write the full file.

For objects:
Fish: 
- pos, vel, size, angle.
- buoyancy factor ~ 0.95 (slightly lighter than water so floats up a bit / neutral). Let's set so it can swim around midwater. In water: net accel due to buoyancy small upward. Swim force toward target. Current advects.
- Swim target: when no strong current, wander within tank. When current present (draining), fish tries to swim left (against current) - target x = left area. Current strength near crack strong; fish swims left but current pushes right. Eventually fish reaches crack region, gets swept out (velocity becomes jet velocity, transitions to airborne).
- In air (after exiting tank): gravity + air drag. Then floor collision, flops.
- Also fish might exit via crack into jet even underwater path.

Fish detection of "swept": if fish x crosses right wall (tank right) then it's out. When out, it follows projectile.

Rock: dense. In water sinks to floor, rests. When water drains below it, still on floor. Not moved by current (heavy). Stays in tank.

Plant: anchored at bottom, sways with current. When water drains, still anchored, sways less. Provide some.

Floating toy: light, floats on surface (buoyant, floats at waterline). On surface, moves with current drift, advected toward crack, gets swept through when reaches crack. Then airborne projectile, lands in puddle, floats on puddle.

Let me handle toy buoyancy: density ~0.4. In water, net upward accel = (1-0.4)*g. It will float to surface and bob. At surface, horizontal drift with current.

Given complexity, let me write reasonably.

Let me define water current field inside tank during draining:
- current horizontal velocity toward right (toward crack) increasing with flow and closer to crack, and also stronger lower? Actually water moves toward the crack which is at right panel at depth. Near the crack, high speed. Let me define u(y) = Q/(A_cross * ...) Not necessary to be exact. I'll define current speed proportional to flow rate and a ramp toward crack: currentX(x) = base * (x - tankLeft)/(tankWidth) * factor, directed +x. Plus at the crack region, a strong inward velocity.

Let me just compute average horizontal current speed = Q / (waterHeight * dz) roughly (flow area cross-section). currentX = that. It's uniform-ish. Good enough.

For fish swimming: fish swimSpeed ~ 90 px/s. Current can exceed it when jet strong, sweeping fish.

Now the jet: at crack, water exits at speed v (Torricelli). The jet goes horizontally then curves down (projectile). Actually water exiting horizontally from a vertical slit; the jet initially horizontal then falls. So jet particles have vx = v, vy = 0, then gravity adds -g? No y down is positive, gravity downward. Wait y down positive, gravity downward positive gy. But jet should curve downward. So vy increases downward. Initial vy=0 (horizontal). vx = v. But actually water from crack at right wall shoots to the right then falls. Good, matches.

But wait: crack on right panel, water shoots rightward (+x) out of tank, curving down to floor, forming puddle at right side. And puddle spreads. Good.

Hmm, but tank is at left, floor continues right to room right wall at x=1180. Plenty of room for jet to arc and puddle. Good.

Jet particles: spawn at crack center (or along submerged opening) with vx = v (plus small downward component at bottom of slit). Life: when hit floor, convert to puddle (splash), remove or turn to splash particle.

Let me also add spray/splash particles on impact.

Rendering order: room background, tank glass, water in tank (with waterline), underwater objects, jet, puddle, fragments, fish, toy, plants, rocks, UI.

Let me code it now.

Let me be careful about coordinate and performance.

Let me write the file.

I'll implement object update with dt.

Let me define physics params:
- g = 900
- rhoWater = 1, rhoAir = 0.0013
- For objects use effective density.

Let me just implement per object type with custom update logic rather than fully general, simpler and more controllable.

Fish update:
```
// if in tank & underwater
if mode burst:
  current = currentSpeed (toward +x), increasing as drains
  // swim: target left when current significant, else wander
  // buoyancy: slightly upward
  // position update
  if fish.x > tankRight: // exited through crack
     airborne fish
```

Let me define fish position; it's inside tank. When current exists, fish swims left with swimSpeed. currentSpeed pushes right. Net vx = current - swimSpeed (if trying to swim left). If current > swimSpeed, fish drifts right despite swimming. When fish crosses tankRight - small, it's out: set airborne with vx = currentSpeed+jet, vy=0, then projectile.

Also fish in water bobs with buoyancy.

Let me set swimSpeed slightly less than max current so eventually fish gets swept (requirement: fish attempts to swim against current before being swept). Good.

Let me implement fish float: in water, fish has neutral-ish buoyancy; I'll keep it near a depth target or let it swim up/down toward target.

Simplify fish: fish follows target point with swimSpeed; target chosen: during calm, random point in tank. During drain, target = left side (swimming against current). Add buoyancy to keep near mid-water. Also the fish can be swept.

Once airborne (out of tank): gravity, air drag, on floor flop.

Toy update: buoyancy floats it to waterline. Horizontal drift with current (no swimming). When reaches crack, swept out → projectile → lands in puddle → floats.

Rocks: sink to bottom, static.

Plants: anchored, sway by current.

Let me code all.

Let me also make multiple fish (3-4).

Now the waterline lowering: waterHeight computed from V each frame; render water rectangle from bottom up to waterline. The top edge (waterline) drops continuously. Good. As it drops below crack top, flow reduces to 0.

Let me ensure flow stops when waterline <= crackTop.

Let me code and test mentally for bugs.

Let me write the HTML now.

I'll include a reset button to reload simulation.

For drag: allow dragging crack center vertically between tank top and bottom. Show a handle (line with arrows) on right panel.

Let me define crack as a vertical line on the right glass panel. crackY center, crackH = 90.

I'll draw crack as jagged line from (crackY-crackH/2) to (crackY+crackH/2) at x=rightPanel inner.

Trigger button starts failure.

Let me write.

For puddle front spreading: 
```
puddleFront (half-width) grows from ~0 to maxFloorHalf with some speed ~ 160 px/s.
waterOnFloor height = V_puddle / (roomWidth * dz)  // fills whole width
```
Actually let me compute puddle height from volume and current covered width. Covered width = 2*front, capped at roomWidth. area = coveredWidth * dz. puddleHeight = V_puddle / area. As covered width grows, height shrinks (spreading). Once covered full width, height grows with volume. Good.

Render puddle as rectangle from floor up height, from leftWall to rightWall (or from tank to right edge). The jet lands to the right of tank, so puddle should be on right side initially. Let me center puddle around jet landing, spreading both directions, capped by walls. I'll place puddle spanning [max(leftWall, tankRight - front), min(rightWall, jetLandX + front)]. Simpler: puddle between tank right wall and right wall (since jet lands right of tank, water spreads left toward tank and right toward wall). Actually water can also flow under/around. Let me just fill entire floor rectangle gradually via front growing from jetLandX outward to both tankRight and rightWall. The region between tank and right wall fills.

Hmm tank sits on floor, so water between tank and right wall, plus water can go in front (toward viewer) but 2D.

Let me just make puddle cover floor from x=0..roomW as front grows from jetLandX to both edges, height from volume. Good enough visually.

I'll render puddle water as translucent blue rect from floor up by puddleHeight across [leftCovered, rightCovered].

Let me now write code. I'll keep draw functions clear.

Let me write the entire file.

One more: glass fragments fly outward from crack at burst with angular velocity; collide with floor (bounce, lose energy), walls, and water resistance (drag) in air. Provide 8-12 fragments.

Also water resistance in air = drag; in water fragments decelerate fast.

Let me code fragment: pos, vel, angle, angVel, size. Update: gravity, air drag (linear + quadratic), angular integrate. Collide floor: if y+size>=floorY and vy>0: vy=-vy*restitution, vx*=friction, angVel*=0.6, maybe rest. Collide walls similarly. Rest when energy low.

OK writing now.

Let me set up the crack burst sequence: during 'cracking' mode for ~0.9s, the crack visually grows (draw more jagged, widen), then burst: mode='burst', spawn fragments, open the panel (remove that section), start flow.

Let me make the flow ramp in quickly (valve opening). I'll set openFactor ramps 0→1 over ~0.3s at burst.

Now let me write.

Let me also display a small legend/instructions at top.

I'll write the file.

Let me carefully manage the tank water rectangle: interior of tank from x=tankX+thickness to tankRight-thickness, y from tankTop+thickness to tankBottom-thickness. Water fills from tankBottom-thickness up to waterline y. waterline = tankBottom - waterHeight. waterHeight max = tankInnerHeight.

Now the crack is on right inner wall. Jet spawns at (tankRight, waterline... no at crack top area). Let me spawn jet particles along submerged portion of crack at x=tankRight (inner), with vx=v, plus small downward component proportional to depth within slit (since deeper water faster + pressure). I'll add vy = 0.3*v*(depthFraction). 

Let me code spawn every few frames.

Fish swept: when fish.x >= tankRight (crosses inner right wall) set airborne, vel = (jetV, small), follows projectile from that position.

Let me handle fish airborne then floor: fish flopping on floor: reduce to rest.

OK let me write it all now. This is a big file but let me do it.

I'll write ~600 lines.

Let me produce code.

For drawing fish, simple ellipse body + tail. For toy, a small duck/boat shape (circle + beak) or a ring. I'll draw a little rubber-duck-like or a colored ball that floats. Let me do a floating toy = a ball with a rope, floats. Draw circle with pattern.

Rocks: irregular polygon gray. Plants: green wavy lines from bottom.

Let me code drawing helpers.

Let me define room floor at FLOOR=680, room H=700 canvas, room width from 0..1200 but tank legs... tank bottom sits at floor.

Let me finalize numbers:
- canvas 1200x700
- FLOOR = 680
- tank: x=90, width=500 → right=590. thickness=12. innerRight=578. tankTop=280, tankBottom=680 → height=400, innerHeight=376.
- waterHeight init 356, waterline=680-356=324.
- crack on right inner panel, center x=578. crackH=90. crackY initial ~520 (mid-lower).
- room right wall at 1190.
- jet lands around x ~ 578 + arc... with v ~ sqrt(2*900*depth). depth to crack top ~ e.g. waterline 324, crackTop=crackY-45=475, depth=151, v=sqrt(2*900*151)= sqrt(271800)=521 px/s. Horizontal speed 521. Time to fall from crackY~520 to floor 680 = 160px → t=sqrt(2*160/900)=0.596s. horizontal distance=521*0.596=310 → lands at x=578+310=888. Good, within room. 

So jet arcs from right side of tank to floor at ~888. Puddle spreads from there. 

Let me set current speed inside tank = Q/(waterHeight*dz). Q ~ area*v. area=crackDepth*effH=40*90=3600. v~500 → Q=1.8e6 px^3/s. dz=260. waterHeight~350 → crossArea=350*260=91000. current=1.8e6/91000≈20 px/s. That's small. Hmm to sweep fish need current comparable to swimSpeed. Let me increase crackDepth effect or current calc. Actually average current in tank is small because tank is wide; that's realistic. Fish near crack see stronger current. Let me model fish being pushed by a local current that's stronger as they approach crack: currentLocal = current * (1 + 3*(x-tankLeft)/tankWidth) roughly, or based on proximity to crack. To get the swept effect, when fish near crack the inflow accelerates. Let me make local current = current * proximityFactor where proximityFactor ramps up near the crack to maybe 6x. Also the "suction" near crack. Let me add that fish near crack gets pulled.

I'll compute currentStrength for fish as:
```
prox = clamp((x - tankInnerRight)/ (tankWidth*0.5) ... )
```
Let me define currentAt(x) = baseCurrent * (0.5 + 1.5*(x-tankLeft)/(tankWidth)) — stronger toward right. baseCurrent computed from Q. Multiply by maybe 8 to make fish swim effort matter. Let me set baseCurrent = Q/(waterHeight*dz) and multiply by 12. Then mid-tank ~ 20*1.25*... hmm.

Let me just tune: fish swimSpeed=110. For fish to be swept, current near crack > swimSpeed. baseCurrent maybe 40 near crack. Let me just empirically set current such that fish gets swept after tank draining proceeds. I'll tune with a factor. Since I can't run it, I'll choose factors that guarantee behavior logically: define current = baseQ * K / (waterHeight*dz) with K chosen so near-crack current exceeds swimSpeed once flow strong, and fish swims left at swimSpeed.

Let me just set: currentProfile(x) = flowFactor * currentPeak * prox, currentPeak ~ 200, prox = (x - tankLeft)/tankWidth * 2 (0..2). Mid tank prox=1 → 200*flowFactor. flowFactor ramps with openFactor and sqrt of flow. Actually let me define current speed = 260 * flowFactor * ((x-tankLeft)/tankWidth)^1.3. Near crack (right) ~ 260*flowFactor. flowFactor = openFactor * clamp(sqrt(2*g*h_head)/400,0,1). This gives strong current near crack when draining. Fish swimming left at 110 gets pushed; once current>110 near crack, swept. Good.

Now the fish will drift right overall when current > swimSpeed even mid tank. That's fine—fish gets pushed toward crack and then sucked through. But I want fish to visibly try swimming left. Set fish velocity = -swimSpeed (toward left) + currentPush. When currentPush>swimSpeed net right. It'll reach crack and be swept. Good.

Let me implement fish with position clamp inside tank (water region) until swept.

Let me write everything now. I'll do it in one go.

Let me define global arrays and update.

I'll write the code.

For the crack drag UI, I need pointer events on canvas. Setup before trigger.

Let me code.

I think I've planned enough. Let me write.

Let me also add splash particles when jet hits floor and puddle.

Let me now produce the file.

I'll write functions:
- init()
- drawBackground()
- drawTank()
- drawCrack()
- drawWater()
- updateWater(dt)
- spawnJet(dt)
- updateJet(dt)
- drawJet()
- updatePuddle(dt), drawPuddle()
- initFish etc.
- updateFish, drawFish
- updateToy, drawToy
- updateFragments, drawFragments
- loop

Let me write.

I'll represent water volume as variable waterV, waterHeight derived.

Jet particles array.

Let me code now.

Actually, for drawing order: puddle should be under tank? The tank sits on floor; puddle on floor at right side extends. Tank is at left, puddle from tankRight outward. Draw puddle after background but the tank water is separate. Order: background → puddle floor water → tank (glass+water) → underwater objects → jet → fragments → fish/toy that are outside → UI.

Objects outside (airborne fish/toy) drawn above tank. Underwater drawn inside tank. I'll draw all objects after tank; those inside tank render within tank region, fine.

Let me finalize and write. I'll write the code carefully.

Let me write the whole thing now.

For fish color and size, 3 fish.

Fish update detail:
```
fish.state: 'tank' | 'air' | 'floor'
if tank:
  if mode==='burst':
     push = currentAt(x)  // +x
     // swim
     swim = -swimSpeed // left
     vx = swim + push
     vy = buoyancy small + swim vertical toward target
     x += vx*dt; y += vy*dt
     // keep in tank water, clamp y to water
     if x > innerRight - 6: // reached crack
        // swept
        fish.state='air'; fish.x=innerRight; fish.vx = jetSpeed(fish.y)+push; fish.vy=0; fish.dir=1
  else:
     // calm wander
     ...
```
buoyancy: fish near neutral; I'll apply small upward accel so it doesn't sink: actually keep fish swimming. I'll have fish hover at its y with slight random vertical target.

Let me give fish a target and swim toward it: vector from pos to target normalized * swimSpeed, plus current. When draining, target = (tankLeft+40, current y) so it swims left. When calm, target random in tank.

Let me implement.

Fish in air: vx, vy; vy += g*dt; drag; when y+size>=floor: state floor, stop (flop), reduce.

Toy: 
```
if state tank:
  buoyancy: netUp = (1-0.45)*g = 0.55*g; vy -= buoyancy? y down positive so buoyancy up = -0.55*g*dt.
  floats: clamp y to waterline (surface) -> when y < waterline, vy toward surface
  horizontal drift = currentAt(x)
  if x>innerRight: swept → air
if air: projectile
if floor: floats on puddle (position on puddle surface), stays near landing.
```
Toy floats on surface, so its y tracks waterline. As waterline lowers, toy stays at surface, drifting right toward crack, then swept. Good—toy rides the draining water. 

Let me implement toy y = waterline - toyR + bobbing.

Now let me code the file fully.

I'll write it.

Let me also add a "lower crack → stronger jet" note: since h_head larger. The jet particle vx depends on h_head at spawn.

Let me write.

Also initial fish positions inside tank.

Let me define tank inner bounds: innerLeft = tankX+th, innerRight = tankX+tankW-th = rightWall - th. innerTop, innerBottom.

crack x = innerRight (on inner face). Jet spawn at x=innerRight.

Let me write now.

I'll keep dt = 1/60 fixed step with accumulator or just dt from rAF clamped.

Let me code.

Time to write the file.

Let me make canvas responsive-ish but fixed 1200x700 with CSS scale to fit.

Write now.

Let me write the file.

Let me verify the file exists and do a quick sanity check on the JS for errors by running node to parse the script.

Let me extract the script and run node --check.

JS syntax is valid. Let me do a quick logic sanity check on a couple of things.

1. The `flowUpdate` returns jetY but I don't use it. Fine.

2. In `burst()`, fragment color uses `rgba(190,225,255,` prefix but fragments drawn with fillStyle = f.color + '0.85)'. That works.

3. `f.angVel*0.6;` in floor collision is a statement without assignment - no-op bug. Let me fix: `f.angVel *= 0.6;`.

Let me fix that.

Also, one thing: fish in tank clamp x to IN_R-4, and to escape requires f.x>=IN_R-4 and y within crack. But clamped to IN_R-4 means f.x can equal IN_R-4 which is < IN_R-4? clamp upper is IN_R-4, so f.x can reach IN_R-4. Condition f.x>=IN_R-4 true. Good.

But the escape condition also requires f.y between crTop and crBot. Fish's y is clamped to [wl+4, IN_BOT-6]. The crack may be anywhere; if fish doesn't align vertically with crack it won't escape. Fish swimming target during burst is (IN_L+30, f.y), vertical stays same. So fish vertical position is whatever it was. If that's not within crack height, fish won't escape and will just be pinned at right wall. Hmm. That could make fish get stuck at wall instead of swept.

I should make the current also pull fish vertically toward the crack when near the wall, so fish gets sucked into the crack. Or broaden escape: allow fish to be pulled to crack. Let me add: when fish near right wall, pull y toward crack center.

Let me modify updateFish tank branch: add a suction toward crack when x is close to right wall and mode burst. Pull fish.y toward crackY gradually. Also allow the fish to be dragged down/up.

Let me add:
```
if(mode==='burst' && f.x > IN_R - 60){
  f.y += (crackY - f.y)*1.5*dt;  // suction into crack
}
```
And clamp. Then when it reaches wall and y within crack, escapes.

Also once at wall pinned, if y still slightly off, this pull helps align.

Let me also make it so if fish is pinned at wall and never exactly aligns, we still allow escape when y within crackH region. The suction should align it.

Let me refine: allow a generous crack match: within [crTop-10, crBot+10].

Let me update.

Also the fish might escape through a crack that's high but fish pinned low — suction pulls it up. Good.

Let me also ensure fish doesn't get stuck against wall forever if crack never aligns — with suction it will align.

Let me patch updateFish.

Also fix angVel bug.

Let me make these edits.