sceneview-mcp 3.0.1 → 3.0.2

package/dist/index.js

@@ -6,6 +6,9 @@ import { readFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { getSample, SAMPLE_IDS, SAMPLES } from "./samples.js";
+import { validateCode, formatValidationReport } from "./validator.js";
+import { MIGRATION_GUIDE } from "./migration.js";
+import { fetchKnownIssues } from "./issues.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 let API_DOCS;
 try {
@@ -14,7 +17,8 @@ try {
 catch {
     API_DOCS = "SceneView API docs not found. Run `npm run prepare` to bundle llms.txt.";
 }
-const server = new Server({ name: "@sceneview/mcp", version: "3.0.1" }, { capabilities: { resources: {}, tools: {} } });
+const server = new Server({ name: "@sceneview/mcp", version: "3.0.2" }, { capabilities: { resources: {}, tools: {} } });
+// ─── Resources ───────────────────────────────────────────────────────────────
 server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
         {
@@ -23,21 +27,36 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => ({
             description: "Complete SceneView 3.0.0 API — Scene, ARScene, SceneScope DSL, ARSceneScope DSL, node types, resource loading, camera, gestures, math types, threading rules, and common patterns. Read this before writing any SceneView code.",
             mimeType: "text/markdown",
         },
+        {
+            uri: "sceneview://known-issues",
+            name: "SceneView Open GitHub Issues",
+            description: "Live list of open issues from the SceneView GitHub repository. Check this before reporting a bug or when something isn't working — there may already be a known workaround.",
+            mimeType: "text/markdown",
+        },
     ],
 }));
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    if (request.params.uri === "sceneview://api") {
-        return {
-            contents: [{ uri: "sceneview://api", mimeType: "text/markdown", text: API_DOCS }],
-        };
+    switch (request.params.uri) {
+        case "sceneview://api":
+            return {
+                contents: [{ uri: "sceneview://api", mimeType: "text/markdown", text: API_DOCS }],
+            };
+        case "sceneview://known-issues": {
+            const issues = await fetchKnownIssues();
+            return {
+                contents: [{ uri: "sceneview://known-issues", mimeType: "text/markdown", text: issues }],
+            };
+        }
+        default:
+            throw new Error(`Unknown resource: ${request.params.uri}`);
     }
-    throw new Error(`Unknown resource: ${request.params.uri}`);
 });
+// ─── Tools ───────────────────────────────────────────────────────────────────
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
             name: "get_sample",
-            description: "Returns a complete, compilable Kotlin sample for a given SceneView scenario. Use this to get a working starting point before customising.",
+            description: "Returns a complete, compilable Kotlin sample for a given SceneView scenario. Use this to get a working starting point before customising. Call `list_samples` first if you are unsure which scenario fits.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -50,6 +69,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["scenario"],
             },
         },
+        {
+            name: "list_samples",
+            description: "Lists all available SceneView code samples with their IDs, descriptions, and tags. Use this to find the right sample before calling `get_sample`, or to show the user what SceneView can do.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tag: {
+                        type: "string",
+                        description: "Optional tag to filter by (e.g. \"ar\", \"3d\", \"anchor\", \"face-tracking\", \"geometry\", \"animation\"). Omit to list all samples.",
+                    },
+                },
+                required: [],
+            },
+        },
         {
             name: "get_setup",
             description: "Returns the Gradle dependency and AndroidManifest snippet required to use SceneView in an Android project.",
@@ -65,16 +98,46 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["type"],
             },
         },
+        {
+            name: "validate_code",
+            description: "Checks a Kotlin SceneView snippet for common mistakes: threading violations, wrong destroy order, missing null-checks on rememberModelInstance, LightNode trailing-lambda bug, deprecated 2.x APIs, and more. Always call this before presenting generated SceneView code to the user.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: {
+                        type: "string",
+                        description: "The Kotlin source code to validate (composable function, class, or file).",
+                    },
+                },
+                required: ["code"],
+            },
+        },
+        {
+            name: "get_migration_guide",
+            description: "Returns the full SceneView 2.x → 3.0 migration guide. Use this when a user reports code that worked in 2.x but breaks in 3.0, or when helping someone upgrade.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                required: [],
+            },
+        },
     ],
 }));
