hbengine 0.2.3

package/engine-examples/plinko/math-kit/pack.mjs

@@ -0,0 +1,165 @@
+/**
+ * The maths kit: a game's outcomes as weighted rows, its RTP exactly, and the
+ * pack the engine verifies (SPEC §1). A row is { weight, data, pay } where
+ * pay is { betId: multBp } (10000 = 1×, the total stake back) and data is
+ * what the bundle receives to show the round.
+ *
+ *   import { writePack, fit } from './pack.mjs';
+ *   const rows = fit(simulated, 9600);            // exact 96.00% (balance() when no row pays nothing)
+ *   writePack('math', { game: 'my-slot', rtpBp: 9600, modes: [{ id: 'base', rows, bets: ['spin'] }] });
+ *
+ * Every number here is an integer: weights are BigInt, RTP is a fraction.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const MAX_SUM = 1n << 63n;
+
+// A small seeded generator for building tables (never for play: the engine draws).
+export function rng(seed) {
+    let a = seed >>> 0;
+    const next = () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+    next.int = (n) => Math.floor(next() * n);
+    return next;
+}
+
+export function binomial(n, k) {
+    let r = 1n;
+    for (let i = 1n; i <= BigInt(k); i++) r = (r * BigInt(n - k) + r * i) / i;
+    return r;
+}
+
+const gcd = (a, b) => { while (b) [a, b] = [b, a % b]; return a < 0n ? -a : a; };
+
+/** RTP of one bet over rows, exactly: { num, den } in basis points, and a 4-decimal string. */
+export function rtp(rows, bet) {
+    let num = 0n, den = 0n;
+    for (const r of rows) { den += r.weight; num += r.weight * BigInt(r.pay[bet] || 0); }
+    return { num, den, bp: bp4(num, den) };
+}
+
+export const bp4 = (num, den) => {
+    const x = (num * 10000n) / den; // bp × 10^4, truncated as the verifier reports it
+    return `${x / 10000n}.${String(x % 10000n).padStart(4, '0')}`;
+};
+
+/**
+ * Weights so that one bet's RTP is exactly targetBp: the paying rows keep
+ * their proportions (all multiplied by one integer), the rows that pay
+ * nothing share what is left in their own proportions. Needs rows that pay
+ * nothing, and paying rows that alone return more than the target.
+ */
+export function fit(rows, targetBp, bet = Object.keys(rows[0].pay)[0]) {
+    const T = BigInt(targetBp);
+    const wins = rows.filter((r) => r.pay[bet] > 0), zeros = rows.filter((r) => !(r.pay[bet] > 0));
+    if (!zeros.length) throw new Error('fit: no row pays nothing');
+    const S = wins.reduce((s, r) => s + r.weight * (BigInt(r.pay[bet]) - T), 0n); // what the wins return above T
+    if (S <= 0n) throw new Error(`fit: the paying rows alone return less than ${targetBp / 100}%`);
+    const k = T / gcd(S, T);     // so that k·S is a multiple of T
+    const Z = (k * S) / T;       // the weight the zero rows share
+    const zw = zeros.reduce((s, r) => s + r.weight, 0n);
+    let given = 0n;
+    const out = rows.map((r) => {
+        if (r.pay[bet] > 0) return { ...r, weight: r.weight * k };
+        const w = (Z * r.weight) / zw;
+        given += w;
+        return { ...r, weight: w };
+    });
+    // The rounding remainder goes to the first zero row; a zero weight is dropped.
+    const first = out.find((r) => !(r.pay[bet] > 0));
+    first.weight += Z - given;
+    const kept = out.filter((r) => r.weight > 0n);
+    const check = rtp(kept, bet);
+    if (check.num !== T * check.den) throw new Error('fit: not exact (a bug)');
+    return kept;
+}
+
+/**
+ * Weights so that one bet's RTP is exactly targetBp when every row pays
+ * something (a bonus buy, plinko): rows paying more than the target are
+ * all multiplied by one integer, rows paying less by another, so each
+ * group keeps its own proportions and the two balance at the target.
+ */
+export function balance(rows, targetBp, bet = Object.keys(rows[0].pay)[0]) {
+    const T = BigInt(targetBp);
+    const over = rows.reduce((s, r) => s + (BigInt(r.pay[bet] || 0) > T ? r.weight * (BigInt(r.pay[bet]) - T) : 0n), 0n);
+    const under = rows.reduce((s, r) => s + (BigInt(r.pay[bet] || 0) < T ? r.weight * (T - BigInt(r.pay[bet] || 0)) : 0n), 0n);
+    if (!over || !under) throw new Error('balance: needs rows on both sides of the target');
+    const g = gcd(over, under);
+    const out = rows.map((r) => ({ ...r, weight: r.weight * (BigInt(r.pay[bet] || 0) > T ? under / g : BigInt(r.pay[bet] || 0) < T ? over / g : 1n) }));
+    const check = rtp(out, bet);
+    if (check.num !== T * check.den) throw new Error('balance: not exact (a bug)');
+    return out;
+}
+
+/** Rows with the same data are one row with the sum of their weights. */
+export function merge(rows) {
+    const by = new Map();
+    for (const r of rows) {
+        const key = JSON.stringify(r.data);
+        const x = by.get(key);
+        if (x) x.weight += r.weight;
+        else by.set(key, { ...r, weight: r.weight });
+    }
+    return [...by.values()];
+}
+
+// Inclusive [lo, hi] ranges of sorted indexes.
+function ranges(ids) {
+    const out = [];
+    for (const i of ids) {
+        const last = out.at(-1);
+        if (last && last[1] === i - 1) last[1] = i;
+        else out.push([i, i]);
+    }
+    return out;
+}
+
+/**
+ * Writes manifest.json and one table per mode. A mode is { id, label?, rows,
+ * bets: [id | {id, label}] }; its rows are sorted by what the first bet pays,
+ * so each pay tier is one range. Prints every bet's exact RTP, hit rate and
+ * largest multiplier; returns them.
+ */
+export function writePack(dir, { game, rtpBp, modes }) {
+    mkdirSync(dir, { recursive: true });
+    const manifest = { format: 'house-engine-math/1', game, rtpBp, modes: [] };
+    const report = [];
+    for (const mode of modes) {
+        const bets = mode.bets.map((b) => (typeof b === 'string' ? { id: b } : b));
+        const first = bets[0].id;
+        const rows = [...mode.rows].sort((a, b) => (a.pay[first] || 0) - (b.pay[first] || 0));
+        if (rows.length < 2 || rows.length > 1_000_000) throw new Error(`${mode.id}: 2 to 1,000,000 rows, not ${rows.length}`);
+        const sum = rows.reduce((s, r) => s + r.weight, 0n);
+        if (sum > MAX_SUM) throw new Error(`${mode.id}: weights sum to more than 2^63`);
+        const lines = rows.map((r) => {
+            if (r.weight <= 0n) throw new Error(`${mode.id}: a weight is not positive`);
+            const json = r.data === undefined ? '' : JSON.stringify(r.data);
+            if (json.length > 4096) throw new Error(`${mode.id}: a row's data is over 4096 bytes`);
+            return json ? `${r.weight}\t${json}` : String(r.weight);
+        });
+        const table = `${game}-${mode.id}.tsv`;
+        writeFileSync(join(dir, table), lines.join('\n') + '\n');
+        manifest.modes.push({
+            id: mode.id, ...(mode.label ? { label: mode.label } : {}), kind: 'table', table,
+            bets: bets.map((b) => {
+                const tiers = new Map();
+                rows.forEach((r, i) => { const m = r.pay[b.id] || 0; if (m > 0) (tiers.get(m) || tiers.set(m, []).get(m)).push(i); });
+                const { num, den, bp } = rtp(rows, b.id);
+                const hit = rows.reduce((s, r) => s + (r.pay[b.id] > 0 ? r.weight : 0n), 0n);
+                const max = Math.max(...tiers.keys());
+                report.push({ mode: mode.id, bet: b.id, rtp: bp, hit: bp4(hit * 10000n, den), max: max / 10000, rows: rows.length, exact: num % den === 0n });
+                return { id: b.id, ...(b.label ? { label: b.label } : {}), tiers: [...tiers].map(([multBp, ids]) => ({ outcomes: ranges(ids), multBp })) };
+            }),
+        });
+    }
+    writeFileSync(join(dir, 'manifest.json'), JSON.stringify(manifest) + '\n');
+    for (const r of report) console.log(`${r.mode}/${r.bet}: RTP ${r.rtp} bp  hit ${r.hit} bp  max ${r.max}×  rows ${r.rows}`);
+    return report;
+}

