We need to create index.html with CSS, JS inline. Use three.min.js from current dir. Should load via <script src="three.min.js"></script>.

Create a simple scene: camera, renderer, sun (sphere with emissive material), planets orbiting, starfield background using Points.

Implement orbits using time and radius, maybe use animation loop updating positions.

Orbit-drag camera controls: we can use OrbitControls from Three.js? But we cannot import external, but controls.js might not be present. We might need to implement minimal orbit controls ourselves? Wait, the instruction: "three.min.js is already present". It doesn't say other libraries. But OrbitControls is part of Three.js examples, not included in min. We could implement simple camera orbit using mouse events manually. But maybe we can include the controls source as a separate script file? But they say only the library file is three.min.js. So we can't use external resources.

We could implement a simple orbital camera: rotate around center based on mouse drag.

Starfield: create many points randomly positioned far away.

Planets: create few objects (Mercury, Venus, Earth, Mars, etc.) with small radius, orbit radius and speed.

Set up animation loop.

Also set light: sun as point light.

Let's write HTML. We'll create a div container maybe full-screen canvas.

Let's write in one file.

Let's proceed to create index.html.

Need to consider style: set margin 0, overflow hidden.

We'll add a <canvas id="c">? But renderer will create canvas automatically.

Implement CSS: body margin 0.

Write JS script: load three.min.js first via script tag before our inline script. Ensure to put our script after.

Implement basic scene.

Implement camera: PerspectiveCamera(45, window.innerWidth/window.innerHeight, 0.1, 1000). Position at (0, 50, 100). Controls: use simple trackball: track mouse drag to rotate camera around origin.

Let's implement: use event listeners on window for mousedown, mousemove, mouseup. We'll calculate delta and adjust azimuth and elevation angles; then compute new camera position: radius fixed, e.g., 100 units. Or we can use polar coordinates.

Simpler: use orbit controls algorithm: maintain spherical coordinates (theta, phi), update camera position based on spherical.

Implement orbit speed: On each frame, update each planet's orbital angle based on speed.

Starfield: create Geometry with points; 4000 points random positions between -5000 to 5000. Use PointsMaterial with white color and size.

Add light: sun as sphere and point light at same position.

Add sun: large sphere radius 5, emissive material.

Add planets: array of objects with parameters: name, radius, distance (orbit radius), speed, color.

Create meshes; for orbit radius, we will store object and its orbit radius and current angle.

Animation loop: update angle += speed * delta; position = new Vector3(distance * cos(angle), 0, distance * sin(angle)).

Add them to scene.

Add ambient light maybe.

Resize event to update renderer size and camera aspect.

Implement.

Let's produce index.html.

We must also include three.min.js from local folder. Let's confirm file exists. Use bash to list?

We need to create index.html file with full self-contained webapp: CSS in <style>, JS in <script>, inline. Use the three.min.js script loaded from local file. Must build a 3D solar system with sun, orbiting planets at varied speeds and sizes, orbit-drag camera controls, and starfield. We cannot use external resources. So need to build the scene manually. We can use Three.js standard features.

But we cannot load external modules from CDN, but we can import OrbitControls? Wait OrbitControls is part of three.js examples. But we might not have that file. Only three.min.js present. But we could implement orbit controls manually or use built-in controls? Three.js doesn't have built-in OrbitControls; it's an external module. We could implement a simple custom orbit controls or maybe use CSS transform? But requirement is orbit-drag camera controls. We can write minimal code for orbit controls: on mouse drag, rotate camera around target.

Simpler: Use basic orbit controls from Three.js, but we might not have the file. Let's check if three.min.js includes OrbitControls. Usually not. But we might create minimal script. Since we cannot use external resources, we have to embed the OrbitControls code ourselves. But maybe we can implement a simple version: on mouse down/move, adjust spherical angles and update camera position.

Also create starfield: 2000 small points or 1000.

Plan:

- index.html with <script src="three.min.js"></script>
- <script> code: create scene, camera, renderer, add sun as sphere with emissive material, planets: small spheres with texture maybe color; add orbit radius, speed; animate via requestAnimationFrame.

- Use custom OrbitControls: store target, radius, azimuthalAngle, polarAngle; on mousedown, record last positions; on mousemove, update angles; update camera position accordingly.

- Provide CSS: maybe minimal to make canvas full-screen.

Write file.

Let's create index.html content.

But before writing, maybe we need to test that three.min.js loads. We'll just trust.

Implement starfield: create THREE.Points with random positions in a sphere with radius large, e.g., 5000. Use small white dots.

Also set up lighting: point light at sun.

Set up sun as emissive sphere or MeshBasicMaterial with color.

Add planets: array with parameters: name, radius, distance, orbitSpeed, color.

Add planet meshes with MeshPhongMaterial or MeshBasicMaterial.

Add a ring? not necessary.

Implement animation: each planet rotates around sun based on speed, using trigonometric functions.

Use a simple function to compute positions.

Add orbit lines? optional.

But requirement: varied speeds and sizes.

Also camera controls: on mouse drag.

Let's create code.

Implement CSS to set body margin 0; overflow hidden.

Also set canvas to width/height window inner.

Let's create index.html.