@stakeplate/core 0.1.0

package/dist/network-pBW8CX1o.d.ts

@@ -0,0 +1,120 @@
+import { c as JurisdictionConfig, d as ReplayParams, m as Round, r as AuthenticateResponse, s as EndRoundResponse, u as PlayResponse } from "./protocol-C1KamF3t.js";
+//#region src/rgs/runtime.d.ts
+/**
+ * Stake launch parameters (mirrors `StakeEngine/web-sdk`
+ * `packages/state-shared/src/stateUrl`): sessionID, rgs_url, lang, currency, device,
+ * social, demo — plus the REPLAY set: replay, amount, game, version, mode, event.
+ * `lang` is REQUIRED by `/wallet/authenticate` (its absence 400s the RGS).
+ */
+interface ReplayLaunch {
+  /** `?replay=true` — launch into replay (fetch + play back a recorded round). */
+  active: boolean;
+  amount: number;
+  game: string;
+  version: string;
+  mode: string;
+  event: string;
+}
+interface RuntimeConfig {
+  rgsUrl: string;
+  sessionId: string;
+  /** BCP-47-ish language for `/wallet/authenticate` + the HUD locale ('br' → 'pt'). */
+  language: string;
+  /** `?currency=` — currency code (used for replay, where there's no wallet to read it). */
+  currency: string;
+  /** `?social=true` — force Stake US social/sweepstakes wording. */
+  social: boolean;
+  /** `?device=` — Stake's viewport hint ('' | 'desktop' | 'mobile' | a small popout). */
+  device: string;
+  /** `?demo=true` — run against the built-in mock RGS, no real backend. */
+  demo: boolean;
+  replay: ReplayLaunch;
+}
+type ParamSource = (name: string) => string | undefined;
+/** Read a URL param from `window.location.search` (undefined off-DOM). */
+declare function urlParam(name: string): string | undefined;
+/**
+ * Parse the Stake launch params into a {@link RuntimeConfig}. Pass `overrides` (or a
+ * custom `param` reader) for tests/embedding; otherwise reads the page URL. `rgsUrl`
+ * defaults to a local emulator so `pnpm dev` works out of the box.
+ */
+declare function readRuntime(opts?: {
+  param?: ParamSource;
+  overrides?: Partial<RuntimeConfig>;
+  defaultRgsUrl?: string;
+}): RuntimeConfig;
+//#endregion
+//#region src/rgs/MockNetworkManager.d.ts
+interface MockOptions {
+  /** Starting balance in MAJOR units (default 1000). */
+  balance?: number;
+  currency?: string;
+  betLevels?: number[];
+  defaultBet?: number;
+  rtp?: number;
+  jurisdiction?: JurisdictionConfig;
+  /** Mode key → cost multiplier, so the mock charges bet × cost like the platform. */
+  modes?: Record<string, number>;
+  /** An incomplete round present at authenticate — for testing mid-spin resume. */
+  activeRound?: Round | null;
+}
+/** A scripted round. `payoutMultiplier` is BOOK units (×100); `win` (major) is a shortcut. */
+interface ScriptedRound {
+  mode?: string;
+  /** BOOK units (100 = 1×). Provide this OR `win`. */
+  payoutMultiplier?: number;
+  /** Convenience: the win in MAJOR units for the given bet (sets payoutMultiplier). */
+  win?: number;
+  /** The stake charged, MAJOR units (default = the bet passed to play). */
+  stake?: number;
+  /** The book events the game's `interpretBook` will parse. */
+  events?: unknown[];
+  /** Leave the round open (needs `end-round`) — for exercising the settle path. */
+  active?: boolean;
+}
+declare class MockNetworkManager implements NetworkManager {
+  private balanceApi;
+  private currency;
+  private readonly config;
+  private active;
+  private readonly modes;
+  private readonly queue;
+  /** The last round returned but not yet end-round'd (its win is applied on settle). */
+  private pendingWinApi;
+  constructor(opts?: MockOptions);
+  /** Queue the next round `play()` will return (call repeatedly to queue several). */
+  forceRound(round: ScriptedRound): this;
+  /** Set the current balance (MAJOR units). */
+  setBalance(major: number): this;
+  private balance;
+  authenticate(): Promise<AuthenticateResponse>;
+  play(args: PlayArgs): Promise<PlayResponse>;
+  endRound(): Promise<EndRoundResponse>;
+  replay(_p: ReplayParams): Promise<Round>;
+}
+//#endregion
+//#region src/rgs/network.d.ts
+interface PlayArgs {
+  /** Base bet in MAJOR units (the transport converts to API units). */
+  bet: number;
+  /** Mode key — base / a boost / a bonus buy. The platform applies its cost. */
+  mode: string;
+  /** Currency code; defaults to the one learned at authenticate. */
+  currency?: string;
+}
+interface NetworkManager {
+  authenticate(): Promise<AuthenticateResponse>;
+  play(args: PlayArgs): Promise<PlayResponse>;
+  endRound(): Promise<EndRoundResponse>;
+  /** Optional — fetch a recorded round for read-only replay. */
+  replay?(params: ReplayParams): Promise<Round>;
+  dispose?(): void;
+}
+/**
+ * Pick the transport from the runtime: `?demo=true` (or a supplied `mock`) → the
+ * in-process mock RGS; otherwise the real Stake transport.
+ */
+declare function createNetwork(runtime: RuntimeConfig, mock?: MockNetworkManager): NetworkManager;
+//#endregion
+export { MockOptions as a, RuntimeConfig as c, MockNetworkManager as i, readRuntime as l, PlayArgs as n, ScriptedRound as o, createNetwork as r, ReplayLaunch as s, NetworkManager as t, urlParam as u };
+//# sourceMappingURL=network-pBW8CX1o.d.ts.map

