The user wants a single-file self-contained HTML app that runs a Gray-Scott reaction-diffusion simulation on a canvas, with real-time organic Turing patterns and mouse interaction for seeding new growth.

Requirements:
- Single page web app, all in one `index.html` file.
- CSS in a `<style>` tag, JS in a `<script>` tag.
- Inline, no separate files.
- Use NO external resources, CDNs, or network requests: self-contained.
- Must run fully sandboxed with no network.
- Gray-Scott reaction-diffusion simulation.
- Organic Turing patterns.
- Real-time.
- Mouse seeds new growth.

Let me design this:

Gray-Scott model:
- Two chemicals U and V.
- Equations:
  dU/dt = Du * ∇²U - U*V² + F*(1-U)
  dV/dt = Dv * ∇²V + U*V² - (F+F_kill)*V
- Standard parameters: Du ≈ 1, Dv ≈ 0.5 (scaled), F ≈ 0.055, F_kill ≈ 0.062
- This produces Turing patterns like spots, stripes, etc.

Implementation:
- Use a `<canvas>` element sized to window.
- Render to canvas pixel data directly (ImageData).
- Use a grid of U and V values.
- Iterate using FDM with Laplacian (5-point stencil or 9-point).
- Mouse down/click adds V (and subtracts U locally) to seed new spots.
- Render to canvas by mapping V to grayscale or color.
- Use `requestAnimationFrame` for real-time animation.
- Handle resize.

Optimization:
- Use Web Workers? That would need a separate file unless inline blob. But blob inline is self-contained. However might complicate. Let's keep it simple main thread with 1/2 or 1/4 resolution scaled up if needed. But with canvas pixel manipulation it's doable in JS.
- Lower resolution grid (e.g., 400x400) scaled to fullscreen canvas.
- Use edge detection or color mapping for organic look.

Let's write the full HTML with embedded CSS/JS.

Parameters:
- Grid size: e.g., `width = Math.floor(window.innerWidth / 2)`, `height = Math.floor(window.innerHeight / 2)`
- F = 0.055, k = 0.062
- Du = 1.0, Dv = 0.5
- dt = 1.0
- Use 2D arrays U and V.
- Mouse adds a blob of V=1, U=0 when clicking.

Rendering:
- Convert V to RGB: dark background, colorful spots based on V and maybe derivative.
- For organic look, use a color palette map: base hue based on V and maybe U.
- Could map V to a gradient: black → blue → cyan → white, or something nice.

UI:
- Title/overlay minimal.
- Maybe show controls? Keep it simple.

Let's draft the JS logic.

Double-buffer arrays.
For each pixel (x,y):
  u = U[x][y]
  v = V[x][y]
  uvv = u * v * v
  lapU = sum(U neighbours) - 4*u
  lapV = sum(V neighbours) - 4*v
  newU = u + dt * (Du * lapU - uvv + F * (1-u))
  newV = v + dt * (Dv * lapV + uvv - (F+k) * v)

Neighbors: wrap around toroidal (periodic boundary).

Mouse:
- Track mousedown, mousemove, mouseup.
- Add V=1, U=0 in radius r around mouse position.
- Map mouse coords to grid coords.

Rendering:
- Create ImageData.
- For each pixel, color = f(V).
  `t = v * 255`
  For Hubble-like colors: `r = t*2, g = 0, b = t*4` etc. Or use HSL-style.
  Let's do: `c = Math.floor(v * 255); r = c; g = c*c/255; b = c*2`? Maybe a nice gradient: 
  base on v: 
    r = Math.floor(Math.min(255, v*255*2))
    g = Math.floor(Math.min(255, v*255*0.5))
    b = Math.floor(Math.min(255, v*255*3))
  Or Simon Gladman's typical palette: black -> blue -> cyan -> green -> yellow -> red.

Actually, let's make a palette function:
  `let t = v; // 0..1`
  `let r = Math.floor(255 * Math.sin(0.5 * t) * Math.sin(1.5 * t));` no.
  
Simpler: map v to HSL with hue shifting from 240 down to 0 as v increases.
  `let h = (1 - v) * 240;`
  `let s = 0.8;`
  `let l = v * 0.5;`
  Convert to RGB without external libs. Can implement a small hslToRgb.

But for performance, maybe just simple RGB approximation:
  `let r = Math.floor(v * 255 * 2);`
  `let g = Math.floor(v * 255);`
  `let b = Math.floor(v * 255 * 3);`
  clamp.

Or use a more artistic palette:
  // Color map from black -> dark purple -> red -> yellow -> white
  let r,g,b;
  if(v < 0.33) { let x = v/0.33; r=x*80; g=0; b=x*160; }
  else if(v < 0.66) { let x=(v-0.33)/0.33; r=80+x*175; g=x*x*200; b=160-x*160; }
  else { let x=(v-0.66)/0.34; r=255; g=200+x*55; b=0; }
  
That could look good.

Let's write the file. Use a single HTML file. Keep JS concise but clear.

Also add some slight color diffusion/blur in rendering? Not necessary.

Let's ensure smooth animation: maybe 5-10 iterations per frame at lower res. That makes it faster.

Let's design:
  const GRID_SCALE = 2; // each canvas pixel covers 2 grid cells
  So grid is roughly half the canvas resolution. That gives speed.

But we can make it dynamic: if performance low, adapt.

Simplify: cellSize = 2 or 3 pixels.

I will write the complete HTML now.

Check constraints: No external resources, so no images, no CDNs, no fetch.

Everything inline.

Let's produce `index.html`.

The user asked for a Gray-Scott reaction-diffusion simulation on a canvas, with mouse seeding new growth, self-contained in one HTML file. I just wrote the file successfully. Let me confirm it's there and summarize for the user.