@energy8platform/game-engine 0.15.2 → 0.16.0

package/dist/lua.cjs.js

@@ -1,1499 +1,13 @@
 'use strict';
 
-var fengari = require('fengari');
-var worker_threads = require('worker_threads');
-var os = require('os');
-var url = require('url');
-var path = require('path');
-var child_process = require('child_process');
-var promises = require('fs/promises');
-var fs = require('fs');
-var crypto = require('crypto');
+var lua = require('@energy8platform/platform-core/lua');
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-const { lua: lua$1, lauxlib: lauxlib$1 } = fengari;
-const { to_luastring: to_luastring$1, to_jsstring: to_jsstring$1 } = fengari;
-/** Cache for to_luastring() results — avoids re-encoding the same keys every iteration */
-const luaStringCache = new Map();
-function cachedToLuastring(s) {
-    let cached = luaStringCache.get(s);
-    if (!cached) {
-        cached = to_luastring$1(s);
-        luaStringCache.set(s, cached);
-    }
-    return cached;
-}
-/**
- * Seeded xoshiro128** PRNG for deterministic simulation/replay.
- * Period: 2^128 - 1
- */
-function createSeededRng(seed) {
-    let s0 = (seed >>> 0) | 1;
-    let s1 = (seed * 1103515245 + 12345) >>> 0;
-    let s2 = (seed * 6364136223846793005 + 1442695040888963407) >>> 0;
-    let s3 = (seed * 1442695040888963407 + 6364136223846793005) >>> 0;
-    return () => {
-        const result = (((s1 * 5) << 7) * 9) >>> 0;
-        const t = s1 << 9;
-        s2 ^= s0;
-        s3 ^= s1;
-        s1 ^= s2;
-        s0 ^= s3;
-        s2 ^= t;
-        s3 = ((s3 << 11) | (s3 >>> 21)) >>> 0;
-        return result / 4294967296;
-    };
-}
-/**
- * Implements and registers all platform `engine.*` functions into a Lua state.
- */
-class LuaEngineAPI {
-    rng;
-    logger;
-    gameDefinition;
-    constructor(gameDefinition, rng, logger) {
-        this.gameDefinition = gameDefinition;
-        this.rng = rng ?? Math.random;
-        this.logger = logger ?? ((level, msg) => {
-            const fn = level === 'error' ? console.error
-                : level === 'warn' ? console.warn
-                    : level === 'debug' ? console.debug
-                        : console.log;
-            fn(`[Lua:${level}] ${msg}`);
-        });
-    }
-    /** Register `engine` global table on the Lua state */
-    register(L) {
-        // Create the `engine` table
-        lua$1.lua_newtable(L);
-        this.registerFunction(L, 'random', (LS) => {
-            const min = lauxlib$1.luaL_checkinteger(LS, 1);
-            const max = lauxlib$1.luaL_checkinteger(LS, 2);
-            const result = this.random(Number(min), Number(max));
-            lua$1.lua_pushinteger(LS, result);
-            return 1;
-        });
-        this.registerFunction(L, 'random_float', (LS) => {
-            lua$1.lua_pushnumber(LS, this.randomFloat());
-            return 1;
-        });
-        this.registerFunction(L, 'random_weighted', (LS) => {
-            lauxlib$1.luaL_checktype(LS, 1, lua$1.LUA_TTABLE);
-            const weights = [];
-            const len = lua$1.lua_rawlen(LS, 1);
-            for (let i = 1; i <= len; i++) {
-                lua$1.lua_rawgeti(LS, 1, i);
-                weights.push(lua$1.lua_tonumber(LS, -1));
-                lua$1.lua_pop(LS, 1);
-            }
-            const result = this.randomWeighted(weights);
-            lua$1.lua_pushinteger(LS, result);
-            return 1;
-        });
-        this.registerFunction(L, 'shuffle', (LS) => {
-            lauxlib$1.luaL_checktype(LS, 1, lua$1.LUA_TTABLE);
-            const arr = [];
-            const len = lua$1.lua_rawlen(LS, 1);
-            for (let i = 1; i <= len; i++) {
-                lua$1.lua_rawgeti(LS, 1, i);
-                arr.push(luaToJS(LS, -1));
-                lua$1.lua_pop(LS, 1);
-            }
-            const shuffled = this.shuffle(arr);
-            pushJSArray(LS, shuffled);
-            return 1;
-        });
-        this.registerFunction(L, 'log', (LS) => {
-            const level = to_jsstring$1(lauxlib$1.luaL_checkstring(LS, 1));
-            const msg = to_jsstring$1(lauxlib$1.luaL_checkstring(LS, 2));
-            this.logger(level, msg);
-            return 0;
-        });
-        this.registerFunction(L, 'get_config', (LS) => {
-            const config = this.getConfig();
-            pushJSObject(LS, config);
-            return 1;
-        });
-        // Set the table as global `engine`
-        lua$1.lua_setglobal(L, to_luastring$1('engine'));
-    }
-    // ─── engine.* implementations ─────────────────────────
-    random(min, max) {
-        return Math.floor(this.rng() * (max - min + 1)) + min;
-    }
-    randomFloat() {
-        return this.rng();
-    }
-    randomWeighted(weights) {
-        const totalWeight = weights.reduce((a, b) => a + b, 0);
-        let roll = this.rng() * totalWeight;
-        for (let i = 0; i < weights.length; i++) {
-            roll -= weights[i];
-            if (roll < 0)
-                return i + 1; // 1-based index
-        }
-        return weights.length; // fallback to last
-    }
-    shuffle(arr) {
-        const copy = [...arr];
-        for (let i = copy.length - 1; i > 0; i--) {
-            const j = Math.floor(this.rng() * (i + 1));
-            [copy[i], copy[j]] = [copy[j], copy[i]];
-        }
-        return copy;
-    }
-    getConfig() {
-        const def = this.gameDefinition;
-        let betLevels = [];
-        if (Array.isArray(def.bet_levels)) {
-            betLevels = def.bet_levels;
-        }
-        else if (def.bet_levels && 'levels' in def.bet_levels && def.bet_levels.levels) {
-            betLevels = def.bet_levels.levels;
-        }
-        return {
-            id: def.id,
-            type: def.type,
-            bet_levels: betLevels,
-        };
-    }
-    // ─── Helpers ──────────────────────────────────────────
-    registerFunction(L, name, fn) {
-        lua$1.lua_pushcfunction(L, fn);
-        lua$1.lua_setfield(L, -2, to_luastring$1(name));
-    }
-}
-// ─── Lua ↔ JS marshalling ───────────────────────────────
-/** Read a Lua value at the given stack index and return its JS equivalent */
-function luaToJS(L, idx) {
-    const type = lua$1.lua_type(L, idx);
-    switch (type) {
-        case lua$1.LUA_TNIL:
-            return null;
-        case lua$1.LUA_TBOOLEAN:
-            return lua$1.lua_toboolean(L, idx);
-        case lua$1.LUA_TNUMBER:
-            if (lua$1.lua_isinteger(L, idx)) {
-                return Number(lua$1.lua_tointeger(L, idx));
-            }
-            return lua$1.lua_tonumber(L, idx);
-        case lua$1.LUA_TSTRING:
-            return to_jsstring$1(lua$1.lua_tostring(L, idx));
-        case lua$1.LUA_TTABLE:
-            return luaTableToJS(L, idx);
-        default:
-            return null;
-    }
-}
-/** Convert a Lua table to a JS object or array */
-function luaTableToJS(L, idx) {
-    // Normalize index to absolute
-    if (idx < 0)
-        idx = lua$1.lua_gettop(L) + idx + 1;
-    // Check if it's an array (sequential integer keys starting at 1)
-    const len = lua$1.lua_rawlen(L, idx);
-    if (len > 0) {
-        // Verify it's a pure array by checking key 1 exists
-        lua$1.lua_rawgeti(L, idx, 1);
-        const hasFirst = lua$1.lua_type(L, -1) !== lua$1.LUA_TNIL;
-        lua$1.lua_pop(L, 1);
-        if (hasFirst) {
-            // Check if there are also string keys (mixed table)
-            let hasStringKeys = false;
-            lua$1.lua_pushnil(L);
-            while (lua$1.lua_next(L, idx) !== 0) {
-                lua$1.lua_pop(L, 1); // pop value
-                if (lua$1.lua_type(L, -1) === lua$1.LUA_TSTRING) {
-                    hasStringKeys = true;
-                    lua$1.lua_pop(L, 1); // pop key
-                    break;
-                }
-            }
-            if (!hasStringKeys) {
-                // Pure array
-                const arr = [];
-                for (let i = 1; i <= len; i++) {
-                    lua$1.lua_rawgeti(L, idx, i);
-                    arr.push(luaToJS(L, -1));
-                    lua$1.lua_pop(L, 1);
-                }
-                return arr;
-            }
-        }
-    }
-    // Object (or mixed table)
-    const obj = {};
-    lua$1.lua_pushnil(L);
-    while (lua$1.lua_next(L, idx) !== 0) {
-        const keyType = lua$1.lua_type(L, -2);
-        let key;
-        if (keyType === lua$1.LUA_TSTRING) {
-            key = to_jsstring$1(lua$1.lua_tostring(L, -2));
-        }
-        else if (keyType === lua$1.LUA_TNUMBER) {
-            key = String(lua$1.lua_tonumber(L, -2));
-        }
-        else {
-            lua$1.lua_pop(L, 1);
-            continue;
-        }
-        obj[key] = luaToJS(L, -1);
-        lua$1.lua_pop(L, 1);
-    }
-    return obj;
-}
-/** Push a JS value onto the Lua stack */
-function pushJSValue(L, value) {
-    if (value === null || value === undefined) {
-        lua$1.lua_pushnil(L);
-    }
-    else if (typeof value === 'boolean') {
-        lua$1.lua_pushboolean(L, value ? 1 : 0);
-    }
-    else if (typeof value === 'number') {
-        if (Number.isInteger(value)) {
-            lua$1.lua_pushinteger(L, value);
-        }
-        else {
-            lua$1.lua_pushnumber(L, value);
-        }
-    }
-    else if (typeof value === 'string') {
-        lua$1.lua_pushstring(L, cachedToLuastring(value));
-    }
-    else if (Array.isArray(value)) {
-        pushJSArray(L, value);
-    }
-    else if (typeof value === 'object') {
-        pushJSObject(L, value);
-    }
-    else {
-        lua$1.lua_pushnil(L);
-    }
-}
-/** Push a JS array as a Lua table (1-based) */
-function pushJSArray(L, arr) {
-    lua$1.lua_createtable(L, arr.length, 0);
-    for (let i = 0; i < arr.length; i++) {
-        pushJSValue(L, arr[i]);
-        lua$1.lua_rawseti(L, -2, i + 1);
-    }
-}
-/** Push a JS object as a Lua table */
-function pushJSObject(L, obj) {
-    const keys = Object.keys(obj);
-    lua$1.lua_createtable(L, 0, keys.length);
-    for (const key of keys) {
-        pushJSValue(L, obj[key]);
-        lua$1.lua_setfield(L, -2, cachedToLuastring(key));
-    }
-}
 
