@rotifer/playground 0.8.1 → 0.8.5

package/genes/evolve-life/index.ts

@@ -1,255 +0,0 @@
-interface LifeInput {
-  width?: number;
-  height?: number;
-  generations?: number;
-  preset?: "glider" | "pulsar" | "blinker" | "beacon" | "r-pentomino" | "random";
-  grid?: number[][];
-  rule?: string;
-  seed?: number;
-}
-
-interface LifeOutput {
-  final_grid: number[][];
-  alive_count: number;
-  peak_population: number;
-  stabilized_at: number;
-  extinction: boolean;
-  generations_computed: number;
-  cells_processed: number;
-  ascii_snapshot?: string;
-}
-
-function parseRule(rule: string): { birth: Set<number>; survive: Set<number> } {
-  const birth = new Set<number>();
-  const survive = new Set<number>();
-  const match = rule.match(/B([0-8]*)\/S([0-8]*)/);
-  if (!match) return { birth: new Set([3]), survive: new Set([2, 3]) };
-  for (const ch of match[1]) birth.add(parseInt(ch));
-  for (const ch of match[2]) survive.add(parseInt(ch));
-  return { birth, survive };
-}
-
-function mulberry32(seed: number): () => number {
-  let s = seed | 0;
-  return () => {
-    s = (s + 0x6d2b79f5) | 0;
-    let t = Math.imul(s ^ (s >>> 15), 1 | s);
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-function createGrid(w: number, h: number): number[][] {
-  const g: number[][] = [];
-  for (let y = 0; y < h; y++) {
-    g.push(new Array(w).fill(0));
-  }
-  return g;
-}
-
-function placePattern(grid: number[][], pattern: number[][], cx: number, cy: number): void {
-  for (let py = 0; py < pattern.length; py++) {
-    for (let px = 0; px < pattern[py].length; px++) {
-      const gy = cy + py;
-      const gx = cx + px;
-      if (gy >= 0 && gy < grid.length && gx >= 0 && gx < grid[0].length) {
-        grid[gy][gx] = pattern[py][px];
-      }
-    }
-  }
-}
-
-function applyPreset(grid: number[][], preset: string, seed?: number): void {
-  const w = grid[0].length;
-  const h = grid.length;
-  const cx = Math.floor(w / 2);
-  const cy = Math.floor(h / 2);
-
-  switch (preset) {
-    case "glider":
-      placePattern(grid, [
-        [0, 1, 0],
-        [0, 0, 1],
-        [1, 1, 1],
-      ], cx - 1, cy - 1);
-      break;
-
-    case "blinker":
-      placePattern(grid, [[1, 1, 1]], cx - 1, cy);
-      break;
-
-    case "beacon":
-      placePattern(grid, [
-        [1, 1, 0, 0],
-        [1, 1, 0, 0],
-        [0, 0, 1, 1],
-        [0, 0, 1, 1],
-      ], cx - 2, cy - 2);
-      break;
-
-    case "pulsar":
-      placePattern(grid, [
-        [0,0,1,1,1,0,0,0,1,1,1,0,0],
-        [0,0,0,0,0,0,0,0,0,0,0,0,0],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [0,0,1,1,1,0,0,0,1,1,1,0,0],
-        [0,0,0,0,0,0,0,0,0,0,0,0,0],
-        [0,0,1,1,1,0,0,0,1,1,1,0,0],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [0,0,0,0,0,0,0,0,0,0,0,0,0],
-        [0,0,1,1,1,0,0,0,1,1,1,0,0],
-      ], cx - 6, cy - 6);
-      break;
-
-    case "r-pentomino":
-      placePattern(grid, [
-        [0, 1, 1],
-        [1, 1, 0],
-        [0, 1, 0],
-      ], cx - 1, cy - 1);
-      break;
-
-    case "random": {
-      const rng = mulberry32(seed ?? 42);
-      const density = 0.35;
-      for (let y = 0; y < h; y++) {
-        for (let x = 0; x < w; x++) {
-          grid[y][x] = rng() < density ? 1 : 0;
-        }
-      }
-      break;
-    }
-  }
-}
-
-function countAlive(grid: number[][]): number {
-  let count = 0;
-  for (let y = 0; y < grid.length; y++) {
-    for (let x = 0; x < grid[0].length; x++) {
-      count += grid[y][x];
-    }
-  }
-  return count;
-}
-
-function gridHash(grid: number[][]): string {
-  let hash = 0;
-  for (let y = 0; y < grid.length; y++) {
-    for (let x = 0; x < grid[0].length; x++) {
-      hash = ((hash << 5) - hash + grid[y][x]) | 0;
-    }
-  }
-  return hash.toString(36);
-}
-
-function step(
-  current: number[][],
-  next: number[][],
-  w: number,
-  h: number,
-  birth: Set<number>,
-  survive: Set<number>
-): void {
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      let neighbors = 0;
-      for (let dy = -1; dy <= 1; dy++) {
-        for (let dx = -1; dx <= 1; dx++) {
-          if (dy === 0 && dx === 0) continue;
-          const ny = (y + dy + h) % h;
-          const nx = (x + dx + w) % w;
-          neighbors += current[ny][nx];
-        }
-      }
-      if (current[y][x] === 1) {
-        next[y][x] = survive.has(neighbors) ? 1 : 0;
-      } else {
-        next[y][x] = birth.has(neighbors) ? 1 : 0;
-      }
-    }
-  }
-}
-
-function toAscii(grid: number[][], maxW: number, maxH: number): string {
-  const h = Math.min(grid.length, maxH);
-  const w = Math.min(grid[0].length, maxW);
-  const lines: string[] = [];
-  for (let y = 0; y < h; y++) {
-    let line = "";
-    for (let x = 0; x < w; x++) {
-      line += grid[y][x] ? "\u2588" : "\u00b7";
-    }
-    lines.push(line);
-  }
-  return lines.join("\n");
-}
-
-export async function express(input: LifeInput): Promise<LifeOutput> {
-  const w = Math.max(4, Math.min(512, input.width ?? 64));
-  const h = Math.max(4, Math.min(512, input.height ?? 64));
-  const maxGen = Math.max(1, Math.min(10000, input.generations ?? 100));
-  const { birth, survive } = parseRule(input.rule ?? "B3/S23");
-
-  let gridA = createGrid(w, h);
-  let gridB = createGrid(w, h);
-
-  if (input.preset) {
-    applyPreset(gridA, input.preset, input.seed);
-  } else if (input.grid) {
-    for (let y = 0; y < Math.min(input.grid.length, h); y++) {
-      for (let x = 0; x < Math.min(input.grid[y].length, w); x++) {
-        gridA[y][x] = input.grid[y][x] ? 1 : 0;
-      }
-    }
-  } else {
-    applyPreset(gridA, "random", input.seed);
-  }
-
-  let peak = countAlive(gridA);
-  let stabilizedAt = -1;
-  let extinction = false;
-  let gen = 0;
-
-  let prevHash = gridHash(gridA);
-  let prevPrevHash = "";
-
-  for (gen = 0; gen < maxGen; gen++) {
-    step(gridA, gridB, w, h, birth, survive);
-    [gridA, gridB] = [gridB, gridA];
-
-    const alive = countAlive(gridA);
-    if (alive > peak) peak = alive;
-
-    if (alive === 0) {
-      extinction = true;
-      gen++;
-      break;
-    }
-
-    const currentHash = gridHash(gridA);
-    if (currentHash === prevHash || currentHash === prevPrevHash) {
-      stabilizedAt = gen + 1;
-      gen++;
-      break;
-    }
-    prevPrevHash = prevHash;
-    prevHash = currentHash;
-  }
-
-  const finalAlive = countAlive(gridA);
-
-  return {
-    final_grid: gridA,
-    alive_count: finalAlive,
-    peak_population: peak,
-    stabilized_at: stabilizedAt,
-    extinction,
-    generations_computed: gen,
-    cells_processed: w * h * gen,
-    ascii_snapshot: toAscii(gridA, 80, 40),
-  };
-}

