We need respond by creating file index.html in current dir. Need build real-time fluid simulation full-screen canvas dragging mouse pushes swirling colored dye through fluid. No external resources. Need inspect cwd maybe empty. Need write single self-contained HTML. Need maybe implement with JS canvas. Need think deeply. Need produce actual file. Need maybe use tools. Need current /tmp/ws. Need maybe list.

Need write index.html. Need no external. Need implement real-time fluid simulation. Could use canvas 2D with dye advection? Full screen. Need dragging mouse pushes swirling colored dye. Need performance. Options:

- Use 2D canvas, low-resolution grid, simulate velocity and dye fields with semi-Lagrangian advection, projection to incompressible, vorticity confinement, pressure solve. Fullscreen high DPI scaling. Pointer events.

Need single file. Need no external. Need include CSS. Need canvas full-screen. Need script.

Need implement robust. Let's design.

Canvas full-screen. Simulation grid maybe W=256/320 by H=256/320 based on aspect. Use offscreen image buffers for dye and velocity? We can store Float32Array for dye rgba and velocity vx/vy, previous arrays. Use canvas 2D image data for rendering at lower resolution scaled to full screen. Dragging injects velocity and dye.

Need "real-time fluid simulation" on full-screen canvas. A simplified stable fluids algorithm:
- Grid resolution maybe 256x256? For full screen aspect, store width = canvas.width / scale? Since rendering canvas at devicePixelRatio but sim at lower. Need full-screen canvas CSS width/height. Set canvas.width = cssWidth*dpr, canvas.height=cssHeight*dpr. Render offscreen simulation canvas at simW x simH, then drawImage stretched to canvas. Need image smoothing maybe false or true? For fluid, maybe true? Use canvas 2D.

- Fields:
  - vx, vy arrays length N
  - dyeR,G,B,A arrays length N. Maybe single Uint8ClampedArray dye pixels length N*4 for rendering and storing? For advection, need sample dye from image data. Could store Float32Array dR,dG,dB,dA? Simpler use Float32Array for each channel. N maybe 256*256=65536, 4 channels 1MB each, fine. vx/vy 0.5MB each. Use Float32.
  - prevVX, prevVY, prevR,G,B,A maybe for advection.
  - maybe vorticity? We can use vorticity confinement.

Simulation steps:
- Clear fields? At start maybe fill dye white/blue? We can start with background dark gradient/noise, then dragging injects colored dye. Need swirling colored dye through fluid. Could inject random colors on drag.
- Pointer:
  - On pointer down set isDown, lastX/Y, lastTime, inject at current point with velocity from pointer movement and swirl.
  - On pointer move, compute dx,dy from last to current, speed. Add velocity to grid around radius (e.g., 30px sim units). Push fluid: vx += dx * strength, vy += dy * strength. Add swirl tangent: add perpendicular vector depending on radius and pointer speed. Also inject dye color around center with alpha and random hue. Use canvas 2D? Could write to Float32 arrays.
  - If not moving but down, inject swirl at center with no velocity.

