@viji-dev/sdk 1.0.0 → 1.0.2

package/src/scenes-hmr.ts

@@ -1,158 +0,0 @@
-// Load all scene files eagerly as raw; seed a live map we can update on HMR
-const initialMapRaw = import.meta.glob('/scenes/**/*.{js,ts,jsx,tsx}', { query: '?raw', import: 'default', eager: true });
-
-// Import project filesystem to mark source changes
-import { projectFileSystem } from './services/project-filesystem';
-
-// Use global window storage to persist the map across HMR reloads
-if (!(window as any).vijiSceneHmrLive) {
-  (window as any).vijiSceneHmrLive = new Map<string, string>(
-    Object.entries(initialMapRaw).map(([k, v]) => [k, v as unknown as string])
-  );
-}
-export const sceneHmrLive = (window as any).vijiSceneHmrLive as Map<string, string>;
-
-export const sceneHmrCount = sceneHmrLive.size;
-
-// Debug: log what files were actually discovered
-console.log('🔍 [Scenes HMR] Discovered files:', Array.from(sceneHmrLive.keys()));
-
-// Import scene files as modules (not raw) for HMR tracking
-const sceneModules = import.meta.glob('/scenes/**/*.{js,ts,jsx,tsx}', { eager: false });
-// Also prepare lazy loaders for targeted refreshes  
-const sceneLoaders = import.meta.glob('/scenes/**/*.{js,ts,jsx,tsx}', { query: '?raw', import: 'default' });
-
-// File change polling mechanism (since Vite HMR doesn't work well with external files)
-// Use global window storage to persist across HMR reloads
-if (!(window as any).vijiSceneHashes) {
-  (window as any).vijiSceneHashes = new Map<string, string>();
-}
-const fileHashes = (window as any).vijiSceneHashes as Map<string, string>;
-
-// Initialize file hashes only if not already set
-async function initializeHashes() {
-  console.log('🔧 [Scenes HMR] Initializing file hashes for', sceneHmrLive.size, 'files');
-  
-  // Update the global map with fresh initial content
-  for (const [path, content] of Object.entries(initialMapRaw)) {
-    sceneHmrLive.set(path, content as unknown as string);
-  }
-  
-  for (const [path, content] of sceneHmrLive.entries()) {
-    const hash = hashContent(content);
-    if (!fileHashes.has(path)) {
-      fileHashes.set(path, hash);
-      console.log('🔧 [Scenes HMR] Initial hash for', path, ':', hash, `(${content.length} chars)`);
-    } else {
-      const oldHash = fileHashes.get(path);
-      console.log('🔧 [Scenes HMR] Hash already exists for', path, ':', oldHash, 'vs current:', hash);
-      
-      // If hash changed during initialization, reload fresh content and trigger event
-      if (oldHash !== hash) {
-        console.log('🎯 [Scenes HMR] File change detected during init:', path, `(${content.length} chars)`, 'oldHash:', oldHash, 'newHash:', hash);
-        // Reload fresh content instead of using stale initial content
-        try {
-          const loader = sceneLoaders[path];
-          if (loader) {
-            const freshContent = await (loader as any)();
-            const freshHash = hashContent(freshContent);
-          console.log('🔄 [Scenes HMR] Reloaded fresh content:', path, `(${freshContent.length} chars)`);
-          fileHashes.set(path, freshHash);
-          sceneHmrLive.set(path, freshContent);
-          projectFileSystem.markSourceChanged(path); // Mark source as changed for cache invalidation
-          window.dispatchEvent(new CustomEvent('viji-scene-file-updated', { detail: { path } }));
-          } else {
-            // Fallback to stale content if no loader
-            fileHashes.set(path, hash);
-            sceneHmrLive.set(path, content);
-            window.dispatchEvent(new CustomEvent('viji-scene-file-updated', { detail: { path } }));
-          }
-        } catch (err) {
-          console.warn('⚠️ [Scenes HMR] Failed to reload fresh content for:', path, err);
-          // Fallback to stale content
-          fileHashes.set(path, hash);
-          sceneHmrLive.set(path, content);
-          window.dispatchEvent(new CustomEvent('viji-scene-file-updated', { detail: { path } }));
-        }
-      }
-    }
-  }
-}
-
-// Run initialization
-initializeHashes();
-
-function hashContent(content: string): string {
-  let hash = 2166136261; // FNV offset basis
-  for (let i = 0; i < content.length; i++) {
-    hash ^= content.charCodeAt(i);
-    hash = (hash * 16777619) >>> 0; // FNV prime, convert to unsigned 32-bit
-  }
-  return hash.toString(16);
-}
-
-async function checkForFileChanges() {
-  for (const [path, loader] of Object.entries(sceneLoaders)) {
-    try {
-      const currentContent = await (loader as any)();
-      const currentHash = hashContent(currentContent);
-      const lastHash = fileHashes.get(path);
-      
-      // Debug: show hash comparison for core-demo (only when different)
-      if (path.includes('core-demo') && lastHash !== currentHash) {
-        console.log('🔍 [Scenes HMR] Change detected in', path, '- lastHash:', lastHash, 'currentHash:', currentHash);
-      }
-      
-      if (lastHash && lastHash !== currentHash) {
-      console.log('🎯 [Scenes HMR] file change detected:', path, `(${currentContent.length} chars)`);
-        
-        sceneHmrLive.set(path, currentContent);
-        fileHashes.set(path, currentHash);
-        projectFileSystem.markSourceChanged(path); // Mark source as changed for cache invalidation
-        window.dispatchEvent(new CustomEvent('viji-scene-file-updated', { detail: { path } }));
-      } else if (!lastHash) {
-        // First time seeing this file
-        fileHashes.set(path, currentHash);
-        console.log('🔧 [Scenes HMR] First time hash set for:', path, currentHash);
-      }
-    } catch (err) {
-      console.warn('⚠️ [Scenes HMR] failed to check file:', path, err);
-    }
-  }
-}
-
-// Polling disabled - HMR system is working correctly and polling conflicts with it
-console.log('🔧 [Scenes HMR] Polling disabled - HMR events are sufficient');
-
-// Also try HMR as fallback (in case it works for some files)
-if (import.meta.hot) {
-  // Accept updates for each scene module explicitly and refresh live map
-  // Use regular module imports for HMR tracking, then fetch raw content
-  for (const p of Object.keys(sceneModules)) {
-    try {
-      console.log('🔧 [Scenes HMR] registering hot.accept for:', p);
-      import.meta.hot.accept(p, async (newModule) => {
-        try {
-          console.log('🎯 [Scenes HMR] hot.accept triggered for:', p, newModule);
-          const loader = sceneLoaders[p];
-          if (!loader) {
-            console.warn('⚠️ [Scenes HMR] no loader for:', p);
-            return;
-          }
-          const content = await (loader as any)();
-          const contentHash = hashContent(content);
-          sceneHmrLive.set(p, content);
-          fileHashes.set(p, contentHash);
-          console.log('🎯 [Scenes HMR] accept handler updated:', p, `(${content.length} chars)`);
-          window.dispatchEvent(new CustomEvent('viji-scene-file-updated', { detail: { path: p } }));
-        } catch (err) {
-          console.warn('⚠️ [Scenes HMR] accept reload failed:', p, err);
-        }
-      });
-    } catch (err) {
-      console.warn('⚠️ [Scenes HMR] failed to register hot.accept for:', p, err);
-    }
-  }
-}
-
-