package/engine-examples/plinko/math-kit/package.json

@@ -0,0 +1,8 @@
+{
+    "name": "@housegames/engine-math",
+    "private": true,
+    "version": "0.1.0",
+    "type": "module",
+    "description": "The maths kit: outcomes as weighted rows, exact RTP, an exact fit to a target, the pack the engine verifies; a video slot model (reels, lines, wilds, scatters, free spins) and a tumble model (scatter pays, tumbles, multipliers).",
+    "exports": { "./pack.mjs": "./pack.mjs", "./slot.mjs": "./slot.mjs", "./tumble.mjs": "./tumble.mjs" }
+}

package/engine-examples/plinko/math-kit/slot.mjs

@@ -0,0 +1,94 @@
+/**
+ * A video slot for the maths kit: reels, paylines, a wild, a scatter that
+ * starts free spins (with a multiplier, retriggers), and a win cap. It plays
+ * rounds with a seeded generator to make the table's rows ("books"): every
+ * row is a whole round, base spin and free spins, with what it pays. fit()
+ * then makes the table's RTP exact; the table is the game.
+ *
+ * Pays are in basis points of the total stake (10000 = 1×) for 3, 4, 5 of a
+ * kind on a line, left to right; scatters pay anywhere, times the stake.
+ *
+ * A row's data, for the bundle: { b: spin, f: [spin…], x: free multiplier }
+ * where a spin is [stop0…stopN, winBp, lineMask, scatterCount].
+ */
+export function slot(cfg) {
+    const { reels, freeReels = reels, rows, lines, pays, wild, scatter, maxWinBp } = cfg;
+    const n = reels.length;
+
+    const grid = (strips, stops) => stops.map((s, r) => Array.from({ length: rows }, (_, y) => strips[r][(s + y) % strips[r].length]));
+
+    // One spin's wins: each line pays its best run from the left (wilds stand in).
+    function evaluate(strips, stops) {
+        const g = grid(strips, stops);
+        let win = 0, mask = 0;
+        lines.forEach((line, li) => {
+            const cells = line.map((y, r) => g[r][y]);
+            const sym = cells.find((c) => c !== wild) ?? wild;
+            if (sym === scatter.symbol) return;
+            let count = 0;
+            while (count < n && (cells[count] === sym || cells[count] === wild)) count++;
+            const pay = (pays[sym] || {})[count] || 0;
+            // A run of wilds alone pays as wilds when that is more.
+            let wc = 0;
+            while (wc < n && cells[wc] === wild) wc++;
+            const best = Math.max(pay, (pays[wild] || {})[wc] || 0);
+            if (best > 0) { win += best; mask |= 1 << li; }
+        });
+        const scatters = g.flat().filter((c) => c === scatter.symbol).length;
+        win += (scatter.pays[scatters] || 0);
+        return { win, mask, scatters };
+    }
+
+    const spin = (strips, next) => strips.map((s) => next.int(s.length));
+
+    /** One whole round: the row's data and what it pays (bp of the stake).
+     * A bought round is the free spins alone, as three scatters start them. */
+    function round(next, buy = false) {
+        const stops = buy ? null : spin(reels, next);
+        const base = buy ? { win: 0, scatters: 3 } : evaluate(reels, stops);
+        const data = buy ? { buy: 1 } : { b: [...stops, base.win, base.mask, base.scatters] };
+        let total = base.win;
+        let left = scatter.spins[base.scatters] || 0;
+        if (left) {
+            data.f = [];
+            data.x = scatter.multiplier;
+            while (left > 0 && data.f.length < scatter.cap) {
+                left--;
+                const s = spin(freeReels, next);
+                const e = evaluate(freeReels, s);
+                data.f.push([...s, e.win * scatter.multiplier, e.mask, e.scatters]);
+                total += e.win * scatter.multiplier;
+                left += scatter.retrigger[e.scatters] || 0;
+            }
+        }
+        if (total > maxWinBp) { total = maxWinBp; data.cap = 1; }
+        return { data, pay: total };
+    }
+
+    return { evaluate, round, grid };
+}
+
+/**
+ * Plays `count` rounds (bought ones with `buy`) and keeps them as rows: every paying round, and up to
+ * `losing` different losing rounds that share the weight of every losing
+ * round played (so the rows keep the played RTP and hit rate before fit).
+ */
+export function books(game, next, count, losing = 4000, buy = false) {
+    const wins = new Map(), lose = new Map();
+    let lost = 0n;
+    for (let i = 0; i < count; i++) {
+        const { data, pay } = game.round(next, buy);
+        if (pay <= 0) {
+            lost++;
+            if (lose.size < losing) lose.set(JSON.stringify(data), { weight: 0n, data, pay: { spin: 0 } });
+            continue;
+        }
+        const key = JSON.stringify(data);
+        const r = wins.get(key);
+        if (r) r.weight += 1n;
+        else wins.set(key, { weight: 1n, data, pay: { spin: pay } });
+    }
+    const zeros = [...lose.values()];
+    zeros.forEach((r, i) => { r.weight = lost / BigInt(zeros.length) + (BigInt(i) < lost % BigInt(zeros.length) ? 1n : 0n); });
+    return [...zeros.filter((r) => r.weight > 0n), ...wins.values()];
+}

