The user wants me to create a full-screen flow-field particle animation using p5.min.js that's already in the current directory. Let me first check what's in the directory and verify p5.min.js exists.

Good, p5.min.js is present. Now I need to create a single self-contained index.html file with:

1. CSS in a `<style>` tag
2. JS in a `<script>` tag (inline)
3. Load p5.min.js via `<script src="p5.min.js"></script>`
4. Full-screen flow-field particle animation with:
   - Thousands of particles
   - Perlin-noise vector field
   - Fading trails
   - Colors shifting over time

Let me design this carefully:

- Use a canvas that fills the window
- Create a 2D flow field based on Perlin noise (p5's `noise()` function)
- Spawn many particles (2000-5000)
- Each particle follows the flow field vectors
- Use a semi-transparent background overlay to create fading trails
- Shift hue over time using HSB color mode

I'll use p5 in global mode since we load it via `<script src="p5.min.js">`.

Let me think about the implementation:

1. **Flow field**: Divide the canvas into a grid. For each cell, compute a noise value and convert it to an angle (0 to 2π). Store these as vectors.

2. **Particles**: Each particle has position (x, y) and velocity. At each frame, look up the flow field vector at the particle's position, apply it as a force/steering, update position.

3. **Fading trails**: Instead of clearing the canvas each frame, draw a semi-transparent rectangle over it (like `background(0, 0, 0, 10)` in HSB mode, or use `clear()` with alpha).

4. **Color shifting**: Use HSB color mode and shift the hue based on frame count or particle age.

Let me write the code:

```javascript
let flowField;
let particles = [];
let cols, rows;
let resolution = 15;
let zoff = 0;

function setup() {
  createCanvas(windowWidth, windowHeight);
  colorMode(HSB, 360, 100, 100, 100);
  cols = floor(width / resolution);
  rows = floor(height / resolution);
  flowField = new Array(cols * rows);
  for (let i = 0; i < 3000; i++) {
    particles.push(new Particle());
  }
  background(0);
}

function draw() {
  // Fading trail effect
  fill(0, 0, 0, 15);
  noStroke();
  rect(0, 0, width, height);
  
  // Update flow field
  let yoff = 0;
  for (let y = 0; y < rows; y++) {
    let xoff = 0;
    for (let x = 0; x < cols; x++) {
      let index = x + y * cols;
      let angle = noise(xoff, yoff, zoff) * TWO_PI * 4;
      let v = p5.Vector.fromAngle(angle);
      v.setMag(1);
      flowField[index] = v;
      xoff += 0.1;
    }
    yoff += 0.1;
  }
  zoff += 0.005;
  
  // Update and draw particles
  for (let p of particles) {
    p.follow(flowField);
    p.update();
    p.edges();
    p.show();
  }
}

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.hue = random(360);
  }
  
  follow(vectors) {
    let x = floor(this.pos.x / resolution);
    let y = floor(this.pos.y / resolution);
    let index = x + y * cols;
    index = constrain(index, 0, flowField.length - 1);
    let force = flowField[index];
    this.applyForce(force);
  }
  
  applyForce(force) {
    this.acc.add(force);
  }
  
  update() {
    this.prevPos = this.pos.copy();
    this.vel.add(this.acc);
    this.vel.limit(this.maxSpeed);
    this.pos.add(this.vel);
    this.acc.mult(0);
    this.hue = (this.hue + 0.5) % 360;
  }
  
  edges() {
    if (this.pos.x > width) { this.pos.x = 0; this.prevPos = this.pos.copy(); }
    if (this.pos.x < 0) { this.pos.x = width; this.prevPos = this.pos.copy(); }
    if (this.pos.y > height) { this.pos.y = 0; this.prevPos = this.pos.copy(); }
    if (this.pos.y < 0) { this.pos.y = height; this.prevPos = this.pos.copy(); }
  }
  
  show() {
    strokeWeight(1);
    stroke(this.hue, 80, 100, 80);
    line(this.prevPos.x, this.prevPos.y, this.pos.x, this.pos.y);
  }
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  cols = floor(width / resolution);
  rows = floor(height / resolution);
  flowField = new Array(cols * rows);
}
```

Wait, I need to be careful about using ES6 classes with p5 in global mode. Let me check - in global mode, p5.js should support classes fine since modern browsers support them. But let me make sure the class syntax works.

Actually, for maximum compatibility and since we're using global mode, I should avoid the `class` keyword if targeting very old browsers, but modern p5 supports it fine. Let me use the class syntax.

Let me also think about the fading trail approach. Using a semi-transparent black rect works in HSB mode if I set it up correctly. Actually, in HSB mode, the fill with low alpha for the rect overlay might cause issues. Let me think...

When using `colorMode(HSB, 360, 100, 100, 100)`, `fill(0, 0, 0, 15)` means H=0, S=0, B=0, A=15 which is essentially transparent black. That should work for the trail fade.

Let me also consider performance. With 3000 particles and a flow field, we need good performance. The flow field resolution of 15px and a noise scale of 0.1 should be fine.

Let me write the complete HTML file.

The file has been written successfully. Let me verify it's in place and looks correct.