hypercube-compute 2.0.0

package/docs/assets/index-BLyglqQr.js

@@ -0,0 +1 @@
+var U=Object.defineProperty;var G=(t,s,c)=>s in t?U(t,s,{enumerable:!0,configurable:!0,writable:!0,value:c}):t[s]=c;var w=(t,s,c)=>G(t,typeof s!="symbol"?s+"":s,c);(function(){const s=document.createElement("link").relList;if(s&&s.supports&&s.supports("modulepreload"))return;for(const e of document.querySelectorAll('link[rel="modulepreload"]'))n(e);new MutationObserver(e=>{for(const o of e)if(o.type==="childList")for(const g of o.addedNodes)g.tagName==="LINK"&&g.rel==="modulepreload"&&n(g)}).observe(document,{childList:!0,subtree:!0});function c(e){const o={};return e.integrity&&(o.integrity=e.integrity),e.referrerPolicy&&(o.referrerPolicy=e.referrerPolicy),e.crossOrigin==="use-credentials"?o.credentials="include":e.crossOrigin==="anonymous"?o.credentials="omit":o.credentials="same-origin",o}function n(e){if(e.ep)return;e.ep=!0;const o=c(e);fetch(e.href,o)}})();var Z=class{constructor(t=100*1024*1024){w(this,"buffer");w(this,"offset",0);this.buffer=new ArrayBuffer(t)}allocateCube(t,s=6){const e=t*t*Float32Array.BYTES_PER_ELEMENT*s;if(this.offset+e>this.buffer.byteLength)throw new Error(`[TriadeMasterBuffer] Out Of Memory. Impossible d'allouer ${e} bytes supplémentaires.`);const o=this.offset;return this.offset+=e,o}getUsedMemoryInMB(){return(this.offset/(1024*1024)).toFixed(2)+" MB"}},H=class{constructor(t,s,c=6){w(this,"mapSize");w(this,"faces",[]);w(this,"offset");w(this,"engine",null);this.mapSize=t,this.offset=s.allocateCube(t,c);const n=t*t,e=n*Float32Array.BYTES_PER_ELEMENT;for(let o=0;o<c;o++)this.faces.push(new Float32Array(s.buffer,this.offset+o*e,n))}setEngine(t){this.engine=t}compute(){if(!this.engine){console.warn("[TriadeCubeV2] Aucun Engine (Cerveau) n'a été assigné à ce cube.");return}this.engine.compute(this.faces,this.mapSize)}clearFace(t){this.faces[t].fill(0)}},K=class{constructor(t,s,c,n,e,o=6,g=!0){w(this,"cubes",[]);w(this,"cols");w(this,"rows");w(this,"cubeSize");w(this,"isPeriodic");this.cols=t,this.rows=s,this.cubeSize=c,this.isPeriodic=g;for(let l=0;l<s;l++){this.cubes[l]=[];for(let u=0;u<t;u++){const h=new H(c,n,o);h.setEngine(e()),this.cubes[l][u]=h}}}compute(t=0){var c;for(let n=0;n<this.rows;n++)for(let e=0;e<this.cols;e++)(c=this.cubes[n][e])==null||c.compute();const s=Array.isArray(t)?t:[t];for(const n of s)this.synchronizeBoundaries(n)}synchronizeBoundaries(t){const s=this.cubeSize,c=s-1,n=s-2;for(let e=0;e<this.rows;e++)for(let o=0;o<this.cols;o++){const l=this.cubes[e][o].faces[t];if(o<this.cols-1||this.isPeriodic){const h=this.cubes[e][(o+1)%this.cols].faces[t];for(let d=1;d<c;d++)h[d*s+0]=l[d*s+n]}if(o>0||this.isPeriodic){const h=this.cubes[e][(o-1+this.cols)%this.cols].faces[t];for(let d=1;d<c;d++)h[d*s+c]=l[d*s+1]}}for(let e=0;e<this.rows;e++)for(let o=0;o<this.cols;o++){const l=this.cubes[e][o].faces[t];(e<this.rows-1||this.isPeriodic)&&this.cubes[(e+1)%this.rows][o].faces[t].set(l.subarray(n*s,n*s+s),0),(e>0||this.isPeriodic)&&this.cubes[(e-1+this.rows)%this.rows][o].faces[t].set(l.subarray(1*s,1*s+s),c*s)}}},V=class{constructor(){w(this,"dragScore",0);w(this,"initialized",!1)}get name(){return"Lattice Boltzmann D2Q9 (O(1))"}compute(t,s){const c=s,n=t[18],e=t[19],o=t[20],g=t[21],l=[0,1,0,-1,0,1,-1,-1,1],u=[0,0,1,0,-1,1,1,-1,-1],h=[4/9,1/9,1/9,1/9,1/9,1/36,1/36,1/36,1/36],d=[0,3,4,1,2,7,8,5,6],v=.12,_=1.95;if(!this.initialized){for(let i=0;i<c*c;i++){const a=v,p=0,y=a*a+p*p;for(let x=0;x<9;x++){const P=l[x]*a+u[x]*p,r=h[x]*1*(1+3*P+4.5*P*P-1.5*y);t[x][i]=r,t[x+9][i]=r}}this.initialized=!0}let m=0;for(let i=1;i<c-1;i++)for(let b=1;b<c-1;b++){const a=i*c+b;if(n[a]>0){for(let r=1;r<9;r++){const E=b-l[r],B=(i-u[r])*c+E;t[d[r]+9][B]=t[r][B],r===1&&(m+=t[1][B])}e[a]=0,o[a]=0;continue}let p=0,y=0,x=0;for(let r=0;r<9;r++){const E=t[r][a];p+=E,y+=l[r]*E,x+=u[r]*E}b===1&&(y=v*p,x=0),p>0&&(y/=p,x/=p),e[a]=y,o[a]=x;const P=y*y+x*x;for(let r=0;r<9;r++){const E=l[r]*y+u[r]*x,N=h[r]*p*(1+3*E+4.5*E*E-1.5*P),B=t[r][a]*(1-_)+N*_;let Y=b+l[r],S=i+u[r];S<1?S=c-2:S>c-2&&(S=1),Y>c-2&&(Y=c-2),t[r+9][S*c+Y]=B}}for(let i=0;i<9;i++)t[i].set(t[i+9]);this.dragScore=this.dragScore*.9+m*1e3*.1;for(let i=1;i<c-1;i++)for(let b=1;b<c-1;b++){const a=i*c+b,p=o[a+1]-o[a-1],y=e[a+c]-e[a-c];g[a]=p-y}}};const M=document.getElementById("triade-canvas"),I=M.getContext("2d"),D=2,F=2,f=64,L=D*f,O=F*f,W=new Z,A=new K(D,F,f,W,()=>new V,22,!0),Q=L/2,$=O/2,T=15;for(let t=0;t<F;t++)for(let s=0;s<D;s++){const c=A.cubes[t][s];if(!c)continue;const n=c.faces[18];for(let e=0;e<f;e++)for(let o=0;o<f;o++){const g=s*f+o,l=t*f+e;(g-Q)**2+(l-$)**2<T*T?n[e*f+o]=1:n[e*f+o]=0}}let q=!1;M.addEventListener("mousedown",t=>{q=!0,X(t)});window.addEventListener("mouseup",()=>q=!1);M.addEventListener("mousemove",t=>{q&&X(t)});function X(t){var g;const s=M.getBoundingClientRect(),c=L/s.width,n=O/s.height,e=Math.floor((t.clientX-s.left)*c),o=Math.floor((t.clientY-s.top)*n);if(e>=0&&e<L&&o>=0&&o<O){const l=Math.floor(e/f),u=Math.floor(o/f),h=e%f,d=o%f,v=(g=A.cubes[u])==null?void 0:g[l];if(!v)return;const _=2;for(let m=-_;m<=_;m++)for(let i=-_;i<=_;i++){const b=h+i,a=d+m;b>=0&&b<f&&a>=0&&a<f&&(v.faces[18][a*f+b]=1)}}}const z=I.createImageData(L,O),C=z.data;function R(){requestAnimationFrame(R),A.compute([0,1,2,3,4,5,6,7,8,18,19,20,21]);for(let s=0;s<F;s++)for(let c=0;c<D;c++){const n=A.cubes[s][c];if(!n)continue;const e=n.faces[18],o=n.faces[19],g=n.faces[20],l=n.faces[21];for(let u=0;u<f;u++)for(let h=0;h<f;h++){const d=u*f+h,v=c*f+h,m=((s*f+u)*L+v)*4;if(e[d]>.5)C[m]=150,C[m+1]=150,C[m+2]=150,C[m+3]=255;else{const i=l[d],b=o[d]**2+g[d]**2,a=Math.max(0,i*2e4),p=Math.max(0,-i*2e4),y=Math.min(255,b*1e4);C[m]=Math.min(255,a+y*.2),C[m+1]=Math.min(255,y*.5),C[m+2]=Math.min(255,p+y),C[m+3]=255}}}const t=document.createElement("canvas");t.width=L,t.height=O,t.getContext("2d").putImageData(z,0,0),I.clearRect(0,0,M.width,M.height),I.imageSmoothingEnabled=!1,I.drawImage(t,0,0,M.width,M.height)}R();

