@mihirsarya/manim-scroll-next 0.1.1

package/dist/cache.d.ts

@@ -0,0 +1,63 @@
+import type { ExtractedAnimation } from "./extractor";
+export interface CacheEntry {
+    /** The hash of the animation props */
+    hash: string;
+    /** Scene name */
+    scene: string;
+    /** Original props */
+    props: Record<string, unknown>;
+    /** Path to the manifest.json file */
+    manifestPath: string;
+    /** URL path for runtime use */
+    manifestUrl: string;
+}
+export interface CacheManifest {
+    /** Version of the cache format */
+    version: number;
+    /** Map of animation hash to manifest URL */
+    animations: Record<string, string>;
+}
+/**
+ * Compute a deterministic hash for animation props.
+ * This hash is used as the cache key and for runtime lookup.
+ *
+ * Note: This uses a simple hash function that works identically
+ * in both Node.js and browser environments.
+ */
+export declare function computePropsHash(scene: string, props: Record<string, unknown>): string;
+/**
+ * Check if an animation is already cached.
+ */
+export declare function isCached(hash: string, publicDir: string): boolean;
+/**
+ * Get the cache entry for an animation if it exists.
+ */
+export declare function getCacheEntry(hash: string, publicDir: string): CacheEntry | null;
+/**
+ * Determine which animations need to be rendered (not in cache).
+ */
+export declare function getAnimationsToRender(animations: ExtractedAnimation[], publicDir: string): {
+    cached: CacheEntry[];
+    toRender: ExtractedAnimation[];
+};
+/**
+ * Ensure the manim-assets directory exists.
+ */
+export declare function ensureAssetDir(publicDir: string): string;
+/**
+ * Get the output directory for a specific animation hash.
+ */
+export declare function getOutputDir(hash: string, publicDir: string): string;
+/**
+ * Write the runtime cache manifest that maps hashes to manifest URLs.
+ * This is used by the React component to look up animations at runtime.
+ */
+export declare function writeCacheManifest(animations: ExtractedAnimation[], publicDir: string): void;
+/**
+ * Read the existing cache manifest if it exists.
+ */
+export declare function readCacheManifest(publicDir: string): CacheManifest | null;
+/**
+ * Clean up orphaned cache entries that are no longer referenced.
+ */
+export declare function cleanOrphanedCache(animations: ExtractedAnimation[], publicDir: string): void;

package/dist/cache.js