-/**
- * Replicates the platform's action dispatch and transition evaluation.
- * Routes play requests to the correct action, evaluates transition conditions
- * against current variables to determine next actions and session operations.
- */
-class ActionRouter {
-    actions;
-    constructor(gameDefinition) {
-        this.actions = gameDefinition.actions;
-    }
-    /** Look up action by name and validate prerequisites */
-    resolveAction(actionName, hasSession) {
-        const action = this.actions[actionName];
-        if (!action) {
-            throw new Error(`Unknown action: "${actionName}". Available: ${Object.keys(this.actions).join(', ')}`);
-        }
-        if (action.requires_session && !hasSession) {
-            throw new Error(`Action "${actionName}" requires an active session`);
-        }
-        return action;
-    }
-    /** Evaluate transitions in order, return the first matching rule */
-    evaluateTransitions(action, variables) {
-        for (const rule of action.transitions) {
-            if (evaluateCondition(rule.condition, variables)) {
-                return { rule, nextActions: rule.next_actions };
-            }
-        }
-        throw new Error(`No matching transition for action with stage "${action.stage}". ` +
-            `Variables: ${JSON.stringify(variables)}`);
-    }
-}
-// ─── Condition Evaluator ────────────────────────────────
-/**
- * Evaluates a transition condition expression against variables.
- *
- * Supports:
- * - "always" → true
- * - Simple comparisons: "var > 0", "var == 1", "var >= 10", "var != 0", "var < 5", "var <= 3"
- * - Logical connectives: "expr && expr", "expr || expr"
- *
- * This covers all patterns used by the platform's govaluate conditions.
- */
-function evaluateCondition(condition, variables) {
-    const trimmed = condition.trim();
-    if (trimmed === 'always')
-        return true;
-    // Handle || (OR) — lowest precedence
-    if (trimmed.includes('||')) {
-        const parts = splitOnOperator(trimmed, '||');
-        return parts.some(part => evaluateCondition(part, variables));
-    }
-    // Handle && (AND)
-    if (trimmed.includes('&&')) {
-        const parts = splitOnOperator(trimmed, '&&');
-        return parts.every(part => evaluateCondition(part, variables));
-    }
-    // Single comparison: "variable op value"
-    return evaluateComparison(trimmed, variables);
-}
-function splitOnOperator(expr, operator) {
-    const parts = [];
-    let depth = 0;
-    let current = '';
-    for (let i = 0; i < expr.length; i++) {
-        if (expr[i] === '(')
-            depth++;
-        else if (expr[i] === ')')
-            depth--;
-        if (depth === 0 && expr.substring(i, i + operator.length) === operator) {
-            parts.push(current);
-            current = '';
-            i += operator.length - 1;
-        }
-        else {
-            current += expr[i];
-        }
-    }
-    parts.push(current);
-    return parts;
-}
-function evaluateComparison(expr, variables) {
-    // Match: variable_name operator value
-    const match = expr.trim().match(/^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*(>=|<=|!=|==|>|<)\s*(-?\d+(?:\.\d+)?)\s*$/);
-    if (!match) {
-        throw new Error(`Cannot parse condition: "${expr}"`);
-    }
-    const [, varName, op, valueStr] = match;
-    const left = variables[varName] ?? 0;
-    const right = parseFloat(valueStr);
-    switch (op) {
-        case '>': return left > right;
-        case '>=': return left >= right;
-        case '<': return left < right;
-        case '<=': return left <= right;
-        case '==': return left === right;
-        case '!=': return left !== right;
-        default: return false;
-    }
-}
 
