novac 2.3.0 → 2.4.0

package/kits/kitlife/kitdef.js

@@ -0,0 +1,575 @@
+'use strict';
+
+/**
+ * kitlife — Conway's Game of Life
+ *
+ * Full interactive terminal Life sim with:
+ *   - Toroidal (wrapping) or bounded grid
+ *   - Speed control (1–10)
+ *   - 30+ named preset patterns
+ *   - Draw mode: place/erase cells with cursor
+ *   - Stats: generation, population, births, deaths, peak
+ *   - Pattern library browser
+ *   - Random fill
+ *   - Step mode (advance one generation at a time)
+ *
+ * kitdef API:
+ *   .start()      reset to blank/preset
+ *   .input(key)   see controls below
+ *   .tick(dt)     advance simulation
+ *   .frame()      → ANSI string
+ *   .state        → 'running'|'paused'|'drawing'
+ *   .score        → generation count
+ *
+ * Controls:
+ *   SPACE         pause/resume
+ *   ENTER         step one generation (while paused)
+ *   Arrow keys    move cursor (in draw/pattern mode)
+ *   D             toggle draw mode (click cells alive/dead)
+ *   X             toggle cell under cursor (draw mode)
+ *   C             clear grid
+ *   R             random fill
+ *   +/-           speed up / slow down
+ *   P             open pattern browser
+ *   T             toggle toroidal wrapping
+ *   W/H           (with shift) resize grid (cycle presets)
+ */
+
+// ─── ANSI / CANVAS ───────────────────────────────────────────────────────────
+
+const FC = {
+  blk:30,red:31,grn:32,yel:33,blu:34,mag:35,cyn:36,wht:37,
+  BLK:90,RED:91,GRN:92,YEL:93,BLU:94,MAG:95,CYN:96,WHT:97,
+};
+const BC = {
+  blk:40,red:41,grn:42,yel:43,blu:44,mag:45,cyn:46,wht:47,
+  BLK:100,RED:101,GRN:102,YEL:103,BLU:104,MAG:105,CYN:106,WHT:107,
+};
+const RST = '\x1b[0m';
+const BLD = '\x1b[1m';
+
+function makeCanvas(W, H) {
+  const ch = Array.from({length:H}, () => new Array(W).fill(' '));
+  const fg = Array.from({length:H}, () => new Array(W).fill(FC.wht));
+  const bg = Array.from({length:H}, () => new Array(W).fill(BC.blk));
+  const cv = {
+    W, H,
+    clear(c=' ', f=FC.wht, b=BC.blk) {
+      for (let y=0;y<H;y++) for (let x=0;x<W;x++) { ch[y][x]=c;fg[y][x]=f;bg[y][x]=b; }
+    },
+    set(x, y, c, f=FC.wht, b=BC.blk) {
+      if (x<0||x>=W||y<0||y>=H) return;
+      ch[y][x]=(String(c)[0])||' '; fg[y][x]=f; bg[y][x]=b;
+    },
+    put(x, y, s, f=FC.wht, b=BC.blk) {
+      for (let i=0;i<s.length;i++) cv.set(x+i, y, s[i], f, b);
+    },
+    fill(x, y, w, h, c, f=FC.wht, b=BC.blk) {
+      for (let dy=0;dy<h;dy++) for (let dx=0;dx<w;dx++) cv.set(x+dx,y+dy,c,f,b);
+    },
+    box(x, y, w, h, f=FC.wht, b=BC.blk) {
+      cv.put(x, y, '┌'+'─'.repeat(w-2)+'┐', f, b);
+      for (let dy=1;dy<h-1;dy++) { cv.set(x,y+dy,'│',f,b); cv.set(x+w-1,y+dy,'│',f,b); }
+      cv.put(x, y+h-1, '└'+'─'.repeat(w-2)+'┘', f, b);
+    },
+    render() {
+      const lines = [];
+      for (let y=0;y<H;y++) {
+        let row='', cf=-1, cb=-1;
+        for (let x=0;x<W;x++) {
+          const f=fg[y][x], b=bg[y][x];
+          if (f!==cf||b!==cb) { row+=`\x1b[${f};${b}m`; cf=f; cb=b; }
+          row+=ch[y][x];
+        }
+        lines.push(row+RST);
+      }
+      return lines.join('\n');
+    },
+  };
+  return cv;
+}
+
+function makeEmitter() {
+  const L = new Map();
+  return {
+    on(ev,fn)  { if(!L.has(ev)) L.set(ev,[]); L.get(ev).push(fn); },
+    off(ev,fn) { if(L.has(ev)) L.set(ev,L.get(ev).filter(f=>f!==fn)); },
+    emit(ev,...a) { (L.get(ev)??[]).forEach(fn=>fn(...a)); },
+  };
+}
+
+const rng = n => Math.random()*n|0;
+const clamp = (x,lo,hi) => Math.max(lo,Math.min(hi,x));
+
+// ─── PATTERN LIBRARY ─────────────────────────────────────────────────────────
+// Patterns stored as arrays of [col, row] offsets from center, or RLE strings.
+// Using coordinate arrays for simplicity.
+
+const PATTERNS = {
+  // ── Still lifes ──
+  'Block': {
+    cells: [[0,0],[1,0],[0,1],[1,1]],
+    desc: 'Simplest still life',
+  },
+  'Beehive': {
+    cells: [[1,0],[2,0],[0,1],[3,1],[1,2],[2,2]],
+    desc: 'Common still life',
+  },
+  'Loaf': {
+    cells: [[1,0],[2,0],[0,1],[3,1],[1,2],[3,2],[2,3]],
+    desc: 'Still life',
+  },
+  'Boat': {
+    cells: [[0,0],[1,0],[0,1],[2,1],[1,2]],
+    desc: 'Still life',
+  },
+
+  // ── Oscillators ──
+  'Blinker': {
+    cells: [[0,1],[1,1],[2,1]],
+    desc: 'Period-2 oscillator',
+  },
+  'Toad': {
+    cells: [[1,0],[2,0],[3,0],[0,1],[1,1],[2,1]],
+    desc: 'Period-2 oscillator',
+  },
+  'Beacon': {
+    cells: [[0,0],[1,0],[0,1],[3,2],[2,3],[3,3]],
+    desc: 'Period-2 oscillator',
+  },
+  'Pulsar': {
+    cells: [
+      [2,0],[3,0],[4,0],[8,0],[9,0],[10,0],
+      [0,2],[5,2],[7,2],[12,2],
+      [0,3],[5,3],[7,3],[12,3],
+      [0,4],[5,4],[7,4],[12,4],
+      [2,5],[3,5],[4,5],[8,5],[9,5],[10,5],
+      [2,7],[3,7],[4,7],[8,7],[9,7],[10,7],
+      [0,8],[5,8],[7,8],[12,8],
+      [0,9],[5,9],[7,9],[12,9],
+      [0,10],[5,10],[7,10],[12,10],
+      [2,12],[3,12],[4,12],[8,12],[9,12],[10,12],
+    ],
+    desc: 'Period-3 oscillator',
+  },
+  'Pentadecathlon': {
+    cells: [[1,0],[2,0],[0,1],[3,1],[1,2],[2,2],[1,3],[2,3],[1,4],[2,4],[1,5],[2,5],[0,6],[3,6],[1,7],[2,7]],
+    desc: 'Period-15 oscillator',
+  },
+  'Clock': {
+    cells: [[1,0],[2,1],[0,1],[1,2],[2,2],[3,1]],
+    desc: 'Period-2 oscillator',
+  },
+
+  // ── Spaceships ──
+  'Glider': {
+    cells: [[1,0],[2,1],[0,2],[1,2],[2,2]],
+    desc: 'Simplest spaceship',
+  },
+  'LWSS': {
+    cells: [[1,0],[4,0],[0,1],[0,2],[4,2],[0,3],[1,3],[2,3],[3,3]],
+    desc: 'Light-weight spaceship',
+  },
+  'MWSS': {
+    cells: [[2,0],[0,1],[4,1],[0,2],[0,3],[4,3],[0,4],[1,4],[2,4],[3,4]],
+    desc: 'Middle-weight spaceship',
+  },
+  'HWSS': {
+    cells: [[2,0],[3,0],[0,1],[5,1],[0,2],[0,3],[5,3],[0,4],[1,4],[2,4],[3,4],[4,4]],
+    desc: 'Heavy-weight spaceship',
+  },
+
+  // ── Guns ──
+  'Gosper Glider Gun': {
+    cells: [
+      [24,0],
+      [22,1],[24,1],
+      [12,2],[13,2],[20,2],[21,2],[34,2],[35,2],
+      [11,3],[15,3],[20,3],[21,3],[34,3],[35,3],
+      [0,4],[1,4],[10,4],[16,4],[20,4],[21,4],
+      [0,5],[1,5],[10,5],[14,5],[16,5],[17,5],[22,5],[24,5],
+      [10,6],[16,6],[24,6],
+      [11,7],[15,7],
+      [12,8],[13,8],
+    ],
+    desc: 'Produces a glider every 30 generations',
+  },
+
+  // ── Methuselahs ──
+  'R-pentomino': {
+    cells: [[1,0],[2,0],[0,1],[1,1],[1,2]],
+    desc: 'Lives 1103 generations',
+  },
+  'Diehard': {
+    cells: [[6,0],[0,1],[1,1],[1,2],[5,2],[6,2],[7,2]],
+    desc: 'Dies after 130 generations',
+  },
+  'Acorn': {
+    cells: [[1,0],[3,1],[0,2],[1,2],[4,2],[5,2],[6,2]],
+    desc: 'Lives 5206 generations',
+  },
+
+  // ── Fun patterns ──
+  'Glider Fleet': {
+    cells: [
+      [1,0],[2,1],[0,2],[1,2],[2,2],
+      [11,0],[12,1],[10,2],[11,2],[12,2],
+      [21,0],[22,1],[20,2],[21,2],[22,2],
+      [1,10],[2,11],[0,12],[1,12],[2,12],
+      [11,10],[12,11],[10,12],[11,12],[12,12],
+    ],
+    desc: 'Five gliders in formation',
+  },
+  'Cross': {
+    cells: [
+      [2,0],[2,1],[0,2],[1,2],[2,2],[3,2],[4,2],[2,3],[2,4],
+    ],
+    desc: 'Simple cross — evolves interestingly',
+  },
+  'Pi heptomino': {
+    cells: [[0,0],[1,0],[2,0],[0,1],[2,1],[0,2],[1,2],[2,2]],
+    desc: 'Chaotic methuselah',
+  },
+  'Infinite growth': {
+    cells: [
+      [0,0],[1,0],[2,0],[3,0],[4,0],[5,0],[6,0],[7,0],
+      [9,0],[10,0],[11,0],[12,0],[13,0],
+      [17,0],[18,0],[19,0],
+      [26,0],[27,0],[28,0],[29,0],[30,0],[31,0],[32,0],
+      [34,0],[35,0],[36,0],[37,0],[38,0],
+    ],
+    desc: 'Population grows without bound',
+  },
+};
+
+const PATTERN_KEYS = Object.keys(PATTERNS);
+
+// ─── LIFE ENGINE ─────────────────────────────────────────────────────────────
+
+function makeLife(opts = {}) {
+  const GW      = opts.width  ?? 80;
+  const GH      = opts.height ?? 40;
+  const em      = makeEmitter();
+
+  // Use two flat Uint8Arrays and ping-pong
+  let cells  = new Uint8Array(GW * GH);
+  let next_  = new Uint8Array(GW * GH);
+
+  let gen, population, births, deaths, peakPop;
+  let toroidal, drawMode, speed, tickAcc, state;
+  let curX, curY;
+  let patternMenu, patternIdx;
+  let score;
+  let ageCells; // for color-by-age rendering
+
+  function idx(x, y) { return y * GW + x; }
+  function wrap(x, y) {
+    if (toroidal) return [(x + GW) % GW, (y + GH) % GH];
+    return [clamp(x, 0, GW-1), clamp(y, 0, GH-1)];
+  }
+
+  function aliveAt(x, y) {
+    if (!toroidal && (x < 0 || x >= GW || y < 0 || y >= GH)) return 0;
+    const [wx, wy] = wrap(x, y);
+    return cells[idx(wx, wy)];
+  }
+
+  function countNeighbors(x, y) {
+    return aliveAt(x-1,y-1) + aliveAt(x,y-1) + aliveAt(x+1,y-1) +
+           aliveAt(x-1,y)                     + aliveAt(x+1,y)   +
+           aliveAt(x-1,y+1) + aliveAt(x,y+1) + aliveAt(x+1,y+1);
+  }
+
+  function step() {
+    let born = 0, died = 0;
+    for (let y = 0; y < GH; y++) {
+      for (let x = 0; x < GW; x++) {
+        const n   = countNeighbors(x, y);
+        const was = cells[idx(x, y)];
+        let  now  = 0;
+        if (was) {
+          now = (n === 2 || n === 3) ? 1 : 0;
+        } else {
+          now = n === 3 ? 1 : 0;
+        }
+        next_[idx(x, y)] = now;
+        if (!was &&  now) { born++; ageCells[idx(x,y)] = 0; }
+        if ( was && !now) { died++; ageCells[idx(x,y)] = 0; }
+        if ( was &&  now) ageCells[idx(x,y)] = Math.min(ageCells[idx(x,y)] + 1, 15);
+      }
+    }
+    // swap buffers
+    [cells, next_] = [next_, cells];
+    births     += born;
+    deaths     += died;
+    gen        += 1;
+    population  = cells.reduce((s, v) => s + v, 0);
+    peakPop     = Math.max(peakPop, population);
+    score       = gen;
+    em.emit('score', score);
+  }
+
+  function setCell(x, y, v) {
+    if (x < 0 || x >= GW || y < 0 || y >= GH) return;
+    cells[idx(x, y)] = v;
+    if (v) ageCells[idx(x, y)] = 0;
+  }
+
+  function placePattern(key, cx, cy) {
+    const pat = PATTERNS[key];
+    if (!pat) return;
+    for (const [dx, dy] of pat.cells) {
+      setCell(cx + dx, cy + dy, 1);
+    }
+    population = cells.reduce((s,v)=>s+v,0);
+  }
+
+  function randomFill(density = 0.3) {
+    for (let i = 0; i < GW * GH; i++) {
+      cells[i]    = Math.random() < density ? 1 : 0;
+      ageCells[i] = 0;
+    }
+    population = cells.reduce((s,v)=>s+v,0);
+  }
+
+  function clearGrid() {
+    cells.fill(0);
+    ageCells.fill(0);
+    population = 0;
+  }
+
+  function start(presetKey) {
+    cells     = new Uint8Array(GW * GH);
+    next_     = new Uint8Array(GW * GH);
+    ageCells  = new Uint8Array(GW * GH);
+    gen = 0; births = 0; deaths = 0; population = 0; peakPop = 0;
+    toroidal = opts.toroidal ?? true;
+    drawMode = false;
+    speed    = opts.speed ?? 5;       // 1..10
+    tickAcc  = 0;
+    state    = 'running';
+    curX     = GW >> 1;
+    curY     = GH >> 1;
+    patternMenu = false;
+    patternIdx  = 0;
+    score    = 0;
+
+    const key = presetKey ?? opts.preset ?? 'Gosper Glider Gun';
+    if (PATTERNS[key]) {
+      const cx = (GW >> 1) - 20;
+      const cy = (GH >> 1) - 6;
+      placePattern(key, cx, cy);
+    } else {
+      randomFill();
+    }
+    population = cells.reduce((s,v)=>s+v,0);
+    em.emit('start');
+  }
+
+  // ── speed → ms per generation ──────────────────────────────────────────────
+  function msPerGen() {
+    // speed 1 = 1000ms, speed 10 = 30ms
+    return Math.round(1000 / (speed * speed * 0.1 + 0.1));
+  }
+
+  // ── input ──────────────────────────────────────────────────────────────────
+  function input(key) {
+    // Pattern menu navigation
+    if (patternMenu) {
+      if (key === 'escape' || key === 'p') { patternMenu = false; return; }
+      if (key === 'up')    { patternIdx = (patternIdx - 1 + PATTERN_KEYS.length) % PATTERN_KEYS.length; return; }
+      if (key === 'down')  { patternIdx = (patternIdx + 1) % PATTERN_KEYS.length; return; }
+      if (key === 'enter' || key === 'space') {
+        clearGrid();
+        placePattern(PATTERN_KEYS[patternIdx], (GW>>1)-10, (GH>>1)-7);
+        gen=0; births=0; deaths=0; score=0;
+        patternMenu = false;
+        state = 'paused';
+      }
+      return;
+    }
+
+    if (key === 'p')                          { patternMenu = true; return; }
+    if (key === 'space')                      { state = state === 'running' ? 'paused' : 'running'; return; }
+    if (key === 'enter' && state==='paused')  { step(); return; }
+    if (key === 'd')                          { drawMode = !drawMode; return; }
+    if (key === 't')                          { toroidal = !toroidal; return; }
+    if (key === 'c')                          { clearGrid(); gen=0; births=0; deaths=0; return; }
+    if (key === 'r')                          { randomFill(); gen=0; births=0; deaths=0; return; }
+    if (key === '+' || key === '=')           { speed = clamp(speed+1, 1, 10); return; }
+    if (key === '-')                          { speed = clamp(speed-1, 1, 10); return; }
+
+    // cursor movement
+    const step_ = drawMode ? 1 : 3;
+    if (key === 'up')    curY = clamp(curY - step_, 0, GH-1);
+    if (key === 'down')  curY = clamp(curY + step_, 0, GH-1);
+    if (key === 'left')  curX = clamp(curX - step_, 0, GW-1);
+    if (key === 'right') curX = clamp(curX + step_, 0, GW-1);
+
+    // draw mode: x toggles cell, f fills 3x3, e erases 3x3
+    if (drawMode) {
+      if (key === 'x' || key === 'z') {
+        setCell(curX, curY, cells[idx(curX,curY)] ? 0 : 1);
+        population = cells.reduce((s,v)=>s+v,0);
+      }
+      if (key === 'f') {
+        for (let dy=-1;dy<=1;dy++) for (let dx=-1;dx<=1;dx++) setCell(curX+dx, curY+dy, 1);
+        population = cells.reduce((s,v)=>s+v,0);
+      }
+      if (key === 'e') {
+        for (let dy=-2;dy<=2;dy++) for (let dx=-2;dx<=2;dx++) setCell(curX+dx, curY+dy, 0);
+        population = cells.reduce((s,v)=>s+v,0);
+      }
+    }
+  }
+
+  // ── tick ───────────────────────────────────────────────────────────────────
+  function tick(dt = 16) {
+    if (state !== 'running') return;
+    tickAcc += dt;
+    const threshold = msPerGen();
+    while (tickAcc >= threshold) {
+      tickAcc -= threshold;
+      step();
+    }
+  }
+
+  // ── frame ──────────────────────────────────────────────────────────────────
+
+  // Map age → color (young=bright, old=dim)
+  const AGE_COLORS = [
+    FC.WHT, FC.CYN, FC.GRN, FC.YEL, FC.yel,
+    FC.grn, FC.cyn, FC.BLK, FC.BLK, FC.BLK,
+  ];
+
+  function frame() {
+    // We render the grid using half-block trick: each terminal row = 2 grid rows
+    // '▀' = top cell alive, '▄' = bottom cell alive, '█' = both, ' ' = neither
+    const PANEL_W = 22;
+    const DISP_W  = GW;   // grid cols = terminal cols (1 char per cell for speed)
+    const DISP_H  = Math.ceil(GH / 2); // half-block rows
+    const TOTAL_W = DISP_W + PANEL_W + 1;
+    const TOTAL_H = DISP_H + 3;
+
+    const cv = makeCanvas(TOTAL_W, TOTAL_H);
+    cv.clear(' ', FC.wht, BC.blk);
+
+    // ── header ──
+    const stateStr = patternMenu ? 'PATTERN' : state.toUpperCase();
+    const modeStr  = drawMode ? ' DRAW' : '';
+    cv.put(0, 0,
+      ` LIFE  Gen:${String(gen).padStart(6,' ')}  Pop:${String(population).padStart(5,' ')}` +
+      `  Spd:${speed}  ${stateStr}${modeStr}  ${toroidal?'⟳ Wrap':'■ Bound'}`,
+      FC.YEL, BC.blk);
+    cv.put(0, 1, '─'.repeat(Math.min(TOTAL_W, 80)), FC.BLK, BC.blk);
+
+    if (patternMenu) {
+      // ── pattern browser overlay ──
+      const W2=50, H2=Math.min(PATTERN_KEYS.length+4, 30);
+      const ox=(TOTAL_W-W2)>>1, oy=2;
+      cv.fill(ox, oy, W2, H2, ' ', FC.wht, BC.blk);
+      cv.box(ox, oy, W2, H2, FC.CYN, BC.blk);
+      cv.put(ox+2, oy, ' PATTERN LIBRARY ', FC.YEL, BC.blk);
+      const visible = 20;
+      const start_  = Math.max(0, patternIdx - (visible>>1));
+      for (let i=0; i<visible; i++) {
+        const ki = start_ + i;
+        if (ki >= PATTERN_KEYS.length) break;
+        const k   = PATTERN_KEYS[ki];
+        const sel = ki === patternIdx;
+        const pat = PATTERNS[k];
+        cv.put(ox+2, oy+1+i,
+          `${sel?'▶':' '} ${k.padEnd(22,' ')} ${pat.desc.slice(0,18)}`,
+          sel ? FC.YEL : FC.wht, BC.blk);
+      }
+      cv.put(ox+2, oy+H2-2, '↑↓ browse  ENTER place  ESC cancel', FC.BLK, BC.blk);
+    }
+
+    // ── grid ──
+    for (let row = 0; row < DISP_H; row++) {
+      const y0 = row * 2;
+      const y1 = y0 + 1;
+      for (let x = 0; x < GW; x++) {
+        const a = cells[idx(x, y0)];
+        const b = (y1 < GH) ? cells[idx(x, y1)] : 0;
+        const age = ageCells[idx(x, y0)];
+        const col = AGE_COLORS[Math.min(age, AGE_COLORS.length-1)];
+        const isCur = drawMode && x === curX && (y0 === curY || y1 === curY);
+        if (isCur) {
+          cv.set(x, row+2, '◎', FC.RED, BC.blk);
+        } else if (a && b) {
+          cv.set(x, row+2, '█', col, BC.blk);
+        } else if (a) {
+          cv.set(x, row+2, '▀', col, BC.blk);
+        } else if (b) {
+          cv.set(x, row+2, '▄', col, BC.blk);
+        } else {
+          cv.set(x, row+2, ' ', FC.BLK, BC.blk);
+        }
+      }
+    }
+
+    // ── side panel ──
+    const px = DISP_W + 1;
+    let py = 2;
+    const P = (s, f=FC.wht) => { cv.put(px, py++, s.slice(0,PANEL_W), f, BC.blk); };
+
+    P(`┌─ STATS ──────────┐`, FC.BLK);
+    P(`  Gen:   ${String(gen).padStart(9,' ')}`, FC.CYN);
+    P(`  Pop:   ${String(population).padStart(9,' ')}`, FC.GRN);
+    P(`  Peak:  ${String(peakPop).padStart(9,' ')}`, FC.YEL);
+    P(`  Born:  ${String(births).padStart(9,' ')}`, FC.GRN);
+    P(`  Died:  ${String(deaths).padStart(9,' ')}`, FC.RED);
+    P(`  Speed: ${'▰'.repeat(speed)}${'▱'.repeat(10-speed)}`, FC.MAG);
+    P(`  ${toroidal?'Toroidal wrap   ':'Bounded grid    '}`, FC.BLK);
+    P(`└──────────────────┘`, FC.BLK);
+    py++;
+    P(`┌─ CONTROLS ───────┐`, FC.BLK);
+    P(`  SPACE  pause/run `, FC.wht);
+    P(`  ENTER  step      `, FC.wht);
+    P(`  +/-    speed     `, FC.wht);
+    P(`  D      draw mode `, drawMode?FC.YEL:FC.wht);
+    P(`  X      toggle cell`, FC.wht);
+    P(`  F/E    fill/erase`, FC.wht);
+    P(`  C      clear     `, FC.wht);
+    P(`  R      random    `, FC.wht);
+    P(`  P      patterns  `, FC.wht);
+    P(`  T      wrap      `, FC.wht);
+    P(`└──────────────────┘`, FC.BLK);
+
+    // legend
+    cv.put(0, TOTAL_H-1,
+      ' New:' + `\x1b[${FC.WHT}m██\x1b[0m` +
+      ' Mid:' + `\x1b[${FC.GRN}m██\x1b[0m` +
+      ' Old:' + `\x1b[${FC.BLK}m██\x1b[0m` +
+      `  Cursor:${curX},${curY}`,
+      FC.BLK, BC.blk);
+
+    return cv.render();
+  }
+
+  return {
+    start, input, tick, frame,
+    on:  em.on.bind(em),
+    off: em.off.bind(em),
+    get state()  { return state; },
+    get score()  { return score; },
+    get gen()    { return gen;   },
+    get pop()    { return population; },
+    patterns: PATTERN_KEYS,
+  };
+}
+
+// ─── EXPORT ──────────────────────────────────────────────────────────────────
+
+const kitdef = {
+  Life: (opts) => {
+    const g = makeLife(opts);
+    g.start(opts?.preset);
+    return g;
+  },
+  patterns: PATTERN_KEYS,
+  makeLife, PATTERNS 
+};
+
+module.exports = { kitdef };