package/engine-examples/plinko/math-kit/tumble.mjs

@@ -0,0 +1,94 @@
+/**
+ * A tumbling, scatter-pays slot for the maths kit: a cols × rows grid, every
+ * cell drawn by symbol weight; a symbol pays when enough of it is anywhere
+ * on the grid; winners vanish, the rest fall, new symbols drop in, until
+ * nothing pays. Scatters start free spins, where multiplier symbols land
+ * and multiply the spin's win. Like slot.mjs, it plays whole rounds into
+ * rows; fit() then makes the RTP exact.
+ *
+ * Symbols are single characters. Pays are basis points of the stake by
+ * count: { A: [[8, 2000], [10, 5000], [12, 10000]] } pays the highest band
+ * the count reaches.
+ *
+ * A row's data, for the page:
+ *   { b: spin, f: [spin…] }   spin = [grid, [tumble…], multipliers?]
+ *   grid    the first grid, column by column, top to bottom ("ABCDE…")
+ *   tumble  [winners, winBp, fill0, fill1, …]: the symbols that paid, what
+ *           they paid, and per column the new symbols that drop in (top first)
+ *   multipliers  free spins only: the values of the multiplier symbols on the
+ *           last grid, summed onto the spin's win when it won
+ */
+export function tumble(cfg) {
+    const { cols, rows, weights, freeWeights = weights, pays, scatter, bomb, maxWinBp } = cfg;
+    const pick = (w, next) => {
+        const total = w.reduce((s, [, n]) => s + n, 0);
+        let x = next() * total;
+        for (const [s, n] of w) if ((x -= n) < 0) return s;
+        return w[w.length - 1][0];
+    };
+    const table = (o) => Object.entries(o);
+    const base = table(weights), free = table(freeWeights);
+    const counts = Object.keys(scatter.spins).map(Number), least = Math.min(...counts), most = Math.max(...counts);
+
+    // One spin: the grid, its tumbles, and (free spins) its multipliers.
+    function spin(next, inFree) {
+        const w = inFree ? free : base;
+        const draw = () => {
+            const s = pick(w, next);
+            return s === bomb?.symbol && !inFree ? pick(base.filter(([x]) => x !== bomb.symbol), next) : s;
+        };
+        let grid = Array.from({ length: cols }, () => Array.from({ length: rows }, draw));
+        const first = grid.map((c) => c.join('')).join('');
+        const tumbles = [];
+        let win = 0;
+        for (;;) {
+            const counts = {};
+            for (const c of grid) for (const s of c) counts[s] = (counts[s] || 0) + 1;
+            let paid = '', bp = 0;
+            for (const [s, bands] of Object.entries(pays)) {
+                const band = bands.filter(([n]) => counts[s] >= n).at(-1);
+                if (band) { paid += s; bp += band[1]; }
+            }
+            if (!paid) break;
+            win += bp;
+            const fills = grid.map((c) => {
+                const kept = c.filter((s) => !paid.includes(s));
+                const add = Array.from({ length: rows - kept.length }, draw);
+                c.splice(0, rows, ...add, ...kept); // new symbols on top
+                return add.join('');
+            });
+            tumbles.push([paid, bp, ...fills]);
+        }
+        const out = [first, tumbles];
+        const scatters = grid.flat().filter((s) => s === scatter.symbol).length; // on the last grid
+        let total = win;
+        if (inFree && bomb) {
+            const bombs = grid.flat().filter((s) => s === bomb.symbol).map(() => pick(bomb.values, next));
+            if (bombs.length) out.push(bombs);
+            if (win && bombs.length) total = win * bombs.reduce((a, b) => a + b, 0);
+        }
+        return { out, total, scatters };
+    }
+
+    /** One whole round: the row's data and what it pays (bp of the stake). */
+    function round(next) {
+        const b = spin(next, false);
+        const data = { b: b.out };
+        let total = b.total + (scatter.pays[Math.min(b.scatters, most)] || 0);
+        let left = b.scatters >= least ? scatter.spins[Math.min(b.scatters, most)] : 0;
+        if (left) {
+            data.f = [];
+            while (left > 0 && data.f.length < scatter.cap) {
+                left--;
+                const f = spin(next, true);
+                data.f.push(f.out);
+                total += f.total;
+                if (f.scatters >= scatter.retrigger.count) left += scatter.retrigger.spins;
+            }
+        }
+        if (total > maxWinBp) { total = maxWinBp; data.cap = 1; }
+        return { data, pay: total };
+    }
+
+    return { round };
+}

