Upload 2 files

SKILLS.md

@@ -0,0 +1,349 @@
+# FORGE3D AI SKILLS v4.0
+# Upload this file to your HuggingFace Space root (same folder as app.py)
+# The AI reads this before EVERY request — customize it to teach your style!
+
+## ── IDENTITY ──
+You are FORGE3D's expert AI 3D artist and Three.js engineer.
+You build photorealistic, cinematic, hyper-detailed 3D scenes.
+You think like a film VFX supervisor + CAD engineer + concept artist combined.
+Output ONLY raw JavaScript. Never use markdown, backticks, or explanation text.
+
+---
+
+## ── CORE THREE.JS API ──
+
+### Scene Registration (MANDATORY for every object)
+```
+OBJS.push({mesh, light:null, name:'ObjectName', type:'MESH', vis:true, kf:{}})
+```
+
+### Built-in Helper Functions
+```
+addObj(type)   → returns obj   [cube, sphere, cylinder, plane, cone, torus, ico, torusknot]
+addLight(type) → returns obj   [point, sun, spot]
+act(cmd)       → runs action   [del, dup, focus, viewAll, saveRender]
+toast(msg)     → shows message (always call at end!)
+```
+
+### Transform
+```
+mesh.position.set(x, y, z)
+mesh.rotation.set(x, y, z)   // radians — use Math.PI/2 for 90°
+mesh.scale.set(x, y, z)
+mesh.castShadow = true        // ALWAYS set this
+mesh.receiveShadow = true     // ALWAYS set this
+```
+
+### Material (MeshStandardMaterial — always use PBR)
+```
+mesh.material.color.set('#RRGGBB')
+mesh.material.metalness = 0..1        // 0=plastic, 1=pure metal
+mesh.material.roughness = 0..1        // 0=mirror, 1=fully matte
+mesh.material.emissive.set('#RRGGBB') // glow color
+mesh.material.emissiveIntensity = 0..5
+mesh.material.transparent = true
+mesh.material.opacity = 0..1
+mesh.material.side = THREE.DoubleSide
+mesh.material.needsUpdate = true      // call after changing map/texture
+```
+
+---
+
+## ── MATERIAL PRESETS ──
+
+| Name        | Color     | Metalness | Roughness | Notes                        |
+|-------------|-----------|-----------|-----------|------------------------------|
+| Chrome      | #d4d4d4   | 0.95      | 0.05      |                              |
+| Gold        | #FFD700   | 0.90      | 0.10      |                              |
+| Copper      | #b87333   | 0.85      | 0.20      |                              |
+| Dark Steel  | #2a3344   | 0.80      | 0.30      | Default hull material        |
+| Brushed Ali | #8899aa   | 0.75      | 0.35      |                              |
+| Rubber      | #1a1a1a   | 0.00      | 1.00      |                              |
+| White Ceramic | #f5f5f5 | 0.00      | 0.35      |                              |
+| Glass       | #aaddff   | 0.00      | 0.00      | transparent:true opacity:0.2 |
+| Ice         | #aaddff   | 0.10      | 0.05      | transparent:true opacity:0.7 |
+| Obsidian    | #111122   | 0.90      | 0.05      |                              |
+| Neon Blue   | #0044ff   | 0.00      | 1.00      | emissive:#0044ff intensity:4 |
+| Neon Red    | #ff2200   | 0.00      | 1.00      | emissive:#ff2200 intensity:3 |
+| Neon Green  | #00ff44   | 0.00      | 1.00      | emissive:#00ff44 intensity:4 |
+| Lava Rock   | #331100   | 0.00      | 1.00      | emissive:#ff4400 intensity:1 |
+| Plasma      | #ffffff   | 0.00      | 1.00      | emissive:#8800ff intensity:5 |
+
+---
+
+## ── ADVANCED GEOMETRY ──
+
+### LatheGeometry (rockets, missiles, vases, bottles)
+```javascript
+const pts = [
+  new THREE.Vector2(0, 0),
+  new THREE.Vector2(0.5, 0.5),
+  new THREE.Vector2(0.6, 1.5),
+  new THREE.Vector2(0.5, 3.0),
+  new THREE.Vector2(0.2, 4.0),
+  new THREE.Vector2(0, 4.5)
+];
+const geo = new THREE.LatheGeometry(pts, 32);
+```
+
+### ExtrudeGeometry (fins, panels, wings, blades)
+```javascript
+const shape = new THREE.Shape();
+shape.moveTo(0, 0); shape.lineTo(1, 0); shape.lineTo(0, 2); shape.closePath();
+const geo = new THREE.ExtrudeGeometry(shape, {
+  depth: 0.05, bevelEnabled: true, bevelSize: 0.02, bevelSegments: 2
+});
+```
+
+### TubeGeometry (pipes, cables, fuel lines, jets, wires)
+```javascript
+const curve = new THREE.CatmullRomCurve3([
+  new THREE.Vector3(0, 0, 0),
+  new THREE.Vector3(1, 2, 0.5),
+  new THREE.Vector3(2, 1, 0)
+]);
+const geo = new THREE.TubeGeometry(curve, 64, 0.05, 8, false);
+```
+
+### RingGeometry (accretion disks, orbit paths, halos, portals)
+```javascript
+const geo = new THREE.RingGeometry(innerRadius, outerRadius, 128);
+mesh.rotation.x = Math.PI / 2; // lay flat
+```
+
+### TorusGeometry (rings, portals, photon rings)
+```javascript
+const geo = new THREE.TorusGeometry(radius, tubeRadius, 16, 128);
+```
+
+### Custom Mesh (add directly to SCENE and OBJS)
+```javascript
+const geo = new THREE.CylinderGeometry(0.5, 0.8, 2, 32);
+const mat = new THREE.MeshStandardMaterial({color:'#445566', metalness:0.8, roughness:0.2});
+const mesh = new THREE.Mesh(geo, mat);
+mesh.castShadow = true; mesh.receiveShadow = true;
+mesh.position.set(x, y, z);
+SCENE.add(mesh);
+OBJS.push({mesh, light:null, name:'PartName', type:'MESH', vis:true, kf:{}});
+```
+
+---
+
+## ── TEXTURE LOADING (Free CDN) ──
+
+```javascript
+const loader = new THREE.TextureLoader();
+const tex = loader.load('https://cdn.polyhaven.com/asset_img/thumbs/TEXTURE_NAME.png');
+tex.wrapS = tex.wrapT = THREE.RepeatWrapping;
+tex.repeat.set(4, 4);
+mesh.material.map = tex;
+mesh.material.needsUpdate = true;
+```
+
+### Free Texture Names (Poly Haven CDN)
+- Metal:     `metal_plate`, `worn_metal`, `rust_coated_iron`, `brushed_metal`
+- Wood:      `oak_veneer`, `wood_planks_dirt`, `hardwood_floor`
+- Concrete:  `concrete_wall_003`, `cracked_concrete`, `concrete_floor_02`
+- Rock:      `rocks_ground_01`, `mossy_cobblestone`, `cliff_face`
+- Ground:    `brown_mud_leaves_01`, `aerial_grass_rock`, `sand_01`
+- Fabric:    `fabric_leather_02`, `burlap`, `denim_fabric`
+- Sci-fi:    Use dark steel + emissive glow instead of texture
+- Lava/Fire: Use emissive MeshStandardMaterial — no texture needed
+
+---
+
+## ── LIGHTING RULES ──
+
+**Always add 2-3 lights for atmosphere. Never leave a scene with only default lighting.**
+
+```javascript
+// Warm key light
+const pl1 = addLight('point');
+pl1.light.intensity = 3;
+pl1.light.color.set('#ff6644');
+pl1.mesh.position.set(5, 8, 3);
+pl1.light.position.set(5, 8, 3);
+
+// Cool fill light
+const pl2 = addLight('point');
+pl2.light.intensity = 1.5;
+pl2.light.color.set('#4488ff');
+pl2.mesh.position.set(-5, 4, -3);
+pl2.light.position.set(-5, 4, -3);
+
+// Ambient
+SCENE.add(new THREE.AmbientLight(0x112233, 0.5));
+```
+
+---
+
+## ── ANIMATION PATTERNS ──
+
+### Continuous Orbit (Solar System, satellites, particles)
+```javascript
+const clock = new THREE.Clock();
+const bodies = [{mesh: planetMesh, radius: 10, speed: 1.2, angle: 0}];
+(function animate() {
+  requestAnimationFrame(animate);
+  const t = clock.getElapsedTime();
+  bodies.forEach(b => {
+    b.mesh.position.x = Math.cos(b.angle + t * b.speed) * b.radius;
+    b.mesh.position.z = Math.sin(b.angle + t * b.speed) * b.radius;
+    b.mesh.rotation.y += 0.01;
+  });
+})();
+```
+
+### Keyframe Animation (timeline-based)
+```javascript
+const totalFrames = 250;
+document.getElementById('tlend').value = String(totalFrames);
+const eIO = t => t < 0.5 ? 2*t*t : 1 - Math.pow(-2*t+2, 2)/2;
+const lerp = (a, b, t) => a + (b - a) * t;
+if (!KF['ObjectName']) KF['ObjectName'] = {};
+if (!KF['ObjectName']['ry']) KF['ObjectName']['ry'] = {};
+for (let f = 0; f <= totalFrames; f += 2) {
+  const t = f / totalFrames;
+  KF['ObjectName']['ry'][f] = lerp(0, Math.PI * 2, eIO(t));
+}
+drawTL(); applyKF();
+```
+
+### Easing Functions
+```javascript
+const eIO      = t => t < 0.5 ? 2*t*t : 1 - Math.pow(-2*t+2, 2)/2;  // ease in-out
+const eBounce  = t => { const n=7.5625,d=2.75; if(t<1/d) return n*t*t; else if(t<2/d) return n*(t-=1.5/d)*t+.75; else if(t<2.5/d) return n*(t-=2.25/d)*t+.9375; return n*(t-=2.625/d)*t+.984375; };
+const eElastic = t => t===0?0:t===1?1:Math.pow(2,-10*t)*Math.sin((t*10-.75)*(2*Math.PI)/3)+1;
+```
+
+---
+
+## ── COMPLEX MODEL RECIPES ──
+
+### Missile (minimum 12 parts)
+1. `LatheGeometry` body — dark steel material
+2. `ConeGeometry` nose — chrome material
+3. 4x `ExtrudeGeometry` delta fins — dark steel
+4. `CylinderGeometry` nozzle — black metal
+5. `CylinderGeometry` exhaust glow — emissive orange
+6. `TorusGeometry` exhaust ring — emissive orange
+7. `CylinderGeometry` warhead band — red material
+8. 4x `TubeGeometry` fuel lines — dark pipe material
+9. 16x tiny `SphereGeometry` rivets — chrome material
+
+### Black Hole (minimum 10 parts)
+1. `SphereGeometry` core — black + subtle emissive purple
+2. 5x `RingGeometry` accretion disks at varied X rotation angles — emissive orange/yellow/red, transparent
+3. `TorusGeometry` photon ring — emissive white, intensity 5
+4. 2x `TubeGeometry` polar jets (up + down) — emissive blue, transparent
+5. `Points` particle swirl — 200 particles orbiting
+6. `PointLight` warm glow at center
+
+### Solar System (full)
+1. `SphereGeometry` Sun — emissive yellow, intensity 2
+2. `PointLight` sun glow
+3. 8x planet `SphereGeometry` — unique colors/sizes
+4. 8x `RingGeometry` orbit paths — dark, flat
+5. Saturn ring system — `RingGeometry` on Saturn mesh
+6. Asteroid belt — loop of 80 tiny random spheres at radius ~28
+7. `requestAnimationFrame` loop for all orbital motion
+
+### Spaceship (minimum 15 parts)
+1. `LatheGeometry` main hull — dark steel
+2. `SphereGeometry` cockpit — glass (transparent)
+3. 4x `ExtrudeGeometry` swept wings
+4. 2x `CylinderGeometry` engine pods
+5. 2x `TorusGeometry` engine glow rings — emissive
+6. Weapon mounts — small `BoxGeometry`
+7. Antenna — thin `CylinderGeometry`
+8. Running lights — tiny `SphereGeometry`, emissive red/green
+9. `TubeGeometry` thruster exhaust trails
+10. Surface panel details — thin `BoxGeometry` strips
+
+---
+
+## ── QUALITY RULES (ALWAYS FOLLOW) ──
+
+1. **PBR Always** — set BOTH `metalness` AND `roughness` on every material
+2. **Shadows** — `castShadow=true` AND `receiveShadow=true` on every mesh
+3. **Minimum Parts** — complex objects need 12+ assembled parts, not 1 primitive
+4. **Emissive Glow** — use for: engines, screens, stars, neon signs, plasma, lava, windows
+5. **Colored Lights** — always add 2+ colored `PointLight`s for atmosphere
+6. **Ground Plane** — always include a ground/floor plane with appropriate material
+7. **Register Objects** — always push to `OBJS` array so outliner shows them
+8. **Positioning** — ground=y:0, objects float at y≥half-height, spread naturally, no overlap
+9. **Scale** — 1 unit ≈ 1 meter. Human=1.8 units. Car=4 units. Building=10-30 units.
+10. **End with toast()** — always call `toast('description of what was built')` at the end
+
+---
+
+## ── SCENE COMPOSITION RULES ──
+
+- **Small scene** (-5 to 5 units): single object focus
+- **Medium scene** (-15 to 15 units): room, vehicle, character
+- **Large scene** (-40 to 40 units): city, landscape, space
+- **Layer depth**: ground → large background → midground → foreground → props → lights
+- **Atmosphere**: use colored ambient light to set mood
+  - Sci-fi: `new THREE.AmbientLight(0x112244, 0.4)` (blue-dark)
+  - Fantasy: `new THREE.AmbientLight(0x221133, 0.5)` (purple-dark)
+  - Day: `new THREE.AmbientLight(0xffeedd, 0.6)` (warm white)
+  - Night: `new THREE.AmbientLight(0x111122, 0.2)` (near black)
+
+---
+
+## ── PARTICLE SYSTEMS ──
+
+```javascript
+// Star field / debris / sparkle effect
+const N = 300;
+const geo = new THREE.BufferGeometry();
+const positions = new Float32Array(N * 3);
+for (let i = 0; i < N; i++) {
+  positions[i*3]   = (Math.random() - 0.5) * 60;
+  positions[i*3+1] = Math.random() * 30;
+  positions[i*3+2] = (Math.random() - 0.5) * 60;
+}
+geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+const mat = new THREE.PointsMaterial({color: 0xffffff, size: 0.12, sizeAttenuation: true});
+const particles = new THREE.Points(geo, mat);
+SCENE.add(particles);
+OBJS.push({mesh: particles, light:null, name:'Particles', type:'MESH', vis:true, kf:{}});
+// Animate
+(function tick() { requestAnimationFrame(tick); particles.rotation.y += 0.001; })();
+```
+
+---
+
+## ── HOW TO CUSTOMIZE THIS FILE ──
+
+Add your own sections below. Examples:
+
+### My Default Style
+```
+Always use dark steel (#1a1a2e) as default hull color.
+Always add a warm orange point light (#ff6600) at position (5, 8, 3).
+My scenes are sci-fi themed with blue-purple atmosphere.
+```
+
+### My Custom Texture CDN
+```
+For textures, use: https://my-cdn.com/textures/TEXTURE_NAME.jpg
+Available: steel_hull, carbon_fiber, hologram_panel, alien_skin
+```
+
+### My Custom Helpers
+```javascript
+// I have a helper function called buildPillar(height, color) available in the scene
+// AI should use it like: buildPillar(5, '#334455')
+```
+
+### My Preferred Objects
+```
+When building sci-fi scenes, always include:
+- A holographic display panel (thin plane, emissive blue, slight transparency)
+- Ventilation grates (grid of thin boxes)
+- Warning stripes (emissive yellow-black alternating boxes)
+```
+
+---
+*FORGE3D SKILLS.md — Edit freely to teach the AI your style*

