hbengine 0.2.3

package/engine-examples/tower/AGENTS.md

@@ -0,0 +1,3 @@
+# For agents
+
+This is a House Engine game (Housebets). Read the guide first: `engine_guide` (MCP) or `engine-sdk/GUIDE.md`. Then `hbengine verify`, `hbengine dev`, `hbengine upload` (or the `engine_*` tools). The math is `math/`, the frontend `bundle/`; never compute money or outcomes in the frontend.

package/engine-examples/tower/README.md

@@ -0,0 +1,21 @@
+# Tower — a ladder with cash-out
+
+Eight floors; four tiles each, one is a trap. Every floor survived multiplies
+the pot by about 4/3; the player cashes out after any floor, or loses the
+stake on a trap. Max 9.89×.
+
+Cumulative payout after k survived floors, exactly (`ladderBp`):
+
+    13200 · 17600 · 23466 · 31288 · 41718 · 55624 · 74166 · 98888 bp
+
+RTP of stopping after floor k = ladderBp[k-1] · (3/4)^k, every stop ≤ 99 %:
+
+    9900 · 9900 · 9899.72 · 9899.72 · 9899.88 · 9899.88 · 9899.97 · 9899.97 bp
+
+The best stop bounds every strategy (the player learns only "survived so
+far"), so the bet's RTP is 99.00 %. The panel (`/engine-sdk/ui.js`) draws Bet,
+Next and Cash out; this bundle's `game.js` renders the tower and reveals each
+floor the server drew.
+
+    npx hbengine verify .                      exact RTP per stop, the mathHash
+    npx hbengine init my-tower --template tower --slug my-tower   # make it yours, then: verify, dev, upload

package/engine-examples/tower/bundle/assets.json

@@ -0,0 +1 @@
+{ "groups": { "boot": { "files": ["index.html", "game.js", "game.css"] } } }

package/engine-examples/tower/bundle/game.css

@@ -0,0 +1,8 @@
+body { margin: 0; background: #08141a; }
+.tower { display: grid; grid-template-rows: repeat(8, 44px); gap: 6px; padding: 20px; width: min(360px, 100%); box-sizing: border-box; margin: 0 auto; }
+.floor { display: grid; grid-template-columns: repeat(4, 1fr); gap: 6px; opacity: .5; transition: opacity 160ms ease; }
+.floor.revealed { opacity: 1; }
+.tile { height: 44px; border-radius: 8px; background: #0d2a38; box-shadow: inset 0 0 0 1px rgba(40,243,243,.1); transition: background 180ms ease, box-shadow 180ms ease, transform 180ms ease; }
+.floor.revealed .tile.safe { background: #0b3b2a; box-shadow: inset 0 0 0 1px #3ad67a; }
+.floor.revealed .tile.trap { background: #3b0f14; box-shadow: inset 0 0 0 1px #ff5a6a; }
+.floor.bust .tile.trap { background: #ff5a6a; transform: scale(1.04); }

package/engine-examples/tower/bundle/game.js

@@ -0,0 +1,37 @@
+import { mount } from '/engine-sdk/ui.js';
+
+const FLOORS = 8;
+const TILES = 4;
+const zone = document.getElementById('tower');
+
+for (let i = FLOORS; i >= 1; i--) {
+    const row = document.createElement('div');
+    row.className = 'floor';
+    row.dataset.floor = i;
+    for (let t = 0; t < TILES; t++) {
+        const tile = document.createElement('div');
+        tile.className = 'tile';
+        tile.dataset.tile = t;
+        row.append(tile);
+    }
+    zone.append(row);
+}
+
+function render(round) {
+    const bust = round.state === 'busted'; // round.busted is the drawn path's, also after a cash-out
+    for (let i = 1; i <= FLOORS; i++) {
+        const row = zone.querySelector(`[data-floor="${i}"]`);
+        const data = round.data[i - 1];
+        row.classList.toggle('revealed', !!data);
+        row.classList.toggle('bust', bust && i === round.step);
+        for (const tile of row.children) {
+            const t = Number(tile.dataset.tile);
+            tile.classList.toggle('trap', !!data && t === data.trap);
+            tile.classList.toggle('safe', !!data && t !== data.trap);
+        }
+    }
+}
+
+await mount(document.getElementById('game'), {
+    step: (round) => render(round),
+});

package/engine-examples/tower/bundle/hbtest.json

@@ -0,0 +1,5 @@
+{
+  "stake": { "page": "index.html", "selector": "hb-game hb-bet-amount input", "value": "1.00" },
+  "bet": { "page": "index.html", "selector": "hb-game [data-main]" },
+  "then": [{ "page": "index.html", "selector": "hb-game [data-next]" }, { "page": "index.html", "selector": "hb-game [data-cashout]" }]
+}

package/engine-examples/tower/bundle/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>Tower</title>
+<link rel="stylesheet" href="./game.css">
+<script type="module" src="/engine-sdk/bet-field.js"></script>
+<script type="module" src="./game.js"></script>
+</head>
+<body>
+<hb-game id="game">
+  <div slot="zone" class="tower" id="tower" aria-live="polite"></div>
+</hb-game>
+</body>
+</html>

package/engine-examples/tower/math/floor.tsv

@@ -0,0 +1,4 @@
+1	{"trap":0}
+1	{"trap":1}
+1	{"trap":2}
+1	{"trap":3}

package/engine-examples/tower/math/manifest.json

@@ -0,0 +1,61 @@
+{
+  "format": "house-engine-math/1",
+  "game": "tower",
+  "rtpBp": 9900,
+  "modes": [
+    {
+      "id": "climb",
+      "label": "Climb",
+      "kind": "ladder",
+      "steps": [
+        {
+          "table": "floor.tsv"
+        },
+        {
+          "table": "floor.tsv"
+        },
+        {
+          "table": "floor.tsv"
+        },
+        {
+          "table": "floor.tsv"
+        },
+        {
+          "table": "floor.tsv"
+        },
+        {
+          "table": "floor.tsv"
+        },
+        {
+          "table": "floor.tsv"
+        },
+        {
+          "table": "floor.tsv"
+        }
+      ],
+      "cashout": true,
+      "ladderBp": [
+        13200,
+        17600,
+        23466,
+        31288,
+        41718,
+        55624,
+        74166,
+        98888
+      ],
+      "bets": [
+        {
+          "id": "climb",
+          "label": "Climb",
+          "survive": [
+            [
+              0,
+              2
+            ]
+          ]
+        }
+      ]
+    }
+  ]
+}

package/engine-examples/tumble/AGENTS.md

@@ -0,0 +1,3 @@
+# For agents
+
+This is a House Engine game (Housebets). Read the guide first: `engine_guide` (MCP) or `engine-sdk/GUIDE.md`. Then `hbengine verify`, `hbengine dev`, `hbengine upload` (or the `engine_*` tools). The math is `math/`, the frontend `bundle/`; never compute money or outcomes in the frontend.

package/engine-examples/tumble/README.md

@@ -0,0 +1,18 @@
+# Tumble — a scatter-pays slot with tumbles, from the maths kit
+
+A 6 × 5 grid: 8 or more of a symbol anywhere pays; the winners vanish and
+new symbols drop in until nothing pays. Four scatters pay and start ten free
+spins where multiplier symbols (2× to 100×) add up and multiply each winning
+spin; three scatters in free spins add five (up to 30). 5,000× cap. RTP
+exactly 96.00%, hit rate 22.7%.
+
+| path | what |
+|---|---|
+| `math/gen.mjs` | the model, 300,000 rounds played into rows, `fit` to exactly 96%; writes `bundle/model.json` |
+| `math-kit/tumble.mjs` | the tumble model (grid, scatter pays, tumbles, free spins, multipliers) |
+| `bundle/game.js` | drops the grid, plays each tumble and the free spins the row holds; a tap skips the free spins |
+
+A row: `{"b":[grid, [[winners, winBp, fill per column…]…], multipliers?], "f":[spin…]}`;
+the grid is column by column, top to bottom, one character per symbol.
+
+    node math/gen.mjs && npx hbengine verify .

package/engine-examples/tumble/bundle/assets.json

@@ -0,0 +1 @@
+{"groups": {"boot": {"files": ["index.html", "game.js", "game.css", "model.json", "i18n.json"]}}}

package/engine-examples/tumble/bundle/game.css

@@ -0,0 +1,13 @@
+body { margin: 0; background: #08141a; }
+.tumble { container-type: inline-size; display: flex; flex-direction: column; align-items: center; gap: 12px; width: 100%; padding: 14px 12px; box-sizing: border-box; }
+.banner, .win { height: 22px; font: 700 15px/22px 'Red Hat Display', 'Figtree', system-ui, sans-serif; font-variant-numeric: tabular-nums; }
+.banner { color: #8F96A8; font-size: 13px; }
+.win { color: #FDDC73; }
+.grid { --c: min(84px, (100cqi - 40px) / 6); position: relative; display: grid; grid-template-columns: repeat(6, var(--c)); gap: 4px; padding: 8px; border-radius: 14px; background: #061218; box-shadow: inset 0 0 0 1px #0D2A38; }
+.col { position: relative; height: calc(var(--c) * 5); overflow: hidden; border-radius: 8px; background: #0b1f28; }
+.cell { position: absolute; left: 0; top: 0; width: var(--c); height: var(--c); display: grid; place-items: center; transition: transform 260ms cubic-bezier(.3, .7, .3, 1), opacity 200ms; }
+.cell svg { width: 70%; height: 70%; }
+.cell.won { background: rgba(253, 220, 115, .14); border-radius: 8px; }
+.cell.gone { opacity: 0; }
+.cell i { position: absolute; font: 800 calc(var(--c) * .26)/1 'Red Hat Display', system-ui, sans-serif; color: #041015; font-style: normal; }
+@media (prefers-reduced-motion: reduce) { .cell { transition: none; } }

package/engine-examples/tumble/bundle/game.js

@@ -0,0 +1,119 @@
+// Tumble: a 6 × 5 grid that pays 8 or more of a symbol anywhere. The panel
+// is the engine's (engine-sdk/ui.js); this file plays back the row the
+// server drew: the first grid, each tumble (what paid, what drops in), and
+// the free spins with their multipliers. model.json comes from math/gen.mjs.
+import { mount } from '/engine-sdk/ui.js';
+
+const model = await (await fetch('./model.json')).json();
+// The page's own words in the player's language (bundle/i18n.json, English otherwise).
+const I18N = await (await fetch('./i18n.json')).json();
+let W = I18N.en;
+const t = (k, v = {}) => W[k].replace(/\{(\w+)\}/g, (_, x) => v[x]);
+const ROWS = model.rows, COLS = model.cols;
+const gridEl = document.getElementById('grid'), banner = document.getElementById('banner'), winEl = document.getElementById('win');
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+const shape = (d, fill, stroke) => `<svg viewBox="0 0 40 40"><path d="${d}" fill="${fill}" stroke="${stroke}" stroke-width="2.2" stroke-linejoin="round"/></svg>`;
+// Deep fills, bright strokes: the big shapes stay muted.
+const ART = {
+    R: shape('M20 34L7 21a7.5 7.5 0 0113-9 7.5 7.5 0 0113 9z', '#7e1f3a', '#ff6b81'),
+    P: shape('M20 5l13 10-5 17H12L7 15z', '#4a2a6b', '#c89bff'),
+    G: shape('M20 5l14 15-14 15L6 20z', '#1f5a3a', '#7cf2b0'),
+    B: shape('M8 14l6-8h12l6 8-12 20z', '#0d5f6e', '#5cf6f6'),
+    a: shape('M20 7a13 13 0 110 26 13 13 0 010-26z', '#7d5410', '#FDDC73'),
+    b: shape('M9 9h22v22H9z', '#2b2f6b', '#a6adff'),
+    c: shape('M20 6l15 26H5z', '#5a2a2a', '#ff9f80'),
+    d: shape('M12 7h16l7 13-7 13H12L5 20z', '#264a52', '#9fe0ea'),
+    e: shape('M20 6l4 10h10l-8 7 3 11-9-6-9 6 3-11-8-7h10z', '#3b4a1f', '#d4f27c'),
+    S: shape('M20 4l4.5 10.5L36 16l-8.5 7.5L30 35l-10-6-10 6 2.5-11.5L4 16l11.5-1.5z', '#7d5410', '#FDDC73'),
+    M: shape('M20 6a14 14 0 110 28 14 14 0 010-28z', '#F9F9FB', '#FDDC73'),
+};
+
+let c = 80;
+const cols = Array.from({ length: COLS }, () => { const e = document.createElement('div'); e.className = 'col'; gridEl.append(e); return { el: e, cells: [] }; });
+const place = (cell, y) => { cell.el.style.transform = `translateY(${y * c}px)`; };
+const make = (sym, y) => {
+    const el = document.createElement('div');
+    el.className = 'cell';
+    el.innerHTML = ART[sym] || sym;
+    el.style.transition = 'none';
+    el.style.transform = `translateY(${y * c}px)`;
+    return { sym, el };
+};
+
+// A new grid falls in from above.
+async function drop(grid, quick) {
+    c = cols[0].el.getBoundingClientRect().height / ROWS || c;
+    cols.forEach((col, x) => {
+        col.el.replaceChildren();
+        col.cells = [...grid.slice(x * ROWS, x * ROWS + ROWS)].map((s, y) => make(s, y - ROWS - 1));
+        col.cells.forEach((cell) => col.el.append(cell.el));
+    });
+    void gridEl.offsetWidth;
+    cols.forEach((col, x) => col.cells.forEach((cell, y) => { cell.el.style.transition = ''; cell.el.style.transitionDelay = quick ? '0ms' : `${x * 40}ms`; place(cell, y); }));
+    await wait(quick ? 200 : 520);
+}
+
+// One tumble: the winners light up and vanish, the rest fall, new ones drop in.
+async function tumble([paid, , ...fills], quick) {
+    cols.forEach((col) => col.cells.forEach((cell) => cell.el.classList.toggle('won', paid.includes(cell.sym))));
+    await wait(quick ? 120 : 520);
+    cols.forEach((col) => col.cells.forEach((cell) => { if (paid.includes(cell.sym)) cell.el.classList.add('gone'); }));
+    await wait(quick ? 60 : 200);
+    cols.forEach((col, x) => {
+        const kept = col.cells.filter((cell) => !paid.includes(cell.sym));
+        col.cells.filter((cell) => paid.includes(cell.sym)).forEach((cell) => cell.el.remove());
+        const add = [...fills[x]].map((s, i) => make(s, i - fills[x].length - 1));
+        add.forEach((cell) => col.el.append(cell.el));
+        col.cells = [...add, ...kept];
+        void col.el.offsetWidth;
+        col.cells.forEach((cell, y) => { cell.el.style.transition = ''; cell.el.style.transitionDelay = '0ms'; place(cell, y); });
+    });
+    await wait(quick ? 160 : 360);
+}
+
+const times = (bp) => (bp / 10000).toFixed(2) + '×';
+
+// One spin of the row: the grid, its tumbles, its multipliers. Returns its win.
+async function play([grid, tumbles, bombs], quick, already) {
+    await drop(grid, quick);
+    let win = 0;
+    for (const t of tumbles) {
+        await tumble(t, quick);
+        win += t[1];
+        winEl.textContent = times(already + win);
+    }
+    if (bombs) {
+        let i = 0;
+        cols.forEach((col) => col.cells.forEach((cell) => { if (cell.sym === 'M') cell.el.insertAdjacentHTML('beforeend', `<i>${bombs[i++]}×</i>`); }));
+        if (win) { win *= bombs.reduce((a, b) => a + b, 0); winEl.textContent = times(already + win); await wait(quick ? 150 : 600); }
+    }
+    return win;
+}
+
+drop(Array.from({ length: COLS * ROWS }, (_, i) => 'edcbaBGPR'[i % 9]), true);
+
+const game = await mount(document.getElementById('game'), {
+    async reveal(round) {
+        const d = round.data[0];
+        winEl.textContent = ''; banner.textContent = '';
+        let total = await play(d.b, false, 0);
+        const scatters = cols.flatMap((col) => col.cells).filter((cell) => cell.sym === 'S').length; // on the last grid, as the maths counts them
+        if (model.scatter.pays[Math.min(scatters, 6)]) total += model.scatter.pays[Math.min(scatters, 6)];
+        if (total) winEl.textContent = times(total);
+        if (d.f) {
+            let skip = false;
+            const tap = () => { skip = true; };
+            gridEl.addEventListener('pointerdown', tap);
+            await wait(600);
+            for (let i = 0; i < d.f.length; i++) {
+                banner.textContent = t('freeSpins', { i: i + 1, n: d.f.length }) + (skip ? '' : ` · ${t('tapToSkip')}`);
+                total += await play(d.f[i], skip, total);
+            }
+            gridEl.removeEventListener('pointerdown', tap);
+            banner.textContent = t('freeOver');
+        }
+        if (d.cap) winEl.textContent = `${times(model.maxWinBp)} · ${t('maxWin')}`;
+        else if (total) winEl.textContent = times(total);
+    },
+});
+W = I18N[(game.engine.config.locale || 'en').slice(0, 2)] || I18N.en;

package/engine-examples/tumble/bundle/hbtest.json

@@ -0,0 +1,4 @@
+{
+  "stake": { "page": "index.html", "selector": "hb-game hb-bet-amount input", "value": "1.00" },
+  "bet": { "page": "index.html", "selector": "hb-game [data-main]" }
+}

package/engine-examples/tumble/bundle/i18n.json

@@ -0,0 +1,122 @@
+{
+ "en": {
+  "freeSpins": "Free spins {i} of {n}",
+  "tapToSkip": "tap to skip",
+  "freeOver": "Free spins over",
+  "maxWin": "max win"
+ },
+ "ar": {
+  "freeSpins": "دورات مجانية {i} من {n}",
+  "tapToSkip": "اضغط للتخطي",
+  "freeOver": "انتهت الدورات المجانية",
+  "maxWin": "أقصى ربح"
+ },
+ "da": {
+  "freeSpins": "Gratis spins {i} af {n}",
+  "tapToSkip": "tryk for at springe over",
+  "freeOver": "Gratis spins slut",
+  "maxWin": "maks. gevinst"
+ },
+ "de": {
+  "freeSpins": "Freispiele {i} von {n}",
+  "tapToSkip": "zum Überspringen tippen",
+  "freeOver": "Freispiele beendet",
+  "maxWin": "Maximalgewinn"
+ },
+ "es": {
+  "freeSpins": "Giros gratis {i} de {n}",
+  "tapToSkip": "toca para saltar",
+  "freeOver": "Giros gratis terminados",
+  "maxWin": "premio máximo"
+ },
+ "fi": {
+  "freeSpins": "Ilmaiskierrokset {i}/{n}",
+  "tapToSkip": "ohita napauttamalla",
+  "freeOver": "Ilmaiskierrokset päättyivät",
+  "maxWin": "maksimivoitto"
+ },
+ "fr": {
+  "freeSpins": "Tours gratuits {i} sur {n}",
+  "tapToSkip": "touchez pour passer",
+  "freeOver": "Tours gratuits terminés",
+  "maxWin": "gain maximal"
+ },
+ "hi": {
+  "freeSpins": "फ्री स्पिन {i} / {n}",
+  "tapToSkip": "छोड़ने के लिए टैप करें",
+  "freeOver": "फ्री स्पिन खत्म",
+  "maxWin": "अधिकतम जीत"
+ },
+ "hu": {
+  "freeSpins": "Ingyenes pörgetés {i}/{n}",
+  "tapToSkip": "koppints az átugráshoz",
+  "freeOver": "Vége az ingyenes pörgetéseknek",
+  "maxWin": "max. nyeremény"
+ },
+ "id": {
+  "freeSpins": "Putaran gratis {i} dari {n}",
+  "tapToSkip": "ketuk untuk lewati",
+  "freeOver": "Putaran gratis selesai",
+  "maxWin": "kemenangan maks"
+ },
+ "it": {
+  "freeSpins": "Giri gratis {i} di {n}",
+  "tapToSkip": "tocca per saltare",
+  "freeOver": "Giri gratis finiti",
+  "maxWin": "vincita massima"
+ },
+ "ja": {
+  "freeSpins": "フリースピン {i}/{n}",
+  "tapToSkip": "タップでスキップ",
+  "freeOver": "フリースピン終了",
+  "maxWin": "最大配当"
+ },
+ "ko": {
+  "freeSpins": "프리 스핀 {i}/{n}",
+  "tapToSkip": "탭하여 건너뛰기",
+  "freeOver": "프리 스핀 종료",
+  "maxWin": "최대 당첨"
+ },
+ "pl": {
+  "freeSpins": "Darmowe spiny {i} z {n}",
+  "tapToSkip": "dotknij, aby pominąć",
+  "freeOver": "Koniec darmowych spinów",
+  "maxWin": "maks. wygrana"
+ },
+ "pt": {
+  "freeSpins": "Giros grátis {i} de {n}",
+  "tapToSkip": "toque para pular",
+  "freeOver": "Giros grátis terminados",
+  "maxWin": "ganho máximo"
+ },
+ "ru": {
+  "freeSpins": "Бесплатные вращения {i} из {n}",
+  "tapToSkip": "нажмите, чтобы пропустить",
+  "freeOver": "Бесплатные вращения закончились",
+  "maxWin": "максимальный выигрыш"
+ },
+ "th": {
+  "freeSpins": "ฟรีสปิน {i} จาก {n}",
+  "tapToSkip": "แตะเพื่อข้าม",
+  "freeOver": "ฟรีสปินจบแล้ว",
+  "maxWin": "รางวัลสูงสุด"
+ },
+ "tr": {
+  "freeSpins": "Bedava dönüş {i}/{n}",
+  "tapToSkip": "geçmek için dokun",
+  "freeOver": "Bedava dönüşler bitti",
+  "maxWin": "maksimum kazanç"
+ },
+ "vi": {
+  "freeSpins": "Lượt quay miễn phí {i}/{n}",
+  "tapToSkip": "chạm để bỏ qua",
+  "freeOver": "Hết lượt quay miễn phí",
+  "maxWin": "thắng tối đa"
+ },
+ "zh": {
+  "freeSpins": "免费旋转 {i}/{n}",
+  "tapToSkip": "点击跳过",
+  "freeOver": "免费旋转结束",
+  "maxWin": "最高奖金"
+ }
+}

package/engine-examples/tumble/bundle/index.html

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>Tumble</title>
+<link rel="stylesheet" href="./game.css">
+<script type="module" src="/engine-sdk/bet-field.js"></script>
+<script type="module" src="./game.js"></script>
+</head>
+<body>
+<hb-game id="game">
+  <div slot="zone" class="tumble">
+    <div class="banner" id="banner" aria-live="polite"></div>
+    <div class="grid" id="grid"></div>
+    <div class="win" id="win" aria-live="polite"></div>
+  </div>
+</hb-game>
+</body>
+</html>

package/engine-examples/tumble/bundle/model.json

@@ -0,0 +1 @@
+{"cols":6,"rows":5,"weights":{"e":16,"d":15,"c":14,"b":13,"a":12,"B":9,"G":8,"P":7,"R":6,"S":3},"freeWeights":{"e":16,"d":15,"c":14,"b":13,"a":12,"B":9,"G":8,"P":7,"R":6,"S":3,"M":3},"pays":{"R":[[8,250000],[10,600000],[12,1200000]],"P":[[8,60000],[10,250000],[12,600000]],"G":[[8,50000],[10,120000],[12,400000]],"B":[[8,40000],[10,50000],[12,300000]],"a":[[8,25000],[10,40000],[12,250000]],"b":[[8,20000],[10,30000],[12,200000]],"c":[[8,12000],[10,25000],[12,120000]],"d":[[8,10000],[10,22000],[12,100000]],"e":[[8,6000],[10,18000],[12,50000]]},"scatter":{"symbol":"S","pays":{"4":30000,"5":50000,"6":1000000},"spins":{"4":10,"5":10,"6":10},"retrigger":{"count":3,"spins":5},"cap":30},"bomb":{"symbol":"M","values":[[2,40],[3,25],[4,15],[5,10],[10,6],[25,3],[50,1],[100,0.5]]},"maxWinBp":50000000}

package/engine-examples/tumble/math/gen.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+// The tumble slot's maths: a 6 × 5 grid that pays 8 or more of a symbol
+// anywhere; winners vanish and new symbols drop in until nothing pays. Four
+// scatters start ten free spins where multiplier symbols (2× to 100×) add up
+// and multiply each winning spin; three scatters in free spins add five.
+// 5,000× cap. Played into whole-round rows and fitted to exactly 96.00%;
+// the model goes to the bundle too.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { fit, rng, writePack } from '../math-kit/pack.mjs';
+import { books } from '../math-kit/slot.mjs';
+import { tumble } from '../math-kit/tumble.mjs';
+
+const DIR = dirname(fileURLToPath(import.meta.url));
+const project = join(DIR, '..', 'hbengine.json');
+const GAME = process.argv[2] || (existsSync(project) ? JSON.parse(readFileSync(project, 'utf8')).slug : 'tumble');
+const RTP = 9600, ROUNDS = Number(process.env.ROUNDS || 300_000), SEED = 20261015;
+
+const weights = { e: 16, d: 15, c: 14, b: 13, a: 12, B: 9, G: 8, P: 7, R: 6, S: 3 };
+const model = {
+    cols: 6, rows: 5, weights, freeWeights: { ...weights, M: 3 },
+    // × the stake for 8–9, 10–11, 12 or more anywhere (basis points below)
+    pays: Object.fromEntries(Object.entries({
+        R: [25, 60, 120], P: [6, 25, 60], G: [5, 12, 40], B: [4, 5, 30],
+        a: [2.5, 4, 25], b: [2, 3, 20], c: [1.2, 2.5, 12], d: [1, 2.2, 10], e: [0.6, 1.8, 5],
+    }).map(([s, [x, y, z]]) => [s, [[8, x * 10000], [10, y * 10000], [12, z * 10000]]])),
+    scatter: { symbol: 'S', pays: { 4: 30000, 5: 50000, 6: 1000000 }, spins: { 4: 10, 5: 10, 6: 10 }, retrigger: { count: 3, spins: 5 }, cap: 30 },
+    bomb: { symbol: 'M', values: [[2, 40], [3, 25], [4, 15], [5, 10], [10, 6], [25, 3], [50, 1], [100, 0.5]] },
+    maxWinBp: 50_000_000,
+};
+
+const rows = books(tumble(model), rng(SEED), ROUNDS);
+const raw = rows.reduce((a, r) => [a[0] + r.weight * BigInt(r.pay.spin), a[1] + r.weight], [0n, 0n]);
+const hits = rows.reduce((a, r) => a + (r.pay.spin > 0 ? r.weight : 0n), 0n);
+console.log(`played ${ROUNDS}: before the fit RTP ${(Number(raw[0] * 1000000n / raw[1]) / 1e6 / 100).toFixed(2)}%, hit rate ${(Number(hits * 10000n / BigInt(ROUNDS)) / 100).toFixed(2)}%`);
+writePack(DIR, { game: GAME, rtpBp: RTP, modes: [{ id: 'base', label: 'Spin', rows: fit(rows, RTP), bets: [{ id: 'spin', label: 'Spin' }] }] });
+writeFileSync(join(DIR, '..', 'bundle', 'model.json'), JSON.stringify(model) + '\n');