littlejsengine 1.18.4 → 1.18.7

package/src/engineLogo.js

@@ -0,0 +1,146 @@
+/**
+ * LittleJS Engine Logo
+ * - Draws the LittleJS splash screen logo
+ * - Used internally during engine startup
+ */
+
+'use strict';
+
+///////////////////////////////////////////////////////////////////////////////
+function drawEngineLogo(t)
+{
+    const blackAndWhite = 0;
+    const showName = 1;
+
+    // LittleJS Logo and Splash Screen
+    const x = mainContext;
+    const dpr = canvasPixelRatio ?? (devicePixelRatio || 1);
+    const w = mainCanvas.width = innerWidth * dpr;
+    const h = mainCanvas.height = innerHeight * dpr;
+    {
+        // background
+        const p3 = percent(t, 1, .8);
+        const p4 = percent(t, 0, .5);
+        const g = x.createRadialGradient(w/2,h/2,0,w/2,h/2,hypot(w,h)*.6);
+        g.addColorStop(0,hsl(0,0,lerp(0,p3/2,p4),p3).toString());
+        g.addColorStop(1,hsl(0,0,0,p3).toString());
+        x.save();
+        x.fillStyle = g;
+        x.fillRect(0,0,w,h);
+    }
+    const gradient = (X1,Y1,X2,Y2,C,S=1)=>
+    {
+        if (C >= 0)
+        {
+            if (blackAndWhite)
+                x.fillStyle = '#fff';
+            else
+            {
+                const g = x.fillStyle = x.createLinearGradient(X1,Y1,X2,Y2);
+                g.addColorStop(0,color(C,2));
+                g.addColorStop(1,color(C,1));
+            }
+        }
+        else
+            x.fillStyle = '#000';
+        C >= -1 ? (x.fill(), S && x.stroke()) : x.stroke();
+    }
+    const circle = (X,Y,R,A=0,B=2*PI,C,S)=>
+    {
+        x.beginPath();
+        x.arc(X,Y,R,p*A,p*B);
+        gradient(X,Y-R,X,Y+R,C,S);
+    }
+    const rect = (X,Y,W,H,C)=>
+    {
+        x.beginPath();
+        x.rect(X,Y,W,H*p);
+        gradient(X,Y+H,X+W,Y,C);
+    }
+    const poly = (points,C,Y,H)=>
+    {
+        x.beginPath();
+        for (const p of points)
+            x.lineTo(p.x, p.y);
+        x.closePath();
+        gradient(0, Y, 0, Y+H,C);
+    }
+    const color = (c,l)=> l?`hsl(${[.95,.56,.13][c%3]*360} 99%${[0,50,75][l]}%`:'#000';
+
+    // center and fit to screen
+    const alpha = oscillate(1,1,t);
+    const p = percent(alpha, .1, .5);
+    const size = min(6, min(w,h)/99);
+    x.translate(w/2,h/2);
+    x.scale(size,size);
+    x.translate(-40,-35);
+    p < 1 && x.setLineDash([99*p,99]);
+    x.lineJoin = x.lineCap = 'round';
+    x.lineWidth = .1 + p*1.9;
+    //x.strokeStyle='#fff7';
+
+    if (showName)
+    {
+        // engine name text
+        const Y = 54;
+        const s = 'LittleJS';
+        x.font = '900 15.5px arial';
+        x.lineWidth = .1+p*3.9;
+        x.textAlign = 'center';
+        x.textBaseline = 'top';
+        rect(11,Y+1,59,8*p,-1);
+        x.beginPath();
+
+        let w2 = 0;
+        for (let i=0;i<s.length;++i)
+            w2 += x.measureText(s[i]).width;
+        for (let j=2;j--;)
+        for (let i=0,X=40-w2/2;i<s.length;++i)
+        {
+            const w = x.measureText(s[i]).width, X2 = X+w/2;
+            gradient(X2,Y,X2+2,Y+13,i>5?1:0);
+            x[j?'strokeText':'fillText'](s[i],X2,Y+.5,17*p);
+            X += w;
+        }
+
+        x.lineWidth = .1 + p*1.9;
+        rect(3,Y,73,0); // bottom
+    }
+
+    rect(7,15,26,-7,0);   // cab top
+    rect(25,15,8,25,-1);  // cab front
+    rect(10,40,15,-25,1); // cab back
+    rect(14,21,7,9,2);    // cab window
+    rect(38,20,6,-6,2);   // little stack
+
+    // big stack
+    rect(49,20,10,-6,0);
+    const stackPoints = [vec2(44,8),vec2(64,8),vec2(59,8+6*p),vec2(49,8+6*p)];
+    poly(stackPoints,2,8,6*p);
+    rect(44,8,20,-7,0);
+
+    // engine
+    for (let i=5;i--;) circle(59-i*6*p,30,10,0,2*PI,1,0);
+    circle(59,30,4,0,7,2); // light
+
+    // engine outline
+    rect(35,20,24,0);  // top
+    circle(59,30,10);  // front
+    circle(47,30,10,PI/2,PI*3/2); // middle
+    circle(35,30,10,PI/2,PI*3/2); // back
+    rect(7,40,13,7,-1);   // bottom back
+    rect(17,40,43,14,-1); // bottom center
+
+    // wheels
+    for (let i=3;i--;) for (let j=2;j--;) circle(17+15*i,47,j?7:1,0,2*PI,2);
+
+    // cowcatcher
+    for (let i=2;i--;)
+    {
+        let w=6, s=7, o=53+w*p*i
+        const points = [vec2(o+s,54),vec2(o,40),vec2(o+w*p,40),vec2(o+s+w*p,54)];
+        poly(points,0,40,14);
+    }
+
+    x.restore();
+}

