@energy8platform/platform-core 0.28.2 → 0.29.0

package/src/dev-bridge/DevBridge.ts

@@ -173,7 +173,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
@@ -466,7 +466,7 @@ export class DevBridge {
         ? 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);
@@ -561,7 +561,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

@@ -61,39 +61,68 @@ export function toGameDefinition(spec: GameSpec): GameDefinition {
   for (const [key, action] of Object.entries(spec.actions)) {
     actions[key] = toActionDefinition(key, action, freeKey);
   }
-  return {
+  const def: GameDefinition = {
     id: spec.id,
     type: 'SLOT',
+    // Bare filename — the platform resolves it to games/{id}/script.lua. Required so the exported
+    // config.json points at the uploaded script.
+    script_path: spec.scriptPath ?? 'script.lua',
     actions,
     bet_levels: [...spec.betLevels],
     max_win: { multiplier: spec.maxWin },
   };
+  if (spec.sessionTtl) def.session_ttl = spec.sessionTtl;
+  if (spec.persistentState) def.persistent_state = { ...spec.persistentState };
+  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,17 +1,37 @@
 import type { GameSpec, GameModel } from './types';
 import { defineGame } from './defineGame';
 
-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;
 }
 
-export function exportGame(
-  spec: GameSpec,
-  opts: { logicLua: string },
-): { 'gameDefinition.json': string; 'script.lua': string } {
+/** 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 SpinML (prelude ⧺ math) — S3: games/{id}/script.spin. */
+  'script.spin': string;
+}
+
+/**
+ * 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 exportGameSpin(spec: GameSpec, opts: { logicSpin: string }): E8SpinBundle {
   const model = defineGame(spec);
+  const config = {
+    ...(model.gameDefinition as unknown as Record<string, unknown>),
+    engine_mode: 'spin',
+    script_path: 'script.spin',
+  };
+  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 {
-    'gameDefinition.json': JSON.stringify(model.gameDefinition, null, 2),
-    'script.lua': buildLuaScript(model, opts.logicLua),
+    'config.json': JSON.stringify(config, null, 2),
+    'script.spin': script,
   };
 }

package/src/game-spec/index.ts

@@ -1,6 +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 } 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

@@ -48,6 +48,15 @@ export interface GameSpec {
   actions: Record<string, ActionSpec>;
   /** Open hint for codegen/UI: 'cascade' | 'cluster' | 'ways' | 'lines' | … */
   mechanic?: string;
+  /**
+   * Lua script key for the exported E8 `config.json`. Default `"script.lua"`, which the platform
+   * resolves to `games/{id}/script.lua`. Override only when the script lives at a custom S3 key.
+   */
+  scriptPath?: string;
+  /** Session expiry for the exported config (Go-style duration, e.g. "24h"). Omitted when unset. */
+  sessionTtl?: string;
+  /** Cross-spin persistent state (charge meters etc.) surfaced into the exported config. */
+  persistentState?: { vars: string[]; exposed_vars: string[] };
   /** Game-level escape hatch. */
   meta?: Record<string, unknown>;
 }
@@ -76,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/lua/types.ts

@@ -5,6 +5,13 @@ import type { SessionData, PlayParams } from '@energy8platform/game-sdk';
 export interface GameDefinition {
   id: string;
   type: 'SLOT' | 'TABLE';
+  /**
+   * Lua script S3 object key or bare filename (e.g. "script.lua" — the platform resolves a bare
+   * name to `games/{id}/script.lua`). Mirrors the server's `GameDefinition.ScriptPath` (omitempty).
+   * The engine itself loads the script from `LuaEngineConfig.script`, so this is only carried for
+   * the exported platform `config.json`.
+   */
+  script_path?: string;
   actions: Record<string, ActionDefinition>;
   bet_levels?: number[] | BetLevelsConfig;
   max_win?: MaxWinConfig;

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';

package/src/vite/index.ts

@@ -7,8 +7,8 @@ import type { Plugin } from 'vite';
  * into the HTML during development, so the game can communicate with
  * a mock casino host without manual setup.
  *
- * Pair with `luaPlugin` to also enable `.lua` raw imports and serve a
- * Lua execution endpoint at POST /__lua-play.
+ * Pair with `spinPlugin` to serve the math endpoint at POST /__lua-play
+ * (the route name is the frozen frontend contract; the engine is e8).
  */
 const VIRTUAL_ID = '/@dev-bridge-entry.js';
 
@@ -75,122 +75,5 @@ await import('${entrySrc}');
   };
 }
 