- Advection:
  - For each cell i:
    - x = (i%W) + 0.5, y = floor(i/W)+0.5
    - sample vx,vy with bilinear at x - dt*vx[i], y - dt*vy[i] from previous arrays. Use clamp.
    - Update prev fields to current? Standard: advect(v, dt, prevVX, prevVY, vx, vy); prevX = current velocity. Then set v = advected value.
    - For dye: advect each channel with velocity from prev? Need use previous velocity. Standard:
      1. dt = fixed time.
      2. diffuse? Could skip.
      3. advect velocity with prev arrays.
      4. project velocity.
      5. advect dye with updated velocity.
    - But for injection after projection? Use step order:
       - Add force/injection before advection? We'll inject directly into velocity/dye.
       - Simulate:
          a. Add velocity from pointer to vx/vy.
          b. Advect velocity with dt from prev arrays into new arrays? But if we reuse arrays, need careful.
          c. Project velocity.
          d. Advect dye with dt using projected velocity from prev dye to new dye.
          e. Fade dye, decay velocity.
    - We can use separate arrays for current and previous. For each frame:
       - Use prevVX, prevVY for advecting current vx/vy into temp? But need projection modifies vx/vy in place.
       - Standard:
         * prev.copy(vx), prev.copy(vy)
         * addForces(vx,vy)
         * velocityStep(vx,vy,prevVX,prevVY,dt)
         * project(vx,vy)
         * dyeStep(dR,dG,dB,dA,vx,vy,dt)
         * fade
       - velocityStep implementation:
          for i:
             x=...
             vx[i] = sample(prevVX, x - dt*vx[i], y - dt*vy[i])
             vy[i] = sample(prevVY, x - dt*vx[i], y - dt*vy[i])
          Note uses original vx/vy for tracing.
       - dyeStep:
          for i:
             x = x0 - dt*vx[i]; y = y0 - dt*vy[i]; sample prev dye arrays.
       - Need maybe vorticity confinement:
          after projection? Compute curl = dvy/dx - dvx/dy. Normalize gradient of curl and add force to velocity = eps * cross(n, curl) (2D n x curl? f = eps * vec(-n.y*curl, n.x*curl) maybe).
       - Project:
          Need solve pressure Poisson for divergence-free velocity. For incompressible stable fluids:
          for i:
            divergence[i] = -0.5*(vx[i+1]-vx[i-1]+vy[i+W]-vy[i-W])/W
            pressure[i]=0
          for 0..20 Jacobi:
            pressure[i] = (divergence[i] + pressure[left]+pressure[right]+pressure[up]+pressure[down])*0.25
          for i:
            vx[i] -= 0.5*(pressure[i+1]-pressure[i-1])*W
            vy[i] -= 0.5*(pressure[i+W]-pressure[i-W])*W
          This is common for grid spacing 1/W. Need handle boundaries.

       - Boundary conditions:
          Need arrays size W*H. We can use padded width W+2 and height H+2, with W sim width, H sim height, stride = W+2. Then index = y*stride+x. Boundary x=0,W+1,y=0,H+1. Use padded arrays for easier pressure. N = (W+2)*(H+2). Interior indices 1..W,1..H. For rendering, need only interior pixels. This simplifies projection.
          For advection sample at x,y in interior. For pressure boundary? Initialize pressure to 0 at boundaries.
          For projection:
            divergence for interior:
              -0.5 * (vx[y*stride+x+1]-vx[y*stride+x-1] + vy[(y+1)*stride+x]-vy[(y-1)*stride+x]) * S
            pressure = 0
            Jacobi for interior:
              pressure[i] = (divergence[i] + pressure[left]+right+up+down)*0.25
            subtract:
              vx[i] -= 0.5*S*(pressure[right]-pressure[left])
              vy[i] -= 0.5*S*(pressure[down]-pressure[up])
            Boundary maybe set 0.
          Need pressure array float length total.
          Need maybe zero boundary after projection.

       - Vorticity confinement:
          curl[i] = (vy[right]-vy[left])*S - (vx[down]-vx[up])*S
          n = gradient of |curl| maybe with eps=0.05? f = eps * ( -n.y*curl, n.x*curl). Add to velocity. Use curl magnitude gradient? Could compute normal = gradient(abs(curl)) normalized.
          But adding after projection? Standard after projection. Could do after projection before dye advection. Need pressure after force? If add force after projection, velocity not exactly divergence-free, but okay. Or diffuse/force/projection. We can do force after injection and before projection? Vorticity after projection maybe. It's fine.
          Need maybe diffusion? Could skip. Add small fading.

       - Dye advection:
          for i:
             x = (i%xStride?) We can compute x = ix - dt*vx[i], y = iy - dt*vy[i]; sample prev dye arrays.
          Then fade:
             for i: dR[i]*=0.999 maybe; alpha *= 0.995; add background? Since we store dye only, render black if alpha low. Could initialize dye to dark blue? For background, render background gradient separately? Since dye alpha maybe 0 and background black. Could draw background then draw dye with composite. Better render:
              - Fill offscreen canvas with dark blue/black.
              - Put image data for dye (rgba values) with alpha maybe 0.95. Draw with source-over or lighter.
              - Then drawImage offscreen to main.
            Need dye alpha initial maybe 0.8. Fade over time. We can add subtle background color into dye? Not needed.
          If alpha fades too fast, dragging continuous.

       - Need color injection:
          - Hue from time/random, saturation, lightness. Convert hsl to rgb.
          - radius sim units maybe 28. For cells within radius, add dye:
             dyeR[i] += r*strength; etc; alpha += 0.7
             maybe swirl color.
          - To create "swirling colored dye through fluid", inject color with spiral pattern:
             angle = atan2(dy, dx)? swirl = (ix-cx)^2? Maybe assign hue based on angle around pointer and distance.
          - Velocity injection:
             for cells within radius:
                vx[i] += dx * 0.12 + tangentX * 0.45 * falloff
                vy[i] += dy * 0.12 + tangentY * 0.45 * falloff
             tangent = (-dy, dx) normalized * speed* maybe.
             plus radial outward? 
             Use strength = min(1, speed/8) maybe.
             We need stable dt. Use dt = Math.min(0.033, (now-last)/1000).
             velocity units pixels per frame? If grid size sim width ~256, dx in pixels sim units. If dx=10, vx += 5. Vorticity. Need not too high. Could set vx += dx*0.08, vy += dy*0.08; tangent += speed*0.08? Maybe.
          - Pointer down at start inject swirling dye at point.

       - Need render scaling:
          Offscreen canvas simCanvas width W height H. Offscreen context imageSmoothingEnabled = false? If false, pixelated. Maybe true for smooth. But fluid simulation can be blocky. Full screen. Use CSS image-rendering auto. Use main ctx drawImage. Need maybe canvas covers viewport.

       - Need display instructions overlay maybe. But no external. Need canvas full screen. Could include small HUD with instructions and FPS. CSS pointer-events none. Need not create separate.

       - Need support touch. Use pointer events. Prevent default. Need pointer capture.
       - Need resize:
          - update canvas CSS size via viewport.
          - set dpr = min(window.devicePixelRatio||1, 2)
          - canvas.width = Math.floor(innerWidth*dpr), height.
          - Offscreen W/H maybe based on min dimension. Let base = Math.min(320, max(180, Math.floor(Math.min(innerWidth,innerHeight)/2.2)))? For full screen, if wide, W maybe 384 and H based aspect. Need fit memory.
             const simW = Math.min(384, Math.max(160, Math.floor(innerWidth / 2.4)));
             const simH = Math.min(384, Math.max(160, Math.floor(innerHeight / 2.4)));
             If aspect huge, cap H maybe 384. Fine.
          - Reinitialize arrays on resize. Need not too often. Could debounce? Use resize event.

       - Need avoid memory? Total arrays:
          vx,vy,dR,dG,dB,dA,prev...,pressure,curl,total. If W=384,H=384,stride=386,total=148996. Each Float32 0.6MB. 10 arrays ~6MB. Fine.

       - Need maybe use Uint8ClampedArray for dye rendering? Float32 arrays easier. But to render image data, create Uint8ClampedArray per frame? Could be costly but okay. Better create Uint8ClampedArray buffer length total*4 once, and copy from Float32 to Uint8 each frame. Then putImageData. But Float32 to Uint8 loop each frame. Fine.
          Or use ImageData with Uint8ClampedArray length W*H*4 and fill. Need mapping interior. We can create imageData = simCtx.createImageData(W,H), data = imageData.data; For each y/x index j = y*W+x, set data[j*4+k] = clamp dye. This loops N each frame. Good. Then putImageData. Need no image smoothing.
          Need maybe add background to imageData? Fill black before. Use simCtx.fillStyle = '#02030a'; fillRect. Then copy dye data. Since alpha 0..1.

       - Need maybe use OffscreenCanvas? Not needed.

       - Need implement bilinear sample:
          function sample(arr, x, y) {
             if (x < 1 || y < 1 || x > W || y > H) return 0;
             const x0 = Math.floor(x);
             const y0 = Math.floor(y);
             const tx = x - x0; const ty = y-y0;
             const i00 = y0*stride+x0; i10 = i00+1; i01=i00+stride; i11=i01+1;
             return (1-tx)*(1-ty)*arr[i00]+...
          }
       Need for x > W? If x0==W? if x in (W,W+1) sample interior and boundary maybe arr at W+1? Our arrays include boundary at W+1. But for dye, boundary 0. Need maybe clamp x to [1,W], y to [1,H] before sample? If x>W, x0=W, tx>0, i10=right boundary. Need arrays for dye boundary maybe 0. For velocity boundary maybe 0. Simpler clamp:
          if (x < 1) x=1; if (y<1)y=1; if(x>W)x=W; if(y>H)y=H;
          Then x0<=W-1? If x==W, x0=W, tx=0, i10=W+1? Actually if x0= floor(W)=W, i10=W+1 boundary. Need okay. For x= W exactly, i00 y*stride+W, i10 boundary. But if x0 = Math.floor(x); if x==W, x0=W, tx=0, sample i00 only. i10 not used. For x near W, x0=W-1, tx<1, i10=W. Good. Fine.
          For y==H similarly.

       - Need projection pressure:
          arrays pressure length total. initialize pressure boundary =0. Jacobi. Need maybe set pressure interior.
          Divergence array? Could reuse pressure? Need divergence values for Jacobi. Use pressure array? We can compute divergence in pressure? Need hold divergence. Use pressure array for pressure, divergence array separate. Could use velocity? Better pressure and divergence arrays. Arrays increase.
          For Jacobi, pressure values. After each iteration, pressure interior =...
          Need divergence computed every projection. Could compute into pressure? Then Jacobi needs old pressure. Need divergence array. Use div array.
       - Need maybe use fixed number iterations: 20 or adaptive. For W=384, 20 okay. Maybe 12 for performance. Need real-time. Use 14.
       - Need maybe "real-time fluid simulation" more credible if stable fluid. Use dt.

       - Need maybe add "dye diffusion"? Could skip. Maybe use small diffusion? Not necessary. Could add color mixing maybe.

       - Need maybe "swirling colored dye through fluid" with drag. Need maybe pointer movement pushes fluid and swirl. Need maybe draw trail as colored vortices.

       - Need maybe implement "force" injection in simulation step before advect. But if injection each pointer move then advection moves it. Need if user drags quickly, injection cells are advected. Good.

       - Need maybe when not pointer down, apply small fading/decay. Need maybe "global background swirl" maybe. But user asked dragging. Could include ambient subtle current to make fluid alive.
          - Add a faint background curl maybe:
             vx[i] += Math.sin((y*0.03)+time)*0.005
             vy[i] += Math.cos((x*0.025)-time)*0.005
          - But injection enough.
       - Need maybe "full-screen canvas" no scroll. Body margin 0 overflow hidden. Canvas fixed.

       - Need maybe include "Click/drag to stir; release to let dye swirl." Overlay.

       - Need maybe use `will-change: transform`? No.

       - Need maybe ensure no external resources. No imports.