package/genes/evolve-life/phenotype.json

@@ -1,129 +0,0 @@
-{
-  "domain": "evolve.life",
-  "description": "Conway's Game of Life simulator. Computes cellular automaton evolution from an initial grid state over N generations. Supports preset patterns (glider, pulsar, random) and custom grids. Pure computation \u2014 ideal Native Gene benchmark.",
-  "inputSchema": {
-    "type": "object",
-    "properties": {
-      "width": {
-        "type": "number",
-        "description": "Grid width in cells",
-        "default": 64,
-        "minimum": 4,
-        "maximum": 512
-      },
-      "height": {
-        "type": "number",
-        "description": "Grid height in cells",
-        "default": 64,
-        "minimum": 4,
-        "maximum": 512
-      },
-      "generations": {
-        "type": "number",
-        "description": "Number of generations to simulate",
-        "default": 100,
-        "minimum": 1,
-        "maximum": 10000
-      },
-      "preset": {
-        "type": "string",
-        "description": "Initial pattern preset. Overrides grid if provided.",
-        "enum": [
-          "glider",
-          "pulsar",
-          "blinker",
-          "beacon",
-          "r-pentomino",
-          "random"
-        ]
-      },
-      "grid": {
-        "type": "array",
-        "description": "Custom initial grid (2D array of 0s and 1s). Ignored if preset is set.",
-        "items": {
-          "type": "array",
-          "items": {
-            "type": "number",
-            "enum": [
-              0,
-              1
-            ]
-          }
-        }
-      },
-      "rule": {
-        "type": "string",
-        "description": "Life-like rule in B/S notation (default: B3/S23 for Conway's Life)",
-        "default": "B3/S23"
-      },
-      "seed": {
-        "type": "number",
-        "description": "Random seed for 'random' preset (deterministic output)"
-      }
-    },
-    "required": []
-  },
-  "outputSchema": {
-    "type": "object",
-    "properties": {
-      "final_grid": {
-        "type": "array",
-        "description": "Grid state after all generations",
-        "items": {
-          "type": "array",
-          "items": {
-            "type": "number",
-            "enum": [
-              0,
-              1
-            ]
-          }
-        }
-      },
-      "alive_count": {
-        "type": "number",
-        "description": "Number of live cells in final grid"
-      },
-      "peak_population": {
-        "type": "number",
-        "description": "Maximum live cells observed across all generations"
-      },
-      "stabilized_at": {
-        "type": "number",
-        "description": "Generation at which the grid stabilized (-1 if not stabilized)"
-      },
-      "extinction": {
-        "type": "boolean",
-        "description": "Whether all cells died before final generation"
-      },
-      "generations_computed": {
-        "type": "number",
-        "description": "Actual number of generations computed (may be less if stabilized/extinct)"
-      },
-      "cells_processed": {
-        "type": "number",
-        "description": "Total cell evaluations (width * height * generations_computed)"
-      },
-      "ascii_snapshot": {
-        "type": "string",
-        "description": "ASCII art of the final grid state (max 80x40)"
-      }
-    },
-    "required": [
-      "final_grid",
-      "alive_count",
-      "peak_population",
-      "stabilized_at",
-      "extinction",
-      "generations_computed",
-      "cells_processed"
-    ]
-  },
-  "dependencies": [],
-  "version": "0.2.0",
-  "author": "rotifer-team",
-  "createdAt": 1741906800000,
-  "fidelity": "Native",
-  "transparency": "Open",
-  "ir_hash": "f04e1e5913d7b6624630254dc97e18f2bea5b113bd52e3cd6fdddc0ce0f471c2"
-}