package/dist/protocol-C1KamF3t.d.ts

@@ -0,0 +1,112 @@
+//#region src/rgs/protocol.d.ts
+/**
+ * Stake Engine wire protocol — the GAME-AGNOSTIC shapes every Stake RGS speaks.
+ * (A game's own book/event types live in the game and are parsed by its
+ * `interpretBook`; here a round's events are opaque `unknown[]`.)
+ *
+ * Two money scales (Stake convention):
+ *   - API units : value × 1_000_000 (six implied decimals). Every RGS endpoint.
+ *   - BOOK units: value × 100. A book's `payoutMultiplier` + its event amounts.
+ * So: win_api = round(betAmount_api × payoutMultiplier_book / 100).
+ *
+ * @see https://github.com/StakeEngine/web-sdk — packages/rgs-requests, rgs-fetcher/schema
+ */
+declare const API_AMOUNT_MULTIPLIER = 1000000;
+declare const BOOK_AMOUNT_MULTIPLIER = 100;
+interface Balance {
+  amount: number;
+  currency: string;
+}
+/**
+ * Stake Engine's per-player jurisdiction config, delivered at `/wallet/authenticate`
+ * as `config.jurisdiction`. Structurally compatible with `@open-slot-ui`'s
+ * `JurisdictionConfig`, so it feeds straight into `hud.applyJurisdiction`.
+ */
+interface JurisdictionConfig {
+  socialCasino?: boolean;
+  disabledFullscreen?: boolean;
+  disabledTurbo?: boolean;
+  disabledSuperTurbo?: boolean;
+  disabledAutoplay?: boolean;
+  disabledSlamstop?: boolean;
+  disabledSpacebar?: boolean;
+  disabledBuyFeature?: boolean;
+  displayNetPosition?: boolean;
+  displayRTP?: boolean;
+  displaySessionTimer?: boolean;
+  /** Minimum ms a round must take — enforced by the core, not the platform. */
+  minimumRoundDuration?: number;
+  /** Buy-feature confirm threshold (× base bet) — fed to the HUD's confirm gate. */
+  confirmBuyAboveCost?: number;
+}
+interface RgsConfig {
+  minBet: number;
+  maxBet: number;
+  stepBet: number;
+  betLevels: number[];
+  defaultBetLevel: number;
+  /** Theoretical RTP percentage (e.g. 96.0) for the RTP readout. */
+  rtp?: number;
+  jurisdiction?: JurisdictionConfig;
+}
+/**
+ * One RGS round. `E` is the game's book-event type (opaque to the core — the game's
+ * `interpretBook` narrows it). The real Stake RGS returns the event list under
+ * `state`; some emulators use `events`; read via {@link roundEvents}.
+ */
+interface Round<E = unknown> {
+  betID: string | number;
+  mode: string;
+  amount: number;
+  payout?: number;
+  payoutMultiplier: number;
+  state?: E[];
+  events?: E[];
+  /** True while a (winning) round still awaits `/wallet/end-round`. */
+  active?: boolean;
+}
+/** The book events for a round, whichever field the RGS used (`state` or `events`). */
+declare function roundEvents<E>(round: Round<E>): E[];
+interface AuthenticateRequest {
+  sessionID: string;
+  /** REQUIRED by the real RGS — omitting it 400s `ERR_VAL "could not parse request json"`. */
+  language: string;
+}
+interface AuthenticateResponse {
+  balance: Balance;
+  config: RgsConfig;
+  round: Round | null;
+}
+interface PlayRequest {
+  sessionID: string;
+  amount: number;
+  mode: string;
+  currency: string;
+}
+interface PlayResponse {
+  round: Round;
+  balance: Balance;
+}
+interface EndRoundRequest {
+  sessionID: string;
+}
+interface EndRoundResponse {
+  balance: Balance;
+}
+/** `GET /bet/replay/{game}/{version}/{mode}/{event}` params (from `?replay=…` launch). */
+interface ReplayParams {
+  game: string;
+  version: string;
+  mode: string;
+  event: string;
+  /** The bet amount for the replayed round (API units are NOT used here; major units). */
+  amount: number;
+}
+/** RGS error body (`{ error: 'ERR_VAL', message }`) — codes map to `hud.showRgsError`. */
+interface RgsError {
+  error: string;
+  message?: string;
+}
+//#endregion
+export { Balance as a, JurisdictionConfig as c, ReplayParams as d, RgsConfig as f, roundEvents as h, BOOK_AMOUNT_MULTIPLIER as i, PlayRequest as l, Round as m, AuthenticateRequest as n, EndRoundRequest as o, RgsError as p, AuthenticateResponse as r, EndRoundResponse as s, API_AMOUNT_MULTIPLIER as t, PlayResponse as u };
+//# sourceMappingURL=protocol-C1KamF3t.d.ts.map