package/docs/index.html

@@ -0,0 +1,78 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Triade Engine Demo</title>
+    <style>
+        body,
+        html {
+            margin: 0;
+            padding: 0;
+            background: #0a0a0a;
+            color: white;
+            font-family: 'Inter', sans-serif;
+            height: 100vh;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            overflow: hidden;
+        }
+
+        canvas {
+            box-shadow: 0 0 40px rgba(0, 255, 136, 0.1);
+            border-radius: 8px;
+            border: 1px solid #222;
+            image-rendering: pixelated;
+            width: 512px;
+            height: 512px;
+            background: #111;
+        }
+
+        .header {
+            margin-bottom: 25px;
+            text-align: center;
+            z-index: 10;
+        }
+
+        h1 {
+            margin: 0;
+            font-size: 28px;
+            color: #00ff88;
+            letter-spacing: -0.5px;
+            font-weight: 600;
+        }
+
+        p {
+            margin: 8px 0 0;
+            color: #888;
+            font-size: 15px;
+        }
+
+        .tag {
+            display: inline-block;
+            padding: 4px 10px;
+            border-radius: 12px;
+            background: rgba(0, 255, 136, 0.1);
+            color: #00ff88;
+            font-size: 12px;
+            font-weight: bold;
+            margin-bottom: 15px;
+        }
+    </style>
+  <script type="module" crossorigin src="./assets/index-BLyglqQr.js"></script>
+</head>
+
+<body>
+    <div class="header">
+        <div class="tag">Zero-Allocation Compute</div>
+        <h1>🌊 Triade GodMode O(1)</h1>
+        <p>Lattice Boltzmann (LBM D2Q9) Fluid Mechanics Simulation.<br /><b>Click & Drag</b> on the grid to draw solid
+            walls. The fluid flows from Left to Right!</p>
+    </div>
+    <canvas id="triade-canvas" width="512" height="512"></canvas>
+</body>
+
+</html>

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "hypercube-compute",
+  "version": "2.0.0",
+  "description": "A high-performance O(1) tensor-based compute engine for Web and Node.js environments.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "tensor",
+    "compute",
+    "O(1)",
+    "engine",
+    "physics",
+    "webassembly",
+    "web-workers",
+    "lattice-boltzmann"
+  ],
+  "author": "Helron1977",
+  "license": "MIT",
+  "devDependencies": {
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3"
+  }
+}