package/src/services/project-filesystem.ts

@@ -1,436 +0,0 @@
-/**
- * Project File System Service
- * Manages folder-based scene projects in the root scenes/ directory
- * Each project is a folder containing main.js/main.ts and any additional files
- */
-
-// Browser-compatible path utilities
-// Bring in eagerly-tracked scene files (raw strings) so Vite HMR updates contents live
-import { sceneHmrLive } from '../scenes-hmr';
-const joinPaths = (...paths: string[]): string => {
-  return paths
-    .filter(Boolean)
-    .join('/')
-    .replace(/\/+/g, '/') // Remove duplicate slashes
-    .replace(/\/$/, ''); // Remove trailing slash
-};
-
-export interface ProjectInfo {
-  id: string;
-  name: string;
-  path: string;
-  mainFile: string;
-  projectType: 'javascript' | 'typescript' | 'shader';
-  lastModified: Date;
-  isBuilt: boolean;
-  distPath?: string;
-}
-
-// Note: CreateProjectOptions and BuildProjectOptions removed - project management moved to CLI
-
-export class ProjectFileSystemService {
-  private scenesRoot: string;
-  private projectsCache = new Map<string, ProjectInfo>();
-  private changeCallbacks = new Set<(projects: ProjectInfo[]) => void>();
-  private bundleCache = new Map<string, { content: string; hash: string; timestamp: number; sourceTimestamp: number }>();
-  // Use global window storage for source change counter to persist across HMR reloads
-  private get sourceChangeCounter(): Map<string, number> {
-    if (!(window as any).vijiSourceChangeCounter) {
-      (window as any).vijiSourceChangeCounter = new Map<string, number>();
-    }
-    return (window as any).vijiSourceChangeCounter;
-  }
-
-  // Note: hashString removed - not needed anymore
-
-  // Increment change counter for a source file (called by HMR system)
-  public markSourceChanged(filePath: string): void {
-    const currentCount = this.sourceChangeCounter.get(filePath) || 0;
-    const newCount = currentCount + 1;
-    this.sourceChangeCounter.set(filePath, newCount);
-    console.log('🔄 [Bundler] Source change marked for:', filePath, 'count:', newCount, '(was:', currentCount + ')');
-  }
-
-  constructor(workspaceRoot: string = '') {
-    this.scenesRoot = joinPaths(workspaceRoot, 'scenes');
-    this.initializeDirectory();
-    // Wire Vite HMR to refresh project list when files in /scenes change
-    try {
-      const hot: any = (import.meta as any).hot;
-      if (hot) {
-        const normalize = (p: string) => p.replace(/\?.*$/, '').replace(/^\/@fs\//, '/');
-        const onChange = () => {
-          // Debounced notify
-          try { this.notifyChange(); } catch {}
-        };
-        hot.on('vite:afterUpdate', (payload: any) => {
-          const updates = payload?.updates || [];
-          if (updates.some((u: any) => (normalize(u.path || u.acceptedPath || '')).includes('/scenes/'))) {
-            onChange();
-          }
-        });
-        hot.on?.('vite:invalidate', (payload: any) => {
-          const p = normalize(payload?.path || '');
-          if (p.startsWith('/scenes/')) onChange();
-        });
-      }
-    } catch {}
-  }
-
-  /**
-   * Initialize scenes directory if it doesn't exist
-   */
-  private async initializeDirectory(): Promise<void> {
-    try {
-      console.log(`📁 Initialized scenes directory: ${this.scenesRoot}`);
-    } catch (error) {
-      console.error('Failed to initialize scenes directory:', error);
-    }
-  }
-
-  /**
-   * Get all scene projects from the scenes/ folder
-   */
-  async getProjects(): Promise<ProjectInfo[]> {
-    try {
-      // Use Vite's import.meta.glob to dynamically discover scene projects
-      const projects = await this.scanProjectsFromFilesystem();
-      
-      // Update cache
-      this.projectsCache.clear();
-      projects.forEach(project => {
-        this.projectsCache.set(project.id, project);
-      });
-
-      return projects;
-    } catch (error) {
-      console.error('Failed to scan projects:', error);
-      return [];
-    }
-  }
-
-  /**
-   * Dynamically scan the scenes/ folder for projects using Vite's import.meta.glob
-   */
-  private async scanProjectsFromFilesystem(): Promise<ProjectInfo[]> {
-    const projects: ProjectInfo[] = [];
-    
-    try {
-      // Use Vite's glob import to discover all main files in scene projects
-      const sceneModules = import.meta.glob('/scenes/*/main.{js,ts,jsx,tsx}', { 
-        eager: false,
-        import: 'default'
-      });
-      
-
-      console.log('🔍 Discovered scene modules:', Object.keys(sceneModules));
-      
-      for (const modulePath of Object.keys(sceneModules)) {
-        // Extract project information from the path
-        // Path format: /scenes/project-name/main.{js|ts|jsx|tsx}
-        const pathMatch = modulePath.match(/^\/scenes\/([^\/]+)\/main\.(js|ts|jsx|tsx)$/);
-        
-        if (pathMatch) {
-          const [, projectId, extension] = pathMatch;
-          const projectName = this.formatProjectName(projectId);
-          const projectType = this.getProjectTypeFromExtension(extension);
-          
-          console.log(`🔍 Found project: ID="${projectId}", Name="${projectName}", Path="${modulePath}"`);
-          
-          // Built status will be determined differently since dynamic globs aren't supported
-          const isBuilt = false; // TODO: Check built status via different method
-          
-          const project: ProjectInfo = {
-            id: projectId,
-            name: projectName,
-            path: `./scenes/${projectId}`,
-            mainFile: `./scenes/${projectId}/main.${extension}`,
-            projectType,
-            lastModified: new Date(), // In real implementation, this would come from file stats
-            isBuilt,
-            distPath: isBuilt ? `./scenes/${projectId}/dist` : undefined
-          };
-          
-          // Add to cache for consistent lookup
-          this.projectsCache.set(projectId, project);
-          
-          projects.push(project);
-          console.log('📁 Discovered project:', project.name, `(${project.projectType}) - ID: ${project.id}`);
-        }
-      }
-      
-      // Sort projects by name
-      projects.sort((a, b) => a.name.localeCompare(b.name));
-      
-      console.log(`✅ Found ${projects.length} scene projects`);
-      return projects;
-      
-    } catch (error) {
-      console.error('❌ Failed to scan filesystem for projects:', error);
-      // Fallback: return empty array so UI still works
-      return [];
-    }
-  }
-
-  /**
-   * Convert kebab-case project folder names to display names
-   */
-  private formatProjectName(projectId: string): string {
-    // Return folder name as-is (no formatting)
-    return projectId;
-  }
-
-  /**
-   * Determine project type from file extension
-   */
-  private getProjectTypeFromExtension(extension: string): 'javascript' | 'typescript' | 'shader' {
-    switch (extension) {
-      case 'ts':
-      case 'tsx':
-        return 'typescript';
-      case 'js':
-      case 'jsx':
-      default:
-        return 'javascript';
-    }
-  }
-
-  /**
-   * Convert ESM exports to runtime-friendly declarations for worker eval
-   */
-  private transformESMToRuntime(code: string): string {
-    try {
-      let out = code;
-      out = out.replace(/^(\s*)export\s+default\s+/gm, '$1const __default__ = ');
-      out = out.replace(/^(\s*)export\s+const\s+/gm, '$1const ');
-      out = out.replace(/^(\s*)export\s+(let|var)\s+/gm, '$1$2 ');
-      out = out.replace(/^(\s*)export\s+function\s+/gm, '$1function ');
-      out = out.replace(/^(\s*)export\s+class\s+/gm, '$1class ');
-      // Remove bare export statements like `export {}` or `export { name }`
-      out = out.replace(/^\s*export\s*\{[^}]*\}\s*;?\s*$/gm, '');
-      // Remove type-only exports left after TS stripping (e.g., `export type X = ...;`)
-      out = out.replace(/^\s*export\s+type\s+[^;]+;?\s*$/gm, '');
-      // Clean up any dangling `export` tokens that may remain alone on a line
-      out = out.replace(/^\s*export\s*;?\s*$/gm, '');
-      return out;
-    } catch {
-      return code;
-    }
-  }
-
-  /**
-   * Strip minimal TypeScript syntax to plain JS
-   */
-  private stripTypescript(code: string): string {
-    try {
-      let out = code;
-      // 1) Strip types from function parameter lists
-      out = out.replace(/function\s+([\w$]+)\s*\(([^)]*)\)/g, (_m, name, params) => {
-        const cleaned = String(params)
-          .replace(/\?\s*:\s*[^,\)]+/g, '')
-          .replace(/:\s*[^,\)]+/g, '');
-        return `function ${name}(${cleaned})`;
-      });
-      // 2) Remove return types on functions
-      out = out.replace(/\)\s*:\s*[A-Za-z_$][A-Za-z0-9_$<>,\[\]\|\s]*\s*\{/g, '){');
-      // 3) Remove variable type annotations
-      out = out.replace(/\b(let|const|var)\s+([\w$]+)\s*:\s*[^=;\n]+/g, '$1 $2');
-      // 4) Remove interfaces and type aliases
-      out = out.replace(/interface\s+[A-Za-z_$][A-Za-z0-9_$]*\s*\{[\s\S]*?\}\s*/g, '');
-      out = out.replace(/type\s+[A-Za-z_$][A-Za-z0-9_$]*\s*=\s*[\s\S]*?;\s*/g, '');
-      // 5) Remove `as Type` assertions
-      out = out.replace(/\s+as\s+[A-Za-z_$][A-Za-z0-9_$<>,\[\]\|\s]*/g, '');
-      return out;
-    } catch {
-      return code;
-    }
-  }
-
-
-  // Note: Project creation removed - manage projects manually/CLI
-
-  // Note: Project building removed - use CLI to build projects
-
-  // Note: Project deletion removed - manage projects manually/CLI
-
-  // Note: Project renaming removed - manage projects manually/CLI
-
-  /**
-   * Get default scene template for new projects
-   */
-  private getDefaultSceneTemplate(projectType: 'javascript' | 'typescript' | 'shader'): string {
-    // Delegate to shared minimal template to avoid duplicates
-    const lang = projectType === 'typescript' ? 'ts' : 'js';
-    try {
-      // Dynamic import to avoid bundling issues in some environments
-      // Note: For type safety we keep a simple fallback below.
-      // @ts-ignore
-      const { getMinimalSceneTemplate } = require('../templates/minimal-template.js');
-      return getMinimalSceneTemplate(lang);
-    } catch {
-      // Fallback minimal template
-      return lang === 'ts'
-        ? `// New TypeScript Scene\n\n// Parameter declarations\n// const speed = viji.slider(1.0, { min: 0.1, max: 3.0, label: 'Speed' });\n// const color = viji.color('#ff0000', { label: 'Color' });\n\nfunction render(viji: any) {\n  // Your scene code here\n}\n`
-        : `// New JavaScript Scene\n\n// Parameter declarations\n// const speed = viji.slider(1.0, { min: 0.1, max: 3.0, label: 'Speed' });\n// const color = viji.color('#ff0000', { label: 'Color' });\n\nfunction render(viji) {\n  // Your scene code here\n}\n`;
-    }
-  }
-
-  // Note: loadProjectCode removed - use loadBundledProjectCode instead
-
-  /**
-   * Load and bundle a project's main file plus its local relative imports into a single script
-   */
-  async loadBundledProjectCode(projectId: string): Promise<string> {
-    let project = this.projectsCache.get(projectId);
-    if (!project) {
-      // Self-heal cache (HMR may recreate the service)
-      const refreshed = await this.getProjects();
-      project = refreshed.find(p => p.id === projectId);
-    if (!project) {
-      throw new Error(`Project not found: ${projectId}`);
-    }
-    }
-    
-    // Simple time-based cache to prevent rapid duplicate calls (no content checking)
-    const cacheKey = projectId;
-    const cached = this.bundleCache.get(cacheKey);
-    if (cached && Date.now() - cached.timestamp < 50) { // Very short 50ms cache
-      console.log('📦 [Bundler] Using recent cached bundle for:', projectId, '(rapid call prevention)');
-      return cached.content;
-    }
-    // discover all scene files as raw loaders
-    // Prefer eager HMR map for freshest contents
-    const loaders = import.meta.glob('/scenes/**/*.{js,ts,jsx,tsx}', { eager: false, query: '?raw', import: 'default' });
-    const tryPaths = [
-        `/scenes/${projectId}/main.js`,
-        `/scenes/${projectId}/main.ts`,
-        `/scenes/${projectId}/main.jsx`,
-        `/scenes/${projectId}/main.tsx`
-      ];
-    const mainPath = tryPaths.find(p => loaders[p] || sceneHmrLive.has(p));
-    if (!mainPath) {
-      // Fallback to default template
-      return this.getDefaultSceneTemplate(project.projectType);
-    }
-
-    const visited = new Set<string>();
-    const order: string[] = [];
-    const read = async (path: string): Promise<string> => {
-      const eager = sceneHmrLive.get(path);
-      if (eager) {
-        // console.log('📚 [Bundler] reading from HMR live map:', path, `(${eager.length} chars)`);
-        return eager;
-      }
-      // console.log('📚 [Bundler] reading from Vite loader:', path);
-      const content = await (loaders[path] as any)();
-      // console.log('📚 [Bundler] loaded from Vite:', path, `(${content.length} chars)`);
-      return content;
-    };
-    const resolveRel = (from: string, rel: string): string | null => {
-      if (!rel.startsWith('.')) return null;
-      const fromDir = from.replace(/\/[^\/]*$/, '');
-      const norm = (p: string) => p.replace(/\\+/g, '/').replace(/\/\./g, '/');
-      const base = norm(joinPaths(fromDir, rel));
-      const candidates = [
-        base,
-        `${base}.js`, `${base}.ts`, `${base}.jsx`, `${base}.tsx`,
-        `${base}/index.js`, `${base}/index.ts`, `${base}/index.jsx`, `${base}/index.tsx`
-      ];
-      for (const c of candidates) if (loaders[c]) return c;
-      return null;
-    };
-    const importRegex = /import\s+[^'"`]+from\s+['"]([^'"`]+)['"]/g;
-
-    const dfs = async (path: string) => {
-      if (visited.has(path)) return;
-      visited.add(path);
-      let code = await read(path);
-      // console.log('📚 [Bundler] reading:', path, `(${code.length} chars)`);
-      // follow local relative imports
-      const rels: string[] = [];
-      for (const m of code.matchAll(importRegex) as any) {
-        const rel = m[1];
-        const resolved = resolveRel(path, rel);
-        if (resolved) rels.push(resolved);
-      }
-      for (const dep of rels) await dfs(dep);
-      order.push(path);
-    };
-    await dfs(mainPath);
-
-    // concatenate in order (deps first, main last)
-    let bundled = '';
-    for (const p of order) {
-      let source = await read(p);
-      
-      // Debug: Show line 230 content for core-demo and source info (disabled - HMR working)
-      // if (p.includes('core-demo')) {
-      //   const lines = source.split('\n');
-      //   const isFromHmr = sceneHmrLive.has(p);
-      //   if (lines.length > 230) {
-      //     console.log('🎨 [Bundler] Line 230 in', p, ':', JSON.stringify(lines[229]), `(source: ${isFromHmr ? 'HMR-live' : 'Vite-loader'})`);
-      //   }
-      // }
-      
-      if (p.endsWith('.ts') || p.endsWith('.tsx')) source = this.stripTypescript(source);
-      source = this.transformESMToRuntime(source);
-      bundled += `\n// File: ${p}\n` + source + `\n`;
-    }
-    
-    // Update cache with new bundle (simple time-based cache)
-    this.bundleCache.set(cacheKey, {
-      content: bundled,
-      hash: '', // Not used anymore
-      timestamp: Date.now(),
-      sourceTimestamp: 0 // Not used anymore
-    });
-    
-    // console.log('🧩 [Bundler] final bundle length:', bundled.length);
-    return bundled;
-  }
-
-  /**
-   * Watch for changes in the scenes directory
-   */
-  onProjectsChange(callback: (projects: ProjectInfo[]) => void): () => void {
-    this.changeCallbacks.add(callback);
-    
-    // Return unsubscribe function
-    return () => {
-      this.changeCallbacks.delete(callback);
-    };
-  }
-
-  /**
-   * Refresh projects list from filesystem
-   */
-  async refreshProjects(): Promise<ProjectInfo[]> {
-    return await this.getProjects();
-  }
-
-  // Private helper methods
-
-  // Note: normalizeProjectName removed - not needed for read-only operations
-
-  private notifyChange(): void {
-    // Notify all listeners asynchronously
-    setTimeout(async () => {
-      const projects = await this.getProjects();
-      this.changeCallbacks.forEach(callback => {
-        try {
-          callback(projects);
-        } catch (error) {
-          console.error('Error in project change callback:', error);
-        }
-      });
-    }, 0);
-  }
-
-
-  // Note: buildProjectInternal removed - building moved to CLI
-
-
-}
-
-// Default singleton instance
-export const projectFileSystem = new ProjectFileSystemService();

package/src/stores/scene-player/index.ts

@@ -1,3 +0,0 @@
-// Re-export all store types and hooks
-export * from './scene-session.store';
-export * from './input-manager.store';