package/dist/rgs.d.ts

@@ -0,0 +1,25 @@
+import { a as Balance, c as JurisdictionConfig, d as ReplayParams, f as RgsConfig, h as roundEvents, i as BOOK_AMOUNT_MULTIPLIER, l as PlayRequest, m as Round, n as AuthenticateRequest, o as EndRoundRequest, p as RgsError, r as AuthenticateResponse, s as EndRoundResponse, t as API_AMOUNT_MULTIPLIER, u as PlayResponse } from "./protocol-C1KamF3t.js";
+import { a as MockOptions, c as RuntimeConfig, i as MockNetworkManager, l as readRuntime, n as PlayArgs, o as ScriptedRound, r as createNetwork, s as ReplayLaunch, t as NetworkManager, u as urlParam } from "./network-pBW8CX1o.js";
+//#region src/rgs/StakeNetworkManager.d.ts
+interface StakeNetworkOptions {
+  rgsUrl: string;
+  sessionId: string;
+  /** REQUIRED — `/wallet/authenticate` 400s without it. */
+  language: string;
+}
+declare class StakeNetworkManager implements NetworkManager {
+  private readonly opts;
+  private readonly base;
+  /** Currency learned at authenticate; sent on every `/wallet/play`. */
+  private currency;
+  constructor(opts: StakeNetworkOptions);
+  authenticate(): Promise<AuthenticateResponse>;
+  play(args: PlayArgs): Promise<PlayResponse>;
+  endRound(): Promise<EndRoundResponse>;
+  replay(p: ReplayParams): Promise<Round>;
+  private post;
+  private get;
+}
+//#endregion
+export { API_AMOUNT_MULTIPLIER, AuthenticateRequest, AuthenticateResponse, BOOK_AMOUNT_MULTIPLIER, Balance, EndRoundRequest, EndRoundResponse, JurisdictionConfig, MockNetworkManager, MockOptions, NetworkManager, PlayArgs, PlayRequest, PlayResponse, ReplayLaunch, ReplayParams, RgsConfig, RgsError, Round, RuntimeConfig, ScriptedRound, StakeNetworkManager, StakeNetworkOptions, createNetwork, readRuntime, roundEvents, urlParam };
+//# sourceMappingURL=rgs.d.ts.map