package/src/Triade.ts

@@ -0,0 +1,45 @@
+import { TriadeMasterBuffer } from './core/TriadeMasterBuffer';
+import { TriadeCubeV2 } from './core/TriadeCubeV2';
+import type { ITriadeEngine } from './engines/ITriadeEngine';
+
+/**
+ * Chef d'orchestre de la V2. 
+ * Il possède la VRAM globale partagée et gère les instanciations de Cubes sans fragmentation RAM.
+ */
+export class Triade {
+    private _masterBuffer: TriadeMasterBuffer;
+    public cubes: Map<string, TriadeCubeV2> = new Map();
+
+    get masterBuffer() {
+        return this._masterBuffer;
+    }
+
+    /**
+     * @param vRamAllocMegabytes Taille du ArrayBuffer en Mega-Octets (par defaut 50MB)
+     */
+    constructor(vRamAllocMegabytes: number = 50) {
+        this._masterBuffer = new TriadeMasterBuffer(vRamAllocMegabytes * 1024 * 1024);
+        console.log(`[Triade.js SDK] Initialized with ${vRamAllocMegabytes}MB of Raw Buffer Memory.`);
+    }
+
+    /**
+     * Forge un nouveau Cube (View Paging) depuis le Buffer Maître.
+     */
+    public createCube(name: string, mapSize: number, engine: ITriadeEngine, numFaces: number = 6): TriadeCubeV2 {
+        if (this.cubes.has(name)) {
+            throw new Error(`Cube avec le nom ${name} existe déjà.`);
+        }
+
+        const cube = new TriadeCubeV2(mapSize, this._masterBuffer, numFaces);
+        cube.setEngine(engine);
+        this.cubes.set(name, cube);
+        return cube;
+    }
+
+    /**
+     * Accès sécurisé à un cube pour UI/Render logic.
+     */
+    public getCube(id: string): TriadeCubeV2 | undefined {
+        return this.cubes.get(id);
+    }
+}