package/genes/evolve-life-bitwise/.cloud-manifest.json

@@ -1,6 +0,0 @@
-{
-  "cloud_id": "f6f7b7b6-9d59-4977-862d-fad378e1c422",
-  "owner": "Rotifer Protocol",
-  "version": "0.2.0",
-  "published_at": "2026-03-17T14:12:38.343Z"
-}

package/genes/evolve-life-bitwise/.compile-result.json

@@ -1,12 +0,0 @@
-{
-  "geneId": "5c2d27d8cc0f8f2d5be5bdf95b4c5b499a8a753c5181dc6551a55eb000ca2628",
-  "name": "evolve-life-bitwise",
-  "domain": "evolve.life",
-  "compiledAt": "2026-03-14T06:25:01.974Z",
-  "fidelity": "Native",
-  "wasmAvailable": true,
-  "irHash": "29095a3f52e096d1e8ba016b9025cacb90e95f9be1b157f6f5d0c487114ec538",
-  "totalSize": 1307563,
-  "codeSectionSize": 956115,
-  "durationMs": 4505
-}

package/genes/evolve-life-bitwise/index.ts

@@ -1,273 +0,0 @@
-interface LifeInput {
-  width?: number;
-  height?: number;
-  generations?: number;
-  preset?: "glider" | "pulsar" | "blinker" | "beacon" | "r-pentomino" | "random";
-  grid?: number[][];
-  rule?: string;
-  seed?: number;
-}
-
-interface LifeOutput {
-  final_grid: number[][];
-  alive_count: number;
-  peak_population: number;
-  stabilized_at: number;
-  extinction: boolean;
-  generations_computed: number;
-  cells_processed: number;
-  ascii_snapshot?: string;
-}
-
-function parseRule(rule: string): { birth: number[]; survive: number[] } {
-  const birth: number[] = [];
-  const survive: number[] = [];
-  const match = rule.match(/B([0-8]*)\/S([0-8]*)/);
-  if (!match) return { birth: [3], survive: [2, 3] };
-  for (const ch of match[1]) birth.push(parseInt(ch));
-  for (const ch of match[2]) survive.push(parseInt(ch));
-  return { birth, survive };
-}
-
-function mulberry32(seed: number): () => number {
-  let s = seed | 0;
-  return () => {
-    s = (s + 0x6d2b79f5) | 0;
-    let t = Math.imul(s ^ (s >>> 15), 1 | s);
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-const WORD_BITS = 32;
-
-function wordsPerRow(w: number): number {
-  return ((w + WORD_BITS - 1) / WORD_BITS) | 0;
-}
-
-function createBitGrid(w: number, h: number): Int32Array {
-  return new Int32Array(h * wordsPerRow(w));
-}
-
-function getBit(grid: Int32Array, wpr: number, x: number, y: number): number {
-  const wordIdx = y * wpr + ((x / WORD_BITS) | 0);
-  const bitIdx = x % WORD_BITS;
-  return (grid[wordIdx] >>> bitIdx) & 1;
-}
-
-function setBit(grid: Int32Array, wpr: number, x: number, y: number): void {
-  const wordIdx = y * wpr + ((x / WORD_BITS) | 0);
-  const bitIdx = x % WORD_BITS;
-  grid[wordIdx] |= 1 << bitIdx;
-}
-
-function popcount32(v: number): number {
-  v = v - ((v >>> 1) & 0x55555555);
-  v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);
-  return (((v + (v >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
-}
-
-function countAlive(grid: Int32Array): number {
-  let count = 0;
-  for (let i = 0; i < grid.length; i++) {
-    count += popcount32(grid[i]);
-  }
-  return count;
-}
-
-function gridHash(grid: Int32Array): number {
-  let h = 0;
-  for (let i = 0; i < grid.length; i++) {
-    h = ((h << 5) - h + grid[i]) | 0;
-  }
-  return h;
-}
-
-function placePattern(grid: Int32Array, wpr: number, w: number, h: number, pattern: number[][], ox: number, oy: number): void {
-  for (let py = 0; py < pattern.length; py++) {
-    for (let px = 0; px < pattern[py].length; px++) {
-      if (pattern[py][px]) {
-        const gx = ox + px;
-        const gy = oy + py;
-        if (gx >= 0 && gx < w && gy >= 0 && gy < h) setBit(grid, wpr, gx, gy);
-      }
-    }
-  }
-}
-
-function applyPreset(grid: Int32Array, wpr: number, w: number, h: number, preset: string, seed?: number): void {
-  const cx = (w / 2) | 0;
-  const cy = (h / 2) | 0;
-
-  switch (preset) {
-    case "glider":
-      placePattern(grid, wpr, w, h, [[0,1,0],[0,0,1],[1,1,1]], cx - 1, cy - 1);
-      break;
-    case "blinker":
-      placePattern(grid, wpr, w, h, [[1,1,1]], cx - 1, cy);
-      break;
-    case "beacon":
-      placePattern(grid, wpr, w, h, [[1,1,0,0],[1,1,0,0],[0,0,1,1],[0,0,1,1]], cx - 2, cy - 2);
-      break;
-    case "pulsar":
-      placePattern(grid, wpr, w, h, [
-        [0,0,1,1,1,0,0,0,1,1,1,0,0],
-        [0,0,0,0,0,0,0,0,0,0,0,0,0],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [0,0,1,1,1,0,0,0,1,1,1,0,0],
-        [0,0,0,0,0,0,0,0,0,0,0,0,0],
-        [0,0,1,1,1,0,0,0,1,1,1,0,0],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [1,0,0,0,0,1,0,1,0,0,0,0,1],
-        [0,0,0,0,0,0,0,0,0,0,0,0,0],
-        [0,0,1,1,1,0,0,0,1,1,1,0,0],
-      ], cx - 6, cy - 6);
-      break;
-    case "r-pentomino":
-      placePattern(grid, wpr, w, h, [[0,1,1],[1,1,0],[0,1,0]], cx - 1, cy - 1);
-      break;
-    case "random": {
-      const rng = mulberry32(seed ?? 42);
-      for (let y = 0; y < h; y++) {
-        for (let x = 0; x < w; x++) {
-          if (rng() < 0.35) setBit(grid, wpr, x, y);
-        }
-      }
-      break;
-    }
-  }
-}
-
-function step(
-  current: Int32Array,
-  next: Int32Array,
-  w: number,
-  h: number,
-  wpr: number,
-  birthLut: Uint8Array,
-  surviveLut: Uint8Array
-): void {
-  next.fill(0);
-  for (let y = 0; y < h; y++) {
-    const yn = (y - 1 + h) % h;
-    const ys = (y + 1) % h;
-    for (let x = 0; x < w; x++) {
-      let neighbors = 0;
-      const xw = (x - 1 + w) % w;
-      const xe = (x + 1) % w;
-      neighbors += getBit(current, wpr, xw, yn);
-      neighbors += getBit(current, wpr, x,  yn);
-      neighbors += getBit(current, wpr, xe, yn);
-      neighbors += getBit(current, wpr, xw, y);
-      neighbors += getBit(current, wpr, xe, y);
-      neighbors += getBit(current, wpr, xw, ys);
-      neighbors += getBit(current, wpr, x,  ys);
-      neighbors += getBit(current, wpr, xe, ys);
-
-      const isAlive = getBit(current, wpr, x, y);
-      if (isAlive ? surviveLut[neighbors] : birthLut[neighbors]) {
-        setBit(next, wpr, x, y);
-      }
-    }
-  }
-}
-
-function bitGridToArray(grid: Int32Array, wpr: number, w: number, h: number): number[][] {
-  const result: number[][] = [];
-  for (let y = 0; y < h; y++) {
-    const row = new Array(w);
-    for (let x = 0; x < w; x++) {
-      row[x] = getBit(grid, wpr, x, y);
-    }
-    result.push(row);
-  }
-  return result;
-}
-
-function toAscii(grid: Int32Array, wpr: number, w: number, h: number): string {
-  const maxW = Math.min(w, 80);
-  const maxH = Math.min(h, 40);
-  const lines: string[] = [];
-  for (let y = 0; y < maxH; y++) {
-    let line = "";
-    for (let x = 0; x < maxW; x++) {
-      line += getBit(grid, wpr, x, y) ? "\u2588" : "\u00b7";
-    }
-    lines.push(line);
-  }
-  return lines.join("\n");
-}
-
-export async function express(input: LifeInput): Promise<LifeOutput> {
-  const w = Math.max(4, Math.min(512, input.width ?? 64));
-  const h = Math.max(4, Math.min(512, input.height ?? 64));
-  const maxGen = Math.max(1, Math.min(10000, input.generations ?? 100));
-  const { birth, survive } = parseRule(input.rule ?? "B3/S23");
-
-  const birthLut = new Uint8Array(9);
-  const surviveLut = new Uint8Array(9);
-  for (const b of birth) birthLut[b] = 1;
-  for (const s of survive) surviveLut[s] = 1;
-
-  const wpr = wordsPerRow(w);
-  let gridA = createBitGrid(w, h);
-  let gridB = createBitGrid(w, h);
-
-  if (input.preset) {
-    applyPreset(gridA, wpr, w, h, input.preset, input.seed);
-  } else if (input.grid) {
-    for (let y = 0; y < Math.min(input.grid.length, h); y++) {
-      for (let x = 0; x < Math.min(input.grid[y].length, w); x++) {
-        if (input.grid[y][x]) setBit(gridA, wpr, x, y);
-      }
-    }
-  } else {
-    applyPreset(gridA, wpr, w, h, "random", input.seed);
-  }
-
-  let peak = countAlive(gridA);
-  let stabilizedAt = -1;
-  let extinction = false;
-  let gen = 0;
-  let prevHash = gridHash(gridA);
-  let prevPrevHash = 0;
-
-  for (gen = 0; gen < maxGen; gen++) {
-    step(gridA, gridB, w, h, wpr, birthLut, surviveLut);
-    [gridA, gridB] = [gridB, gridA];
-
-    const alive = countAlive(gridA);
-    if (alive > peak) peak = alive;
-
-    if (alive === 0) {
-      extinction = true;
-      gen++;
-      break;
-    }
-
-    const currentHash = gridHash(gridA);
-    if (currentHash === prevHash || currentHash === prevPrevHash) {
-      stabilizedAt = gen + 1;
-      gen++;
-      break;
-    }
-    prevPrevHash = prevHash;
-    prevHash = currentHash;
-  }
-
-  const finalAlive = countAlive(gridA);
-
-  return {
-    final_grid: bitGridToArray(gridA, wpr, w, h),
-    alive_count: finalAlive,
-    peak_population: peak,
-    stabilized_at: stabilizedAt,
-    extinction,
-    generations_computed: gen,
-    cells_processed: w * h * gen,
-    ascii_snapshot: toAscii(gridA, wpr, w, h),
-  };
-}