+// ─── Tool handlers ────────────────────────────────────────────────────────────
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     switch (request.params.name) {
+        // ── get_sample ────────────────────────────────────────────────────────────
         case "get_sample": {
             const scenario = request.params.arguments?.scenario;
             const sample = getSample(scenario);
             if (!sample) {
                 return {
-                    content: [{ type: "text", text: `Unknown scenario "${scenario}". Available: ${SAMPLE_IDS.join(", ")}` }],
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown scenario "${scenario}". Call \`list_samples\` to see available options.`,
+                        },
+                    ],
                     isError: true,
                 };
             }
@@ -85,6 +148,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         text: [
                             `## ${sample.title}`,
                             ``,
+                            `**Tags:** ${sample.tags.join(", ")}`,
+                            ``,
                             `**Gradle dependency:**`,
                             `\`\`\`kotlin`,
                             `implementation("${sample.dependency}")`,
@@ -102,6 +167,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ],
             };
         }
+        // ── list_samples ──────────────────────────────────────────────────────────
+        case "list_samples": {
+            const filterTag = request.params.arguments?.tag;
+            const entries = Object.values(SAMPLES).filter((s) => !filterTag || s.tags.includes(filterTag));
+            if (entries.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No samples found with tag "${filterTag}". Available tags: 3d, ar, model, geometry, animation, camera, environment, anchor, plane-detection, image-tracking, face-tracking, placement, gestures`,
+                        },
+                    ],
+                };
+            }
+            const header = filterTag
+                ? `## SceneView samples tagged \`${filterTag}\` (${entries.length})\n`
+                : `## All SceneView samples (${entries.length})\n`;
+            const rows = entries
+                .map((s) => `### \`${s.id}\`\n**${s.title}**\n${s.description}\n*Tags:* ${s.tags.join(", ")}\n*Dependency:* \`${s.dependency}\`\n\nCall \`get_sample("${s.id}")\` for the full code.`)
+                .join("\n\n---\n\n");
+            return { content: [{ type: "text", text: header + rows }] };
+        }
+        // ── get_setup ─────────────────────────────────────────────────────────────
         case "get_setup": {
             const type = request.params.arguments?.type;
             if (type === "3d") {
@@ -158,6 +246,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 isError: true,
             };
         }
+        // ── validate_code ─────────────────────────────────────────────────────────
+        case "validate_code": {
+            const code = request.params.arguments?.code;
+            if (!code || typeof code !== "string") {
+                return {
+                    content: [{ type: "text", text: "Missing required parameter: `code`" }],
+                    isError: true,
+                };
+            }
+            const issues = validateCode(code);
+            const report = formatValidationReport(issues);
+            return { content: [{ type: "text", text: report }] };
+        }
+        // ── get_migration_guide ───────────────────────────────────────────────────
+        case "get_migration_guide": {
+            return { content: [{ type: "text", text: MIGRATION_GUIDE }] };
+        }
         default:
             return {
                 content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],

package/dist/issues.js

@@ -0,0 +1,72 @@
+// Cache for 10 minutes — avoids hammering the GitHub API on every tool call
+const CACHE_TTL_MS = 10 * 60 * 1000;
+let cache = null;
+export async function fetchKnownIssues() {
+    const now = Date.now();
+    if (cache && now - cache.fetchedAt < CACHE_TTL_MS) {
+        return cache.data;
+    }
+    let issues = [];
+    let fetchError = null;
+    try {
+        const response = await fetch("https://api.github.com/repos/SceneView/sceneview-android/issues?state=open&per_page=30", {
+            headers: {
+                Accept: "application/vnd.github+json",
+                "User-Agent": "sceneview-mcp/3.0",
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+        });
+        if (!response.ok) {
+            fetchError = `GitHub API returned ${response.status}: ${response.statusText}`;
+        }
+        else {
+            issues = (await response.json());
+        }
+    }
+    catch (err) {
+        fetchError = `Failed to fetch issues: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    const result = formatIssues(issues, fetchError);
+    cache = { data: result, fetchedAt: now };
+    return result;
+}
+function formatIssues(issues, fetchError) {
+    const lines = ["# SceneView — Open GitHub Issues\n"];
+    if (fetchError) {
+        lines.push(`> ⚠️ ${fetchError}. Showing cached data if available.\n`);
+    }
+    else {
+        lines.push(`*Fetched live from GitHub — ${issues.length} open issue(s). Cached for 10 minutes.*\n`);
+    }
+    if (issues.length === 0) {
+        lines.push("No open issues. 🎉");
+        return lines.join("\n");
+    }
+    // Group by label: bugs first, then questions/other
+    const bugs = issues.filter((i) => i.labels.some((l) => l.name === "bug"));
+    const others = issues.filter((i) => !i.labels.some((l) => l.name === "bug"));
+    const renderGroup = (title, group) => {
+        if (group.length === 0)
+            return;
+        lines.push(`## ${title}\n`);
+        for (const issue of group) {
+            const labelStr = issue.labels.length > 0 ? ` [${issue.labels.map((l) => l.name).join(", ")}]` : "";
+            lines.push(`### #${issue.number} — ${issue.title}${labelStr}`);
+            lines.push(`*Opened by @${issue.user.login} · ${issue.updated_at.slice(0, 10)}*`);
+            lines.push(issue.html_url);
+            // Include first 300 chars of body as context
+            if (issue.body) {
+                const excerpt = issue.body
+                    .replace(/\r\n/g, "\n")
+                    .replace(/```[\s\S]*?```/g, "[code block]") // strip code blocks for brevity
+                    .trim()
+                    .slice(0, 300);
+                lines.push(`\n> ${excerpt.replace(/\n/g, "\n> ")}${issue.body.length > 300 ? "…" : ""}`);
+            }
+            lines.push("");
+        }
+    };
+    renderGroup("🐛 Bug Reports", bugs);
+    renderGroup("📋 Other Issues", others);
+    return lines.join("\n");
+}

package/dist/issues.test.js

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+// We test the private formatIssues logic by calling fetchKnownIssues with a
+// mocked global fetch so we never hit the real GitHub API in tests.
+const mockIssues = [
+    {
+        number: 123,
+        title: "SIGABRT on dispose",
+        html_url: "https://github.com/SceneView/sceneview-android/issues/123",
+        body: "Calling destroy() causes a native crash.",
+        labels: [{ name: "bug" }],
+        created_at: "2026-01-01T00:00:00Z",
+        updated_at: "2026-01-15T00:00:00Z",
+        user: { login: "testuser" },
+    },
+    {
+        number: 124,
+        title: "How do I add shadows?",
+        html_url: "https://github.com/SceneView/sceneview-android/issues/124",
+        body: "I want to enable shadows for my AR scene.",
+        labels: [{ name: "question" }],
+        created_at: "2026-01-02T00:00:00Z",
+        updated_at: "2026-01-16T00:00:00Z",
+        user: { login: "anotheruser" },
+    },
+];
+beforeEach(() => {
+    // Reset module cache so the in-memory cache is cleared between tests
+    vi.resetModules();
+});
+describe("fetchKnownIssues", () => {
+    it("returns markdown with issue titles when GitHub API succeeds", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => mockIssues,
+        }));
+        const { fetchKnownIssues } = await import("./issues.js");
+        const result = await fetchKnownIssues();
+        expect(result).toContain("SIGABRT on dispose");
+        expect(result).toContain("#123");
+        expect(result).toContain("How do I add shadows?");
+        expect(result).toContain("#124");
+        vi.unstubAllGlobals();
+    });
+    it("groups bug-labelled issues under Bug Reports", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => mockIssues,
+        }));
+        const { fetchKnownIssues } = await import("./issues.js");
+        const result = await fetchKnownIssues();
+        expect(result).toContain("Bug Reports");
+        expect(result).toContain("SIGABRT on dispose");
+        vi.unstubAllGlobals();
+    });
+    it("groups non-bug issues under Other Issues", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => mockIssues,
+        }));
+        const { fetchKnownIssues } = await import("./issues.js");
+        const result = await fetchKnownIssues();
+        expect(result).toContain("Other Issues");
+        expect(result).toContain("How do I add shadows?");
+        vi.unstubAllGlobals();
+    });
+    it("includes github URLs", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => mockIssues,
+        }));
+        const { fetchKnownIssues } = await import("./issues.js");
+        const result = await fetchKnownIssues();
+        expect(result).toContain("https://github.com/SceneView/sceneview-android/issues/123");
+        vi.unstubAllGlobals();
+    });
+    it("includes body excerpt", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => mockIssues,
+        }));
+        const { fetchKnownIssues } = await import("./issues.js");
+        const result = await fetchKnownIssues();
+        expect(result).toContain("native crash");
+        vi.unstubAllGlobals();
+    });
+    it("shows warning message when GitHub API fails", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+            ok: false,
+            status: 403,
+            statusText: "Forbidden",
+        }));
+        const { fetchKnownIssues } = await import("./issues.js");
+        const result = await fetchKnownIssues();
+        expect(result).toContain("403");
+        vi.unstubAllGlobals();
+    });
+    it("shows warning message when fetch throws (network error)", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("Network error")));
+        const { fetchKnownIssues } = await import("./issues.js");
+        const result = await fetchKnownIssues();
+        expect(result).toContain("Network error");
+        vi.unstubAllGlobals();
+    });
+    it("shows celebration when there are no open issues", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => [],
+        }));
+        const { fetchKnownIssues } = await import("./issues.js");
+        const result = await fetchKnownIssues();
+        expect(result).toContain("No open issues");
+        vi.unstubAllGlobals();
+    });
+});

