Create a large glass aquarium whose side panel develops a visible crack and then bursts.

Simulation must include many features. Need single HTML file with CSS/JS inline, no external resources. Create self-contained.

We need to implement physics simulation. Probably canvas 2D.

Features:
- Water escaping through opening with flow strength based on depth decreasing as tank drains
- Curved water jet affected by gravity
- Spreading puddle collides with room boundaries
- Fish, rocks, plants, floating toy reacting differently according to density, buoyancy, drag, current
- Objects transitioning underwater to airborne then floor collisions
- Fish attempting to swim against current before swept through breach
- Glass fragments with angular velocity, collisions, water resistance
- Visible waterline lowers continuously
- User drag crack vertically before triggering failure. Lower crack stronger jet.

We need one file index.html.

Implementation approach: canvas full screen. Draw room, floor, aquarium rectangle. Water as particles? Could be simplified.

Simplify: Tank is rectangle. Water level variable. Crack is a line segment on right wall, user can drag its vertical position (y start/end). Maybe drag handle.

When trigger (button), crack grows, glass fragments spawn. Water outflow: compute pressure = rho * g * depth. Jet velocity = sqrt(2*g*depth). Emit particles from crack opening.

Particles follow projectile motion under gravity. When hit floor, contribute to puddle. Puddle is a shape expanding.

Objects inside tank: fish (multiple), rocks (heavy), plants (light flexible), floating toy (buoyant). Each with density, buoyancy, drag. Simulate in tank water and after exit.

Simplify physics: 2D objects with x,y,vx,vy. Underwater: buoyancy force upward = rho_water * displaced volume * g. Weight = density*volume*g. Net vertical force = buoyancy - weight - drag. Drag proportional to v^2.

Current from jet: near crack, water velocity field pushes objects.

Fish AI: try swim toward safe zone, swim against current.

Glass fragments: spawn at crack, angular velocity, collide with water and floor.

Waterline: draw water rectangle height = water level.

Flow strength based on depth: Torricelli.

Need user drag crack vertically before triggering failure. Provide slider or drag.

Implement simple UI: crack position handle draggable, button "Burst".

Let's create canvas with requestAnimationFrame.

Simplify to keep code manageable but fulfill requirements.

We'll create classes:
Tank {x,y,w,h}
Water {level}
Particles for water jet.
Puddle {radius, area}
Objects array.

Glass fragments array.

Use simple physics.

Implementation details:

Canvas size e.g., 1000x700.

Tank centered left? Let's put tank at x=150, y=100, w=300, h=400.

Room boundaries: floor at canvas height - 50.

Crack: on right wall. Crack has yCenter, length (maybe 60). User drags yCenter within wall bounds.

When burst triggered: set burst = true, crack grows, glass fragments spawn.

Water outflow rate: outflow = C * area * sqrt(2*g*depth) where depth = waterLevel - crackCenter? Actually depth to crack: water depth above crack opening = waterSurfaceY - crackY (in tank local). If crack below water surface, outflow.

Decrease water volume: dV/dt = - outflow. Water level decreases.

Simplify: water height in pixels. Volume proportional to height * width. outflow in pixels^2 per sec? Use approximate.

Let outflow_rate = k * crackLength * sqrt(max(0, waterSurfaceY - crackY)) . Then waterHeight -= outflow_rate * dt / tankWidth.

Jet particles: emit from crack at interval. Initial vx = jetSpeed * cos(angle). Actually jet horizontal outward. angle maybe slightly upward? Torricelli gives horizontal velocity sqrt(2g h). So initial vx = jetSpeed, vy = 0 (or slight). Then gravity acts.

Fish: each has position inside tank. Swim speed. If near crack and current strong, get swept.

Simplify current field: for objects inside tank, if x > tank.x + tank.w - 80 and y between crack top and bottom, apply force outward.

When object exits tank through crack opening: set underwater = false, then apply gravity.

Collision with floor: simple bounce damping.

Water resistance: drag coefficient higher underwater.

Fish attempt swim against current: if current >0, fish vx -= swimSpeed.

Glass fragments: polygon shards. Simple squares with rotation.

Puddle: when water particles hit floor, increase puddle radius based on volume. Puddle collides with room boundaries: constrain max radius.

Let's implement.

We need visible waterline lowers continuously.

No external resources. Use canvas.

Let's produce HTML with <style> and <script>.

Add UI controls: slider for crack position, button burst, reset.

Implement drag: mouse down on handle.

Let's craft code.

Complexities: many objects. Keep manageable.

We'll use dt ~ 1/60.

Physics constants: g = 900 px/s^2 (tuned).

Water density =1.

Buoyancy: for each object, volume ~ area. Buoyancy force = rho_water * volume * g * submerged fraction. Simplified: if underwater, apply upward acceleration = (1 - density) * g * submergeFactor.

Density values:
fish ~ 1.02 (slightly negative) but swim.
rock ~ 2.5
plant ~ 0.6
toy ~ 0.3

Drag: underwater drag = 0.02 * v^2.

Air drag smaller.

Implementation steps in code:

setup canvas.

tank = {x:200, y:120, w:320, h:420}
waterHeight initial = tank.h * 0.9
waterLevelY = tank.y + tank.h - waterHeight

crack = {yCenter: tank.y + tank.h*0.6, length: 50, open: false}

Handle drag.

Objects:
create 5 fish, 3 rocks, 2 plants, 1 toy.

Each object: x,y,vx,vy, radius, density, type, rotation, angularVel, underwater bool.

Update loop:
if burst:
  water outflow...
  emit jet particles
  update glass fragments
  update puddle

update objects:
if underwater (y > water surface? Actually inside tank and y > water surface? Wait tank coordinate: y increases down. Water surface at top of water. So underwater if y > water surface and inside tank bounds? Actually inside water column.

Simplify: object is underwater if its y + radius > waterSurfaceY and its x inside tank and y < tank.y + tank.h.

When object exits tank through crack: if x > tank.x + tank.w and y between crack top/bottom, set underwater false, inAir true.

Physics for underwater:
net vertical accel = (1 - density) * g * submerge - drag_y
horizontal accel from current.

For in air: accel = g downward, drag small.

Floor collision: if y + radius > floorY, set y = floorY - radius, vy *= -0.3, vx *= 0.8.

Water jet particles: array of {x,y,vx,vy,life}. Update with gravity. If y > floorY, add to puddle volume.

Puddle: have volume. radius = sqrt(volume / pi). Expand slowly, collide with walls.

Glass fragments: spawn at burst ~ 20 fragments. Each with x,y,vx,vy,angle,angularVel,size. Update with gravity, water resistance if underwater. Collide floor.

Fish AI: try stay near center, avoid crack. If current strong, try swim left.

Simplify.

Let's produce final HTML.

Make sure code is self-contained.

Potential performance fine.

We'll add UI overlay div for instructions.

User drag crack vertically before triggering failure. Provide a handle on right wall.

Implement mouse events on canvas.

We'll have state: draggingCrack = false.

On mousedown, check if near handle (x ~ tank.x + tank.w, y ~ crack.yCenter). If within 20px, start drag.

On mousemove update crack.yCenter clamped.

Burst button triggers.

Reset button.

Ensure visible waterline.

Implement water drawing: fillRect for water with gradient.

Crack drawing: line on tank wall with increasing width after burst.

Glass shards: draw polygons.

Okay.

Let's write file.

File written. Let's confirm presence.

Done.