sceneview-mcp 3.4.14 → 3.5.0

package/README.md

@@ -4,7 +4,7 @@
 
 [![npm version](https://img.shields.io/npm/v/sceneview-mcp?color=6c35aa)](https://www.npmjs.com/package/sceneview-mcp)
 [![npm downloads](https://img.shields.io/npm/dm/sceneview-mcp?color=blue)](https://www.npmjs.com/package/sceneview-mcp)
-[![Tests](https://img.shields.io/badge/tests-612%20passing-brightgreen)](#quality)
+[![Tests](https://img.shields.io/badge/tests-858%20passing-brightgreen)](#quality)
 [![MCP](https://img.shields.io/badge/MCP-v1.12-blue)](https://modelcontextprotocol.io/)
 [![Registry](https://img.shields.io/badge/MCP%20Registry-listed-blueviolet)](https://registry.modelcontextprotocol.io)
 [![License](https://img.shields.io/badge/License-MIT-green)](./LICENSE)
@@ -12,12 +12,24 @@
 
 The official [Model Context Protocol](https://modelcontextprotocol.io/) server for **[SceneView](https://sceneview.github.io)** -- the cross-platform 3D & AR SDK for Android (Jetpack Compose + Filament), iOS/macOS/visionOS (SwiftUI + RealityKit), and Web (Filament.js + WebXR).
 
-Connect it to Claude, Cursor, Windsurf, or any MCP client. The assistant gets 14 specialized tools, 33 compilable code samples, a full API reference, and a code validator -- so it writes correct, working 3D/AR code on the first try.
+Connect it to Claude, Cursor, Windsurf, or any MCP client. The assistant gets 22 specialized tools, 33 compilable code samples, a full API reference, and a code validator -- so it writes correct, working 3D/AR code on the first try.
 
 > **Disclaimer:** Generated code is provided "as is" without warranty. Always review before production use. See [TERMS.md](./TERMS.md) and [PRIVACY.md](./PRIVACY.md).
 
 ---
 
+## 🚀 Pro Products
+
+| Product | Price | Description |
+|---------|-------|-------------|
+| [MCP Creator Kit](https://buy.polar.sh/polar_cl_tb87ROB9Xn0c5aohdn3NvkTINDF1xjW5zpkg70UwmcF) | €29 | Everything to create your own MCP server — template, CLI, docs, examples |
+| [SceneView Pro Starter Kit](https://buy.polar.sh/polar_cl_tb87ROB9Xn0c5aohdn3NvkTINDF1xjW5zpkg70UwmcF) | €49 | Complete Android 3D + AR app template — 4 screens, ready to customize |
+| [SceneView MCP Pro](https://buy.polar.sh/polar_cl_tb87ROB9Xn0c5aohdn3NvkTINDF1xjW5zpkg70UwmcF) | €9.99/mo | Premium MCP tools and priority support |
+
+⭐ [Sponsor on GitHub](https://github.com/sponsors/sceneview) — Help us build the future of 3D/AR development
+
+---
+
 ## Quick start
 
 **One command -- no install required:**
@@ -72,7 +84,7 @@ Same JSON config as above. The server communicates via **stdio** using the stand
 
 ## What you get
 
-### 18 tools
+### 22 tools
 
 | Tool | What it does |
 |---|---|
@@ -80,7 +92,7 @@ Same JSON config as above. The server communicates via **stdio** using the stand
 | `list_samples` | Browse all samples, filter by tag (`ar`, `3d`, `ios`, `animation`, `geometry`, ...) |
 | `validate_code` | Checks generated code against 15+ rules before presenting it to the user |
 | `get_node_reference` | Full API reference for any of 26+ node types -- exact signatures, defaults, examples |
-| `list_node_types` | List every composable node type available in SceneView |
+| `list_platforms` | List all supported platforms with their status, renderer, and framework |
 | `get_setup` | Gradle + manifest setup for Android 3D or AR projects |
 | `get_ios_setup` | SPM dependency, Info.plist, and SwiftUI integration for iOS/macOS/visionOS |
 | `get_web_setup` | Kotlin/JS + Filament.js (WASM) setup for browser-based 3D |
@@ -95,6 +107,9 @@ Same JSON config as above. The server communicates via **stdio** using the stand
 | `migrate_code` | Automatically migrates SceneView 2.x code to 3.x with detailed changelog |
 | `debug_issue` | Targeted debugging guide by category or auto-detected from problem description |
 | `generate_scene` | Generates a complete composable from natural language (e.g., "a room with a table and two chairs") |
+| `get_animation_guide` | Guide for model animations, Spring physics, Compose property animations, SmoothTransform |
+| `get_gesture_guide` | Guide for gestures: isEditable, onTouchEvent, tap-to-place, drag-to-rotate, pinch-to-scale |
+| `get_performance_tips` | Performance optimization: LOD, texture compression, instancing, profiling with Systrace/AGI |
 
 ### 2 resources
 
@@ -151,7 +166,7 @@ The assistant calls `render_3d_preview` and returns an interactive link to a bro
 
 ## Quality
 
-The MCP server is tested with **612 unit tests** across 14 test suites covering:
+The MCP server is tested with **858 unit tests** across 22 test suites covering:
 
 - Every tool response (correct output, error handling, edge cases)
 - All 33 code samples (compilable structure, correct imports, no deprecated APIs)
@@ -160,9 +175,9 @@ The MCP server is tested with **612 unit tests** across 14 test suites covering:
 - Resource responses (API reference, GitHub issues integration)
 
 ```
- Test Files  14 passed (14)
-      Tests  612 passed (612)
-   Duration  491ms
+ Test Files  22 passed (22)
+      Tests  858 passed (858)
+   Duration  624ms
 ```
 
 All tools work **fully offline** except `sceneview://known-issues` (GitHub API, cached 10 min).
@@ -213,7 +228,7 @@ The only network call is to the GitHub API (for known issues). All other tools w
 cd mcp
 npm install
 npm run prepare  # Copy llms.txt + build TypeScript
-npm test         # 612 tests
+npm test         # 858 tests
 npm run dev      # Start with tsx (hot reload)
 ```
 
@@ -222,7 +237,7 @@ npm run dev      # Start with tsx (hot reload)
 ```
 mcp/
   src/
-    index.ts          # MCP server entry point (18 tools, 2 resources)
+    index.ts          # MCP server entry point (22 tools, 2 resources)
     samples.ts         # 33 compilable code samples (Kotlin + Swift)
     validator.ts       # Code validator (15+ rules, Kotlin + Swift)
     node-reference.ts  # Node type parser (extracts from llms.txt)
@@ -239,7 +254,7 @@ mcp/
 1. Fork the repository
 2. Create a feature branch
 3. Add tests for new tools or rules
-4. Run `npm test` -- all 612+ tests must pass
+4. Run `npm test` -- all 858+ tests must pass
 5. Submit a pull request
 
 See [CONTRIBUTING.md](../CONTRIBUTING.md) for the full guide.

package/dist/advanced-guides.js

@@ -0,0 +1,806 @@
+/**
+ * advanced-guides.ts
+ *
+ * Animation, gesture, and performance guides for SceneView developers.
+ */
+// ─── Animation Guide ─────────────────────────────────────────────────────────
+export const ANIMATION_GUIDE = `# SceneView Animation Guide
+
+## 1. Playing glTF Model Animations
+
+GLB/glTF models can embed skeletal and morph-target animations. SceneView exposes them via \`Animator\` on the model instance.
+
+\`\`\`kotlin
+@Composable
+fun AnimatedModelScreen() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/character.glb")
+
+    Scene(engine = engine) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 1.0f,
+                // autoAnimate = true plays the first animation automatically
+                autoAnimate = true
+            )
+        }
+    }
+}
+\`\`\`
+
+### Controlling Animations Manually
+
+\`\`\`kotlin
+@Composable
+fun ManualAnimationScreen() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/robot.glb")
+
+    Scene(
+        engine = engine,
+        onFrame = { frameTimeNanos ->
+            modelInstance?.let { instance ->
+                val animator = instance.animator
+                if (animator.animationCount > 0) {
+                    // Update animation time
+                    animator.applyAnimation(
+                        animationIndex = 0,
+                        time = (frameTimeNanos / 1_000_000_000.0).toFloat()
+                    )
+                    animator.updateBoneMatrices()
+                }
+            }
+        }
+    ) {
+        modelInstance?.let { instance ->
+            ModelNode(modelInstance = instance, scaleToUnits = 1.0f)
+        }
+    }
+}
+\`\`\`
+
+### Listing Available Animations
+
+\`\`\`kotlin
+modelInstance?.let { instance ->
+    val animator = instance.animator
+    for (i in 0 until animator.animationCount) {
+        val name = animator.getAnimationName(i)
+        val duration = animator.getAnimationDuration(i)
+        Log.d("Anim", "Animation $i: '$name' (\${duration}s)")
+    }
+}
+\`\`\`
+
+## 2. Spring Animations (KMP Core)
+
+SceneView's KMP core provides spring-based animations for smooth, physics-driven motion.
+
+\`\`\`kotlin
+import io.github.sceneview.core.animation.Spring
+import io.github.sceneview.core.animation.SpringAnimation
+
+@Composable
+fun SpringAnimatedNode() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/cube.glb")
+
+    // Spring-based position animation
+    var targetY by remember { mutableFloatStateOf(0f) }
+    val springY = remember {
+        SpringAnimation(
+            spring = Spring(
+                stiffness = Spring.StiffnessMedium,
+                dampingRatio = Spring.DampingRatioMediumBouncy
+            ),
+            initialValue = 0f
+        )
+    }
+
+    Scene(
+        engine = engine,
+        onFrame = { _ ->
+            springY.target = targetY
+            springY.advance(0.016f) // ~60fps dt
+        }
+    ) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 0.5f,
+                position = Position(0f, springY.value, 0f)
+            )
+        }
+    }
+
+    // Toggle position on button press
+    Button(onClick = { targetY = if (targetY == 0f) 2f else 0f }) {
+        Text("Bounce")
+    }
+}
+\`\`\`
+
+### Spring Presets
+
+| Preset | Stiffness | Damping | Use Case |
+|--------|-----------|---------|----------|
+| \`StiffnessHigh\` / \`DampingRatioNoBouncy\` | 10000 | 1.0 | Snappy UI, instant feel |
+| \`StiffnessMedium\` / \`DampingRatioLowBouncy\` | 1500 | 0.75 | General purpose |
+| \`StiffnessMediumLow\` / \`DampingRatioMediumBouncy\` | 400 | 0.5 | Playful bounce |
+| \`StiffnessLow\` / \`DampingRatioHighBouncy\` | 200 | 0.2 | Heavy bounce, toy-like |
+
+## 3. Property Animations
+
+Animate any node property (position, rotation, scale) over time with easing.
+
+\`\`\`kotlin
+@Composable
+fun PropertyAnimationDemo() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/sphere.glb")
+
+    // Compose animation for rotation
+    val infiniteTransition = rememberInfiniteTransition(label = "rotate")
+    val rotationY by infiniteTransition.animateFloat(
+        initialValue = 0f,
+        targetValue = 360f,
+        animationSpec = infiniteRepeatable(
+            animation = tween(durationMillis = 3000, easing = LinearEasing),
+            repeatMode = RepeatMode.Restart
+        ),
+        label = "rotY"
+    )
+
+    Scene(engine = engine) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 0.5f,
+                rotation = Rotation(0f, rotationY, 0f)
+            )
+        }
+    }
+}
+\`\`\`
+
+### Animating Scale with Compose
+
+\`\`\`kotlin
+var isExpanded by remember { mutableStateOf(false) }
+val scale by animateFloatAsState(
+    targetValue = if (isExpanded) 2.0f else 1.0f,
+    animationSpec = spring(
+        dampingRatio = Spring.DampingRatioMediumBouncy,
+        stiffness = Spring.StiffnessMedium
+    ),
+    label = "scale"
+)
+
+ModelNode(
+    modelInstance = instance,
+    scaleToUnits = scale
+)
+\`\`\`
+
+## 4. Smooth Transform (KMP Core)
+
+SmoothTransform interpolates between current and target transforms over time — ideal for following a moving target.
+
+\`\`\`kotlin
+import io.github.sceneview.core.animation.SmoothTransform
+
+@Composable
+fun SmoothFollowDemo() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/drone.glb")
+
+    val smoothPosition = remember { SmoothTransform(smoothTime = 0.3f) }
+    var targetPosition by remember { mutableStateOf(Position(0f, 1f, 0f)) }
+
+    Scene(
+        engine = engine,
+        onFrame = { _ ->
+            smoothPosition.target = targetPosition
+            smoothPosition.advance(0.016f)
+        }
+    ) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 0.3f,
+                position = smoothPosition.current
+            )
+        }
+    }
+}
+\`\`\`
+
+## 5. AR Animation — Animated Model on Anchor
+
+\`\`\`kotlin
+@Composable
+fun ARAnimatedModel() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/dancing_character.glb")
+    var anchor by remember { mutableStateOf<Anchor?>(null) }
+
+    ARScene(
+        engine = engine,
+        modelLoader = modelLoader,
+        planeRenderer = true,
+        onTouchEvent = { event, hitResult ->
+            if (event.action == MotionEvent.ACTION_UP && hitResult != null) {
+                anchor = hitResult.createAnchor()
+            }
+            true
+        }
+    ) {
+        anchor?.let { a ->
+            AnchorNode(anchor = a) {
+                modelInstance?.let { instance ->
+                    ModelNode(
+                        modelInstance = instance,
+                        scaleToUnits = 0.5f,
+                        autoAnimate = true // plays embedded animation
+                    )
+                }
+            }
+        }
+    }
+}
+\`\`\`
+
+## Key Takeaways
+
+1. **Embedded animations** — use \`autoAnimate = true\` or control \`Animator\` manually in \`onFrame\`.
+2. **Compose animations** — use \`animateFloatAsState\`, \`InfiniteTransition\`, \`Animatable\` — they integrate naturally with SceneView nodes.
+3. **Spring animations** — use KMP core \`SpringAnimation\` for physics-driven motion.
+4. **SmoothTransform** — use for smooth following / interpolation (camera follow, target tracking).
+5. **Threading** — all animation updates in \`onFrame\` run on the main thread (safe for Filament).
+`;
+// ─── Gesture Guide ───────────────────────────────────────────────────────────
+export const GESTURE_GUIDE = `# SceneView Gesture Guide
+
+## 1. Built-in Gestures with \`isEditable\`
+
+The simplest way to add gestures. Setting \`isEditable = true\` on a \`ModelNode\` enables:
+- **Pinch to scale** — two-finger pinch scales the model
+- **Drag to rotate** — single-finger drag rotates around Y axis
+- **Tap to select** — tap highlights the model
+
+\`\`\`kotlin
+@Composable
+fun EditableModelScreen() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/chair.glb")
+
+    Scene(engine = engine) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 1.0f,
+                // Enable built-in gestures
+                isEditable = true
+            )
+        }
+    }
+}
+\`\`\`
+
+### What \`isEditable\` Provides
+
+| Gesture | Action | Modifier |
+|---------|--------|----------|
+| Single tap | Select / deselect | — |
+| Single-finger drag | Rotate around Y axis | — |
+| Two-finger pinch | Scale up / down | Clamped to min/max |
+| Two-finger drag | Pan / translate | — |
+
+## 2. Custom Gesture Handling with \`onTouchEvent\`
+
+For full control, use the \`onTouchEvent\` callback on \`Scene\` or \`ARScene\`.
+
+\`\`\`kotlin
+@Composable
+fun CustomGestureScreen() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/robot.glb")
+    var selectedNode by remember { mutableStateOf<ModelNode?>(null) }
+
+    Scene(
+        engine = engine,
+        onTouchEvent = { event, hitResult ->
+            when (event.action) {
+                MotionEvent.ACTION_DOWN -> {
+                    // hitResult contains the node that was tapped (if any)
+                    // Use this to detect taps on specific models
+                    true
+                }
+                MotionEvent.ACTION_MOVE -> {
+                    // Handle drag gestures
+                    true
+                }
+                MotionEvent.ACTION_UP -> {
+                    // Handle tap release
+                    true
+                }
+                else -> false
+            }
+        }
+    ) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 1.0f
+            )
+        }
+    }
+}
+\`\`\`
+
+## 3. Tap-to-Place in AR
+
+The most common AR gesture — tap a detected plane to place a model.
+
+\`\`\`kotlin
+@Composable
+fun TapToPlaceAR() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/furniture.glb")
+    var anchor by remember { mutableStateOf<Anchor?>(null) }
+
+    ARScene(
+        engine = engine,
+        modelLoader = modelLoader,
+        planeRenderer = true,
+        onTouchEvent = { event, hitResult ->
+            if (event.action == MotionEvent.ACTION_UP && hitResult != null) {
+                // Create an anchor at the tap location on the AR plane
+                anchor = hitResult.createAnchor()
+            }
+            true
+        }
+    ) {
+        anchor?.let { a ->
+            AnchorNode(anchor = a) {
+                modelInstance?.let { instance ->
+                    ModelNode(
+                        modelInstance = instance,
+                        scaleToUnits = 0.5f,
+                        isEditable = true // allow further manipulation after placement
+                    )
+                }
+            }
+        }
+    }
+}
+\`\`\`
+
+## 4. Drag-to-Rotate with Custom Sensitivity
+
+\`\`\`kotlin
+@Composable
+fun DragToRotateScreen() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/shoe.glb")
+    var rotationY by remember { mutableFloatStateOf(0f) }
+    var lastX by remember { mutableFloatStateOf(0f) }
+    val sensitivity = 0.5f
+
+    Scene(
+        engine = engine,
+        onTouchEvent = { event, _ ->
+            when (event.action) {
+                MotionEvent.ACTION_DOWN -> {
+                    lastX = event.x
+                    true
+                }
+                MotionEvent.ACTION_MOVE -> {
+                    val deltaX = event.x - lastX
+                    rotationY += deltaX * sensitivity
+                    lastX = event.x
+                    true
+                }
+                else -> false
+            }
+        }
+    ) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 1.0f,
+                rotation = Rotation(0f, rotationY, 0f)
+            )
+        }
+    }
+}
+\`\`\`
+
+## 5. Pinch-to-Scale with Custom Limits
+
+\`\`\`kotlin
+@Composable
+fun PinchToScaleScreen() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val modelInstance = rememberModelInstance(modelLoader, "models/vase.glb")
+    var currentScale by remember { mutableFloatStateOf(1.0f) }
+    val minScale = 0.3f
+    val maxScale = 3.0f
+
+    val scaleDetector = rememberScaleGestureDetector { detector ->
+        currentScale = (currentScale * detector.scaleFactor).coerceIn(minScale, maxScale)
+    }
+
+    Scene(
+        engine = engine,
+        onTouchEvent = { event, _ ->
+            scaleDetector.onTouchEvent(event)
+            true
+        }
+    ) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = currentScale
+            )
+        }
+    }
+}
+\`\`\`
+
+## 6. Multi-Model Selection
+
+\`\`\`kotlin
+@Composable
+fun MultiModelSelectionScreen() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val chair = rememberModelInstance(modelLoader, "models/chair.glb")
+    val table = rememberModelInstance(modelLoader, "models/table.glb")
+    var selectedModel by remember { mutableStateOf<String?>(null) }
+
+    Scene(engine = engine) {
+        chair?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 0.5f,
+                position = Position(-1f, 0f, 0f),
+                isEditable = true,
+                onTap = { selectedModel = "chair" }
+            )
+        }
+        table?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 0.5f,
+                position = Position(1f, 0f, 0f),
+                isEditable = true,
+                onTap = { selectedModel = "table" }
+            )
+        }
+    }
+
+    // Show selection UI
+    selectedModel?.let { name ->
+        Text("Selected: $name", modifier = Modifier.padding(16.dp))
+    }
+}
+\`\`\`
+
+## 7. HitResultNode — Surface Cursor
+
+A model that follows the user's gaze / screen center on AR planes — before they tap to place.
+
+\`\`\`kotlin
+@Composable
+fun SurfaceCursorAR() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val cursorModel = rememberModelInstance(modelLoader, "models/cursor_ring.glb")
+
+    ARScene(
+        engine = engine,
+        modelLoader = modelLoader,
+        planeRenderer = true
+    ) {
+        // HitResultNode automatically follows the center hit on AR planes
+        HitResultNode(engine = engine) {
+            cursorModel?.let { instance ->
+                ModelNode(modelInstance = instance, scaleToUnits = 0.1f)
+            }
+        }
+    }
+}
+\`\`\`
+
+## Key Takeaways
+
+1. **\`isEditable = true\`** — one-liner for pinch/drag/tap on any ModelNode.
+2. **\`onTouchEvent\`** — full MotionEvent access for custom gesture logic.
+3. **AR tap-to-place** — use \`hitResult.createAnchor()\` in \`onTouchEvent\` with \`ACTION_UP\`.
+4. **Custom rotation/scale** — track touch deltas or use \`ScaleGestureDetector\`.
+5. **HitResultNode** — AR surface cursor that follows the center of the screen.
+6. **Multi-model** — use \`onTap\` callback per ModelNode for selection.
+`;
+// ─── Performance Tips ────────────────────────────────────────────────────────
+export const PERFORMANCE_TIPS = `# SceneView Performance Optimization Guide
+
+## 1. Model Optimization
+
+### Polygon Budget
+
+| Device Tier | Max Triangles | Max Draw Calls | Max Textures |
+|-------------|--------------|----------------|--------------|
+| Low-end     | 50K          | 20             | 8 x 512px    |
+| Mid-range   | 100K         | 50             | 16 x 1024px  |
+| High-end    | 300K+        | 100+           | 32 x 2048px  |
+
+### LOD (Level of Detail)
+
+Use multiple LODs in your glTF models to reduce triangle count at distance. Filament respects glTF LOD extensions.
+
+\`\`\`kotlin
+@Composable
+fun LODModelDemo() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    // Use a GLB exported with LOD levels from Blender/3ds Max
+    // Filament picks the appropriate LOD automatically based on screen coverage
+    val modelInstance = rememberModelInstance(modelLoader, "models/building_lod.glb")
+
+    Scene(engine = engine) {
+        modelInstance?.let { instance ->
+            ModelNode(
+                modelInstance = instance,
+                scaleToUnits = 5.0f
+            )
+        }
+    }
+}
+\`\`\`
+
+### Texture Compression
+
+**Always use KTX2 with Basis Universal** for production builds:
+
+\`\`\`bash
+# Install KTX tools: https://github.com/KhronosGroup/KTX-Software
+# Convert textures to KTX2 with Basis Universal compression
+toktx --t2 --bcmp --assign_oetf srgb output.ktx2 input.png
+
+# Or compress entire glTF with gltf-transform
+npx @gltf-transform/cli optimize input.glb output.glb \\
+    --compress draco \\
+    --texture-compress ktx2
+\`\`\`
+
+**Texture size guidelines:**
+- Diffuse/base color: 1024x1024 max on mobile
+- Normal maps: 512x512 (hard to see detail at higher res on mobile)
+- Roughness/metallic: 512x512 (pack into single texture channels)
+- Environment HDR: 2K (sky_2k.hdr) is sufficient for most scenes
+
+### Mesh Optimization with Draco / Meshopt
+
+\`\`\`bash
+# Draco compression (lossy, smallest files, supported by Filament)
+npx @gltf-transform/cli optimize model.glb compressed.glb \\
+    --compress draco
+
+# Meshopt compression (lossless, good balance, supported by Filament)
+npx @gltf-transform/cli optimize model.glb compressed.glb \\
+    --compress meshopt
+
+# Typical savings: 60-90% file size reduction
+\`\`\`
+
+## 2. Runtime Performance
+
+### Engine and Loader Reuse
+
+\`\`\`kotlin
+// CORRECT — single engine for entire app
+@Composable
+fun MyApp() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+
+    // Pass engine and modelLoader to all scenes
+    NavHost(...) {
+        composable("scene1") { Scene1(engine, modelLoader) }
+        composable("scene2") { Scene2(engine, modelLoader) }
+    }
+}
+
+// WRONG — each screen creates its own engine (wastes GPU memory)
+@Composable
+fun BadScene() {
+    val engine = rememberEngine() // creates new engine each time!
+    Scene(engine = engine) { /* ... */ }
+}
+\`\`\`
+
+### Avoid Per-Frame Allocations
+
+\`\`\`kotlin
+// WRONG — creates new Position every frame
+Scene(
+    engine = engine,
+    onFrame = { _ ->
+        node.position = Position(x, y, z) // allocation every frame!
+    }
+)
+
+// CORRECT — reuse mutable position
+val position = remember { MutablePosition() }
+Scene(
+    engine = engine,
+    onFrame = { _ ->
+        position.set(x, y, z)
+        node.position = position
+    }
+)
+\`\`\`
+
+### Limit Concurrent Model Loads
+
+\`\`\`kotlin
+// WRONG — loads 20 models at once, spikes memory
+items.forEach { item ->
+    val model = rememberModelInstance(modelLoader, item.path)
+    // All 20 start loading simultaneously
+}
+
+// CORRECT — stagger or paginate model loading
+val visibleItems = items.take(4) // only load visible models
+visibleItems.forEach { item ->
+    val model = rememberModelInstance(modelLoader, item.path)
+    model?.let { ModelNode(modelInstance = it, scaleToUnits = 0.5f) }
+}
+\`\`\`
+
+## 3. Frustum Culling
+
+Filament performs frustum culling automatically — objects outside the camera view are not rendered. You can improve this by:
+
+\`\`\`kotlin
+// Set accurate bounding boxes on nodes for better culling
+ModelNode(
+    modelInstance = instance,
+    scaleToUnits = 1.0f
+    // Filament automatically computes bounding boxes from mesh data
+    // For custom geometry, set boundingBox explicitly
+)
+\`\`\`
+
+**Tips for effective frustum culling:**
+- Break large scenes into multiple ModelNodes instead of one giant mesh
+- Each ModelNode has its own bounding box and can be culled independently
+- Use \`scaleToUnits\` — it helps Filament compute tighter bounding boxes
+
+## 4. Instancing
+
+When rendering multiple copies of the same model (e.g., trees, buildings), use instancing to share mesh data.
+
+\`\`\`kotlin
+@Composable
+fun InstancedTreesScene() {
+    val engine = rememberEngine()
+    val modelLoader = rememberModelLoader(engine)
+    val treeInstance = rememberModelInstance(modelLoader, "models/tree.glb")
+
+    Scene(engine = engine) {
+        // Each ModelNode with the same modelInstance shares GPU mesh data
+        // Filament handles instancing internally when using the same asset
+        treeInstance?.let { instance ->
+            for (i in 0 until 10) {
+                val x = (i % 5) * 2.0f - 4.0f
+                val z = (i / 5) * 2.0f - 1.0f
+                ModelNode(
+                    modelInstance = instance,
+                    scaleToUnits = 1.5f,
+                    position = Position(x, 0f, z)
+                )
+            }
+        }
+    }
+}
+\`\`\`
+
+> **Note:** When placing the same \`modelInstance\` in multiple \`ModelNode\`s, the mesh and material data is shared on the GPU. For independent transforms, Filament handles per-instance transforms efficiently.
+
+## 5. Lighting Optimization
+
+\`\`\`kotlin
+// Limit shadow-casting lights — each adds a depth render pass
+LightNode(
+    type = LightNode.Type.DIRECTIONAL,
+    apply = {
+        intensity(100_000f)
+        direction(0f, -1f, -1f)
+        castShadows(true) // adds one depth pass
+    }
+)
+
+// Use small HDR environments
+val environment = rememberEnvironment(engine, "environments/sky_2k.hdr")
+// NOT: sky_4k.hdr or sky_8k.hdr (wastes GPU memory on mobile)
+\`\`\`
+
+**Shadow optimization checklist:**
+- Only 1-2 shadow-casting lights max on mobile
+- Reduce shadow map resolution if needed (Filament defaults are reasonable)
+- Disable shadows on objects that don't need them
+
+## 6. Post-Processing
+
+\`\`\`kotlin
+// Disable post-processing for simpler scenes (saves ~2ms per frame)
+Scene(
+    engine = engine,
+    postProcessing = false // skips bloom, SSAO, tone mapping
+) {
+    // Simpler rendering, better FPS
+}
+\`\`\`
+
+| Effect | Cost | Recommendation |
+|--------|------|----------------|
+| Tone mapping | Low | Keep enabled (visual quality) |
+| FXAA | Low | Keep enabled (anti-aliasing) |
+| Bloom | Medium | Disable on low-end devices |
+| SSAO | High | Disable on mobile |
+| Screen-space reflections | High | Disable on mobile |
+
+## 7. Profiling with Systrace
+
+\`\`\`bash
+# Capture a Systrace for Filament rendering
+python systrace.py -t 5 -o trace.html gfx view
+
+# Or use Android Studio Profiler:
+# 1. Run app with profiling enabled
+# 2. Open CPU profiler → Record trace
+# 3. Look for Filament sections: "Filament::Renderer", "Filament::View"
+\`\`\`
+
+### Key Metrics to Watch
+
+| Metric | Target | Action if Over |
+|--------|--------|----------------|
+| Frame time | < 16.6ms (60fps) | Reduce polygons, textures |
+| Draw calls | < 50 | Merge meshes, use instancing |
+| GPU memory | < 256MB | Compress textures, reduce LOD |
+| Model load time | < 2s | Use Draco/Meshopt, smaller models |
+
+## 8. Android GPU Inspector (AGI)
+
+For detailed GPU profiling:
+
+1. Install AGI from [developer.android.com/agi](https://developer.android.com/agi)
+2. Enable GPU profiling in device developer options
+3. Capture a frame: AGI shows exact GPU time per draw call
+4. Identify bottlenecks: shader compilation, overdraw, texture sampling
+
+## Key Takeaways
+
+1. **Compress models** — Draco/Meshopt + KTX2 textures. Target 60-90% size reduction.
+2. **Reuse engines** — one \`rememberEngine()\` per app, pass it down.
+3. **Limit loads** — max 3-4 concurrent \`rememberModelInstance\` calls.
+4. **Frustum culling** — break scenes into multiple nodes for automatic culling.
+5. **Instancing** — reuse the same \`modelInstance\` for repeated objects.
+6. **Profile** — use Systrace or AGI to find real bottlenecks, don't guess.
+7. **Post-processing** — disable what you don't need (\`postProcessing = false\`).
+`;

package/dist/debug-issue.js

@@ -502,7 +502,7 @@ Scene(
 - Require Xcode 15.0+ (iOS 17 / visionOS targets).
 - Clean: Xcode > Product > Clean Build Folder.
 - Reset packages: File > Packages > Reset Package Caches.
-- URL must be exactly: \`https://github.com/SceneView/sceneview\`
+- URL must be exactly: \`https://github.com/sceneview/sceneview\`
 
 ### Swift Concurrency Warnings
 

package/dist/guides.js

@@ -60,8 +60,8 @@ Shared Kotlin Multiplatform module providing:
 
 ## How to Stay Updated
 
-- **GitHub:** https://github.com/SceneView/sceneview
-- **Releases:** https://github.com/SceneView/sceneview/releases
+- **GitHub:** https://github.com/sceneview/sceneview
+- **Releases:** https://github.com/sceneview/sceneview/releases
 - **Website:** https://sceneview.github.io
 `;
 // ─── Best Practices ───────────────────────────────────────────────────────────
@@ -321,7 +321,7 @@ export const TROUBLESHOOTING_GUIDE = `# SceneView Troubleshooting Guide
 **Fix:**
 - Ensure Xcode 15.0+ (required for iOS 17 / visionOS targets).
 - Clean derived data: Xcode → Product → Clean Build Folder, then File → Packages → Reset Package Caches.
-- Check the URL is exactly: \`https://github.com/SceneView/sceneview\`
+- Check the URL is exactly: \`https://github.com/sceneview/sceneview\`
 
 ### Image Tracking Not Working (iOS)
 **Fix:**
@@ -339,7 +339,7 @@ export const AR_SETUP_GUIDE = `# SceneView AR — Complete Setup Guide (Android
 ## 1. SPM Dependency
 
 \`\`\`swift
-.package(url: "https://github.com/SceneView/sceneview", from: "3.3.0")
+.package(url: "https://github.com/sceneview/sceneview", from: "3.3.0")
 \`\`\`
 
 ## 2. Info.plist — Camera Permission

package/dist/index.js

@@ -17,9 +17,11 @@ import { getPlatformSetup, PLATFORM_IDS } from "./platform-setup.js";
 import { migrateCode, formatMigrationResult } from "./migrate-code.js";
 import { getDebugGuide, autoDetectIssue, DEBUG_CATEGORIES } from "./debug-issue.js";
 import { generateScene, formatGeneratedScene } from "./generate-scene.js";
+import { ANIMATION_GUIDE, GESTURE_GUIDE, PERFORMANCE_TIPS } from "./advanced-guides.js";
+import { MATERIAL_GUIDE, COLLISION_GUIDE, MODEL_OPTIMIZATION_GUIDE, WEB_RENDERING_GUIDE } from "./extra-guides.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // ─── Legal disclaimer ─────────────────────────────────────────────────────────
-const DISCLAIMER = '\n\n---\n*Generated code suggestion. Review before use in production. See [TERMS.md](https://github.com/SceneView/sceneview/blob/main/mcp/TERMS.md).*';
+const DISCLAIMER = '\n\n---\n*Generated code suggestion. Review before use in production. See [TERMS.md](https://github.com/sceneview/sceneview/blob/main/mcp/TERMS.md).*';
 function withDisclaimer(content) {
     if (content.length === 0)
         return content;
@@ -37,7 +39,7 @@ catch {
     API_DOCS = "SceneView API docs not found. Run `npm run prepare` to bundle llms.txt.";
 }
 const NODE_SECTIONS = parseNodeSections(API_DOCS);
-const server = new Server({ name: "@sceneview/mcp", version: "3.4.14" }, { capabilities: { resources: {}, tools: {} } });
+const server = new Server({ name: "sceneview-mcp", version: "3.5.0" }, { capabilities: { resources: {}, tools: {} } });
 // ─── Resources ───────────────────────────────────────────────────────────────
 server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
@@ -424,6 +426,69 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: [],
             },
         },
+        {
+            name: "get_animation_guide",
+            description: "Returns a comprehensive guide for animating 3D models in SceneView — playing embedded glTF animations, Spring physics animations (KMP core), Compose property animations (animateFloatAsState, InfiniteTransition), SmoothTransform for smooth following, and AR animated models. Includes compilable Kotlin code samples. Use this when a user asks about animation, motion, springs, smooth movement, or how to play model animations.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: "get_gesture_guide",
+            description: "Returns a comprehensive guide for adding gestures to 3D objects in SceneView — isEditable for one-line pinch-to-scale/drag-to-rotate/tap-to-select, custom onTouchEvent handlers, AR tap-to-place, drag-to-rotate with sensitivity, pinch-to-scale with limits, multi-model selection, and HitResultNode surface cursor. Includes compilable Kotlin code samples. Use this when a user asks about touch, gestures, interaction, drag, pinch, tap, or editing 3D objects.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: "get_performance_tips",
+            description: "Returns a comprehensive performance optimization guide for SceneView — polygon budgets per device tier, LOD, texture compression (KTX2/Basis Universal), mesh compression (Draco/Meshopt), engine reuse, per-frame allocation avoidance, frustum culling, instancing, lighting optimization, post-processing costs, and profiling with Systrace and Android GPU Inspector. Includes code samples and CLI commands. Use this when a user asks about performance, optimization, FPS, memory, profiling, or slow rendering.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: "get_material_guide",
+            description: "Returns a comprehensive guide for PBR materials in SceneView — baseColor, metallic, roughness, reflectance, emissive, clearCoat, normal maps. Includes recipes for common materials (glass, chrome, gold, rubber, car paint), code samples for modifying materials on ModelNode, texture setup, and environment lighting requirements. Use this when a user asks about materials, textures, colors, shaders, appearance, or why their model looks wrong (flat, dark, too shiny).",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: "get_collision_guide",
+            description: "Returns a comprehensive guide for collision detection, hit testing, and physics in SceneView — node tapping (onTouchEvent), AR surface hit testing (frame.hitTest), ray-box/ray-sphere intersection (KMP core), bounding boxes, and basic rigid body physics. Use this when a user asks about tapping 3D objects, collision detection, physics simulation, ray casting, or hit testing.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: "get_model_optimization_guide",
+            description: "Returns a complete guide for optimizing 3D models for SceneView — polygon budgets per device tier, file size targets, Draco/Meshopt mesh compression, KTX2 texture compression, the recommended optimization pipeline (gltf-transform CLI), texture sizing rules, LOD strategies, and quick wins. Use this when a user asks about model optimization, file size, load times, polygon count, texture compression, or preparing models for mobile.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: "get_web_rendering_guide",
+            description: "Returns a comprehensive guide for SceneView Web (Filament.js WASM) — architecture, quick start (sceneview.js npm or Kotlin/JS), IBL environment lighting (critical for PBR quality), rendering quality settings (SSAO, bloom, TAA), camera exposure tuning, Filament.js vs model-viewer comparison, and web performance tips. Use this when a user asks about web 3D rendering, Filament.js, browser viewing, WebGL, or wants to display 3D models in a web page.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        },
     ],
 }));
 // ─── Tool handlers ────────────────────────────────────────────────────────────
@@ -654,7 +719,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 ``,
                                 `In Xcode: **File → Add Package Dependencies** → paste:`,
                                 `\`\`\``,
-                                `https://github.com/SceneView/sceneview`,
+                                `https://github.com/sceneview/sceneview`,
                                 `\`\`\``,
                                 `Set version rule to **"from: 3.3.0"**.`,
                                 ``,
@@ -667,7 +732,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 `    name: "MyApp",`,
                                 `    platforms: [.iOS(.v17), .macOS(.v14), .visionOS(.v1)],`,
                                 `    dependencies: [`,
-                                `        .package(url: "https://github.com/SceneView/sceneview", from: "3.3.0")`,
+                                `        .package(url: "https://github.com/sceneview/sceneview", from: "3.3.0")`,
                                 `    ],`,
                                 `    targets: [`,
                                 `        .executableTarget(`,
@@ -738,7 +803,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 `### 1. Add SPM Dependency`,
                                 ``,
                                 `\`\`\`swift`,
-                                `.package(url: "https://github.com/SceneView/sceneview", from: "3.3.0")`,
+                                `.package(url: "https://github.com/sceneview/sceneview", from: "3.3.0")`,
                                 `\`\`\``,
                                 ``,
                                 `### 2. Minimum Platform`,
@@ -1050,6 +1115,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             ];
             return { content: withDisclaimer([{ type: "text", text: lines.join("\n") }]) };
         }
+        // ── get_animation_guide ─────────────────────────────────────────────────
+        case "get_animation_guide": {
+            return { content: withDisclaimer([{ type: "text", text: ANIMATION_GUIDE }]) };
+        }
+        // ── get_gesture_guide ────────────────────────────────────────────────────
+        case "get_gesture_guide": {
+            return { content: withDisclaimer([{ type: "text", text: GESTURE_GUIDE }]) };
+        }
+        // ── get_performance_tips ─────────────────────────────────────────────────
+        case "get_performance_tips": {
+            return { content: withDisclaimer([{ type: "text", text: PERFORMANCE_TIPS }]) };
+        }
+        // ── get_material_guide ───────────────────────────────────────────────────
+        case "get_material_guide": {
+            return { content: withDisclaimer([{ type: "text", text: MATERIAL_GUIDE }]) };
+        }
+        // ── get_collision_guide ──────────────────────────────────────────────────
+        case "get_collision_guide": {
+            return { content: withDisclaimer([{ type: "text", text: COLLISION_GUIDE }]) };
+        }
+        // ── get_model_optimization_guide ─────────────────────────────────────────
+        case "get_model_optimization_guide": {
+            return { content: withDisclaimer([{ type: "text", text: MODEL_OPTIMIZATION_GUIDE }]) };
+        }
+        // ── get_web_rendering_guide ──────────────────────────────────────────────
+        case "get_web_rendering_guide": {
+            return { content: withDisclaimer([{ type: "text", text: WEB_RENDERING_GUIDE }]) };
+        }
         default:
             return {
                 content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],

package/dist/issues.js

@@ -9,10 +9,10 @@ export async function fetchKnownIssues() {
     let issues = [];
     let fetchError = null;
     try {
-        const response = await fetch("https://api.github.com/repos/SceneView/sceneview/issues?state=open&per_page=30", {
+        const response = await fetch("https://api.github.com/repos/sceneview/sceneview/issues?state=open&per_page=30", {
             headers: {
                 Accept: "application/vnd.github+json",
-                "User-Agent": "sceneview-mcp/3.3.0",
+                "User-Agent": "sceneview-mcp/3.4.14",
                 "X-GitHub-Api-Version": "2022-11-28",
             },
         });

package/dist/platform-setup.js

@@ -176,7 +176,7 @@ const IOS_3D = `## SceneViewSwift — iOS/macOS/visionOS 3D Setup
 
 In Xcode: **File > Add Package Dependencies** > paste:
 \`\`\`
-https://github.com/SceneView/sceneview
+https://github.com/sceneview/sceneview
 \`\`\`
 Set version rule to **"from: 3.3.0"**.
 
@@ -189,7 +189,7 @@ let package = Package(
     name: "MyApp",
     platforms: [.iOS(.v17), .macOS(.v14), .visionOS(.v1)],
     dependencies: [
-        .package(url: "https://github.com/SceneView/sceneview", from: "3.3.0")
+        .package(url: "https://github.com/sceneview/sceneview", from: "3.3.0")
     ],
     targets: [
         .executableTarget(
@@ -251,7 +251,7 @@ const IOS_AR = `## SceneViewSwift — iOS AR Setup
 ### 1. SPM Dependency
 
 \`\`\`swift
-.package(url: "https://github.com/SceneView/sceneview", from: "3.3.0")
+.package(url: "https://github.com/sceneview/sceneview", from: "3.3.0")
 \`\`\`
 
 ### 2. Info.plist — Camera Permission (Required)

package/dist/samples.js

@@ -1038,8 +1038,8 @@ fun NodeHierarchyScreen() {
         title: "iOS 3D Model Viewer",
         description: "SwiftUI 3D scene with a USDZ model, IBL environment, orbit camera, and animation playback.",
         tags: ["3d", "model", "environment", "camera", "animation", "ios", "swift"],
-        dependency: "https://github.com/SceneView/sceneview — from: \"3.3.0\"",
-        spmDependency: "https://github.com/SceneView/sceneview",
+        dependency: "https://github.com/sceneview/sceneview — from: \"3.3.0\"",
+        spmDependency: "https://github.com/sceneview/sceneview",
         prompt: "Create a SwiftUI screen that loads a USDZ model and displays it with IBL lighting, orbit camera, and animation playback. Use SceneViewSwift.",
         language: "swift",
         code: `import SwiftUI
@@ -1077,8 +1077,8 @@ struct ModelViewerScreen: View {
         title: "iOS AR Tap-to-Place Model Viewer",
         description: "AR scene with plane detection. Tap a surface to place a 3D model using ARKit + RealityKit.",
         tags: ["ar", "model", "anchor", "plane-detection", "placement", "ios", "swift"],
-        dependency: "https://github.com/SceneView/sceneview — from: \"3.3.0\"",
-        spmDependency: "https://github.com/SceneView/sceneview",
+        dependency: "https://github.com/sceneview/sceneview — from: \"3.3.0\"",
+        spmDependency: "https://github.com/sceneview/sceneview",
         prompt: "Create an iOS AR screen that detects surfaces and lets the user tap to place a USDZ model. Use SceneViewSwift.",
         language: "swift",
         code: `import SwiftUI
@@ -1117,8 +1117,8 @@ struct ARModelViewerScreen: View {
         title: "iOS AR Augmented Image",
         description: "Detects reference images in the camera feed and overlays 3D content above them using ARKit.",
         tags: ["ar", "model", "image-tracking", "ios", "swift"],
-        dependency: "https://github.com/SceneView/sceneview — from: \"3.3.0\"",
-        spmDependency: "https://github.com/SceneView/sceneview",
+        dependency: "https://github.com/sceneview/sceneview — from: \"3.3.0\"",
+        spmDependency: "https://github.com/sceneview/sceneview",
         prompt: "Create an iOS AR screen that detects a printed reference image and places a 3D model above it. Use SceneViewSwift.",
         language: "swift",
         code: `import SwiftUI
@@ -1155,8 +1155,8 @@ struct AugmentedImageScreen: View {
         title: "iOS Procedural Geometry",
         description: "Procedural geometry shapes — cube, sphere, cylinder, cone, and plane — with PBR materials.",
         tags: ["3d", "geometry", "ios", "swift"],
-        dependency: "https://github.com/SceneView/sceneview — from: \"3.3.0\"",
-        spmDependency: "https://github.com/SceneView/sceneview",
+        dependency: "https://github.com/sceneview/sceneview — from: \"3.3.0\"",
+        spmDependency: "https://github.com/sceneview/sceneview",
         prompt: "Create a SwiftUI scene showing procedural geometry shapes (cube, sphere, cylinder, cone, plane) with different materials. Use SceneViewSwift.",
         language: "swift",
         code: `import SwiftUI
@@ -1209,8 +1209,8 @@ struct GeometryShapesScreen: View {
         title: "iOS Lighting",
         description: "Directional, point, and spot lights with configurable intensity, color, and shadows.",
         tags: ["3d", "lighting", "environment", "ios", "swift"],
-        dependency: "https://github.com/SceneView/sceneview — from: \"3.3.0\"",
-        spmDependency: "https://github.com/SceneView/sceneview",
+        dependency: "https://github.com/sceneview/sceneview — from: \"3.3.0\"",
+        spmDependency: "https://github.com/sceneview/sceneview",
         prompt: "Create a SwiftUI 3D scene with directional, point, and spot lights illuminating geometry. Use SceneViewSwift.",
         language: "swift",
         code: `import SwiftUI
@@ -1273,8 +1273,8 @@ struct LightingScreen: View {
         title: "iOS Physics Demo",
         description: "Interactive physics simulation with bouncing spheres, gravity, and configurable restitution.",
         tags: ["3d", "physics", "geometry", "ios", "swift"],
-        dependency: "https://github.com/SceneView/sceneview — from: \"3.3.0\"",
-        spmDependency: "https://github.com/SceneView/sceneview",
+        dependency: "https://github.com/sceneview/sceneview — from: \"3.3.0\"",
+        spmDependency: "https://github.com/sceneview/sceneview",
         prompt: "Create a SwiftUI 3D scene where tapping spawns coloured spheres that fall under gravity and bounce off a floor. Use SceneViewSwift.",
         language: "swift",
         code: `import SwiftUI
@@ -1337,8 +1337,8 @@ struct PhysicsDemoScreen: View {
         title: "iOS 3D Text Labels",
         description: "Camera-facing 3D text labels using TextNode and BillboardNode for always-facing-camera behavior.",
         tags: ["3d", "text", "geometry", "ios", "swift"],
-        dependency: "https://github.com/SceneView/sceneview — from: \"3.3.0\"",
-        spmDependency: "https://github.com/SceneView/sceneview",
+        dependency: "https://github.com/sceneview/sceneview — from: \"3.3.0\"",
+        spmDependency: "https://github.com/sceneview/sceneview",
         prompt: "Create a SwiftUI 3D scene with floating text labels that always face the camera, showing planet names. Use SceneViewSwift.",
         language: "swift",
         code: `import SwiftUI
@@ -1385,8 +1385,8 @@ struct TextLabelsScreen: View {
         title: "iOS Video on 3D Surface",
         description: "Video playback on a 3D plane using VideoNode with play/pause controls.",
         tags: ["3d", "video", "ios", "swift"],
-        dependency: "https://github.com/SceneView/sceneview — from: \"3.3.0\"",
-        spmDependency: "https://github.com/SceneView/sceneview",
+        dependency: "https://github.com/sceneview/sceneview — from: \"3.3.0\"",
+        spmDependency: "https://github.com/sceneview/sceneview",
         prompt: "Create a SwiftUI 3D scene with a video playing on a floating 3D plane. Include play/pause controls. Use SceneViewSwift.",
         language: "swift",
         code: `import SwiftUI

package/llms.txt

@@ -3,11 +3,11 @@
 SceneView is a declarative 3D and AR SDK for Android (Jetpack Compose, Filament, ARCore) and Apple platforms — iOS, macOS, visionOS (SwiftUI, RealityKit, ARKit) — with shared core logic via Kotlin Multiplatform. Each platform uses its native renderer: Filament on Android, RealityKit on Apple.
 
 **Android — Maven artifacts (version 3.3.0):**
-- 3D only: `io.github.sceneview:sceneview:3.3.0`
-- AR + 3D: `io.github.sceneview:arsceneview:3.3.0`
+- 3D only: `io.github.sceneview:sceneview:3.4.7`
+- AR + 3D: `io.github.sceneview:arsceneview:3.4.7`
 
 **Apple (iOS 17+ / macOS 14+ / visionOS 1+) — Swift Package:**
-- `https://github.com/sceneview/sceneview-swift.git` (from: "3.3.0")
+- `https://github.com/sceneview/sceneview-swift.git` (from: "3.4.7")
 
 **Min SDK:** 24 | **Target SDK:** 36 | **Kotlin:** 2.3.10 | **Compose BOM compatible**
 
@@ -18,8 +18,8 @@ SceneView is a declarative 3D and AR SDK for Android (Jetpack Compose, Filament,
 ### build.gradle (app module)
 ```kotlin
 dependencies {
-    implementation("io.github.sceneview:sceneview:3.3.0")   // 3D only
-    implementation("io.github.sceneview:arsceneview:3.3.0") // AR (includes sceneview)
+    implementation("io.github.sceneview:sceneview:3.4.7")   // 3D only
+    implementation("io.github.sceneview:arsceneview:3.4.7") // AR (includes sceneview)
 }
 ```
 
@@ -853,9 +853,9 @@ fun ARImageTracking(coverBitmap: Bitmap) {
 
 ## AI Integration
 
-MCP server: `@sceneview/mcp`. Add to `.claude/mcp.json`:
+MCP server: `sceneview-mcp`. Add to `.claude/mcp.json`:
 ```json
-{ "mcpServers": { "sceneview": { "command": "npx", "args": ["-y", "@sceneview/mcp"] } } }
+{ "mcpServers": { "sceneview": { "command": "npx", "args": ["-y", "sceneview-mcp"] } } }
 ```
 
 ## Why SceneView
@@ -1176,7 +1176,7 @@ React Native (Turbo Module / Fabric), KMP Compose iOS (UIKitView).
 ```swift
 // Package.swift
 dependencies: [
-    .package(url: "https://github.com/sceneview/sceneview-swift.git", from: "3.3.0")
+    .package(url: "https://github.com/sceneview/sceneview-swift.git", from: "3.4.7")
 ]
 ```
 
@@ -2359,7 +2359,7 @@ model.enableManipulation()  // look + grab + drag + rotate + scale via system ge
 
 ## MCP Server Tools
 
-The `@sceneview/mcp` server (npm: `sceneview-mcp`) exposes 18 tools and 2 resources for AI assistants.
+The `sceneview-mcp` server exposes 18 tools and 2 resources for AI assistants.
 
 ### Setup tools
 | Tool | Parameters | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sceneview-mcp",
-  "version": "3.4.14",
+  "version": "3.5.0",
   "mcpName": "io.github.sceneview/mcp",
   "description": "MCP server for SceneView — cross-platform 3D & AR SDK for Android and iOS. Give Claude the full SceneView SDK so it writes correct, compilable code.",
   "keywords": [
@@ -50,6 +50,7 @@
     "dist/migrate-code.js",
     "dist/debug-issue.js",
     "dist/generate-scene.js",
+    "dist/advanced-guides.js",
     "llms.txt"
   ],
   "engines": {
@@ -63,7 +64,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0"
+    "@modelcontextprotocol/sdk": "^1.28.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -73,5 +74,15 @@
   },
   "overrides": {
     "picomatch": ">=4.0.4"
-  }
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/sceneview"
+    },
+    {
+      "type": "polar",
+      "url": "https://polar.sh/sceneview"
+    }
+  ]
 }