@energy8platform/platform-core 0.28.3 → 0.30.0

package/src/dev-bridge/DevBridge.ts

@@ -81,11 +81,16 @@ function parseSessionTtl(ttl: string | undefined): number {
   if (!m) return DEFAULT_SESSION_TTL_MS;
   const n = parseFloat(m[1]);
   switch (m[2]) {
-    case 'ms': return n;
-    case 's':  return n * 1000;
-    case 'm':  return n * 60 * 1000;
-    case 'h':  return n * 60 * 60 * 1000;
-    default:   return DEFAULT_SESSION_TTL_MS;
+    case 'ms':
+      return n;
+    case 's':
+      return n * 1000;
+    case 'm':
+      return n * 60 * 1000;
+    case 'h':
+      return n * 60 * 60 * 1000;
+    default:
+      return DEFAULT_SESSION_TTL_MS;
   }
 }
 
@@ -124,7 +129,8 @@ export interface DevBridgeConfig {
   currency?: string;
   /** Game config */
   gameConfig?: Partial<GameConfigData>;
-  /** Base URL for assets (default: '/assets/') */
+  /** Base URL for assets (default: '/' — the site root; the folder lives in the asset paths, not
+   *  the base, so a game isn't forced to name its folder `assets`). */
   assetsUrl?: string;
   /** Active session to resume (null = no active session) */
   session?: SessionData | null;
@@ -148,7 +154,10 @@ export interface DevBridgeConfig {
   replay?: ReplayConfig;
 }
 
-const DEFAULT_CONFIG: Omit<Required<DevBridgeConfig>, 'luaScript' | 'gameDefinition' | 'luaSeed' | 'replay'> = {
+const DEFAULT_CONFIG: Omit<
+  Required<DevBridgeConfig>,
+  'luaScript' | 'gameDefinition' | 'luaSeed' | 'replay'
+> = {
   balance: 10000,
   currency: 'USD',
   gameConfig: {
@@ -158,7 +167,7 @@ const DEFAULT_CONFIG: Omit<Required<DevBridgeConfig>, 'luaScript' | 'gameDefinit
     viewport: { width: 1920, height: 1080 },
     betLevels: [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50],
   },
-  assetsUrl: '/assets/',
+  assetsUrl: '/',
   session: null,
   onPlay: () => ({}),
   networkDelay: 200,
@@ -173,7 +182,7 @@ const DEFAULT_CONFIG: Omit<Required<DevBridgeConfig>, 'luaScript' | 'gameDefinit
  * the need for postMessage and iframes.
  *
  * When `luaScript` is set, play requests are sent to the Vite dev server
- * which runs LuaEngine in Node.js — no fengari in the browser.
+ * which runs LuaEngine in Node.js — no math in the browser.
  *
  * @example
  * ```ts
@@ -192,7 +201,20 @@ const DEFAULT_CONFIG: Omit<Required<DevBridgeConfig>, 'luaScript' | 'gameDefinit
  * ```
  */
 export class DevBridge {
-  private _config: Required<Pick<DevBridgeConfig, 'balance' | 'currency' | 'gameConfig' | 'assetsUrl' | 'session' | 'onPlay' | 'networkDelay' | 'debug'>> & Pick<DevBridgeConfig, 'luaScript' | 'gameDefinition' | 'luaSeed' | 'replay'>;
+  private _config: Required<
+    Pick<
+      DevBridgeConfig,
+      | 'balance'
+      | 'currency'
+      | 'gameConfig'
+      | 'assetsUrl'
+      | 'session'
+      | 'onPlay'
+      | 'networkDelay'
+      | 'debug'
+    >
+  > &
+    Pick<DevBridgeConfig, 'luaScript' | 'gameDefinition' | 'luaSeed' | 'replay'>;
   private _balance: number;
   private _roundCounter = 0;
   private _bridge: Bridge | null = null;
@@ -346,9 +368,7 @@ export class DevBridge {
   private resolveReplayResults(): Promise<PlayResultData[]> {
     if (!this._replayResults) {
       const { mode, roundId } = this._replayLaunch ?? {};
-      this._replayResults = Promise.resolve(
-        this._config.replay!.resolve(mode, roundId),
-      );
+      this._replayResults = Promise.resolve(this._config.replay!.resolve(mode, roundId));
     }
     return this._replayResults;
   }
@@ -382,10 +402,7 @@ export class DevBridge {
       });
   }
 
-  private handlePlayRequest(
-    payload: PlayParams,
-    id?: string,
-  ): void {
+  private handlePlayRequest(payload: PlayParams, id?: string): void {
     if (this._replayLaunch) {
       this.handleReplayPlay(id);
       return;
@@ -462,11 +479,9 @@ export class DevBridge {
       // Round id rules mirror server's playRound:
       //   non-session  → fresh UUID, client-supplied id is ignored
       //   session-based → reuse the active session's round id
-      const serverRoundId = actionDef.requires_session
-        ? this._activeRoundId!
-        : generateRoundId();
+      const serverRoundId = actionDef.requires_session ? this._activeRoundId! : generateRoundId();
 
-      this.executeLuaOnServer({ action, bet, roundId: serverRoundId, params })
+      this.executeOnServer({ action, bet, roundId: serverRoundId, params })
         .then((result) => {
           this._lastPlayResult = result;
           this.updateSessionState(result);
@@ -481,7 +496,8 @@ export class DevBridge {
       // Fallback to onPlay callback
       const { roundId } = payload;
       const customResult = this._config.onPlay({ action, bet, roundId, params });
-      const totalWin = customResult.totalWin ?? (Math.random() > 0.6 ? bet * (1 + Math.random() * 10) : 0);
+      const totalWin =
+        customResult.totalWin ?? (Math.random() > 0.6 ? bet * (1 + Math.random() * 10) : 0);
 
       this._balance += totalWin;
 
@@ -561,7 +577,7 @@ export class DevBridge {
     return bet;
   }
 
-  private async executeLuaOnServer(params: PlayParams): Promise<PlayResultData> {
+  private async executeOnServer(params: PlayParams): Promise<PlayResultData> {
     const response = await fetch('/__lua-play', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },

package/src/game-spec/defineGame.ts

@@ -1,13 +1,13 @@
 import type { GameSpec, GameModel } from './types';
 import { validateSpec } from './validate';
-import { toGameDefinition, toLuaPrelude, toModeMap, toMathModes, toPaytableView } from './derive';
+import { toGameDefinition, toSpinPrelude, toModeMap, toMathModes, toPaytableView } from './derive';
 
 export function defineGame(spec: GameSpec): GameModel {
   validateSpec(spec);
   return {
     spec,
     gameDefinition: toGameDefinition(spec),
-    luaPrelude: toLuaPrelude(spec),
+    spinPrelude: toSpinPrelude(spec),
     modeMap: toModeMap(spec),
     mathModes: toMathModes(spec),
     paytable: toPaytableView(spec),

package/src/game-spec/derive.ts

@@ -76,30 +76,53 @@ export function toGameDefinition(spec: GameSpec): GameDefinition {
   return def;
 }
 
-function luaTable(record: Record<number, number>): string {
-  const parts = Object.entries(record).map(([k, v]) => `[${k}]=${v}`);
-  return `{${parts.join(', ')}}`;
+/** Число с гарантированной float-формой для SpinML (10 → "10.0"). */
+function spinF(n: number): string {
+  return Number.isInteger(n) ? `${n}.0` : String(n);
 }
 
-export function toLuaPrelude(spec: GameSpec): string {
+/**
+ * The generated .spin prelude: SPEC/SYM as const groups,
+ * SYMBOLS as a str array, the paytable as indexable threshold/payout arrays
+ * (PAY_COUNTS + PAY_<ID>, 0.0 = no pay at that threshold), VALUES as
+ * VAL_<ID>. Prepended to the author's script.spin by buildSpinScript.
+ */
+export function toSpinPrelude(spec: GameSpec): string {
   const lines: string[] = ['-- AUTO-GENERATED from game.spec.ts — do not edit'];
-  lines.push(`SPEC = { cols = ${spec.grid.cols}, rows = ${spec.grid.rows}, max_win = ${spec.maxWin} }`);
+  lines.push(
+    `const SPEC = { cols: ${spec.grid.cols}, rows: ${spec.grid.rows}, cells: ${spec.grid.cols * spec.grid.rows}, max_win: ${spinF(spec.maxWin)} }`,
+  );
 
   const symNames = spec.symbols.map((s) => `"${s.id}"`).join(', ');
-  lines.push(`SYMBOLS = { ${symNames} }`);
+  lines.push(`const SYMBOLS: [str; ${spec.symbols.length}] = [${symNames}]`);
+  lines.push(`const N_SYMBOLS: int = ${spec.symbols.length}`);
 
-  const symIndex = spec.symbols.map((s, i) => `${s.id}=${i + 1}`).join(', ');
-  lines.push(`SYM = { ${symIndex} }`);
+  const symIndex = spec.symbols.map((s, i) => `${s.id}: ${i + 1}`).join(', ');
+  lines.push(`-- 1-based индексы символов (порядок SYMBOLS)`);
+  lines.push(`const SYM = { ${symIndex} }`);
 
-  const payEntries = spec.symbols
-    .filter((s) => s.pay)
-    .map((s) => `  ${s.id} = ${luaTable(s.pay as Record<number, number>)}`);
-  lines.push(`PAYTABLE = {\n${payEntries.join(',\n')}\n}`);
+  const paying = spec.symbols.filter((s) => s.pay);
+  if (paying.length) {
+    const counts = Array.from(
+      new Set(paying.flatMap((s) => Object.keys(s.pay as Record<number, number>).map(Number))),
+    ).sort((a, b) => a - b);
+    lines.push(`-- пейтейбл: пороги count + выплата на порог (0.0 = нет выплаты)`);
+    lines.push(`const PAY_COUNTS: [int; ${counts.length}] = [${counts.join(', ')}]`);
+    for (const s of paying) {
+      const pay = s.pay as Record<number, number>;
+      const row = counts.map((c) => spinF(pay[c] ?? 0));
+      lines.push(`const PAY_${s.id}: [float; ${counts.length}] = [${row.join(', ')}]`);
+    }
+  }
 
-  const valEntries = spec.symbols
-    .filter((s) => s.value !== undefined)
-    .map((s) => `  ${s.id} = ${Array.isArray(s.value) ? `{${s.value.join(', ')}}` : s.value}`);
-  if (valEntries.length) lines.push(`VALUES = {\n${valEntries.join(',\n')}\n}`);
+  for (const s of spec.symbols) {
+    if (s.value === undefined) continue;
+    if (Array.isArray(s.value)) {
+      lines.push(`const VAL_${s.id}: [int; ${s.value.length}] = [${s.value.join(', ')}]`);
+    } else {
+      lines.push(`const VAL_${s.id}: int = ${s.value}`);
+    }
+  }
 
   return lines.join('\n') + '\n';
 }

package/src/game-spec/export.ts

@@ -1,53 +1,37 @@
 import type { GameSpec, GameModel } from './types';
 import { defineGame } from './defineGame';
 
-/** Compose the self-contained Lua the platform runs: generated prelude ⧺ author logic. */
-export function buildLuaScript(model: GameModel, logicLua: string): string {
-  return model.luaPrelude + '\n' + logicLua;
+/** Compose the self-contained .spin: generated const prelude ⧺ author math. */
+export function buildSpinScript(model: GameModel, logicSpin: string): string {
+  return model.spinPrelude + '\n' + logicSpin;
 }
 
-/** The two E8-platform deliverables, keyed by their on-disk filenames. */
-export interface E8Bundle {
-  /** GameDefinition JSON — uploaded to S3 as `games/{id}/config.json`. */
+/** The spin-runtime platform deliverables, keyed by on-disk filenames. */
+export interface E8SpinBundle {
+  /** GameDefinition JSON (engine_mode=spin) — S3: games/{id}/config.json. */
   'config.json': string;
-  /** Self-contained Lua (prelude ⧺ logic) — uploaded to S3 as `games/{id}/script.lua`. */
-  'script.lua': string;
+  /** Self-contained SpinML (prelude ⧺ math) — S3: games/{id}/script.spin. */
+  'script.spin': string;
 }
 
 /**
- * Produce the E8 platform deliverables from one spec + the author's `script.logic.lua`.
- * The config carries `script_path` so the platform can locate the uploaded script; the script is
- * the prelude-prepended, self-contained source. Structurally validated before returning.
+ * Produce the spin-runtime deliverables from one spec + the author's
+ * `script.spin`. The platform routes engine_mode="spin" games to the e8
+ * engine; script_path points at the uploaded .spin.
  */
-export function exportGame(spec: GameSpec, opts: { logicLua: string }): E8Bundle {
+export function exportGameSpin(spec: GameSpec, opts: { logicSpin: string }): E8SpinBundle {
   const model = defineGame(spec);
-  const bundle: E8Bundle = {
-    'config.json': JSON.stringify(model.gameDefinition, null, 2),
-    'script.lua': buildLuaScript(model, opts.logicLua),
+  const config = {
+    ...(model.gameDefinition as unknown as Record<string, unknown>),
+    engine_mode: 'spin',
+    script_path: 'script.spin',
   };
-  validateE8Bundle(bundle);
-  return bundle;
-}
-
-/**
- * Structural (fengari-free) checks that catch the obvious ways an export is unusable before it
- * reaches the platform: malformed config, missing `script_path`/`actions`, or a script with no
- * `execute` entry point. A full boot check (running the script in a LuaEngine) is the caller's job.
- */
-export function validateE8Bundle(bundle: E8Bundle): void {
-  let config: Record<string, unknown>;
-  try {
-    config = JSON.parse(bundle['config.json']);
-  } catch (e) {
-    throw new Error(`E8 export: config.json is not valid JSON — ${(e as Error).message}`);
-  }
-  if (!config.id || typeof config.id !== 'string') throw new Error('E8 export: config.json missing "id"');
-  if (config.type !== 'SLOT' && config.type !== 'TABLE') throw new Error('E8 export: config.json "type" must be SLOT or TABLE');
-  if (!config.script_path) throw new Error('E8 export: config.json missing "script_path"');
-  if (!config.actions || typeof config.actions !== 'object' || Object.keys(config.actions as object).length === 0) {
-    throw new Error('E8 export: config.json has no actions');
-  }
-  if (!/function\s+execute\s*\(/.test(bundle['script.lua'])) {
-    throw new Error('E8 export: script.lua does not define a global `execute(state)` function');
+  const script = buildSpinScript(model, opts.logicSpin);
+  if (!/fn\s+execute\s*\(/.test(script)) {
+    throw new Error('E8 spin export: script.spin does not define `fn execute(...)`');
   }
+  return {
+    'config.json': JSON.stringify(config, null, 2),
+    'script.spin': script,
+  };
 }

package/src/game-spec/index.ts

@@ -1,7 +1,7 @@
 export * from './types';
 export { validateSpec, GameSpecError } from './validate';
-export { toGameDefinition, toLuaPrelude, toModeMap, toMathModes, toPaytableView } from './derive';
+export { toGameDefinition, toSpinPrelude, toModeMap, toMathModes, toPaytableView } from './derive';
 export { defineGame } from './defineGame';
-export { buildLuaScript, exportGame, validateE8Bundle } from './export';
-export type { E8Bundle } from './export';
+export { buildSpinScript, exportGameSpin } from './export';
+export type { E8SpinBundle } from './export';
 export type { GameDefinition, ActionDefinition, TransitionRule, MaxWinConfig } from '../lua/types';

package/src/game-spec/types.ts

@@ -85,7 +85,8 @@ export interface PaytableView {
 export interface GameModel {
   spec: GameSpec;
   gameDefinition: GameDefinition;
-  luaPrelude: string;
+  /** Generated .spin prelude (SPEC/SYM/PAYTABLE consts) for the spin runtime. */
+  spinPrelude: string;
   modeMap: Record<string, string>;
   mathModes: MathModeSpec[];
   paytable: PaytableView;

package/src/index.ts

@@ -5,7 +5,7 @@
  * engine.
  *
  * Sub-paths for fine-grained imports:
- *   - `@energy8platform/platform-core/lua`        — Lua engine + simulation
+ *   - `@energy8platform/platform-core/lua`        — shared game-definition types
  *   - `@energy8platform/platform-core/dev-bridge` — DevBridge mock host
  *   - `@energy8platform/platform-core/vite`       — Vite plugins
  */
@@ -21,17 +21,11 @@ export type {
   SDKOptions,
 } from './PlatformSession';
 
-// ─── Lua ────────────────────────────────────────────────
-// LuaEngine and friends are available only via the /lua sub-path. We
-// don't re-export them as runtime values from the main entry because
-// `fengari` (the underlying Lua VM) is a CommonJS module — pulling it
-// in unconditionally breaks Vite dev-mode ESM resolution for any
-// consumer that doesn't actually use Lua in the browser. Use:
-//
-//   import { LuaEngine } from '@energy8platform/platform-core/lua';
-//
-// For Node-only RTP simulation (Go binary, worker_threads), import from
-// '@energy8platform/platform-core/simulation' instead.
+// ─── Math runtime ───────────────────────────────────────
+// The math runtime is SpinML (the Rust e8 engine): dev rounds via the
+// `spinPlugin` vite plugin + e8-server, simulation via `e8 simulate`
+// (see '@energy8platform/platform-core/simulation'). The fengari Lua
+// engine was removed — legacy Lua games stay on <= 0.28.x.
 
 // ─── DevBridge ──────────────────────────────────────────
 export { DevBridge } from './dev-bridge';

package/src/lua/index.ts

@@ -1,14 +1,7 @@
-// Browser-safe Lua engine surface. Only depends on `fengari`, no Node built-ins.
-//
-// For the Node-only runners (NativeSimulationRunner backed by a Go binary,
-// ParallelSimulationRunner backed by worker_threads), import from
-// `@energy8platform/platform-core/simulation` instead.
-export { LuaEngine } from './LuaEngine';
-export { LuaEngineAPI, createSeededRng } from './LuaEngineAPI';
-export { ActionRouter, evaluateCondition } from './ActionRouter';
-export { SessionManager } from './SessionManager';
-export { PersistentState } from './PersistentState';
-export { SimulationRunner, formatSimulationResult } from './SimulationRunner';
+// Shared game-definition types. The fengari Lua engine that used to live
+// here is GONE — the math runtime is SpinML (e8): dev rounds via spinPlugin
+// + e8-server, simulation via `e8 simulate` (stake-math-tools). Legacy Lua
+// games stay on platform-core <= 0.28.x.
 export type {
   GameDefinition,
   ActionDefinition,

package/src/simulation/NativeSimulationRunner.ts

@@ -28,6 +28,17 @@ export interface NativeSimulationConfig {
   binaryPath: string;
   /** Lua script source code */
   script: string;
+  /**
+   * Extension of the temp script file (default 'lua'). The e8 SpinML engine
+   * takes 'spin' — the runner is otherwise runtime-agnostic: it writes the
+   * script, points config.script_path at it and spawns the binary.
+   */
+  scriptExt?: 'lua' | 'spin';
+  /**
+   * Args prepended before the flag args (default none). The e8 binary is a
+   * multi-command CLI — its Go-compatible mode is the `simulate` subcommand.
+   */
+  argsPrefix?: string[];
   /** Platform game definition */
   gameDefinition: GameDefinition;
   /** Number of iterations */
@@ -100,6 +111,14 @@ export interface NativeSimulationResult extends SimulationResult {
   workerSeeds?: string[];
   /** Echo of replay params when the run was in replay mode. */
   replay?: NativeReplayParams;
+  /** Round-win standard deviation (currency units). */
+  stddev?: number;
+  /** Coefficient of variation (stddev / mean round win). */
+  cv?: number;
+  /** Volatility score 0..10 (casino_platform classifyVolatility buckets). */
+  volatility?: number;
+  /** Volatility tier label (Low … Extreme). */
+  volatilityLabel?: string;
 }
 
 // ─── Go JSON output shape (snake_case) ──────────────────
@@ -136,6 +155,10 @@ interface GoSimulationOutput {
   rng_kind?: NativeRNGKind;
   master_seed?: string;
   worker_seeds?: string[];
+  stddev?: number;
+  cv?: number;
+  volatility?: number;
+  volatility_label?: string;
   replay?: {
     server_seed: string;
     client_seed: string;
@@ -190,7 +213,7 @@ export class NativeSimulationRunner {
   }
 
   async run(): Promise<NativeSimulationResult> {
-    const { binaryPath, script, gameDefinition, iterations, bet, action, params, seed, rng, replay, dump } = this.config;
+    const { binaryPath, script, scriptExt, argsPrefix, gameDefinition, iterations, bet, action, params, seed, rng, replay, dump } = this.config;
 
     if (replay && rng && rng !== 'provably-fair') {
       throw new Error(`Replay mode requires rng="provably-fair" (got rng="${rng}")`);
@@ -198,28 +221,28 @@ export class NativeSimulationRunner {
 
     const id = randomBytes(8).toString('hex');
     const tmpDir = tmpdir();
-    const luaPath = join(tmpDir, `sim-${id}.lua`);
+    const scriptPath = join(tmpDir, `sim-${id}.${scriptExt ?? 'lua'}`);
     const configPath = join(tmpDir, `sim-${id}.json`);
 
     try {
       // Write temp files
       await Promise.all([
-        writeFile(luaPath, script, 'utf-8'),
-        writeFile(configPath, JSON.stringify({ ...gameDefinition, script_path: luaPath }), 'utf-8'),
+        writeFile(scriptPath, script, 'utf-8'),
+        writeFile(configPath, JSON.stringify({ ...gameDefinition, script_path: scriptPath }), 'utf-8'),
       ]);
 
       // Build CLI args
       const args = buildNativeArgs({ configPath, iterations, bet, action, params, rng, seed, dump, replay });
 
       // Execute binary
-      const output = await this.exec(binaryPath, args);
+      const output = await this.exec(binaryPath, [...(argsPrefix ?? []), ...args]);
 
       // Parse JSON output
       const json: GoSimulationOutput = JSON.parse(output);
       return mapGoResult(json);
     } finally {
       // Cleanup temp files
-      await Promise.allSettled([unlink(luaPath), unlink(configPath)]);
+      await Promise.allSettled([unlink(scriptPath), unlink(configPath)]);
     }
   }
 
@@ -298,6 +321,10 @@ function mapGoResult(json: GoSimulationOutput): NativeSimulationResult {
     rngKind: json.rng_kind,
     masterSeed: json.master_seed,
     workerSeeds: json.worker_seeds,
+    stddev: json.stddev,
+    cv: json.cv,
+    volatility: json.volatility,
+    volatilityLabel: json.volatility_label,
     replay: json.replay
       ? {
           serverSeed: json.replay.server_seed,
@@ -318,42 +345,40 @@ function mapGoResult(json: GoSimulationOutput): NativeSimulationResult {
 // ─── Binary discovery ───────────────────────────────────
 
 /**
- * Search for a native simulation binary in standard locations.
- * Returns the absolute path if found, null otherwise.
+ * Search for the e8 SpinML engine binary (Rust) — same lookup discipline as
+ * findNativeBinary: env override → <pkg>/bin/e8-<platform>-<arch> → $PATH.
+ * Fetched by scripts/install-e8.mjs on postinstall.
  */
-export function findNativeBinary(baseDir?: string): string | null {
-  // 1. Explicit env var
-  const envPath = process.env.SIMULATE_BINARY;
+export function findE8Binary(baseDir?: string): string | null {
+  const envPath = process.env.E8_BINARY;
   if (envPath && isExecutable(envPath)) {
     return envPath;
   }
 
-  const platform = process.platform; // darwin, linux, win32
-  const nodeArch = process.arch; // arm64, x64
+  const platform = process.platform;
+  const nodeArch = process.arch;
   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}`,
-  ];
+  const names = [`e8-${goPlatform}-${goArch}${ext}`, `e8${ext}`];
 
-  // Search directories: user's project first, then this package's bin/
   const searchDirs: string[] = [];
   if (baseDir) searchDirs.push(baseDir);
-
-  // This package's root (where postinstall downloads the binary)
+  // Раскладки различаются: dist/simulation.esm.js → ../bin,
+  // src/simulation/*.ts (vitest/tsx) → ../../bin. Пробуем оба уровня.
   try {
-    const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
-    if (!searchDirs.includes(pkgRoot)) searchDirs.push(pkgRoot);
+    const here = dirname(fileURLToPath(import.meta.url));
+    for (const up of ['..', '../..']) {
+      const root = join(here, up);
+      if (!searchDirs.includes(root)) searchDirs.push(root);
+    }
   } catch {
-    // fallback for CJS
     if (typeof __dirname !== 'undefined') {
-      const pkgRoot = join(__dirname, '..');
-      if (!searchDirs.includes(pkgRoot)) searchDirs.push(pkgRoot);
+      for (const up of ['..', '../..']) {
+        const root = join(__dirname, up);
+        if (!searchDirs.includes(root)) searchDirs.push(root);
+      }
     }
   }
 
@@ -364,32 +389,24 @@ export function findNativeBinary(baseDir?: string): string | null {
     }
   }
 
-  // Check $PATH
-  for (const bin of ['simulate', 'simulation']) {
-    try {
-      const cmd = platform === 'win32' ? `where ${bin}` : `which ${bin}`;
-      const result = execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-      if (result) return result.split('\n')[0];
-    } catch {
-      // not found
-    }
+  try {
+    const cmd = platform === 'win32' ? 'where e8' : 'which e8';
+    const result = execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    if (result) return result.split('\n')[0];
+  } catch {
+    // not found
   }
 
   return null;
 }
 
-/**
- * Return the native binary path or throw a clear, install-guiding error.
- * The math pipeline is go-native only — NO JS fallback.
- *
- * @param finder - injectable finder for testability; defaults to findNativeBinary.
- */
-export function requireNativeBinary(finder: () => string | null = findNativeBinary): string {
+/** Return the e8 binary path or throw an install-guiding error. */
+export function requireE8Binary(finder: () => string | null = findE8Binary): string {
   const bin = finder();
   if (!bin) {
     throw new Error(
-      'native simulation binary not found — run `npm install` (platform-core fetches it via install-simulate). ' +
-      'The math pipeline is go-native only (no JS fallback).',
+      'e8 engine binary not found — run `npm install` (platform-core fetches it via install-e8), ' +
+      'or point E8_BINARY at a local build (casino-platform/e8/target/release/e8).',
     );
   }
   return bin;
@@ -445,6 +462,15 @@ export function formatNativeResult(result: NativeSimulationResult): string {
     `Max Win Cap Hits: ${result.maxWinHits}`,
   );
 
+  if (result.volatilityLabel !== undefined && result.cv !== undefined) {
+    lines.push(
+      '',
+      '--- Volatility ---',
+      `Volatility: ${result.volatility}/10 (${result.volatilityLabel})`,
+      `StdDev: ${(result.stddev ?? 0).toFixed(2)}   CV: ${result.cv.toFixed(2)}`,
+    );
+  }
+
   if (result.bonusTriggered > 0) {
     const frequency = Math.round(result.iterations / result.bonusTriggered);
     lines.push(

package/src/simulation/index.ts

@@ -8,10 +8,10 @@
 
 export {
   NativeSimulationRunner,
-  findNativeBinary,
   formatNativeResult,
   buildNativeArgs,
-  requireNativeBinary,
+  findE8Binary,
+  requireE8Binary,
 } from './NativeSimulationRunner';
 export type {
   NativeSimulationConfig,
@@ -22,5 +22,3 @@ export type {
   DistributionBucket,
   NativeArgsInput,
 } from './NativeSimulationRunner';
-
-export { ParallelSimulationRunner } from './ParallelSimulationRunner';