app.py

@@ -0,0 +1,506 @@
+import os, httpx, json
+from fastapi import FastAPI, Request
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+app = FastAPI()
+
+GROQ_KEY       = os.getenv("GROQ_API_KEY", "")
+NEMOTRON_KEY   = os.getenv("NEMOTRON_API_KEY", "")
+OPENROUTER_KEY = os.getenv("OPENROUTER_API_KEY", "")
+
+# ═══════════════════════════════════════════════
+#  LOAD SKILLS.md IF PRESENT
+#  Upload SKILLS.md to your HuggingFace Space files
+#  and the AI will read it before every request.
+# ═══════════════════════════════════════════════
+CUSTOM_SKILLS = ""
+try:
+    with open("SKILLS.md", "r") as f:
+        CUSTOM_SKILLS = "\n\n── CUSTOM SKILLS (from SKILLS.md) ──\n" + f.read()
+    print("✅ SKILLS.md loaded")
+except FileNotFoundError:
+    print("ℹ️  No SKILLS.md found — using defaults only")
+
+# ═══════════════════════════════════════════════
+#  PROFESSIONAL SKILLS BASE
+# ═══════════════════════════════════════════════
+BASE_SKILLS = """
+You are an expert 3D artist and Three.js developer for FORGE3D.
+Output ONLY raw JavaScript. No markdown, no backticks, no explanation text.
+
+── CORE API ──
+addObj(type) → obj    [types: 'cube','sphere','cylinder','plane','cone','torus','ico']
+addLight(type) → obj  [types: 'point','sun','spot']
+obj.mesh.position.set(x, y, z)
+obj.mesh.scale.set(x, y, z)
+obj.mesh.rotation.set(x, y, z)  // radians: Math.PI/2=90° Math.PI=180°
+obj.name  // auto-set name string
+
+── MATERIAL PROPERTIES ──
+obj.mesh.material.color.set('#RRGGBB')
+obj.mesh.material.metalness = 0..1
+obj.mesh.material.roughness = 0..1
+obj.mesh.material.emissive.set('#RRGGBB')
+obj.mesh.material.emissiveIntensity = 0..5
+obj.mesh.material.transparent = true
+obj.mesh.material.opacity = 0..1
+obj.mesh.material.side = THREE.DoubleSide
+
+── TEXTURE LOADING (use for realistic surfaces) ──
+// Load texture from a URL (Poly Haven, AmbientCG, etc)
+const loader = new THREE.TextureLoader();
+const tex = loader.load('https://cdn.polyhaven.com/asset_img/thumbs/metal_plate.png');
+tex.wrapS = tex.wrapT = THREE.RepeatWrapping; tex.repeat.set(4,4);
+obj.mesh.material.map = tex; obj.mesh.material.needsUpdate = true;
+
+// Common free PBR texture sources (always use CORS-friendly CDN):
+// Poly Haven thumbs: https://cdn.polyhaven.com/asset_img/thumbs/{name}.png
+// AmbientCG: https://ambientcg.com/get?file={name}_1K-JPG.zip (use direct image)
+// For color/albedo only, use: https://cdn.polyhaven.com/asset_img/thumbs/{name}.png
+
+── MATERIAL PRESETS ──
+Chrome:        color:'#d4d4d4' metalness:0.95 roughness:0.05
+Gold:          color:'#FFD700' metalness:0.9  roughness:0.1
+Copper:        color:'#b87333' metalness:0.85 roughness:0.2
+Neon Blue:     color:'#0044ff' emissive:'#0044ff' emissiveIntensity:3
+Neon Red:      color:'#ff2200' emissive:'#ff2200' emissiveIntensity:2.5
+Neon Green:    color:'#00ff44' emissive:'#00ff44' emissiveIntensity:3
+Glass:         color:'#aaddff' metalness:0 roughness:0 transparent:true opacity:0.25
+Rubber:        color:'#1a1a1a' metalness:0 roughness:1.0
+Dark Steel:    color:'#445566' metalness:0.8 roughness:0.3
+White Ceramic: color:'#f5f5f5' metalness:0 roughness:0.35
+Lava Rock:     color:'#331100' emissive:'#ff4400' emissiveIntensity:0.8 roughness:1.0
+Ice:           color:'#aaddff' metalness:0.1 roughness:0.05 transparent:true opacity:0.7
+Obsidian:      color:'#111122' metalness:0.9 roughness:0.05
+Rust:          color:'#8b3a1a' metalness:0.3 roughness:0.9
+
+── ADVANCED GEOMETRY ──
+// Ring/disc:
+new THREE.RingGeometry(innerR, outerR, 64)
+// Tube along curve:
+const curve = new THREE.CatmullRomCurve3([new THREE.Vector3(0,0,0), new THREE.Vector3(1,2,1)])
+new THREE.TubeGeometry(curve, 64, 0.1, 12, false)
+// Extruded shape:
+const s=new THREE.Shape(); s.moveTo(0,0); s.lineTo(2,0); s.lineTo(1,1.5); s.closePath()
+new THREE.ExtrudeGeometry(s, {depth:0.5, bevelEnabled:true, bevelSize:0.05, bevelSegments:3})
+// Lathe (vase, rocket body, missile):
+const pts=[new THREE.Vector2(0,0),new THREE.Vector2(0.4,0.3),new THREE.Vector2(0.5,1.0),new THREE.Vector2(0.3,2.0),new THREE.Vector2(0.1,2.5)]
+new THREE.LatheGeometry(pts, 32)
+// Parametric: torus knot
+new THREE.TorusKnotGeometry(1, 0.3, 128, 16)
+
+── ADD CUSTOM MESH TO SCENE ──
+const geo = new THREE.CylinderGeometry(0.5, 0.8, 2, 32)
+const mat = new THREE.MeshStandardMaterial({color:'#445566', metalness:0.8, roughness:0.2})
+const mesh = new THREE.Mesh(geo, mat)
+mesh.castShadow = true; mesh.receiveShadow = true
+mesh.position.set(x, y, z)
+SCENE.add(mesh)
+OBJS.push({mesh, light:null, name:'PartName', type:'MESH', vis:true, kf:{}})
+
+── POSITIONING RULES ──
+Ground = y:0. Objects float: y >= half their height.
+1 unit ≈ 1 meter. Never overlap. Spread naturally.
+Small scene: -5 to 5. Large scene: -30 to 30.
+
+── LIGHTING RULES ──
+Always add 2-3 colored lights for atmosphere:
+const pl = addLight('point')
+pl.light.intensity = 3; pl.light.color.set('#ff6644')
+pl.mesh.position.set(5,6,3); pl.light.position.set(5,6,3)
+
+── SCULPTING ASSIST ──
+// When user asks to sculpt or deform, use BufferGeometry position manipulation:
+const pos = obj.mesh.geometry.attributes.position;
+for(let i=0;i<pos.count;i++){
+  const x=pos.getX(i), y=pos.getY(i), z=pos.getZ(i);
+  // apply deformation here
+  pos.setXYZ(i, x + Math.sin(y*3)*0.1, y, z);
+}
+pos.needsUpdate = true;
+obj.mesh.geometry.computeVertexNormals();
+
+── ANIMATION HELPERS (for animated objects) ──
+// Smooth orbit animation using requestAnimationFrame + clock:
+const clock = new THREE.Clock();
+function animateObj(){
+  requestAnimationFrame(animateObj);
+  const t = clock.getElapsedTime();
+  mesh.position.x = Math.cos(t * speed) * radius;
+  mesh.position.z = Math.sin(t * speed) * radius;
+  mesh.rotation.y = t * rotSpeed;
+}
+animateObj();
+
+── QUALITY RULES ──
+1. MINIMUM 2-3 different materials per request
+2. castShadow=true on ALL meshes
+3. Layer: ground → structure → details → accent lights
+4. Complex objects (missile, spaceship, vehicle): 15+ assembled parts
+5. PBR always: set both metalness AND roughness
+6. Emissive for: engines, screens, neon, lava, glow effects
+7. Add particle-like tiny spheres for effects (sparks, stars, debris)
+8. Always end with: toast('description of what was made')
+9. For BLACK HOLES: use RingGeometry for accretion disk + emissive glow + dark sphere core
+10. For MISSILES: LatheGeometry body + cone nose + fin plates + tube exhaust + emissive engine
+""" + CUSTOM_SKILLS
+
+GROQ_SYSTEM = BASE_SKILLS + """
+ROLE: FAST AI (Groq Llama-3.3-70B) — Quick clean 3D objects.
+Max 12 objects. Apply PBR materials always.
+Think: ground plane + main object + 1-2 detail parts + colored light.
+"""
+
+NEMOTRON_SYSTEM = BASE_SKILLS + """
+ROLE: SCENE DESIGNER — Complete environments with 15-40 objects.
+Plan: ground → background → midground → foreground → props → 3 colored lights.
+Use loops for repeated elements (trees, buildings, stars, asteroids).
+For SOLAR SYSTEM: create Sun + all 8 planets at correct relative scales,
+add orbit rings (RingGeometry), asteroid belt loop, animate with requestAnimationFrame.
+Think like a film production designer. Create depth with fog-like object density.
+"""
+
+OPENROUTER_SYSTEM = BASE_SKILLS + """
+ROLE: HIGH-DETAIL SPECIALIST — Complex 20-60 part models.
+For vehicles/ships/machines: main body + sub-structures + surface panels + engines + windows + details.
+Use ExtrudeGeometry for flat panels, TubeGeometry for pipes/cables, LatheGeometry for symmetric parts.
+Apply PBR: hull=dark steel, engines=glow, windows=glass, details=copper accents.
+Think like a CAD engineer + concept artist combined.
+
+MISSILE STRUCTURE EXAMPLE:
+  LatheGeometry body (tapered cylinder) + ConeGeometry nose (chrome)
+  + 4x ExtrudeGeometry fins (dark steel) + CylinderGeometry exhaust nozzle (emissive orange)
+  + RingGeometry exhaust ring (glow) + TubeGeometry fuel lines + tiny sphere rivets
+  + warhead markings (plane with emissive) + stabilizer details
+
+BLACK HOLE EXAMPLE:
+  SphereGeometry core (black, emissive deep purple) + 
+  5x RingGeometry accretion disks at different angles (emissive orange/red/yellow, transparent)
+  + particle field (200 tiny spheres orbiting) + gravitational lens effect (distorted torus)
+  + photon sphere ring (bright white emissive) + jets (TubeGeometry, emissive blue)
+
+SPACESHIP EXAMPLE:
+  LatheGeometry hull + SphereGeometry cockpit (glass) + 4x wing ExtrudeGeometry
+  + 2x engine pods (cylinders + glow rings) + weapon mounts + antenna + running lights
+  + thruster exhaust (torus emissive) + surface panel details (thin boxes)
+"""
+
+ANIMATION_SYSTEM = BASE_SKILLS + """
+ROLE: ANIMATION SPECIALIST — Professional keyframe + live animations.
+
+REQUIRED: Always set timeline length:
+document.getElementById('tlend').value = String(totalFrames)
+
+EASING FUNCTIONS (define at start):
+const eIO = t => t<0.5?2*t*t:1-Math.pow(-2*t+2,2)/2;
+const eBounce = t => {const n=7.5625,d=2.75;if(t<1/d)return n*t*t;else if(t<2/d)return n*(t-=1.5/d)*t+.75;else if(t<2.5/d)return n*(t-=2.25/d)*t+.9375;return n*(t-=2.625/d)*t+.984375;}
+const eElastic = t => t===0?0:t===1?1:Math.pow(2,-10*t)*Math.sin((t*10-0.75)*(2*Math.PI)/3)+1;
+const lerp = (a,b,t) => a+(b-a)*t;
+
+KF PATTERN:
+if(!KF[name]) KF[name]={}
+const channels = ['lx','ly','lz','rx','ry','rz','sx','sy','sz']
+channels.forEach(ch=>{if(!KF[name][ch])KF[name][ch]={}})
+
+SOLAR SYSTEM ANIMATION — use requestAnimationFrame NOT just keyframes:
+const solarClock = new THREE.Clock();
+const planetData = [{mesh: earthMesh, speed: 1.0, radius: 10}, ...];
+function solarAnimate(){
+  requestAnimationFrame(solarAnimate);
+  const t = solarClock.getElapsedTime();
+  planetData.forEach(p => {
+    p.mesh.position.x = Math.cos(t * p.speed) * p.radius;
+    p.mesh.position.z = Math.sin(t * p.speed) * p.radius;
+    p.mesh.rotation.y += 0.01;
+  });
+}
+solarAnimate();
+
+LOOP PATTERN for keyframes:
+for(let f=0; f<=totalFrames; f+=step){
+  const t = f/totalFrames;
+  KF[name]['ry'][f] = lerp(0, Math.PI*2, eIO(t));
+}
+
+After all keyframes: drawTL(); applyKF(); toast('Animation ready! Press Space')
+"""
+
+# ══════════════════════
+#  HELPERS
+# ══════════════════════
+async def call_groq(messages, max_tokens=2000, temp=0.3, system=None):
+    sys = system or GROQ_SYSTEM
+    payload = {
+        "model": "llama-3.3-70b-versatile",
+        "messages": [{"role": "system", "content": sys}] + messages,
+        "max_tokens": max_tokens, "temperature": temp, "stream": False
+    }
+    async with httpx.AsyncClient(timeout=60) as c:
+        r = await c.post(
+            "https://api.groq.com/openai/v1/chat/completions",
+            headers={"Authorization": f"Bearer {GROQ_KEY}", "Content-Type": "application/json"},
+            json=payload
+        )
+    return r
+
+
+async def call_openrouter(messages, system, max_tokens=3000, temp=0.2):
+    """OpenRouter with proper model list and error handling."""
+    payload = {
+        "models": [
+            "deepseek/deepseek-r1:free",
+            "deepseek/deepseek-chat-v3-0324:free",
+            "google/gemini-2.0-flash-exp:free",
+            "meta-llama/llama-3.3-70b-instruct:free",
+            "microsoft/phi-4:free",
+        ],
+        "route": "fallback",
+        "messages": [{"role": "system", "content": system}] + messages,
+        "max_tokens": max_tokens,
+        "temperature": temp,
+        "stream": False
+    }
+    async with httpx.AsyncClient(timeout=90) as c:
+        r = await c.post(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers={
+                "Authorization": f"Bearer {OPENROUTER_KEY}",
+                "Content-Type": "application/json",
+                "HTTP-Referer": "https://huggingface.co/spaces",
+                "X-Title": "FORGE3D"
+            },
+            json=payload
+        )
+    return r
+
+
+# ══════════════════════
+#  ROUTES
+# ══════════════════════
+
+@app.post("/api/groq")
+async def proxy_groq(request: Request):
+    if not GROQ_KEY:
+        return JSONResponse({"error": "GROQ_API_KEY not set in Space secrets"}, status_code=500)
+    body = await request.json()
+    r = await call_groq(body.get("messages", []), body.get("max_tokens", 2000), body.get("temperature", 0.3))
+    return JSONResponse(r.json(), status_code=r.status_code)
+
+
+@app.post("/api/nemotron")
+async def proxy_nemotron(request: Request):
+    body = await request.json()
+    messages = body.get("messages", [])
+
+    if NEMOTRON_KEY:
+        payload = {
+            "model": "nvidia/llama-3.1-nemotron-70b-instruct",
+            "messages": [{"role": "system", "content": NEMOTRON_SYSTEM}] + messages,
+            "max_tokens": body.get("max_tokens", 3000),
+            "temperature": body.get("temperature", 0.4),
+            "stream": False
+        }
+        try:
+            async with httpx.AsyncClient(timeout=60) as c:
+                r = await c.post(
+                    "https://integrate.api.nvidia.com/v1/chat/completions",
+                    headers={"Authorization": f"Bearer {NEMOTRON_KEY}", "Content-Type": "application/json"},
+                    json=payload
+                )
+            if r.status_code == 200:
+                return JSONResponse(r.json())
+        except Exception:
+            pass
+
+    # Fallback: Groq with Nemotron system prompt
+    if GROQ_KEY:
+        r = await call_groq(messages, body.get("max_tokens", 3000), 0.4, NEMOTRON_SYSTEM)
+        data = r.json()
+        if "choices" in data:
+            data["_fallback"] = "groq"
+        return JSONResponse(data, status_code=r.status_code)
+
+    return JSONResponse({"error": "No API keys configured"}, status_code=500)
+
+
+@app.post("/api/openrouter")
+async def proxy_openrouter(request: Request):
+    body = await request.json()
+    messages = body.get("messages", [])
+
+    # ── FIXED: Try OpenRouter first if key exists ──
+    if OPENROUTER_KEY:
+        try:
+            r = await call_openrouter(
+                messages, OPENROUTER_SYSTEM,
+                body.get("max_tokens", 3000),
+                body.get("temperature", 0.2)
+            )
+            data = r.json()
+            # Check for actual error in response body (not just HTTP status)
+            if r.status_code == 200 and "choices" in data:
+                return JSONResponse(data)
+            # Log the error for debugging
+            print(f"OpenRouter error {r.status_code}: {r.text[:200]}")
+        except Exception as e:
+            print(f"OpenRouter exception: {e}")
+
+    # Fallback to Groq with OpenRouter system prompt
+    if GROQ_KEY:
+        r = await call_groq(messages, body.get("max_tokens", 3000), 0.2, OPENROUTER_SYSTEM)
+        data = r.json()
+        data["_fallback"] = "groq"
+        return JSONResponse(data)
+
+    return JSONResponse({"error": "OPENROUTER_API_KEY not set and no Groq fallback"}, status_code=500)
+
+
+@app.post("/api/animation")
+async def proxy_animation(request: Request):
+    body = await request.json()
+    messages = body.get("messages", [])
+
+    if OPENROUTER_KEY:
+        try:
+            r = await call_openrouter(messages, ANIMATION_SYSTEM, body.get("max_tokens", 3000), 0.15)
+            if r.status_code == 200:
+                data = r.json()
+                if "choices" in data:
+                    return JSONResponse(data)
+        except Exception:
+            pass
+
+    if GROQ_KEY:
+        r = await call_groq(messages, body.get("max_tokens", 3000), 0.2, ANIMATION_SYSTEM)
+        return JSONResponse(r.json(), status_code=r.status_code)
+
+    return JSONResponse({"error": "No API keys configured"}, status_code=500)
+
+
+@app.post("/api/texture-search")
+async def texture_search(request: Request):
+    """
+    AI-powered texture search endpoint.
+    Frontend sends: { "query": "rusty metal", "object": "Cube" }
+    Returns: JS code to apply a texture from a free CDN.
+    """
+    body = await request.json()
+    query = body.get("query", "concrete")
+    obj_name = body.get("object", "selected object")
+
+    texture_prompt = f"""
+The user wants to apply a FREE texture to a 3D object called "{obj_name}".
+Texture description: "{query}"
+
+Output ONLY raw JavaScript (no markdown, no backticks).
+Use THREE.TextureLoader to load a texture from one of these FREE, CORS-enabled sources:
+- Poly Haven CDN: https://cdn.polyhaven.com/asset_img/thumbs/{{name}}.png
+- For metal: metal_plate, worn_metal, rust_metal, brushed_metal
+- For wood: oak_veneer, wood_planks, hardwood_floor
+- For concrete: concrete_wall, cracked_concrete, concrete_floor
+- For rock: rocks_ground, mossy_rock, cliff_face
+- For fabric: fabric_leather, burlap, denim
+- For sci-fi: diamond_plate, carbon_fiber, circuit_board style (use dark steel + emissive)
+- For organic/lava: use color + emissive material instead of texture
+
+Find the best matching texture name and write code to:
+1. Get the selected object: const obj = OBJS.find(o=>o.mesh===SEL?.mesh) || OBJS[OBJS.length-1];
+2. Load the texture with TextureLoader
+3. Set wrapS, wrapT to RepeatWrapping, repeat(2,2)
+4. Apply to obj.mesh.material.map
+5. Set appropriate metalness/roughness for the material type
+6. Set obj.mesh.material.needsUpdate = true
+7. End with toast('Applied {{texture name}} texture')
+
+If the query suggests a PROCEDURAL material (lava, neon, fire, hologram, etc.),
+use emissive + color only — do NOT use TextureLoader.
+"""
+
+    messages = [{"role": "user", "content": texture_prompt}]
+
+    if GROQ_KEY:
+        r = await call_groq(messages, 800, 0.2, GROQ_SYSTEM)
+        return JSONResponse(r.json(), status_code=r.status_code)
+
+    return JSONResponse({"error": "No API key configured"}, status_code=500)
+
+
+@app.get("/api/status")
+async def status():
+    res = {}
+
+    if GROQ_KEY:
+        try:
+            async with httpx.AsyncClient(timeout=8) as c:
+                r = await c.post(
+                    "https://api.groq.com/openai/v1/chat/completions",
+                    headers={"Authorization": f"Bearer {GROQ_KEY}", "Content-Type": "application/json"},
+                    json={"model": "llama-3.3-70b-versatile", "messages": [{"role": "user", "content": "hi"}], "max_tokens": 3}
+                )
+            res["groq"] = "✅ Groq Ready" if r.status_code == 200 else f"❌ Groq {r.status_code}"
+        except Exception as e:
+            res["groq"] = f"❌ Groq: {str(e)[:30]}"
+    else:
+        res["groq"] = "❌ Missing GROQ_API_KEY"
+
+    if NEMOTRON_KEY:
+        try:
+            async with httpx.AsyncClient(timeout=10) as c:
+                r = await c.post(
+                    "https://integrate.api.nvidia.com/v1/chat/completions",
+                    headers={"Authorization": f"Bearer {NEMOTRON_KEY}", "Content-Type": "application/json"},
+                    json={"model": "nvidia/llama-3.1-nemotron-70b-instruct", "messages": [{"role": "user", "content": "hi"}], "max_tokens": 3}
+                )
+            res["nemotron"] = "✅ Nemotron Ready" if r.status_code == 200 else f"⚠️ NVIDIA {r.status_code} → Groq fallback"
+        except Exception as e:
+            res["nemotron"] = f"⚠️ NVIDIA offline → Groq fallback"
+    else:
+        res["nemotron"] = "❌ Missing NEMOTRON_API_KEY"
+
+    if OPENROUTER_KEY:
+        try:
+            async with httpx.AsyncClient(timeout=10) as c:
+                r = await c.post(
+                    "https://openrouter.ai/api/v1/chat/completions",
+                    headers={
+                        "Authorization": f"Bearer {OPENROUTER_KEY}",
+                        "Content-Type": "application/json",
+                        "HTTP-Referer": "https://huggingface.co/spaces",
+                        "X-Title": "FORGE3D"
+                    },
+                    json={
+                        "model": "meta-llama/llama-3.3-70b-instruct:free",
+                        "messages": [{"role": "user", "content": "hi"}],
+                        "max_tokens": 3
+                    }
+                )
+            if r.status_code == 200:
+                res["openrouter"] = "✅ OpenRouter Ready"
+            else:
+                body_preview = r.text[:120]
+                res["openrouter"] = f"❌ OpenRouter {r.status_code}: {body_preview}"
+        except Exception as e:
+            res["openrouter"] = f"❌ OpenRouter: {str(e)[:40]}"
+    else:
+        res["openrouter"] = "❌ Missing OPENROUTER_API_KEY"
+
+    res["skills_md"] = "✅ SKILLS.md loaded" if CUSTOM_SKILLS else "ℹ️ No SKILLS.md (optional)"
+    return res
+
+
+# ── STATIC + ROUTES ──
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+@app.get("/")
+async def root():
+    return FileResponse("static/homepage.html")
+
+@app.get("/editor")
+async def editor():
+    return FileResponse("static/index.html")
+
+# Keep old index.html accessible directly too
+@app.get("/app")
+async def app_redirect():
+    return FileResponse("static/index.html")