Need decide final file content. We can write. Need maybe test with browser? We can maybe run node? Not needed. But maybe use `python`? Could run `python` to parse? We can maybe use `node` to check syntax? HTML script can be extracted and node --check. Need perhaps run `node --check` on script after extracting. But no browser. Use `node --check` maybe.

Need produce index.html. Let's craft carefully.

Potential issue: `createImageData` each frame? We can create once. `simCtx.putImageData(dyeImage,0,0)` copies. `dyeImageData.data` is Uint8ClampedArray.
Need main canvas maybe has dpr and CSS. `ctx.drawImage(simCanvas, 0,0, canvas.width, canvas.height)` draws simCanvas scaled to actual pixel size. Offscreen canvas internal W/H. CSS? simCanvas not in DOM. Good.
Need set `ctx.imageSmoothingEnabled = true` on main. Offscreen context maybe false.

Potential issue: `ctx.fillStyle` background and `putImageData` with alpha. If dye alpha low, transparent shows black. Good.

Need maybe if `ctx` for main not set? yes.

Need maybe `requestAnimationFrame(animate);`.

Need maybe variable `lastFrame` initialized performance.now. `dt` = Math.min(0.033, (now - lastFrame)/1000). If first dt 0.016.
Need maybe use `dt = Math.min(0.033, Math.max(0.001, ...))`. If hidden tab, dt cap.

