The user wants a single-page web app in index.html using the pre-provided three.min.js (global THREE). Visualize the Lorenz attractor as a glowing 3D butterfly trajectory that draws over time, with orbit-drag camera controls.

Let me first check what's in the current directory and whether three.min.js exists.

three.min.js is present. It's three r134-ish based on the license date 2021. Let me check the version. It uses global THREE. Let me build the app.

The Lorenz attractor equations:
dx/dt = sigma(y - x)
dy/dt = x(rho - z) - y
dz/dt = xy - beta*z

Classic values: sigma=10, rho=28, beta=8/3.

I'll animate a glowing butterfly trajectory. Use a TubeGeometry growing over time, or draw points. A common approach: precompute the trajectory as points, then draw a line/tube up to current index over time. For "glowing", use additive blending, Points with custom shader, and a Line with additive blending.

Let me do it robustly with r134 API. Use Points with a size attenuation, additive blending, and a Line with additive blending. Draw over time by using a growing segment of the precomputed path.

Let me also add orbit controls manually since OrbitControls is not provided. The user said "orbit-drag camera controls" - I need to implement drag-to-orbit myself. Since only three.min.js is provided, no OrbitControls. I'll implement simple spherical orbit drag with mouse events.

Let me write a nice glowing effect:
- Use a Points cloud or a Line with additive blending.
- To get "glow", create sprites/textures... but no external resources. I can generate a radial gradient texture via canvas to create glowing point sprites.

Approach:
1. Precompute N points of the Lorenz trajectory using RK4, normalize/center.
2. Visualize as a moving glowing trail: use Points with a canvas-generated soft circular sprite, additive blending.
3. Actually a beautiful approach: use a TubeGeometry built incrementally, but tube geometry can be heavy to rebuild each frame.

Better: Use Line with vertexColors and additive blending — a glowing curve. Add points with soft sprite for glow. Let me combine: a Line (THREE.Line with BufferGeometry and LineBasicMaterial additive) for the trail, plus Points for the sparkly glow.

Let me think about the "draws over time" aspect: reveal the trajectory progressively. I can set drawRange on the geometry to reveal segment by segment. Since I precompute all points, I set geometry.setDrawRange(0, count) and increase count each frame. That efficiently reveals the line without rebuilding.

For glowing: I'll use LineBasicMaterial with additive blending, vertex colors mapping from blue->cyan->green->yellow->red or a nice gradient. Actually LineBasicMaterial alpha and color glow. Line widths are limited to 1 on most platforms but that's fine.

To make it more "glowing", add a Points layer with soft sprite texture, additive blending, positioned along trail. Points can be large and bright with a radial gradient texture giving a bloom look.

Let me also add a subtle ambient starfield background and maybe a faint second colored trail.

Let me implement orbit drag controls:
- Track mouse down, compute spherical angles phi/theta, update camera position around a target (0,0,0).
- Add wheel zoom.

Let me write everything.

Colors: good to use a gradient along the path. I'll assign vertex colors based on index fraction using HSL -> convert to Color via THREE.Color().setHSL().

Let me write the render loop with requestAnimationFrame.

Let me handle high-DPI and resize.

Let me structure:

```
<script>
const sigma=10, rho=28, beta=8/3;
const N=12000;
const dt=0.004;
function lorenz(p){...}
// RK4
pts=[]
let x=0.1,y=0,z=0;
for i in N: push; integrate.
// center & scale
compute bbox center, max radius; normalize positions to fit.
```

Actually I'll keep raw coords and just center/scale, then camera target at origin.

Compute positions Float32Array scaled. vertexColors.

Create geometry, setDrawRange(0,0). Use line.

Also create points geometry using same positions but maybe every kth point, with sprite material.

Let me build the points texture with canvas radial gradient.

Glow via additive blending.

drawRate: reveal e.g. 60-120 points per frame so it takes ~ a few seconds for 12000 points. With 60fps, 100/frame ~ 2s. Let me make it nice and loop.

Maybe make reveal faster initially then steady. I'll just constant rate.

Let me add a subtle second pass: after reaching end, fade and restart? Could pulse. Keep simple: loop reveal.

Let me add starfield background with random points.

Zoom via wheel.

Camera near/far. Set pixel ratio.

Let me write the code carefully for r134.

For Line, THREE.Line(geometry, material). three.min r134 supports setDrawRange. Yes.

LineBasicMaterial: { vertexColors:true, blending:THREE.AdditiveBlending, transparent:true, opacity:... }

Let me also set linewidth (ignored mostly).

Points material with size and sizeAttenuation. Map from canvas texture. Use color white, map, additive, transparent, depthWrite:false.

Let me create the texture:

```
function makeGlow(){
 const c=document.createElement('canvas'); c.width=c.height=64;
 const ctx=c.getContext('2d');
 const g=ctx.createRadialGradient(32,32,0,32,32,32);
 g.addColorStop(0,'rgba(255,255,255,1)');
 g.addColorStop(0.3,'rgba(255,255,255,0.8)');
 g.addColorStop(0.7,'rgba(255,255,255,0.2)');
 g.addColorStop(1,'rgba(255,255,255,0)');
 ctx.fillStyle=g; ctx.fillRect(0,0,64,64);
 const t=new THREE.Texture(c); t.needsUpdate=true; return t;
}
```

Now orbit controls custom:

```
let target=new THREE.Vector3(0,0,0);
let theta=Math.PI/2, phi=0.3, radius=8;
function updateCam(){
 camera.position.set(
  radius*Math.sin(theta)*Math.cos(phi),
  radius*Math.cos(theta),
  radius*Math.sin(theta)*Math.sin(phi)
 );
 camera.lookAt(target);
}
```

Mouse drag: compute dTheta from dy, dPhi from dx (or vice versa). Let me do standard: 
drag: phi -= dx*0.005; theta -= dy*0.005; clamp theta.

wheel: radius *= 1+deltaY*0.001; clamp.

Pointer events on renderer dom element.

Let me now write the file.

I'll include a little HUD title overlay with styling.

Let me finalize reveal logic:
```
let revealed=0; const rate=110; // per frame
function tick(){
 requestAnimationFrame(tick);
 updateCam();
 if(revealed<N){
   revealed=Math.min(N, revealed+rate);
   line.geometry.setDrawRange(0,revealed);
   points.geometry.setDrawRange(0,revealed);
 }
 renderer.render(scene,camera);
}
```

For Points setDrawRange works too (BufferGeometry). Good.

Color gradient along path: use setHSL( (i/N)*0.8+0.5, 1, 0.6 )? Let me design a nice butterfly: hue from 0.55 (cyan) to 0.0 (red) over the path. So hue = 0.55 - (i/N)*0.55.

After normalizing scale, I want the points bright.

Let me implement centering: compute min/max, center, and scale so max extent ~ some value. Then also color.

Let me also add "glow trail" using a second thicker Points with slightly larger size but lower opacity for bloom. Actually the generator texture additive will be glowy enough. I might add two point layers: one with size ~0.1 single per point maybe too dense. If I add one point per path point (12000), that's a lot but okay. Points size maybe 1.5. Hmm additive with many points may blow out white. Use moderate opacity.

Actually for a line-based butterfly plus points for glow. Let me not overdo. I'll use the Line for the crisp curve and a Points layer (same points) with sprite additive for glow. Set points size so each is small, opacity ~0.9. That gives neon glow.

Scale positions: Let me find the numerics. For 12000 steps dt=0.004, t=48s. Lorenz with rho=28 has butterfly spanning roughly x in [-18,18], z in [0,45]. Center around mean and scale to radius ~5.

```
let minx=1e9... compute.
center=(min+max)/2
range=max range among dims
scale= 5 / (range/2)  // fit within radius 5
pos=(p-center)*scale
```

Set camera radius ~12, far 200.

Let me write the whole file now.

I'll also add a subtle rotating ring/inertia? No, keep orbit control. Maybe add slight idle rotation (auto-rotate) when not dragging. Could be nice. I'll add gentle auto-rotation that pauses on drag. Keep it.

Auto-rotate: phi += 0.0005 per frame when not dragging.

Let me write it.

Edge: initial mouse positions for drag deltas.

Let me write the HTML.

Let me also set background: dark gradient via CSS and renderer clear color dark.

I'll write it all.

Let me verify the file and do a quick sanity check that there are no JS syntax errors by running through node (though node lacks THREE/DOM). I can at least syntax-check the script portion with node --check on an extracted file, but the HTML wraps it. Let me extract the second script content and check syntax with node.

Actually I can just do a quick check by extracting the JS between the last <script> tags (not the three one). Let me do that.

The syntax is valid. Let me do a quick runtime sanity check to make sure THREE API usage is valid for r134. I can try running it in node with a mock of three? That's heavy. Instead, let me verify the key APIs used exist in the provided three.min.js. Let me grep for CanvasTexture, setDrawRange, setHSL, BufferAttribute.

All good. setPointerCapture is a DOM API, not three. Fine.

Let me verify with node that three.min.js loads as a module? It uses UMD. In node, `require('./three.min.js')` gives THREE. Let me run a quick test to ensure the geometry operations work (setDrawRange, etc.) in a headless way — but WebGLRenderer needs canvas. I can at least test the non-renderer parts: building BufferGeometry, Line, Points, texture. Let me do a quick node smoke test avoiding WebGL.

The Lorenz integration and scene construction work correctly. Points span within radius 5 as intended. Everything validated. Let me clean up the temp files.