package/src/engineMath.js

@@ -153,7 +153,11 @@ function percentLerp(value, percentA, percentB, lerpA, lerpB)
  *  @return {number}
  *  @memberof Math */
 function distanceWrap(valueA, valueB, wrapSize=1)
-{ const d = (valueA - valueB) % wrapSize; return d*2 % wrapSize - d; }
+{
+    ASSERT(wrapSize > 0, 'distanceWrap wrapSize must be > 0');
+    const d = (valueA - valueB) % wrapSize;
+    return d*2 % wrapSize - d;
+}
 
 /** Linearly interpolates between values passed in with wrapping
  *  @param {number} valueA
@@ -470,6 +474,7 @@ class RandomGenerator
      *  @param {number} [seed] - Starting seed or engine default seed */
     constructor(seed = 123456789)
     {
+        ASSERT(seed !== 0, 'RandomGenerator seed must be non-zero (xorshift is fixed at 0)');
         /** @property {number} - random seed */
         this.seed = seed;
     }
@@ -763,8 +768,10 @@ class Vector2
      * @return {Vector2} */
     floor() { return new Vector2(floor(this.x), floor(this.y)); }
 
-    /** Returns a copy of this vector snapped to a grid
-     *  @param {number} grid - grid size to snap to
+    /** Returns a copy of this vector snapped to a grid. Note that `grid` is
+     *  the number of snap steps per unit (so `grid=2` snaps to halves and
+     *  `grid=0.5` snaps to twos), not the cell size.
+     *  @param {number} grid - snap steps per unit
      *  @return {Vector2} */
     snap(grid)
     {

package/src/engineObject.js

@@ -132,10 +132,18 @@ class EngineObject
         const parent = this.parent;
         if (parent)
         {
-            // copy parent pos/angle
+            // compose with parent transform inline to avoid intermediate vector allocs
             const mirror = parent.getMirrorSign();
-            this.pos = this.localPos.multiply(vec2(mirror,1)).rotate(parent.angle).add(parent.pos);
-            this.angle = mirror*this.localAngle + parent.angle;
+            const lp = this.localPos, pp = parent.pos;
+            const lx = lp.x*mirror, ly = lp.y, pa = parent.angle;
+            if (pa)
+            {
+                const c = cos(-pa), s = sin(-pa);
+                this.pos = new Vector2(lx*c - ly*s + pp.x, lx*s + ly*c + pp.y);
+            }
+            else
+                this.pos = new Vector2(lx + pp.x, ly + pp.y);
+            this.angle = mirror*this.localAngle + pa;
         }
 
         // update children
@@ -501,8 +509,6 @@ class EngineObject
      *  @return {string} */
     toString()
     {
-        if (!debug) return;
-        
         let text = 'type = ' + this.constructor.name;
         if (this.pos.x || this.pos.y)
             text += '\npos = ' + this.pos;

package/src/engineParticles.js

@@ -315,11 +315,14 @@ class ParticleEmitter extends EngineObject
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// scratch vector reused by Particle.render to avoid per-frame allocations
+const particleDrawPos = new Vector2;
+
 /**
  * Particle Object - Created automatically by Particle Emitters
  * @memberof Particles
  */
-class Particle 
+class Particle
 {
     /**
      * Create a particle with the passed in settings
@@ -494,14 +497,14 @@ class Particle
         additive && setBlendMode(true);
 
         // update the position and angle for drawing
-        const pos = this.pos.copy();
+        const pos = particleDrawPos.set(this.pos.x, this.pos.y);
         let angle = this.angle;
         if (localSpace)
         {
             // in local space of emitter
             const a = emitter.angle;
             const c = cos(a), s = sin(a);
-            pos.set(emitter.pos.x + pos.x*c - pos.y*s, 
+            pos.set(emitter.pos.x + pos.x*c - pos.y*s,
                 emitter.pos.y + pos.x*s + pos.y*c);
             angle += a;
         }

package/src/engineRelease.js

@@ -18,7 +18,7 @@ const debugPhysics = 0;
 const debugParticles = 0;
 const debugRaycast = 0;
 const debugGamepads = 0;
-const debugMedals = 0;
+const debugPointSize = .5;
 
 // debug commands are automatically removed from the final build
 function ASSERT          (){}

package/src/engineSettings.js

@@ -322,33 +322,6 @@ let soundDefaultRange = 40;
  *  @memberof Settings */
 let soundDefaultTaper = .7;
 
-///////////////////////////////////////////////////////////////////////////////
-// Medals settings
-
-/** How long to show medals for in seconds
- *  @type {number}
- *  @default
- *  @memberof Settings */
-let medalDisplayTime = 5;
-
-/** How quickly to slide on/off medals in seconds
- *  @type {number}
- *  @default
- *  @memberof Settings */
-let medalDisplaySlideTime = .5;
-
-/** Size of medal display
- *  @type {Vector2}
- *  @default Vector2(640,80)
- *  @memberof Settings */
-let medalDisplaySize = vec2(640, 80);
-
-/** Set to stop medals from being unlockable (like if cheats are enabled)
- *  @type {boolean}
- *  @default
- *  @memberof Settings */
-let medalsPreventUnlock = false;
-
 ///////////////////////////////////////////////////////////////////////////////
 // Setters for global variables
 
@@ -610,26 +583,6 @@ function setSoundDefaultRange(range) { soundDefaultRange = range; }
  *  @memberof Settings */
 function setSoundDefaultTaper(taper) { soundDefaultTaper = taper; }
 
-/** Set how long to show medals for in seconds
- *  @param {number} time
- *  @memberof Settings */
-function setMedalDisplayTime(time) { medalDisplayTime = time; }
-
-/** Set how quickly to slide on/off medals in seconds
- *  @param {number} time
- *  @memberof Settings */
-function setMedalDisplaySlideTime(time) { medalDisplaySlideTime = time; }
-
-/** Set size of medal display
- *  @param {Vector2} size
- *  @memberof Settings */
-function setMedalDisplaySize(size) { medalDisplaySize = size.copy(); }
-
-/** Set to stop medals from being unlockable
- *  @param {boolean} preventUnlock
- *  @memberof Settings */
-function setMedalsPreventUnlock(preventUnlock) { medalsPreventUnlock = preventUnlock; }
-
 /** Set if watermark with FPS should be shown
  *  @param {boolean} show
  *  @memberof Debug */

package/src/engineUtilities.js

@@ -190,9 +190,14 @@ function readSaveData(saveName, defaultSaveData)
 {
     ASSERT(isString(saveName), 'loadData requires saveName string');
     
-    // replace undefined values with defaults
+    // replace undefined values with defaults; tolerate corrupt JSON
     const data = localStorage[saveName];
-    const loadedData = data ? JSON.parse(data) : {};
+    let loadedData = {};
+    if (data)
+    {
+        try { loadedData = JSON.parse(data); }
+        catch { LOG('readSaveData: corrupt JSON for', saveName, '— using defaults'); }
+    }
     return { ...defaultSaveData, ...loadedData };
 }
 

package/src/engineWebGL.js

@@ -99,7 +99,7 @@ function glInit(rootElement)
         // reinit WebGL and restore textures
         initWebGL();
         for (const info of glTextureInfos)
-            info.glTexture = glCreateTexture(info.image);
+            info.glTexture = glCreateTexture(info.image, info.wrap);
         pluginList.forEach(plugin=>plugin.glContextRestored?.());
     });
 
@@ -315,6 +315,30 @@ function glSetTexture(texture)
     glContext.bindTexture(glContext.TEXTURE_2D, glActiveTexture);
 }
 