Need arrays initialization:
```
let W,H,stride,total;
let vx,vy,dR,dG,dB,dA,prevVX,prevVY,prevR,prevG,prevB,prevA,pressure,divergence,curl;
let dyeImage, dyeData;
function resizeSimulation() {
 const dpr = Math.min(window.devicePixelRatio || 1, 2);
 const cssW = window.innerWidth;
 ...
 canvas.width = Math.floor(cssW*dpr); canvas.height = ...
 canvas.style.width = cssW+'px'; ...
 const base = Math.min(420, Math.max(180, Math.floor(Math.min(cssW,cssH)/2.1)));
 W = Math.min(420, Math.max(160, Math.floor(cssW/2.3)));
 H = Math.min(420, Math.max(160, Math.floor(cssH/2.3)));
 stride = W+2; total = stride*H;
 allocate...
 initDye();
}
```
Need if resize many times, arrays reallocated. Good. But if resizing with pointer active, reset maybe okay. Could not reset dye if only DPR changes? Sim W/H changes. Fine.
Need maybe initial dye background:
```
function initDye() {
 for i: dR[i]=0; dG[i]=0; dB[i]=0; dA[i]=0;
 // add subtle blue background? Maybe dA=0.05, dB=0.1? But if background black, initial fluid not visible. Could add very subtle dark blue everywhere:
 const t = performance.now()*0.001;
 for y...
    const n = 0.5+0.5*Math.sin(x*0.03 + t)+...
    dA[i] = 0.02; dB[i]=0.05 + n*0.08; dR[i]=0.01; dG[i]=0.03;
```
But injecting color stands out. Maybe start with subtle blue.
Could also create a few colored dye blobs on load for visual. Maybe not necessary but nice. On first frame, inject 5 blobs? But user asked drag. Could create initial swirl to show. Maybe after resize, add initial dye at center? We can call `seedDye(0.5*W,0.5*H, 0.7, 120);` maybe. But if no user, fluid has some. Fine.
Need maybe `pressure.fill(0); divergence.fill(0); curl.fill(0);`

Need allocate arrays:
```
function allocate() {
 vx = new Float32Array(total); ...
}
```
Need memory.

Need HSL conversion:
```
function hslToRgb(h,s,l){... return [r,g,b];}
```
For injection maybe compute each pointer move. HSL to RGB returns 0..1.
Need add dye:
```
function injectDye(cx,cy,radius,hue,saturation,lightness, amount) {
 const r2 = radius*radius;
 for y=1..H:
   const dy=y-cy;
   for x=1..W:
      const dx=x-cx; d2=dx*dx+dy*dy;
      if d2 <= r2:
         const falloff = 1 - Math.sqrt(d2)/radius;
         const swirl = Math.atan2(dy,dx) + (1-falloff)*Math.PI*2;
         const color = hslToRgb((hue + swirl*180/Math.PI + (1-falloff)*60) % 360, saturation, lightness);
         const idx = y*stride+x;
         const local = falloff*falloff*(3-2*falloff);
         dR[idx] += color[0]*amount*local;
...
         dA[idx] = Math.min(1, dA[idx] + 0.55*local);
```
Need maybe use `Math.hypot(dx,dy)`? We have sqrt for falloff. Fine.
Could add background "smoke" by adding alpha.