package/dist/migration.js

@@ -0,0 +1,248 @@
+export const MIGRATION_GUIDE = `# SceneView 2.x → 3.0 Migration Guide
+
+SceneView 3.0 is a full rewrite from Android Views to **Jetpack Compose**. Nearly every public API changed. This guide covers every breaking change and how to fix it.
+
+---
+
+## 1. Gradle dependency
+
+| 2.x | 3.0 |
+|-----|-----|
+| \`io.github.sceneview:sceneview:2.x.x\` | \`io.github.sceneview:sceneview:3.0.0\` |
+| \`io.github.sceneview:arsceneview:2.x.x\` | \`io.github.sceneview:arsceneview:3.0.0\` |
+
+---
+
+## 2. Root composable names
+
+| 2.x | 3.0 |
+|-----|-----|
+| \`SceneView(…)\` | \`Scene(…)\` |
+| \`ArSceneView(…)\` | \`ARScene(…)\` |
+
+**Before:**
+\`\`\`kotlin
+SceneView(modifier = Modifier.fillMaxSize())
+\`\`\`
+
+**After:**
+\`\`\`kotlin
+val engine = rememberEngine()
+Scene(modifier = Modifier.fillMaxSize(), engine = engine)
+\`\`\`
+
+---
+
+## 3. Engine lifecycle
+
+In 2.x the engine was managed internally. In 3.0 you own it — use \`rememberEngine()\` which ties it to the composition lifecycle.
+
+| 2.x | 3.0 |
+|-----|-----|
+| Engine implicit | \`val engine = rememberEngine()\` |
+| Never destroy manually | Never call \`engine.destroy()\` — \`rememberEngine\` does it |
+
+---
+
+## 4. Model loading
+
+| 2.x | 3.0 |
+|-----|-----|
+| \`modelLoader.loadModelAsync(path) { … }\` | \`rememberModelInstance(modelLoader, path)\` (returns \`null\` while loading) |
+| \`modelLoader.loadModel(path)\` | \`modelLoader.loadModelInstanceAsync(path)\` (imperative) |
+| \`ModelRenderable.builder()\` | Removed — use GLB/glTF assets |
+
+**Before:**
+\`\`\`kotlin
+var modelInstance by remember { mutableStateOf<ModelInstance?>(null) }
+LaunchedEffect(Unit) {
+    modelInstance = modelLoader.loadModelAsync("models/chair.glb")
+}
+\`\`\`
+
+**After:**
+\`\`\`kotlin
+Scene(engine = engine, modelLoader = modelLoader) {
+    rememberModelInstance(modelLoader, "models/chair.glb")?.let { instance ->
+        ModelNode(modelInstance = instance, scaleToUnits = 1.0f)
+    }
+}
+\`\`\`
+
+---
+
+## 5. Node hierarchy — imperative → declarative DSL
+
+In 2.x nodes were added imperatively (\`scene.addChild(node)\`). In 3.0 nodes are declared as composables inside \`Scene { }\` or \`ARScene { }\`.
+
+**Before:**
+\`\`\`kotlin
+val modelNode = ModelNode().apply {
+    loadModelGlbAsync(
+        glbFileLocation = "models/chair.glb",
+        scaleToUnits = 1f,
+    )
+}
+sceneView.addChildNode(modelNode)
+\`\`\`
+
+**After:**
+\`\`\`kotlin
+Scene(engine = engine, modelLoader = modelLoader) {
+    rememberModelInstance(modelLoader, "models/chair.glb")?.let { instance ->
+        ModelNode(modelInstance = instance, scaleToUnits = 1f)
+    }
+}
+\`\`\`
+
+---
+
+## 6. Removed nodes and replacements
+
+| 2.x | 3.0 replacement |
+|-----|-----------------|
+| \`TransformableNode\` | Set \`isEditable = true\` on \`ModelNode\` |
+| \`PlacementNode\` | \`AnchorNode(anchor = hitResult.createAnchor())\` + \`HitResultNode\` |
+| \`ViewRenderable\` | \`ViewNode\` with a \`@Composable\` content lambda |
+| \`AnchorNode()\` (no-arg) | \`AnchorNode(anchor = hitResult.createAnchor())\` |
+
+**TransformableNode:**
+\`\`\`kotlin
+// Before
+val node = TransformableNode(transformationSystem).apply {
+    setParent(anchorNode)
+}
+
+// After
+ModelNode(
+    modelInstance = instance,
+    scaleToUnits = 1f,
+    isEditable = true  // enables pinch-to-scale + drag-to-rotate
+)
+\`\`\`
+
+**ViewRenderable → ViewNode:**
+\`\`\`kotlin
+// Before
+ViewRenderable.builder()
+    .setView(context, R.layout.my_layout)
+    .build()
+    .thenAccept { renderable -> … }
+
+// After
+val windowManager = rememberViewNodeManager()
+Scene(viewNodeWindowManager = windowManager) {
+    ViewNode(windowManager = windowManager) {
+        Card { Text("Hello 3D World!") }
+    }
+}
+\`\`\`
+
+---
+
+## 7. Light configuration
+
+LightNode's \`apply\` is a **named parameter** (not a trailing lambda). This is the most common silent breakage after migrating.
+
+\`\`\`kotlin
+// WRONG — trailing lambda is silently ignored
+LightNode(engine = engine, type = LightManager.Type.DIRECTIONAL) {
+    intensity(100_000f)
+}
+
+// CORRECT
+LightNode(
+    engine = engine,
+    type = LightManager.Type.DIRECTIONAL,
+    apply = {
+        intensity(100_000f)
+        castShadows(true)
+    }
+)
+\`\`\`
+
+---
+
+## 8. Environment / IBL loading
+
+| 2.x | 3.0 |
+|-----|-----|
+| \`environmentLoader.loadEnvironment(path)\` | \`environmentLoader.createHDREnvironment(path)\` |
+
+\`\`\`kotlin
+// 3.0
+val environmentLoader = rememberEnvironmentLoader(engine)
+Scene(
+    environment = rememberEnvironment(environmentLoader) {
+        environmentLoader.createHDREnvironment("environments/sky_2k.hdr")!!
+    }
+) { … }
+\`\`\`
+
+---
+
+## 9. AR session configuration
+
+In 3.0 \`sessionConfiguration\` is a lambda parameter on \`ARScene\` (not a separate builder).
+
+\`\`\`kotlin
+ARScene(
+    engine = engine,
+    modelLoader = modelLoader,
+    sessionConfiguration = { session, config ->
+        config.depthMode =
+            if (session.isDepthModeSupported(Config.DepthMode.AUTOMATIC))
+                Config.DepthMode.AUTOMATIC else Config.DepthMode.DISABLED
+        config.instantPlacementMode = Config.InstantPlacementMode.LOCAL_Y_UP
+        config.lightEstimationMode = Config.LightEstimationMode.ENVIRONMENTAL_HDR
+    }
+) { … }
+\`\`\`
+
+---
+
+## 10. AR anchors (no more worldPosition hacks)
+
+| 2.x pattern | 3.0 |
+|-------------|-----|
+| \`node.worldPosition = hitResult.hitPose.position\` | \`AnchorNode(anchor = hitResult.createAnchor())\` |
+
+Plain nodes whose \`worldPosition\` is set manually will drift when ARCore remaps its coordinate system. \`AnchorNode\` compensates automatically.
+
+---
+
+## 11. Shadows
+
+In 3.0, \`ARScene\` has shadows enabled by default via \`createARView()\`. For \`Scene\` (3D only), shadows are disabled by default — enable with:
+
+\`\`\`kotlin
+Scene(
+    view = rememberView(engine).also { it.setShadowingEnabled(true) },
+    …
+)
+\`\`\`
+
+---
+
+## 12. Camera
+
+| 2.x | 3.0 |
+|-----|-----|
+| \`CameraManipulator\` set on the View | \`cameraManipulator = rememberCameraManipulator()\` on \`Scene\` |
+| Custom camera via \`setCameraNode\` | \`cameraNode = rememberCameraNode(engine) { … }\` on \`Scene\` |
+
+---
+
+## Checklist
+
+- [ ] Replace \`SceneView(…)\` → \`Scene(engine = rememberEngine(), …)\`
+- [ ] Replace \`ArSceneView(…)\` → \`ARScene(engine = rememberEngine(), …)\`
+- [ ] Replace \`modelLoader.loadModelAsync\` → \`rememberModelInstance\`
+- [ ] Add null-check on every \`rememberModelInstance\` result
+- [ ] Replace \`TransformableNode\` → \`isEditable = true\`
+- [ ] Replace \`PlacementNode\` → \`AnchorNode\` + \`HitResultNode\`
+- [ ] Replace \`ViewRenderable\` → \`ViewNode\` with Compose lambda
+- [ ] Fix \`LightNode { … }\` → \`LightNode(apply = { … })\`
+- [ ] Remove manual \`engine.destroy()\` calls
+- [ ] Replace manual \`worldPosition\` in AR → \`AnchorNode\`
+`;

