@guinetik/gcanvas 1.0.2 → 1.0.4

package/scripts/bundle4llm.js

@@ -1,276 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * bundle4llm
- * -------------
- * Create a comprehensive, single-file, import/export-free JavaScript bundle
- * ideal for feeding into LLMs without worrying about dependencies.
- *
- * Features:
- * - Recursively resolves and includes all exported modules
- * - Flattens directory structure
- * - Orders files by export order in index files
- * - Sanitizes code based on selected preset (defaults to ES2020)
- * - Skips index.js files from output (used only for ordering)
- * - Ensures comprehensive module inclusion
- * - Supports verbose logging with --verbose or -v
- * - Optional comment stripping with --strip-comments
- * - Accurate token estimation for various LLM models
- *
- * Usage:
- *   bundle4llm --src ./src --out ./dist --file bundle.js --preset es2020 --strip-comments --model claude -v
- */
-
-import fs from 'fs';
-import path from 'path';
-import { argv } from 'process';
-
-const args = Object.fromEntries(
-  argv.slice(2).map(arg => {
-    const [key, val] = arg.replace(/^--?/, '').split('=');
-    return [key, val ?? true];
-  })
-);
-
-const srcDir = path.resolve(args.src || './src');
-const outDir = path.resolve(args.out || './dist');
-const outFile = args.file || 'llm-bundle.js';
-const verbose = args.v || args.verbose;
-const stripComments = args['strip-comments'] || false;
-const preset = args.preset || 'es2020';
-const model = args.model || 'claude'; // Default to Claude model
-
-// Deep file collection with recursive export resolution
-function collectModules(indexPath, fileMap = {}, visited = new Set(), depth = 0) {
-  // Prevent infinite recursion
-  if (depth > 10) return fileMap;
-  
-  // Prevent revisiting the same index file
-  if (visited.has(indexPath)) return fileMap;
-  visited.add(indexPath);
-
-  // Read index file contents
-  if (!fs.existsSync(indexPath)) return fileMap;
-  const content = fs.readFileSync(indexPath, 'utf-8');
-
-  // Find all export declarations
-  const exportMatches = [
-    ...content.matchAll(/export\s+(?:\*|{[^}]*})\s*from\s+['"](.+)['"]/g),
-    ...content.matchAll(/export\s+{[^}]*}\s*from\s+['"](.+)['"]/g)
-  ];
-
-  // Resolve and process each exported module
-  for (const match of exportMatches) {
-    const rawPath = match[1];
-    const modulePath = rawPath.startsWith('.') 
-      ? path.resolve(path.dirname(indexPath), rawPath)
-      : path.resolve(srcDir, rawPath);
-    
-    // Normalize path
-    const normalizedPath = modulePath.replace(/\.js$/, '');
-    const jsPath = normalizedPath + '.js';
-
-    // If it's a directory, look for its index file
-    const indexInDir = path.join(normalizedPath, 'index.js');
-    
-    if (fs.existsSync(jsPath) && !fileMap[jsPath]) {
-      // Add the module file
-      fileMap[jsPath] = jsPath;
-      
-      // If it's a directory with an index, recursively collect its exports
-      if (fs.existsSync(indexInDir)) {
-        collectModules(indexInDir, fileMap, visited, depth + 1);
-      }
-    } else if (fs.existsSync(indexInDir)) {
-      // Recursively collect exports from subdirectory index
-      collectModules(indexInDir, fileMap, visited, depth + 1);
-    }
-  }
-
-  return fileMap;
-}
-
-// Order modules based on index file export order
-function orderModules(srcDir) {
-  const indexPath = path.join(srcDir, 'index.js');
-  const fileMap = collectModules(indexPath);
-  
-  // Convert to array and sort
-  return Object.values(fileMap)
-    .filter(filePath => !filePath.endsWith('index.js'));
-}
-
-// Sanitization presets
-const sanitizationPresets = {
-  // ES2020 sanitization - strips imports and optionally comments
-  es2020: (code, options = {}) => {
-    let result = code;
-    
-    // Strip import statements
-    result = result
-      .split('\n')
-      .filter(line => !/^\s*import\b/.test(line))
-      .join('\n');
-    
-    // Optionally strip comments
-    if (options.stripComments) {
-      // Strip block comments
-      result = result.replace(/\/\*[\s\S]*?\*\//g, '');
-      // Strip line comments
-      result = result.replace(/\/\/.*$/gm, '');
-    }
-    
-    return result.trim();
-  },
-  
-  // ES2015 sanitization - more conservative approach
-  es2015: (code, options = {}) => {
-    let result = code;
-    
-    // Strip import statements
-    result = result
-      .split('\n')
-      .filter(line => !/^\s*import\b/.test(line))
-      .join('\n');
-      
-    // Optionally strip comments
-    if (options.stripComments) {
-      // Strip block comments
-      result = result.replace(/\/\*[\s\S]*?\*\//g, '');
-      // Strip line comments
-      result = result.replace(/\/\/.*$/gm, '');
-    }
-    
-    return result.trim();
-  },
-  
-  // Minimal sanitization - only strips imports
-  minimal: (code, options = {}) => {
-    let result = code
-      .split('\n')
-      .filter(line => !/^\s*import\b/.test(line))
-      .join('\n');
-      
-    return result.trim();
-  }
-};
-
-// Generic sanitize function that uses the selected preset
-function sanitizeCode(code, presetName, options = {}) {
-  const sanitizer = sanitizationPresets[presetName] || sanitizationPresets.es2020;
-  return sanitizer(code, options);
-}
-
-/**
- * Improved token estimation function supporting multiple LLM models
- * 
- * @param {string} text - The text to estimate tokens for
- * @param {string} model - Model identifier ('claude', 'gpt3', 'gpt4', etc.)
- * @return {number} Estimated token count
- */
-function estimateTokens(text, model = 'claude') {
-  // Basic character counting
-  const charCount = text.length;
-  const wordCount = text.split(/\s+/).filter(Boolean).length;
-  
-  // Model-specific token ratio estimations
-  const modelRatios = {
-    // Anthropic Claude models
-    'claude': { 
-      charRatio: 3.5,      // ~3.5 chars per token for Claude
-      wordRatio: 0.75,     // ~0.75 words per token for Claude
-    },
-    // OpenAI models
-    'gpt3': {
-      charRatio: 4.0,      // ~4 chars per token for GPT-3
-      wordRatio: 0.75,     // ~0.75 words per token for GPT-3
-    },
-    'gpt4': {
-      charRatio: 3.8,      // ~3.8 chars per token for GPT-4
-      wordRatio: 0.7,      // ~0.7 words per token for GPT-4
-    },
-    // Default fallback
-    'default': {
-      charRatio: 4.0,
-      wordRatio: 0.75,
-    }
-  };
-  
-  // Get the appropriate ratio for the model
-  const ratio = modelRatios[model] || modelRatios.default;
-  
-  // Estimate based on character count and word count, using an average of both methods
-  const charBasedEstimate = Math.ceil(charCount / ratio.charRatio);
-  const wordBasedEstimate = Math.ceil(wordCount / ratio.wordRatio);
-  
-  // Language features that tend to increase token count
-  const codeFeatures = {
-    symbols: (text.match(/[{}[\]()<>:;,."'`~!@#$%^&*+=|\\/?-]/g) || []).length,
-    indentation: (text.match(/^ +/gm) || []).length,
-    camelCase: (text.match(/[a-z][A-Z]/g) || []).length,
-  };
-  
-  // Adjustment for code-specific features (symbols, indentation, camelCase)
-  const codeAdjustment = codeFeatures.symbols * 0.1 + 
-                          codeFeatures.indentation * 0.05 + 
-                          codeFeatures.camelCase * 0.2;
-  
-  // Calculate weighted average with more weight on char-based for code
-  const weightedEstimate = (charBasedEstimate * 0.7) + (wordBasedEstimate * 0.3);
-  
-  // Add code-specific adjustment
-  const finalEstimate = Math.ceil(weightedEstimate + codeAdjustment);
-  
-  return finalEstimate;
-}
-
-// Main bundling function
-function bundleLLMBuild(srcDir, outDir, outFile, options = {}) {
-  const orderedFiles = orderModules(srcDir);
-  const { verbose, stripComments, preset, model } = options;
-
-  let output = '/**\n * bundle4llm Output\n';
-  output += ` * Generated: ${new Date().toISOString()}\n`;
-  output += ` * Source: ${srcDir}\n`;
-  output += ` * Preset: ${preset}\n`;
-  if (stripComments) output += ` * Comments: Stripped\n`;
-  output += ` */\n\n`;
-
-  let currentDir = '';
-  for (const file of orderedFiles) {
-    const fileDir = path.dirname(file).replace(srcDir, '');
-    if (fileDir !== currentDir) {
-      currentDir = fileDir;
-      output += `\n// =========================================\n`;
-      output += `// DIRECTORY: ${currentDir || '/'}\n`;
-      output += `// =========================================\n\n`;
-    }
-
-    let contents = fs.readFileSync(file, 'utf-8');
-    contents = sanitizeCode(contents, preset, { stripComments });
-    
-    if (verbose) console.log('📦 Including:', file);
-    output += contents + '\n\n';
-  }
-
-  // Ensure output directory exists
-  fs.mkdirSync(outDir, { recursive: true });
-  
-  // Write the bundled file
-  const fullOutputPath = path.join(outDir, outFile);
-  fs.writeFileSync(fullOutputPath, output);
-
-  const totalTokens = estimateTokens(output, model).toLocaleString();
-  console.log(`✅ Created LLM build → ${fullOutputPath}`);
-  console.log(`📊 Total modules included: ${orderedFiles.length}`);
-  console.log(`🔧 Preset: ${preset}${stripComments ? ', comments stripped' : ''}`);
-  console.log(`🔍 Estimated tokens (${model}): ${totalTokens}`);
-}
-
-// Execute the bundle
-bundleLLMBuild(srcDir, outDir, outFile, {
-  verbose,
-  stripComments,
-  preset,
-  model
-});

package/scripts/clearconsole.js

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-const path = require("path");
-
-const targetDir = process.argv[2] || "./src"; // default to ./src
-
-function isLineCommented(line) {
-  return /^\s*\/\/.*console\.log/.test(line);
-}
-
-function isInsideBlockComment(lines, index) {
-  for (let i = index; i >= 0; i--) {
-    if (lines[i].includes("*/")) break;
-    if (lines[i].includes("/*")) return true;
-  }
-  return false;
-}
-
-function processFile(filePath) {
-  const content = fs.readFileSync(filePath, "utf8");
-  const lines = content.split("\n");
-  const modified = lines.map((line, i) => {
-    if (
-      line.includes("console.log") &&
-      !isLineCommented(line) &&
-      !isInsideBlockComment(lines, i)
-    ) {
-      return line.replace(/(.*?)(console\.log.*)/, "$1// $2");
-    }
-    return line;
-  });
-  fs.writeFileSync(filePath, modified.join("\n"), "utf8");
-  console.log(`✔ Commented console.log in: ${filePath}`);
-}
-
-function walkDir(dir) {
-  fs.readdirSync(dir).forEach((file) => {
-    const fullPath = path.join(dir, file);
-    if (fs.statSync(fullPath).isDirectory()) {
-      walkDir(fullPath);
-    } else if (/\.(js|ts|jsx|tsx)$/.test(fullPath)) {
-      processFile(fullPath);
-    }
-  });
-}
-
-walkDir(targetDir);

package/test/math/orbital.test.js

@@ -1,61 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { decayingOrbitalRadius, getTerminalTrajectory } from "../../src/math/orbital";
-
-describe("Orbital Math Utilities", () => {
-    describe("decayingOrbitalRadius", () => {
-        it("should return the initial radius when t=0", () => {
-            const r0 = 100;
-            const decay = 0.5;
-            const r = decayingOrbitalRadius(r0, decay, 0);
-            expect(r).toBe(r0);
-        });
-
-        it("should decay the radius over time", () => {
-            const r0 = 100;
-            const decay = 0.5;
-            const r1 = decayingOrbitalRadius(r0, decay, 1);
-            const r2 = decayingOrbitalRadius(r0, decay, 2);
-
-            expect(r1).toBeLessThan(r0);
-            expect(r2).toBeLessThan(r1);
-            expect(r1).toBeCloseTo(100 * Math.exp(-0.5), 5);
-        });
-
-        it("should handle zero decay factor", () => {
-            const r0 = 100;
-            const r = decayingOrbitalRadius(r0, 0, 10);
-            expect(r).toBe(r0);
-        });
-    });
-
-    describe("getTerminalTrajectory", () => {
-        it("should return start position at progress=0", () => {
-            const start = { x: 100, y: 50, z: 25 };
-            const pos = getTerminalTrajectory(start.x, start.y, start.z, 0);
-            expect(pos).toEqual(start);
-        });
-
-        it("should return origin at progress=1", () => {
-            const start = { x: 100, y: 50, z: 25 };
-            const pos = getTerminalTrajectory(start.x, start.y, start.z, 1);
-            expect(pos).toEqual({ x: 0, y: 0, z: 0 });
-        });
-
-        it("should interpolate linearly by default", () => {
-            const start = { x: 100, y: 100, z: 100 };
-            const pos = getTerminalTrajectory(start.x, start.y, start.z, 0.5);
-            expect(pos).toEqual({ x: 50, y: 50, z: 50 });
-        });
-
-        it("should apply easing function if provided", () => {
-            const start = { x: 100, y: 100, z: 100 };
-            const easeInQuad = (t) => t * t;
-            const pos = getTerminalTrajectory(start.x, start.y, start.z, 0.5, easeInQuad);
-            // 0.5 * 0.5 = 0.25
-            // 100 * (1 - 0.25) = 75
-            expect(pos.x).toBe(75);
-            expect(pos.y).toBe(75);
-            expect(pos.z).toBe(75);
-        });
-    });
-});

package/test/math/tensor.test.js

@@ -1,114 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Tensor } from "../../src/math/tensor";
-
-describe("Tensor class", () => {
-    describe("Basic Operations", () => {
-        it("should create a tensor from components", () => {
-            const components = [
-                [1, 2],
-                [3, 4],
-            ];
-            const t = new Tensor(components);
-            expect(t.get(0, 0)).toBe(1);
-            expect(t.get(1, 1)).toBe(4);
-            expect(t.dimension).toBe(2);
-        });
-
-        it("should be immutable", () => {
-            const components = [[1, 2], [3, 4]];
-            const t1 = new Tensor(components);
-            const t2 = t1.set(0, 0, 9);
-
-            expect(t1.get(0, 0)).toBe(1);
-            expect(t2.get(0, 0)).toBe(9);
-            expect(t1).not.toBe(t2);
-        });
-
-        it("should add two tensors", () => {
-            const t1 = new Tensor([[1, 0], [0, 1]]);
-            const t2 = new Tensor([[1, 2], [3, 4]]);
-            const sum = t1.add(t2);
-            expect(sum.get(0, 1)).toBe(2);
-            expect(sum.get(1, 1)).toBe(5);
-        });
-
-        it("should scale a tensor", () => {
-            const t = new Tensor([[1, 2], [3, 4]]);
-            const scaled = t.scale(2);
-            expect(scaled.get(0, 0)).toBe(2);
-            expect(scaled.get(1, 1)).toBe(8);
-        });
-    });
-
-    describe("Inversion & Determinant (Diagonal Optimizations)", () => {
-        it("should compute inverse of a diagonal tensor (fast path)", () => {
-            const t = Tensor.diagonal([-1, 0.5, 2, 4]);
-            const inv = t.inverse();
-            expect(inv.get(0, 0)).toBe(-1);
-            expect(inv.get(1, 1)).toBe(2);
-            expect(inv.get(2, 2)).toBe(0.5);
-            expect(inv.get(3, 3)).toBe(0.25);
-        });
-
-        it("should compute determinant of a diagonal matrix (fast path)", () => {
-            const t = Tensor.diagonal([-1, 1, 1, 1]);
-            expect(t.determinant()).toBe(-1);
-        });
-
-        it("should compute inverse of a non-diagonal matrix (Gaussian elimination)", () => {
-            const t = new Tensor([
-                [1, 2],
-                [3, 4]
-            ]);
-            const inv = t.inverse();
-            // det = 1*4 - 2*3 = -2
-            // inv = (-1/2) * [4, -2; -3, 1] = [-2, 1; 1.5, -0.5]
-            expect(inv.get(0, 0)).toBeCloseTo(-2, 10);
-            expect(inv.get(0, 1)).toBeCloseTo(1, 10);
-            expect(inv.get(1, 0)).toBeCloseTo(1.5, 10);
-            expect(inv.get(1, 1)).toBeCloseTo(-0.5, 10);
-        });
-    });
-
-    describe("GR Metrics", () => {
-        it("should create Schwarzschild metric", () => {
-            const g = Tensor.schwarzschild(10, 2);
-            expect(g.name).toBe("Schwarzschild");
-            // factor = 1 - 2/10 = 0.8
-            expect(g.get(0, 0)).toBe(-0.8);
-            expect(g.get(1, 1)).toBeCloseTo(1 / 0.8, 5);
-        });
-
-        it("should create contravariant Schwarzschild metric directly", () => {
-            const gInv = Tensor.schwarzschildContravariant(10, 2);
-            expect(gInv.get(0, 0)).toBeCloseTo(-1 / 0.8, 5);
-            expect(gInv.get(1, 1)).toBe(0.8);
-        });
-
-        it("should match numerical inverse for Kerr metric", () => {
-            const r = 10, theta = Math.PI / 4, M = 1, a = 0.6;
-            const g = Tensor.kerr(r, theta, M, a);
-            const gInvNumerical = g.inverse();
-            const gInvAnalytical = Tensor.kerrContravariant(r, theta, M, a);
-
-            for (let i = 0; i < 4; i++) {
-                for (let j = 0; j < 4; j++) {
-                    expect(gInvAnalytical.get(i, j)).toBeCloseTo(gInvNumerical.get(i, j), 8);
-                }
-            }
-        });
-
-        it("should compute analytical Christoffel symbols for Schwarzschild", () => {
-            const r = 10, rs = 2, theta = Math.PI / 2;
-            const pos = [0, r, theta, 0];
-            pos._rs = rs;
-
-            const gamma = Tensor.christoffel((p) => Tensor.schwarzschild(p[1], rs, p[2]), pos);
-
-            // factor = 0.8
-            // Gamma^t_tr = rs / (2r^2 * factor) = 2 / (200 * 0.8) = 2 / 160 = 0.0125
-            expect(gamma[0][0][1]).toBeCloseTo(0.0125, 8);
-            expect(gamma[0][1][0]).toBeCloseTo(0.0125, 8);
-        });
-    });
-});

package/test/particle/emitter.test.js

@@ -1,204 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ParticleEmitter } from "../../src/particle/emitter";
-import { Particle } from "../../src/particle/particle";
-
-describe("ParticleEmitter", () => {
-  describe("constructor", () => {
-    it("should initialize with default values", () => {
-      const emitter = new ParticleEmitter();
-
-      expect(emitter.rate).toBe(10);
-      expect(emitter.position).toEqual({ x: 0, y: 0, z: 0 });
-      expect(emitter.spread).toEqual({ x: 0, y: 0, z: 0 });
-      expect(emitter.velocity).toEqual({ x: 0, y: 0, z: 0 });
-      expect(emitter.velocitySpread).toEqual({ x: 0, y: 0, z: 0 });
-      expect(emitter.lifetime).toEqual({ min: 1, max: 2 });
-      expect(emitter.size).toEqual({ min: 1, max: 1 });
-      expect(emitter.color).toEqual({ r: 255, g: 255, b: 255, a: 1 });
-      expect(emitter.shape).toBe("circle");
-      expect(emitter.active).toBe(true);
-    });
-
-    it("should accept custom options", () => {
-      const emitter = new ParticleEmitter({
-        rate: 50,
-        position: { x: 100, y: 200 },
-        velocity: { y: -100 },
-        lifetime: { min: 0.5, max: 1.5 },
-        size: { min: 2, max: 5 },
-        color: { r: 255, g: 0, b: 0, a: 0.8 },
-        shape: "square",
-        active: false,
-      });
-
-      expect(emitter.rate).toBe(50);
-      expect(emitter.position).toEqual({ x: 100, y: 200, z: 0 });
-      expect(emitter.velocity).toEqual({ x: 0, y: -100, z: 0 });
-      expect(emitter.lifetime).toEqual({ min: 0.5, max: 1.5 });
-      expect(emitter.size).toEqual({ min: 2, max: 5 });
-      expect(emitter.color).toEqual({ r: 255, g: 0, b: 0, a: 0.8 });
-      expect(emitter.shape).toBe("square");
-      expect(emitter.active).toBe(false);
-    });
-  });
-
-  describe("emit", () => {
-    it("should initialize particle with emitter settings", () => {
-      const emitter = new ParticleEmitter({
-        position: { x: 100, y: 200, z: 50 },
-        velocity: { x: 10, y: -20, z: 5 },
-        lifetime: { min: 2, max: 2 },
-        size: { min: 3, max: 3 },
-        color: { r: 128, g: 64, b: 32, a: 0.5 },
-        shape: "triangle",
-      });
-
-      const p = new Particle();
-      emitter.emit(p);
-
-      expect(p.x).toBe(100);
-      expect(p.y).toBe(200);
-      expect(p.z).toBe(50);
-      expect(p.vx).toBe(10);
-      expect(p.vy).toBe(-20);
-      expect(p.vz).toBe(5);
-      expect(p.lifetime).toBe(2);
-      expect(p.size).toBe(3);
-      expect(p.color).toEqual({ r: 128, g: 64, b: 32, a: 0.5 });
-      expect(p.shape).toBe("triangle");
-      expect(p.age).toBe(0);
-      expect(p.alive).toBe(true);
-    });
-
-    it("should apply position spread", () => {
-      const emitter = new ParticleEmitter({
-        position: { x: 0, y: 0, z: 0 },
-        spread: { x: 100, y: 100, z: 100 },
-      });
-
-      // Mock Math.random to return predictable values
-      const mockRandom = vi.spyOn(Math, "random");
-      mockRandom.mockReturnValue(0.5); // Mid-point = 0 spread
-
-      const p = new Particle();
-      emitter.emit(p);
-
-      // With Math.random() = 0.5, spread = (0.5 - 0.5) * 2 * spread = 0
-      expect(p.x).toBe(0);
-      expect(p.y).toBe(0);
-      expect(p.z).toBe(0);
-
-      mockRandom.mockRestore();
-    });
-
-    it("should apply velocity spread", () => {
-      const emitter = new ParticleEmitter({
-        velocity: { x: 100 },
-        velocitySpread: { x: 50 },
-      });
-
-      const mockRandom = vi.spyOn(Math, "random");
-      mockRandom.mockReturnValue(0); // (0 - 0.5) * 2 * 50 = -50
-
-      const p = new Particle();
-      emitter.emit(p);
-
-      expect(p.vx).toBe(50); // 100 + (-50)
-
-      mockRandom.mockRestore();
-    });
-
-    it("should randomize lifetime within range", () => {
-      const emitter = new ParticleEmitter({
-        lifetime: { min: 1, max: 3 },
-      });
-
-      const mockRandom = vi.spyOn(Math, "random");
-      mockRandom.mockReturnValue(0.5);
-
-      const p = new Particle();
-      emitter.emit(p);
-
-      expect(p.lifetime).toBe(2); // 1 + 0.5 * (3 - 1)
-
-      mockRandom.mockRestore();
-    });
-
-    it("should randomize size within range", () => {
-      const emitter = new ParticleEmitter({
-        size: { min: 2, max: 10 },
-      });
-
-      const mockRandom = vi.spyOn(Math, "random");
-      mockRandom.mockReturnValue(0.25);
-
-      const p = new Particle();
-      emitter.emit(p);
-
-      expect(p.size).toBe(4); // 2 + 0.25 * (10 - 2)
-
-      mockRandom.mockRestore();
-    });
-  });
-
-  describe("update", () => {
-    it("should return 0 when inactive", () => {
-      const emitter = new ParticleEmitter({ rate: 100, active: false });
-
-      expect(emitter.update(1)).toBe(0);
-    });
-
-    it("should return 0 when rate is 0", () => {
-      const emitter = new ParticleEmitter({ rate: 0 });
-
-      expect(emitter.update(1)).toBe(0);
-    });
-
-    it("should emit particles based on rate", () => {
-      const emitter = new ParticleEmitter({ rate: 10 }); // 10 particles/second
-
-      // 0.2 seconds should spawn 2 particles
-      const count = emitter.update(0.2);
-
-      expect(count).toBe(2);
-    });
-
-    it("should accumulate time between frames", () => {
-      const emitter = new ParticleEmitter({ rate: 10 }); // interval = 0.1s
-
-      // First frame: 0.05s (not enough for a particle)
-      expect(emitter.update(0.05)).toBe(0);
-
-      // Second frame: 0.05s more (total 0.1s = 1 particle)
-      expect(emitter.update(0.05)).toBe(1);
-    });
-
-    it("should handle high frame rates correctly", () => {
-      const emitter = new ParticleEmitter({ rate: 60 });
-
-      // One frame at 60fps = ~0.0167s
-      // At 60 particles/second, interval = 0.0167s, so 1 particle per frame
-      let total = 0;
-      for (let i = 0; i < 60; i++) {
-        total += emitter.update(1 / 60);
-      }
-
-      expect(total).toBe(60);
-    });
-  });
-
-  describe("reset", () => {
-    it("should reset the emission timer", () => {
-      const emitter = new ParticleEmitter({ rate: 10 });
-
-      // Accumulate some time
-      emitter.update(0.05);
-      expect(emitter._timer).toBeGreaterThan(0);
-
-      // Reset
-      emitter.reset();
-
-      expect(emitter._timer).toBe(0);
-    });
-  });
-});