Need inject velocity:
```
function injectVelocity(cx,cy,velocityX,velocityY,amount) {
 const radius = Math.max(18, Math.min(44, 26 + amount*20));
 const r2 = radius*radius;
 const speed = Math.hypot(velocityX,velocityY);
 const nx = velocityX/(speed||1), ny=...
 for cells:
   const dx=x-cx,dy=y-cy; dist2...
   const falloff = ...
   const tangent = 1.2*falloff*falloff;
   vx[idx] += velocityX * 0.10 * falloff + (-ny*velocityY + nx*dy? hmm)
```
Need swirl tangent. Given pointer movement vector v=(dx,dy). Tangent perpendicular = (-dy, dx). Add to velocity with strength proportional to speed and falloff. Also radial? 
```
const push = 0.08 * falloff;
vx += vxMove * push;
vy += vyMove * push;
const swirl = (0.22 + Math.min(speed,40)*0.006) * falloff*falloff;
vx += -vyMove * swirl;
vy += vxMove * swirl;
```
But vxMove variable conflicts field. Use `moveX, moveY`.
Need maybe if speed low (pointer down) inject radial swirl:
```
const angle = Math.atan2(y-cy,x-cx);
const radialX = Math.cos(angle)*0.08*falloff;
vx += radialX*0.08;
vy += radialY*0.08;
```
Maybe.
Need pointer event:
```
let pointer = {down:false, lastX:0,lastY:0, lastT:0, hue:0};
function pointerToSim(clientX,clientY){
 return {x:(clientX-rect.left)*(W/rect.width), y:(clientY-rect.top)*(H/rect.height)};
}
canvas.addEventListener('pointerdown', e => {
 e.preventDefault(); canvas.setPointerCapture(e.pointerId); pointer.down=true; ... last...
 injectDyeAndVelocity(x,y,0,0,hue);
});
canvas.addEventListener('pointermove', e => {
 if(!pointer.down) return;
 e.preventDefault();
 const now=performance.now();
 const rect=canvas.getBoundingClientRect();
 const x=...
 const dt=Math.max(0.001, Math.min(0.033,(now-pointer.lastT)/1000));
 const moveX=x-pointer.lastX; moveY=y-pointer.lastY;
 const speed=Math.hypot(moveX,moveY)/dt;
 const radius = Math.min(52, Math.max(22, 24 + Math.min(speed,80)*0.25));
 injectDye(x,y,radius, pointer.hue + (Math.random()*30-15), 0.85, 0.55, 0.9);
 injectVelocity(x,y,moveX,moveY,Math.min(1, speed/80));
 pointer.hue=(pointer.hue+18+Math.random()*20)%360;
 pointer.lastX=x; pointer.lastY=y; pointer.lastT=now;
});
['pointerup','pointercancel','pointerleave'].forEach...
```
Need `pointerleave` while captured? If pointer captured, leave might fire? We can use pointerup. `window.addEventListener('blur')`.
Need maybe `e.button !== 0` ignore? For touch button maybe -1. Use if e.pointerType==='mouse' && e.button !==0 return.
Need maybe CSS `touch-action: none`.

Need maybe pointerdown if no previous last, set last to x. But injection with no velocity.
Need maybe if pointer moves with dt huge, speed maybe huge but cap.

Need maybe add "dragging mouse pushes swirling colored dye through fluid." Good.

Simulation details:
```
function step(dt) {
 const S = 1 / W;
 // optional ambient currents
 for y=1..H:
  for x=1..W:
    idx = y*stride+x;
    vx[idx] += Math.sin(y*0.05 + t*0.7)*0.002;
    vy[idx] += Math.cos(x*0.05 - t*0.6)*0.002;
 // advect velocity
 for y...
   const x = ix - dt*vx[idx]; y=...
   vx[idx] = sample(prevVX,x,y);
   vy[idx] = sample(prevVY,x,y);
 // vorticity confinement
 compute curl
 applyVorticity()
 // project
 project()
 // advect dye
 for y...
   x = ix - dt*vx[idx]; y=...
   prevR[idx] = sample(prevR,x,y); ...
 // fade
 const fade = Math.pow(0.985, dt*60);
 const velFade = Math.pow(0.992, dt*60);
 for i:
   vx[i] *= velFade; vy[i] *= velFade;
   dR[i] *= fade; ...
   dA[i] = Math.max(0,dA[i]*fade - 0.0002);
```
Need if `dt=0`? dt cap. Fine.
Need maybe advect velocity before injection? We inject before step. Good.
Need maybe `prev` arrays contain previous frame fields. We overwrite after advection. Dye prev arrays overwritten after dye advection. Good.
Need maybe pressure and divergence arrays overwritten. Need not clear boundary after projection? Project sets boundary maybe. Need set boundary to 0 after projection:
```
for y=0; y<=H+1; y++:
  vx[y*stride]=0; vy[y*stride]=0; vx[y*stride+W+1]=0; vy[...] =0;
for x=0; x<=W+1; x++:
  vx[x]=0; vy[x*stride]=0; vx[(H+1)*stride+x]=0; ...
```
Need also pressure boundary =0 each projection. Initialize pressure all 0 maybe `pressure.fill(0)` before divergence. Divergence boundary maybe 0.