package/engine-examples/slot/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/slot/README.md

@@ -0,0 +1,26 @@
+# Slot — a 3-reel, 1-line example
+
+`math/slot.tsv` is 48³ = 110,592 rows (weight 1 each, `{"stops":[a,b,c]}`): a
+slot is recommended to have 100,000 different rounds in every mode. The
+reel strip is in `math/gen.mjs` (regenerate with `node math/gen.mjs`) and in
+`bundle/game.js`. The panel is the engine's (`/engine-sdk/ui.js`);
+`bundle/game.js` only spins the reels to the stops the server drew.
+
+Strip (48 positions): one turn of 16, `7 bar bar bell bell bell cherry cherry cherry lemon lemon lemon lemon plum plum plum`,
+three times round the reel, the second turn rotated by 5 and the third by 11, so the windows differ.
+
+Bet `line`, exact RTP `1,083,429,000 / 110,592` bp = **97.9663%** (`rtpBp` cap 9800): the proportions are one turn's, so the RTP is the 16-stop strip's.
+
+| Combination    | Hits / 110,592 | Multiplier |
+| -------------- | -------------: | ---------: |
+| Three sevens   |             27 |       500× |
+| Three bars     |            216 |        50× |
+| Three bells    |            729 |        20× |
+| Three cherries |            729 |        10× |
+| Three plums    |            729 |         8× |
+| Three lemons   |          1,728 |         5× |
+| Two cherries   |          9,477 |         2× |
+| One cherry     |         41,067 |       0.7× |
+
+    npx hbengine verify .                      exact RTP per bet, the mathHash
+    npx hbengine init my-slot --template slot --slug my-slot   # make it yours, then: verify, dev, upload

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

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

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