+/** Set the wrap mode (REPEAT or CLAMP_TO_EDGE) on an existing WebGL texture
+ *  Flushes the current batch only if the texture is the active one
+ *  @param {WebGLTexture} texture
+ *  @param {boolean} [wrap] - true for REPEAT, false for CLAMP_TO_EDGE
+ *  @memberof WebGL */
+function glSetTextureWrap(texture, wrap=true)
+{
+    if (!glContext || !texture) return;
+
+    // flush only if changing wrap on the currently bound texture
+    const isCurrent = texture === glActiveTexture;
+    if (isCurrent)
+        glFlush();
+    else
+        glContext.bindTexture(glContext.TEXTURE_2D, texture);
+
+    const wrapMode = wrap ? glContext.REPEAT : glContext.CLAMP_TO_EDGE;
+    glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_WRAP_S, wrapMode);
+    glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_WRAP_T, wrapMode);
+
+    if (!isCurrent && glActiveTexture)
+        glContext.bindTexture(glContext.TEXTURE_2D, glActiveTexture);
+}
+
 /** Compile WebGL shader of the given type, will throw errors if in debug mode
  *  @param {string} source
  *  @param {number} type
@@ -359,9 +383,10 @@ function glCreateProgram(vsSource, fsSource)
 /** Create WebGL texture from an image and init the texture settings
  *  Restores the active texture when done
  *  @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas} [image]
+ *  @param {boolean} [wrap] - true for REPEAT, false for CLAMP_TO_EDGE
  *  @return {WebGLTexture}
  *  @memberof WebGL */