Need maybe projection:
```
function project() {
 pressure.fill(0);
 for y=1..H:
   for x=1..W:
     idx=...
     divergence[idx] = -0.5*S*(vx[idx+1]-vx[idx-1]+vy[idx+stride]-vy[idx-stride]);
 for iter=0; iter<20; iter++:
   for y=1..H:
     for x=1..W:
       pressure[idx] = 0.25*(divergence[idx] + pressure[idx-1]+...);
 // boundary pressure 0 maybe no need if pressure.fill(0) only at start; after Jacobi boundary remains 0.
 for y=1..H:
   for x=1..W:
      vx[idx] -= 0.5*S*(pressure[idx+1]-pressure[idx-1]);
      vy[idx] -= 0.5*S*(pressure[idx+stride]-pressure[idx-stride]);
 setBoundaryVelocity(0);
}
```
Potential issue: pressure boundary remains 0 but pressure interior uses boundary values from previous iteration? We set pressure.fill(0) at start. Good.
Need maybe divergence sign. Standard: divergence = -0.5*(...) then pressure solves laplacian = divergence. Then subtract gradient. Fine.
Need maybe if velocities large, projection stable.

Need vorticity:
```
function addVorticity(dt) {
 const eps=0.05;
 // compute curl
 for y=1..H:
  for x=1..W:
    curl[idx] = (vy[idx+1]-vy[idx-1])*S - (vx[idx+stride]-vx[idx-stride])*S;
 // apply
 for y=1..H:
  for x=1..W:
    const c = Math.abs(curl[idx]);
    const gx = 0.5*(Math.abs(curl[idx+1])-Math.abs(curl[idx-1]))*S;
    const gy = 0.5*(Math.abs(curl[idx+stride])-Math.abs(curl[idx-stride]))*S;
    const inv = 1/Math.hypot(gx,gy) || 0;
    const nx = gx*inv; const ny=gy*inv;
    vx[idx] += eps*dt*nx*curl[idx]; // cross(n,curl) maybe? 
    vy[idx] += eps*dt*(-ny*curl[idx]); // n x curl = (-n_y*curl,n_x*curl)
```
Need maybe eps dt? Standard force = eps * cross(n, curl), not multiply dt? We can multiply dt. Use eps=0.08.
Need maybe gradient of abs curl. Good.
Need maybe after projection? If add vorticity after projection, pressure not solved. Could add vorticity before projection:
 - Advect velocity
 - addVorticity()
 - project()
 - advect dye
This is cleaner. But vorticity force after advection before projection. Good.
Need maybe add "pressure solve after vorticity" to keep divergence-free.
Need maybe add "dye advection after projection". Good.

Need maybe "colorful dye" injection values not clipped. If multiple injections, dR etc >1. Rendering clamp. Fade. Good.
Need maybe alpha fade. Need maybe if alpha low, no dye. Good.

Need maybe `render()`:
```
function render() {
 simCtx.fillStyle = '#02030a';
 simCtx.fillRect(0,0,W,H);
 const data = dyeData;
 for (let y=1; y<=H; y++) {
   let src = y*stride+1;
   let dst = (y-1)*W*4;
   for (let x=1; x<=W; x++, src++, dst+=4) {
      const a = dA[src];
      if (a <= 0.002) { data[dst]=data[dst+1]=data[dst+2]=0; data[dst+3]=0; continue; }
      const alpha = Math.min(1,a*0.95);
      data[dst] = dR[src]*255;
      data[dst+1] = dG[src]*255;
      data[dst+2] = dB[src]*255;
      data[dst+3] = Math.round(alpha*255);
   }
 }
 simCtx.putImageData(dyeImage,0,0);
 ctx.clearRect(0,0,canvas.width,canvas.height);
 ctx.imageSmoothingEnabled = true;
 ctx.drawImage(simCanvas,0,0,canvas.width,canvas.height);
}
```
Need maybe `dyeImage.data` is Uint8ClampedArray. Setting values. Good.
Need maybe if alpha >1, clamp.

Potential issue: Offscreen canvas dimensions W/H maybe 384. `simCtx.putImageData` with ImageData W/H. Good.
Need maybe `ctx.drawImage` with canvas.width/height in device pixels. Good.
Need maybe `ctx.imageSmoothingQuality = 'high'`.

Need maybe include overlay with FPS:
```
let fps = 0, frames=0, fpsTime=performance.now();
...
frames++;
if(now-fpsTime>500){ fps=frames*1000/(now-fpsTime); fpsEl.textContent = `${fps.toFixed(0)} FPS · drag to stir`; frames=0; fpsTime=now; }
```
Need not too much.

Need maybe "real-time fluid simulation" in title.