package/src/addons/ocean-simulation/OceanEngine.ts

@@ -0,0 +1,208 @@
+import type { ITriadeEngine } from '../../engines/ITriadeEngine';
+
+export interface OceanEngineParams {
+    tau_0: number;
+    smagorinsky: number;
+    cflLimit: number;
+    bioDiffusion: number;
+    bioGrowth: number;
+    vortexRadius: number;
+    vortexStrength: number;
+}
+
+export class OceanEngine implements ITriadeEngine {
+    public readonly name = "OceanEngine";
+
+    // Re-use lab-perfect constants
+    private readonly w = [4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36];
+    private readonly cx = [0, 1, 0, -1, 0, 1, -1, -1, 1];
+    private readonly cy = [0, 0, 1, 0, -1, 1, 1, -1, -1];
+    private readonly opp = [0, 3, 4, 1, 2, 7, 8, 5, 6];
+
+    // Caches to avoid per-frame allocations
+    private feq_cache = new Float32Array(9);
+    private pulled_f = new Float32Array(9);
+
+    public params: OceanEngineParams = {
+        tau_0: 0.8,
+        smagorinsky: 0.2,
+        cflLimit: 0.38,
+        bioDiffusion: 0.05,
+        bioGrowth: 0.0005,
+        vortexRadius: 28,
+        vortexStrength: 0.02
+    };
+
+    public stats = {
+        maxU: 0,
+        avgTau: 0
+    };
+
+    // UI Input simulation (will be fed by the high-level framework/addon)
+    public interaction = {
+        mouseX: 0,
+        mouseY: 0,
+        active: false
+    };
+
+    constructor() { }
+
+    /**
+     * Entry point: Orchestrates LBM and Bio steps
+     */
+    compute(faces: Float32Array[], size: number): void {
+        this.stepLBM(faces, size);
+        this.stepBio(faces, size);
+    }
+
+    private stepLBM(m: Float32Array[], size: number): void {
+        const rho = m[20], ux = m[18], uy = m[19], obst = m[22];
+
+        let maxU = 0;
+        let sumTau = 0;
+        let activeCells = 0;
+
+        // 0. CLEAR NEXT FRAME BUFFERS
+        for (let k = 0; k < 9; k++) m[k + 9].fill(0);
+
+        const mx = this.interaction.mouseX;
+        const my = this.interaction.mouseY;
+        const isForcing = this.interaction.active;
+        const vr2 = this.params.vortexRadius * this.params.vortexRadius;
+
+        // 1. PULL-STREAMING & COLLISION (O1 Optimized)
+        // We only compute inner domain. Ghost cells (0 and size-1) are managed by Grid Boundary Exchange.
+        for (let y = 1; y < size - 1; y++) {
+            for (let x = 1; x < size - 1; x++) {
+                const i = y * size + x;
+
+                if (obst[i] > 0.5) {
+                    for (let k = 0; k < 9; k++) m[k + 9][i] = this.w[k];
+                    continue;
+                }
+
+                // --- PULL STREAMING ---
+                let r = 0, vx = 0, vy = 0;
+
+                for (let k = 0; k < 9; k++) {
+                    const nx = x - this.cx[k];
+                    const ny = y - this.cy[k];
+
+                    const ni = ny * size + nx;
+                    if (obst[ni] > 0.5) {
+                        this.pulled_f[k] = m[this.opp[k]][i]; // Bounce back against internal obstacles
+                    } else {
+                        this.pulled_f[k] = m[k][ni]; // Stream from adjacent cell (can be Ghost Cell)
+                    }
+
+                    r += this.pulled_f[k];
+                    vx += this.pulled_f[k] * this.cx[k];
+                    vy += this.pulled_f[k] * this.cy[k];
+                }
+
+                // Stability Clamping
+                let isShockwave = false;
+                if (r < 0.8) { r = 0.8; isShockwave = true; }
+                else if (r > 1.2) { r = 1.2; isShockwave = true; }
+                else if (r < 0.0001) r = 0.0001;
+
+                vx /= r;
+                vy /= r;
+
+                // Vortex Forcing
+                if (isForcing) {
+                    const dx = x - mx;
+                    const dy = y - my;
+                    const dist2 = dx * dx + dy * dy;
+                    if (dist2 < vr2) {
+                        const forceScale = this.params.vortexStrength * 0.005 * (1.0 - Math.sqrt(dist2) / this.params.vortexRadius);
+                        vx += -dy * forceScale;
+                        vy += dx * forceScale;
+                    }
+                }
+
+                const v2 = vx * vx + vy * vy;
+                const speed = Math.sqrt(v2);
+                if (speed > maxU) maxU = speed;
+
+                let u2_clamped = v2;
+                if (speed > this.params.cflLimit) {
+                    const scale = this.params.cflLimit / speed;
+                    vx *= scale;
+                    vy *= scale;
+                    u2_clamped = vx * vx + vy * vy;
+                    isShockwave = true;
+                }
+
+                // Store Macros
+                rho[i] = r;
+                ux[i] = vx;
+                uy[i] = vy;
+
+                // --- COLLISION ---
+                if (isShockwave) {
+                    for (let k = 0; k < 9; k++) {
+                        const cu = 3 * (this.cx[k] * vx + this.cy[k] * vy);
+                        m[k + 9][i] = this.w[k] * r * (1 + cu + 0.5 * cu * cu - 1.5 * u2_clamped);
+                    }
+                } else {
+                    let Pxx = 0, Pyy = 0, Pxy = 0;
+
+                    for (let k = 0; k < 9; k++) {
+                        const cu = 3 * (this.cx[k] * vx + this.cy[k] * vy);
+                        this.feq_cache[k] = this.w[k] * r * (1 + cu + 0.5 * cu * cu - 1.5 * u2_clamped);
+
+                        const fneq = this.pulled_f[k] - this.feq_cache[k];
+                        Pxx += fneq * this.cx[k] * this.cx[k];
+                        Pyy += fneq * this.cy[k] * this.cy[k];
+                        Pxy += fneq * this.cx[k] * this.cy[k];
+                    }
+
+                    const S_norm = Math.sqrt(2 * (Pxx * Pxx + Pyy * Pyy + 2 * Pxy * Pxy));
+                    let tau_eff = this.params.tau_0 + this.params.smagorinsky * S_norm;
+                    if (isNaN(tau_eff) || tau_eff < 0.505) tau_eff = 0.505;
+
+                    sumTau += tau_eff;
+                    activeCells++;
+
+                    for (let k = 0; k < 9; k++) {
+                        m[k + 9][i] = this.pulled_f[k] - (this.pulled_f[k] - this.feq_cache[k]) / tau_eff;
+                    }
+                }
+            }
+        }
+
+        if (activeCells > 0) this.stats.avgTau = sumTau / activeCells;
+        this.stats.maxU = maxU;
+
+        // 4. MEMORY SWAP
+        for (let k = 0; k < 9; k++) {
+            const tmp = m[k];
+            m[k] = m[k + 9];
+            m[k + 9] = tmp;
+        }
+    }
+
+    private stepBio(m: Float32Array[], size: number): void {
+        const bio = m[21];
+        const bio_next = m[17]; // Proxy temp
+        const area = size * size;
+
+        for (let y = 1; y < size - 1; y++) {
+            for (let x = 1; x < size - 1; x++) {
+                const i = y * size + x;
+
+                const lap = bio[i - 1] + bio[i + 1] + bio[i - size] + bio[i + size] - 4 * bio[i];
+                let next = bio[i] + this.params.bioDiffusion * lap + this.params.bioGrowth * bio[i] * (1 - bio[i]);
+
+                if (next < 0) next = 0;
+                if (next > 1) next = 1;
+                bio_next[i] = next;
+
+                // Bio no longer acts as physical obstacle to allow the fixed Island to persist.
+            }
+        }
+
+        for (let i = 0; i < area; i++) bio[i] = bio_next[i];
+    }
+}

