Aquarium breach · particle-1

Let me plan the simulation carefully.

Scene layout (canvas 1200x800 CSS but responsive). Let's define world coordinates matching canvas.

Room: floor at y = 700, walls at x = 60 and x = 1140, ceiling maybe top. Table? Tank sits on a table? Simpler: tank stands on floor/stand.

Tank: rect x from 200 to 800, y from 160 to 640. Glass walls. Waterline initial y = 230. Water fills from waterline to bottom inner.

Crack: on right side of tank (x = 800) vertical, draggable vertically between y=300 and y=600 (below initial waterline 230). Crack drawn as visible jagged line. Drag vertically only.

Breach button: pressed, panel breaks around opening: fragments spawn at opening, jagged hole opens (hole grows). Water jet from hole toward right, gravity curved: particles spawn at hole with velocity vx ~ outflow speed (based on depth relative to waterline: sqrt(2g(hole_depth))?), vy initial small then gravity. Water leaves only if waterline > hole y. Outflow weakens as water level approaches opening; hole effective area shrinks.

Water simulation: simple 2D height field inside tank? Tank has fixed width; water volume decreases over time -> waterline falls. Compute outflow rate = k * area * sqrt(2 g (h - holeY)) when h > holeY. Volume = tankWidth*(bottom - h). dV/dt = -Q. So waterline falls continuously.

Puddle: spreading puddle constrained by floor and walls. Use a 1D height field across the room width (x from 60 to 1140), with water accumulating. Each jet particle that collides floor or puddle adds volume at landing x. Puddle height field diffuses/spreads with neighbor exchange; constrained at walls. Draw as filled shape with wavy surface. Also puddle should be bounded by tank? Tank is sitting in room; puddle can spread both ways around the tank? Tank occupies x 200..800 on floor. Simplify: puddle spreads on the floor in front? Since 2D side view, the puddle is on the floor behind/in front of tank. Let puddle spread across the whole room floor (x 60..1140), drawn in front of the tank's lower part, and objects land on floor. The tank's base blocks liquid? Hmm, physically water escaping to the right would spread right and also left under the tank. In side-view 2D, drawing puddle across floor including under tank is visually okay if tank is a glass box seen from front: puddle is on floor in front of the tank, so it can spread across. Let's just draw the puddle in front of the tank base (z-order) spanning the room; that reads fine and is constrained by floor and walls as required.

Objects:
- Rocks: static-ish heavy, on tank bottom. Buoyancy: rocks dense => sink, rest on bottom. Response to current: minimal, but maybe tiny nudge? Requirement "rocks sink". They stay on bottom. Maybe move slightly with strong current? Keep them settled.
- Toy: floating initially at waterline near left. Buoyancy pushes toward waterline; drag; current pushes; if it escapes through hole (only if near hole and small), gets gravity, bounces on floor, floats on puddle.
- Plants: anchored at tank bottom, bend with current: stalks as segmented chains with stiffness, affected by current field inside tank. Bending away from breach, "drift".
- Fish: several. Initially swim against the current (turn to face left/into current) when breach occurs; some get swept toward hole and through it. Fish physics: buoyancy-ish (neutral, stay within water), steering force, current force. Fish count maybe 6; 2-3 swept out. Escape criteria: near hole and water level above hole, chance/force -> carried through. Once outside: gravity arc, land on floor, flop on floor/puddle.

Glass fragments: spawn at breach when breaking, with rotation, velocities outward, collide with floor, experience water drag inside water. Also collide with tank walls? Keep simple: floor and ground, plus water drag. Fragments rotate with angular velocity, damped.

Particles for jet: many water particles with gravity, leaving from hole; they are semi-transparent blue. Also spray.

Crack drag: user drags vertical crack along right wall within below waterline. Show a dashed/solid jagged crack, with a drag handle. Must be visible.

On breach: selection zone around crack becomes opening: hole grows in a few hundred ms from crack center; fragments spawn. Hole rect from crackCenterY - h/2 to +h/2, size ~ 46 px tall (fixed? maybe crack length defines opening size). Let crack be a fixed length (e.g., 70px) with center draggable. Opening height maybe 60 -> objects fitting opening are small (toy radius 12, fish height ~ 12) can pass if they reach the hole.

Current field inside tank: near hole, flow toward hole with speed decaying with distance and proportional to current outflow strength. For fish, current force. Plants get flow force proportional to speed.

Waterline lowering: track waterHeight h (y of surface) from 640 (bottom) to top of water. Initially 230. Volume = (640 - surfaceY) * width. Outflow reduces volume. Q = A * v, v = sqrt(2*g*depth) * discharge coeff; depth = surfaceY? depth of hole below surface = holeY - surfaceY. Actually depth = holeY - surfaceY. As surface falls toward hole, depth -> 0, Q -> 0, stop. That gives water level asymptote maybe above hole? Q -> 0 as depth->0, so water stops exactly at hole. Requirement "outflow weakens as the water level approaches the opening and stops when water no longer reaches it." Good. But asymptote means slow; add threshold stop when depth < 2px.

Also reduce area as hole passes? The hole has vertical extent; submergence factor: fraction of hole below surface. Q = w * submergedHeight * sqrt(2g*depthToCenter) * C. That's more realistic and ensures stops. Good.

Puddle volume from outgoing jet particles: each particle landing adds fixed volume, but total should track outflow. Simpler: track total volume lost, and distribute to puddle at jet landing positions proportional to particle landings. Approach: maintain puddle height field array. When a jet particle lands at x, add a small volume (fixed per particle) to that cell. But number of particles vs Q: spawn rate proportional to Q, so particle count proportional to volume. Use per-particle volume = outflow volume / number spawned accumulated. Let's just do: each frame, lostVolume = Q*dt; spawn n particles; each carries lostVolume/n volume; when particle lands, add to puddle at x. Need to handle particles that hit floor outside before? Fine.

Puddle field: N=~140 cells across room; each cell volume; height = volume/cellWidth (with clamp). Spreading: exchange flow between neighbors proportional to height differences and maybe based on height to spread; simulate with relaxation: h[i] += k*(h[i-1]-2h[i]+h[i+1]) but ensure non-negative. Better use volume array with leveling: dt exchange = min(volume, k*(h[i]-h[i+1]))... keep simple and stable: h array and diffuse with alpha 0.15 damped, clamping >=0. Height in px maybe up to 30 for contained volume: tank width 600 * water height 410 = 246000 px². Room floor width 1080 * avg height 30 = 32400 — too small. Volume in 2D cross-section: puddle can be deep-ish. Actually all 246k volume spread over 1080 => 228px depth, unrealistic. This is the classic 2D vs 3D issue. Puddle should be shallow: treat puddle height scaled so max ~60px. Use scale factor: convert jet volume to puddle "visual" volume at small ratio (e.g., 0.12) so puddle depth ~27px average. Fine—simplified physics acceptable.

Puddle height in cells, max maybe 70. Let puddleVolumeScale = 0.14. Total volume ~ 246000*0.14=34440 / 1080 = 32px avg, localized near breach initially can be 60. Good.

Float toy on puddle: toy rests at puddle surface if puddle deep enough.

Fish outside water: gravity, on floor flop. Fish inside must stay inside tank and not through walls except hole. Simple confinement: keep within inner bounds; if crossing right wall region and within hole and flow, allow exit. Similarly fish collide with floor inside tank.

Also the tank waterline falling changes fish vertical bounds; fish should stay underwater (steer upward if near surface? Fish near surface can be at surface). Let fish clamped between surface+8 and bottom.

Water rendering: filled rect with gradient + surface wave line. As it falls, redraw.

Jet: particles start at hole edge (x = 800 + wall) with vx proportional sqrt(g*depth) maybe 200-500 px/s, vy small downward initial (0 to 50) then gravity. Curve downward. Also stream visual: draw thick tapered polyline from hole using ballistic trajectory computed for current velocity; plus particles. The trajectory ballistic: x = x0 + vx*t, y = y0 + vy*t + 0.5g t². Good clear curve.

Splash: when particles hit floor/puddle, small splash particles maybe. Add droplet particles bounce.

Crack visualization: jagged vertical line at right wall drawn over glass. Drag with pointer only limited to y within tank and below initial waterline (surface initial 230 + 20 to bottom-20). Crack drag below water line. Use pointer events on canvas; hit test near crack.

UI: Title, Breach button, Reset button, status text (waterline %, outflow), maybe hint "Drag the crack on the right wall". Buttons disabled appropriately (Breach disabled until... always available; when intact clicking Breach without crack? Crack exists initially visible; user may drag it. Breach always works at current crack location). Also perhaps allow clicking Breach even before dragging, using default position.

Also add gentle idle: fish swimming, toy bobbing, plants sway, water surface ripple.

Reset: restore initial scene exactly: reinit objects and water, intact glass, crack at default, clear puddle, fragments, particles.

Glass "intact" appearance: divider frame, subtle glass highlights, reflective shine. After breach: hole in wall with jagged edges, drawn as cutout by drawing wall segments around hole plus crack lines.

Room: background gradient wall, floor with baseboard, maybe a shelf? Keep clean.

Tank: rim top, base. Water clipped inside tank inner area. Rocks on bottom (polygons gray). Plants: 3 clusters segments.

Let me now write the code.

Key architecture:

```js
const W=1200,H=800;
const tank = {x:230,y:170,w:560,h:470}; // outer
const glassT = 10; inner x 240..780, bottom 630, top 180
const room = {left:60,right:1140,floor:700};
```
Tank base bottom at 640, sitting on floor 700? Need stand: tank bottom at 640, legs? Let tank stand on floor: tank bottom y=700. Then room floor 700. Tank height 470 => top y=230. Waterline initial y=300, below crack region 360..660.

Let's set tank: x=235, y=185, w=550, h=515 -> bottom 700 on floor. Inner: x=245..775, y=195..690. Water surface initial y=290. Crack right wall at x=785 (wall center), draggable y between 350 and 660. Below initial waterline yes.

Hmm the tank tall 515; screen 800. Good. Puddle on floor y=700 across room. Tank sits over puddle visually? Draw puddle in front of tank bottom so it's fine.

Hole opening height 64 centered at crackY. Fragments spawn from hole.

Tank right wall at x = 235+550 = 785; wall thickness 10 (outer 785, inner 775). So hole spans x 775..785.

Jet origin x=786, y = center of hole (or lowest? exit from hole center/area). Let's emit particles from random y within submerged portion of hole at x=787.

Waterline surfaceY stored; inner bottom innerBottom=690; water volume-based: depth = innerBottom - surfaceY. width inner = 530.

Initial surfaceY = 290 -> depth 400, volume 212000.

Outflow: submerged top = max(surfaceY, holeTop), submerged bottom = min(innerBottom, holeBottom)... holeCenter below water. Q = discharge * (holeBottom - max(holeTop,surfaceY)) * sqrt(2*g*(holeY - surfaceY)) with g=900 px/s² scaled. Units: px²/s => volume px²/s. With hole height 64, depth 100 => sqrt(180000)=424, Q=0.6*64*424=16k px²/s -> volume 212k drains in ~13s but Q decreases; initial depth 360? holeY maybe 500 => depth 210 => sqrt(378000)=615 -> Q 23600, ~9s. Reasonable. Use gravity 1400 for faster jet curvature? Jet vx should match outflow-speed: vx = C*sqrt(2g*depth) maybe 0.5. With g=1200 and depth 210 => 710 px/s. Strong. Good curve visible: falls 100px in ~0.2s while traveling 140px. Nice.

Let's pick g=1200. Initial holeY default = 470 => depth=180 => sqrt(432000)=657; vx=0.55*657=361 px/s. jet exits and curves. Spawn q particles per second proportional to Q; particle carries volume.

Particle volume: lostVolume per frame = Q*dt; spawn count = max(1, round(Q*dt / particleVol)) where particleVol maybe 1500 px²? Q 22000*dt(0.016)=352 -> 0 per frame. Better accumulate spawnAccum += Q*dt/particleVol; spawn floor(accum); particleVol=3000 gives 0.12/frame -> ~7/s too few. Use volume per particle 400 (spawn ~9/frame). Then puddle scale multiplies. Let's do particles as visual plus volume: per particle volume = 350; spawn rate = Q/350 ≈ 63/s. Fine; 60 fps -> 1 per frame. Hmm need more visual density: draw stream ribbon + maybe emit 2-4/frame. particleVol relative to puddle scaling: volume total not tracked via particles but via scale. Actually we add lostVolume*factor into the puddle where particles land. Simplify: keep a pendingVolume accumulator: each jet particle carries volume = lostVolume/n via per-particle weight tracked; but easier: for each particle that lands, add `outflowRate*dt*scale / spawnCount`... 

Simplest consistent: maintain `dischargeVol` (px²) accumulated since last puddle add? Let's do: each particle spawn gets vvol = Q*dt / nSpawn (volume for that spawn batch). When particle lands, add vvol * PUDDLE_SCALE to puddle cell. Splash/evaporation aside, conserved. If particles go off canvas, they're during flight? They land on floor before right wall? vx 360 px/s, from x=787 to right wall 1140 = 353px => ~1s flight; with gravity from y 470 falls 600px in 1s, lands at floor ~700 quickly (230px => 0.62s) while x ~ 787+223=1010, so lands on floor before wall. Good. Some spray may hit wall: clamp.

Puddle simulation: array N=120 over x 60..1140 (cell width 9). Volumes in visual px². Height = vol/cellW. Leveling: for each pair i,i+1: diff = h[i]-h[i+1]; flow = diff*0.25*... Only allow equalizing; conservative volumes. Loop pairs both directions via iterative:
```
for i in 0..N-2:
  diff = h[i]-h[i+1]
  if abs(diff)>0.05:
    amt = diff*0.18 * min(1, ...)? 
```
Amount volume = amt*cellW*0.5 transferred. Use h changes: transfer volume v = diff*0.15*cellW*0.5? Let's do mass: vol[i] -= f; vol[i+1] += f; f = diff*cellW*0.5*0.2. That's stable if coefficient <1. Also puddle should not flow uphill beyond level. Good. Clamp negative.

Also apply shallow-water "wet" smoothing to surface heights only when positive.

Draw puddle: path along cells h>0.4, fill semi-transparent gradient, plus surface highlight.

Toy floats on puddle: check local puddle height at toy.x; if water depth > toyRadius, buoyancy upward to surface y = floor - h; otherwise rests on floor with slight bounce.

Fish:
```
fish = {x,y,vx,vy,angle,escaped, panic}
```
Inside: target swim direction; current force fx,fy from flowAt(x,y). Behavior: baseline wander; on breach, swim against current: force opposite current direction * strength (fish swim speed limited), some fish "weak" get swept. Implement: desired = -currentDir * speed for strong fish; weak fish desired = current dir + random. Clamp fish within water and tank. Near hole (distance < 90) and flow strong and random chance -> mark escaping: allow crossing hole: target = hole center, and when x > wallX -> escaped. For escaped: gravity, air drag, land on floor, then flop with small hops and slide; rests.

Fish must not escape through other walls: clamp x to inner right - radius unless in hole band and escaping.

Plants: anchored at bottom; chain of 7 segments. Each segment angle influenced by flow: target bend angle = flow*0.02 etc. Simulate springs:
For each plant, have points from base; use simple angular springs: angle[i] += (target - angle)*k + sin wave. Then compute points by cosine/sine. Flow from current field at plant point x,y.

Rocks: static polygons at bottom, maybe 3. Add slight shift? Keep static. Requirement "rocks sink" — they start on bottom; when breach, current isn't strong enough to move them. Could add tiny nudge to a small pebble to demonstrate current? Requirement mentions movable objects that fit opening can be carried out. Add small pebbles? Not necessary. Maybe allow a small rock to be pushed slightly along bottom by current, then sink back. Could add dynamic small pebble affected by flow but heavy so sinks and slides slightly. That demonstrates drag/buoyancy. Let's add one small stone (dynamic) with high density; it slides along bottom a bit but not out.

Toy: initial floating at surface left of center x=350, y = surface - r. Buoyancy toward surface, bob; current pushes right toward hole. If reaches hole -> carried out -> gravity, bounce floor, float on puddle. Radius 14 < hole 64 so fits.

Glass fragments: on breach spawn 14 shards at hole edges (right side) with velocities outward/down, rotation. Physics: gravity, water drag if y<surface (before exiting? at hole they are already outside water mostly), floor collision with restitution and friction, wall collision, angular damping. Also "experience resistance in water" — some fragments spawned slightly inside water? Better spawn half inside (x 775-790, y in hole) and water drag if inside tank and below surface. Fine.

Crack visuals: jagged line from center-35 to center+35 with zigzag, plus little stress lines. Before breach it's a "visible crack". Drag handle: a small circle at center with arrows? Keep: crack line + subtle grab handle (rounded rect label?). Simpler: crack drawn thick dark line with whitish highlight, and a round translucent handle at midpoint.

Pointer: on pointerdown near crack x within 30px of wall and y within +/-50 of crack center -> dragging. On move, crackY = clamp(y, surfaceY+50?, ...). Requirement drag vertically below initial waterline: clamp between initialSurface+40 (330) and innerBottom-40(650). Use fixed bounds [350, 650], independent of current waterline so reset works. During breach dragging disabled.

Hover cursor: canvas style cursor pointer when near crack.

UI overlay: top-left panel with title "AQUARIUM BREACH" and buttons bottom-center? Let's put a header panel at top-left: title, hint. Buttons at top-right: Breach (orange), Reset. Status readouts: waterline %, outflow L/s fake, breach state. Use DOM buttons over canvas for accessibility.

Also maybe gauge. Keep clean.

Now rendering details:

Background: room wall gradient (#e8eef2 to #d5dfe6) with subtle vertical stripes? Add baseboard and floor. Maybe a poster? Not necessary. Add soft shadow under tank.

Tank: glass: outer rounded rect with translucent gradient; rim top dark; stand? sits on floor.

Water inside tank: clip to inner rect, fill gradient blue with alpha 0.55; surface line sinusoidal; small bubbles. Caustic lines optional.

Waterline marker: dashed line with label "waterline".

Breach hole: draw right wall as segments: from inner top to holeTop, and holeBottom to inner bottom, plus jagged edge. Show white/light edge around hole and crack propagation lines.

Jet stream: compute trajectory for current Q. Draw ribbon: for t 0..0.6 sample, width tapering from 14 to 3, alpha. Use quadratic points; clip? no, outside. Plus particle droplets (circles) with gravity and alpha fade when landing.

Splash particles on puddle impact.

Ambient: fish, plants, toy, rocks.

Bubbles: emit from rocks occasionally, rise, pop at surface. Nice detail.

Also glass reflections diagonal streaks.

Sound: no.

Motion loop uses dt clamp 0.033.

Let me estimate fish escape: 6 fish at positions. On breach, current field pulls near hole. Once fish is within hole-ish region (x > 700 near wall and |y-holeY| < 80), allow swept: set escaping=true, give vx = outflow*0.7 toward hole. Fish with "strong" trait swim against current: max swim accel limited; current force maybe exceed for weak ones. Deterministically: fish[0..1] weak -> get swept, fish others resist but drift; ensure at least 1 swept through. Actually verify asks "fish initially swim against the current before some are swept through the breach". So fish turn to face the current (leftwards) and swim; weaker/close ones get sucked out. Good.

Flow field inside tank:
```
function flowAt(x,y){
 if (surfaceY>=innerBottom) return 0
 const depthF = y < surfaceY? 0 : clamp01((y - surfaceY)/40) // fully in water
 if (!breached || inflow<=0) return {x:0,y:0}
 const dx = hole.x - x, dy = hole.y - y;
 const dist = hypot(dx,dy);
 const sub = submergedFraction;
 const strength = jetSpeed * sub * Math.exp(-dist/180) * (dist<... ) 
 return {x: dx/dist*strength, y: dy/dist*strength}
}
```
Also vertical "sink" near hole? Add slight down component. Magnitude in px/s for current velocity: jetSpeed ~ 300-650 times exp; near hole ~500. Fish swim speed ~90-110 px/s so can't resist near hole -> swept if close enough. But fish should visibly swim against current for a while. Fish swim accel capability: they move at ~60 px/s against current of 150 px/s at mid distances? The field declines; fish will drift slowly. Good.

Fish movement:
```
if escaping:
  integrate; if in water until x>innerRight: mark out
else:
  // desired velocity
  const flow = flowAt;
  const against = {-flow.x/|flow|*swimSpeed, ...}
  const baseWander...
  desired = flowSpeed>25 ? against : wander
  vx += (desired - vx)*3*dt? 
```
Simpler physically: fish has thrust accel toward desired; velocity also experiences drag + current (current effectively velocity of water; fish velocity relative to water gets drag): 
vx += (flow.x - vx)*dragCoef*dt + thrust.x*dt. With thrust up to 140 px/s. If flow 500, fish gets dragged. As fish nears hole, swept. For fish far from hole flow low, they can swim against it. That's physically nice.

Add boundary clamping: fish stay inside inner rect (x in [innerLeft+20, innerRight-14], y in [surfaceY+14, innerBottom-14]). If fish hits right boundary and escape condition (hole band) -> let through; else clamp.

When fish reaches x > innerRight + 20, escaped=true, outside water: gravity, drag, rotate, land on floor, flop, settle.

Toy similarly: anchor float with buoyancy: 
```
if toy.y < surface - r? toy above surface
spring toward (surfaceY - r + bob)
flow force: toy.vx += (flow.x - toy.vx)*2*dt
```
Toy is small (~12 radius) floats near surface. Set initial x 330. It will drift toward hole. When x > innerRight - 12 and within hole band and water above hole -> escapes. If toy floats high when waterline above hole, toy at surface; if surface above hole top, toy can pass. Good.

Toy maybe should be on left, it needs to drift across tank (~400 px) before surface drops below hole (drain 5-8s; the toy may not make it). To satisfy "movable objects that fit the opening can be carried out", we want the toy to escape before waterline drops. Strong flow near surface? Our flow field near surface weaker? Let's make flow magnitude high enough mid: at surface far from hole maybe turbidity. Add general gentle circulation in tank toward hole horizontally: flow = hole direction + horizontal drift. Toy drag: water current moves it. Time to cross 400px at 80 px/s = 5s. Waterline starts 290, hole center 470, hole top 438. Water falls to 438 in... volume 150k of 212k, ~70%. With Q~20000 initial decreasing, maybe 5-6s. Toy might escape just in time. Also we can give fish/toy the benefit of a stronger current near the surface (draw current). Alternatively start toy at x=560 closer. Put toy at x=600 initially (right of center) — still "floating toy". Then crossing 160px is fast. Good. Fish placed both sides.

Set default crack y=470. User can drag to 380..640.

Glass wall segments around hole: draw wall with hole. Also fragments show.

Object-out-of-water collision with floor: floor y=700 (tank base also 700). Objects inside tank bottom at 690. Escaped objects land on room floor at 700, but they'd be in front of tank visually. Fine.

Jet particles land: if y > floor - puddleHeight at x -> convert to puddle volume + splash. Also collide with right wall at 1140 -> vertical wall run down? Just let particles hit the wall and slide: set vx *= -0.1? Water hitting wall should flow down. Simpler: if x>1140 set x=1140, vx=0, continue falling to puddle. Puddle min floor at wall. good.

Waterline computation each frame:
```
if breached and surfaceY < innerBottom:
  subH = clamp(holeBottom - max(holeTop, surfaceY), 0, holeH)
  depth = holeY - surfaceY (+ maybe measure centroid)
  if (subH > 0.5 && depth>0) Q = 0.85*sqrt(2*G)*subH*sqrt(max(depth,0)) * outflowFactor
  else Q=0
  lost = Q*dt
  surfaceY += lost/innerWidth
  outflow = Q
```
Wait units: contract coefficient 0.85 gives large; check initial: subH=64, depth=470-290=180 => Q=0.85*49*64*13.4=35.7k px²/s. Volume 212k => surface rises 67px/s initially; hole top at 438 reached after (438-290)*530=78k volume in ~2.5s at decreasing Q. That's a bit fast, toy may not escape. Reduce coefficient to 0.35: Q~14.7k => ~7s to hole. Better. Jet exit speed = 0.55*sqrt(2G*depth) ≈ 0.55*657=361 px/s. Visual good. Q value in fake "L/s" display: Q/1000.

But wait, physically the water column pressure. Fine.

Puddle and surface interplay: fallen water enters puddle until full; ignore overflow.

Also water inside tank should update fish water bounds and plants (plants near bottom unaffected until water low, then droop? Optional).

Waterline falls regardless of puddle. Stops when surface reaches hole top? Q->0 as subH->0. good. Stop threshold surfaceY > holeTop - 1 => set breached water static. Requirement stops when water no longer reaches opening.

Fragments spawn with gravity; some may fall inside tank? spawn at hole, velocities mostly +x. Add a few with -x into water then sink (water drag), nice.

Crack drawn only if !breached; during breach show hole + radiating cracks, maybe crack grayed/fractures.

Reset restores everything and repositions crack default? "Reset to restore the same initial scene" — same initial scene: crack at default center. Yes reset crack to default.

Add status overlay DOM with waterline percent and outflow.

Now implement carefully.

Structure:
```js
const canvas, ctx; let W,H with devicePixelRatio handling and resize.
```
Canvas fills window but world fixed 1200x800? Use responsive scaling: canvas internal size set to window W/H and use scale transform to fit 1200x800 with letterbox background. Simpler: canvas has width=1200 height=800 CSS max-width 100%, maintaining aspect. Playwright viewport 1200x800 - fits. Use CSS: display block; width min(100vw, calc(100vh*1.5)); height auto. Body background dark or matching. Buttons overlay positioned in a UI bar? Requirement canvas simulation. I'd put header within the scene? DOM bar at top could overlay canvas. Better make page layout: canvas container centered filling viewport with aspect ratio, control panel overlaid top-right and top-left. At 1200x800 exact fit.

I'll set body margin 0, background #0e1a24; .stage position relative, width 100vw height 100vh; canvas absolute inset 0 width 100% height 100%; but aspect distortion? Render at 1200x800 and stretch to fill viewport; with 1200x800 viewport fine. Use CSS canvas width 1200px height 800px, transform scale based on window? Simpler set canvas internal 1200x800 and CSS max-width:100%; max-height:100%; object-fit contain. Use flex centering. UI overlay in stage sized to canvas using absolute with same max sizing? Buttons can be fixed viewport top-right; okay.

Let's do: .wrap {position:fixed; inset:0; display:flex; align-items:center; justify-content:center} canvas {width:1200px;height:800px; max-width:100vw;max-height:100vh; aspect-ratio:3/2} This may stretch if viewport aspect differs; acceptable. HUD absolutely positioned in top-left of viewport with pointer events. But buttons might not align with canvas when letterboxed. Use player container with width:min(100vw,150vh) aspect 3/2; position relative; canvas 100%x100%; HUD inside container. 

Pointer coordinates: map client coords to canvas 1200x800 using bounding rect.

Now code.

```js
const W=1200,H=800, G=1200;
const room={l:60,r:1140,floor:700};
const tank={x:235,y:185,w:550,h:515,wall:10};
const inner={l:tank.x+tank.wall, r:tank.x+tank.w- tank.wall, t:tank.y+tank.wall, b:tank.y+tank.h-tank.wall}; // 245..775, 195..690
const INIT_SURFACE=290;
const holeH=64;
```
Wait tank bottom 700 equals floor. tank base 700. inner bottom 690.

Crack bounds y: 350..650. Default 470.

Hole = {y: crackY, h:64, top, bottom, x: tank.x+tank.w (785)}.

State:
```
let state={mode:'intact', breached:false, cracking:0, surfaceY:INIT_SURFACE, Q:0, totalOut:0, crackY:470, drag:false, t:0}
```
Objects arrays: fish[], plants[], rocks[], bubbles[], jet[], splashes[], shards[], puddle volumes.

Init:
- rocks: static polygons generated deterministic at bottom x 300..600. Use fixed arrays.
- plants: 4 plants at x 300, 400, 660, 720 anchored bottom 690.
- fish: 7 with positions, size, hue, strong boolean.
- toy: {x:600,y:INIT_SURFACE-14+...}
- pebble: maybe 1 dynamic (small rock) that can slide. It will sink and stay; current near bottom may slide it. Show response to current? Rocks might shift slightly with current. Let's give small pebble flow response and floor friction but heavy so it doesn't leave. Requirements satisfied by rocks sinking (they rest).

Fish data: {x,y,vx,vy,size,hue,strength,escaped,out,phase,dir}
Initial y between 330 and 620.

Plant points precomputed with base.

Hole opening growth on breach: `holeOpen` animates from 0 to 1 over 0.5s; during that, fragments spawn at start. Q begins after 0.15s ramp.

Puddle: N=120; volumes Float64Array; width=(room.r-room.l)/N; loop.

Draw ordering:
1. room background walls/floor
2. puddle (behind tank? If behind, tank occludes puddle area under tank. Since tank is glass, seeing puddle through is okay-ish. Draw puddle after water but before tank frame? Water inside tank is above floor, no overlap. Puddle top max 60 so from y 700 up to 640, tank occupies to 700. Draw puddle after tank/front glass so visible. But "room walls" constrain. We'll draw puddle after the tank so it's in front (spilled in front of tank). Fish/shard resting on floor are in front too. Good.
Order:
- background (wall, floor)
- tank shadow
- tank interior back glass
- water, rocks, plants, toy, fish (clipped to tank inner)
- tank front glass frame + highlights
- breach hole details (on wall)
- puddle
- jet stream/particles (in front)
- shards
- escaped objects (drawn with water objects? fish drawing clipped vs not) — draw fish with clipping only if inside; simpler draw all fish unclipped but positions inside. For escaped, outside. Draw all after tank front? Fish should appear inside glass, but glass is transparent. Draw fish before front frame; escaped fish after puddle. Split.
Hmm glass front highlight over fish fine.

Puddle before escaped fish/shards so they appear on top.

Breach hole must be drawn over front wall.

Draw water clipped to tank inner. At surface draw wave. Water when below hole stops? fine.

Bubbles clipped inside.

Jet particles not clipped.

Crack and handle drawn.

Status text updates every few frames.

Let's write functions:

`drawRoom(t)`:
- wall gradient top #dfe9ee -> #c6d4dc; subtle wallpaper stripes every 40px alpha .03.
- floor: rect y 700..800 fill gradient #8a7a6a? Let's style modern: wall pale blue-gray, floor warm oak with horizontal planks. Puddle stands out blue.
- baseboard at 700, height 10 dark.
- Maybe shadow under tank.
- Light vignette.

`drawTankFrame()`:
- outer glass: rounded rect from tank.x,tank.y to w,h. Fill rgba(200,230,240,0.10), stroke rgba(255,255,255,0.55) 3, plus side wall thick translucent.
- top rim: rect tank.x-8, y-14, w+16, 14 with metal gradient.
- base: rect x-10, 700-12, w+20, 12 dark metal.
- corners.

Interior back: glass tint with reflection diagonal stripes clipped in inner rect.

Water: clip inner rect. Gradient vertical from rgba(70,170,215,0.45) top to rgba(20,90,140,0.8) bottom. Draw surface polygon with wave: sample 40 points y = surface + sin. Draw caustic arcs. Waterline dashed after.

Fish drawing: body ellipse rotated toward velocity, tail triangle wiggling, eye. Colors orange/gold/blue. Use `ctx.save translate rotate`.

Toy: rubber duck? draw duck-like: yellow body circle, head, beak, eye. Floating toy boat? Duck cute and shows rotation. Duck radius ~16. Good.

Plants: draw thick green stems as series of points; leaves as ellipses. Sway.

Rocks: gray rounded polygons with highlight.

Puddle: cells → path: start at left cell with h; build top polyline; fill down to floor; add highlight line. Clip to room walls.

Jet stream: draw a ribbon from hole using trajectory with current vx/vy and gravity. But particles also. Ribbon alpha follows Q. Width 12→4.

Jet particles: array {x,y,vx,vy,r,vvol,life}. Spawn based on Q. Update with gravity; if y>=floor -> land: puddle add volume at x, splash spawn, remove. If x>room.r-1 -> clamp x, vx=0. If x<... unlikely.

`addPuddle(x, vol)`: index by x; volume += vol*PUDDLE_SCALE maybe scale already baked.

PUDDLE_SCALE=0.16. Particle vvol sum = lost volume, so multiply by scale on landing. Good.

Leveling each frame, 2 iterations.

Puddle max height cap ~80 to prevent weird. No overflow handling.

Shards: on breach spawn 16: {x,y,vx,vy,a,va,w,h,shape,life}. Update: gravity if outside water; if inside water (x<inner.r && y<surfaceY) heavy drag + buoyancy? Glass sinks: gravity reduced by water, drag high. Collision floor y=700: restitution 0.35, friction, angular damping. Wall x limits. Draw as irregular triangle/quad with fill rgba(200,235,245,0.7), stroke white.

Breach triggering:
```
function breach(){
 if(state.mode!=='intact') return;
 state.mode='breaching'; state.breachT=0; spawn shards; 
}
```
Hole opening: 0.45s growth.
Surface lowering starts after growth maybe.

Crack drag:
- pointerdown in canvas coordinates.
- if mode intact and hit near (wallX±26, crackY±45) -> dragging=true.
- pointermove: crackY=clamp(py, 350, 650)
- pointerup dragging false.
- Also cursor.

Buttons: Breach disabled after breach; Reset always. Hint text.

Status HUD: water level percentage (relative to full tank inner height?), outflow. Use elements.

Reset: set everything from init (call resetScene) and state. Also reinit puddle.

Fish update details:

```
const speed = hypot(vx,vy)
// water presence
insideWater = fish.y > surfaceY+? 
flow = flowAt(fish.x,fish.y)
if escaped:
  // air
  vy += G*0.85*dt
  x+=vx*dt; y+=vy*dt
  vx*=exp(-0.4dt)
  a += va*dt
  if y > floor - size: land, bounce, flop flag
  clamp walls
else:
  if fish.y < surfaceY + size*0.8: push down (can't jump out)
  if fish.x > inner.r - size - 2 && ... wall: if near hole and inside hole band and Q>... then escapedFlow=true (set x=inner.r+6, vx=jetSpeed*0.6, vy=...) else clamp x and vx=-abs(vx)
  // thrust
  let desired = wander(direction)
  if flowMag > 40: desired = opposite flow direction (against current)
  fish.vx += (desired.x*swim - fish.vx)*2.2*dt? 
```
Hmm to allow current dominate, model: relative velocity damping toward water velocity. 
```
const k=2.8;
fish.vx += (flow.x - fish.vx)*(0.6+flowMag/220)*dt*? 
```
Let's formulate:

accel = thrust (toward desired dir, magnitude strength) + drag*(flow - v). With drag coefficient 1.2/s. If flow=300 and thrust=90, equilibrium relative -... v approaches flow minus thrust/drag -> 300-75=225 downstream while swimming upstream. Fish near hole will be swept. Far where flow ~50, fish net swims against current easily. This is good, but fish may drift to hole fast: 225 px/s from x 400 -> 1.7s. It's okay, some swept out. Fish weak: lower thrust 60 and drag 1.4 -> more swept; strong: thrust 130, drag 1.8 -> can hold.

Wander when flow low: desired angle slowly changing; speed 40.

Fish must not go below bottom: clamp y and vy, and keep within. Fish y min surface+12 (they can approach surface).

which fish swept: depends. Ensure at least two fish start within 200px of hole for likely sweep. Positions: (620,360),(700,430),(560,500),(420,330),(500,560),(660,600),(340,430). Hole x=785,y~470. Fish at 700,430 and 660,600 likely exit. Good.

Once fish crosses x>inner.r (through wall) set escaped & in air. Place x=inner.r+12. Give vx=jetSpeed*0.8.

Toy: similar to fish but buoyant. Toy inside:
```
targetY = surfaceY - 10
vy += (targetY-y)*4*dt // spring
toy.vx += (flow.x - toy.vx)*1.6*dt
toy.vy += (flow.y - toy.vy)*0.6*dt
toy.vy *= drag
```
When surface falls below? Toy floats down with waterline, then if waterline reaches hole top and toy near hole -> not escape because no water. It could get stuck at hole? Let's still allow toy to be carried out only when surface > holeTop and x near hole. If not, toy remains inside floating at low water (sits on bottom if water shallow). Good.

Toy escape check near wall: if x > inner.r - 18, |y-holeY|<holeH/2 and surfaceY < holeY - 6 -> escape with flow. But toy floats at surface; if surface is at 420 and hole top 438, toy center y=406, distance to hole center 64 >32 so not within hole. Hmm toy would need to be pulled under. Since current pulls horizontally and slightly down (flow toward hole center may point down if hole is lower). At toy y=surface-10=410 and hole center 470, direction has downward component, so toy dips a bit. Could still not align. To make carry-through possible, define exit when toy right edge reaches wall and y within [holeTop-20, holeBottom+10] and surface > holeTop+5, and nudge vy downward when very near wall. Fine. The toy is 14 radius; as it approaches wall at surface 300 it's well above hole 438. It will float at surface. To escape via hole below surface, it must be submerged. Realistically floating toy wouldn't exit submerged hole unless water level falls. Options: toy stays floating and escapes if the waterline reaches hole (but by then it stops). Requirement says movable objects that fit can be carried out, not necessarily the toy. Fish are movable and get carried out. Toy floats — required "the toy floats". So no need toy escape. Keep toy inside floating; if the water level falls below it maybe rests on bottom. But puddle toy? Not needed. Still implement escape for toy under current: near the hole, the flow bends downward; give toy extra downward force to be pulled through if within 60px of wall and |surface-hole|<... Eh, might be nice. But priority: correct float behavior.

Actually water drains to hole top = 438; toy floating at 424 near surface. At the wall, its lower half (424+14=438) would be at hole top; flow near wall could pull it out. We can allow toy escape if center y within holeTop-20..holeBottom and surface >= holeTop, i.e., y 418..534. At surface 430, toy center 416; close. Let's set threshold holeTop-24. Then toy may exit around the end. But does it get to wall? Current drag 1.6/s with flow up to 200 -> reaches over ~3s from 600. yes likely. Then toy carried out, drops, lands on puddle and floats. Nice. Let's implement with a condition that requires surfaceY > holeTop - 8. 

But toy floating at surface when surface is below hole top and then it's just stuck. Fine.

Puddle floating: toy in air after escape; gravity; when y > floor - h - toy.r -> float and apply damping; bobbing. Also fish on floor.

Pebble dynamic: {x,y,vx,vy,r,rot} with buoyancy negative (sinks), flow force small, floor friction. It stays mostly.

Rocks possibly get displaced? Keep static 3 rocks + pebble.

Now buoyancy/drag modeling: fish, toy, rocks with density values. Good.

Water current field toward hole also should affect plants: plant bend target from flow at segment.

Water current should exist only after breach and while Q>0. Also add small ambient current? No.

Inside-water drag for jet? Jet particles outside.

Glass shards inside water drag: if shard.x < inner.r && shard.y < surfaceY && shard.y > inner.t: apply strong drag, gravity reduced.

Splashes: {x,y,vx,vy,life} small droplets, gravity, die on floor.

Bubbles: from rocks and plants rising; reset.

Crack drawing: jagged zigzag line from y=cy-34 to cy+34 at x=wallX (785) with points alternating ±5. Add branches. Handle: circle 11px at (785, cy) with double arrow icon? Draw a small pill "≡" maybe. Let's draw circular knob with two chevrons up/down. Cursor grab.

Hint: "Drag the crack ↑↓ then press Breach" displayed in HUD.

Also when dragging crack, maybe show ghost hole outline? Not necessary.

Now verify: use browser screenshot to check visuals, then tweak.

Time budget 15 min. Let's write the file now, sizable (~900 lines). Be efficient.

HTML with HUD:
```html
<div class="stage">
 <div class="frame"><canvas id="c" width="1200" height="800"></canvas></div>
 <div class="hud top">...</div>
 <div class="controls">...</div>
</div>
```
Position HUD inside stage via absolute top-left; stage is exactly canvas size using width min(100vw, 150vh) and aspect-ratio 3/2. Use container `.stage{position:relative;width:min(100vw,150vh);aspect-ratio:3/2;}` with canvas width/height 100%.

HUD styling: top-left title panel, controls top-right.

Title: "AQUARIUM BREACH SIM" small label, plus meters below? Put status readouts in a bottom-left chip: "WATER 84% · OUTFLOW 12 L/s". Better top-left compact panel with title and hint. Top-right buttons.

Ensure buttons pointer events; canvas receives pointer events; HUD pointer-events none except buttons.

Let me write JS carefully.

```js
const c=document.getElementById('c'), ctx=c.getContext('2d');
const W=1200,H=800;
const G=1250;
const room={l:60,r:1140,floor:700};
const tank={x:235,y:185,w:550,h:515,wall:10};
const inner={l:245,t:195,r:775,b:690};
const INIT_SURFACE=290;
const CRACK_MIN=352, CRACK_MAX=642, CRACK_DEF=470;
const HOLE_H=64;
const WIDTH=inner.r-inner.l; //530
```

State variables:
```js
let surfaceY, Q, mode, crackY, breachT, holeGrow, lossAcc, jetAccum, time, shaking...
let fish, plants, rocks, shards, jets, splashes, bubbles, puddle, toy, pebble;
```

helper rand(a,b), clamp, lerp.

`initScene()` sets all. Called on load and reset.

Plants: create points with base x and segments 8; store angles array and lengths. Implementation per plant:
```
plants.push({x, h:..., n:8, phase, hue, angles: new Array(n).fill(0), lengths:...})
```
Update: compute flow at tip; each angle target = bend based on flow + sway; use spring smoothing:
```
for i: target = clamp(flow.y? ... )
```
Simplify: compute a single bend angle applied progressively:
```
const fl = flowAt(baseX, bottom-120)
const bendTarget = clamp(fl.x*0.0016, -0.5,0.5) ... plus wave
plant.bend += (bendTarget - plant.bend)*3*dt
plant.phase += dt
points: start base; each segment angle = base lean + plant.bend*(i/n) + sin(time*1.3+phase+i*0.5)*0.05
```
Leaning overall. Plant root fixed. Flow direction to the right -> plant.x points right? angle measured from vertical; x += sin(angle)*len, y -= cos(angle)*len. bend positive -> sin positive -> right. Good. Bend target = clamp(flow.x * 0.0012, -0.7, 0.7) plus turbulence.

Also leaves.

Rocks static: define 3 shape point arrays generated via seeded rand. Keep one big at (350,660), medium (600,655), small (520,675). Each with points around ellipse, irregular. Store `pts`. Draw with gradient.

Pebble dynamic at (430,676), r=9.

Fish drawing helper.

Flow field:
```js
function flowAt(x,y){
  if(mode==='intact' || Q<=0) return {x:0,y:0,m:0};
  const hy = holeCenterY();
  const dx = tank.x+tank.w - x, dy = hy-y;
  const dist = Math.hypot(dx,dy)+1;
  const under = clamp((surfaceY - y)/50+1,0,1); // 1 if below surface? toy at surface
  const sub = Math.min(1, Math.max(0,(hy+HOLE_H/2 - surfaceY)/HOLE_H));
  const speed = (Q>0? Math.sqrt(Math.max(0,hy-surfaceY))*1.1 : 0) * Math.exp(-dist/210) * sub;
  ...
}
```
Hmm use jetSpeed (set when calculating Q): store `state.jetSpeed = 0.55*Math.sqrt(2*G*depth)`; flow magnitude = jetSpeed * exp(-dist/230) * (0.4+0.6*sub) maybe; also vertical gradient: stronger near hole.

Make flow calmer far: exp(-dist/170). At dist 200 -> 0.31. Toy 150px away gets ~100 which is enough to move with drag 1.6 (equilibrium v=flow). Good.

Direction toward hole. Add slight horizontal bias so it isn't weird: normalize(dx,dy*1.2).

Also only within tank x < wall.

`holeCenterY()` = crackY.

Hole extents: top=crackY-HOLE_H/2, bottom=crackY+HOLE_H/2.

Q computation:
```
const submerged = clamp(Math.min(inner.b, holeBottom) - Math.max(surfaceY, holeTop),0,HOLE_H)
const depth = holeCenterY - surfaceY
if(mode==='breached' && submerged>0.5 && depth>0 && holeGrow>=1){
  const v = Math.sqrt(2*G*Math.max(depth,0));
  Q = 0.36 * submerged * v;   // px²/s
  jetSpeed = 0.6*v;
} else Q=0;
surfaceY += Q*dt/WIDTH;
if(surfaceY > holeTop-0.5 && submerged<=0.5) -> stop (Q 0)
```
Use holeGrow for ramp: multiply by holeGrow.

Note as surfaceY approaches holeTop, submerged→0, Q→0.

Total volume lost displayed? status: water level % = (inner.b - surfaceY)/(inner.b-INIT_SURFACE).

Spawn jets: `jetAccum += Q*dt / 320;` while >=1 spawn.

Spawn particle at x = tank.x+tank.w+3 (788), y random within submerged part [max(surfaceY+4,holeTop+2), min(holeBottom-2, surfaceY+?)] Wait jet exits below water surface; use intersection of hole and water: y between max(holeTop, surfaceY+2) and holeBottom. vx = jetSpeed*(0.8+0.4rand) ... vy = (random -0.15)*20 + 20? Gravity curve.

Particle y also should be in the hole vertical. good. r=2..4.5.

vvol = (Q*dt)/spawnedThisFrame maybe; simplify vvol = 320 (constant) since spawn rate derived from Q, conservation approximate. Then puddle gets total = sum 320 per particle ≈ Q dt. Good, use PUDDLE_SCALE 0.17.

Gravity on particles G. Lifetime until floor.

Ribbon trajectory: draw using jetSpeed and hole center, with t up to 0.9s, points. Fill ribbon shape via lines with varying width. Use ctx globalAlpha proportional to Q.

Puddle add volume: `puddle.v[i] += vol*PUDDLE_SCALE` with cell index clamp. Also add a bit of slosh? Leveling.

Puddle draw: total height array. Heights h[i]=v[i]/cellW. Draw with smoothing. Max cap optional for drawing only min(h, 90).

Fish escape mechanics when near wall:
Inside update, if fish.x > inner.r - fish.size*0.8:
```
const within = Math.abs(fish.y - holeCenterY()) < HOLE_H*0.45;
const hOk = surfaceY > holeTop - 10;
if (within && hOk && Q>200) {
   fish.escaped=true; fish.x=inner.r+8; fish.vx = jetSpeed*0.85; fish.vy=30+Math.random()*40;
} else { fish.x = inner.r-fish.size*0.8; fish.vx = -Math.abs(fish.vx)*0.4; }
```
Also for fish that pass through, maybe add rotation.

Fish escaped update:
```
vy += G*0.9*dt; x+=vx*dt; y+=vy*dt; angle = atan2(vy,vx); rot = ...
drag air: vx *= exp(-0.25dt)
if (x>room.r-10){x=room.r-10;vx*=-0.2}
if (y > floor - size*0.5) { y=...; if(vy>40){vy*=-0.35; splash} else vy=0; vx*=0.9; onGround=true; flop timer}
if(onGround) { vx *= 0.95; wobble rotation; y = floor - size*0.45 - abs(sin(t*6))*2? }
```
Fish flop with small hops for 2s.

Water inside: clamp fish.y between surfaceY+10 and inner.b - size. If waterline falls below fish, fish gets exposed? Water drains only to hole top 438, fish below that remain. Fish near surface clamp down as surface falls. Fine.

Toy:
```
if(!toy.escaped){
 // buoyancy spring to surface
 const target = Math.min(surfaceY - 8, inner.b - 20);
 toy.vy += ((target - toy.y)*7 - toy.vy*2.2)*dt;
 toy.vx += (flow.x - toy.vx)*1.4*dt + ... small
 toy.x += vx*dt; toy.y += vy*dt
 clamp x inside; bounce; y clamp to inner bounds
 // escape
 if(toy.x>inner.r-14 && surfaceY < holeBottom-6 && Math.abs(toy.y-holeCenterY())<HOLE_H*0.65 && Q>300) escape
}
```
Toy initially at x=600 y=surface-8. With flow, drifts right. Toy buoyancy spring strong to surface; current has downward component near hole can pull underwater slightly. fine.

Escape toy: set escaped, gravity, bounce floor, then floating on puddle:
```
if y > floor - puddleH - 12: y=...; vy = -vy*0.15; vx damping; bob
```
puddleH at toy.x.

When puddle shallow, toy sits on floor.

Shards spawn:
```
for i<18:
 const side = random < .75 ? 1 : -1  // outward
 x = 782 + rand(-8,4)
 y = holeCenterY() + rand(-HOLE_H/2-8, HOLE_H/2+8)
 vx = 60 + rand(0,180) + (side>0?150:0)? 
```
Most fly right/down onto floor. A few fly inward and sink. Shapes as triangles with vertices.

Shard update:
- inWater if x < inner.r-2 && y < surfaceY and y > inner.t
- gravity: if inWater vy += G*0.25*dt else vy += G*0.85*dt
- drag in water: vx*=exp(-3dt), vy*=exp(-2dt)
- air drag small.
- x+=vx, y+=vy; rot += va; va scaling.
- floor: if y > floor - h/2: y=...; vy *= -0.35; vx*=0.6; va*=0.6; if abs(vy)<30 vy=0.
- walls: left room wall? shards spawn at 787 so no.
- glass wall collision? skip.

Collide glass? skip.

Crack hit test region includes x between 755 and 800, y ±50.

Now draw crack with animation subtle pulse.

Waterline label: "WATERLINE" dashed to left? maybe unnecessary.

HUD metrics update each 0.1s:
- level bar width.
- outflow value: Q*0.02 display "L/s" maybe scale: Q in px²/s ~15000 -> show (Q/600).toFixed(1) => 25 L/s.
- status text: "INTACT" / "BREACHED".

HUD design: compact dark glass panel overlapping top-left inside canvas:
```
<div class="hud">
  <div class="brand"><span class="dot"></span> AQUARIUM BREACH</div>
  <div class="sub">Drag the crack on the right wall, then breach.</div>
  <div class="meters">
    <div>WATER <b id="lvl">100%</b></div>
    <div>OUTFLOW <b id="out">0.0</b></div>
  </div>
</div>
```
Top right buttons: Breach, Reset. Buttons style.

Maybe an instruction pill near crack? Add canvas-drawn label "DRAG CRACK" with arrow when intact & !dragging, fading after 8s. Canvas label near crack, helps verification.

Now write code. Let's be careful with context clipping and z-order.

Detailed draw functions:

drawBackground:
```
const wallGrad = ctx.createLinearGradient(0,0,0,700);
stops '#eaf3f7','#d7e5ec','#c8d9e2'
fillRect(0,0,W,700)
// subtle stripes
for x every 60: fillStyle rgba(255,255,255,0.06) rect
// spotlight radial from top
```
Floor: gradient '#7d6b58' to '#5b4d3f'? Warm wood. Add planks lines every 48 along y? side view floor: horizontal surface plane not perspective. Just floor band y=700..800 with vertical plank lines with slight perspective? Simple dark wood with horizontal grain lines. Baseboard: rect 0,690,1200,10 white-ish.

Wall-floor junction shadow.

Tank shadow ellipses.

`drawTankBack()`:
- inner rect fill rgba(210,238,246,0.18)
- diagonal reflections broad.
- glass edge highlight line.

`drawWater()`:
clip inner rect.
compute surface wave points (x from inner.l to inner.r step 10): y = surfaceY + sin(x*0.02 + time*1.2)*1.8 + sin(...)*1.
Path from (l,surface) along wave to (r,surface) down to bottom corners.
Fill gradient.
Add subtle rays: translucent polygons moving? skip or simple.
Draw surface highlight stroke rgba(255,255,255,.6).
When breached and hole submerged, draw suction dark streaks near hole inside? Could add small lines pointing to hole. Nice: draw 6 short curved streaks with alpha related Q.
Restore clip.

Note if surfaceY >= inner.b (not happening).

`drawInteriorObjects()`: rocks, plants, toy, fish. Clip to inner rect for inside ones.

Order: rocks/plants first, then toy, then fish (fish in front). Clip.

Toy bubble etc.

`drawFrontGlass()`:
- vertical side walls translucent, top/bottom rims with metallic gradient.
- glass reflections: two diagonal parallelograms opacity .08.
- outer border stroke.
- draw breach hole: cut wall. To simulate, first the right wall as a whole is drawn. Around the hole, erase? Easier: draw right wall in two segments (from inner.t to holeTop-8) and (holeBottom+8 to inner.b), and the base/rim continuous. When intact, full wall.
Need also the outer glass border stroke broken at hole. Draw outer rounded rect stroke? If stroke continuous it will cross hole. Use manual path for right edge segments. Simpler: draw rest of frame without right edge, then draw right edge segments.

Let me implement frame with lines:
- left wall: rect tank.x..tank.x+10 full height with gradient.
- top rim and bottom base.
- right wall segments around hole if breached.
- top/bottom inner border lines.
- glass highlights.

Top rim rect (tank.x-6, tank.y-14, tank.w+12, 14) metal gradient; bottom base rect (tank.x-8, 700-10, tank.w+16, 10).

Actually tank bottom 700, floor 700. Base at y 690..700 overlapping inner bottom 690. Base rect y 690 height 10. Wall bottom ends 690.

Right wall from y 195 to 690: segments.

Hole: draw jagged outline polygon around opening x from 772..790 (wall) spanning randomized edge. Fill with dark interior? The hole should reveal room behind (not water?) Actually the hole in the side wall shows water pouring out with edges. Draw hole as dark/blue gradient and cracks.

Since water inside is behind the front glass? The hole is in the right wall (side perspective), draw water jet emerging. Draw hole fill with water color gradient (since tank interior water visible through opening). Then jagged white glass edge.

Fragments spawn.

Hole grow factor scales height: h = HOLE_H * easeOut(holeGrow) maybe width too.

Cracks around hole: draw jagged radiating lines from hole corners outward up to 50px.

Crack (intact) drawn at wall with glow and grab knob.

Draw "DRAG" tag: small text near crack with arrow ↕ at x=820, y=crackY maybe outside tank; text style. Only if intact and time<12 and not dragging. Actually keep until breach. "DRAG ↕" in small pill. This overlaps the puddle area but fine.

On breach remove crack, show cracks.

`drawPuddle()`:
- total heights from volumes. Build polygon for wet cells. Fill gradient blue alpha. Surface highlight.
- Add edge wet streaks; maybe puddle under tank hidden? drawn on top.
- Add reflections/waves: sin.
- Clamp heights max 90 for draw.

Puddle volumes leveling in update: iterate 2 times over cells; handle boundaries with walls (no exchange outside => constrained by walls naturally). Exchange: 
```
for i in 0..N-2:
  const diff = h[i]-h[i+1];
  if(Math.abs(diff)>0.01){
    const f = diff*0.10; // height units
    // convert to volume: cellW*f*0.5
    const v = f*cellW*0.5;
    vv[i]-=v; vv[i+1]+=v;
  }
```
Wait check stability: each pair exchange half the height difference scaled by 0.10 → small. Use 0.35 coefficient: v = diff*0.35*cellW*0.5. With 120 cells, diffusion spread speed. Need puddle to spread enough over ~10s. Coeff 0.4 per pair per frame at 60fps would be huge. Use per-frame coefficient 0.08 to be stable and spread reasonably: characteristic diffusion over 120 cells... 0.08*0.5 = 4% per frame of difference, spreads quickly. Fine. Also clamp h >= 0.

At draw compute h[i]=vv[i]/cellW; smooth for shape.

Also puddle surface should settle flat eventually.

`drawJet()` and particles.

`drawShards()` after jet.

`drawBubbles()` inside clip.

`drawEscaped()` — escaped fish & toy after puddle.

Status UI update.

Now fish initial placement must ensure no overlapping rocks badly. Fine.

Let me code now. I'll write the whole file then test.

Potential issue: hole near bottom (crack max 642, hole bottom 674 > inner.b? 674 < 690 fine).

Hole default 470, depth 180 → jet.

Fisher update thrust: define in init strength 0.7-1.2.

Compute flowMag. Fish desires:
```
const flow = flowAt(f.x, f.y);
const fm = Math.hypot(flow.x, flow.y);
if (fm > 30) {
  const inv = 1/fm;
  desired.x = -flow.x*inv*120; desired.y = -flow.y*inv*120 *0.6;
} else {
  const a = f.wander + Math.sin(time*0.7+f.phase)*0.5; desired = cos/sin * 55
}
const thrust = f.strength*120;
let ax = desired.x - f.vx; ... normalize to thrust
f.vx += (flow.x - f.vx)*1.6*dt + ax*? 
```
Do:
```
const relx = flow.x - f.vx, rely = flow.y - f.vy;
f.vx += relx*1.8*dt;
f.vy += rely*1.8*dt;
// add thrust:
const len=hypot(dx,dy); f.vx += dx/len*thrust*dt; ...
```
With flow 250, drag 1.8 → equilibrium slip 139 while thrust upstream 120. Hmm strong fish nearly holds. Weak thrust 70 → slip 167. Both drift downstream near hole. Fish far flow 50 → thrust 70-120 upstream wins. Good. Fish not escape from other walls.

But fish velocity must be capped maybe 600.

Wander target changes slowly when no flow.

Also fish rotate to velocity. Tail wiggle.

Fish positions update; if outside water surface (shouldn't) clamp.

Fish on floor outside: draw rotated horizontal, flop by rotating around body; y = floor - size*0.45 - hop.

Draw fish function with options for color and size, angle, wiggle; body ellipse length 30-44, height 14-20.

Plants chain draw: compute points each frame in update or draw. Do in draw using stored bend & time.

Bubbles: spawn from rock positions occasionally; rise at 20-40 px/s + wobble; pop at surface; if surface falls below bubble y, remove. Draw clip.

Now glass shards and water drag.

Let's implement. Also add `visibility` handling maybe no need.

Canvas sizing: 1200x800 fixed; add slight DPR? At 1200 wide screenshot exact, no need. But set canvas width 1200 height 800 and CSS fits.

We'll use requestAnimationFrame with dt clamp 0.033.

Now write file.

For pointer coordinates:
```
function toCanvas(e){ const r=c.getBoundingClientRect(); return {x:(e.clientX-r.left)*1200/r.width, y:(e.clientY-r.top)*800/r.height}; }
```
Pointer events on canvas, setPointerCapture.

Cursor style update on move when intact.

HUD buttons:
```
<button id="breachBtn">BREACH</button>
<button id="resetBtn">RESET</button>
```

For accessibility and clarity.

Let's write.

Draw hole and crack details.

`drawCrack()`:
```
if(mode!=='intact') return;
const x=tank.x+tank.w; // 785
const cy=crackY;
const pts=[];
for (k=0;k<=12;k++){ const y=cy-36+k*6; const xx=x+((k%2)?3:-3) + Math.sin(k*2.1)*2; pts.push([xx,y]); }
stroke rgba(255,255,255,.9) width 4 then rgba(30,60,80,.75) width 2.
branches from midpoint.
glow circle at (x,cy) r=16 rgba cyan .2
knob: circle r=10 at (x, cy) fill rgba(10,40,55,.55) stroke white; chevrons.
```
Knob on top of crack. Since wall x=785 is at tank edge, knob extends inside/outside. fine.

Hit region x 740..830, y cy±48.

Drag bounds: CRACK_MIN=360, MAX=645.

`holeGrow` eased.

Q jet and waterline: note water surface can fall below crack top but still some water until surface reaches crack top? Physics: water drains until surface at *top* of hole? In reality when surface falls below top of hole, opening partially exposed; outflow continues with decreasing head until surface at bottom of hole? Wait through a side opening, water exits until the water level drops to the bottom edge of the hole (hole becomes fully above water -> stops when surface reaches bottom of hole, not top). I earlier said top: outflow stops when waterline reaches the *bottom*? Let's think: hole spans y [top,bottom]. Submerged height = bottom - max(top, surface). As surface approaches bottom, submerged→0. So water stops at level bottom. Yes stops at hole bottom (lower edge). I mistakenly wrote holeTop. Depth = center - surface becomes negative before that; use depth to lower submerged centroid. So water drains until surface = hole bottom (674 for default crack!). That means tank drains a lot (surface from 290 to 674). Hmm then toy/fish near bottom? That's a lot of water; puddle volume 212k*? all out. The requirement "outflow weakens as the water level approaches the opening and stops when water no longer reaches it" fits.

Depth to use: centroid of submerged area = (max(surface,top)+bottom)/2 => depth = centroid - surface = (bottom - surface)/2 when partially... use:
```
const top2 = Math.max(holeTop, surfaceY);
const sub = holeBottom - top2; // >0
const head = Math.max(0, (top2 + holeBottom)/2 - surfaceY); // distance from surface to centroid
Q = c * sub * sqrt(2G*head)
```
Then Q→0 as surface→holeBottom. This drains until surface at hole bottom. The hole top is where crack center -32. Default 470 → hole bottom 502. Surface stops at 502. Water level % ~30%. Drains 212k*? volume from 290..502 = 112k. Time ~10s. Toy floats down and might not be at hole... if surface reaches 502, toy floats at 494 near hole center; then gets pulled out? The water stops at 502 (hole bottom) meaning no flow beyond. Toy likely exits earlier.

Hmm, wait, in 2D side view the crack at right wall; waterline falls to bottom of crack. That's physically right.

But "outflow weakens as water level approaches the opening and stops when water no longer reaches it" exactly.

For water level to fall noticeably early, yes Q high enough.

Set coefficient 0.5? Initial sub=64, head = (438+502)/2-290 = 180 → sqrt(2*1250*180)=671 → Q=0.4*64*671=17180. Surface rate 32 px/s. Noticeable. Total drain time with decreasing: rough ∫ maybe 12s. Good.

Jet speed v = 0.55*sqrt(2G*head) = 0.55*sqrt(450000)=369. Good.

Puddle volume delivered total= lost volume * scale 0.16 = 112000*.16=17920 over 1080 width = 16.6 px avg. If localized near breach initially maybe 40 px. Can increase scale to 0.3 → 31 avg, deeper near breach 70. Let's use 0.28. Also restrict puddle spread speed so it stays near breach early. Good.

For verification "sample early outflow": check jet curves downward: particle vx=369 with G=1250: after 0.4s dy = 0.5*1250*.16=100px, dx=148. Slope steep. Good.

But note the puddle drawing: if max height 31px average, looks like thin layer; near impact local 70px. Fine.

Fish caught near hole at x~700 may exit quickly. Good.

Water surface waves should not look odd at low level.

Implement.

Also add `state` no need.

One issue: fish swimming inside but clipping to tank; when fish at right boundary near hole but not exactly hole band, clamp.

Let's write. Then test with browser screenshot.

Also expose debug info in window for testing? Could set `window.__sim = {...}` to inspect state for verification (e.g., jet particles). Helpful for automated check via browser inspect? Browser tool only screenshot/inspect DOM/console. I can add a hidden debug element or window variable and use inspect? The browser tool actions: inspect, console etc. I can add console logging maybe. Simpler verify visually.

Add `<div id="dbg">` hidden? Could update HUD with water level, enough.

Let's write the code now.

I need to be mindful of code length but fine.

CSS:

```css
*{box-sizing:border-box}
html,body{margin:0;height:100%;background:#0a1118;font-family:'Segoe UI',system-ui,sans-serif;overflow:hidden}
body{display:grid;place-items:center}
.stage{position:relative;width:min(100vw,150vh);height:min(66.6667vw,100vh);...}
```
Aspect: canvas 1200/800=1.5. width = min(100vw, 150vh); height=width/1.5. Use `.stage{position:relative;aspect-ratio:3/2;width:min(100vw,150vh);}` height auto via aspect ratio. Body grid center.

canvas{width:100%;height:100%;display:block;border-radius:14px;box-shadow:...;cursor:default}

HUD:
```
.hud{position:absolute;left:22px;top:20px;background:rgba(8,22,32,.72);backdrop-filter:blur(8px);color:#dff4ff;padding:14px 16px;border-radius:14px;border:1px solid rgba(120,200,230,.25);pointer-events:none;width:270px}
```
Since canvas scales, HUD in CSS px doesn't scale with canvas; at 1200 wide it's fine. At smaller viewport ok. Use vw? Keep px.

Controls top-right with buttons.

Bar: water level meter with inner fill.

Buttons: Breach orange gradient, Reset outline. disabled states.

Responsive text.

Now code.

Puddle drawing smooth: use heights array, iterate cells and draw path with midpoint smoothing. Fill to floor. Use two layers: main fill gradient from rgba(80,170,210,.55) to rgba(30,100,150,.7); surface line white alpha.

Also puddle reflection of tank? skip.

Physics object floor collision with puddle: escaped fish lands on floor 700, drawn over puddle (top of puddle maybe 690) so appears lying in puddle. Good.

Now writing.

For flow near bottom plants: plants rooted at 690; flow at y 600 distance to hole ~200 → 0.3*369=110 → bend target = 110*0.003=0.33 rad moderate. Good.

Flow current visualization inside tank: draw few semi-transparent streaks moving toward hole when Q>0, clipped. Optional nice: use 12 dots with positions, move along flow; reset when reaching hole. Let's add "current motes" for visible current response. Dots update by flow*dt, respawn random. Draw with low alpha. This makes current visible. Add array currentDots with random positions inside water, each frame move by flow*dt*0.7; if near hole or outside -> respawn. Only when Q>0.

Be careful no unneeded complexity.

Now the main loop order:
```
function update(dt){
 time+=dt;
 if(mode==='breached'){ holeGrow=Math.min(1,holeGrow+dt/0.5); compute drain; spawn jets; }
 updateJet(dt); updatePuddle(dt); updateFish(dt); updateToy(dt); updateShards(dt); updateBubbles(dt); updateCurrentDots(dt);
}
```
Order puddle before draw. Fish before draw. Add `if(mode==='breached')` compute Q includes holeGrow.

Hole grow affects Q starting 0→.

Trigger: mode 'breached'; breachTime=0; spawn shards; clear old jets.

The panel breaking show flash: `flash` variable 1→0 over .3s draw white overlay around hole? Add screen shake? Slight shake first 0.4s maybe subtle (canvas translate) — can complicate pointer mapping but only visual 1-2px. Add `shake=8` decays; ctx.save translate random; skip HUD. Fine but pointer map unaffected. Keep small.

Update all times with time even intact for idle.

In intact mode, water surface gentle waves; fish swim; toy bobs; plants sway.

Now code writing. I'll build in one go.

Fish draw: 
```
function drawFish(f, inWater){
 ctx.save(); ctx.translate(x,y); ctx.rotate(f.angle + (f.escaped? Math.sin(time*8)*0.15: 0));
 const s=f.size;
 // tail
 const wag = Math.sin(time*(f.escaped?18:10)+f.phase)*0.5;
 ...
 body gradient ellipse; fin; eye
}
```
Use colors: body `hsl(hue 80% 55%)`, lighter belly.

Duck draw:
```
ellipse body yellow, head circle, beak orange, eye black
```

Rock draw with gradient; stable.

Plant draw: stems with leaves.

Now the breach hole drawing:

```
function drawHole(){
 if(mode!=='breached') return;
 const hh = HOLE_H * easeHole;
 const top = crackY - hh/2, bot = crackY+hh/2;
 const wx = tank.x+tank.w; // 785
 // hole dark opening revealing water/room
 ctx.save();
 const g = ctx.createLinearGradient(wx-10,crackY,wx+10,crackY);
 g.addColorStop(0,'rgba(20,70,95,0.75)'); ...
 ctx.beginPath();
 // jagged aperture shape
 ...
 fill
 // inner water sheen
 // glass edge
 stroke
 // radial cracks
 ctx.restore();
}
```
Aperture: polygon points: (wx-7, top), (wx+3, top+7), (wx+1,top+18), (wx+9, bot-14), (wx-3, bot), (wx-7, bot-8), (wx-9,top+22)... hmm draw a jagged closed polygon spanning wall thickness. Then draw cracks radiating up/down along wall.

Right wall segments drawn before hole. If hole height animating, wall gap is hh. Draw wall segments accordingly.

Wall right draw:
```
const gapTop = crackY - hh/2, gapBot=...
fillRect(wx-10, inner.t, 10, gapTop-inner.t)
fillRect(wx-10, gapBot, 10, inner.b-gapBot)
```
But also outer frame extends from tank.y to tank.y+h = 700; inner region 195..690, rim. Use wall from tank.y to 700, gap only when breached. Segment top: tank.y .. gapTop; bottom gapBot .. 700.

Then top rim/base drawn afterwards covering.

Okay.

Water jet ribbon compute ballistic and draw; ensure it appears from hole center and in front.

Jet particles also draw circles with trail? Use small circles alpha .55.

Splash drawing: small arcs.

Escaped fish/toy drawn after puddle.

Shards after puddle too.

Bubbles inside clip drawn in interior.

HUD updates.

Debug: add `window.sim` object exposing surfaceY, Q getters, mode, crackY, jet count for possible console inspection. We can use browser evaluate? The browser tool has no evaluate action, but inspect may return DOM and console? The inspect action likely gives console logs/DOM. I can log initial states and occasionally? Better not spam. I'll rely on screenshots and HUD.

Let me now write.

Careful with `ctx.ellipse` support fine.

The hole's opening only affects right wall; objects pass at x>inner.r.

Crack center default 470.

Collision fish: fish size is half-length maybe. Use f.r=12.

Implementation details for fish positions:

```
const fishDefs=[[330,380,28,hue],[420,560,32],[520,340,25],[610,520,30],[680,400,26],[700,600,24],[560,620,22]];
```
Fish y all >surface+.

Fish swim wander direction.

On breach flow near 680,400 strong: dist from (785,470)=114 => exp(-.67)=0.51*369*sub(1)=188. Fish with thrust 100, drag equilibrium slip 188 - 55 = 133 downstream -> swept in ~1s. Fish x 700,600 dist 155 → 175. swept maybe. Good.

Fish that are swept will hit wall within 1-2 s. The verify expects fish "initially swim against current before some are swept" — they do point upstream briefly. To make more dramatic, maybe reduce drag coefficient near wall so they fight a bit longer. With thrust and current, they visibly face left while drifting right ~1-2 s. Good.

Toy from x=600 to wall 175px with flow maybe 150 and drag 1.5, drift speed ~... equilibrium = flow since no thrust = ~150 px/s -> 1.2s. Might exit before waterline falls much. Fine.

Current dots: 40 inside tank, move toward hole speed*0.5. Render small dashes.

Now puddle and Q conservation: jet particles landing adds to puddle. Some particles may still be in flight when simulation stops. fine.

Puddle total height from 112k*0.28=31k/1080=29px avg. Good. Wait 0.28 factor means 28% of 2D cross-section area. visually fine.

Puddle ionization when waterline stops exactly at hole bottom (502): tank still has water below 502. Fish below hole could still swim in remaining water (bounds surfaceY=502). Objects above hole exposed? Toy floating at surface 494; hole top 438..bottom 502; toy at 494 inside hole band, may be pulled out with remaining flow. Eventually stops.

When Q=0, toy remains floating at 494 right next to hole; if it reached wall it likely escaped. If not, fine.

Let's code.

One more: draggable crack "visible crack vertically on one side below initial waterline" — default at 470, visible. On reset same. Good.

Reset must restore initial waterline etc. Also reset RNG not necessary.

Write file now.

I'll be careful about `state` variable naming collisions (state.mode). Use globals `mode`, `crackY`, `surfaceY`, `Q`.

Let me write the JS fully.

```js
const cv = document.getElementById('c');
const ctx = cv.getContext('2d');
const W=1200,H=800;
...
let mode, surfaceY, Q, jetSpeed, holeGrow, crackY, time, dragging=false, shake=0, breachAge=0;
let jets, shards, splashes, bubbles, fish, toy, pebble, plants, rocks, puddleVol, currentDots, toast...
```

initScene:
```
mode='intact'; surfaceY=INIT_SURFACE; Q=0; jetSpeed=0; holeGrow=0; crackY=CRACK_DEF; time=0; shake=0;
jets=[];shards=[];splashes=[];bubbles=[];currentDots=[];puddleVol=new Float64Array(N);
fish = defs.map(...)
toy={x:600,y:surfaceY-10,vx:0,vy:0,escaped:false,onGround:false,rot:0}
pebble=...
plants=...
rocks=... static shapes
bubbles initial none
```
HUD reset text.

Update HUD on reset.

Rocks arrays define deterministic with fixed pseudo random seeded.

Let me create seeded RNG:
```
let seed=7; function rnd(){ seed=(seed*16807)%2147483647; return (seed-1)/2147483646; }
```
Use only in init for shapes so reset identical.

Now writing code. I'll aim for clarity.

Puddle leveling also maybe add slosh wave? Not needed.

Draw order precise:
```
ctx.clearRect
drawRoom();
drawTankShadow();
drawTankBack();
drawWater();            // clipped
drawTankInterior();     // clipped? rocks/plants/fish clipped to inner
drawGlassFrame();       // includes right wall gap + rim + reflections
drawCrackOrHole();      // crack knob / hole + cracks
drawPuddle();
drawJet();              // ribbon + particles + splashes
drawShards();
drawEscapedObjects();   // escaped fish/toy
drawLabels();           // drag hint, etc.
```
But escaped objects should perhaps be behind jet? drawn after puddle fine.

Fish escaped: only when outside. Inside fish drawn clipped in interior. Toy inside drawn in interior.

Draw interior with clip inner. Bubbles drawn there.

Current dots drawn clipped too.

drawGlassFrame right wall segments need hole info; crack section separate.

Reflections: diagonal stripes across glass after objects.

Now implement drawWater with hole suction streaks maybe skip.

Status: water % = (inner.b - surfaceY)/(inner.b - INIT_SURFACE)*100 clamp.

Outflow display = (Q/700).toFixed(1) maybe initial ~24.

At intact display 0.0 L/s.

Breach button disabled when breached; text changes to "BREACHING". Reset label "RESET".

Add hint text update: intact: "Drag the crack ↕ · Press Breach"; breached: "Outflow stops when water drops below the opening.".

Let's write.

Now run in browser.

Initial render looks good, but the tank seems shifted: The right wall at x~790 in image coordinates? The screenshot is 1200x800 rendered at 1200x800. The tank drawn from x=235 to 785; in image it appears from 243 to 785? Wait tank left wall visible at ~243 and the tank top rim from 233 to 808? Actually image shows tank going from x~243 to 786 (water). Hmm the water looks like it spans 245..775 and glass right wall at 785. But screenshot shows the tank top rim ending at ~790 and water right edge ~775. Looks fine. However the tank extends below to y=700, and glass left/right walls appear as thin lines. Looks nice.

The crack appears as a zigzag at x=785 with DRAG CRACK label. Good.

The room side walls appear as faint vertical lines at 60 and 1140. Fine.

The plants look like tall grass but a bit sparse. Fine.

Now test breach: click Breach button.

The breach happened: jet curves downward, fishes turned toward opening? Actually the current streak lines converge to hole. The jet looks very thin and mostly like a line, not much water visible. The droplets near the hole are small. It seems outflow but puddle not yet formed. Fish are moving toward hole.

Issues:
1. The jet ribbon is extremely thin/faint (line). Need more visible water stream particles/ribbon. Increase particle spawn (each visual) and ribbon width/alpha. Particle volume maintain. Also in the screenshot, after ~ maybe 0.1s? The HUD says 99%, outflow 19.7, so early. Jet only has a few droplets.

2. The hole rendering: black/green weird shape at wall around 780, looks like a dark eye. Could improve.

3. Water right wall: water surface still. Fine.

4. Fish seem to be moving towards hole but none exited yet. Fine.

5. Jet trajectory line goes down to x~1060 at bottom right - good curve.

6. Fish at right near hole maybe being swept.

Let me wait a bit and screenshot to see evolution, puddle, fish exits.

Use motion action maybe capture frames? Let's just wait via screenshot? The tool doesn't have wait. I can take screenshot after some time (each call takes time). Let's inspect DOM after clicking again? Use screenshot.

Now waterline fell to 86%, puddle formed near right side, curved jet visible, shards on floor. But some issues:

1. Fish: I see only 5 fish inside, 1 fish (yellow) at hole, green fish at bottom? Fish may have exited? HUD fish not exposed in DOM. But visually fish near the hole: yellow one at right wall (escaped? maybe in air?). Hard to tell. Need to check escaped fish land.

2. Puddle height is quite tall (a cone ~90px) near x=960; that's from local accumulation and slow spreading. It looks like a spike. Real puddle should be flatter. The leveling coefficient may be too low relative to volume input concentrated. Increase spreading coefficient significantly and perhaps add lateral "splash spread" deposition around impact. Also volume scale might make mound too high. Reduce PUDDLE_SCALE to 0.18, increase leveling to 0.25. Add deposition spread over 3 cells weighted. Also add a max puddle height to avoid pyramid.

3. The jet ribbon is still thin, looks like a thin arc line; particles visible as tiny dots. Increase visual density: spawn more particles with smaller vvol? The emitted count is Q*dt/300 ≈ 17000/60/300 ≈ 0.94/frame. Double to 2/frame: use /150 and vvol 150. Increase radii (2-5) and alpha. Ribbon width 16→4.

4. The hole at wall still looks dark/teal blob. Improve hole shape: cut open and show water inside, plus white jagged glass edges. Maybe fine but make it look more like a broken pane with shard edges. It's okay-ish but dark. Add water gradient bright.

5. Glass shards visible on floor right, good.

6. Toy floats at surface, moved right near hole (x~672) - good.

7. Waterline has fallen with a drawn marker? fine.

8. Fish: currently at (330,380) etc still; fish appear to have moved near hole. The yellow fish at right wall at y=430 is maybe inside or exiting. There is a green fish at 780,615 not at hole (maybe moved down). Fish should eventually get swept. Need to verify later.

9. Also the water in the tank seems "surface line" drawn at 345 but no falling water effect other than level.

Let me improve puddle and jet. Also fix hole.

For puddle: deposition spread gaussian across 5 cells around impact with weights. Increase leveling to 0.22, maybe 3 iterations. PUDDLE_SCALE 0.2. Ensure puddle remains within walls.

Actually total puddle height expected 112k*0.2/1080 = 20px. The cone reaching 90 due to concentration. Spread deposition:
```
const w=[0.12,0.22,0.32,0.22,0.12] centered at index
for each add vol*scale*w
```
With leveling 0.15 * 3 iterations should flatten to maybe 30px. Add cap height? no.

Waterline stop: at hole bottom 502 = 41% water level. Fine.

The initial level % currently 86 after some seconds. Good.

Fish escape: they need to reach wall band. At 86% surface 350ish. Fish at y 430 yellow near wall. After surface falls below holeTop 438, fish must be below surface; they clamp. Fine.

Puddle draw ripples okay.

Let me also add escaping fish visual: splash when fish exits? currently shake only. Add splash at exit.

Let me tune and retest. Also maybe increase jet velocity slightly? Curve good.

I also notice the puddle hidden behind tank? Drawn over tank bottom, looks okay: blue mound in front.

One more: room walls at 60/1140 barely visible; puddle limited visually by walls. Fine.

Improve plants? They look like thin grass blades; some leaves hidden. Acceptable.

Toy: yellow duck floating works.

Let's edit.

Also add splash when fish exits, and improve hole. Let me improve hole visual: make aperture brighter water colored, with jagged shard edges. Current is dark green-ish. Use blue water colors. Update fill gradient.

Also maybe water jet should emit visibly; increased.

Add exit splash at fish.

Reload and test: reset then drag crack to test drag, then breach, wait, screenshot, then reset.

First reload.

Test drag: drag crack from (785,470) to (785,570). In screen coords crack knob at (785,470). The stage is 1200x800 at viewport 1200x800 so direct. Drag.

Crack moved down to ~560. Drag works. Fish fish swimming fine. Note fish at right wall x=770 y=405 (yellow) sits at right wall — that's the fish idle clamped; might look stuck at wall. Since wandering pushes it right, it may hover. It's okay but maybe add wander direction bias to avoid wall sticking. Minor.

Now breach with crack lower, test. Click Breach.

The jet now looks like a smooth tube with only a couple droplets - because ribbon dominates but no visible particles at this moment? Particles might be spaced. Hmm at 0.1 s after breach, only few particles emitted. The ribbon from hole arcs down and off bottom right; forms clean curve. Good. Shards visible.

But wait: hole at y=560; jet width good. The puddle hasn't formed yet. Need wait.

Also the waterline label 100% still. It just started.

Let me wait and screenshot.

Now the waterline has fallen 25% and jet curves nicely. Puddle has spread from x~820 to 1140 with a smooth slope, looks decent but edges have a sharp peak near x=1140? It's fine.

Issues observed:
1. Fish all remain inside at y positions below surface but appear clustered; none escaped yet. The yellow fish near right wall (x=760,y=400) should get sucked but hole at y=560 now far below fish. It may drift down? Fish are at surface, hole is deeper, current near surface weak due to "below" factor and distance; they may not be swept. Requirement says "fish initially swim against the current before some are swept through the breach". Need to ensure at least some fish escape. Earlier default crack at 470 was close to fish. With crack at 560, fish at surface (386) ~174px above hole; flow weak (exp(-174/185)=0.39*jetSpeed maybe 0.39*? current) plus below factor. They might get pulled down eventually. Fish at 560-ish y (red/cyan) are near hole level and could be swept but they're at x~600, 185 away -> flow speed maybe exp(-1)*? ~0.37*300=110, while fish thrust 115 can resist. Hmm.

In the earlier default test after 85% water, fish were near hole but none escaped. Let me check the debug state to see. The browser tool doesn't evaluate JS, but inspect maybe returns DOM only. I can add fish status to HUD? Or use console log? I can use `browser inspect` maybe shows console messages. I could add a temporary console.log of fish escaped count when changes; then inspect. Simpler: add to HUD hidden? Instead, I'll alter logic to guarantee fish get swept: increase current force near hole and reduce fish thrust when flow > threshold (panic), and make fish get carried out once they touch the wall hole band. Also allow fish to escape if near hole band with surface above; fish must reach wall.

To reliably get fish out, implement "swept" behavior: once flow at fish > ~80, fish turns and struggles but gets dragged; flow field should be stronger in mid-water. Increase flow magnitude decay length from 185 to 240 and reduce fish drag relation? Fish velocity relative slip = flow - thrust/drag. At flow 300 and thrust 100 drage 1.8 => slip 244 downstream. They will reach wall in ~0.5s from x 600. But why didn't they? Because flow at those positions likely only ~60. Let's compute: hole (785,560), fish (640,380): dist=229, exp(-229/185)=0.29, submerged=1, jetSpeed≈0.56*sqrt(2*1250*head). Surface at ~380, head≈(560+? - 380)? sub 64, head=(560+592)/2 - 380 = 196, v=700, jetSpeed=392; flow=0.29*392=114. Thrust/drag = 115/1.8=64 → slip 50 px/s downstream. Should drift to wall in 3s, but fish also steers downward? Direction toward hole down-right, so fish gets pulled downward too. The screenshot after maybe 3s since breach shows fish still at x~740? Could be moving.

Wait screenshot shows fish x positions: orange at 470, red at 365, yellow near 760 at surface, purple at 725, banded at 640, green 600, red 680. All still inside. Maybe they just haven't reached wall yet; escaped fish would be on floor visible. None.

Also concern: as waterline falls, fish clamp to surface? No, they are below.

Let me wait longer (say 8s) and screenshot to see if any fish exit. Tool calls take ~1s each? Let's check after a couple of screenshots.

Waterline at 53%, outflow 19 L/s, puddle formed. Fish are at the top surface clustered near the waterline, but none escaped. Two fish near the hole at x=760 (yellow and purple) at surface, hole at 560, so they're 170 above. The flow at surface near wall should pull them down toward the hole. But they're staying near surface because of the "below" factor: `below = clamp((surfaceY - y)/30 + 1, 0, 1)` — for a fish at y=surface+12, below = 0.6? Actually (surfaceY - y)/30 + 1 = 1 - 12/30 = 0.6. Fine. But also fish are clamped to top limit surface + size*0.85, i.e., they cannot go deeper? No clamp only top and bottom. They can go deeper. The fish swim behavior when fm > 34 swims against current with ty = -flow.y*inv*0.6: if flow points down-right, against = up-left with ty = -positive*0.6 = up; so fish actively swim upward to surface, resisting the downward pull, creating the clustering at surface. That's "swim against current" but prevents sweeping. Need fish to be swept through: weaker fish should not have enough thrust; stronger should struggle. Currently drag coefficient 1.8 means equilibrium slip ~flow, which should carry them. But thrust direction upward-left offsets and the vertical force maybe balances.

Also fish near wall at x=760 (20px from wall) and hole at 560, they are not in hole band; they press against wall above hole.

To ensure escape, add model: fish caught in strong current near the wall get pulled toward hole center, especially when flow is strong. Increase drag (flow coupling) and reduce upward anti-current ty for vertical component. Also fish should target the hole? No—swept means not controlled.

Better escape condition: if fish within some distance of wall (< 60px) and water at hole exists and its y within, say, 1.6*HOLE_H of hole center, then mark escaped with downward suction. But fish at 380 vs hole 560 difference 180 > 102 threshold. Hmm.

Alternative: Adapt to requirement: "fish initially swim against the current before some are swept through the breach." Fish should get swept when waterline near hole. Since hole is near bottom and fish float up, maybe hole should be higher (default 470) and fish should be pulled. In previous test fish also didn't escape.

Let's add explicit "sweep" logic based on flow magnitude and proximity, plus stronger downward current near wall. At the wall, flow directly toward hole; multiply by 1.4. For fish at x > inner.r - 60, pull toward (wall, holeY) strongest. And fish drag should scale with flow: fish gets exhausted. Implement:

- In updateFish underwater, if fm > 90: fish.exhaust += dt else decay.
- Thrust reduced: `thrust = 115*strength*(fm>90?0.55:1)`.
- Increase coupling drag to 2.6 when fm>90 (so fish approaches water velocity).
- Remove vertical anti-current factor maybe: ty = -flow.y... still.

Escape condition: if fish x > inner.r - 24 (wall) and surfaceY > holeTop-6 and Q>120, calculate vertical distance to hole; if |y - crackY| < 130 → set y smoothly toward hole? Rather than teleport, add attraction: when x > inner.r - 40 and fm > 50, force fish vy += (crackY - y)*3*dt - this pulls into hole band; then escape triggers. This represents suction near opening. Good. And since fish at surface 385 and hole 560, the suction zone near wall only activates when x>inner.r-40=735; the fish at 760 will be pulled down along wall into the hole, then escape. Nice visual of being sucked down/out.

Also some fish may be swept earlier. Let's implement:
```
if (f.x > inner.r - 55 && Q > 120 && surfaceY > holeTop()-6) {
  const dy = crackY - f.y;
  f.vy += dy * 5 * dt;
  f.vx += 40*dt;
}
```
Then escape when x > inner.r - f.size*0.6 and |y-crackY| < HOLE_H*0.55.

Also fish above hole get pulled down at wall; once in band, out.

Need escaped fish to visibly fall and land. After exit, x = inner.r+6 = 781, floor 700. It falls outside tank at x 781; potential overlap with tank right wall? x 781 is beyond wall 785? inner.r=775, +6 = 781, wall spans 775..785 so fish is inside wall thickness. Should place x = tank.x+tank.w+8? wall outer 785, so x=792. Change escape x to 792. Also toy x 792.

Puddle impacts around x 800-1000. Escaped fish landing there.

Fish land on floor and flop. Good.

Also I noticed fish "swim" all at surface because current pushes them up? Actually anti-current has negative y. And buoyancy none. The fish that are at surface look odd — many fish pressed against waterline. The vertical anti-current pull makes them rise. Change ty anti-current: instead of -flow.y, use 0.25 * -flow.y so they mostly swim horizontally upstream, and can be pulled down. And if fish near surface, add slight downward wander. Let's reduce vertical contra.

Additionally fish vertical clamp at top = surface + size*0.85; they look half out of water (purple/yellow appear at surface). Their body rotates; center at surface+10 with size 12 means top above water. Better top limit = surfaceY + f.size*1.1. And fish bobbing at surface not too much.

Also puddle currently is a giant slope with high point at right wall up to 100px? It reached y~620 at wall (height 80). Probably too tall, but okay. It actually looks like a decent mound, though constrained at right wall (the wall line). Fine. Left spread stopped at x 780 due to... puddle spread left but tank body blocks visually? Since tank drawn under puddle, puddle drawn over tank base. Hmm puddle spread left limit seems around 770? Actually puddle extends from ~780 to 1140. It should spread left (toward 60) over time. It's not spreading much left because leveling is slow and the gradient mild? It does extend only to x=780. After water continues, leveling should. Maybe needs more iterations/coefficient. But volume ~26k; if spread over 1080 at 20px avg, shape should extend. Here local puddle is 80 tall near 1000, so more should flow left. Increase leveling to 0.35 and steps 3 → transfer 17.5% diff per pair per step. That's 0.35*0.5=0.175 — actually f = diff*0.22*CELL_W*0.5 = 0.11 per step. Should spread. Diffusion across 132 cells is slow (~diffusivity 0.11*cell²/frame ≈ high). Hmm 0.11 diffusion coefficient should spread quickly (t=1s → width sqrt(2*0.11*60*132²)?). It reaches wall and stops. Maybe okay — puddle starts near breach and spreads gradually over tens of seconds.

But physical puddle should spread immediately outward. We can boost spreading near tall regions. Not critical.

The tank's right wall is drawn, and water drains below hole? Waterline at 53% (~430) is above hole top 528? Wait crack y=560, hole top 528. Surface at 430 still above. Fine.

Issue: Now the water surface falls; fish clamped to top limit follow down; toy floats at surface. Good.

Let me implement fish suction, vertical tweak, and escape x. Also increase water top limit.

Also fish should not all clump at the surface: the anti-current vertical force + top clamp. Reducing vertical will help.

Let me edit.

Now reload, reset/breach test. But also check reset works after breach. Let me reload, drag maybe default, click breach, wait some, screenshot, then reset and verify.

Initial state looks good. Crack at default 470 shows. Plants look a bit thin but okay. The toy is floating at surface. Fish swim.

Note fish now appear spread vertically rather than all at surface. Good.

Test breach default and wait.

Hmm, the breach screenshot shows water level 100%, outflow 0.0 in HUD even though the jet is clearly visible! Also the jet ribbon starts from the opening and arcs off the bottom. But HUD outflow 0.0 L/s and 100% is stale? Wait DOM says OUTFLOW 0.0 L/s while image shows 0.0. The Q ramps with holeGrow over 0.5s, and HUD update could be lagging? DOM earlier returned 22.8. This screenshot was taken maybe immediately after the click (same frame) so holeGrow small → Q maybe low, but jet drawn with jetSpeed from Q? It shows jet though. The tool may capture after DOM query but before next HUD? It says outflow 0.0 but the click response showed 22.8. Weird.

Wait, look at the screenshot: the waterline appears at same level (~290) and the hole is open, jet flowing. The HUD shows 100% 0.0 L/s. Maybe the screenshot is from the previous frame before update? Or image might be stale due to rendering timing. Not critical. The click response DOM said 22.8.

More important: fish visible clustered left? 6 fish inside, one green at 670,545. None escaped yet.

Also EEL-like crack line? The "suction streaks" appear as white arcs converging to hole — they look like fibrous strands (too many, too bright), kind of like hair. Might reduce. They're inside water though rendered before glass; acceptable but maybe too prominent. Could make them subtler and shorter.

Wait: The fish are drawn *behind* the streaks, giving weird look. Fine.

Let me wait to see fish exit with new suction.

Now the waterline fell to 74% and puddle formed, but fish are all at the surface again clustered along waterline! The new fish behavior causes them to rise to surface — because current near hole pulls them? Wait they are all at surface, evenly spaced, like floating. Something is wrong: perhaps the current field pulls them upward? flow direction toward hole which is below (hole y=470, fish above? fish y initially 365 etc, hole below → flow down), anti-current ty = -flow.y*... = upward. They swim up and clamp at surface. Then at the wall suction pulls down, but only within 58px of wall, so fish at surface mid-tank stay.

Fish shouldn't float at surface; fish are neutral buoyancy, but they keep swimming up against the current and get stuck at surface. Better: no vertical anti-current component (ty=0) so fish only swim horizontally; then the downward flow drags them down. Set ty = -flow.y*inv*0.1. Also add a depth preference so fish don't cling to surface: if near surface, thrust downward slightly. And reduce top clamp.

But the bigger issue: no fish escaped so far. The pinned fish at surface near wall (duck is near wall at x=760 y=395; purple at 640,440; etc). The wall suction zone x>717: only duck? Duck is toy. Fish near 640 not in suction.

We should ensure the current in mid-tank is strong enough that fish get pulled toward hole. Current field magnitude at (640,440): hole (785,470) dist=148, exp(-0.8)=0.45*jetSpeed ~ 400 → 180 px/s. Fish thrust 115/1.8=64 → slip ~116 px/s toward hole (right and slightly down). So fish should reach wall in ~1s and be sucked down. Yet screenshot 74% (~few seconds) shows them still mid-tank at surface. Because vertical anti-current keeps them at surface AND... wait horizontal movement should still occur. They are at x=300..760, mostly left. They appear spread but maybe just screenshot timing. Hmm purple at 635, pink at 605, blue at 400. The current streaks show flow is strong near hole.

Maybe the flow "below" factor reduces at surface to 0.6, still 100+. They should drift right. Unless their thrust upstream 115*strength > flow*? Fish thrust added to velocity directly as acceleration with drag coefficient 1.8: acceleration 115, drag = 1.8*(flow - v). At v=0, flow=180 → drag accel = 324 right, thrust 65 left = net 259 right. Definitely drift right. Unless the fish are clamped at the surface and their vertical velocity zero, x movement unaffected. So in a second they'd be at wall. The screenshot shows some near wall (purple ~640? no). Maybe the fish that were near the wall already got swept out? I don't see any escaped fish on the floor though. There should be splashing fish outside.

Hold on, could the fish be *going out* but then invisible? Look at hole area: there is a small blue-ish thing at the hole. Maybe fish are being teleported to x=793 and then fall but are drawn behind the puddle? drawEscaped draws fish after puddle, so visible. None visible on floor.

Maybe all fish got "escaped" then immediately drawn at x=793 and then... they fall and land, but the image doesn't show them because the screenshot occurred right after? Not likely after 3 seconds.

Let me inspect state via browser? I can add a hidden DOM element showing escaped count for verification. Better: add debug text in HUD metrics? Add a third metric "FISH OUT". Could be nice for the sim. Actually showing "ESCAPED FISH" count would be informative. Let's add it to HUD (replace? add a third metric). That helps verification too.

Let me add metric "FISH OUT" with count. Also make sure fish sweep logic.

The fish surface clustering: set vertical anti-current to 0 and add slight downward bias when fish near surface (y < surface+40): ty direction downward. Fish should then distribute throughout water.

Also once flow ends (Q=0), fish resume wandering.

For better sweep, increase suction zone radius to 80 and pull stronger (7). The hole is at 470, fish at 400 y near wall. With suction, fish pulled down into band |y-470|<38 (0.6*64=38). zone.

Let me first add the HUD metric and test whether escaped count changes.

Also note the HUD screenshot inconsistency: DOM text 74%, screenshot 74% matches now. The previous mismatch maybe due to screenshot timing, ignore.

Puddle spreading: now from ~830 to 1140; not left of 785 due to the tank? Our physics spreads both directions but the puddle's left edge is near tank right. It looks like puddle is constrained by tank base? It's not; but spread may be slow. It's acceptable; maybe add faster spreading.

Let me add HUD fish metric and adjust fish.

The second edit is a no-op and wasn't found due to spacing; remove it. The first edit may have been applied? It says could not find edits[1], likely none applied (atomic?). Let me check the file for fishOut.

None applied. Reapply without the no-op. Note metrics grid has 2 columns; with 3 metrics third wraps. Fine, or change grid to 2 columns with third spanning? Add `grid-column: span 2` for fish metric? Keep simple: 3 items in 2 cols, third half width. Visually okay but asym. I'll make metric 3 full width via class wide with grid-column:1/-1. Let's do.

Now reload and test breach, watch fish out.

The fishOut metric row looks okay. Breach and wait.

Again screenshot apparently from an earlier frame (HUD 100%, 0 L/s) while DOM says 99% 17. The screenshot lags one frame behind? Actually the image might be captured before the state updates from the click. Still interesting.

Wait fish are all clustered around y 370-570 and none at wall. The yellow fish at (620,405) has moved right. Pink at 550,530. They're drifting. Good.

Let me wait more.

Now at 88% and fish are clustered around middle-right but still 0 out. The fish at (670,520) pink should be pulled. Actually there's a purple at (555,430) and yellow at (520,405) – they're moving toward hole. Waterline 88%. 

Hmm none out yet after 3-4 seconds. Water level 88% means only ~1.2s? Level from 100 to 88 quickly. Fish are drifting right slowly. Let's wait another screenshot.

At 75%, fish are all pressed against the surface, and the duck is at the wall at surface (x=760, y=390) above hole top (438). Fish still 0 out.

Problem: fish and duck are pinned at surface due to buoyancy? Fish aren't buoyant but they all move to surface because the anti-current vertical? I set ty=0.5 downward when near surface... but they're still at surface. Why? Their y is at topLimit = surfaceY + size*1.15 ≈ surface+16, they clamp there. Their vertical velocity may be negative. What pushes them up? flow direction: hole is at 470, fish at y~380 → dy = 470-380 = +90 (down), so flow.y positive (down). Anti-current ty = -flow.y...*0.08 = upward (negative), but small. If near surface, ty = 0.5 downward. So net downward thrust. Yet they sit at the top clamp. Could be waterline is falling so the fish are left at the surface as the clamp moves? The clamp moves downward as surface falls, so fish would follow via position clamp only if they're above it. Their y rises each frame due to... "below" factor makes flow up? Wait flow direction uses dy = hy - y = 470 - fishY. For fish at 380, dy=+90 downward. Should pull down. The fish's y is ~381 and surface ~390? Wait surface at 75% = 390. Fish center drawn at 385 (topLimit 405?). Hmm.

Look: at surface line ~395; fish centers at 390-410. topLimit = surfaceY + size*1.15 ≈ 408. So they are exactly at topLimit, meaning something is pushing them up hard to the clamp. Then ty=0.5 downward accelerates down, but maybe their vy is negative large due to previous anti-current? The suction? Fish near x=680 not within 82 of wall (717? inner.r=775 -82=693). The yellow at 730 is within suction; suction pulls down toward 470 but it's at surface — suction force scales pull ~ (730-693)/82=0.45 → 6.5*(470-390)*0.45=234 px/s² downward — should dive, yet it's at surface. So why?

OH. The fish position update occurs; if f.y < topLimit, set y=topLimit, if vy<0 vy*=-0.2. But maybe f.y is ABOVE topLimit because topLimit is computed *after* applying surfaceY? Yes. If fish is at surface, y = topLimit. Next frame, suction pulls down: vy += 234*dt = 3.9, then damping and position y += 3.9*dt small, still < topLimit? But topLimit itself follows surface down (surface falls 15px per frame? no, ~0.5px/frame). The fish should slowly go down. Hmm.

Maybe the issue: fish velocity y is being overwritten by swim behavior: `if (f.y < surfaceY + f.size * 2.4) ty = 0.5;` only when fm>34. But then `f.vy += ... + ty*thrust*0.6*dt`. thrust downward 34.5 per sec, not much.

Wait maybe the whole fish rendering shows fish at surface because the drawn fish are actually at deeper y but their *drawn body* rotated vertically makes them appear at surface? In the screenshot, fish are oriented vertically (heads up) and drawn as vertical ellipses, spanning from surface to +30. Their center is ~surface+25. That's topLimit. So yes.

Could this be a bug where fish y decreases due to wander when flow is low? Flow at surface far from hole maybe <34? Exp decay strong. For fish at x=400, dist ~390 → exp(-2.1)=0.12*400=48 >34. Hmm.

What pushes fish up? Look at `flowAt`: `below = clamp((surfaceY - y) / 30 + 1, 0, 1)`. For fish at y > surfaceY (below surface), (surfaceY - y) negative → below <1. Fine. Flow y positive (down). Both add down.

Wait but the waterline falling means fish are clamped at top only if fish y < surface+something? I set topLimit = surfaceY + f.size*1.15 which is BELOW the surface (larger y). So fish y >= topLimit. They can't be above. So fish cannot be at surface or above; center is 17px below. In rendering, the fish at (400? y=390) with size 15, body half-height 9, so top at 381, surface at 372? Screenshot shows fish center ~390, surface line ~395. Hmm maybe center is slightly above surface. Whatever, they're near the surface.

Physically fish should be distributed. The cause is likely the suction/current pulling fish up? Actually wait: water exits at hole 470 causing water to flow toward hole; in a real tank the surface would dip near the hole but overall fish would be pulled toward the hole, not up.

Hold on—maybe the fish never update their y because the top clamp is triggered because surfaceY decreases faster than fish fall? Fish fall slowly relative to 15px per second surface fall? TopLimit moves down ~0.3-0.5px/frame. Fish with downward velocity ~5px/s (0.08px/frame) less than surface fall → fish gets clamped each frame and pushed down with surface. Their vy gets reset to *-0.2 when vy<0 then pulls... but suction acceleration should increase downward speed over time. Unless each frame the fish is set y=topLimit and then `vy` is damped by coupling with flow.y: flow.y for a fish just below surface is (470-400)*inv*speed. The flow vector: dy=+70, dist ~? inv computed 1/max(1, hypot(dx, dy*1.35)) etc. flow.y = dy*1.35*inv*speed. This is positive down. So coupling adds down. It should accelerate downward.

Hmm, but note fish velocity is also damped by `f.vy *= exp(-.35dt)` negligible.

Maybe the fish are indeed diving slowly but the water level is falling at ~30px/s so the surface catches up faster than they can dive? Suction 234px/s² → after 1s downward velocity 234 px/s. That's fast. Unless suction isn't active because Q? Q 18.6 > 120 yes.

Wait, look more carefully at fish shapes: at (320,410), (445,395), (485,390), (625,405) etc. The water surface at y≈400? Actually waterline visually at ~400 on the left; these fish may be just below surface. Their vertical orientation indicates angle = atan2(vy, vx) with vy positive (down) and vx small → angle ~90° → head down. That suggests they ARE diving! They're pointing head-down but slowly because update happens. Yes the fish are oriented downward (heads toward bottom), so the simulation is pulling them down. They'll take a few seconds to reach the hole. Good.

Also duck at wall surface.

So let's wait more. Water reaches hole top (438) at level? surface 438 → level = (690-438)/(690-290)=63%. At 75% now. Wait, surface at 75% is 690-0.75*400=390. Hole top 438. So water still 48px above hole top. The fish are being dragged down slowly.

Wait fish at surface center ~400, hole center 470, so only 70px away. Suction should bring them down. Let's see next screenshot.

Interesting! The duck has escaped through the hole! It's on the puddle right of the tank at x~900, y~610, floating. Good. That demonstrates movable object carried out.

But fish still 0/7. Water surface now 59% = 690-236=454, which is below hole top? Wait hole top = 470-32 = 438. Surface 454 > 438, so still above top. Outflow 8 L/s decreasing. The toy (duck) escaped at some point when surface was near hole. Good.

Fish are clustered at surface mid-tank, not at the wall. The one green at (760,520) near hole. Why don't the fish in the middle get sucked right? The current at surface maybe very weak due to `below` factor ~0.5 and distance. But at 8 L/s flow is weak now. They should have been carried earlier.

Also I notice the toy "duck" at puddle: it's floating at y=610 on a 50px puddle, correct.

The duck getting out proves the movable object scenario. Fish not out is a requirement gap ("fish initially swim against the current before some are swept through the breach"). Need to fix.

Why aren't fish moving right? Looking at sequence: at 88% fish were at x 500-680. At 75% they were still 320-730. At 59% they are at 360-740. They appear to be swimming LEFT against the current (they turned to face right? Actually heads are pointing left? The orange at 520 has head left (eye at left)? In drawFish, head is at +x local, so if fish faces left, eye at left. In the screenshot the orange at (520,465) seems head at right? Hard.

They are clearly pressed at the surface again despite ty downward when near surface. Hmm.

Possible bug: `topLimit = surfaceY + f.size*1.15`, but fish have `f.y` at 465 while surface ~455 → they're 10 below. Fish centers are ~10 below surface, which is expected topLimit. They're clamped at top. Why? Because maybe their velocity is upward due to `flowAt` producing upward flow? Let's check flowAt signs again:

```
const dx = wx - x, dy = hy - y;
const inv = 1 / hypot(dx, dy*1.35);
return {x: dx*inv*speed, y: dy*1.35*inv*speed}
```
dy = 470 - 465 = +5 → downward small. At x=520, dx=255. Flow mostly right. speed = jetSpeed*exp(-dist/185)*below. dist~255, exp=0.25, jetSpeed at head maybe 200 -> speed ~50*0.5=25 → below threshold 34, so fish wander instead of fighting. Wander random directions, some upward, hence surface clamping over time? Wandering fish shouldn't all end at surface; random walk but with clamp they don't leave.

The key: why do fish at x=520 not drift right when flow ~25? It's too weak to overcome their drag; they wander. Near the hole, x=700 dist=85 flow ~0.63*0.6*200=75. Fish at 740 should be pushed strongly; there's a green fish at 760,520. It's within 15px of wall (x > 775-size) and should escape if y within |520-470|=50 < 38? No, 50 > 38.4 (0.6*64), so it's clamped at wall below hole band. Then suction should pull it up toward 470. The green fish shown at (760,520) is inside, near wall. It should escape soon.

So the issue is that fish don't get near the hole enough; outflow weakens and stops before they reach. Need to accelerate the sweep mechanic and/or make fish more susceptible. Requirements don't demand all fish exit, just "some are swept through". We can make it deterministic by increasing current and suction to pull nearby fish sooner. At 88% there were two fish close to the wall (yellow at 730,405 and purple at 560). Yellow should get sucked; but maybe it escaped? No fish out count 0.

Wait maybe the fish at x=730,y=405: top clamp; hole y=470; suction zone x>693; pull=(730-693)/82=0.45; vy += (470-405)*6.5*0.45 = 190 px/s². It should dive and then exit. By 75% screenshot, duck had moved to wall but yellow fish was at 730,405 still. Hmm the screenshot might be at a moment. Then by 59%, no yellow fish near wall? Looking at 59% screenshot: fish at 360, 435, 520, 590, 715, 640, 260. There's a yellow at 590,445. So it moved left! The fish are actively swimming LEFT (against current, tx=-flow.x) with thrust 115 and flow possibly weak; they escape rightward? No, they go left away from hole, which is "swim against current" correctly! The current is leftward? No current points right toward hole, so fish swim left. That's why they move away and never exit. They are strong enough to swim away from all but the strongest current.

So to get "some swept through", the current near the opening must exceed fish thrust for some fishes. The suction zone only applies at x>693, but fish avoid that region by swimming left when flow >34. At 88% fish were at x=680... then they swam left. The one fish that got near wall escaped? no.

We need a mechanic: fish can't escape upstream once close to the hole. Increase suction zone to ~150px from the wall and add strong pull right (not just down) so some are dragged in. The current should be stronger overall mid-tank. The current magnitude at 680,440: jetSpeed maybe 300 at 88%: dist=~110, exp=0.55, below 0.5 → 82. Fish thrust 115 → they can swim upstream (left) at ~35 px/s. So they hold. Increase current coupling via `speed` scale (jetSpeed) or add a stronger horizontal component. Real flow into a hole is strong.

Simplest: multiply flow magnitude by 2.0 near hole? jetSpeed itself can be increased to 0.8*sqrt(2G*head) (from 0.56). But jet visual speed would change too (jet particles); okay, but curve less downward if vx high. We can separate: flow strength multiplier for objects vs jet exit velocity. Let `flowAt` use `jetSpeed * 1.8 * exp(-dist/240) * ...`. Then fish at x=680 gets 0.55*300*1.8=297 → swept. Fish at x=520 dist 255 exp(-1.06)=0.35*300*1.8=189*0.5(below)=94 → still near thrust but slightly. Fish near wall strongly sucked.

Also suction zone enlarged to 130 with pull right. Then at least the 2-3 fish nearest the breach (x>600) will get swept when water is high. That satisfies "some".

Also these fish should fight visibly before being dragged: their thrust is 115 vs current 300 → drift right ~100 px/s over ~1s. Visible.

Let's adjust flowAt strength: `const speed = jetSpeed * 1.6 * Math.exp(-dist / 220) * ...`. And suction zone to inner.r-120 with vx pull 90.

But caution: the toy then also gets dragged faster — it already escapes, fine. Plants bend more and visually lean strongly. Current dots move.

Fish fight: good.

Also fish at surface issue: after Q drops they'll wander back. Fine.

Let me also make fish not clamp to surface so much: topLimit = surfaceY + f.size*1.6, and when fish near surface add downward force regardless of flow. Also top clamp should not pin them if pushed. Fine.

Another thought: fish escaping count 0 might be because the escape condition requires `surfaceY > holeTop()-6`; at 59% surface 454 > 432 yes. And Q>120 false (Q=8*640=5120 >120 true). Fine.

Let's boost flow and suction, then test. We need escaped fish before water falls too far. At 88% plenty of time.

Edit:
- flow speed multiplier 1.7, decay 220.
- suction zone from inner.r-120, pull strength 8, vx 90.
- escape band 0.7.
- fish topLimit + size*1.4 and add `if (f.y < surfaceY + f.size * 1.8) f.vy += 80*dt;` (downward) outside flow condition.

Careful not to make all fish dive to bottom. They'll hover.

Also, physically the current near hole is strongest; using 1.7 is fine.

Now I want to check fish escape faster. Reload, breach, screenshot after a bit.

The initial scene is good. The crack and DRAG CRACK label visible. Fish distributed. Duck floats.

Now breach and watch fish out.

Now the jet's particles are visible as dotted arcs near the hole, while the ribbon extends off bottom right. The stream curves down. Good. However the ribbon looks like a thin smooth tube that extends straight off the bottom edge at x~1080; it ends at T=0.8s at y=... The ribbon isn't landing at the floor because T=0.8 gives y=470+8*0.8+0.5*1250*.64=470+6+400=876 > floor. It goes through the floor and beyond, visible over the floor (drawn after puddle). That's a visual bug: the jet ribbon extends below the floor line at bottom right! In the screenshot, the arc continues below floor to bottom right. Should clip the ribbon at floor/puddle surface, or limit T so it ends at floor. Also the droplets presumably land. Let's compute ribbon until it reaches the floor: solve for t; easier: truncate points when y > room.floor - puddleHeightAt(x) using step loop. Do that for both ribbon arrays.

Also the streamlines inside water (white strands) are quite prominent, appearing like a bundle of fibers. Tone down alpha to ~0.25 and fewer. Maybe fine but make more subtle.

Now check fish count after waiting.

Now I see the fish are being sucked toward the hole: yellow fish at (755,435) right at hole band, duck at wall too. The yellow fish is about to escape. Fish out 0 still due to timing. At 84% waterline y~354? Wait surface shown ~355, hole at 470. The yellow fish near hole center at 435.

The jet ribbon still extends through the floor to bottom right. Need to clip.

The puddle at right is nice. Shards on floor.

Let me wait.

Still 0/7, and now the fish are clustered at the surface AGAIN, including the yellow one right at the wall above the hole (y=395). Weird. The fish out doesn't happen even when the yellow fish is at the wall near y=435 earlier; it must have then been pushed up to surface.

Why do fish rise? At the wall, suction pulls toward hole y=470, but the fish is at 435 → downward. Yet next screenshot fish at 395 (surface). The duck is at 395 surface.

Hypothesis: the top limit clamp is computed from surfaceY; after waterline falls, fish y gets clamped to topLimit only if above. That would move them DOWN, not up. So something is actively pushing fish up strongly. Could it be the anti-current direction? flowAt for a fish near wall above hole: dy = hy - y = 470-435 = +35 (down). flow.y positive down. Anti-current ty = -flow.y*inv*0.08 (up small). Not enough.

Wait — `if (f.y < surfaceY + f.size * 1.8) f.vy += 85 * dt;` pushes DOWN. Hmm.

But look at the fish drawing: The fish are facing UP (heads up, vertical). angle = atan2(vy,vx). If vy negative (up), they'd face up. So they're moving up. What gives them upward velocity?

Look at fish update order:
```
f.vx += (flow.x-f.vx)*coupling*dt + tx*thrust*dt;
f.vy += (flow.y-f.vy)*coupling*dt + ty*thrust*0.6*dt;
f.vx *= exp(-.35dt); f.vy *= ...
...
f.x += f.vx*dt; f.y += f.vy*dt;
const topLimit...
if (f.y < topLimit) { f.y = topLimit; if (f.vy < 0) f.vy *= -0.2; }
```
Note when clamped, vy gets flipped to +0.2*|vy| (down). So they shouldn't stay up.

But wait: the fish in the screenshot at 74% are concentrated around x=520-760 with heads up and tails down, all at y~400-410 (surface 395). Two are overlapped (orange & purple) at x=520. That's suspicious: fish may be caught in a weird attractor at the surface. The suction near x>650 pulls toward crackY=470 (down), not up. The flow field near surface: below factor = clamp((surfaceY - y)/30+1) — for fish at y=407 > surfaceY=395, below = 0.6; flow direction toward hole is right-down. So coupling gives down+right. Thrust against current gives left+up. tx=-1, ty small up. Net vertical could be up if flow.y small: flow.y = dy*1.35*inv*speed. At fish (700,407): dy=63, dx=85, inv=1/hypot(85,85)=0.0083, speed ~? exp(-dist/220) with dist 105 => 0.62, jetSpeed maybe 350, factor 1.7 => 369*0.6(below)=221. flow.y=63*1.35*0.0083*221=155 down; flow.x=85*0.0083*221=156 right. Fish thrust 115: tx=-0.73*115=-84, ty=-0.11*115*0.6=-7.6. Drag coupling (flow.y-vy)*2.0 (~flow >95) — should accelerate down strongly. So no way they're pushed up. Unless f.vy huge negative from earlier suction? Suction pulls down.

Hmm, could the screenshot fish actually be facing down (heads at bottom)? Looking closely, the orange fish at 520 has its eye on the lower right? The eye is visible at the right end of the body. Body horizontal-ish. The shapes: orange at (520,412) appears with tail at left, eye at right - normal horizontal. So they are at the surface horizontally. Not necessarily moving up.

Could they be *born* at surface after being reset? No.

Wait: maybe they're not at the surface. Water surface at y=395 and the fish are at y=410 just below. The fish at x=520 overlaps the waterline. That's because topLimit = surfaceY + size*1.45 ≈ 395+21=416 and the fish are at ~412. So they are pinned to the top clamp. So they're at the surface boundary, yes. Something keeps them up.

Possibility: The shear from flowAt is upward *outside* near hole due to `dy = hy - y` sign when fish is *below* hole center. For fish at y=500 (below hole center 470), dy=-30 → flow.y negative → anti-current ty positive (down)?? Wait flow points up toward hole from below; fish swims down against it. Fine.

At the top clamp, fish should dive due to the downward 85 force. Unless fm < 34 and the wander target points up, but the 85 downward still applies. Hmm, the 85 downward force is applied only after the flow block and only when f.y < surfaceY + size*1.8 (~416), which is true at clamp. So vy increases downward by 85*dt. With clamp, y can't go above limit, but as soon as vy becomes positive, y goes below limit and should move down. However, the clamping happens BEFORE the suction block? Let's see order:

```
f.x += f.vx*dt; f.y += f.vy*dt;
const topLimit...
if (f.y < topLimit) { f.y = topLimit; if (f.vy<0) f.vy *= -0.2; }
...
if (f.x > inner.r - 125...) suction
if (f.y < surfaceY + size*1.8) f.vy += 85*dt;
if (f.x > inner.r - size*0.6) escape...
```
So the 85 downward force is added at the end, and next frame y should increase. Unless topLimit is lower than y? No.

Wait, the fish may have vy positive downward but y clamped at topLimit because topLimit is RECOMPUTED each frame after surfaceY falls. If the fish only moves down at ~5px/s but surface falls 20px/s, the fish is effectively pinned. But 85px/s² gives ~85px/s in 1s, so should keep up. Unless vy is being damped by the flow coupling to upward flow. Hmm.

Hold on, maybe we aren't seeing the same fish; maybe these fish are dead/floating at surface due to something else. Actually there is a much simpler explanation: the fish are swimming upward against the current because the current is strong horizontally to the right, and the fish's upstream direction has a slight upward component when above the hole. The fish is fighting to stay still but its drag pulls it toward the flow. Near surface that flow vector maybe points UP? Let's recompute flow direction threshold for "swim against" — but that doesn't set velocity; it sets desired direction with limited thrust. It can't beat drag down.

Unless the flow field is zero (fm<34) for those fish because `below` factor is small near the surface: below = clamp((surfaceY-y)/30+1) with y just below surface → ~1, not small. Hmm.

Let me instead add an explicit depth-keeping behavior for fish when not near the hole: a target depth band, applied as a weak vertical spring, so they don't all pile at the surface. E.g., fish have `homeY` and when not in strong current, steer toward homeY. That would fix visuals and the sim "fish initially swim against current" still works horizontally. Also for escape guarantee, add a small probability/force that specific weaker fish get sucked. 

But the count remains 0/7 even when yellow is at the hole band. Maybe the yellow fish shown at (755,435) in the 84% shot actually was cut off from the wall by the clamp `f.x = inner.r - size*0.6` = 775-7.5=767.5; escape triggers when f.x > 767.5 and inHoleBand |435-470|=35 < 44.8 and waterAtHole yes → should escape! It didn't. So maybe inHoleBand check happened before the suction moved it to the band; it was at 435 within band. Should have escaped the same frame. Unless Q dropped below 100? No 18 L/s → 11k.

Why not? OH WAIT. The condition `surfaceY > holeTop() - 6`: surfaceY=354, holeTop=438 → false! The waterline at 84% is at 354, which is ABOVE holeTop (smaller y). I wrote the condition incorrectly: water at the hole exists when surfaceY < holeBot (surface above bottom of hole), not > holeTop. I inverted! In screen coords, smaller y = higher water. `surfaceY > holeTop()-6` is false until the surface falls BELOW the top of the hole (lower than hole), which is wrong. That's why fish never escape while water is above the hole, and only the toy escaped when surface fell near the hole (because toy uses `surfaceY < holeBot()-4` correct).

Fix: waterAtHole should be `surfaceY < holeBot() - 4` (surface higher than hole bottom). Same for suction condition. This is the bug! Fish will now escape when reaching the wall band, which they do.

Similarly `Q > 100`.

Fix both occurrences:
- suction: `surfaceY > holeTop() - 6` → `surfaceY < holeBot() - 4`
- escape: same.

Toy's condition: `surfaceY < holeBot() - 4 && Q > 200` correct.

Also the toy escaped only when the water level fell near the hole; with the correct fish condition, fish will escape early (water high). Good.

Let me fix. Also add desired depth for fish to reduce surface clumping. And clip jet ribbon at floor. Also reduce suction streak alpha/fibers slightly.

Implement:
```
const waterAtHole = surfaceY < holeBot() - 4 && Q > 100;
```

Fish depth preference: add f.homeY initialized random 380..600; if fm < 60 and not escaped, ty added toward home: 
```
const dyHome = f.homeY - f.y;
f.vy += clamp(dyHome * 0.6, -60, 60)*dt? 
```
This keeps them distributed. But after breach, if fm high they ignore home. Add before integration maybe. Let's add in the wander branch: if fm<=34, steer to home depth. But fish in weak flow still at surface due to clamping; add global vertical spring to home when fm < 120:
```
f.vy += clamp((f.homeY - f.y)*0.8, -70, 70)*dt;
```
(accel px/s²). Home baseline maybe set per fish during init to their initial y, but as waterline falls, home could be above water; clamp home y ≥ surfaceY+30 when used. Also the tank surface moves; keep home relative? Just clamp.

In init map, add homeY: f.y.

Let me edit.

I edited drawJet to add an `if (left.length > 1) {` but need to ensure closing brace structure. Let me view that section.

The replacement removed the drawing code inside the if. Need to re-add the path drawing code and close the block properly. Fix lines 1184-1185.

Now reload and test breach.

Initial scene looks good now: fish distributed throughout the water, toy floating, crack visible with label. The tank glass is somewhat faint but clear.

Now click Breach and check fish escaped.

Good early outflow: jet arcs downward, waterline about to fall, fish orienting toward current. Note the jet now terminates at the floor (no extension below). It ends at x~960 near the floor at the very edge of the screenshot? The ribbon ends around y=685 x=1005 maybe. Good.

Wait HUD says water 100% but DOM said 99%. slight timing.

Fish are turning left against the current (heads left) — good.

Now wait for fish exit.

Fish out 1/7, and a green fish is visible flying through the air just outside the jet, falling to the floor. Nice.

But two fish at the top-left appear to be at the surface (orange/red) overlapping, heads down/up. Fine—they may be swimming near surface; acceptable though all fish seem to gather at the surface near the start. Actually two fish are above the surface line! The orange fish at (440,360) and red at (420,390) — waterline ~345, so they're below by 15-45 px. okay.

The jet looks great now. Puddle growing. 

One concern: jet ribbon passes through the escaped fish? The fish is at 891,575 while jet path at x=890 y~530? close. Fine.

Next, check more fish escape and waterline stops. Then reset. Let me screenshot after more time.

3/7 fish out. Two fish visibly being carried out in the jet (yellow and pink) - excellent. Puddle spread from ~830 to 1140. Fish on puddle (green) at right. Shards on floor. Waterline falling.

Issues:
1. The puddle has a sharp pointed peak and edge; it looks like a wedge. Could be improved with more smoothing but acceptable.
2. Duck is at right wall floating above the hole, waiting. It will escape when waterline approaches hole; earlier it did. Fine.
3. Glass shards on floor visible.
4. The hole around wall looks like a dark blue oval - fine.
5. Fish at surface two of them (orange) - they're at surface but that's because they're being pulled near the surface? They look okay.

Now verify outflow stops and waterline stabilizes at hole bottom. Let it run to end. Each screenshot advances ~1s? It seems each screenshot advances about 1-1.5s. Water 78%, needs to reach 63% (hole top 438?? Wait stop is hole bottom = 502 → level (690-502)/400=47%). That takes a while (~5-8 more sec). Let's take a couple more screenshots and check.

At 68% outflow 15.3. Duck floats at hole level, will be carried out soon. The puddle is spreading. The tank water level is well below tank top now; good.

Observations:
- The fish in the tank are near the surface, being pulled toward the hole; flow lines show. Good.
- jet is thinner as Q drops. Good.
- Puddle mound high at 1120? It looks like a hill peaking near x=1010 then thinner. Should spread over floor; it's spread from 820 to 1140.

Need to check stop. Let's wait more.

Now the duck has escaped and is floating on the puddle at x=905. Fish out 3/7. Water 61% still above hole top? Hole top 438 -> water level 61% = 690-0.61*400 = 446. So waterline just above hole top, jet weakening. Two fish inside at surface (orange, purple). Waterline will stop at hole bottom 502 -> 47%. Since surface at 446, still 8px above hole top. Jet continues until 502. It's slowing.

Eventually some more fish may escape; fish out 3, fine. Toy escaped.

One visual issue: the puddle floats the duck at the surface, but the puddle near x=905 height ~55; the duck is drawn at y~620 (surface). Good.

Now check the stop after more time. Then reset.

Waterline at 57%, outflow 6.2, hole at crackY 470, hole top 438, hole bottom 502. Wait water level 57% = 690-228=462. That's already below hole top 438, so opening partially exposed; sub = 502-462=40. Jet smaller. Nearly stopping at 502 (47%). Good.

But notice the plants are still fully upright and long despite waterline below? plants at bottom, fine.

Fish inside at top; hole now near surface. They may escape.

Now reset test. Click Reset and verify scene restores: water 100%, crack visible, puddle gone, fish 7 inside, duck floating.

Reset restores the intact scene: 100%, crack, duck, all 7 fish, no puddle/shards. Great.

A few polish items:
1. Fish are still not all spread; they're fine.
2. The water surface line is at 290 and the duck floats.
3. The crack zigzag line and knob are visible. "DRAG CRACK" label.

Remaining concerns:
- Requirement "Water exits in a gravity-curved jet, and the waterline falls continuously" — verified.
- "Outflow weakens ... stops when water no longer reaches it" — we've seen weakening to 6.2 at 57%; need to verify it stops at ~47%. Let me quickly test again but would need to wait, expensive. I'm fairly confident because sub→0 at holeBot, Q=0. But one subtlety: when surfaceY gets within a few px of hole bot, particles might still spawn. Fine.
- "Escaped water forms a spreading puddle constrained by floor and room walls" — verified.
- "rocks sink, toy floats, plants bend/drift, fish swim against current before some swept through" — rocks are on bottom, duck floats & escaped, plants bend (were they bending? In breach screenshots plants appear mostly upright with slight lean; flow factor 0.0028*flow.x maybe 0.3 rad, subtle. Could increase to make it obvious).
- "Movable objects that fit the opening can be carried out" — duck escaped, fish escaped.
- "Objects leaving water transition to gravity and collide with floor" — fish flew and landed; duck.
- "Glass fragments rotate, collide, resistance in water" — shards visible on floor, they rotate. Some spawned inward into water. Verified visually.
- Drag crack: verified moving to 560.

Improvements worth doing with remaining time:
1. Plants bend more visibly. Increase target multiplier 0.0028→0.005 and sway. But plants drawn as thin grass with leaves; during breach screenshots they looked upright. The flow at plant tip maybe ~100px/s => target 0.28 rad ~16°, subtle. Increase 0.006 → 0.6 rad. Let's do 0.0045.

2. Water stop simulation: The outflow when surface is below hole top produces a small stream exiting from partially exposed hole - fine.

3. Puddle constrained by room walls: the puddle currently only spreads to right wall and to the breach; it eventually may spread left. Fine.

4. Maybe verify dragging below initial waterline bounds: clamps 356..640. Fine.

5. Fish "swept through" - verified 3 out.

6. The duck escaped - good.

7. The tank appears to float? Its base at y=700 floor, good.

8. Minor: The HUD FISH OUT wide metric style displays label and value on one line, okay.

9. The water jet ribbon alpha and curve good.

10. The breach hole looks like a small dark slot; panel breaking around the opening shown with cracks and shards. Good.

One thing: On Reset while waterline low, all good.

Let me test the full stop quickly by clicking breach and waiting several screenshots. Actually each screenshot advances about 1.5-2s. From 100% to 47% takes maybe 12s → ~8 screenshots. That's a lot but fine, we have time. But more valuable: test crack drag + breach near bottom? Not necessary.

I should verify outflow truly reaches 0. Let me do a quick automated approach: since I can't evaluate JS, I could temporarily set window speed? No. I could add a query parameter? Not needed. Let me just breach and take a few screenshots. We have some minutes. Meanwhile increase plant bend first? Changes require reload and retest, losing state. Do the plant tweak and maybe increase puddle spread, then retest to stop with fresh run. Let's edit plant multiplier to 0.005, and maybe plant length taller for visibility? fine.

Also improve the puddle left spread? It's constrained by the tank visually? At final screenshot puddle extended from x=820 to 1140, not left of tank. Since the breach is on the right, water would naturally run right and spread around; wall at 1140 stops it. Physically puddle should also spread left along floor eventually. Let's increase leveling coefficient maybe 0.3 and steps 3 so it spreads more. But that also flattens the nice mound. Fine.

Also escaped fish on the puddle at x~1000 are drawn lying; good.

Let me make plants bend more. And possibly make surface waves bigger near breach? not needed.

Also noticed: The duck escapes before fish and floats; all good.

One more requirement: "Glass fragments rotate, collide, and experience resistance in water." Good enough.

Let me also ensure no console errors. Console was empty on reload. Good.

Final tweaks: plant bend factor 0.005, and maybe increase puddle leveling to 0.28. Then reload, quick smoke: breach, wait 2 screenshots to confirm no errors, maybe not the full stop. I already trust the stop math. But I want one more check for the stop behavior since it's explicit. Could reduce drain time for test by dragging crack low so only a little water drains! Clever: drag crack to near bottom (640), then breach: initial surface 290, hole top 608, so water drains a lot (290→672) — no. To stop quickly, crack near the initial surface: drag crack to 360 (min 356), hole top 328, bottom 392: after water falls from 290 to 388, stops quickly (~3s). Great test! But requirement says crack must be below initial waterline; 356 is below 290, yes. Waterline then stops at 388 (level 75%). Let's test stop with crack at 356 after tweaks.

Edit plant and puddle.

Now reload and test crack high: drag from (785,470) to (785,360). Then breach and watch stop.

Good. Now drag crack up to 360.

Crack now near the top of the draggable range, above the initial waterline?? Wait initial waterline at y=290; crack at 362 is below it, good. Hole spans 330..394.

Now breach and check stop at waterline 388 (~75%). This should take ~3-4 s.

Hmm, this screenshot is odd: the jet appears as a thin faint curve and there are little bubbles around the hole instead of a dense stream. Also the hole isn't clearly visible? The crack is replaced by a small jagged area at y~360. Water level still 100% (screenshot lag). The jet trajectory extends from x=780 y=360 curving down to x~960 y=690 - gravity curved. But it's very faint and thin because Q=8.7 at ramp-up. The splashes around the hole are the shards? They look like glass bubbles.

Also note the outflow HUD 8.7, DOM 13.8 - HUD update lag. Soon.

Important issue: the crack at 362 is only ~70px below surface. The jet from a hole near surface should arc down. Looks reasonable.

Wait, the jet's starting point seems y=350 whereas the hole is at 362; fine.

But the plants barely bend, and current dots visible. The duck floats at surface and will likely escape.

Wait, the ribbon appears to originate from x=770? and is a thin diagonal line ending at bottom x~950. The particles are tiny. At low head (depth ~70), flow speed is lower, so particles fall quickly; ribbon width maybe 17 but alpha low.

We need to check stop. Let's take another screenshot after ~2s.

Now the waterline is 92% (=690-368=322) and outflow 13.3. The crack at 362, hole 330..394. The duck is passing through the hole! Nice.

But the water level in the tank appears mostly unchanged; 8% drop. The water surface is at y≈320 and hole near 362, so soon stops at 394 (74%).

The jet looks like a dotted curve of droplets, not a continuous jet, because particles are spaced. The ribbon is very transparent now? At this low Q, alpha clamp(0.38+Q/26000)=0.88 yet the ribbon should be visible... In the screenshot, I see faint dashed arcs (particles) plus a faint ribbon maybe. The visible curve is mostly droplet dots. The individual dots are spaced because only ~1.7 particles/frame with velocity 240 px/s => 4px spacing? Actually particle spacing along trajectory ~v*dt/n = 240*0.016/1.7 = 2.3px, should be continuous. But in the screenshot, dots spaced ~10px. That suggests the browser render captures every nth frame or the dt is high? Hmm, or the image is downscaled? The screenshot is 1200x800 exact. Particles look like teal dashes spaced 12px. Their radius 1.9-4.8*stretch; spacing ~10. Maybe spawn ~1 per frame.

Also note the jet seems to pass through the duck (duck is at the hole). It's not obvious.

The puddle near x=950 is small mound. Fine.

Another issue: The duck is being "carried out" while the water level is still above the hole - good.

The waterline is drawn with a large translucent blue area; nice.

The outflow continues; let's check when water reaches 74% and the jet stops. Take another screenshot.

Waterline 86% and Q 7.8 — but wait, why is outflow 7.8 at 86% when the crack is at y=362? Waterline at 86% = 690-344=346. Hole top = 330, hole bottom = 394. So the water is still above the hole bottom by 48px, sub=48. Q ~0.42*48*sqrt(2*1250*head) with head (330+394)/2-346=16 → 0.42*48*200=4032 → display 6.3. plausible. It'll stop at 394 (74%).

The jet now: particles are visible and the duck floats on puddle ~890. Good. But there is no continuous ribbon visible now — the ribbon may be drawn but alpha low? I see only droplets. Wait the ribbon is behind/around the dots? Looking closely, there's a faint blue line from the hole to the puddle maybe. It's fine but I'd like a stronger continuous jet. Perhaps the ribbon isn't rendering because left.length <= 1? No, it runs to floor. Maybe the fill gradient alpha 0.88 but ribbon width 17px would be obvious. Hmm I don't see it. Could it be drawn but clipped by something? drawJet is called after drawPuddle, so should be on top.

Look at the earlier low crack screenshot: the jet was also only particles/bubbles, no ribbon. But at the default crack, the jet ribbon was visible as a smooth tube at first. Why would it disappear? In the first screenshots, the jet was a thin arc line, maybe that was the ribbon but narrow? Actually in default test page, the arc was a thin smooth line - that could be the ribbon with width ~1-2? My width calc lerp(17,3.5)*... should be ~12px at the exit.

Wait — check for an exception in drawJet? If left.length > 1 is true and the fill happens. Hmm.

Maybe the issue is the `ctx.globalAlpha` and subsequent draw calls: within the `if (left.length > 1)` block I create gradient etc. Fine.

Could the ribbon be hidden *behind* the water? No, outside tank.

Wait, in the current screenshot, I can see a very faint blue curved band along the droplet arc; it's there but very light because the gradient's start is rgba(195,248,255,0.85) × globalAlpha 0.4-0.9 => alpha ~0.3. And its width ~12*0.6=7px. The screenshot shows a light blue line under the dots maybe. It's okay but not "water jet" heavy.

Why does it get narrow? sub factor at 86%: sub = (394-346)/64 = 0.75. Width = lerp(17,3.5) * (0.6+0.4*0.75)= at start 17*0.9=15px. Should be obvious. Maybe the screenshot is scaled and it's subtle. The droplets are drawn at alpha 0.72 and are clearly visible. Hmm.

Let me zoom in mentally: near hole at (785,380) there are arcs of dots; the band is visible faintly. It could be that the ribbon is drawn but the gradient endpoints make it nearly transparent except near start. The gradient from x0 to x0+420; at x0+100 it's still 0.85 alpha. Hmm.

Wait, there might be a bug: In `drawJet`, I create `jg` after `ctx.beginPath()` and fill. That's fine. But I used `ctx.globalAlpha` 0.88 etc. Should be visible.

Actually look at screenshot: from the hole to the dots there's a slightly lighter blue curved region maybe 4px wide. Fine. Increasing width would help, but not critical.

More important potential bug: the water level at 86% but the actual water surface drawn at y=340? Tank top rim y=185, water surface drawn at ~342. Fine.

Now verify stop: wait for another screenshot.

At 82% and Q 4.0. The jet is now a dotted arc with a tiny stream. The duck floats on the puddle. The waterline indicator says 82% and the tank surface is at ~360? The hole at 362. Waterline nearly at the hole; stops soon. The jet stream becomes small dots. Fine.

But I notice the water surface appears at y=362, matching. So stop level 82%? Wait earlier I calculated hole bottom 394 = 74%. Here water surface appears ~360, and hole spans 330..394. The crack I dragged is around 362. The hole top 330, bottom 394. So the surface at 360 is within the hole; it will drop to 394. The visible jet source is at hole mid; the jet dots come out even though water surface is above (360 < 394). Good.

One issue: The puddle is only a thin layer near x 780..1130 and has a weird dark tip at x=780 (a small spout). Fine.

The duck's puddle float looks good.

Let me get one more screenshot to see the stop at 74% and Q=0.

Fish out 1/7, and the red fish is now lying on the puddle (visible at x~960) — escaped. The jet at 2.5 L/s is a trickle of dots. Water level 80%. Hmm the hole top is 330, bottom 394, and water surface is at ~373? Level 80% = 690-320=370. So still 24 px above hole bottom. It's slowing.

Wait the crack at 362 → hole top 330, bottom 394. The visible jet exits at hole top/mid from surface. The water level should stop at 394 (74%). It's approaching.

Interesting that fish out only 1 at this point; the fish that exited is on the puddle. The rest are fine.

The duck is on the puddle. Good.

The glass shards on the floor are visible (small white pieces).

I need to confirm it stops. Let me take one more screenshot (maybe Q goes to 0).

Now 2/7 out, pink fish flying through the air outside, red fish on puddle. Water 78%, outflow 1.7. Water should stop around 74%. 

I notice the tank water surface in this screenshot is at y~375, hole top ~330. The waterline almost at the hole bottom. The outflow still 1.7.

Everything works. The plants bend to the right only slightly here because flow is weak. Earlier with stronger flow, did they bend? In earlier screenshots they appeared upright, but since we increased the factor they may bend more. Need not verify deeply.

Now I want to verify the stop reaches 0. The math does: sub→0 at surface 394. At 78% surface=378, sub=16; Q=0.42*16*sqrt(2G*head). head=(330+394)/2-378= -16? Wait head = max(0, (max(holeTop,surface)+holeBot)/2 - surface). With surface 378: top2=378, sub=16, head=(378+394)/2 - 378 = 8. v=141, Q=0.42*16*141=947 → display 1.5. As surface→394, both sub→0 and head→0, so Q→0. Good.

Let me take one more to observe 74% and possibly 0. But each screenshot ~1-2 s. Not strictly necessary, but verification explicitly asks to check outflow stops. Let's do 1-2 more.

Water 78%, outflow 1.3, still slowly dropping. Because the dynamics asymptotically approach hole bottom, the "stop" is asymptotic and the level bar may show 78% for a while. The requirement says "outflow weakens as water level approaches opening and stops when water no longer reaches it." It will eventually stop when sub <0.6. At this rate, surface 382ish, needs 12px more; head small → very slow. Might take 10+ more seconds. That's acceptable physically, but to make the stop cleaner/faster, accelerate the near-zero: stop when sub < 2 (not 0.6) or when head < 1.5. Could bump threshold to sub > 2.5 and head > 2 so it stops earlier with a slight 3px gap. That demonstrates stop clearly within ~8s. Also outflow display may remain 1.3 for a while.

I think it's fine. But to be safe on verification "stops when water no longer reaches it", the current state is water still reaches the opening (surface above bottom edge), so outflow should continue. Correct behavior.

Now, there's one bug I see: a fish seems to be at the water surface at the top left, overlapping the surface line with its body above water (purple/yellow). Because topLimit = surfaceY + size*1.45 = ~20px below surface, but the body drawing is 9px tall, shouldn't stick out. The fish at x=350,y=415? water surface at 382, so 33 below. Fine, they are at surface but inside.

The shape of the puddle is now nice and flat-ish with duck floating. Good.

One thing: the escaped red fish on the puddle is drawn on top of the puddle but at floor y=700-8, i.e., below the puddle surface? It appears lying at the puddle edge, half submerged; fine.

Also, fish out=2 but the pink fish that was flying is now gone from the air and presumably on the puddle too? I only see red on the puddle. Maybe the pink fish already escaped and is behind the duck? Fish count 2. They lie overlapping maybe.

We should finalize. But first, I want to verify reset once more after all modifications and ensure no console errors. Also check the "stop" maybe with a fast-forward impossible. Not critical.

Potential improvements in remaining time:
- Make the flow stop threshold clearer: change `if (sub > 0.6 && head > 0.5 ...)` to `sub > 2 && head > 1.2` so it stops with water 2px above the bottom edge and shows outflow 0.0. This ensures a crisp stop test. The waterline then rests just above hole bottom. Good. Let's do it.
- Fix the "DRAG CRACK" label hidden after 16s? It's fine; on reset time=0 shows.

- Maybe add a tiny bit more visual jet thickness. Not necessary.

I also want to double check that dragging is the only way the crack moves and the Breach uses the crack center. Yes.

- Check outflow at the start is strong: 25 L/s, waterline falls 100→84 quickly. Good.
- Jet curve: screenshot shows it curving downward with the arc. Verified.
- Reset: verified earlier; after edits reset code unchanged. Let's verify once more at the end.

Another thought: Requirement "Initially show an intact glass tank containing water, fish, rocks, plants, and a floating toy." Yes. "Let the user drag a visible crack vertically on one side below the initial waterline" - yes, bounds 356..640 vs waterline 290.

Potential issue: The crack is drawn at the wall x=785, and the knob/hit area extends into the room outside the tank; users can grab it. Good.

Let me apply the stop threshold and verify reset. Also add a subtle "waterline marker" after breach? Not needed.

One more thing: the fish "swim against the current": visually fish near the hole face left while being pulled; looked good in screenshots. Great.

Let me update threshold and maybe reduce asymptotic tail. Also console check via reload.

Now final verification: reload, drag crack maybe not, breach, quick screenshot, reset. Also check console. Reload returns console. Let's do it.

This screenshot is nice and clear. However, I notice now the "DRAG CRACK" label and crack knob: the crack zigzag is at x=785, but label is at x≈810. Good. The plants are at the bottom but look like simple grass. Rocks visible. 

Wait — the duck is at y=282 sitting on the waterline. Good.

One cosmetic issue: the crack knob at y=470 is a gray circle with chevrons; okay.

The tank looks like it extends below the floor line? The tank base is at floor 700; yes aligned. There's a gray base strip. Good.

Also the room side walls at 60/1140 are visible as faint lines.

Now click breach and verify quickly.

Now the jet is very thin/faint (a 2px line) and the droplets count low at the beginning. Hmm. Why is the ribbon so thin now? It should be 17px wide at start, but the screenshot shows a 2px curve. Something's off.

Ah, I see: the jet ribbon alpha gradient is there but maybe the ribbon's path is being drawn with fill that is mostly off? The ribbon extends from the hole and curves down. The visible line is extremely thin. Compare with particles visible near hole.

Wait — the screenshot shows a thin cyan curve and small bubbles exiting. The ribbon fill may not be visible because globalAlpha is applied but the fill surface is... Let me re-check the code for drawJet. After my edit, the fill block is inside `if (left.length > 1)`. It should work. Width 17px would be clearly visible. Unless `ctx.globalAlpha` is stale? 0.38+17/26 ≈ 1.04 clamp 0.9. Hmm.

Could the width actually be tiny because `sub` is small? sub = (holeBot - max(holeTop,surface))/HOLE_H. Initially surface 290, crack 470 → hole 438..502 fully submerged → sub = 1. width start = 17*1=17. So no.

Maybe the ribbon is drawn correctly but it's behind the water / not visible because of z-order? drawJet is after drawPuddle, so on top of everything. The thin curve is from the *particles* aligned. The ribbon is invisible maybe due to a bug: after beginPath and lines, `ctx.fillStyle = jg; ctx.fill();` — jg is a linear gradient from x0,y0 to x0+420, y0+260. Colors have alpha, multiply globalAlpha. Should show.

Is it possible that the ribbon is not being drawn due to an exception? If an exception were thrown in drawJet, the rest of render (droplets/splashes/shards/escaped) would not be drawn. But droplets and shards are drawn. So no exception.

Wait, look at the top of the thin curve: at the hole there is a teal conical bit; the curve is thin. Perhaps the ribbon got overdrawn by the water jet's droplets? No.

Hold on, maybe the gradient alpha: the fill style is gradient along x0,y0 to x0+420,y0+260. The gradient stop at 0 is rgba(195,248,255,0.85) — visible.

Maybe the fill is there but appears as the thin line because... left/right points: I push y ± w/2 for each step and then draw left forward and right backward. That's correct polygon.

Width w = lerp(17,3.5,i/steps)*(0.6+0.4*sub) = 17 at start. That's 17px. In the screenshot, the line looks 2-3px. Maybe the screenshot shows the ribbon's edge highlight? The ribbon in the screenshot from hole (785,470) to floor (960,690) looks like a 2px stroke. Hmm.

Wait, maybe CSS scaling: the screenshot is 1200x800 and canvas 1200x800. No scaling.

Could `ctx.globalAlpha` be set low elsewhere and not reset? drawJet sets it at start 0.9. Then fill. It's inside ctx.save/restore. Fine.

Could the gradient be nearly transparent due to color stops all at alpha but ctx.globalAlpha changed? Doesn't matter.

Let me look at the screenshot more carefully: There might be a pale blue ribbon ~8px wide extending from the hole, but it's nearly invisible against the bright background; actually I see a faint wide band? The image at the jet: a thin bright line with the droplets forming a sort of spray. I think the ribbon is that pale blue translucent band around the line? It's hard to tell.

Earlier (default test) the jet appeared as a thin smooth line too. So the ribbon probably renders narrow. Maybe the `fill()` is working but the ribbon is too transparent. Increase alpha/stops and width. Let's make the jet much more visible: gradient with alpha 0.95 at start, 0.75 middle; width 22 → 5; plus draw a bright core stroke 2px along centerline. That will guarantee the stream reads as water. Also increase globalAlpha to 1.

I'll update:
- width: lerp(22,4,...)
- jg stops with higher alpha, start 'rgba(210,250,255,0.95)', mid 'rgba(120,215,245,0.85)', end 'rgba(90,180,220,0.35)'
- globalAlpha = clamp(0.55+Q/30000,0.55,1)
- add centerline stroke.

Also, the "suction streaks" (white fibers) look good at this moment actually—thin flow lines converging. Okay.

Another thing: at 99% water with Q 21.9 (screenshot 17), the jet curvature is visible and ends at floor. Good.

Let's make the jet thicker.

Test quickly: reload, breach, screenshot.

Good. Breach now.

The jet is still very thin! Width 22 should be 22px... but it renders as a 2px line. There must be a bug: the ribbon polygon is collapsing. Let's think: left points [x, y - w/2], right [x, y + w/2]. Build path left forward, then right backward. For i=0, left=(x0, y0-11), right=(x0,y0+11). For later i, x increases and y curves down. This creates a proper ribbon. Unless... the fill is not visible because the gradient alpha and fill style? alpha 0.55-1.

But the visible line is a hairline. Maybe the ribbon is being drawn but is entirely behind the *particles* and the thin line is its bright core stroke (1.6px). The fill could be transparent because of the gradient? createLinearGradient(x0, y0, x0+420, y0+260) then addColorStop. All fine.

OH WAIT. I see it! In `drawJet`, I have the outer `ctx.save()` at the beginning, then draw ribbon. After the `if (left.length > 1)`, I added `ctx.restore();` earlier, which is *inside* the `if (mode===...)` block. But did I set the `ctx.globalAlpha` right? Fine.

Hmm, maybe the issue is `ctx.fillStyle = jg` followed by `ctx.fill()` gets canceled because the current path after building left/right is not closed? I do closePath. Fine.

Let me look at the actual current code to verify structure and maybe the ribbon is not drawn due to `T` being reached quickly? If the ribbon is short, say only 2 points, then from hole to a short distance; the rest of the visible line is particles. In the screenshot, the line extends to the floor with even thickness, and there are droplets near the start. T=0.8s, jetSpeed ≈ 390 → up to x=1100. It should end at floor x≈965. y at 0.8 = 470+6+400=876 → truncated at floor ~y=695 at t? solve 470+8t+625t²=695 → t≈0.53 → x=785+206=991. So the ribbon spans x 785..991. The visible line extends to x≈995. So the line might be the ribbon's bright core, but why isn't the fill visible?

Wait, the width varies from 22 px down to 4.5; at the start, the ribbon is 22px thick. In the screenshot near the hole, the spray is ~20px spread (droplets). Hmm the ribbon should be there as a pale band. Maybe it IS there but extremely faint due to color over a light background. The bright core line is obvious. The fill alpha ~0.9, color rgba(120,215,245,0.85) → should be quite visible (light cyan on pale blue-white background). The background outside the tank is very light gray, so cyan at high alpha should show.

Unless... globalAlpha = 0.55? combined with the gradient alpha → 0.47; still visible.

Hold on, maybe there is a second render call that overwrites? No.

Let me inspect the image pixel colors around the jet to determine. Use Python to sample pixels near x=880,y=560. Let me compute the trajectory: at x=880 -> t=(880-787)/390=0.238; y=470+8*.238+625*.0566=470+1.9+35.4=508. Sample around (880,508) for cyan band. Use PIL.

No screenshot file. Maybe the browser tool stores somewhere. Not critical. I could use browser screenshot and crop? No.

The jet line visible is likely the core line over the translucent fill, and the fill might be subtle. Visually it reads as a water jet due to the droplets and core. In the earlier default image the arc was thick-ish? Looking at the first breach screenshot, the jet appeared like a solid curved band about 6-8px. Now it's thinner. Weird variance could be due to `sub` and particle alignment.

Wait, I wonder if the gradient fill has a bug due to `ctx.createLinearGradient` with y coordinates outside canvas? No.

Let me look at the current drawJet code again in full.

The code is fine. So the ribbon is drawn. Maybe in the screenshot it is visible as a light blue wide band but the bright core makes it look thin at this scale. The image shows a thin line with a subtle pale band? Hard to tell. Hmm.

Wait, look again at the screenshot: the jet arc from the hole is a thin *cyan* line about 2px, and there are light-blue dashes near the start at x 790-850. The wide band is absent. Suspicious.

Could the ribbon be drawn *behind* the background because of the ctx transformation? No.

Could `ctx.globalAlpha` from previous draw calls be low? We set 0.55+. 

OH! I think I see: `drawJet` is called after `drawPuddle`, and the ribbon is drawn, but *the canvas is cleared and redrawn every frame; the ribbon may be visible*. No issue.

Maybe the issue is color: the room background near the arc is white-ish #eef4f7. A semi-transparent cyan band would darken it noticeably. Not seen.

Hmm, is `ctx.fill()` using the current path? After `ctx.closePath()`, yes.

Is it possible that left/right arrays have x values beyond the canvas and the polygon self-intersects? The polygon goes left forward (down-right), then right backward to start; proper.

Could `sub` be 0 due to surfaceY? At this moment surface 99% (293), crack 470 → sub=1.

I'm puzzled, but the functionality "gravity-curved jet" is clearly visible via the core line and droplets. It looks acceptable, though I'd like a denser jet. Alternative approach: draw the stream as a stroked polyline with varied lineWidth (thick to thin) and high alpha. Stroke is reliable. I'll replace the fill ribbon with a thick stroked path using `ctx.lineWidth = 12` tapering trick not possible with single stroke. But I can draw several segments with decreasing lineWidth and stroke each.

Simplest robust: draw the centerline path and stroke with width w (average 10) and rgba(150,225,250,0.7); plus a thinner bright core. Tapering can be approximated by segments:
```
for i=0..n-1: beginPath moveTo(p[i]) lineTo(p[i+1]); lineWidth = lerp(18,4,i/n); strokeStyle rgba(...); stroke();
```
This guarantees visible thickness. Let's do that instead of fill ribbon. Keep the fill too if it works. Better: replace block.

Also the droplets are quite small and sparse near the start. It's okay.

Let's implement segmented stroke. This is a cosmetic improvement, but worth it since the jet is a key visual.

Also I should check the stop behavior and reset once more, then finish. Time budget: we're maybe 12 minutes in. Fine.

Implement:
```
if (left.length > 1) {
  ctx.lineCap='round'; ctx.lineJoin='round';
  for (let i=0;i<left.length-1;i++){
    const cx=(left[i][0]+right[i][0])/2, ...
    const nx=...;
    ctx.beginPath(); moveTo(cx,cy); lineTo(nx,ny);
    ctx.lineWidth = lerp(20,4,i/(left.length-1));
    ctx.strokeStyle=`rgba(140,225,250,${lerp(0.8,0.3,...)})`;
    ctx.stroke();
  }
  // core stroke
  ...
}
```
This draws overlapping segments smoothly. Remove the fill. Since the segments overlap with round caps, it will look continuous.

Let's replace the fill block.

Test reload and breach screenshot.

Good initial. Click breach.

Now the jet is a clear thick cyan arc curving downward. Great. The HUD in this screenshot is stale (100%, 0.0) again due to capture timing; DOM says 99% 21.9.

Also notice fish are all turning left against the current. Good.

But wait, the crack at 470 means the jet starts at y=470; the waterline is at 290. Fine.

The arc ends at the floor near x=1000, good.

One issue: at the breach, the shards around hole look like sparkles; the hole itself is a small teal rectangle. Panel breaking is okay.

Now test reset once more after the breach. Then finish. Maybe also confirm fish escaping after a few seconds in this run: already verified. No need.

Let me click reset and screenshot.

Reset restored intact scene perfectly. 

Everything checks out. Remaining unverified: full asymptotic stop to Q=0 (we saw it weaken to 1.2 L/s; math guarantees stop, and threshold change makes it stop slightly earlier). Glass fragment water resistance (only visually seen shards). Not directly verified fish count over time after latest tweak? We saw 3/7 in an earlier build and 2/7 in another. Fine.

One final consideration: The HUD screenshot often shows stale water/outflow, but DOM matches state. It's just screenshot capture timing. Fine.

I could make one last improvement: the puddle should be constrained by the tank base? It spreads left of the breach if enough volume; currently stays right. Fine.

Also check no console errors: console empty on reloads. Good.

Final file exists. Report concisely. Mention what was tested and unverified.

Actually, one thing to double check: In the release version, fish escapes depend on waterAtHole condition fixed. Verified 2-3 escaped. Toy escaped. Good.

Let me maybe run a quick grep for syntax errors using node? JS inside HTML, but browser console empty means fine.

Report: 
- Built index.html.
- Verified initial scene, crack drag (moved), breach, jet curve, waterline 100→78% with outflow 22→1 L/s, puddle, fish escape 3/7, duck carried out, shards/objects land, reset restores.
- Unverified: complete stopping at zero (observed asymptotic weakening), detailed collision behavior of every shard, plant bend magnitude.

Done.