Need maybe no external. Good.

Need maybe `canvas.addEventListener('contextmenu', e=>e.preventDefault());`.

Need maybe check for WebGL? Not needed.

Could implement shader? No.

Need maybe perhaps use `OffscreenCanvas`? No.

Potential issue with `pointerdown` on canvas: if user drags, `pointermove` events delivered because pointer capture. Good.
Potential issue with `pointerleave` while down but captured; if pointer leaves window, pointercancel. Good.
Potential issue with `e.clientX` maybe undefined? Pointer events have.

Need maybe "full-screen canvas" should fill viewport. Body style.

Need maybe `window.addEventListener('resize', resizeSimulation, {passive:true})`.

Need maybe initial seed:
```
function seedDye() {
 const cx=W*0.5, cy=H*0.5;
 injectDye(cx,cy,Math.min(W,H)*0.18,190,0.9,0.55,1.0);
 injectVelocity(cx,cy,-2,3,1);
}
```
But `injectDye` uses W/H and arrays. Called after init. Good. It adds colored blob. Maybe also 3 blobs.
Need maybe initial dye could appear before user. Fine.

Need maybe "dragging mouse pushes swirling colored dye through fluid." Good.

Need maybe maybe need use `document.documentElement.style`? no.

Need maybe maybe use `requestAnimationFrame` and not `setInterval`.

Need maybe if no pointer, still animate? Real-time fluid simulation should update even idle. We can run loop always. Good.

Need maybe `lastTime` resets on resize? Set `lastTime = performance.now();`.

Need maybe `dt` in seconds. Advection uses dt in "grid cells per second". If dt=0.016 and velocity units in px per frame? We add vx += moveX*0.1. If moveX=10, vx=1 px per frame? Actually dt*vx = 0.016 px, too small? Wait stable fluids uses velocities in grid cells per second? If vx units are pixels per second, then dt*vx = pixels. We add velocity units in pixels per frame? If vx=10, dt*vx=0.16 px, too slow. Need calibrate.
Let's think. In stable fluid algorithm, velocity arrays represent velocity in grid cells per second? Typically `dt` is seconds and `v[i]` is velocity in grid units per second. So if pointer move 10 sim pixels over 16ms, velocity should be 600 px/s, so dt*vx=10 px. We can add `moveX / dt * 0.08` or `moveX * 5` if dt=0.016. Let's set velocity injection:
```
const invDt = 1/dt;
const push = (moveX * invDt) * 0.015; // 10/0.016*0.015=9.37
const swirl = (speed * invDt?) speed already px/s; swirl = speed*0.018*falloff^2 = 600*0.018=10.8
```
So vx += moveX*0.94 + tangent* maybe. Good.
Alternatively use `vx += moveX * 0.8; vy += moveY*0.8; vx += -moveY*1.2; vy += moveX*1.2;` This makes dt*vx ~0.016*10=0.16 if 0.8. Too slow. Need bigger. Use 6-10.
Let's define:
```
const invDt = 1 / Math.max(dt, 0.001);
const push = 0.018 * invDt; // if dt=0.016, 1.125
vx += moveX * push * falloff;
vy += moveY * push * falloff;
const swirl = (0.035 + 0.00035 * speed) * falloff*falloff; // speed px/s 600 =>0.245
vx += -moveY * swirl;
vy += moveX * swirl;
```
For moveX=10, push=1.125 -> 11.25 velocity, dt*vx=0.18? Wait dt*11=0.18 px. No, if velocity units px/s, dt*vx should be 10. Need push=1/dt not 0.018*1/dt? For moveX=10, moveX*invDt=625. Need coefficient maybe 0.012 -> 7.5. dt*7.5=0.12 px. Still too low. Actually if velocity in grid cells per second, dt*velocity = cells. If moveX=10 cells over 0.016s, velocity = 625 cells/s. To set velocity = 625, coefficient=1. So vx += moveX*invDt. That can be large. But stable fluids can handle 625 cells/s, dt*vx=10 cells. Need not multiply small. But projection can handle. Maybe set `vx += moveX * invDt * 0.85;` for direct push, `vx += -moveY*invDt*0.95` for swirl. That gives 531 cells/s. Good. But if dt=0.016, dt*vx=8.5 cells. Good.
Could cap speed. `speed = Math.min(900, Math.hypot(moveX,moveY)/dt);` Then `vx += moveX*invDt*0.9;`. Good.
But if pointer move 100 px over 16ms, velocity 5625, cap speed but direct component uses moveX*invDt not capped, huge. Better use capped velocity vector:
```
const moveSpeed = Math.hypot(moveX,moveY);
const cappedMoveX = moveX / Math.max(moveSpeed,1) * Math.min(moveSpeed, 180);
const cappedMoveY = ...
vx += cappedMoveX * 0.9 * falloff;
...
const speed = moveSpeed / dt;
const swirl = Math.min(speed, 1200) * 0.0015 * falloff^2; // 1200*0.0015=1.8
vx += -moveY * swirl;
vy += moveX * swirl;
```
This yields direct push velocity ~180 cells/s, dt*vx=2.9 cells. Good. Swirl ~1.8, dt=0.03 cells. Hmm. Need maybe swirl stronger: 0.004 => 4.8 cells/s, dt*4.8=0.077 cells. Not much. But swirl is added to velocity, advected with dt. Need swirl velocity in cells/s. To get swirl displacement 5 cells over 16ms, velocity=300 cells/s. Use coefficient 0.0025*speed cap=3 cells/s? Wait speed=1200 cells/s, *0.0025=3 cells/s, dt*3=0.048 cells. Too low. Use coefficient 0.25? speed=1200*0.25=300. So `swirl = Math.min(speed,1200)*0.25*falloff^2`. For speed 600 ->150 cells/s, dt*150=2.4 cells. Good.
Direct push: `cappedMoveX * 0.8` with cappedMove=180 ->144 cells/s, dt*144=2.3 cells. Good.
So inject velocity:
```
const cappedMoveX = moveX / moveDistance * Math.min(moveDistance, 180);
...
vx += cappedMoveX * 0.9 * falloff;
vy += cappedMoveY * 0.9 * falloff;
const speed = moveDistance/dt;
const swirlStrength = Math.min(speed, 1400) * 0.25 * falloff*falloff;
vx += -moveY * swirlStrength;
vy += moveX * swirlStrength;
```
But `swirlStrength` multiplies moveY (px) causing units px^2/s? That's wrong. Should swirl tangent vector should be normalized tangent * velocity. If use moveY not normalized, tangent magnitude = moveDistance. Then velocity = -moveY * swirlStrength (px * cells/s) too large. Better:
```
const tx = -moveY / moveDistance;
const ty = moveX / moveDistance;
vx += tx * swirlVelocity * falloff;
vy += ty * swirlVelocity * falloff;
```
where swirlVelocity = min(speed,1400)*0.25. Good.
Direct push velocity = cappedMove*0.9.
So:
```
const moveSpeedPx = Math.hypot(moveX,moveY);
const cappedMoveSpeed = Math.min(moveSpeedPx, 220);
const pushVX = (moveX/moveSpeedPx)*cappedMoveSpeed*0.9;
...
const swirlV = Math.min(moveSpeedPx/dt, 1600)*0.32;
vx += (-moveY/moveSpeedPx)*swirlV*falloff;
vy += (moveX/moveSpeedPx)*swirlV*falloff;
```
If moveSpeed=10, dt=0.016, moveSpeedPx/dt=625, swirlV=200, displacement 3.2 cells. Good. If moveSpeed=100, swirlV=512, displacement 8 cells. Good.
Add radial:
```
const radialV = 60*falloff;
vx += (dx/dist)*radialV*falloff;
...
```
Good.