-// ─── Lua Plugin ─────────────────────────────────────────
-
-/**
- * Vite plugin that:
- * 1. Enables importing `.lua` files as raw strings with HMR
- * 2. Runs a LuaEngine on the Vite dev server (Node.js) via POST /__lua-play
- *
- * fengari runs server-side only — no browser shims needed.
- */
-export function luaPlugin(configPath: string): Plugin {
-  let luaEngine: any = null;
-  let viteServer: any = null;
-
-  async function initEngine() {
-    if (!viteServer) return;
-
-    try {
-      // Invalidate cached modules so HMR picks up changes
-      const root = viteServer.config.root;
-      const fullConfigPath = configPath.startsWith('.')
-        ? root + '/' + configPath.replace(/^\.\//, '')
-        : configPath;
-
-      // Invalidate the config module and its dependencies
-      const configMod = viteServer.moduleGraph.getModuleById(fullConfigPath);
-      if (configMod) viteServer.moduleGraph.invalidateModule(configMod);
-
-      // ssrLoadModule handles TS transpilation and resolves all imports
-      const mod = await viteServer.ssrLoadModule(fullConfigPath);
-      const config = mod.default ?? mod.config ?? mod;
-
-      if (!config.luaScript || !config.gameDefinition) {
-        console.log('[LuaPlugin] No luaScript/gameDefinition in config — Lua server disabled');
-        luaEngine = null;
-        return;
-      }
-
-      // Load LuaEngine via SSR (fengari runs natively in Node.js)
-      const luaMod = await viteServer.ssrLoadModule('@energy8platform/platform-core/lua');
-      const { LuaEngine } = luaMod;
-
-      if (luaEngine) luaEngine.destroy();
-      luaEngine = new LuaEngine({
-        script: config.luaScript,
-        gameDefinition: config.gameDefinition,
-        seed: config.luaSeed,
-      });
-      console.log('[LuaPlugin] LuaEngine initialized (server-side)');
-    } catch (e: any) {
-      console.warn('[LuaPlugin] Failed to initialize LuaEngine:', e.message);
-      luaEngine = null;
-    }
-  }
-
-  return {
-    name: 'platform-core:lua',
-    apply: 'serve',
-
-    async configureServer(server) {
-      viteServer = server;
-      await initEngine();
-
-      // POST /__lua-play — execute Lua on the server
-      server.middlewares.use('/__lua-play', (req: any, res: any) => {
-        if (req.method !== 'POST') {
-          res.statusCode = 405;
-          res.end('Method Not Allowed');
-          return;
-        }
-
-        let body = '';
-        req.on('data', (chunk: string) => { body += chunk; });
-        req.on('end', () => {
-          try {
-            if (!luaEngine) {
-              res.statusCode = 503;
-              res.setHeader('Content-Type', 'application/json');
-              res.end(JSON.stringify({ error: 'LuaEngine not initialized' }));
-              return;
-            }
-
-            const params = JSON.parse(body);
-            const result = luaEngine.execute(params);
-
-            res.statusCode = 200;
-            res.setHeader('Content-Type', 'application/json');
-            res.end(JSON.stringify(result));
-          } catch (e: any) {
-            res.statusCode = 500;
-            res.setHeader('Content-Type', 'application/json');
-            res.end(JSON.stringify({ error: e.message }));
-          }
-        });
-      });
-    },
-
-    transform(code: string, id: string) {
-      if (id.endsWith('.lua')) {
-        return {
-          code: `export default ${JSON.stringify(code)};`,
-          map: null,
-        };
-      }
-    },
-
-    async handleHotUpdate({ file, server }: { file: string; server: any }) {
-      if (file.endsWith('.lua') || file.includes('dev.config')) {
-        console.log('[LuaPlugin] Reloading LuaEngine...');
-
-        // Invalidate all SSR modules so ssrLoadModule picks up fresh code
-        server.moduleGraph.invalidateAll();
-
-        await initEngine();
-        server.ws.send({ type: 'full-reload' });
-        return [];
-      }
-    },
-  };
-}
+export { spinPlugin } from './spinPlugin';
+export type { SpinPluginOptions } from './spinPlugin';