@@ -0,0 +1,206 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computePropsHash = computePropsHash;
+exports.isCached = isCached;
+exports.getCacheEntry = getCacheEntry;
+exports.getAnimationsToRender = getAnimationsToRender;
+exports.ensureAssetDir = ensureAssetDir;
+exports.getOutputDir = getOutputDir;
+exports.writeCacheManifest = writeCacheManifest;
+exports.readCacheManifest = readCacheManifest;
+exports.cleanOrphanedCache = cleanOrphanedCache;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CACHE_VERSION = 1;
+/**
+ * Compute a deterministic hash for animation props.
+ * This hash is used as the cache key and for runtime lookup.
+ *
+ * Note: This uses a simple hash function that works identically
+ * in both Node.js and browser environments.
+ */
+function computePropsHash(scene, props) {
+    // Create a deterministic string representation
+    // Sort keys to ensure consistent ordering
+    const sortedProps = sortObjectKeys(props);
+    const data = JSON.stringify({ scene, props: sortedProps });
+    // Use djb2 hash algorithm - fast and produces good distribution
+    let hash = 5381;
+    for (let i = 0; i < data.length; i++) {
+        hash = ((hash << 5) + hash + data.charCodeAt(i)) | 0;
+    }
+    // Convert to positive hex string, padded to 8 chars
+    const hexHash = (hash >>> 0).toString(16).padStart(8, "0");
+    return hexHash;
+}
+/**
+ * Recursively sort object keys for deterministic JSON stringification.
+ */
+function sortObjectKeys(obj) {
+    if (obj === null || typeof obj !== "object") {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(sortObjectKeys);
+    }
+    const sorted = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+        sorted[key] = sortObjectKeys(obj[key]);
+    }
+    return sorted;
+}
+/**
+ * Check if an animation is already cached.
+ */
+function isCached(hash, publicDir) {
+    const manifestPath = path.join(publicDir, "manim-assets", hash, "manifest.json");
+    return fs.existsSync(manifestPath);
+}
+/**
+ * Get the cache entry for an animation if it exists.
+ */
+function getCacheEntry(hash, publicDir) {
+    const assetDir = path.join(publicDir, "manim-assets", hash);
+    const manifestPath = path.join(assetDir, "manifest.json");
+    if (!fs.existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        return {
+            hash,
+            scene: manifest.scene,
+            props: {},
+            manifestPath,
+            manifestUrl: `/manim-assets/${hash}/manifest.json`,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Determine which animations need to be rendered (not in cache).
+ */
+function getAnimationsToRender(animations, publicDir) {
+    const cached = [];
+    const toRender = [];
+    for (const animation of animations) {
+        const hash = computePropsHash(animation.scene, animation.props);
+        const entry = getCacheEntry(hash, publicDir);
+        if (entry) {
+            cached.push(entry);
+        }
+        else {
+            toRender.push(animation);
+        }
+    }
+    return { cached, toRender };
+}
+/**
+ * Ensure the manim-assets directory exists.
+ */
+function ensureAssetDir(publicDir) {
+    const assetDir = path.join(publicDir, "manim-assets");
+    if (!fs.existsSync(assetDir)) {
+        fs.mkdirSync(assetDir, { recursive: true });
+    }
+    return assetDir;
+}
+/**
+ * Get the output directory for a specific animation hash.
+ */
+function getOutputDir(hash, publicDir) {
+    return path.join(publicDir, "manim-assets", hash);
+}
+/**
+ * Write the runtime cache manifest that maps hashes to manifest URLs.
+ * This is used by the React component to look up animations at runtime.
+ */
+function writeCacheManifest(animations, publicDir) {
+    const manifest = {
+        version: CACHE_VERSION,
+        animations: {},
+    };
+    for (const animation of animations) {
+        const hash = computePropsHash(animation.scene, animation.props);
+        manifest.animations[hash] = `/manim-assets/${hash}/manifest.json`;
+    }
+    const manifestPath = path.join(publicDir, "manim-assets", "cache-manifest.json");
+    ensureAssetDir(publicDir);
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+}
+/**
+ * Read the existing cache manifest if it exists.
+ */
+function readCacheManifest(publicDir) {
+    const manifestPath = path.join(publicDir, "manim-assets", "cache-manifest.json");
+    if (!fs.existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        if (manifest.version !== CACHE_VERSION) {
+            return null;
+        }
+        return manifest;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Clean up orphaned cache entries that are no longer referenced.
+ */
+function cleanOrphanedCache(animations, publicDir) {
+    const assetDir = path.join(publicDir, "manim-assets");
+    if (!fs.existsSync(assetDir)) {
+        return;
+    }
+    // Get all valid hashes
+    const validHashes = new Set(animations.map((a) => computePropsHash(a.scene, a.props)));
+    // Check each directory in manim-assets
+    const entries = fs.readdirSync(assetDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && !validHashes.has(entry.name)) {
+            // This hash is no longer used, remove it
+            const dirPath = path.join(assetDir, entry.name);
+            fs.rmSync(dirPath, { recursive: true, force: true });
+        }
+    }
+}

package/dist/cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cache.test.js

@@ -0,0 +1,292 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cache_1 = require("./cache");
+// Mock fs module
+vitest_1.vi.mock("fs");
+(0, vitest_1.describe)("computePropsHash", () => {
+    (0, vitest_1.it)("should produce consistent hashes for same input", () => {
+        const hash1 = (0, cache_1.computePropsHash)("TextScene", { text: "Hello", fontSize: 72 });
+        const hash2 = (0, cache_1.computePropsHash)("TextScene", { text: "Hello", fontSize: 72 });
+        (0, vitest_1.expect)(hash1).toBe(hash2);
+    });
+    (0, vitest_1.it)("should produce different hashes for different scenes", () => {
+        const hash1 = (0, cache_1.computePropsHash)("TextScene", { text: "Hello" });
+        const hash2 = (0, cache_1.computePropsHash)("CustomScene", { text: "Hello" });
+        (0, vitest_1.expect)(hash1).not.toBe(hash2);
+    });
+    (0, vitest_1.it)("should produce different hashes for different props", () => {
+        const hash1 = (0, cache_1.computePropsHash)("TextScene", { text: "Hello" });
+        const hash2 = (0, cache_1.computePropsHash)("TextScene", { text: "World" });
+        (0, vitest_1.expect)(hash1).not.toBe(hash2);
+    });
+    (0, vitest_1.it)("should normalize key order", () => {
+        const hash1 = (0, cache_1.computePropsHash)("TextScene", { a: 1, b: 2, c: 3 });
+        const hash2 = (0, cache_1.computePropsHash)("TextScene", { c: 3, a: 1, b: 2 });
+        (0, vitest_1.expect)(hash1).toBe(hash2);
+    });
+    (0, vitest_1.it)("should handle empty props", () => {
+        const hash = (0, cache_1.computePropsHash)("TextScene", {});
+        (0, vitest_1.expect)(hash).toHaveLength(8);
+        (0, vitest_1.expect)(hash).toMatch(/^[0-9a-f]{8}$/);
+    });
+    (0, vitest_1.it)("should handle nested objects with sorted keys", () => {
+        const hash1 = (0, cache_1.computePropsHash)("Scene", { config: { b: 2, a: 1 } });
+        const hash2 = (0, cache_1.computePropsHash)("Scene", { config: { a: 1, b: 2 } });
+        (0, vitest_1.expect)(hash1).toBe(hash2);
+    });
+    (0, vitest_1.it)("should handle arrays (preserving order)", () => {
+        const hash1 = (0, cache_1.computePropsHash)("Scene", { items: [1, 2, 3] });
+        const hash2 = (0, cache_1.computePropsHash)("Scene", { items: [3, 2, 1] });
+        (0, vitest_1.expect)(hash1).not.toBe(hash2);
+    });
+});
+(0, vitest_1.describe)("isCached", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)("should return true when manifest exists", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        const result = (0, cache_1.isCached)("abc12345", "/public");
+        (0, vitest_1.expect)(result).toBe(true);
+        (0, vitest_1.expect)(fs.existsSync).toHaveBeenCalledWith(path.join("/public", "manim-assets", "abc12345", "manifest.json"));
+    });
+    (0, vitest_1.it)("should return false when manifest does not exist", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = (0, cache_1.isCached)("abc12345", "/public");
+        (0, vitest_1.expect)(result).toBe(false);
+    });
+});
+(0, vitest_1.describe)("getCacheEntry", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)("should return null when manifest does not exist", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = (0, cache_1.getCacheEntry)("abc12345", "/public");
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+    (0, vitest_1.it)("should return cache entry when manifest exists", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ scene: "TextScene", fps: 30 }));
+        const result = (0, cache_1.getCacheEntry)("abc12345", "/public");
+        (0, vitest_1.expect)(result).toEqual({
+            hash: "abc12345",
+            scene: "TextScene",
+            props: {},
+            manifestPath: path.join("/public", "manim-assets", "abc12345", "manifest.json"),
+            manifestUrl: "/manim-assets/abc12345/manifest.json",
+        });
+    });
+    (0, vitest_1.it)("should return null when manifest is invalid JSON", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue("invalid json");
+        const result = (0, cache_1.getCacheEntry)("abc12345", "/public");
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+});
+(0, vitest_1.describe)("getAnimationsToRender", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)("should separate cached and uncached animations", () => {
+        const animations = [
+            { id: "1", filePath: "a.tsx", line: 1, scene: "TextScene", props: { text: "Hello" } },
+            { id: "2", filePath: "b.tsx", line: 2, scene: "TextScene", props: { text: "World" } },
+        ];
+        // First animation is cached, second is not
+        vitest_1.vi.mocked(fs.existsSync).mockImplementation((p) => {
+            const pathStr = String(p);
+            return pathStr.includes((0, cache_1.computePropsHash)("TextScene", { text: "Hello" }));
+        });
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ scene: "TextScene" }));
+        const result = (0, cache_1.getAnimationsToRender)(animations, "/public");
+        (0, vitest_1.expect)(result.cached).toHaveLength(1);
+        (0, vitest_1.expect)(result.toRender).toHaveLength(1);
+        (0, vitest_1.expect)(result.toRender[0].props.text).toBe("World");
+    });
+    (0, vitest_1.it)("should return all as toRender when none are cached", () => {
+        const animations = [
+            { id: "1", filePath: "a.tsx", line: 1, scene: "TextScene", props: { text: "Hello" } },
+        ];
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = (0, cache_1.getAnimationsToRender)(animations, "/public");
+        (0, vitest_1.expect)(result.cached).toHaveLength(0);
+        (0, vitest_1.expect)(result.toRender).toHaveLength(1);
+    });
+    (0, vitest_1.it)("should return all as cached when all exist", () => {
+        const animations = [
+            { id: "1", filePath: "a.tsx", line: 1, scene: "TextScene", props: { text: "Hello" } },
+        ];
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ scene: "TextScene" }));
+        const result = (0, cache_1.getAnimationsToRender)(animations, "/public");
+        (0, vitest_1.expect)(result.cached).toHaveLength(1);
+        (0, vitest_1.expect)(result.toRender).toHaveLength(0);
+    });
+});
+(0, vitest_1.describe)("ensureAssetDir", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)("should create directory if it does not exist", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(false);
+        vitest_1.vi.mocked(fs.mkdirSync).mockReturnValue(undefined);
+        const result = (0, cache_1.ensureAssetDir)("/public");
+        (0, vitest_1.expect)(result).toBe(path.join("/public", "manim-assets"));
+        (0, vitest_1.expect)(fs.mkdirSync).toHaveBeenCalledWith(path.join("/public", "manim-assets"), { recursive: true });
+    });
+    (0, vitest_1.it)("should not create directory if it exists", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        const result = (0, cache_1.ensureAssetDir)("/public");
+        (0, vitest_1.expect)(result).toBe(path.join("/public", "manim-assets"));
+        (0, vitest_1.expect)(fs.mkdirSync).not.toHaveBeenCalled();
+    });
+});
+(0, vitest_1.describe)("getOutputDir", () => {
+    (0, vitest_1.it)("should return correct output directory path", () => {
+        const result = (0, cache_1.getOutputDir)("abc12345", "/public");
+        (0, vitest_1.expect)(result).toBe(path.join("/public", "manim-assets", "abc12345"));
+    });
+});
+(0, vitest_1.describe)("writeCacheManifest", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)("should write cache manifest with correct content", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.writeFileSync).mockReturnValue(undefined);
+        const animations = [
+            { id: "1", filePath: "a.tsx", line: 1, scene: "TextScene", props: { text: "Hello" } },
+            { id: "2", filePath: "b.tsx", line: 2, scene: "TextScene", props: { text: "World" } },
+        ];
+        (0, cache_1.writeCacheManifest)(animations, "/public");
+        (0, vitest_1.expect)(fs.writeFileSync).toHaveBeenCalledWith(path.join("/public", "manim-assets", "cache-manifest.json"), vitest_1.expect.stringContaining('"version":'));
+    });
+    (0, vitest_1.it)("should generate correct hash for each animation", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        let writtenContent = "";
+        vitest_1.vi.mocked(fs.writeFileSync).mockImplementation((_, content) => {
+            writtenContent = String(content);
+        });
+        const animations = [
+            { id: "1", filePath: "a.tsx", line: 1, scene: "TextScene", props: { text: "Test" } },
+        ];
+        (0, cache_1.writeCacheManifest)(animations, "/public");
+        const manifest = JSON.parse(writtenContent);
+        const hash = (0, cache_1.computePropsHash)("TextScene", { text: "Test" });
+        (0, vitest_1.expect)(manifest.version).toBe(1);
+        (0, vitest_1.expect)(manifest.animations[hash]).toBe(`/manim-assets/${hash}/manifest.json`);
+    });
+});
+(0, vitest_1.describe)("readCacheManifest", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)("should return null when manifest does not exist", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = (0, cache_1.readCacheManifest)("/public");
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+    (0, vitest_1.it)("should return manifest when it exists and is valid", () => {
+        const manifest = {
+            version: 1,
+            animations: { abc123: "/manim-assets/abc123/manifest.json" },
+        };
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(manifest));
+        const result = (0, cache_1.readCacheManifest)("/public");
+        (0, vitest_1.expect)(result).toEqual(manifest);
+    });
+    (0, vitest_1.it)("should return null for wrong version", () => {
+        const manifest = {
+            version: 999, // Wrong version
+            animations: {},
+        };
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(manifest));
+        const result = (0, cache_1.readCacheManifest)("/public");
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+    (0, vitest_1.it)("should return null for invalid JSON", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readFileSync).mockReturnValue("invalid json");
+        const result = (0, cache_1.readCacheManifest)("/public");
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+});
+(0, vitest_1.describe)("cleanOrphanedCache", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)("should do nothing if asset directory does not exist", () => {
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(false);
+        (0, cache_1.cleanOrphanedCache)([], "/public");
+        (0, vitest_1.expect)(fs.readdirSync).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("should remove orphaned directories", () => {
+        const animations = [
+            { id: "1", filePath: "a.tsx", line: 1, scene: "TextScene", props: { text: "Keep" } },
+        ];
+        const validHash = (0, cache_1.computePropsHash)("TextScene", { text: "Keep" });
+        const orphanHash = "deadbeef";
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readdirSync).mockReturnValue([
+            { name: validHash, isDirectory: () => true },
+            { name: orphanHash, isDirectory: () => true },
+            { name: "cache-manifest.json", isDirectory: () => false },
+        ]);
+        vitest_1.vi.mocked(fs.rmSync).mockReturnValue(undefined);
+        (0, cache_1.cleanOrphanedCache)(animations, "/public");
+        (0, vitest_1.expect)(fs.rmSync).toHaveBeenCalledWith(path.join("/public", "manim-assets", orphanHash), { recursive: true, force: true });
+        (0, vitest_1.expect)(fs.rmSync).toHaveBeenCalledTimes(1);
+    });
+    (0, vitest_1.it)("should not remove valid cache entries", () => {
+        const animations = [
+            { id: "1", filePath: "a.tsx", line: 1, scene: "TextScene", props: { text: "Keep" } },
+        ];
+        const validHash = (0, cache_1.computePropsHash)("TextScene", { text: "Keep" });
+        vitest_1.vi.mocked(fs.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs.readdirSync).mockReturnValue([
+            { name: validHash, isDirectory: () => true },
+        ]);
+        vitest_1.vi.mocked(fs.rmSync).mockReturnValue(undefined);
+        (0, cache_1.cleanOrphanedCache)(animations, "/public");
+        (0, vitest_1.expect)(fs.rmSync).not.toHaveBeenCalled();
+    });
+});

package/dist/extractor.d.ts

@@ -0,0 +1,29 @@
+export interface ExtractedAnimation {
+    /** Unique identifier based on file path and location */
+    id: string;
+    /** Source file path */
+    filePath: string;
+    /** Line number in source */
+    line: number;
+    /** Scene name (defaults to "TextScene") */
+    scene: string;
+    /** Props to pass to the Manim scene */
+    props: Record<string, unknown>;
+}
+interface ExtractorOptions {
+    /** Root directory to scan */
+    rootDir: string;
+    /** Glob patterns to include (default: ["**\/*.tsx", "**\/*.jsx"]) */
+    include?: string[];
+    /** Glob patterns to exclude (default: ["node_modules/**", ".next/**"]) */
+    exclude?: string[];
+}
+/**
+ * Scan a directory for ManimScroll components and extract their configurations.
+ */
+export declare function extractAnimations(options: ExtractorOptions): Promise<ExtractedAnimation[]>;
+/**
+ * Extract animations from a single file (useful for watch mode).
+ */
+export declare function extractAnimationsFromFile(filePath: string): ExtractedAnimation[];
+export {};