package/dist/migration.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "vitest";
+import { MIGRATION_GUIDE } from "./migration.js";
+describe("MIGRATION_GUIDE", () => {
+    it("is a non-empty string", () => {
+        expect(typeof MIGRATION_GUIDE).toBe("string");
+        expect(MIGRATION_GUIDE.length).toBeGreaterThan(500);
+    });
+    it("covers composable renames (SceneView → Scene, ArSceneView → ARScene)", () => {
+        expect(MIGRATION_GUIDE).toContain("SceneView");
+        expect(MIGRATION_GUIDE).toContain("Scene");
+        expect(MIGRATION_GUIDE).toContain("ArSceneView");
+        expect(MIGRATION_GUIDE).toContain("ARScene");
+    });
+    it("covers model loading migration (loadModelAsync → rememberModelInstance)", () => {
+        expect(MIGRATION_GUIDE).toContain("loadModelAsync");
+        expect(MIGRATION_GUIDE).toContain("rememberModelInstance");
+    });
+    it("covers removed nodes", () => {
+        expect(MIGRATION_GUIDE).toContain("TransformableNode");
+        expect(MIGRATION_GUIDE).toContain("PlacementNode");
+        expect(MIGRATION_GUIDE).toContain("ViewRenderable");
+    });
+    it("covers LightNode named apply parameter gotcha", () => {
+        expect(MIGRATION_GUIDE).toContain("apply");
+        expect(MIGRATION_GUIDE).toContain("LightNode");
+        expect(MIGRATION_GUIDE).toContain("trailing lambda");
+    });
+    it("covers engine lifecycle (rememberEngine)", () => {
+        expect(MIGRATION_GUIDE).toContain("rememberEngine");
+        expect(MIGRATION_GUIDE).toContain("engine.destroy");
+    });
+    it("covers AR anchor drift (worldPosition → AnchorNode)", () => {
+        expect(MIGRATION_GUIDE).toContain("worldPosition");
+        expect(MIGRATION_GUIDE).toContain("AnchorNode");
+        expect(MIGRATION_GUIDE).toContain("drift");
+    });
+    it("covers gradle dependency changes", () => {
+        expect(MIGRATION_GUIDE).toContain("io.github.sceneview:sceneview:3.0.0");
+        expect(MIGRATION_GUIDE).toContain("io.github.sceneview:arsceneview:3.0.0");
+    });
+    it("includes a migration checklist", () => {
+        expect(MIGRATION_GUIDE).toContain("Checklist");
+        expect(MIGRATION_GUIDE).toContain("- [ ]");
+    });
+    it("includes before/after code examples", () => {
+        expect(MIGRATION_GUIDE).toContain("Before");
+        expect(MIGRATION_GUIDE).toContain("After");
+        expect(MIGRATION_GUIDE).toContain("```kotlin");
+    });
+});