hypercube-compute 2.0.0

package/dist/index.js

@@ -0,0 +1,1392 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AerodynamicsEngine: () => AerodynamicsEngine,
+  BlankEngine: () => BlankEngine,
+  CanvasAdapter: () => CanvasAdapter,
+  EcosystemEngineO1: () => EcosystemEngineO1,
+  GameOfLifeEngine: () => GameOfLifeEngine,
+  HeatmapEngine: () => HeatmapEngine,
+  OceanEngine: () => OceanEngine,
+  OceanSimulatorAddon: () => OceanSimulatorAddon,
+  OceanWebGLRenderer: () => OceanWebGLRenderer,
+  OceanWorld: () => OceanWorld,
+  Triade: () => Triade,
+  TriadeCubeV2: () => TriadeCubeV2,
+  TriadeGrid: () => TriadeGrid,
+  TriadeMasterBuffer: () => TriadeMasterBuffer,
+  WebGLAdapter: () => WebGLAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/TriadeMasterBuffer.ts
+var TriadeMasterBuffer = class {
+  buffer;
+  offset = 0;
+  /**
+   * Alloue un unique bloc de mémoire vive (ArrayBuffer) pour l'ensemble du système.
+   * @param totalBytes Taille totale de la RAM allouée (par défaut 100 MB).
+   */
+  constructor(totalBytes = 100 * 1024 * 1024) {
+    this.buffer = new ArrayBuffer(totalBytes);
+  }
+  /**
+   * Alloue les octets nécessaires pour un Cube de 6 Faces en O(1) sans fragmentation.
+   * @param mapSize Résolution (ex: 400x400)
+   * @returns L'offset de départ dans l'ArrayBuffer
+   */
+  allocateCube(mapSize, numFaces = 6) {
+    const floatsPerFace = mapSize * mapSize;
+    const bytesPerFace = floatsPerFace * Float32Array.BYTES_PER_ELEMENT;
+    const totalCubeBytes = bytesPerFace * numFaces;
+    if (this.offset + totalCubeBytes > this.buffer.byteLength) {
+      throw new Error(`[TriadeMasterBuffer] Out Of Memory. Impossible d'allouer ${totalCubeBytes} bytes suppl\xE9mentaires.`);
+    }
+    const startOffset = this.offset;
+    this.offset += totalCubeBytes;
+    return startOffset;
+  }
+  /** Retourne la quantité de RAM consommée */
+  getUsedMemoryInMB() {
+    return (this.offset / (1024 * 1024)).toFixed(2) + " MB";
+  }
+};
+
+// src/core/TriadeCubeV2.ts
+var TriadeCubeV2 = class {
+  mapSize;
+  faces = [];
+  offset;
+  // Added this property
+  engine = null;
+  /**
+   * @param mapSize La résolution (N x N)
+   * @param masterBuffer L'allocateur de RAM central de l'Orchestrateur
+   */
+  constructor(mapSize, masterBuffer, numFaces = 6) {
+    this.mapSize = mapSize;
+    this.offset = masterBuffer.allocateCube(mapSize, numFaces);
+    const floatCount = mapSize * mapSize;
+    const bytesPerFace = floatCount * Float32Array.BYTES_PER_ELEMENT;
+    for (let i = 0; i < numFaces; i++) {
+      this.faces.push(
+        new Float32Array(
+          masterBuffer.buffer,
+          this.offset + i * bytesPerFace,
+          floatCount
+        )
+      );
+    }
+  }
+  /**
+   * Injecte le cerveau mathématique dans ce paquet mémoire.
+   */
+  setEngine(engine) {
+    this.engine = engine;
+  }
+  /**
+   * Exécute le calcul de la Frame (O1, Wavefront, Automates)
+   */
+  compute() {
+    if (!this.engine) {
+      console.warn("[TriadeCubeV2] Aucun Engine (Cerveau) n'a \xE9t\xE9 assign\xE9 \xE0 ce cube.");
+      return;
+    }
+    this.engine.compute(this.faces, this.mapSize);
+  }
+  /** Helper pour vider une face spécifique */
+  clearFace(faceIndex) {
+    this.faces[faceIndex].fill(0);
+  }
+};
+
+// src/Triade.ts
+var Triade = class {
+  _masterBuffer;
+  cubes = /* @__PURE__ */ new Map();
+  get masterBuffer() {
+    return this._masterBuffer;
+  }
+  /**
+   * @param vRamAllocMegabytes Taille du ArrayBuffer en Mega-Octets (par defaut 50MB)
+   */
+  constructor(vRamAllocMegabytes = 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.
+   */
+  createCube(name, mapSize, engine, numFaces = 6) {
+    if (this.cubes.has(name)) {
+      throw new Error(`Cube avec le nom ${name} existe d\xE9j\xE0.`);
+    }
+    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.
+   */
+  getCube(id) {
+    return this.cubes.get(id);
+  }
+};
+
+// src/core/TriadeGrid.ts
+var TriadeGrid = class {
+  cubes = [];
+  cols;
+  rows;
+  cubeSize;
+  isPeriodic;
+  constructor(cols, rows, cubeSize, masterBuffer, engineFactory, numFaces = 6, isPeriodic = true) {
+    this.cols = cols;
+    this.rows = rows;
+    this.cubeSize = cubeSize;
+    this.isPeriodic = isPeriodic;
+    for (let y = 0; y < rows; y++) {
+      this.cubes[y] = [];
+      for (let x = 0; x < cols; x++) {
+        const cube = new TriadeCubeV2(cubeSize, masterBuffer, numFaces);
+        cube.setEngine(engineFactory());
+        this.cubes[y][x] = cube;
+      }
+    }
+  }
+  /**
+   * Calcule une étape complète de la grille.
+   * 1. Exécute "compute()" sur chaque cube
+   * 2. Synchronise les bords (Boundary Exchange) sur les faces demandées
+   */
+  compute(facesToSynchronize = 0) {
+    for (let y = 0; y < this.rows; y++) {
+      for (let x = 0; x < this.cols; x++) {
+        this.cubes[y][x]?.compute();
+      }
+    }
+    const faces = Array.isArray(facesToSynchronize) ? facesToSynchronize : [facesToSynchronize];
+    for (const f of faces) {
+      this.synchronizeBoundaries(f);
+    }
+  }
+  /**
+   * Recopie les vecteurs périphériques (1 pixel de profondeur) vers les bords des voisins.
+   */
+  synchronizeBoundaries(f) {
+    const s = this.cubeSize;
+    const s_minus_1 = s - 1;
+    const s_minus_2 = s - 2;
+    for (let y = 0; y < this.rows; y++) {
+      for (let x = 0; x < this.cols; x++) {
+        const cube = this.cubes[y][x];
+        const data = cube.faces[f];
+        if (x < this.cols - 1 || this.isPeriodic) {
+          const rightCube = this.cubes[y][(x + 1) % this.cols];
+          const rightData = rightCube.faces[f];
+          for (let row = 1; row < s_minus_1; row++) {
+            rightData[row * s + 0] = data[row * s + s_minus_2];
+          }
+        }
+        if (x > 0 || this.isPeriodic) {
+          const leftCube = this.cubes[y][(x - 1 + this.cols) % this.cols];
+          const leftData = leftCube.faces[f];
+          for (let row = 1; row < s_minus_1; row++) {
+            leftData[row * s + s_minus_1] = data[row * s + 1];
+          }
+        }
+      }
+    }
+    for (let y = 0; y < this.rows; y++) {
+      for (let x = 0; x < this.cols; x++) {
+        const cube = this.cubes[y][x];
+        const data = cube.faces[f];
+        if (y < this.rows - 1 || this.isPeriodic) {
+          const bottomCube = this.cubes[(y + 1) % this.rows][x];
+          const bottomData = bottomCube.faces[f];
+          bottomData.set(data.subarray(s_minus_2 * s, s_minus_2 * s + s), 0);
+        }
+        if (y > 0 || this.isPeriodic) {
+          const topCube = this.cubes[(y - 1 + this.rows) % this.rows][x];
+          const topData = topCube.faces[f];
+          topData.set(data.subarray(1 * s, 1 * s + s), s_minus_1 * s);
+        }
+      }
+    }
+  }
+};
+
+// src/engines/AerodynamicsEngine.ts
+var AerodynamicsEngine = class {
+  dragScore = 0;
+  initialized = false;
+  get name() {
+    return "Lattice Boltzmann D2Q9 (O(1))";
+  }
+  compute(faces, mapSize) {
+    const N = mapSize;
+    const obstacles = faces[18];
+    const ux_out = faces[19];
+    const uy_out = faces[20];
+    const curl_out = faces[21];
+    const cx = [0, 1, 0, -1, 0, 1, -1, -1, 1];
+    const cy = [0, 0, 1, 0, -1, 1, 1, -1, -1];
+    const w = [4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36];
+    const opp = [0, 3, 4, 1, 2, 7, 8, 5, 6];
+    const u0 = 0.12;
+    const omega = 1.95;
+    if (!this.initialized) {
+      for (let idx = 0; idx < N * N; idx++) {
+        const rho = 1;
+        const ux = u0;
+        const uy = 0;
+        const u_sq = ux * ux + uy * uy;
+        for (let i = 0; i < 9; i++) {
+          const cu = cx[i] * ux + cy[i] * uy;
+          const feq = w[i] * rho * (1 + 3 * cu + 4.5 * cu * cu - 1.5 * u_sq);
+          faces[i][idx] = feq;
+          faces[i + 9][idx] = feq;
+        }
+      }
+      this.initialized = true;
+    }
+    let frameDrag = 0;
+    for (let y = 1; y < N - 1; y++) {
+      for (let x = 1; x < N - 1; x++) {
+        const idx = y * N + x;
+        if (obstacles[idx] > 0) {
+          for (let i = 1; i < 9; i++) {
+            const originX = x - cx[i];
+            const originY = y - cy[i];
+            const originIdx = originY * N + originX;
+            faces[opp[i] + 9][originIdx] = faces[i][originIdx];
+            if (i === 1) frameDrag += faces[1][originIdx];
+          }
+          ux_out[idx] = 0;
+          uy_out[idx] = 0;
+          continue;
+        }
+        let rho = 0;
+        let ux = 0;
+        let uy = 0;
+        for (let i = 0; i < 9; i++) {
+          const f_val = faces[i][idx];
+          rho += f_val;
+          ux += cx[i] * f_val;
+          uy += cy[i] * f_val;
+        }
+        if (x === 1) {
+          ux = u0 * rho;
+          uy = 0;
+        }
+        if (rho > 0) {
+          ux /= rho;
+          uy /= rho;
+        }
+        ux_out[idx] = ux;
+        uy_out[idx] = uy;
+        const u_sq = ux * ux + uy * uy;
+        for (let i = 0; i < 9; i++) {
+          const cu = cx[i] * ux + cy[i] * uy;
+          const feq = w[i] * rho * (1 + 3 * cu + 4.5 * cu * cu - 1.5 * u_sq);
+          const f_post = faces[i][idx] * (1 - omega) + feq * omega;
+          let nx = x + cx[i];
+          let ny = y + cy[i];
+          if (ny < 1) ny = N - 2;
+          else if (ny > N - 2) ny = 1;
+          if (nx > N - 2) nx = N - 2;
+          faces[i + 9][ny * N + nx] = f_post;
+        }
+      }
+    }
+    for (let i = 0; i < 9; i++) {
+      faces[i].set(faces[i + 9]);
+    }
+    this.dragScore = this.dragScore * 0.9 + frameDrag * 1e3 * 0.1;
+    for (let y = 1; y < N - 1; y++) {
+      for (let x = 1; x < N - 1; x++) {
+        const idx = y * N + x;
+        const dUy_dx = uy_out[idx + 1] - uy_out[idx - 1];
+        const dUx_dy = ux_out[idx + N] - ux_out[idx - N];
+        curl_out[idx] = dUy_dx - dUx_dy;
+      }
+    }
+  }
+};
+
+// src/engines/EcosystemEngineO1.ts
+var EcosystemEngineO1 = class {
+  get name() {
+    return "Guerre des Triades (Rouge vs Bleu)";
+  }
+  compute(faces, mapSize) {
+    const current = faces[1];
+    const next = faces[2];
+    for (let y = 0; y < mapSize; y++) {
+      for (let x = 0; x < mapSize; x++) {
+        const idx = y * mapSize + x;
+        const state = current[idx];
+        let blues = 0;
+        let reds = 0;
+        const yM = y > 0 ? y - 1 : mapSize - 1;
+        const yP = y < mapSize - 1 ? y + 1 : 0;
+        const xM = x > 0 ? x - 1 : mapSize - 1;
+        const xP = x < mapSize - 1 ? x + 1 : 0;
+        const n1 = current[yM * mapSize + xM];
+        if (n1 === 2) blues++;
+        else if (n1 === 3) reds++;
+        const n2 = current[yM * mapSize + x];
+        if (n2 === 2) blues++;
+        else if (n2 === 3) reds++;
+        const n3 = current[yM * mapSize + xP];
+        if (n3 === 2) blues++;
+        else if (n3 === 3) reds++;
+        const n4 = current[y * mapSize + xM];
+        if (n4 === 2) blues++;
+        else if (n4 === 3) reds++;
+        const n5 = current[y * mapSize + xP];
+        if (n5 === 2) blues++;
+        else if (n5 === 3) reds++;
+        const n6 = current[yP * mapSize + xM];
+        if (n6 === 2) blues++;
+        else if (n6 === 3) reds++;
+        const n7 = current[yP * mapSize + x];
+        if (n7 === 2) blues++;
+        else if (n7 === 3) reds++;
+        const n8 = current[yP * mapSize + xP];
+        if (n8 === 2) blues++;
+        else if (n8 === 3) reds++;
+        const total = blues + reds;
+        if (state !== 2 && state !== 3) {
+          if (total === 3) {
+            next[idx] = blues > reds ? 2 : 3;
+          } else if (Math.random() < 5e-4) {
+            next[idx] = Math.random() < 0.5 ? 2 : 3;
+          } else {
+            next[idx] = 0;
+          }
+        } else if (state === 2) {
+          if (reds >= 2) next[idx] = 0;
+          else if (total === 2 || total === 3) next[idx] = 2;
+          else next[idx] = 0;
+        } else if (state === 3) {
+          if (blues >= 2) next[idx] = 0;
+          else if (total === 2 || total === 3) next[idx] = 3;
+          else next[idx] = 0;
+        }
+      }
+    }
+    current.set(next);
+  }
+};
+
+// src/engines/GameOfLifeEngine.ts
+var GameOfLifeEngine = class {
+  get name() {
+    return "Ecosyst\xE8me Tensoriel (Plantes, Herbivores, Carnivores)";
+  }
+  compute(faces, mapSize) {
+    const current = faces[1];
+    const next = faces[2];
+    for (let y = 0; y < mapSize; y++) {
+      const top = y === 0 ? mapSize - 1 : y - 1;
+      const bottom = y === mapSize - 1 ? 0 : y + 1;
+      const topRow = top * mapSize;
+      const midRow = y * mapSize;
+      const botRow = bottom * mapSize;
+      for (let x = 0; x < mapSize; x++) {
+        const left = x === 0 ? mapSize - 1 : x - 1;
+        const right = x === mapSize - 1 ? 0 : x + 1;
+        const idx = midRow + x;
+        const state = current[idx];
+        let targetState = state + 1;
+        if (targetState > 3) targetState = 0;
+        let predators = 0;
+        if (current[topRow + x] === targetState) predators++;
+        if (current[midRow + left] === targetState) predators++;
+        if (current[midRow + right] === targetState) predators++;
+        if (current[botRow + x] === targetState) predators++;
+        if (current[topRow + left] === targetState) predators++;
+        if (current[topRow + right] === targetState) predators++;
+        if (current[botRow + left] === targetState) predators++;
+        if (current[botRow + right] === targetState) predators++;
+        const threshold = state === 0 ? 1 : 2;
+        if (predators >= threshold) {
+          next[idx] = targetState;
+        } else {
+          next[idx] = state;
+        }
+      }
+    }
+    current.set(next);
+  }
+};
+
+// src/engines/HeatmapEngine.ts
+var HeatmapEngine = class {
+  name = "Heatmap (O1 Spatial Convolution)";
+  radius;
+  weight;
+  /**
+   * @param radius Rayon d'influence en cellules
+   * @param weight Coefficient multiplicateur à l'arrivée
+   */
+  constructor(radius = 10, weight = 1) {
+    this.radius = radius;
+    this.weight = weight;
+  }
+  /**
+   * Exécute le Summed Area Table Algorithm (Face 5) suivi 
+   * d'un Box Filter O(1) vers la Synthèse (Face 3).
+   */
+  compute(faces, mapSize) {
+    const face2 = faces[1];
+    const face3 = faces[2];
+    const face5 = faces[4];
+    for (let y = 0; y < mapSize; y++) {
+      for (let x = 0; x < mapSize; x++) {
+        const idx = y * mapSize + x;
+        const val = face2[idx];
+        const top = y > 0 ? face5[(y - 1) * mapSize + x] : 0;
+        const left = x > 0 ? face5[y * mapSize + (x - 1)] : 0;
+        const topLeft = y > 0 && x > 0 ? face5[(y - 1) * mapSize + (x - 1)] : 0;
+        face5[idx] = val + top + left - topLeft;
+      }
+    }
+    for (let y = 0; y < mapSize; y++) {
+      for (let x = 0; x < mapSize; x++) {
+        const minX = Math.max(0, x - this.radius);
+        const minY = Math.max(0, y - this.radius);
+        const maxX = Math.min(mapSize - 1, x + this.radius);
+        const maxY = Math.min(mapSize - 1, y + this.radius);
+        const A = minX > 0 && minY > 0 ? face5[(minY - 1) * mapSize + (minX - 1)] : 0;
+        const B = minY > 0 ? face5[(minY - 1) * mapSize + maxX] : 0;
+        const C = minX > 0 ? face5[maxY * mapSize + (minX - 1)] : 0;
+        const D = face5[maxY * mapSize + maxX];
+        const sum = D - B - C + A;
+        face3[y * mapSize + x] = sum * this.weight;
+      }
+    }
+  }
+};
+
+// src/io/CanvasAdapter.ts
+var CanvasAdapter = class {
+  /**
+   * Lit un Tenseur Plat (Face de Float32Array) et le peint sur un contexte Canvas Native.
+   * Cette interface sépare la logique de rendu (UI) du moteur mathématique (Triade).
+   */
+  static renderFaceToCanvas(faceData, mapSize, ctx, options = { colorScheme: "grayscale" }) {
+    const imgData = ctx.getImageData(0, 0, mapSize, mapSize);
+    const data = imgData.data;
+    let max = options.normalizeMax || 1e-4;
+    if (!options.normalizeMax) {
+      for (let i = 0; i < faceData.length; i++) {
+        if (faceData[i] > max) max = faceData[i];
+      }
+    }
+    for (let i = 0; i < faceData.length; i++) {
+      const val = faceData[i] / max;
+      const p = i * 4;
+      if (options.colorScheme === "heat") {
+        data[p] = val * 255;
+        data[p + 1] = val > 0.5 ? (val - 0.5) * 510 : 0;
+        data[p + 2] = val * 50;
+        data[p + 3] = 255;
+      } else {
+        const c = val * 255;
+        data[p] = c;
+        data[p + 1] = c;
+        data[p + 2] = c;
+        data[p + 3] = 255;
+      }
+    }
+    ctx.putImageData(imgData, 0, 0);
+  }
+};
+
+// src/io/WebGLAdapter.ts
+var WebGLAdapter = class {
+  gl;
+  texture;
+  program;
+  mapSize;
+  constructor(canvas, mapSize) {
+    this.mapSize = mapSize;
+    const gl = canvas.getContext("webgl2");
+    if (!gl) {
+      throw new Error("WebGL2 n'est pas support\xE9 par ce navigateur.");
+    }
+    this.gl = gl;
+    const vsSource = `#version 300 es
+        in vec2 a_position;
+        out vec2 v_uv;
+        void main() {
+            v_uv = a_position * 0.5 + 0.5; // conversion -1,1 vers 0,1
+            v_uv.y = 1.0 - v_uv.y; // Flip Y
+            gl_Position = vec4(a_position, 0.0, 1.0);
+        }`;
+    const fsSource = `#version 300 es
+        precision highp float;
+        precision highp sampler2D;
+        
+        in vec2 v_uv;
+        uniform sampler2D u_tensor;
+        out vec4 outColor;
+        
+        // Palette simple: froid (bleu) -> chaud (rouge)
+        vec3 heatMap(float t) {
+            return clamp(vec3(1.5*t, 2.0*t - 0.5, 0.5 - t*1.5), 0.0, 1.0);
+        }
+        
+        void main() {
+            // Lecture du Float32Array exact depuis la VRAM Triade
+            float val = texture(u_tensor, v_uv).r; 
+            
+            // Affichage avec la palette
+            vec3 color = mix(vec3(0.05, 0.07, 0.1), vec3(0.0, 0.8, 1.0), clamp(val, 0.0, 1.0)); // Custom Cyan/Dark mapping
+            if (val > 1.0) color = vec3(1.0, 1.0, 1.0); // Saturation
+            
+            outColor = vec4(color, 1.0);
+        }`;
+    this.program = this.createProgram(vsSource, fsSource);
+    this.gl.useProgram(this.program);
+    const positionBuffer = this.gl.createBuffer();
+    this.gl.bindBuffer(this.gl.ARRAY_BUFFER, positionBuffer);
+    const positions = new Float32Array([
+      -1,
+      -1,
+      1,
+      -1,
+      -1,
+      1,
+      -1,
+      1,
+      1,
+      -1,
+      1,
+      1
+    ]);
+    this.gl.bufferData(this.gl.ARRAY_BUFFER, positions, this.gl.STATIC_DRAW);
+    const posLoc = this.gl.getAttribLocation(this.program, "a_position");
+    this.gl.enableVertexAttribArray(posLoc);
+    this.gl.vertexAttribPointer(posLoc, 2, this.gl.FLOAT, false, 0, 0);
+    this.gl.getExtension("EXT_color_buffer_float");
+    this.gl.getExtension("OES_texture_float_linear");
+    this.texture = this.gl.createTexture();
+    this.gl.bindTexture(this.gl.TEXTURE_2D, this.texture);
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.NEAREST);
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.NEAREST);
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
+    this.gl.texImage2D(
+      this.gl.TEXTURE_2D,
+      0,
+      this.gl.R32F,
+      mapSize,
+      mapSize,
+      0,
+      this.gl.RED,
+      this.gl.FLOAT,
+      null
+    );
+  }
+  /**
+   * Propulse la Face Mémoire Triade directement dans la VRAM GPU.
+   * C'est l'opération la plus rapide sur navigateur (O(1) Data Upload).
+   */
+  renderFaceToWebGL(faceData) {
+    this.gl.useProgram(this.program);
+    this.gl.bindTexture(this.gl.TEXTURE_2D, this.texture);
+    this.gl.texSubImage2D(
+      this.gl.TEXTURE_2D,
+      0,
+      0,
+      0,
+      this.mapSize,
+      this.mapSize,
+      this.gl.RED,
+      this.gl.FLOAT,
+      faceData
+    );
+    this.gl.drawArrays(this.gl.TRIANGLES, 0, 6);
+  }
+  createProgram(vsSource, fsSource) {
+    const vs = this.gl.createShader(this.gl.VERTEX_SHADER);
+    this.gl.shaderSource(vs, vsSource);
+    this.gl.compileShader(vs);
+    const fs = this.gl.createShader(this.gl.FRAGMENT_SHADER);
+    this.gl.shaderSource(fs, fsSource);
+    this.gl.compileShader(fs);
+    const prog = this.gl.createProgram();
+    this.gl.attachShader(prog, vs);
+    this.gl.attachShader(prog, fs);
+    this.gl.linkProgram(prog);
+    if (!this.gl.getProgramParameter(prog, this.gl.LINK_STATUS)) {
+      console.error(this.gl.getProgramInfoLog(prog));
+      throw new Error("Erreur de compilation WebGL");
+    }
+    return prog;
+  }
+};
+
+// src/addons/ocean-simulation/OceanEngine.ts
+var OceanEngine = class {
+  name = "OceanEngine";
+  // Re-use lab-perfect constants
+  w = [4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36];
+  cx = [0, 1, 0, -1, 0, 1, -1, -1, 1];
+  cy = [0, 0, 1, 0, -1, 1, 1, -1, -1];
+  opp = [0, 3, 4, 1, 2, 7, 8, 5, 6];
+  // Caches to avoid per-frame allocations
+  feq_cache = new Float32Array(9);
+  pulled_f = new Float32Array(9);
+  params = {
+    tau_0: 0.8,
+    smagorinsky: 0.2,
+    cflLimit: 0.38,
+    bioDiffusion: 0.05,
+    bioGrowth: 5e-4,
+    vortexRadius: 28,
+    vortexStrength: 0.02
+  };
+  stats = {
+    maxU: 0,
+    avgTau: 0
+  };
+  // UI Input simulation (will be fed by the high-level framework/addon)
+  interaction = {
+    mouseX: 0,
+    mouseY: 0,
+    active: false
+  };
+  constructor() {
+  }
+  /**
+   * Entry point: Orchestrates LBM and Bio steps
+   */
+  compute(faces, size) {
+    this.stepLBM(faces, size);
+    this.stepBio(faces, size);
+  }
+  stepLBM(m, size) {
+    const rho = m[20], ux = m[18], uy = m[19], obst = m[22];
+    let maxU = 0;
+    let sumTau = 0;
+    let activeCells = 0;
+    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;
+    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;
+        }
+        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];
+          } else {
+            this.pulled_f[k] = m[k][ni];
+          }
+          r += this.pulled_f[k];
+          vx += this.pulled_f[k] * this.cx[k];
+          vy += this.pulled_f[k] * this.cy[k];
+        }
+        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 < 1e-4) r = 1e-4;
+        vx /= r;
+        vy /= r;
+        if (isForcing) {
+          const dx = x - mx;
+          const dy = y - my;
+          const dist2 = dx * dx + dy * dy;
+          if (dist2 < vr2) {
+            const forceScale = this.params.vortexStrength * 5e-3 * (1 - 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;
+        }
+        rho[i] = r;
+        ux[i] = vx;
+        uy[i] = vy;
+        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;
+    for (let k = 0; k < 9; k++) {
+      const tmp = m[k];
+      m[k] = m[k + 9];
+      m[k + 9] = tmp;
+    }
+  }
+  stepBio(m, size) {
+    const bio = m[21];
+    const bio_next = m[17];
+    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;
+      }
+    }
+    for (let i = 0; i < area; i++) bio[i] = bio_next[i];
+  }
+};
+
+// src/addons/ocean-simulation/OceanSimulatorAddon.ts
+var OceanSimulatorAddon = class {
+  size;
+  master;
+  cube;
+  engine;
+  boats = [];
+  constructor(size = 256) {
+    this.size = size;
+    this.master = new TriadeMasterBuffer();
+    this.cube = new TriadeCubeV2(size, this.master, 24);
+    this.engine = new OceanEngine();
+    this.cube.setEngine(this.engine);
+    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, y, length = 20) {
+    this.boats.push({ x, y, vx: 0, vy: 0, length, angle: 0 });
+  }
+  /**
+   * Global Step: Fluid -> Bio -> Boats
+   */
+  step() {
+    this.cube.compute();
+    const ux = this.cube.faces[18];
+    const uy = this.cube.faces[19];
+    const size = this.size;
+    for (const boat of this.boats) {
+      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];
+        boat.vx += fux * 0.15 - boat.vx * 0.05;
+        boat.vy += fuy * 0.15 - boat.vy * 0.05;
+        boat.x += boat.vx;
+        boat.y += boat.vy;
+        if (Math.abs(boat.vx) > 0.01 || Math.abs(boat.vy) > 0.01) {
+          boat.angle = Math.atan2(boat.vy, boat.vx);
+        }
+        boat.x = (boat.x + size) % size;
+        boat.y = (boat.y + size) % size;
+      }
+    }
+  }
+  /**
+   * Interaction bridge
+   */
+  setInteraction(x, y, active) {
+    this.engine.interaction.mouseX = x;
+    this.engine.interaction.mouseY = y;
+    this.engine.interaction.active = active;
+  }
+  /**
+   * Helper to render everything to a canvas
+   */
+  render(ctx, imageData) {
+    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);
+    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;
+  }
+};
+
+// src/addons/ocean-simulation/OceanWebGLRenderer.ts
+var OceanWebGLRenderer = class {
+  gl;
+  program;
+  indexCount = 0;
+  texRho;
+  texUx;
+  texUy;
+  texObst;
+  globalW;
+  globalH;
+  chunkSize;
+  constructor(canvas, cols, rows, chunkSize) {
+    this.chunkSize = chunkSize;
+    this.globalW = cols * chunkSize;
+    this.globalH = rows * chunkSize;
+    const gl = canvas.getContext("webgl2");
+    if (!gl) throw new Error("WebGL2 non support\xE9.");
+    this.gl = gl;
+    this.gl.getExtension("EXT_color_buffer_float");
+    this.gl.getExtension("OES_texture_float_linear");
+    const vsSource = `#version 300 es
+        in vec2 a_position;
+        out vec2 v_uv;
+        out vec3 v_worldPos;
+        uniform sampler2D u_rho; // We sample density in Vertex Shader!
+        uniform sampler2D u_obst; // Also sample obstacles in Vertex Shader!
+        
+        void main() {
+            v_uv = a_position * 0.5 + 0.5;
+            v_uv.y = 1.0 - v_uv.y;
+            
+            // VTF: Vertex Texture Fetch (Real 3D heights from LBM Density)
+            float rho = texture(u_rho, v_uv).r;
+            float obst = texture(u_obst, v_uv).r;
+            float h = 0.0;
+            if (obst > 0.5) {
+                h = 5.0; // Island elevated plateau
+            } else {
+                h = (rho - 1.0) * 8.0; // Wave extrusion amplitude (softened)
+            }
+            
+            vec3 p = vec3(a_position.x, a_position.y, h);
+            v_worldPos = p;
+
+            // 3D Camera / Perspective Math
+            float angleX = -1.1; // Look down tilt
+            float cosX = cos(angleX);
+            float sinX = sin(angleX);
+            
+            // Apply Pitch rotation
+            float yRot = p.y * cosX - p.z * sinX;
+            float zRot = p.y * sinX + p.z * cosX;
+            
+            // Move camera back
+            zRot -= 2.2; 
+            
+            // Perspective projection
+            float fov = 1.7; 
+            gl_Position = vec4(p.x * fov, (yRot - 0.2) * fov, zRot, -zRot);
+        }`;
+    const fsSource = `#version 300 es
+        precision highp float;
+        precision highp sampler2D;
+        
+        in vec2 v_uv;
+        in vec3 v_worldPos;
+        uniform sampler2D u_rho; // LBM Density -> Heights
+        uniform sampler2D u_ux;
+        uniform sampler2D u_uy;
+        uniform sampler2D u_obst;
+
+        out vec4 outColor;
+        
+        void main() {
+            float obst = texture(u_obst, v_uv).r;
+            if (obst > 0.5) {
+                // Island material
+                vec3 islandTop = vec3(0.5, 0.6, 0.3); // Grass / Forest
+                vec3 islandSide = vec3(0.7, 0.6, 0.4); // Sand / Rock
+                
+                // Read local normals to detect cliffs
+                float oL = textureOffset(u_obst, v_uv, ivec2(-1, 0)).r;
+                float oR = textureOffset(u_obst, v_uv, ivec2(1, 0)).r;
+                float oB = textureOffset(u_obst, v_uv, ivec2(0, -1)).r;
+                float oT = textureOffset(u_obst, v_uv, ivec2(0, 1)).r;
+                float sumO = oL + oR + oB + oT;
+                
+                if (sumO < 3.5) {
+                    outColor = vec4(islandSide, 1.0); // Cliff / Beach
+                } else {
+                    outColor = vec4(islandTop, 1.0); // Plateau core
+                }
+                return;
+            }
+
+            // Sample density around the pixel to compute normal vector
+            float rL = textureOffset(u_rho, v_uv, ivec2(-1, 0)).r;
+            float rR = textureOffset(u_rho, v_uv, ivec2(1, 0)).r;
+            float rB = textureOffset(u_rho, v_uv, ivec2(0, -1)).r; // Inverted Y due to texture flip
+            float rT = textureOffset(u_rho, v_uv, ivec2(0, 1)).r;
+
+            // Generate Normal from heightmap (Density is height proxy)
+            float strength = 25.0; // Softened normals
+            vec3 normal = normalize(vec3((rL - rR) * strength, (rB - rT) * strength, 1.0));
+
+            // Lighting setup
+            vec3 lightDir = normalize(vec3(0.5, 0.8, 0.5)); // Sun angle
+            vec3 viewDir  = normalize(vec3(0.0, -0.6, 1.0)); // Looking at the water
+            
+            float ux = texture(u_ux, v_uv).r;
+            float uy = texture(u_uy, v_uv).r;
+            float speed = sqrt(ux*ux + uy*uy);
+
+            // Water Base Color based on speed (currents)
+            vec3 waterDeep = vec3(0.02, 0.2, 0.5);
+            vec3 waterShallow = vec3(0.0, 0.6, 0.9);
+            vec3 waterColor = mix(waterDeep, waterShallow, clamp(speed * 80.0, 0.0, 1.0));
+
+            // Diffuse Lighting (Lambert)
+            float diff = max(dot(normal, lightDir), 0.0);
+            vec3 diffuse = waterColor * (diff * 0.7 + 0.3); // + ambient
+
+            // Specular Lighting (Phong)
+            vec3 reflectDir = reflect(-lightDir, normal);
+            float spec = pow(max(dot(viewDir, reflectDir), 0.0), 48.0);
+            vec3 specular = vec3(1.0, 1.0, 1.0) * spec * 0.8;
+
+            // Foam based on density peaks (breaking waves)
+            float rho_center = texture(u_rho, v_uv).r;
+            float foam = (rho_center > 1.015) ? clamp((rho_center - 1.015) * 15.0, 0.0, 1.0) : 0.0;
+            
+            outColor = vec4(diffuse + specular + foam, 1.0);
+        }`;
+    this.program = this.createProgram(vsSource, fsSource);
+    const segments = 256;
+    const vertices = new Float32Array((segments + 1) * (segments + 1) * 2);
+    let ptr = 0;
+    for (let y = 0; y <= segments; y++) {
+      for (let x = 0; x <= segments; x++) {
+        vertices[ptr++] = x / segments * 2 - 1;
+        vertices[ptr++] = 1 - y / segments * 2;
+      }
+    }
+    const indices = new Uint32Array(segments * segments * 6);
+    let iPtr = 0;
+    for (let y = 0; y < segments; y++) {
+      for (let x = 0; x < segments; x++) {
+        const i = x + y * (segments + 1);
+        indices[iPtr++] = i;
+        indices[iPtr++] = i + 1;
+        indices[iPtr++] = i + segments + 1;
+        indices[iPtr++] = i + segments + 1;
+        indices[iPtr++] = i + 1;
+        indices[iPtr++] = i + segments + 2;
+      }
+    }
+    this.indexCount = indices.length;
+    const posBuf = this.gl.createBuffer();
+    this.gl.bindBuffer(this.gl.ARRAY_BUFFER, posBuf);
+    this.gl.bufferData(this.gl.ARRAY_BUFFER, vertices, this.gl.STATIC_DRAW);
+    const indexBuf = this.gl.createBuffer();
+    this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, indexBuf);
+    this.gl.bufferData(this.gl.ELEMENT_ARRAY_BUFFER, indices, this.gl.STATIC_DRAW);
+    this.texRho = this.createTexture();
+    this.texUx = this.createTexture();
+    this.texUy = this.createTexture();
+    this.texObst = this.createTexture();
+    this.gl.useProgram(this.program);
+    this.bindTextureUniform("u_rho", 0);
+    this.bindTextureUniform("u_ux", 1);
+    this.bindTextureUniform("u_uy", 2);
+    this.bindTextureUniform("u_obst", 3);
+    const posLoc = this.gl.getAttribLocation(this.program, "a_position");
+    this.gl.enableVertexAttribArray(posLoc);
+    this.gl.vertexAttribPointer(posLoc, 2, this.gl.FLOAT, false, 0, 0);
+  }
+  createTexture() {
+    const tex = this.gl.createTexture();
+    this.gl.bindTexture(this.gl.TEXTURE_2D, tex);
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR);
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.LINEAR);
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
+    this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.R32F, this.globalW, this.globalH, 0, this.gl.RED, this.gl.FLOAT, null);
+    return tex;
+  }
+  bindTextureUniform(name, unit) {
+    const loc = this.gl.getUniformLocation(this.program, name);
+    this.gl.uniform1i(loc, unit);
+  }
+  updateSubTexture(tex, unit, xOff, yOff, data) {
+    this.gl.activeTexture(this.gl.TEXTURE0 + unit);
+    this.gl.bindTexture(this.gl.TEXTURE_2D, tex);
+    this.gl.texSubImage2D(this.gl.TEXTURE_2D, 0, xOff, yOff, this.chunkSize, this.chunkSize, this.gl.RED, this.gl.FLOAT, data);
+  }
+  render(grid) {
+    this.gl.useProgram(this.program);
+    for (let y = 0; y < grid.rows; y++) {
+      for (let x = 0; x < grid.cols; x++) {
+        const cube = grid.cubes[y][x];
+        if (!cube) continue;
+        const xOff = x * this.chunkSize;
+        const yOff = y * this.chunkSize;
+        this.updateSubTexture(this.texRho, 0, xOff, yOff, cube.faces[20]);
+        this.updateSubTexture(this.texUx, 1, xOff, yOff, cube.faces[18]);
+        this.updateSubTexture(this.texUy, 2, xOff, yOff, cube.faces[19]);
+        this.updateSubTexture(this.texObst, 3, xOff, yOff, cube.faces[22]);
+      }
+    }
+    this.gl.drawElements(this.gl.TRIANGLES, this.indexCount, this.gl.UNSIGNED_INT, 0);
+  }
+  createProgram(vsSource, fsSource) {
+    const vs = this.gl.createShader(this.gl.VERTEX_SHADER);
+    this.gl.shaderSource(vs, vsSource);
+    this.gl.compileShader(vs);
+    const fs = this.gl.createShader(this.gl.FRAGMENT_SHADER);
+    this.gl.shaderSource(fs, fsSource);
+    this.gl.compileShader(fs);
+    const prog = this.gl.createProgram();
+    this.gl.attachShader(prog, vs);
+    this.gl.attachShader(prog, fs);
+    this.gl.linkProgram(prog);
+    return prog;
+  }
+};
+
+// src/addons/ocean-simulation/OceanWorld.ts
+var OceanWorld = class {
+  cols;
+  rows;
+  chunkSize;
+  globalSizeW;
+  globalSizeH;
+  grid;
+  boats = [];
+  keys = { up: false, down: false, left: false, right: false };
+  constructor(masterBuffer, cols = 2, rows = 2, chunkSize = 64) {
+    this.cols = cols;
+    this.rows = rows;
+    this.chunkSize = chunkSize;
+    this.globalSizeW = cols * chunkSize;
+    this.globalSizeH = rows * chunkSize;
+    this.grid = new TriadeGrid(cols, rows, chunkSize, masterBuffer, () => new OceanEngine(), 24, true);
+    this.reset();
+  }
+  reset() {
+    const w = [4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36];
+    for (let y = 0; y < this.rows; y++) {
+      for (let x = 0; x < this.cols; x++) {
+        const cube = this.grid.cubes[y][x];
+        cube.faces[20].fill(1);
+        cube.faces[18].fill(0);
+        cube.faces[19].fill(0);
+        for (let k = 0; k < 9; k++) {
+          cube.faces[k].fill(w[k]);
+          cube.faces[k + 9].fill(w[k]);
+        }
+      }
+    }
+    const cx = this.globalSizeW / 2;
+    const cy = this.globalSizeH / 2;
+    for (let y = 0; y < this.rows; y++) {
+      for (let x = 0; x < this.cols; x++) {
+        const cube = this.grid.cubes[y][x];
+        const obst = cube.faces[22];
+        obst.fill(0);
+        for (let ly = 0; ly < this.chunkSize; ly++) {
+          for (let lx = 0; lx < this.chunkSize; lx++) {
+            const globalX = x * this.chunkSize + lx;
+            const globalY = y * this.chunkSize + ly;
+            const dx = globalX - cx;
+            const dy = globalY - cy;
+            if (dx * dx + dy * dy < 400) {
+              obst[ly * this.chunkSize + lx] = 1;
+            }
+          }
+        }
+      }
+    }
+    for (let b of this.boats) {
+      b.x = 20;
+      b.y = 20;
+      b.vx = 0;
+      b.vy = 0;
+      b.angle = 0;
+    }
+    this.grid.compute([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22]);
+  }
+  addBoat(globalX, globalY, length = 20) {
+    this.boats.push({ x: globalX, y: globalY, vx: 0, vy: 0, length, angle: 0 });
+  }
+  step() {
+    this.grid.compute([0, 1, 2, 3, 4, 5, 6, 7, 8, 18, 19, 20, 21]);
+    for (const boat of this.boats) {
+      const gx = Math.floor(boat.x);
+      const gy = Math.floor(boat.y);
+      const safeGx = (gx + this.globalSizeW) % this.globalSizeW;
+      const safeGy = (gy + this.globalSizeH) % this.globalSizeH;
+      const chunkX = Math.floor(safeGx / this.chunkSize);
+      const chunkY = Math.floor(safeGy / this.chunkSize);
+      const localX = safeGx % this.chunkSize;
+      const localY = safeGy % this.chunkSize;
+      const cube = this.grid.cubes[chunkY][chunkX];
+      if (cube) {
+        const uxFace = cube.faces[18];
+        const uyFace = cube.faces[19];
+        const localIdx = localY * this.chunkSize + localX;
+        const fux = uxFace[localIdx];
+        const fuy = uyFace[localIdx];
+        const engineForce = 0.15;
+        const turnForce = 0.05;
+        if (this.keys.up) {
+          boat.vx += Math.cos(boat.angle) * engineForce;
+          boat.vy += Math.sin(boat.angle) * engineForce;
+        }
+        if (this.keys.down) {
+          boat.vx -= Math.cos(boat.angle) * engineForce * 0.5;
+          boat.vy -= Math.sin(boat.angle) * engineForce * 0.5;
+        }
+        if (this.keys.left) boat.angle -= turnForce;
+        if (this.keys.right) boat.angle += turnForce;
+        if (!this.keys.up && !this.keys.down && !this.keys.left && !this.keys.right) {
+          boat.vx += Math.cos(boat.angle) * 0.01;
+          boat.vy += Math.sin(boat.angle) * 0.01;
+        }
+        boat.vx += fux * 0.25 - boat.vx * 0.05;
+        boat.vy += fuy * 0.25 - boat.vy * 0.05;
+        boat.x += boat.vx;
+        boat.y += boat.vy;
+        let cDx = boat.x - this.globalSizeW / 2;
+        if (Math.abs(cDx) > this.globalSizeW / 2) cDx = cDx > 0 ? cDx - this.globalSizeW : cDx + this.globalSizeW;
+        let cDy = boat.y - this.globalSizeH / 2;
+        if (Math.abs(cDy) > this.globalSizeH / 2) cDy = cDy > 0 ? cDy - this.globalSizeH : cDy + this.globalSizeH;
+        const newDist = Math.sqrt(cDx * cDx + cDy * cDy);
+        const islandR = 24;
+        if (newDist < islandR) {
+          const angleFromIsland = Math.atan2(cDy, cDx);
+          boat.x += Math.cos(angleFromIsland) * (islandR - newDist);
+          boat.y += Math.sin(angleFromIsland) * (islandR - newDist);
+          boat.vx *= 0.1;
+          boat.vy *= 0.1;
+        }
+        boat.x = (boat.x + this.globalSizeW) % this.globalSizeW;
+        boat.y = (boat.y + this.globalSizeH) % this.globalSizeH;
+        if (Math.abs(boat.vx) > 0.01 || Math.abs(boat.vy) > 0.01) {
+          boat.angle = Math.atan2(boat.vy, boat.vx);
+        }
+      }
+    }
+  }
+  // Paramètres Globaux du "Touilleur" (Tempête/Vortex)
+  setVortexParams(strength, radius) {
+    for (let y = 0; y < this.rows; y++) {
+      for (let x = 0; x < this.cols; x++) {
+        const engine = this.grid.cubes[y][x]?.engine;
+        if (engine) {
+          engine.params.vortexStrength = strength;
+          engine.params.vortexRadius = radius;
+        }
+      }
+    }
+  }
+  /**
+   * Helper to render a specific chunk to an isolated Canvas Context
+   */
+  renderChunk(chunkX, chunkY, ctx, imageData) {
+    const cube = this.grid.cubes[chunkY][chunkX];
+    if (!cube) return;
+    const size = this.chunkSize;
+    const bio = cube.faces[21];
+    const ux = cube.faces[18];
+    const uy = cube.faces[19];
+    const obst = 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);
+    ctx.fillStyle = "#fff";
+    for (const boat of this.boats) {
+      const localBoatX = boat.x - chunkX * size;
+      const localBoatY = boat.y - chunkY * size;
+      if (localBoatX >= -boat.length && localBoatX <= size + boat.length && localBoatY >= -boat.length && localBoatY <= size + boat.length) {
+        ctx.save();
+        ctx.translate(localBoatX, localBoatY);
+        ctx.rotate(boat.angle);
+        ctx.fillRect(-boat.length / 2, -2, boat.length, 4);
+        ctx.restore();
+      }
+    }
+  }
+  // Interaction globally mapped
+  setInteraction(globalX, globalY, active) {
+    const safeGx = (globalX + this.globalSizeW) % this.globalSizeW;
+    const safeGy = (globalY + this.globalSizeH) % this.globalSizeH;
+    const chunkX = Math.floor(safeGx / this.chunkSize);
+    const chunkY = Math.floor(safeGy / this.chunkSize);
+    const localX = safeGx % this.chunkSize;
+    const localY = safeGy % this.chunkSize;
+    for (let y = 0; y < this.rows; y++) {
+      for (let x = 0; x < this.cols; x++) {
+        const engine = this.grid.cubes[y][x]?.engine;
+        if (engine) engine.interaction.active = false;
+      }
+    }
+    const cube = this.grid.cubes[chunkY][chunkX];
+    if (cube) {
+      const engine = cube.engine;
+      engine.interaction.mouseX = localX;
+      engine.interaction.mouseY = localY;
+      engine.interaction.active = active;
+    }
+  }
+};
+
+// src/templates/BlankEngine.ts
+var BlankEngine = class {
+  get name() {
+    return "My-Blank-Engine";
+  }
+  /**
+   * Called at every simulation tick.
+   * @param faces Array of Float32Array (VRAM Memory mapping of the TriadeCube)
+   *              Face[0] is typically the main Output buffer or State A
+   *              Face[1] is typically the Secondary buffer or State B (Wait/Swap)
+   * @param mapSize The N x N resolution of the chunk
+   */
+  compute(faces, mapSize) {
+    const length = mapSize * mapSize;
+    if (faces.length < 2) {
+      throw new Error(`[Triade BlankEngine] Insufficient faces. Required 2, but only got ${faces.length}. Ensure your Cube allocation specifies numFaces >= 2.`);
+    }
+    const faceIn = faces[0];
+    const faceOut = faces[1];
+    for (let i = 0; i < length; i++) {
+      const state = faceIn[i];
+      let nextState = state;
+      faceOut[i] = nextState;
+    }
+    faceIn.set(faceOut);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AerodynamicsEngine,
+  BlankEngine,
+  CanvasAdapter,
+  EcosystemEngineO1,
+  GameOfLifeEngine,
+  HeatmapEngine,
+  OceanEngine,
+  OceanSimulatorAddon,
+  OceanWebGLRenderer,
+  OceanWorld,
+  Triade,
+  TriadeCubeV2,
+  TriadeGrid,
+  TriadeMasterBuffer,
+  WebGLAdapter
+});