sceneview-mcp 3.0.1 → 3.0.2

package/dist/samples.js

@@ -3,6 +3,7 @@ export const SAMPLES = {
         id: "model-viewer",
         title: "3D Model Viewer",
         description: "Full-screen 3D scene with a GLB model, HDR environment, and orbit camera",
+        tags: ["3d", "model", "environment", "camera"],
         dependency: "io.github.sceneview:sceneview:3.0.0",
         prompt: "Create an Android Compose screen called `ModelViewerScreen` that loads a GLB file from assets/models/my_model.glb and displays it in a full-screen 3D scene with an orbit camera (drag to rotate, pinch to zoom). Add an HDR environment from assets/environments/sky_2k.hdr for realistic lighting. Use SceneView `io.github.sceneview:sceneview:3.0.0`.",
         code: `@Composable
@@ -36,6 +37,7 @@ fun ModelViewerScreen() {
         id: "geometry-scene",
         title: "3D Geometry Scene",
         description: "Procedural 3D scene using primitive geometry nodes (cube, sphere, plane) — no GLB required",
+        tags: ["3d", "geometry", "animation"],
         dependency: "io.github.sceneview:sceneview:3.0.0",
         prompt: "Create an Android Compose screen called `GeometrySceneScreen` that renders a full-screen 3D scene with a red rotating cube, a metallic blue sphere, and a green floor plane. No model files — use SceneView built-in geometry nodes. Orbit camera. Use SceneView `io.github.sceneview:sceneview:3.0.0`.",
         code: `@Composable
@@ -91,6 +93,7 @@ fun GeometrySceneScreen() {
         id: "ar-tap-to-place",
         title: "AR Tap-to-Place",
         description: "AR scene where each tap places a GLB model on a detected surface. Placed models are pinch-to-scale and drag-to-rotate.",
+        tags: ["ar", "model", "anchor", "plane-detection", "placement", "gestures"],
         dependency: "io.github.sceneview:arsceneview:3.0.0",
         prompt: "Create an Android Compose screen called `TapToPlaceScreen` that opens the camera in AR mode. Show a plane detection grid. When the user taps a detected surface, place a 3D GLB model from assets/models/chair.glb at that point. The user should be able to pinch-to-scale and drag-to-rotate after placing. Multiple taps = multiple objects. Use SceneView `io.github.sceneview:arsceneview:3.0.0`.",
         code: `@Composable
@@ -134,6 +137,7 @@ fun TapToPlaceScreen() {
         id: "ar-placement-cursor",
         title: "AR Placement Cursor",
         description: "AR scene with a reticle that follows the surface at screen center. Tap to confirm placement.",
+        tags: ["ar", "model", "anchor", "plane-detection", "placement", "camera"],
         dependency: "io.github.sceneview:arsceneview:3.0.0",
         prompt: "Create an Android Compose AR screen called `ARCursorScreen`. Show a small reticle that snaps to the nearest detected surface at the center of the screen as the user moves the camera. When the user taps, place a GLB model from assets/models/object.glb at that position and hide the reticle. Use SceneView `io.github.sceneview:arsceneview:3.0.0`.",
         code: `@Composable
@@ -180,6 +184,7 @@ fun ARCursorScreen() {
         id: "ar-augmented-image",
         title: "AR Augmented Image",
         description: "Detects a reference image in the camera feed and overlays a 3D model above it.",
+        tags: ["ar", "model", "anchor", "image-tracking"],
         dependency: "io.github.sceneview:arsceneview:3.0.0",
         prompt: "Create an Android Compose AR screen called `AugmentedImageScreen` that detects a printed reference image (from R.drawable.target_image, physical width 15 cm) and places a 3D GLB model from assets/models/overlay.glb above it, scaled to match the image width. The model should disappear when the image is lost. Use SceneView `io.github.sceneview:arsceneview:3.0.0`.",
         code: `@Composable
@@ -222,6 +227,7 @@ fun AugmentedImageScreen() {
         id: "ar-face-filter",
         title: "AR Face Filter",
         description: "Front-camera AR that detects faces and renders a 3D mesh material over them.",
+        tags: ["ar", "face-tracking", "camera"],
         dependency: "io.github.sceneview:arsceneview:3.0.0",
         prompt: "Create an Android Compose AR screen called `FaceFilterScreen` using the front camera. Detect all visible faces and apply a custom material from assets/materials/face_mask.filamat to the face mesh. Use SceneView `io.github.sceneview:arsceneview:3.0.0` with `Session.Feature.FRONT_CAMERA` and `AugmentedFaceMode.MESH3D`.",
         code: `@Composable

package/dist/samples.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import { SAMPLES, SAMPLE_IDS, getSample } from "./samples.js";
+describe("SAMPLE_IDS", () => {
+    it("contains all 6 expected scenarios", () => {
+        expect(SAMPLE_IDS).toContain("model-viewer");
+        expect(SAMPLE_IDS).toContain("geometry-scene");
+        expect(SAMPLE_IDS).toContain("ar-tap-to-place");
+        expect(SAMPLE_IDS).toContain("ar-placement-cursor");
+        expect(SAMPLE_IDS).toContain("ar-augmented-image");
+        expect(SAMPLE_IDS).toContain("ar-face-filter");
+    });
+    it("SAMPLE_IDS matches keys of SAMPLES", () => {
+        expect(SAMPLE_IDS.sort()).toEqual(Object.keys(SAMPLES).sort());
+    });
+});
+describe("every sample", () => {
+    for (const id of SAMPLE_IDS) {
+        const sample = SAMPLES[id];
+        it(`${id}: has all required fields`, () => {
+            expect(sample.id).toBe(id);
+            expect(sample.title).toBeTruthy();
+            expect(sample.description).toBeTruthy();
+            expect(sample.tags.length).toBeGreaterThan(0);
+            expect(sample.dependency).toMatch(/^io\.github\.sceneview:/);
+            expect(sample.prompt).toBeTruthy();
+            expect(sample.code).toBeTruthy();
+        });
+        it(`${id}: code is non-empty Kotlin`, () => {
+            expect(sample.code).toContain("@Composable");
+            expect(sample.code).toContain("fun ");
+        });
+        it(`${id}: dependency is a valid sceneview artifact`, () => {
+            expect(["io.github.sceneview:sceneview:3.0.0", "io.github.sceneview:arsceneview:3.0.0"]).toContain(sample.dependency);
+        });
+    }
+});
+describe("AR samples", () => {
+    const arIds = SAMPLE_IDS.filter((id) => SAMPLES[id].tags.includes("ar"));
+    it("all AR samples use arsceneview dependency", () => {
+        for (const id of arIds) {
+            expect(SAMPLES[id].dependency).toBe("io.github.sceneview:arsceneview:3.0.0");
+        }
+    });
+    it("all AR samples contain ARScene in code", () => {
+        for (const id of arIds) {
+            expect(SAMPLES[id].code).toContain("ARScene");
+        }
+    });
+    it("all AR samples have the 'ar' tag", () => {
+        for (const id of arIds) {
+            expect(SAMPLES[id].tags).toContain("ar");
+        }
+    });
+});
+describe("3D samples", () => {
+    const d3Ids = SAMPLE_IDS.filter((id) => SAMPLES[id].tags.includes("3d"));
+    it("all 3D samples use sceneview dependency", () => {
+        for (const id of d3Ids) {
+            expect(SAMPLES[id].dependency).toBe("io.github.sceneview:sceneview:3.0.0");
+        }
+    });
+    it("all 3D samples contain Scene in code", () => {
+        for (const id of d3Ids) {
+            expect(SAMPLES[id].code).toContain("Scene(");
+        }
+    });
+});
+describe("getSample", () => {
+    it("returns the correct sample by ID", () => {
+        const s = getSample("model-viewer");
+        expect(s).toBeDefined();
+        expect(s.id).toBe("model-viewer");
+        expect(s.title).toBe("3D Model Viewer");
+    });
+    it("returns undefined for an unknown ID", () => {
+        expect(getSample("nonexistent-scenario")).toBeUndefined();
+    });
+    it("returns all samples without undefined", () => {
+        for (const id of SAMPLE_IDS) {
+            expect(getSample(id)).toBeDefined();
+        }
+    });
+});
+describe("tag filtering (simulating list_samples tool)", () => {
+    const filterByTag = (tag) => Object.values(SAMPLES).filter((s) => s.tags.includes(tag));
+    it("tag 'ar' returns only AR samples", () => {
+        const results = filterByTag("ar");
+        expect(results.length).toBeGreaterThan(0);
+        results.forEach((s) => expect(s.tags).toContain("ar"));
+    });
+    it("tag '3d' returns only 3D samples", () => {
+        const results = filterByTag("3d");
+        expect(results.length).toBeGreaterThan(0);
+        results.forEach((s) => expect(s.tags).toContain("3d"));
+    });
+    it("tag 'face-tracking' returns only the face filter sample", () => {
+        const results = filterByTag("face-tracking");
+        expect(results).toHaveLength(1);
+        expect(results[0].id).toBe("ar-face-filter");
+    });
+    it("tag 'image-tracking' returns only augmented image sample", () => {
+        const results = filterByTag("image-tracking");
+        expect(results).toHaveLength(1);
+        expect(results[0].id).toBe("ar-augmented-image");
+    });
+    it("tag 'geometry' returns only geometry scene", () => {
+        const results = filterByTag("geometry");
+        expect(results).toHaveLength(1);
+        expect(results[0].id).toBe("geometry-scene");
+    });
+    it("tag 'anchor' returns AR samples that use anchors", () => {
+        const results = filterByTag("anchor");
+        expect(results.length).toBeGreaterThan(0);
+        results.forEach((s) => expect(s.tags).toContain("anchor"));
+    });
+    it("unknown tag returns empty array", () => {
+        expect(filterByTag("nonexistent-tag")).toHaveLength(0);
+    });
+});

package/dist/validator.js

@@ -0,0 +1,251 @@
+function findLines(lines, pattern) {
+    return lines
+        .map((l, i) => (pattern.test(l) ? i + 1 : -1))
+        .filter((n) => n !== -1);
+}
+const RULES = [
+    // ─── Threading ────────────────────────────────────────────────────────────
+    {
+        id: "threading/filament-off-main-thread",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            if (!/Dispatchers\.(IO|Default)/.test(code))
+                return issues;
+            const filamentCallPatterns = [
+                [/modelLoader\.createModel/, "modelLoader.createModel*"],
+                [/modelLoader\.loadModel/, "modelLoader.loadModel*"],
+                [/materialLoader\./, "materialLoader.*"],
+                [/Texture\.Builder/, "Texture.Builder"],
+                [/engine\.createTexture/, "engine.createTexture"],
+            ];
+            for (const [pat, name] of filamentCallPatterns) {
+                if (pat.test(code)) {
+                    findLines(lines, pat).forEach((line) => issues.push({
+                        severity: "error",
+                        rule: "threading/filament-off-main-thread",
+                        message: `\`${name}\` detected alongside a background dispatcher. Filament JNI calls must run on the **main thread**. Use \`rememberModelInstance\` in composables, or wrap imperative code in \`withContext(Dispatchers.Main)\`.`,
+                        line,
+                    }));
+                }
+            }
+            return issues;
+        },
+    },
+    // ─── AR: plain Node worldPosition instead of AnchorNode ──────────────────
+    {
+        id: "ar/node-not-anchor",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            if (!code.includes("ARScene") && !code.includes("AnchorNode"))
+                return issues;
+            if (/\.worldPosition\s*=/.test(code)) {
+                findLines(lines, /\.worldPosition\s*=/).forEach((line) => issues.push({
+                    severity: "warning",
+                    rule: "ar/node-not-anchor",
+                    message: "Manually setting `worldPosition` inside an AR scene causes drift — ARCore remaps coordinates during tracking and plain nodes don't compensate. Use `AnchorNode(anchor = hitResult.createAnchor())` instead.",
+                    line,
+                }));
+            }
+            return issues;
+        },
+    },
+    // ─── Missing null-check on rememberModelInstance ──────────────────────────
+    {
+        id: "composable/model-instance-null-check",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            const assignMatch = code.match(/val\s+(\w+)\s*=\s*rememberModelInstance\(/);
+            if (!assignMatch)
+                return issues;
+            const varName = assignMatch[1];
+            // Flag ModelNode uses where the variable is passed without null-guard (no ?. !! or ?: )
+            const unsafeUse = new RegExp(`ModelNode\\s*\\([^)]*modelInstance\\s*=\\s*${varName}(?![?!])`);
+            if (unsafeUse.test(code)) {
+                findLines(lines, new RegExp(`modelInstance\\s*=\\s*${varName}(?![?!])`)).forEach((line) => issues.push({
+                    severity: "error",
+                    rule: "composable/model-instance-null-check",
+                    message: `\`${varName}\` from \`rememberModelInstance\` is \`null\` while the asset loads. Guard it: \`${varName}?.let { ModelNode(modelInstance = it, ...) }\`.`,
+                    line,
+                }));
+            }
+            return issues;
+        },
+    },
+    // ─── LightNode trailing lambda instead of named `apply =` ────────────────
+    {
+        id: "api/light-node-trailing-lambda",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            // Matches: LightNode(...) { — trailing lambda, not apply = { inside parens
+            if (/LightNode\s*\([^)]*\)\s*\{/.test(code)) {
+                findLines(lines, /LightNode\s*\([^)]*\)\s*\{/).forEach((line) => issues.push({
+                    severity: "error",
+                    rule: "api/light-node-trailing-lambda",
+                    message: "`LightNode`'s configuration block is a **named parameter** `apply`, not a trailing lambda. Write `LightNode(engine = engine, type = ..., apply = { intensity(100_000f) })`. Without `apply =` the block is silently ignored and your light has default (zero) settings.",
+                    line,
+                }));
+            }
+            return issues;
+        },
+    },
+    // ─── Engine created manually in composable ────────────────────────────────
+    {
+        id: "lifecycle/manual-engine-create",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            findLines(lines, /Engine\.create\(/).forEach((line) => issues.push({
+                severity: "error",
+                rule: "lifecycle/manual-engine-create",
+                message: "`Engine.create()` called directly. In composables use `rememberEngine()` — it ties the Engine to the composition lifecycle and destroys it automatically on disposal, preventing leaks and double-destroy SIGABRTs.",
+                line,
+            }));
+            return issues;
+        },
+    },
+    // ─── Manual engine.destroy() alongside rememberEngine ────────────────────
+    {
+        id: "lifecycle/manual-engine-destroy",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            if (!code.includes("rememberEngine"))
+                return issues;
+            findLines(lines, /engine\.(safeD|d)estroy\(\)/).forEach((line) => issues.push({
+                severity: "warning",
+                rule: "lifecycle/manual-engine-destroy",
+                message: "`engine.destroy()` called manually alongside `rememberEngine()`. The engine is already destroyed on composition disposal — calling it again triggers a SIGABRT. Remove the manual call.",
+                line,
+            }));
+            return issues;
+        },
+    },
+    // ─── Texture destroy order (issue #630) ──────────────────────────────────
+    {
+        id: "lifecycle/texture-destroy-order",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            const texIdx = code.indexOf("safeDestroyTexture");
+            const matIdx = code.indexOf("destroyMaterialInstance");
+            if (texIdx !== -1 && matIdx !== -1 && texIdx < matIdx) {
+                findLines(lines, /safeDestroyTexture|engine\.destroyTexture/).forEach((line) => issues.push({
+                    severity: "error",
+                    rule: "lifecycle/texture-destroy-order",
+                    message: "Texture destroyed **before** the MaterialInstance that references it → SIGABRT (\"Invalid texture still bound to MaterialInstance\"). Destroy the MaterialInstance first: `materialLoader.destroyMaterialInstance(instance)`, then `engine.safeDestroyTexture(texture)`.",
+                    line,
+                }));
+            }
+            return issues;
+        },
+    },
+    // ─── createModelInstance in composable (should be rememberModelInstance) ──
+    {
+        id: "composable/prefer-remember-model-instance",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            findLines(lines, /modelLoader\.createModelInstance\(/).forEach((line) => issues.push({
+                severity: "warning",
+                rule: "composable/prefer-remember-model-instance",
+                message: "`modelLoader.createModelInstance()` blocks the main thread. In composables, use `rememberModelInstance(modelLoader, path)` — it loads asynchronously, returns `null` while loading, and recomposes when ready.",
+                line,
+            }));
+            return issues;
+        },
+    },
+    // ─── Empty AnchorNode() ────────────────────────────────────────────────────
+    {
+        id: "ar/anchor-node-missing-anchor",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            findLines(lines, /AnchorNode\s*\(\s*\)/).forEach((line) => issues.push({
+                severity: "error",
+                rule: "ar/anchor-node-missing-anchor",
+                message: "`AnchorNode()` requires an `anchor` from a hit result. Use `AnchorNode(anchor = hitResult.createAnchor())` inside `onTouchEvent` or `onSessionUpdated`.",
+                line,
+            }));
+            return issues;
+        },
+    },
+    // ─── 2.x → 3.0 renamed/removed APIs ─────────────────────────────────────
+    {
+        id: "migration/old-api",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            const renames = [
+                [/\bSceneView\s*\(/, "`SceneView(…)` → renamed to `Scene(…)` in 3.0"],
+                [/\bArSceneView\s*\(/, "`ArSceneView(…)` → renamed to `ARScene(…)` in 3.0"],
+                [/\bPlacementNode\b/, "`PlacementNode` removed → use `AnchorNode` + `HitResultNode` in 3.0"],
+                [/\bTransformableNode\b/, "`TransformableNode` removed → set `isEditable = true` on `ModelNode` in 3.0"],
+                [/\bViewRenderable\b/, "`ViewRenderable` removed → use `ViewNode` with a `@Composable` content lambda in 3.0"],
+                [/\bmodelLoader\.loadModelAsync\b/, "`loadModelAsync` removed → use `rememberModelInstance` in composables (3.0)"],
+                [/\bmodelLoader\.loadModel\b(?!Instance)/, "`loadModel` → use `rememberModelInstance` or `loadModelInstanceAsync` (3.0)"],
+            ];
+            for (const [pat, msg] of renames) {
+                if (pat.test(code)) {
+                    findLines(lines, pat).forEach((line) => issues.push({ severity: "error", rule: "migration/old-api", message: msg, line }));
+                }
+            }
+            return issues;
+        },
+    },
+    // ─── Scene missing engine param ───────────────────────────────────────────
+    {
+        id: "api/scene-missing-engine",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            // Scene( or ARScene( without engine = somewhere nearby
+            const sceneCallLines = findLines(lines, /\b(AR)?Scene\s*\(/);
+            sceneCallLines.forEach((line) => {
+                // Look at the next 10 lines for engine =
+                const block = lines.slice(line - 1, line + 10).join("\n");
+                if (!block.includes("engine")) {
+                    issues.push({
+                        severity: "error",
+                        rule: "api/scene-missing-engine",
+                        message: "`Scene` / `ARScene` requires an `engine` parameter. Create one with `val engine = rememberEngine()` and pass it: `Scene(engine = engine, …)`.",
+                        line,
+                    });
+                }
+            });
+            return issues;
+        },
+    },
+];
+export function validateCode(kotlinCode) {
+    const lines = kotlinCode.split("\n");
+    return RULES.flatMap((rule) => rule.check(kotlinCode, lines));
+}
+export function formatValidationReport(issues) {
+    if (issues.length === 0) {
+        return "✅ No issues found. The snippet follows SceneView best practices.";
+    }
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    const infos = issues.filter((i) => i.severity === "info");
+    const icon = {
+        error: "🔴",
+        warning: "🟡",
+        info: "🔵",
+    };
+    const header = `Found **${issues.length} issue(s)**: ${errors.length} error(s), ${warnings.length} warning(s), ${infos.length} info(s).\n`;
+    const body = issues
+        .map((issue, i) => {
+        const loc = issue.line ? ` (line ${issue.line})` : "";
+        return [
+            `### ${i + 1}. ${icon[issue.severity]} ${issue.severity.toUpperCase()}${loc}`,
+            `**Rule:** \`${issue.rule}\``,
+            issue.message,
+        ].join("\n");
+    })
+        .join("\n\n");
+    return header + "\n" + body;
+}