@@ -0,0 +1,19 @@
+body { margin: 0; background: #08141a; }
+.slot { display: flex; flex-direction: column; align-items: center; gap: 16px; padding: 24px 16px; width: 100%; box-sizing: border-box; }
+.reels { position: relative; display: grid; grid-template-columns: repeat(3, 92px); gap: 8px; padding: 10px; border-radius: 14px; background: #061218; box-shadow: inset 0 0 0 1px #0D2A38, 0 10px 32px rgba(0, 0, 0, .5); }
+.reel { position: relative; height: 180px; width: 92px; overflow: hidden; background: radial-gradient(circle at 50% 30%, #0b2a35, #061218 80%); border-radius: 8px; }
+.reel .strip { position: absolute; top: 0; left: 0; right: 0; will-change: transform; }
+.sym { height: 60px; display: grid; place-items: center; font: 800 24px/1 'Figtree', system-ui, sans-serif; letter-spacing: .5px; color: #F9F9FB; border-bottom: 1px solid rgba(13, 42, 56, .5); }
+.s-7 { color: #ff5c6c; }
+.s-bar { color: #28F3F3; }
+.s-bell { color: #ffd166; }
+.s-cherry { color: #ff8ab0; }
+.s-lemon { color: #e6f26b; }
+.s-plum { color: #c89bff; }
+.line { position: relative; width: 302px; height: 2px; margin-top: -116px; background: #28F3F3; opacity: .35; transition: opacity .25s, box-shadow .25s; pointer-events: none; }
+.line.win { opacity: 1; box-shadow: 0 0 18px 2px #28F3F3; }
+@media (max-width: 420px) {
+    .reels { grid-template-columns: repeat(3, 84px); }
+    .reel { width: 84px; }
+    .line { width: 278px; }
+}

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

@@ -0,0 +1,42 @@
+// Slot: three reels, one pay line. The panel is the engine's (engine-sdk/ui.js);
+// this file spins the reels to the stops the server drew.
+import { mount } from '/engine-sdk/ui.js';
+
+// The reel as math/gen.mjs has it: one turn of 16 symbols three times round, each turn rotated.
+const TURN = ['7', 'bar', 'bar', 'bell', 'bell', 'bell', 'cherry', 'cherry', 'cherry', 'lemon', 'lemon', 'lemon', 'lemon', 'plum', 'plum', 'plum'];
+const STRIP = [0, 5, 11].flatMap((k) => [...TURN.slice(k), ...TURN.slice(0, k)]);
+const GLYPH = { '7': '7', bar: 'BAR', bell: 'BEL', cherry: 'CHR', lemon: 'LMN', plum: 'PLM' };
+const H = 60;
+const line = document.getElementById('line');
+const reels = [...document.querySelectorAll('.reel')].map((r) => {
+    const strip = document.createElement('div');
+    strip.className = 'strip';
+    for (let k = 0; k < 3; k++) for (const s of STRIP) {
+        const el = document.createElement('div');
+        el.className = 'sym s-' + s;
+        el.textContent = GLYPH[s];
+        strip.append(el);
+    }
+    r.append(strip);
+    return strip;
+});
+
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function spin(strip, stop, dur) {
+    strip.style.transition = 'none';
+    strip.style.transform = 'translateY(0px)';
+    void strip.offsetWidth;
+    strip.style.transition = `transform ${dur}ms cubic-bezier(.2, .8, .15, 1)`;
+    strip.style.transform = `translateY(-${(STRIP.length - 1 + stop) * H}px)`;
+    return wait(dur);
+}
+
+await mount(document.getElementById('game'), {
+    async reveal(round) {
+        line.classList.remove('win');
+        const stops = round.data[0].stops;
+        await Promise.all(stops.map((s, i) => spin(reels[i], s, 1100 + i * 400)));
+        line.classList.toggle('win', round.payout > 0);
+    },
+});

package/engine-examples/slot/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/slot/bundle/index.html

@@ -0,0 +1,23 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>Slot</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="slot" aria-live="polite">
+    <div class="reels" id="reels">
+      <div class="reel"></div>
+      <div class="reel"></div>
+      <div class="reel"></div>
+    </div>
+    <div class="line" id="line" aria-hidden="true"></div>
+  </div>
+</hb-game>
+</body>
+</html>

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

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DIR = dirname(fileURLToPath(import.meta.url));
+
+// The 16 symbols of one turn, three times round the reel, each turn rotated so the
+// windows differ: 48 stops, 48³ = 110,592 different rounds (House Studio holds a slot
+// to 100,000 in every mode). The proportions, and with them the RTP, are one turn's.
+const TURN = ['7', 'bar', 'bar', 'bell', 'bell', 'bell', 'cherry', 'cherry', 'cherry', 'lemon', 'lemon', 'lemon', 'lemon', 'plum', 'plum', 'plum'];
+export const STRIP = [0, 5, 11].flatMap((k) => [...TURN.slice(k), ...TURN.slice(0, k)]);
+
+const PAY = {
+    seven:        { multBp: 5000000, label: 'Three sevens' },
+    bar:          { multBp:  500000, label: 'Three bars' },
+    bell:         { multBp:  200000, label: 'Three bells' },
+    cherry:       { multBp:  100000, label: 'Three cherries' },
+    plum:         { multBp:   80000, label: 'Three plums' },
+    lemon:        { multBp:   50000, label: 'Three lemons' },
+    'two-cherry': { multBp:   20000, label: 'Two cherries' },
+    'one-cherry': { multBp:    7000, label: 'One cherry' },
+};
+const ORDER = ['seven', 'bar', 'bell', 'cherry', 'plum', 'lemon', 'two-cherry', 'one-cherry'];
+
+function classify(a, b, c) {
+    const s = [STRIP[a], STRIP[b], STRIP[c]];
+    if (s[0] === s[1] && s[1] === s[2]) return s[0] === '7' ? 'seven' : s[0];
+    const n = s.filter((x) => x === 'cherry').length;
+    if (n === 2) return 'two-cherry';
+    if (n === 1) return 'one-cherry';
+    return null;
+}
+
+const rows = [];
+const idsByTier = Object.fromEntries(ORDER.map((t) => [t, []]));
+const N = STRIP.length;
+for (let a = 0; a < N; a++) for (let b = 0; b < N; b++) for (let c = 0; c < N; c++) {
+    const idx = rows.length;
+    rows.push([a, b, c]);
+    const t = classify(a, b, c);
+    if (t) idsByTier[t].push(idx);
+}
+
+const ranges = (ids) => {
+    const out = [];
+    for (const i of ids) {
+        const last = out[out.length - 1];
+        if (last && last[1] === i - 1) last[1] = i;
+        else out.push([i, i]);
+    }
+    return out;
+};
+
+const tiers = ORDER.map((t) => ({ outcomes: ranges(idsByTier[t]), multBp: PAY[t].multBp }));
+
+let num = 0;
+for (const t of ORDER) num += idsByTier[t].length * PAY[t].multBp;
+const rtpBp = Math.floor(num / rows.length);
+if (rtpBp < 9600 || rtpBp > 9800) throw new Error('RTP out of band: ' + rtpBp);
+
+const manifest = {
+    format: 'house-engine-math/1',
+    game: 'slot',
+    rtpBp: 9800,
+    modes: [{
+        id: 'spin',
+        label: 'Spin',
+        kind: 'table',
+        table: 'slot.tsv',
+        bets: [{ id: 'line', label: 'Line', tiers }],
+    }],
+};
+
+writeFileSync(join(DIR, 'slot.tsv'), rows.map(([a, b, c]) => `1\t{"stops":[${a},${b},${c}]}`).join('\n') + '\n');
+writeFileSync(join(DIR, 'manifest.json'), JSON.stringify(manifest) + '\n');
+
+console.log(`rows ${rows.length}  rtpBp ${rtpBp}  (${(rtpBp / 100).toFixed(2)}%)`);
+for (const t of ORDER) console.log(`  ${PAY[t].label.padEnd(16)} count ${String(idsByTier[t].length).padStart(5)}  mult ${(PAY[t].multBp / 10000)}x`);