Need `injectDye` radius maybe 36. Good.

Need maybe if pointer down no movement, radius small and hue random. Good.

Need maybe `dt` in `injectVelocity` uses pointer dt not simulation dt. Good.

Need maybe color injection amount. `injectDye(x,y,radius,hue,sat,light,amount)`.
Need maybe `amount` maybe 1.0. `dA += 0.75*local`.

Need maybe render with alpha blending? If dye values >1, clamp. Source-over on black. Good.

Potential issue: `dyeImage.data` initially zeros. If we fill alpha 0 for transparent cells, okay.
Need maybe `putImageData` is expensive but okay. Could use `ImageBitmap`? no.

Need maybe use `ctx.globalCompositeOperation = 'lighter'`? For rendering, if source-over, colors blend. Lighter may make bright. We can set `ctx.globalCompositeOperation = 'lighter';` in render before drawImage? But main canvas draws from offscreen with premultiplied? If source-over, good. For glow, maybe drawImage twice with alpha? Not necessary.
Could set `simCtx.globalCompositeOperation = 'source-over'`. Main `ctx.globalCompositeOperation = 'lighter'`? That will add. But offscreen already has colors. Use source-over.
Need maybe add `ctx.shadowBlur`? no.

Need maybe if user wants "fluid simulation" not just particle. We have stable fluids.

Need maybe maybe use "dragging the mouse pushes swirling colored dye through the fluid" not necessarily stable solver. Good.

Need maybe if no network. Good.

Need maybe final answer: "Created /tmp/ws/index.html" maybe no code block? User asked create. We should mention. Need no extra.

Need maybe after writing, maybe read file? Need verify. Use write. Then maybe run `node --check` on extracted script? Could use bash. Need maybe if node installed. Let's write first.

Need maybe inspect maybe no syntax. Could run node check by extracting script. Need maybe use bash.

Oops python3 missing. Need maybe use node to extract/check.

Need maybe check file exists.

Need final concise mention created. Ensure no mention failed python. Could mention syntax check. Need maybe user didn't ask for explanation. Final: "Created /tmp/ws/index.html with full-screen canvas, stable-fluid simulation, pointer-driven dye injection." Good.