package/dist/rgs.js

@@ -0,0 +1,119 @@
+import { i as roundEvents, n as API_AMOUNT_MULTIPLIER, r as BOOK_AMOUNT_MULTIPLIER, t as MockNetworkManager } from "./MockNetworkManager-cj8WT5v0.js";
+//#region src/rgs/runtime.ts
+/** Read a URL param from `window.location.search` (undefined off-DOM). */
+function urlParam(name) {
+	if (typeof window === "undefined") return void 0;
+	return new URLSearchParams(window.location.search).get(name) ?? void 0;
+}
+/**
+* Parse the Stake launch params into a {@link RuntimeConfig}. Pass `overrides` (or a
+* custom `param` reader) for tests/embedding; otherwise reads the page URL. `rgsUrl`
+* defaults to a local emulator so `pnpm dev` works out of the box.
+*/
+function readRuntime(opts = {}) {
+	const param = opts.param ?? urlParam;
+	const rawLang = param("lang");
+	const language = rawLang === "br" ? "pt" : rawLang || "en";
+	const base = {
+		rgsUrl: param("rgs_url") ?? param("rgsUrl") ?? opts.defaultRgsUrl ?? "http://localhost:4758",
+		sessionId: param("sessionID") ?? param("sessionId") ?? "dev",
+		language,
+		currency: param("currency") ?? "USD",
+		social: param("social") === "true",
+		device: param("device") ?? "",
+		demo: param("demo") === "true",
+		replay: {
+			active: param("replay") === "true",
+			amount: Number(param("amount")) || 0,
+			game: param("game") ?? "",
+			version: param("version") ?? "",
+			mode: param("mode") ?? "",
+			event: param("event") ?? ""
+		}
+	};
+	return {
+		...base,
+		...opts.overrides,
+		replay: {
+			...base.replay,
+			...opts.overrides?.replay
+		}
+	};
+}
+//#endregion
+//#region src/rgs/StakeNetworkManager.ts
+var StakeNetworkManager = class {
+	opts;
+	base;
+	/** Currency learned at authenticate; sent on every `/wallet/play`. */
+	currency = "USD";
+	constructor(opts) {
+		this.opts = opts;
+		this.base = /^https?:\/\//.test(opts.rgsUrl) ? opts.rgsUrl : `https://${opts.rgsUrl}`;
+	}
+	async authenticate() {
+		const res = await this.post("/wallet/authenticate", {
+			sessionID: this.opts.sessionId,
+			language: this.opts.language
+		});
+		this.currency = res.balance.currency;
+		return res;
+	}
+	async play(args) {
+		return this.post("/wallet/play", {
+			sessionID: this.opts.sessionId,
+			currency: args.currency ?? this.currency,
+			amount: Math.round(args.bet * API_AMOUNT_MULTIPLIER),
+			mode: args.mode
+		});
+	}
+	async endRound() {
+		return this.post("/wallet/end-round", { sessionID: this.opts.sessionId });
+	}
+	async replay(p) {
+		const path = `/bet/replay/${encodeURIComponent(p.game)}/${encodeURIComponent(p.version)}/${encodeURIComponent(p.mode)}/${encodeURIComponent(p.event)}`;
+		const res = await this.get(path);
+		return res.round ?? res;
+	}
+	async post(path, body) {
+		const res = await fetch(this.base + path, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(body)
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw new Error(`[StakeNetworkManager] ${path} -> ${res.status} ${text}`);
+		}
+		return await res.json();
+	}
+	async get(path) {
+		const res = await fetch(this.base + path, {
+			method: "GET",
+			headers: { accept: "application/json" }
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw new Error(`[StakeNetworkManager] ${path} -> ${res.status} ${text}`);
+		}
+		return await res.json();
+	}
+};
+//#endregion
+//#region src/rgs/network.ts
+/**
+* Pick the transport from the runtime: `?demo=true` (or a supplied `mock`) → the
+* in-process mock RGS; otherwise the real Stake transport.
+*/
+function createNetwork(runtime, mock) {
+	if (runtime.demo || mock) return mock ?? new MockNetworkManager();
+	return new StakeNetworkManager({
+		rgsUrl: runtime.rgsUrl,
+		sessionId: runtime.sessionId,
+		language: runtime.language
+	});
+}
+//#endregion
+export { API_AMOUNT_MULTIPLIER, BOOK_AMOUNT_MULTIPLIER, MockNetworkManager, StakeNetworkManager, createNetwork, readRuntime, roundEvents, urlParam };
+
+//# sourceMappingURL=rgs.js.map

package/dist/rgs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgs.js","names":[],"sources":["../src/rgs/runtime.ts","../src/rgs/StakeNetworkManager.ts","../src/rgs/network.ts"],"sourcesContent":["/**\n * Stake launch parameters (mirrors `StakeEngine/web-sdk`\n * `packages/state-shared/src/stateUrl`): sessionID, rgs_url, lang, currency, device,\n * social, demo — plus the REPLAY set: replay, amount, game, version, mode, event.\n * `lang` is REQUIRED by `/wallet/authenticate` (its absence 400s the RGS).\n */\n\nexport interface ReplayLaunch {\n  /** `?replay=true` — launch into replay (fetch + play back a recorded round). */\n  active: boolean;\n  amount: number;\n  game: string;\n  version: string;\n  mode: string;\n  event: string;\n}\n\nexport interface RuntimeConfig {\n  rgsUrl: string;\n  sessionId: string;\n  /** BCP-47-ish language for `/wallet/authenticate` + the HUD locale ('br' → 'pt'). */\n  language: string;\n  /** `?currency=` — currency code (used for replay, where there's no wallet to read it). */\n  currency: string;\n  /** `?social=true` — force Stake US social/sweepstakes wording. */\n  social: boolean;\n  /** `?device=` — Stake's viewport hint ('' | 'desktop' | 'mobile' | a small popout). */\n  device: string;\n  /** `?demo=true` — run against the built-in mock RGS, no real backend. */\n  demo: boolean;\n  replay: ReplayLaunch;\n}\n\ntype ParamSource = (name: string) => string | undefined;\n\n/** Read a URL param from `window.location.search` (undefined off-DOM). */\nexport function urlParam(name: string): string | undefined {\n  if (typeof window === 'undefined') return undefined;\n  return new URLSearchParams(window.location.search).get(name) ?? undefined;\n}\n\n/**\n * Parse the Stake launch params into a {@link RuntimeConfig}. Pass `overrides` (or a\n * custom `param` reader) for tests/embedding; otherwise reads the page URL. `rgsUrl`\n * defaults to a local emulator so `pnpm dev` works out of the box.\n */\nexport function readRuntime(opts: { param?: ParamSource; overrides?: Partial<RuntimeConfig>; defaultRgsUrl?: string } = {}): RuntimeConfig {\n  const param = opts.param ?? urlParam;\n  const rawLang = param('lang');\n  const language = rawLang === 'br' ? 'pt' : rawLang || 'en';\n  const base: RuntimeConfig = {\n    rgsUrl: param('rgs_url') ?? param('rgsUrl') ?? opts.defaultRgsUrl ?? 'http://localhost:4758',\n    sessionId: param('sessionID') ?? param('sessionId') ?? 'dev',\n    language,\n    currency: param('currency') ?? 'USD',\n    social: param('social') === 'true',\n    device: param('device') ?? '',\n    demo: param('demo') === 'true',\n    replay: {\n      active: param('replay') === 'true',\n      amount: Number(param('amount')) || 0,\n      game: param('game') ?? '',\n      version: param('version') ?? '',\n      mode: param('mode') ?? '',\n      event: param('event') ?? '',\n    },\n  };\n  return { ...base, ...opts.overrides, replay: { ...base.replay, ...opts.overrides?.replay } };\n}\n","// StakeNetworkManager — the ONLY thing that speaks the Stake RGS wire. Thin: it\n// returns RAW protocol shapes; the engine (SpinPhase/boot) owns the end-round settle\n// + active-round resume. Money: RGS = API units (×1e6); the game's book = BOOK units.\n\nimport {\n  API_AMOUNT_MULTIPLIER,\n  type AuthenticateResponse,\n  type EndRoundResponse,\n  type PlayResponse,\n  type ReplayParams,\n  type Round,\n} from './protocol';\nimport type { NetworkManager, PlayArgs } from './network';\n\nexport interface StakeNetworkOptions {\n  rgsUrl: string;\n  sessionId: string;\n  /** REQUIRED — `/wallet/authenticate` 400s without it. */\n  language: string;\n}\n\nexport class StakeNetworkManager implements NetworkManager {\n  private readonly base: string;\n  /** Currency learned at authenticate; sent on every `/wallet/play`. */\n  private currency = 'USD';\n\n  constructor(private readonly opts: StakeNetworkOptions) {\n    this.base = /^https?:\\/\\//.test(opts.rgsUrl) ? opts.rgsUrl : `https://${opts.rgsUrl}`;\n  }\n\n  async authenticate(): Promise<AuthenticateResponse> {\n    const res = await this.post<AuthenticateResponse>('/wallet/authenticate', {\n      sessionID: this.opts.sessionId,\n      language: this.opts.language,\n    });\n    this.currency = res.balance.currency;\n    return res;\n  }\n\n  async play(args: PlayArgs): Promise<PlayResponse> {\n    return this.post<PlayResponse>('/wallet/play', {\n      sessionID: this.opts.sessionId,\n      currency: args.currency ?? this.currency,\n      amount: Math.round(args.bet * API_AMOUNT_MULTIPLIER),\n      mode: args.mode,\n    });\n  }\n\n  async endRound(): Promise<EndRoundResponse> {\n    return this.post<EndRoundResponse>('/wallet/end-round', { sessionID: this.opts.sessionId });\n  }\n\n  async replay(p: ReplayParams): Promise<Round> {\n    const path = `/bet/replay/${encodeURIComponent(p.game)}/${encodeURIComponent(p.version)}/${encodeURIComponent(p.mode)}/${encodeURIComponent(p.event)}`;\n    const res = await this.get<Record<string, unknown>>(path);\n    // The RGS may return `{ round }` or the round object directly.\n    return (res.round ?? res) as Round;\n  }\n\n  private async post<T>(path: string, body: unknown): Promise<T> {\n    const res = await fetch(this.base + path, {\n      method: 'POST',\n      headers: { 'content-type': 'application/json' },\n      body: JSON.stringify(body),\n    });\n    if (!res.ok) {\n      const text = await res.text().catch(() => '');\n      throw new Error(`[StakeNetworkManager] ${path} -> ${res.status} ${text}`);\n    }\n    return (await res.json()) as T;\n  }\n\n  private async get<T>(path: string): Promise<T> {\n    const res = await fetch(this.base + path, { method: 'GET', headers: { accept: 'application/json' } });\n    if (!res.ok) {\n      const text = await res.text().catch(() => '');\n      throw new Error(`[StakeNetworkManager] ${path} -> ${res.status} ${text}`);\n    }\n    return (await res.json()) as T;\n  }\n}\n","// The transport seam. Adapters return RAW protocol shapes; the engine applies the\n// game's `interpretBook` and owns the round lifecycle (settle / resume).\n\nimport type { AuthenticateResponse, EndRoundResponse, PlayResponse, ReplayParams, Round } from './protocol';\nimport type { RuntimeConfig } from './runtime';\nimport { StakeNetworkManager } from './StakeNetworkManager';\nimport { MockNetworkManager } from './MockNetworkManager';\n\nexport interface PlayArgs {\n  /** Base bet in MAJOR units (the transport converts to API units). */\n  bet: number;\n  /** Mode key — base / a boost / a bonus buy. The platform applies its cost. */\n  mode: string;\n  /** Currency code; defaults to the one learned at authenticate. */\n  currency?: string;\n}\n\nexport interface NetworkManager {\n  authenticate(): Promise<AuthenticateResponse>;\n  play(args: PlayArgs): Promise<PlayResponse>;\n  endRound(): Promise<EndRoundResponse>;\n  /** Optional — fetch a recorded round for read-only replay. */\n  replay?(params: ReplayParams): Promise<Round>;\n  dispose?(): void;\n}\n\n/**\n * Pick the transport from the runtime: `?demo=true` (or a supplied `mock`) → the\n * in-process mock RGS; otherwise the real Stake transport.\n */\nexport function createNetwork(runtime: RuntimeConfig, mock?: MockNetworkManager): NetworkManager {\n  if (runtime.demo || mock) return mock ?? new MockNetworkManager();\n  return new StakeNetworkManager({\n    rgsUrl: runtime.rgsUrl,\n    sessionId: runtime.sessionId,\n    language: runtime.language,\n  });\n}\n"],"mappings":"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"}

package/dist/rules.d.ts

@@ -0,0 +1,68 @@
+import { BlockSpec, MenuSpec } from "@open-slot-ui/core";
+//#region src/rules/social.d.ts
+/** Restricted → replacement, ORDERED longest-phrase-first (so multi-word phrases win). */
+declare const SOCIAL_REPLACEMENTS: ReadonlyArray<readonly [string, string]>;
+/**
+ * Rewrite an English string into its social/sweepstakes wording — restricted phrases swapped
+ * for their alternatives (word-boundary safe, longest-phrase-first, case-preserving). Idempotent
+ * enough for authoring: run it over your menu/feature copy to auto-generate social variants.
+ */
+declare function toSocial(text: string): string;
+/**
+ * AGGRESSIVELY find restricted phrases in an English string — matches even as part of a word
+ * (so `paytable`, `betting`, `payout` are all flagged). Returns the offending terms. Use it at
+ * launch/build to fail on any social-copy that would still surface gambling wording.
+ */
+declare function findRestricted(text: string): string[];
+//#endregion
+//#region src/rules/index.d.ts
+/** RTP / volatility / max-win etc. — shown as a stat grid. Values are display strings. */
+interface RulesStats {
+  rtp?: string;
+  volatility?: string;
+  maxWin?: string;
+  lines?: string;
+  /** Any extra label → value rows (e.g. per-mode RTP/Max win). */
+  extra?: Array<{
+    label: string;
+    value: string;
+  }>;
+}
+interface BuildRulesOptions {
+  /** How Settings exposes sound: a `'toggle'` only · `'master'` slider · `'sliders'`
+   *  (Music + Effects). Default `'sliders'`. */
+  sound?: 'toggle' | 'master' | 'sliders';
+  /** An "About the game" intro paragraph. */
+  about?: string;
+  /** "How to play" steps. */
+  howToPlay?: string[];
+  /** Feature cards (Wild / Scatter / Bonus …). */
+  features?: Array<{
+    icon?: string;
+    title: string;
+    text?: string;
+  }>;
+  /** The game's paytable blocks (usually one `{ kind: 'paytable' }`). */
+  paytable?: BlockSpec[];
+  /** RTP / volatility / max-win — the Game info grid. Must match the certified report. */
+  stats?: RulesStats;
+  /** Extra rules blocks appended before the disclaimer. */
+  extra?: BlockSpec[];
+  /** Override the built-in per-control guide lines (each: `**Name** — what it does.`). */
+  controlGuide?: string[];
+  /** Include the Stake disclaimer (default `true`). */
+  disclaimer?: boolean;
+}
+interface BuiltRules {
+  menu: MenuSpec;
+  /** { normal → social } for the strings buildRules authored — merge into `config.socialMessages.en`. */
+  socialEn: Record<string, string>;
+}
+/** Every interactive control described (Stake: the Info/Help must explain each button). */
+declare const DEFAULT_CONTROL_GUIDE: string[];
+/** The EXACT Stake Engine disclaimer — never reworded, never given a social override. */
+declare const STAKE_DISCLAIMER = "Malfunction voids all wins and plays. A consistent internet connection is required. In the event of a disconnection, reload the game to finish any uncompleted rounds. The expected return is calculated over many plays. The game display is not representative of any physical device and is for illustrative purposes only. Winnings are settled according to the amount received from the Remote Game Server and not from events within the web browser. TM and © 2026 Stake Engine.";
+declare function buildRules(opts?: BuildRulesOptions): BuiltRules;
+//#endregion
+export { BuildRulesOptions, BuiltRules, DEFAULT_CONTROL_GUIDE, RulesStats, SOCIAL_REPLACEMENTS, STAKE_DISCLAIMER, buildRules, findRestricted, toSocial };
+//# sourceMappingURL=rules.d.ts.map