-const MAX_SESSION_SPINS = 200;
-/**
- * Manages session lifecycle matching the platform server behavior:
- * - createSession: initial spin counted (spinsPlayed=1, totalWin=spinWin)
- * - updateSession: accumulates win, decrements spins, checks max win cap on session level
- * - completeSession: returns cumulative totalWin, cleans up session vars
- * - Safety cap: 200 spins max per session
- */
-class SessionManager {
-    session = null;
-    get isActive() {
-        return this.session !== null && !this.session.completed;
-    }
-    get current() {
-        if (!this.session)
-            return null;
-        return this.toSessionData();
-    }
-    get sessionTotalWin() {
-        return this.session?.totalWin ?? 0;
-    }
-    /** Get the fixed bet amount from the session (server uses session bet, not request bet) */
-    get sessionBet() {
-        return this.session?.bet;
-    }
-    /** Get spinsVarName to restore free_spins_remaining into variables */
-    get spinsVarName() {
-        return this.session?.spinsVarName;
-    }
-    get spinsRemaining() {
-        return this.session?.spinsRemaining ?? 0;
-    }
-    /**
-     * Create a new session from a transition rule.
-     * Server behavior: initial spin is already counted (spinsPlayed=1, totalWin includes spinWin).
-     */
-    createSession(rule, variables, bet, spinWin, maxWinCap) {
-        let spinsRemaining = -1;
-        let spinsVarName;
-        if (rule.session_config?.total_spins_var) {
-            spinsVarName = rule.session_config.total_spins_var;
-            spinsRemaining = variables[spinsVarName] ?? -1;
-        }
-        const persistentVarNames = rule.session_config?.persistent_vars ?? [];
-        const persistentVars = {};
-        for (const varName of persistentVarNames) {
-            persistentVars[varName] = variables[varName] ?? 0;
-        }
-        this.session = {
-            spinsRemaining,
-            spinsPlayed: 1, // initial spin counts
-            totalWin: spinWin, // initial spin win included
-            completed: false,
-            maxWinReached: false,
-            bet,
-            maxWinCap,
-            spinsVarName,
-            persistentVarNames,
-            persistentVars,
-            persistentData: {},
-        };
-        return this.toSessionData();
-    }
-    /**
-     * Update session after a bonus spin.
-     * Server behavior: accumulate win, decrement spins, check retrigger, check max win cap,
-     * safety cap at 200 spins.
-     */
-    updateSession(rule, variables, spinWin) {
-        if (!this.session)
-            throw new Error('No active session');
-        // Accumulate win and count spin
-        this.session.totalWin += spinWin;
-        this.session.spinsPlayed++;
-        // Decrement spins (only for non-unlimited sessions)
-        if (this.session.spinsRemaining > 0) {
-            this.session.spinsRemaining--;
-        }
-        // Handle retrigger (add_spins_var)
-        if (rule.add_spins_var) {
-            const extraSpins = variables[rule.add_spins_var] ?? 0;
-            if (extraSpins > 0 && this.session.spinsRemaining >= 0) {
-                this.session.spinsRemaining += extraSpins;
-            }
-        }
-        // Safety cap: server limits sessions to 200 spins
-        if (this.session.spinsPlayed >= MAX_SESSION_SPINS) {
-            this.session.spinsRemaining = 0;
-        }
-        // Update session persistent vars from current variables
-        for (const varName of this.session.persistentVarNames) {
-            if (varName in variables) {
-                this.session.persistentVars[varName] = variables[varName];
-            }
-        }
-        // Check max win cap (on session level, not per spin)
-        if (this.session.maxWinCap !== undefined && this.session.totalWin >= this.session.maxWinCap) {
-            this.session.totalWin = this.session.maxWinCap;
-            this.session.spinsRemaining = 0;
-            this.session.maxWinReached = true;
-        }
-        // Auto-complete if spins exhausted or explicit complete
-        if (this.session.spinsRemaining === 0 || rule.complete_session) {
-            this.session.completed = true;
-        }
-        return this.toSessionData();
-    }
-    /**
-     * Complete the session explicitly.
-     * Returns cumulative totalWin and list of session-scoped var names to clean up.
-     */
-    completeSession() {
-        if (!this.session)
-            throw new Error('No active session to complete');
-        this.session.completed = true;
-        const totalWin = this.session.totalWin;
-        const session = this.toSessionData();
-        const sessionVarNames = [...this.session.persistentVarNames];
-        this.session = null;
-        return { totalWin, session, sessionVarNames };
-    }
-    /** Mark max win reached — stops the session */
-    markMaxWinReached() {
-        if (this.session) {
-            this.session.maxWinReached = true;
-            this.session.completed = true;
-        }
-    }
-    /** Store _persist_* data extracted from Lua result */
-    storePersistData(data) {
-        if (!this.session)
-            return;
-        for (const key of Object.keys(data)) {
-            if (key.startsWith('_persist_')) {
-                const cleanKey = key.slice('_persist_'.length);
-                this.session.persistentData[cleanKey] = data[key];
-            }
-        }
-    }
-    /** Get persistent params to inject into next execute() call */
-    getPersistentParams() {
-        if (!this.session)
-            return {};
-        const params = {};
-        // Session persistent vars (float64) → state.variables
-        for (const [key, value] of Object.entries(this.session.persistentVars)) {
-            params[key] = value;
-        }
-        // _persist_ complex data → _ps_* in state.params
-        for (const [key, value] of Object.entries(this.session.persistentData)) {
-            params[`_ps_${key}`] = value;
-        }
-        return params;
-    }
-    /** Reset all session state */
-    reset() {
-        this.session = null;
-    }
-    toSessionData() {
-        if (!this.session)
-            throw new Error('No session');
-        return {
-            spinsRemaining: this.session.spinsRemaining,
-            spinsPlayed: this.session.spinsPlayed,
-            totalWin: Math.round(this.session.totalWin * 100) / 100,
-            completed: this.session.completed,
-            maxWinReached: this.session.maxWinReached,
-            betAmount: this.session.bet,
-        };
-    }
-}
-
-/**
- * Manages cross-spin persistent state — variables that survive between base game spins.
- * Separate from session-scoped persistence (handled by SessionManager).
- *
- * Handles two mechanisms:
- * 1. Numeric vars declared in `persistent_state.vars` — stored in state.variables
- * 2. Complex data with `_persist_game_*` prefix — stored separately, injected as `_ps_*`
- */
-class PersistentState {
-    config;
-    vars = {};
-    gameData = {};
-    constructor(config) {
-        this.config = config;
-    }
-    /** Load persistent vars into variables map before execute() */
-    loadIntoVariables(variables) {
-        if (!this.config)
-            return;
-        for (const varName of this.config.vars) {
-            if (varName in this.vars) {
-                variables[varName] = this.vars[varName];
-            }
-        }
-    }
-    /** Save persistent vars from variables map after execute() */
-    saveFromVariables(variables) {
-        if (!this.config)
-            return;
-        for (const varName of this.config.vars) {
-            if (varName in variables) {
-                this.vars[varName] = variables[varName];
-            }
-        }
-    }
-    /** Extract _persist_game_* keys from Lua return data, store them */
-    storeGameData(data) {
-        for (const key of Object.keys(data)) {
-            if (key.startsWith('_persist_game_')) {
-                const cleanKey = key.slice('_persist_game_'.length);
-                this.gameData[cleanKey] = data[key];
-                delete data[key]; // remove from client data
-            }
-        }
-    }
-    /** Get _ps_* params for next execute() call */
-    getGameDataParams() {
-        const params = {};
-        for (const [key, value] of Object.entries(this.gameData)) {
-            params[`_ps_${key}`] = value;
-        }
-        return params;
-    }
-    /** Get exposed vars for client data.persistent_state */
-    getExposedVars() {
-        if (!this.config?.exposed_vars?.length)
-            return undefined;
-        const exposed = {};
-        for (const varName of this.config.exposed_vars) {
-            if (varName in this.vars) {
-                exposed[varName] = this.vars[varName];
-            }
-        }
-        return exposed;
-    }
-    /** Reset all state */
-    reset() {
-        this.vars = {};
-        this.gameData = {};
-    }
-}
-
-const { lua, lauxlib, lualib } = fengari;
-const { to_luastring, to_jsstring } = fengari;
-/** Default engine variables matching the server's NewGameState() */
-const DEFAULT_VARIABLES = {
-    multiplier: 1,
-    total_multiplier: 1,
-    global_multiplier: 1,
-    last_win_amount: 0,
-    free_spins_awarded: 0,
-};
-/**
- * Runs Lua game scripts locally, replicating the platform's server-side execution.
- *
- * Implements the full lifecycle matching `casino_platform/internal/usecase/game_usecase.go`:
- * action routing → state assembly → Lua execute() → result extraction →
- * transition evaluation → session management.
- */
-class LuaEngine {
-    L;
-    api;
-    actionRouter;
-    sessionManager;
-    persistentState;
-    gameDefinition;
-    variables = {};
-    simulationMode;
-    /** Reusable state objects to avoid per-iteration allocation */
-    _stateVars = {};
-    _stateParams = {};
-    constructor(config) {
-        this.gameDefinition = config.gameDefinition;
-        this.simulationMode = config.simulationMode ?? false;
-        const rng = config.seed !== undefined
-            ? createSeededRng(config.seed)
-            : undefined;
-        this.api = new LuaEngineAPI(config.gameDefinition, rng, config.logger);
-        this.actionRouter = new ActionRouter(config.gameDefinition);
-        this.sessionManager = new SessionManager();
-        this.persistentState = new PersistentState(config.gameDefinition.persistent_state);
-        this.L = lauxlib.luaL_newstate();
-        lualib.luaL_openlibs(this.L);
-        // Polyfill Lua 5.1/5.2 functions removed in 5.3
-        lauxlib.luaL_dostring(this.L, to_luastring(`
-      math.pow = function(a, b) return a ^ b end
-      math.atan2 = math.atan2 or function(y, x) return math.atan(y, x) end
-      math.log10 = math.log10 or function(x) return math.log(x, 10) end
-      math.cosh = math.cosh or function(x) return (math.exp(x) + math.exp(-x)) / 2 end
-      math.sinh = math.sinh or function(x) return (math.exp(x) - math.exp(-x)) / 2 end
-      math.tanh = math.tanh or function(x) return math.sinh(x) / math.cosh(x) end
-      math.frexp = math.frexp or function(x)
-        if x == 0 then return 0, 0 end
-        local e = math.floor(math.log(math.abs(x), 2)) + 1
-        return x / (2 ^ e), e
-      end
-      math.ldexp = math.ldexp or function(m, e) return m * (2 ^ e) end
-      unpack = unpack or table.unpack
-      loadstring = loadstring or load
-      table.getn = table.getn or function(t) return #t end
-    `));
-        this.api.register(this.L);
-        this.loadScript(config.script);
-    }
-    get session() {
-        return this.sessionManager.current;
-    }
-    get persistentVars() {
-        return { ...this.variables };
-    }
-    /**
-     * Execute a play action — replicates server's Play() function.
-     */
-    execute(params) {
-        const { action: actionName, params: clientParams } = params;
-        // 1. Resolve action
-        const action = this.actionRouter.resolveAction(actionName, this.sessionManager.isActive);
-        // 2. Determine bet — server uses session bet for session actions
-        let bet = params.bet;
-        if (this.sessionManager.isActive && this.sessionManager.sessionBet !== undefined) {
-            bet = this.sessionManager.sessionBet;
-        }
-        // 3. Build state.variables (matching server's NewGameState + restore)
-        // Reuse pooled object to avoid per-iteration allocation
-        const stateVars = this._stateVars;
-        // Clear previous keys
-        for (const key in stateVars)
-            delete stateVars[key];
-        // Apply defaults, then engine vars, then bet
-        Object.assign(stateVars, DEFAULT_VARIABLES, this.variables);
-        stateVars.bet = bet;
-        // Load cross-spin persistent state
-        this.persistentState.loadIntoVariables(stateVars);
-        // Load session persistent vars + restore spinsRemaining
-        if (this.sessionManager.isActive) {
-            const sessionParams = this.sessionManager.getPersistentParams();
-            for (const [k, v] of Object.entries(sessionParams)) {
-                if (typeof v === 'number') {
-                    stateVars[k] = v;
-                }
-            }
-            // Restore spinsRemaining into the variable the script reads
-            if (this.sessionManager.spinsVarName) {
-                stateVars[this.sessionManager.spinsVarName] = this.sessionManager.spinsRemaining;
-            }
-            // Also set free_spins_remaining for convenience
-            stateVars.free_spins_remaining = this.sessionManager.spinsRemaining;
-        }
-        // 4. Build state.params (reuse pooled object)
-        const stateParams = this._stateParams;
-        for (const key in stateParams)
-            delete stateParams[key];
-        if (clientParams)
-            Object.assign(stateParams, clientParams);
-        stateParams._action = actionName;
-        // Inject session _ps_* persistent data
-        if (this.sessionManager.isActive) {
-            const sessionParams = this.sessionManager.getPersistentParams();
-            for (const [k, v] of Object.entries(sessionParams)) {
-                if (typeof v !== 'number') {
-                    stateParams[k] = v;
-                }
-            }
-        }
-        // Inject cross-spin _ps_* game data
-        const gameDataParams = this.persistentState.getGameDataParams();
-        Object.assign(stateParams, gameDataParams);
-        // Handle buy bonus
-        if (action.buy_bonus_mode && this.gameDefinition.buy_bonus) {
-            const mode = this.gameDefinition.buy_bonus.modes[action.buy_bonus_mode];
-            if (mode) {
-                stateParams.buy_bonus = true;
-                stateParams.buy_bonus_mode = action.buy_bonus_mode;
-                if (mode.scatter_distribution) {
-                    stateParams.forced_scatter_count = this.pickFromDistribution(mode.scatter_distribution);
-                }
-            }
-        }
-        // Handle ante bet
-        if (clientParams?.ante_bet && this.gameDefinition.ante_bet) {
-            stateParams.ante_bet = true;
-        }
-        // 5. Execute Lua (server: executor.Execute(stage, state))
-        const luaResult = this.callLuaExecute(action.stage, actionName, stateParams, stateVars);
-        // 6. Process result (server: ApplyLuaResult)
-        const totalWinMultiplier = typeof luaResult.total_win === 'number' ? luaResult.total_win : 0;
-        const resultVariables = (luaResult.variables ?? {});
-        const spinWin = Math.round(totalWinMultiplier * bet * 100) / 100;
-        // Merge ONLY Lua return variables into engine state (not the whole stateVars).
-        // On the server, state.Variables is a temporary object rebuilt each call.
-        // Only the Lua result's `variables` table persists between calls.
-        Object.assign(this.variables, resultVariables);
-        // Also update stateVars for transition evaluation below
-        Object.assign(stateVars, resultVariables);
-        // Build client data (everything except special keys)
-        const data = {};
-        for (const [key, value] of Object.entries(luaResult)) {
-            if (key !== 'total_win' && key !== 'variables') {
-                data[key] = value;
-            }
-        }
-        // 7. Handle _persist_* and _persist_game_* keys
-        this.sessionManager.storePersistData(data);
-        this.persistentState.storeGameData(data);
-        // Save cross-spin persistent state (from stateVars which has Lua result merged)
-        this.persistentState.saveFromVariables(stateVars);
-        // Add exposed persistent vars to client data
-        const exposedVars = this.persistentState.getExposedVars();
-        if (exposedVars) {
-            data.persistent_state = exposedVars;
-        }
-        // Remove _persist_* keys from client data
-        for (const key of Object.keys(data)) {
-            if (key.startsWith('_persist_')) {
-                delete data[key];
-            }
-        }
-        // 8. Evaluate transitions (server uses state.Variables which is stateVars)
-        const { rule, nextActions } = this.actionRouter.evaluateTransitions(action, stateVars);
-        // 9. Determine credit behavior (server: creditNow logic)
-        let creditDeferred = action.credit === 'defer' || rule.credit_override === 'defer';
-        // 10. Session lifecycle (server: create/update/complete session)
-        let session = this.sessionManager.current;
-        let resultTotalWin = spinWin;
-        let sessionCompleted = false;
-        // Calculate max win cap for session
-        const maxWinCap = this.calculateMaxWinCap(bet);
-        if (rule.creates_session && !this.sessionManager.isActive) {
-            // CREATE SESSION — initial spin counted (server: createSession includes spinWin)
-            session = this.sessionManager.createSession(rule, stateVars, bet, spinWin, maxWinCap);
-            creditDeferred = true;
-            resultTotalWin = spinWin;
-            // Clear the trigger variable — it was consumed to set spinsRemaining
-            if (rule.session_config?.total_spins_var) {
-                delete this.variables[rule.session_config.total_spins_var];
-            }
-        }
-        else if (this.sessionManager.isActive) {
-            // UPDATE SESSION — accumulate win, check completion
-            session = this.sessionManager.updateSession(rule, stateVars, spinWin);
-            if (session?.completed) {
-                // SESSION COMPLETED — server returns session.TotalWin as result.TotalWin
-                const completed = this.sessionManager.completeSession();
-                session = completed.session;
-                resultTotalWin = completed.totalWin;
-                sessionCompleted = true;
-                creditDeferred = false;
-                // Clean up session-scoped variables
-                for (const varName of completed.sessionVarNames) {
-                    delete this.variables[varName];
-                }
-            }
-            else {
-                // Mid-session: totalWin = spinWin, credit deferred
-                resultTotalWin = spinWin;
-                creditDeferred = true;
-            }
-        }
-        // No session: resultTotalWin = spinWin (already set)
-        // Apply max win cap for non-session spins
-        if (!this.sessionManager.isActive && !sessionCompleted && maxWinCap !== undefined && resultTotalWin > maxWinCap) {
-            resultTotalWin = maxWinCap;
-            this.variables.max_win_reached = 1;
-            data.max_win_reached = true;
-        }
-        return {
-            totalWin: Math.round(resultTotalWin * 100) / 100,
-            data,
-            nextActions,
-            session,
-            // In simulation mode, return reference directly (caller only reads, never mutates)
-            variables: this.simulationMode ? this.variables : { ...this.variables },
-            creditDeferred,
-        };
-    }
-    reset() {
-        this.variables = {};
-        this.sessionManager.reset();
-        this.persistentState.reset();
-    }
-    destroy() {
-        if (this.L) {
-            lua.lua_close(this.L);
-            this.L = null;
-        }
-    }
-    // ─── Private ──────────────────────────────────────────
-    loadScript(source) {
-        const status = lauxlib.luaL_dostring(this.L, to_luastring(source));
-        if (status !== lua.LUA_OK) {
-            const err = to_jsstring(lua.lua_tostring(this.L, -1));
-            lua.lua_pop(this.L, 1);
-            throw new Error(`Failed to load Lua script: ${err}`);
-        }
-        lua.lua_getglobal(this.L, cachedToLuastring('execute'));
-        if (lua.lua_type(this.L, -1) !== lua.LUA_TFUNCTION) {
-            lua.lua_pop(this.L, 1);
-            throw new Error('Lua script must define a global `execute(state)` function');
-        }
-        lua.lua_pop(this.L, 1);
-    }
-    callLuaExecute(stage, action, params, variables) {
-        lua.lua_getglobal(this.L, cachedToLuastring('execute'));
-        // Build state table: {stage, action, params, variables}
-        lua.lua_createtable(this.L, 0, 4);
-        // state.stage
-        lua.lua_pushstring(this.L, cachedToLuastring(stage));
-        lua.lua_setfield(this.L, -2, cachedToLuastring('stage'));
-        // state.action (server sets this at top level)
-        lua.lua_pushstring(this.L, cachedToLuastring(action));
-        lua.lua_setfield(this.L, -2, cachedToLuastring('action'));
-        // state.params
-        pushJSValue(this.L, params);
-        lua.lua_setfield(this.L, -2, cachedToLuastring('params'));
-        // state.variables
-        pushJSValue(this.L, variables);
-        lua.lua_setfield(this.L, -2, cachedToLuastring('variables'));
-        const status = lua.lua_pcall(this.L, 1, 1, 0);
-        if (status !== lua.LUA_OK) {
-            const err = to_jsstring(lua.lua_tostring(this.L, -1));
-            lua.lua_pop(this.L, 1);
-            throw new Error(`Lua execute() failed: ${err}`);
-        }
-        if (this.simulationMode) {
-            // Fast path: extract only total_win, variables, _persist_* keys
-            const result = {};
-            lua.lua_getfield(this.L, -1, cachedToLuastring('total_win'));
-            result.total_win = lua.lua_type(this.L, -1) === lua.LUA_TNUMBER
-                ? lua.lua_tonumber(this.L, -1) : 0;
-            lua.lua_pop(this.L, 1);
-            lua.lua_getfield(this.L, -1, cachedToLuastring('variables'));
-            if (lua.lua_type(this.L, -1) === lua.LUA_TTABLE) {
-                result.variables = luaToJS(this.L, -1);
-            }
-            lua.lua_pop(this.L, 1);
-            // Scan for _persist_* keys (different stages may or may not have them)
-            lua.lua_pushnil(this.L);
-            while (lua.lua_next(this.L, -2) !== 0) {
-                if (lua.lua_type(this.L, -2) === lua.LUA_TSTRING) {
-                    const key = to_jsstring(lua.lua_tostring(this.L, -2));
-                    if (key.startsWith('_persist_')) {
-                        result[key] = luaToJS(this.L, -1);
-                    }
-                }
-                lua.lua_pop(this.L, 1);
-            }
-            lua.lua_pop(this.L, 1);
-            return result;
-        }
-        // Full path
-        const result = luaToJS(this.L, -1);
-        lua.lua_pop(this.L, 1);
-        if (!result || typeof result !== 'object' || Array.isArray(result)) {
-            throw new Error('Lua execute() must return a table');
-        }
-        return result;
-    }
-    calculateMaxWinCap(bet) {
-        const mw = this.gameDefinition.max_win;
-        if (!mw)
-            return undefined;
-        const caps = [];
-        if (mw.multiplier !== undefined)
-            caps.push(bet * mw.multiplier);
-        if (mw.fixed !== undefined)
-            caps.push(mw.fixed);
-        return caps.length > 0 ? Math.min(...caps) : undefined;
-    }
-    pickFromDistribution(distribution) {
-        const entries = Object.entries(distribution);
-        const totalWeight = entries.reduce((sum, [, w]) => sum + w, 0);
-        let roll = this.api.randomFloat() * totalWeight;
-        for (const [value, weight] of entries) {
-            roll -= weight;
-            if (roll < 0)
-                return parseInt(value, 10);
-        }
-        return parseInt(entries[entries.length - 1][0], 10);
-    }
-}
-
-/**
- * Runs N iterations of a Lua game script and collects RTP statistics.
- * Supports regular spins, buy bonus, and ante bet simulation.
- *
- * @example
- * ```ts
- * const runner = new SimulationRunner({
- *   script: luaSource,
- *   gameDefinition,
- *   iterations: 1_000_000,
- *   bet: 1.0,
- *   seed: 42,
- *   onProgress: (done, total) => console.log(`${done}/${total}`),
- * });
- *
- * const result = runner.run();
- * console.log(`RTP: ${result.totalRtp.toFixed(2)}%`);
- * ```
- */
-class SimulationRunner {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    run() {
-        const { script, gameDefinition, iterations, bet, seed, action: startAction = 'spin', params, progressInterval = 100_000, onProgress, } = this.config;
-        const engine = new LuaEngine({
-            script,
-            gameDefinition,
-            seed,
-            logger: () => { },
-            simulationMode: true,
-        });
-        const spinCost = this.calculateSpinCost(startAction, bet, gameDefinition, params);
-        let totalWagered = 0;
-        let totalWon = 0;
-        let baseGameWin = 0;
-        let bonusWin = 0;
-        let hits = 0;
-        let maxWinMultiplier = 0;
-        let maxWinHits = 0;
-        let bonusTriggered = 0;
-        let bonusSpinsPlayed = 0;
-        const startTime = Date.now();
-        try {
-            for (let i = 0; i < iterations; i++) {
-                totalWagered += spinCost;
-                let roundWin = 0;
-                let roundBonusWin = 0;
-                // Execute the starting action
-                let result = engine.execute({
-                    action: startAction,
-                    bet,
-                    params,
-                });
-                const baseWin = result.totalWin;
-                // If a session was created, play through it using nextActions from the engine
-                if (result.session && !result.session.completed) {
-                    bonusTriggered++;
-                    let safetyLimit = 10_000;
-                    while (result.session && !result.session.completed && safetyLimit-- > 0) {
-                        const nextAction = result.nextActions[0];
-                        result = engine.execute({ action: nextAction, bet });
-                        bonusSpinsPlayed++;
-                    }
-                    // Session completion returns cumulative totalWin (includes trigger spin).
-                    // Use it as the full round win — don't add baseWin separately.
-                    roundWin = result.totalWin;
-                    roundBonusWin = roundWin - baseWin;
-                }
-                else {
-                    // No session — just base game win
-                    roundWin = baseWin;
-                }
-                baseGameWin += baseWin;
-                bonusWin += roundBonusWin;
-                totalWon += roundWin;
-                if (roundWin > 0)
-                    hits++;
-                const roundMultiplier = roundWin / bet;
-                if (roundMultiplier > maxWinMultiplier) {
-                    maxWinMultiplier = roundMultiplier;
-                }
-                if (result.variables?.max_win_reached === 1) {
-                    maxWinHits++;
-                }
-                // Progress reporting
-                if (onProgress && (i + 1) % progressInterval === 0) {
-                    onProgress(i + 1, iterations);
-                }
-            }
-        }
-        finally {
-            engine.destroy();
-        }
-        const durationMs = Date.now() - startTime;
-        return {
-            gameId: gameDefinition.id,
-            action: startAction,
-            iterations,
-            durationMs,
-            totalRtp: totalWagered > 0 ? (totalWon / totalWagered) * 100 : 0,
-            baseGameRtp: totalWagered > 0 ? (baseGameWin / totalWagered) * 100 : 0,
-            bonusRtp: totalWagered > 0 ? (bonusWin / totalWagered) * 100 : 0,
-            hitFrequency: iterations > 0 ? (hits / iterations) * 100 : 0,
-            maxWin: Math.round(maxWinMultiplier * 100) / 100,
-            maxWinHits,
-            bonusTriggered,
-            bonusSpinsPlayed,
-            _raw: { totalWagered, totalWon, baseGameWin, bonusWin, hits },
-        };
-    }
-    /** Calculate the real cost of one spin (accounting for buy bonus / ante bet) */
-    calculateSpinCost(action, bet, gameDefinition, params) {
-        // Check if this is a buy bonus action
-        const actionDef = gameDefinition.actions[action];
-        if (actionDef?.buy_bonus_mode && gameDefinition.buy_bonus) {
-            const mode = gameDefinition.buy_bonus.modes[actionDef.buy_bonus_mode];
-            if (mode) {
-                return bet * mode.cost_multiplier;
-            }
-        }
-        // Check ante bet
-        if (params?.ante_bet && gameDefinition.ante_bet) {
-            return bet * gameDefinition.ante_bet.cost_multiplier;
-        }
-        return bet;
-    }
-}
-/** Format a SimulationResult for console output */
-function formatSimulationResult(result) {
-    const lines = [
-        '',
-        '--- Simulation Results ---',
-        `Game: ${result.gameId}`,
-        `Action: ${result.action}`,
-        `Iterations: ${result.iterations.toLocaleString()}`,
-        `Duration: ${(result.durationMs / 1000).toFixed(1)}s`,
-        `Total RTP: ${result.totalRtp.toFixed(2)}%`,
-        `Base Game RTP: ${result.baseGameRtp.toFixed(2)}%`,
-        `Bonus RTP: ${result.bonusRtp.toFixed(2)}%`,
-        `Hit Frequency: ${result.hitFrequency.toFixed(2)}%`,
-        `Max Win: ${result.maxWin.toFixed(2)}x`,
-        `Max Win Hits: ${result.maxWinHits} (rounds capped by max_win)`,
-    ];
-    if (result.bonusTriggered > 0) {
-        const frequency = Math.round(result.iterations / result.bonusTriggered);
-        lines.push(`Bonus Triggered: ${result.bonusTriggered.toLocaleString()} (1 in ${frequency} spins)`);
-        lines.push(`Bonus Spins Played: ${result.bonusSpinsPlayed.toLocaleString()}`);
-    }
-    return lines.join('\n');
-}
-
-/// <reference types="node" />
-const SEED_STRIDE = 1 << 20; // 2^20 — gap between worker seeds to avoid overlap
-/**
- * Runs simulation across multiple worker threads for parallel speedup.
- * Each worker gets an independent LuaEngine with a partitioned seed range.
- *
- * Results are statistically equivalent to single-threaded mode but not
- * bit-identical (different RNG sequence ordering).
- *
- * @example
- * ```ts
- * const runner = new ParallelSimulationRunner({
- *   script: luaSource,
- *   gameDefinition,
- *   iterations: 1_000_000,
- *   bet: 1.0,
- *   workerCount: 8,
- *   onProgress: (done, total) => console.log(`${done}/${total}`),
- * });
- * const result = await runner.run();
- * ```
- */
-class ParallelSimulationRunner {
-    config;
-    workerCount;
-    constructor(config) {
-        this.config = config;
-        const maxWorkers = os.cpus().length;
-        this.workerCount = Math.max(1, Math.min(config.workerCount ?? maxWorkers, maxWorkers, config.iterations));
-    }
-    async run() {
-        const { iterations, seed, onProgress, workerCount: _, ...restConfig } = this.config;
-        const workerCount = this.workerCount;
-        // Split iterations evenly, remainder goes to last worker
-        const baseChunk = Math.floor(iterations / workerCount);
-        const remainder = iterations - baseChunk * workerCount;
-        const workerPath = path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('lua.cjs.js', document.baseURI).href)))), 'SimulationWorker.ts');
-        const progressPerWorker = new Array(workerCount).fill(0);
-        const totalIterations = iterations;
-        const promises = Array.from({ length: workerCount }, (_, i) => {
-            const workerIterations = baseChunk + (i < remainder ? 1 : 0);
-            const workerSeed = seed !== undefined ? seed + i * SEED_STRIDE : undefined;
-            const workerConfig = {
-                config: {
-                    ...restConfig,
-                    iterations: workerIterations,
-                    seed: workerSeed,
-                    progressInterval: this.config.progressInterval,
-                },
-            };
-            return new Promise((resolve, reject) => {
-                const worker = new worker_threads.Worker(workerPath, {
-                    workerData: workerConfig,
-                    // tsx registers itself via --require/--import; pass through to workers
-                    execArgv: process.execArgv,
-                });
-                worker.on('message', (msg) => {
-                    if (msg.type === 'progress' && onProgress) {
-                        progressPerWorker[i] = msg.progress.completed;
-                        const totalCompleted = progressPerWorker.reduce((a, b) => a + b, 0);
-                        onProgress(totalCompleted, totalIterations);
-                    }
-                    else if (msg.type === 'result') {
-                        resolve(msg.result);
-                    }
-                    else if (msg.type === 'error') {
-                        reject(new Error(`Worker ${i} failed: ${msg.error}`));
-                    }
-                });
-                worker.on('error', (err) => reject(new Error(`Worker ${i} error: ${err.message}`)));
-                worker.on('exit', (code) => {
-                    if (code !== 0)
-                        reject(new Error(`Worker ${i} exited with code ${code}`));
-                });
-            });
-        });
-        const results = await Promise.all(promises);
-        return aggregateResults(results);
-    }
-}
-function aggregateResults(results) {
-    const raw = {
-        totalWagered: 0,
-        totalWon: 0,
-        baseGameWin: 0,
-        bonusWin: 0,
-        hits: 0,
-    };
-    let iterations = 0;
-    let maxWin = 0;
-    let maxWinHits = 0;
-    let bonusTriggered = 0;
-    let bonusSpinsPlayed = 0;
-    let maxDurationMs = 0;
-    for (const r of results) {
-        const rr = r._raw;
-        raw.totalWagered += rr.totalWagered;
-        raw.totalWon += rr.totalWon;
-        raw.baseGameWin += rr.baseGameWin;
-        raw.bonusWin += rr.bonusWin;
-        raw.hits += rr.hits;
-        iterations += r.iterations;
-        if (r.maxWin > maxWin)
-            maxWin = r.maxWin;
-        maxWinHits += r.maxWinHits;
-        bonusTriggered += r.bonusTriggered;
-        bonusSpinsPlayed += r.bonusSpinsPlayed;
-        if (r.durationMs > maxDurationMs)
-            maxDurationMs = r.durationMs;
-    }
-    return {
-        gameId: results[0].gameId,
-        action: results[0].action,
-        iterations,
-        durationMs: maxDurationMs,
-        totalRtp: raw.totalWagered > 0 ? (raw.totalWon / raw.totalWagered) * 100 : 0,
-        baseGameRtp: raw.totalWagered > 0 ? (raw.baseGameWin / raw.totalWagered) * 100 : 0,
-        bonusRtp: raw.totalWagered > 0 ? (raw.bonusWin / raw.totalWagered) * 100 : 0,
-        hitFrequency: iterations > 0 ? (raw.hits / iterations) * 100 : 0,
-        maxWin,
-        maxWinHits,
-        bonusTriggered,
-        bonusSpinsPlayed,
-        _raw: raw,
-    };
-}
-
-// ─── Runner ─────────────────────────────────────────────
-class NativeSimulationRunner {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async run() {
-        const { binaryPath, script, gameDefinition, iterations, bet, action, params } = this.config;
-        const id = crypto.randomBytes(8).toString('hex');
-        const tmpDir = os.tmpdir();
-        const luaPath = path.join(tmpDir, `sim-${id}.lua`);
-        const configPath = path.join(tmpDir, `sim-${id}.json`);
-        try {
-            // Write temp files
-            await Promise.all([
-                promises.writeFile(luaPath, script, 'utf-8'),
-                promises.writeFile(configPath, JSON.stringify({ ...gameDefinition, script_path: luaPath }), 'utf-8'),
-            ]);
-            // Build CLI args
-            const args = [
-                '-config', configPath,
-                '-iterations', String(iterations),
-                '-bet', String(bet),
-                '-format', 'json',
-            ];
-            if (action) {
-                args.push('-action', action);
-            }
-            if (params && Object.keys(params).length > 0) {
-                args.push('-params', JSON.stringify(params));
-            }
-            // Execute binary
-            const output = await this.exec(binaryPath, args);
-            // Parse JSON output
-            const json = JSON.parse(output);
-            return mapGoResult(json);
-        }
-        finally {
-            // Cleanup temp files
-            await Promise.allSettled([promises.unlink(luaPath), promises.unlink(configPath)]);
-        }
-    }
-    exec(binary, args) {
-        return new Promise((resolve, reject) => {
-            const child = child_process.spawn(binary, args, { stdio: ['ignore', 'pipe', 'pipe'] });
-            let stdout = '';
-            let stderr = '';
-            child.stdout.on('data', (chunk) => {
-                stdout += chunk.toString();
-            });
-            child.stderr.on('data', (chunk) => {
-                stderr += chunk.toString();
-            });
-            child.on('error', (err) => {
-                reject(new Error(`Failed to execute simulation binary: ${err.message}`));
-            });
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(`Simulation binary exited with code ${code}: ${stderr.trim()}`));
-                }
-                else {
-                    resolve(stdout);
-                }
-            });
-        });
-    }
-}
-// ─── Result mapping ─────────────────────────────────────
-function mapGoResult(json) {
-    const baseStage = json.per_stage_stats?.base_game;
-    const baseGameRtp = baseStage?.rtp ?? 0;
-    const baseGameWin = baseStage?.total_win ?? 0;
-    const perStage = json.per_stage_stats
-        ? Object.fromEntries(Object.entries(json.per_stage_stats).map(([key, s]) => [
-            key,
-            {
-                totalWin: s.total_win,
-                spinCount: s.spin_count,
-                hitCount: s.hit_count,
-                maxWin: s.max_win,
-                rtp: s.rtp,
-                perSpinRtp: s.per_spin_rtp,
-                hitFrequency: s.hit_frequency,
-                avgWin: s.avg_win,
-            },
-        ]))
-        : undefined;
-    return {
-        gameId: json.game_id,
-        action: 'spin',
-        iterations: json.iterations,
-        durationMs: Math.round(json.duration_sec * 1000),
-        totalRtp: json.total_rtp,
-        baseGameRtp,
-        bonusRtp: json.total_rtp - baseGameRtp,
-        hitFrequency: json.hit_frequency,
-        maxWin: json.max_win,
-        maxWinHits: json.max_win_hits,
-        bonusTriggered: json.bonus_triggered,
-        bonusSpinsPlayed: json.bonus_spins_total,
-        speed: json.speed,
-        workersUsed: json.workers_used,
-        perStage,
-        winDistribution: json.win_distribution,
-        _raw: {
-            totalWagered: json.total_bet,
-            totalWon: json.total_win,
-            baseGameWin,
-            bonusWin: json.total_win - baseGameWin,
-            hits: json.iterations > 0 ? Math.round((json.hit_frequency * json.iterations) / 100) : 0,
-        },
-    };
-}
-// ─── Binary discovery ───────────────────────────────────
-/**
- * Search for a native simulation binary in standard locations.
- * Returns the absolute path if found, null otherwise.
- */
-function findNativeBinary(baseDir) {
-    // 1. Explicit env var
-    const envPath = process.env.SIMULATE_BINARY;
-    if (envPath && isExecutable(envPath)) {
-        return envPath;
-    }
-    const platform = process.platform; // darwin, linux, win32
-    const nodeArch = process.arch; // arm64, x64
-    const goArch = nodeArch === 'x64' ? 'amd64' : nodeArch;
-    const goPlatform = platform === 'win32' ? 'windows' : platform;
-    const ext = platform === 'win32' ? '.exe' : '';
-    const names = [
-        `simulate-${goPlatform}-${goArch}${ext}`,
-        `simulation-${goPlatform}-${goArch}${ext}`,
-        `simulate${ext}`,
-        `simulation${ext}`,
-    ];
-    // Search directories: user's project first, then this package's bin/
-    const searchDirs = [];
-    if (baseDir)
-        searchDirs.push(baseDir);
-    // This package's root (where postinstall downloads the binary)
-    try {
-        const pkgRoot = path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('lua.cjs.js', document.baseURI).href)))), '..');
-        if (!searchDirs.includes(pkgRoot))
-            searchDirs.push(pkgRoot);
-    }
-    catch {
-        // fallback for CJS
-        if (typeof __dirname !== 'undefined') {
-            const pkgRoot = path.join(__dirname, '..');
-            if (!searchDirs.includes(pkgRoot))
-                searchDirs.push(pkgRoot);
-        }
-    }
-    for (const dir of searchDirs) {
-        for (const name of names) {
-            const candidate = path.join(dir, 'bin', name);
-            if (isExecutable(candidate))
-                return candidate;
-        }
-    }
-    // Check $PATH
-    for (const bin of ['simulate', 'simulation']) {
-        try {
-            const cmd = platform === 'win32' ? `where ${bin}` : `which ${bin}`;
-            const result = child_process.execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-            if (result)
-                return result.split('\n')[0];
-        }
-        catch {
-            // not found
-        }
-    }
-    return null;
-}
-function isExecutable(path) {
-    try {
-        fs.accessSync(path, fs.constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// ─── Extended formatting ────────────────────────────────
-/** Format a NativeSimulationResult with per-stage and distribution data */
-function formatNativeResult(result) {
-    const lines = [
-        '',
-        '--- Simulation Results ---',
-        `Game: ${result.gameId}`,
-        `Iterations: ${result.iterations.toLocaleString()}`,
-        `Duration: ${(result.durationMs / 1000).toFixed(1)}s`,
-    ];
-    if (result.speed) {
-        lines.push(`Speed: ${Math.round(result.speed).toLocaleString()} iterations/sec`);
-    }
-    if (result.workersUsed) {
-        lines.push(`Workers: ${result.workersUsed}`);
-    }
-    lines.push('', '--- Total ---', `Total RTP: ${result.totalRtp.toFixed(2)}%`, `Base Game RTP: ${result.baseGameRtp.toFixed(2)}%`, `Bonus RTP: ${result.bonusRtp.toFixed(2)}%`, `Hit Frequency: ${result.hitFrequency.toFixed(2)}%`, `Max Win: ${result.maxWin.toFixed(2)}x`, `Max Win Cap Hits: ${result.maxWinHits}`);
-    if (result.bonusTriggered > 0) {
-        const frequency = Math.round(result.iterations / result.bonusTriggered);
-        lines.push('', '--- Bonus Stats ---', `Bonus Triggered: ${result.bonusTriggered.toLocaleString()} (1 in ${frequency} spins)`, `Bonus Spins Total: ${result.bonusSpinsPlayed.toLocaleString()}`);
-    }
-    // Per-stage breakdown
-    if (result.perStage && Object.keys(result.perStage).length > 0) {
-        lines.push('', '--- Per-Stage Breakdown ---');
-        const header = 'Stage                | Spins      | RTP (contrib) | Per-Spin RTP | Hit Freq  | Avg Win   | Max Win';
-        lines.push(header);
-        lines.push('-'.repeat(header.length));
-        for (const [stage, stats] of Object.entries(result.perStage)) {
-            lines.push(`${stage.padEnd(20)} | ${String(stats.spinCount).padStart(10)} | ` +
-                `${stats.rtp.toFixed(2).padStart(12)}% | ` +
-                `${stats.perSpinRtp.toFixed(2).padStart(11)}% | ` +
-                `${stats.hitFrequency.toFixed(2).padStart(8)}% | ` +
-                `${stats.avgWin.toFixed(3).padStart(8)}x | ` +
-                `${stats.maxWin.toFixed(2).padStart(8)}x`);
-        }
-    }
-    // Win distribution
-    if (result.winDistribution && result.winDistribution.length > 0) {
-        lines.push('', '--- Win Distribution ---');
-        for (const bucket of result.winDistribution) {
-            const bar = '█'.repeat(Math.round(bucket.pct / 2));
-            lines.push(`${bucket.label.padEnd(10)} ${String(bucket.count).padStart(10)} (${bucket.pct.toFixed(2).padStart(6)}%) ${bar}`);
-        }
-    }
-    return lines.join('\n');
-}
-
-exports.ActionRouter = ActionRouter;
-exports.LuaEngine = LuaEngine;
-exports.LuaEngineAPI = LuaEngineAPI;
-exports.NativeSimulationRunner = NativeSimulationRunner;
-exports.ParallelSimulationRunner = ParallelSimulationRunner;
-exports.PersistentState = PersistentState;
-exports.SessionManager = SessionManager;
-exports.SimulationRunner = SimulationRunner;
-exports.createSeededRng = createSeededRng;
-exports.evaluateCondition = evaluateCondition;
-exports.findNativeBinary = findNativeBinary;
-exports.formatNativeResult = formatNativeResult;
-exports.formatSimulationResult = formatSimulationResult;
+Object.keys(lua).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return lua[k]; }
+	});
+});
 //# sourceMappingURL=lua.cjs.js.map