Let me create a full-screen flow-field particle animation using p5.js. I need to:

1. Use p5.min.js that's already in the current directory
2. Create a single index.html file with everything inline
3. Implement:
   - Thousands of particles
   - Perlin noise-based vector field
   - Fading trails (using semi-transparent background overlay)
   - Color shifting over time
   - Full-screen canvas

Key design decisions:
- Use global mode (simpler, works well with the script tag approach)
- Use `createVector` for particle positions and velocities
- Perlin noise with `noise()` function for the flow field
- Trail effect: draw a semi-transparent rectangle each frame instead of clearing
- Color: use HSB mode, shift hue over time
- ~2000-3000 particles for good visual density
- Particles wrap around edges or reset when out of bounds
- Scale noise with pixel coordinate + time offset

Let me write this out.

Good, confirmed p5.min.js exists. Now let me think through the animation carefully:

**Flow-field approach:**
- Divide the canvas into a grid of cells (e.g., 20x20 px cells)
- Each cell has an angle derived from Perlin noise: `noise(x * scale, y * scale, z)` where z = time * speed
- The angle is mapped to [0, TWO_PI * 2] or similar for variety

**Particles:**
- ~2500 particles
- Each has position, velocity vector
- Each frame: look up flow angle at particle's position, compute force vector, apply to velocity with some damping (e.g., vel.mult(0.95))
- Reset particle if it goes off-screen

**Trails:**
- Draw a semi-transparent black rectangle each frame (rgba(0,0,0,20)) over the canvas
- This creates the classic fading trail effect

**Colors:**
- HSB mode
- Hue based on particle's starting Y position + time (so colors shift globally)
- Or: hue = (noise value * 360 + hueOffset) % 360, where hueOffset grows each frame
- Better: use particle index or angle to determine hue, with a global hue shift over time

**Structure:**
```
class Particle {
  constructor() { reset() }
  reset() { position = random position, velocity = zero, hue = random }
  update() { 
    angle = noise(x * 0.005, y * 0.005, z) * TWO_PI * 2
    force = p5.Vector.fromAngle(angle)
    velocity.add(force)
    velocity.limit(2)
    position.add(velocity)
  }
  show() {
    stroke(hue + hueShift, 80%, 90%)
    point(position)
  }
  edges() { wrap or reset }
}
```

**Full-screen handling:**
- Set canvas to windowWidth, windowHeight
- Resize on window resize
- Hide scrollbars, set margin/padding/border: 0 on html/body

**Performance optimization:**
- Use POINTS geometry or point() - but point can be slow for 2500 particles
- Better: use line() from previous position to current position (creates nice trails)
- Or use `beginShape(POINTS)` but that's also not ideal
- Actually for flow fields, drawing a line from old position to new position each frame works great

Let me refine the approach:
- Use `line()` between prev position and current position
- Set strokeWeight to 0.5-1.5 for thin lines
- Use HSB with alpha for colors

Let me write this now. I want it visually stunning:
- High particle count (~3000)
- Subtle trail fade (alpha ~15 for background overlay)
- Noise scale around 0.004-0.006
- Time factor for z offset ~0.003
- Particles have slight opacity and thin lines
- HSB colors with time-shifting hue

Let me also think about performance: 3000 particles each drawing a line per frame = 3000 lines. At 60fps that's fine for modern browsers. But I could use a single PGraphics buffer and draw everything there.

Actually, a simpler approach: use P5's drawing directly, with blend mode.

Let me write the code:

```javascript
const PARTICLE_COUNT = 3000;
const NOISE_SCALE = 0.005;
const Z_SPEED = 0.003;

let particles = [];
let zoff = 0;
let hueShift = 0;

function setup() {
  createCanvas(windowWidth, windowHeight);
  colorMode(HSB, 360, 100, 100, 100);
  background(0);
  for (let i = 0; i < PARTICLE_COUNT; i++) {
    particles.push(new Particle());
  }
}

function draw() {
  background(0, 0, 0, 15);  // semi-transparent overlay for trails
  for (let p of particles) {
    p.update();
    p.show();
    p.edges();
  }
  zoff += Z_SPEED;
  hueShift = (hueShift + 0.2) % 360;
}

class Particle {
  constructor() {
    this.pos = createVector(random(width), random(height));
    this.vel = createVector(0, 0);
    this.acc = createVector(0, 0);
    this.maxSpeed = 2;
    this.prevPos = this.pos.copy();
    this.baseHue = random(360);
  }
  
  reset() {
    this.pos.set(random(width), random(height));
    this.vel.set(0, 0);
    this.prevPos = this.pos.copy();
    this.baseHue = random(360);
  }
  
  update() {
    this.prevPos.set(this.pos.x, this.pos.y);
    let x = this.pos.x * NOISE_SCALE;
    let y = this.pos.y * NOISE_SCALE;
    let angle = noise(x, y, zoff) * TWO_PI * 2;
    let force = p5.Vector.fromAngle(angle);
    force.setMag(0.2);
    this.vel.add(force);
    this.vel.limit(this.maxSpeed);
    this.pos.add(this.vel);
  }
  
  show() {
    let h = (this.baseHue + hueShift) % 360;
    stroke(h, 80, 95, 60);
    strokeWeight(0.8);
    line(this.prevPos.x, this.prevPos.y, this.pos.x, this.pos.y);
  }
  
  edges() {
    if (this.pos.x < 0 || this.pos.x > width || this.pos.y < 0 || this.pos.y > height) {
      this.reset();
    }
  }
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
}
```

For styling, I want full black background, no scrollbars. Let me finalize the HTML.

One concern: drawing 3000 line() calls per frame in p5 might be slow. Let me consider using a more performant approach. Actually for 3000 particles, the standard way works fine in most browsers. Modern p5 handles this.

Alternative: use a P2D renderer or WEBGL. But 2D canvas should be fine.

Let me also add some nice touches:
- Vary particle speed slightly
- Use perlin noise to also affect color/brightness occasionally
- Make sure the animation looks good

Actually, for the background fade: `background(0, 0, 0, 15)` in HSB mode - in HSB the 4th arg is alpha. But p5's background with alpha does work. Let me verify: yes, `background(h, s, b, a)` should work in HSB mode.

Actually for the fade effect, I should use `fill(0, 0, 0, 15)` with `noStroke()` and `rect(0, 0, width, height)`. This is more reliable than background with alpha.

Let me use that approach instead:
```
fill(0, 0, 0, 15);
noStroke();
rect(0, 0, width, height);
```

This draws a nearly-black semi-transparent rectangle each frame, creating the trail fade.

Wait, if I'm in HSB mode: fill(0, 0, 0, 15) = h=0, s=0, b=0, a=15. That's black with 15% opacity (15 out of 100 in HSB mode). Hmm, 15% means strong fade, trails disappear quickly. Let me use lower values for longer trails. alpha=10 would give longer trails.

Actually alpha in HSB is the 4th component, and I set colorMode(HSB, 360, 100, 100, 100) so alpha range is 0-100. alpha=10 means 10% opacity on black, so trails persist longer. That's good.

Let me use alpha=8 for nice long trails.

Now let me write the final HTML.

Let me verify the file is in place and well-formed.

The file is in place. Let me summarize what was created.