package/dist/validator.test.js

@@ -0,0 +1,246 @@
+import { describe, it, expect } from "vitest";
+import { validateCode, formatValidationReport } from "./validator.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function ruleIds(code) {
+    return validateCode(code).map((i) => i.rule);
+}
+function hasRule(code, rule) {
+    return ruleIds(code).includes(rule);
+}
+// ─── threading/filament-off-main-thread ──────────────────────────────────────
+describe("threading/filament-off-main-thread", () => {
+    const RULE = "threading/filament-off-main-thread";
+    it("fires when modelLoader.createModel* used near Dispatchers.IO", () => {
+        const code = `
+      withContext(Dispatchers.IO) {
+        val model = modelLoader.createModelInstance("models/chair.glb")
+      }
+    `;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("fires when Texture.Builder used near Dispatchers.Default", () => {
+        const code = `
+      launch(Dispatchers.Default) {
+        val texture = Texture.Builder().width(4).build(engine)
+      }
+    `;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire without a background dispatcher", () => {
+        const code = `val model = modelLoader.createModelInstance("models/chair.glb")`;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+    it("does NOT fire when Dispatchers.Main is used", () => {
+        const code = `
+      withContext(Dispatchers.Main) {
+        val model = modelLoader.createModelInstance("models/chair.glb")
+      }
+    `;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── ar/node-not-anchor ───────────────────────────────────────────────────────
+describe("ar/node-not-anchor", () => {
+    const RULE = "ar/node-not-anchor";
+    it("fires when worldPosition is set inside an ARScene", () => {
+        const code = `
+      ARScene(engine = engine) {
+        node.worldPosition = Position(0f, 0f, -1f)
+      }
+    `;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire for worldPosition outside ARScene", () => {
+        const code = `node.worldPosition = Position(0f, 0f, -1f)`;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+    it("does NOT fire when AnchorNode is used correctly", () => {
+        const code = `
+      ARScene(engine = engine) {
+        AnchorNode(anchor = hitResult.createAnchor()) { }
+      }
+    `;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── composable/model-instance-null-check ────────────────────────────────────
+describe("composable/model-instance-null-check", () => {
+    const RULE = "composable/model-instance-null-check";
+    it("fires when rememberModelInstance result used without null guard", () => {
+        const code = `
+      val instance = rememberModelInstance(modelLoader, "models/chair.glb")
+      ModelNode(modelInstance = instance, scaleToUnits = 1f)
+    `;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire when guarded with ?.", () => {
+        const code = `
+      val instance = rememberModelInstance(modelLoader, "models/chair.glb")
+      instance?.let { ModelNode(modelInstance = it) }
+    `;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+    it("does NOT fire when guarded with !!", () => {
+        const code = `
+      val instance = rememberModelInstance(modelLoader, "models/chair.glb")
+      ModelNode(modelInstance = instance!!, scaleToUnits = 1f)
+    `;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+    it("does NOT fire when rememberModelInstance is not assigned to a var", () => {
+        const code = `ModelNode(modelInstance = someOtherInstance, scaleToUnits = 1f)`;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── api/light-node-trailing-lambda ──────────────────────────────────────────
+describe("api/light-node-trailing-lambda", () => {
+    const RULE = "api/light-node-trailing-lambda";
+    it("fires on trailing lambda syntax", () => {
+        const code = `LightNode(engine = engine, type = LightManager.Type.SUN) { intensity(100_000f) }`;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire when apply = { } is used correctly", () => {
+        const code = `LightNode(engine = engine, type = LightManager.Type.SUN, apply = { intensity(100_000f) })`;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── lifecycle/manual-engine-create ──────────────────────────────────────────
+describe("lifecycle/manual-engine-create", () => {
+    const RULE = "lifecycle/manual-engine-create";
+    it("fires on Engine.create()", () => {
+        const code = `val engine = Engine.create(eglContext)`;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire when rememberEngine() is used", () => {
+        const code = `val engine = rememberEngine()`;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── lifecycle/manual-engine-destroy ─────────────────────────────────────────
+describe("lifecycle/manual-engine-destroy", () => {
+    const RULE = "lifecycle/manual-engine-destroy";
+    it("fires when engine.destroy() called alongside rememberEngine", () => {
+        const code = `
+      val engine = rememberEngine()
+      DisposableEffect(Unit) { onDispose { engine.destroy() } }
+    `;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire when rememberEngine is absent (imperative code)", () => {
+        const code = `engine.destroy()`;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── lifecycle/texture-destroy-order ─────────────────────────────────────────
+describe("lifecycle/texture-destroy-order", () => {
+    const RULE = "lifecycle/texture-destroy-order";
+    it("fires when texture is destroyed before material instance", () => {
+        const code = `
+      engine.safeDestroyTexture(texture)
+      materialLoader.destroyMaterialInstance(instance)
+    `;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire when material instance destroyed first", () => {
+        const code = `
+      materialLoader.destroyMaterialInstance(instance)
+      engine.safeDestroyTexture(texture)
+    `;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+    it("does NOT fire when only one of the two is present", () => {
+        expect(hasRule(`engine.safeDestroyTexture(texture)`, RULE)).toBe(false);
+        expect(hasRule(`materialLoader.destroyMaterialInstance(instance)`, RULE)).toBe(false);
+    });
+});
+// ─── composable/prefer-remember-model-instance ────────────────────────────────
+describe("composable/prefer-remember-model-instance", () => {
+    const RULE = "composable/prefer-remember-model-instance";
+    it("fires when createModelInstance is used directly", () => {
+        const code = `val m = modelLoader.createModelInstance("models/chair.glb")`;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire for rememberModelInstance", () => {
+        const code = `val m = rememberModelInstance(modelLoader, "models/chair.glb")`;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── ar/anchor-node-missing-anchor ───────────────────────────────────────────
+describe("ar/anchor-node-missing-anchor", () => {
+    const RULE = "ar/anchor-node-missing-anchor";
+    it("fires on empty AnchorNode()", () => {
+        const code = `val node = AnchorNode()`;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire when anchor param is provided", () => {
+        const code = `AnchorNode(anchor = hitResult.createAnchor())`;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── migration/old-api ────────────────────────────────────────────────────────
+describe("migration/old-api", () => {
+    const RULE = "migration/old-api";
+    it("fires on SceneView composable", () => {
+        expect(hasRule(`SceneView(modifier = Modifier.fillMaxSize())`, RULE)).toBe(true);
+    });
+    it("fires on ArSceneView composable", () => {
+        expect(hasRule(`ArSceneView(modifier = Modifier.fillMaxSize())`, RULE)).toBe(true);
+    });
+    it("fires on TransformableNode", () => {
+        expect(hasRule(`val node = TransformableNode(system)`, RULE)).toBe(true);
+    });
+    it("fires on PlacementNode", () => {
+        expect(hasRule(`val node = PlacementNode()`, RULE)).toBe(true);
+    });
+    it("fires on ViewRenderable", () => {
+        expect(hasRule(`ViewRenderable.builder()`, RULE)).toBe(true);
+    });
+    it("fires on loadModelAsync", () => {
+        expect(hasRule(`modelLoader.loadModelAsync("models/x.glb")`, RULE)).toBe(true);
+    });
+    it("does NOT fire on modern 3.0 APIs", () => {
+        const code = `
+      val engine = rememberEngine()
+      Scene(engine = engine) {
+        rememberModelInstance(modelLoader, "models/x.glb")?.let { ModelNode(modelInstance = it) }
+      }
+    `;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── api/scene-missing-engine ─────────────────────────────────────────────────
+describe("api/scene-missing-engine", () => {
+    const RULE = "api/scene-missing-engine";
+    it("fires when Scene() has no engine nearby", () => {
+        const code = `Scene(modifier = Modifier.fillMaxSize()) { }`;
+        expect(hasRule(code, RULE)).toBe(true);
+    });
+    it("does NOT fire when engine is provided", () => {
+        const code = `
+      val engine = rememberEngine()
+      Scene(modifier = Modifier.fillMaxSize(), engine = engine) { }
+    `;
+        expect(hasRule(code, RULE)).toBe(false);
+    });
+});
+// ─── formatValidationReport ───────────────────────────────────────────────────
+describe("formatValidationReport", () => {
+    it("returns success message when no issues", () => {
+        expect(formatValidationReport([])).toContain("No issues found");
+    });
+    it("includes severity counts in the header", () => {
+        const issues = validateCode(`
+      val instance = rememberModelInstance(modelLoader, "x.glb")
+      ModelNode(modelInstance = instance, scaleToUnits = 1f)
+      LightNode(engine = engine) { intensity(1f) }
+    `);
+        const report = formatValidationReport(issues);
+        expect(report).toMatch(/error/);
+        expect(report).toContain("🔴");
+    });
+    it("includes line numbers when available", () => {
+        const code = `\nval instance = rememberModelInstance(modelLoader, "x.glb")\nModelNode(modelInstance = instance, scaleToUnits = 1f)`;
+        const report = formatValidationReport(validateCode(code));
+        expect(report).toMatch(/line \d+/);
+    });
+});