-function glCreateTexture(image)
+function glCreateTexture(image, wrap=false)
 {
     if (!glContext) return;
 
@@ -387,8 +412,9 @@ function glCreateTexture(image)
     const minFilter = mipMap ? glContext.LINEAR_MIPMAP_LINEAR : magFilter;
     glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_MAG_FILTER, magFilter);
     glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_MIN_FILTER, minFilter);
-    glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_WRAP_S, glContext.REPEAT);
-    glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_WRAP_T, glContext.REPEAT);
+    const wrapMode = wrap ? glContext.REPEAT : glContext.CLAMP_TO_EDGE;
+    glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_WRAP_S, wrapMode);
+    glContext.texParameteri(glContext.TEXTURE_2D, glContext.TEXTURE_WRAP_T, wrapMode);
     if (mipMap)
         glContext.generateMipmap(glContext.TEXTURE_2D);
 
@@ -440,7 +466,7 @@ function glRegisterTextureInfo(textureInfo)
     if (textureInfo.glTexture)
         glSetTextureData(textureInfo.glTexture, textureInfo.image);
     else
-        textureInfo.glTexture = glCreateTexture(textureInfo.image);
+        textureInfo.glTexture = glCreateTexture(textureInfo.image, textureInfo.wrap);
 }
 
 /** Tells WebGL to destroy the glTexture and stop tracking it
@@ -659,6 +685,7 @@ function glSetRenderTarget(texture, clear=false)
         glFlush();
         glRenderTarget = undefined;
         glContext.bindFramebuffer(glContext.FRAMEBUFFER, null);
+        glContext.viewport(0, 0, mainCanvasSize.x, mainCanvasSize.y);
     }
 }
 
@@ -781,9 +808,9 @@ function glPolyStrip(points)
         return area;
     }
 
-    // ensure counter-clockwise winding
+    // ensure counter-clockwise winding (slice first so we don't mutate caller's array)
     if (signedArea(points) < 0)
-        points = points.reverse();
+        points = points.slice().reverse();
 
     // check if point is inside triangle
     const e = 1e-9;

package/src/jsconfig.json

@@ -2,7 +2,9 @@
   "compilerOptions": {
     "checkJs": true,
     "target": "ES2020",
-    "module": "esnext"
+    "module": "esnext",
+    "noImplicitAny": false,
+    "strict": false
   },
   "exclude": [
     "engineRelease.js",

package/.github/workflows/test.yml

@@ -1,17 +0,0 @@
-name: Test
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-      - uses: actions/setup-node@v5
-        with:
-          node-version: '22'
-      - run: npm install
-      - run: npm run build
-      - run: npm test

package/AI.md

@@ -1,173 +0,0 @@
-# LittleJS Project - AI Agent Instructions
-
-These instructions are for making changes in the LittleJS repo safely. Optimize for small diffs, clarity, and ease of use.
-
-## Non-negotiable rules
-
-- **Prefer minimal, local changes.** Do not refactor for style unless asked.
-- **No new runtime dependencies.** Keep LittleJS dependency-free at runtime.
-- **Do not hand-edit generated build artifacts.**
-  - Treat `dist/` as generated output.
-  - Make changes in `src/` (and `plugins/` when appropriate), then run the build.
-- **Match surrounding style.** Follow the conventions in the files you touch.
-- **Avoid breaking public APIs.** If a change could break users, call it out clearly and offer a compatible alternative.
-
-If anything in this doc conflicts with the actual repo behavior, follow the repo behavior and update this doc.
-
-## Key resources
-
-- `README.md` - Overview and getting started
-- `reference.md` - API quick reference
-- `examples/` - Working examples demonstrating engine features
-
-## Architecture overview
-
-LittleJS is a modular HTML5 game engine with:
-
-- **Core engine**: `src/engine*.js` (main loop, objects, rendering, physics, input, etc.)
-- **Plugins**: `plugins/*.js` (optional features like Box2D, post-processing, UI, audio helpers, etc.)
-- **Build system**: `src/engineBuild.mjs` (concatenates modules into distributable bundles)
-
-## Repo structure and file types
-
-### Engine source (`src/*.js`)
-- Modular architecture (one subsystem per file)
-- Concatenated at build time (internal source does not use ES modules)
-- Code is vanilla JavaScript with type info expressed via JSDoc comments
-
-### Build output (`dist/`)
-Common outputs include:
-- `littlejs.js` - Full bundle (debug features included)
-- `littlejs.release.js` - Production bundle (debug stripped)
-- `littlejs.esm.js` - ES module build (import/export)
-- `littlejs.esm.min.js` - Minified ES module
-- `littlejs.d.ts` - TypeScript definitions
-
-Use via script tag or ES module import:
-- `<script src="dist/littlejs.js"></script>`
-- `import * as LJS from './dist/littlejs.esm.js'`
-
-Prefer adding new optional features as plugins when it keeps the core simpler.
-
-### Examples
-- `examples/starter/` - Plain JavaScript global usage via `<script>` (recommended starting point)
-- `examples/module/` - ES module import pattern
-- `examples/typescript/` - TypeScript example usage
-- `examples/shorts/*.js` - Single-file demos loaded by the shorts harness
-
-### Short examples (`examples/shorts/*.js`)
-Short examples are special:
-- Pure JS code file, no HTML
-- No imports, do not use LJS namespace - engine APIs are available globally
-- Override hooks: `gameInit()`, `gameUpdate()`, `gameUpdatePost()`, `gameRender()`, `gameRenderPost()`
-
-## Coding conventions
-
-### Factory functions vs constructors
-Prefer factory functions for core types:
-- `vec2(x, y)` not `new Vector2(x, y)`
-- `rgb(r, g, b, a)` or `hsl(h, s, l, a)` not `new Color(...)`
-- `tile(index, size)` for tile info
-
-Use constructors for game objects and complex types:
-- `new EngineObject(pos, size)`
-- `new ParticleEmitter(...)`
-- `new Sound(zzfxParams)`
-- `new Timer(duration)`
-
-### Naming
-- `camelCase` for variables and functions
-- `PascalCase` for classes
-- `UPPER_CASE` for constants that are truly constant (like `PI`)
-
-### Code style
-- Use JSDoc with `@memberof` grouping (namespaces: Engine, Math, Draw, Input, Audio, Debug, Settings, etc.)
-- Prefer single-line comments: `// comment`
-- Use `ASSERT(condition, 'error message')` for validation (stripped in release)
-- Use `LOG(...)` for debug output (stripped in release)
-
-### Type checking
-Use built-in type helpers for validation:
-```javascript
-isNumber(n)   // true if number and not NaN
-isString(s)   // true if not null/undefined (has toString)
-isArray(a)    // true if array
-isVector2(v)  // true if valid Vector2
-isColor(c)    // true if valid Color
-```
-
-### Global variables
-- Engine time: `time`, `timeReal`, `frame`, `timeDelta`
-- Camera: `cameraPos`, `cameraScale`, `cameraAngle`
-- Input: `mousePos`, `mousePosScreen`, `mouseWheel`
-- State: `paused`, `debug`, `debugOverlay`
-- Settings are in `engineSettings.js` with corresponding setter functions
-
-## Common patterns
-
-### Game structure
-```javascript
-function gameInit() { }       // Called once after engine starts
-function gameUpdate() { }     // Called every frame for game logic
-function gameUpdatePost() { } // Called after physics, even when paused
-function gameRender() { }     // Called before objects render
-function gameRenderPost() { } // Called after objects render
-
-engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, ['tiles.png']);
-```
-
-### Creating objects
-```javascript
-class Player extends EngineObject {
-    constructor(pos) {
-        super(pos, vec2(1), tile(0, 16));
-        this.setCollision();
-    }
-    update() {
-        super.update();
-        // custom logic
-    }
-}
-```
-
-### Common drawing functions
-```javascript
-drawRect(pos, size, color)              // solid rectangle
-drawTile(pos, size, tileInfo, color)    // sprite from tile sheet
-drawText(text, pos, size, color)        // text rendering
-drawLine(posA, posB, thickness, color)  // line between points
-drawEllipse(pos, size, color)           // filled ellipse
-```
-
-## Common pitfalls
-
-- **New public APIs must be added to `src/engineExport.js`** - Variables and functions added to engine source files are accessible in script-tag builds automatically, but the ESM build (`littlejs.esm.js`) and TypeScript definitions (`littlejs.d.ts`) only include what's listed in `engineExport.js`. Plugin exports go in `plugins/pluginExport.js`. Forgetting this means ESM/TS users can't access the new API.
-- **ASSERT and LOG are stripped in release builds** - Don't rely on side effects
-- **Don't modify constant colors** - `WHITE`, `BLACK`, `RED`, etc. are frozen; use `.copy()` first
-- **Time variables are global** - `time`, `frame` update automatically each frame
-- **Fixed 60 FPS timestep** - Physics runs at 60 FPS regardless of display refresh rate
-- **WebGL is enabled by default** - Set `glEnable = false` before `engineInit()` for Canvas2D only
-- **Tile coordinates are bottom-left origin** - Y increases upward in world space
-
-## Developer workflows
-
-### Build
-```bash
-npm run build
-```
-
-### Testing
-```bash
-npm test
-```
-
-- Tests target `dist/littlejs.esm.js` — rebuild with `npm run build` after changing source.
-- [test/setup.mjs](test/setup.mjs) stubs minimal DOM and enables headless mode. Tests shouldn't call `engineInit`, `render()`, or assume `time` advances.
-- Zero test dependencies — uses Node's built-in `node --test`. Match the style in [test/](test/) when adding new ones.
-- CI runs build + test on every push/PR ([.github/workflows/test.yml](.github/workflows/test.yml)).
-
-### Debug features
-- Press `Esc` to toggle debug overlay
-- Number keys toggle visualizations
-- `+`/`-` keys control time scale
-- Debug functions: `debugRect()`, `debugCircle()`, `debugLine()`, `debugText()`

package/CLAUDE.md

@@ -1 +0,0 @@
-See @AI.md for instructions.