package/src/addons/ocean-simulation/OceanSimulatorAddon.ts

@@ -0,0 +1,145 @@
+import { TriadeMasterBuffer } from '../../core/TriadeMasterBuffer';
+import { TriadeCubeV2 } from '../../core/TriadeCubeV2';
+import { OceanEngine } from './OceanEngine';
+
+export interface Boat {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    length: number;
+    angle: number;
+}
+
+export class OceanSimulatorAddon {
+    public readonly size: number;
+    private master: TriadeMasterBuffer;
+    private cube: TriadeCubeV2;
+    private engine: OceanEngine;
+
+    public boats: Boat[] = [];
+
+    constructor(size: number = 256) {
+        this.size = size;
+
+        // 1. Initialize Triade Memory System (24 faces for LBM + Bio + Temp)
+        this.master = new TriadeMasterBuffer();
+        this.cube = new TriadeCubeV2(size, this.master, 24);
+
+        // 2. Initialize Engine
+        this.engine = new OceanEngine();
+        this.cube.setEngine(this.engine);
+
+        // 3. Initialize distributions to perfect rest equilibrium
+        const w = [4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36];
+        for (let k = 0; k < 9; k++) {
+            this.cube.faces[k].fill(w[k]);
+        }
+    }
+
+    /**
+     * Engine parameters access
+     */
+    get params() { return this.engine.params; }
+    get stats() { return this.engine.stats; }
+
+    /**
+     * High-level Boat API
+     */
+    addBoat(x: number, y: number, length: number = 20): void {
+        this.boats.push({ x, y, vx: 0, vy: 0, length, angle: 0 });
+    }
+
+    /**
+     * Global Step: Fluid -> Bio -> Boats
+     */
+    step(): void {
+        // Run Triade Math Engine
+        this.cube.compute();
+
+        // Run Boat Physics
+        const ux = this.cube.faces[18];
+        const uy = this.cube.faces[19];
+        const size = this.size;
+
+        for (const boat of this.boats) {
+            // Sample fluid velocity under boat
+            const ix = Math.floor(boat.x);
+            const iy = Math.floor(boat.y);
+
+            if (ix >= 0 && ix < size && iy >= 0 && iy < size) {
+                const i = iy * size + ix;
+                const fux = ux[i];
+                const fuy = uy[i];
+
+                // Advection: Boat is carried by fluid
+                boat.vx += fux * 0.15 - boat.vx * 0.05; // Force + Friction
+                boat.vy += fuy * 0.15 - boat.vy * 0.05;
+
+                // Move boat
+                boat.x += boat.vx;
+                boat.y += boat.vy;
+
+                // Update orientation based on velocity
+                if (Math.abs(boat.vx) > 0.01 || Math.abs(boat.vy) > 0.01) {
+                    boat.angle = Math.atan2(boat.vy, boat.vx);
+                }
+
+                // Periodic bounds for boats (optional)
+                boat.x = (boat.x + size) % size;
+                boat.y = (boat.y + size) % size;
+            }
+        }
+    }
+
+    /**
+     * Interaction bridge
+     */
+    setInteraction(x: number, y: number, active: boolean): void {
+        this.engine.interaction.mouseX = x;
+        this.engine.interaction.mouseY = y;
+        this.engine.interaction.active = active;
+    }
+
+    /**
+     * Helper to render everything to a canvas
+     */
+    render(ctx: CanvasRenderingContext2D, imageData: ImageData): void {
+        const size = this.size;
+        const bio = this.cube.faces[21];
+        const ux = this.cube.faces[18];
+        const uy = this.cube.faces[19];
+        const obst = this.cube.faces[22];
+        const data = imageData.data;
+
+        for (let i = 0; i < size * size; i++) {
+            const j = i * 4;
+            if (obst[i] > 0.5) {
+                data[j] = 20; data[j + 1] = 20; data[j + 2] = 40; data[j + 3] = 255;
+            } else {
+                const speed = Math.sqrt(ux[i] * ux[i] + uy[i] * uy[i]);
+                const intensity = speed * 1200;
+                data[j] = Math.min(255, bio[i] * 40 + intensity * 0.1);
+                data[j + 1] = Math.min(255, bio[i] * 120 + intensity * 0.4);
+                data[j + 2] = Math.min(255, intensity * 2.5 + 20);
+                data[j + 3] = 255;
+            }
+        }
+        ctx.putImageData(imageData, 0, 0);
+
+        // Draw Boats
+        ctx.fillStyle = "#fff";
+        for (const boat of this.boats) {
+            ctx.save();
+            ctx.translate(boat.x, boat.y);
+            ctx.rotate(boat.angle);
+            ctx.fillRect(-boat.length / 2, -2, boat.length, 4);
+            ctx.restore();
+        }
+    }
+
+    /** Access to raw buffers for custom rendering */
+    getRawFaces() {
+        return this.cube.faces;
+    }
+}