@betorigami/game-engine 0.0.0-sha-d6d1f10-20260907014734

package/dist/index.cjs

@@ -0,0 +1 @@
+var v=Object.create;var{getPrototypeOf:L,defineProperty:a,getOwnPropertyNames:I,getOwnPropertyDescriptor:k}=Object,f=Object.prototype.hasOwnProperty;var m=(e,t,r)=>{r=e!=null?v(L(e)):{};let i=t||!e||!e.__esModule?a(r,"default",{value:e,enumerable:!0}):r;for(let u of I(e))if(!f.call(i,u))a(i,u,{get:()=>e[u],enumerable:!0});return i},T=new WeakMap,P=(e)=>{var t=T.get(e),r;if(t)return t;if(t=a({},"__esModule",{value:!0}),e&&typeof e==="object"||typeof e==="function")I(e).map((i)=>!f.call(t,i)&&a(t,i,{get:()=>e[i],enumerable:!(r=k(e,i))||r.enumerable}));return T.set(e,t),t};var K=(e,t)=>{for(var r in t)a(e,r,{get:t[r],enumerable:!0,configurable:!0,set:(i)=>t[r]=()=>i})};var z={};K(z,{sumPayout:()=>X,rtpOf:()=>J,probabilityOf:()=>W,nCr:()=>j,maxMultiplierOf:()=>Q,bigMin:()=>q,bigMax:()=>Z,SingleActionGame:()=>B,RandomValuePool:()=>x,OrigamiGame:()=>M,MultiplierContainer:()=>G,MultiplierCalculator:()=>N,MultiActionGame:()=>h,MIN_CARD_VALUE:()=>$,MAX_CARD_VALUE:()=>w,GameErrorCode:()=>O,GameError:()=>o,FACE_CARD_RANKS:()=>F,Card:()=>S,CARD_VALUES:()=>b,CARD_SUIT_COLORS:()=>H,CARD_SUITS:()=>R,CARD_RANKS:()=>C});module.exports=P(z);var d=require("@betorigami/guard");var $=0,w=51,b=Array.from({length:52},(e,t)=>t),R=["Spades","Hearts","Diamonds","Clubs"],C=["Ace","Two","Three","Four","Five","Six","Seven","Eight","Nine","Ten","Jack","Queen","King"],F=["Jack","Queen","King"],H={Hearts:"red",Diamonds:"red",Spades:"black",Clubs:"black"};class S{value;constructor(e){let t=b[e];d.Guard.againstNullOrUndefined(t,`Invalid card value: ${e}`),this.value=t}get suit(){let e=Math.floor(this.value/13),t=R[e];return d.Guard.againstNullOrUndefined(t,`Invalid suit index: ${e}`),t}get rank(){let e=this.value%13,t=C[e];return d.Guard.againstNullOrUndefined(t,`Invalid rank index: ${e}`),t}toDto(){return{rank:this.rank,suit:this.suit,cardValue:this.value}}}var O;((r)=>{r.UNSUPPORTED_EDGE="UNSUPPORTED_EDGE";r.INPUT_VALIDATION_ERROR="INPUT_VALIDATION_ERROR"})(O||={});class o extends Error{static createUnsupportedEdgeError(e){return new o("UNSUPPORTED_EDGE",e)}static createValidationError(e){return new o("INPUT_VALIDATION_ERROR",e)}static isGameError(e){return e instanceof o}errorCode;constructor(e,t){super(t);this.errorCode=e}}var E=require("@betorigami/guard"),y=m(require("fast-deep-equal"));class h{gameId;edge;constructor(e,t){this.gameId=e;this.edge=t;this.validateEdge(t)}play(e,t,r=[]){let i=this.createGameStore(),u=this.generateRandomValues(e),p=u.toMultipleRandomValues();for(let U of r)i.send({...U.playerArgument,randomValuePool:u});let D=r[r.length-1];if(D)E.Guard.against(!y.default(D.state,this.toExternalState(i.getSnapshot().context.state)),"The final state of the game does not match the expected state based on the previous actions");i.send({...t,randomValuePool:u});let l=i.getSnapshot().context;return{playerArgument:l.playerArgument,state:this.toExternalState(l.state),config:l.config,additionalBetAmount:l.additionalBetAmount,proof:{proofHash:p.proofHash,proofString:p.proofString}}}validateEdge(e){let t=this.supportedEdgeConfigurations.includes(e);E.Guard.against(!t,()=>o.createUnsupportedEdgeError(`${this.gameId} does not support ${e}% edge. Supported edge configurations include: ${this.supportedEdgeConfigurations}`))}}class G{multipliers;constructor(e){this.multipliers=e}getMultipliers(e){let t=this.multipliers.get(e);if(t===void 0)throw new Error(`Multipliers for ${e} not found`);return t}getAllMultipliers(){return Array.from(this.multipliers.entries()).map(([e,t])=>({edge:e,multipliers:t}))}}var M;((n)=>{n.DICE="DICE";n.MINES="MINES";n.KENO="KENO";n.LIMBO="LIMBO";n.ADVANCED_DICE="ADVANCED_DICE";n.BACCARAT="BACCARAT";n.DIAMONDS="DIAMONDS";n.PLINKO="PLINKO";n.ROULETTE="ROULETTE";n.WHEEL="WHEEL";n.BLACKJACK="BLACKJACK";n.BLITZ="BLITZ";n.DARTS="DARTS"})(M||={});var A=m(require("big.js")),c=require("@betorigami/guard"),J=({outcomes:e,totalWeight:t})=>{return c.Guard.against(t<=0,"An outcome distribution must have a positive total weight"),e.reduce((r,{multiplier:i,weight:u})=>r.plus(i.times(u)),A.default(0)).div(t)},Q=({outcomes:e})=>{return c.Guard.againstEmptyArray(e,"An outcome distribution must have at least one outcome"),e.reduce((t,{multiplier:r})=>r.gt(t)?r:t,e[0].multiplier)},W=({outcomes:e,totalWeight:t},r)=>{c.Guard.against(t<=0,"An outcome distribution must have a positive total weight");let i=e.filter((u)=>u.slot===r).reduce((u,p)=>u+p.weight,0);return A.default(i).div(t)};var V=m(require("big.js")),X=(e)=>e.legs.reduce((t,r)=>t.add(r.amount),new V.default("0"));var s=require("@betorigami/guard");class x{source;index=0;constructor(e){this.source=e}static from(e,t){return s.Guard.against(t<=0,`Count must be positive, got ${t}`),s.Guard.against(e.values.length!==t,`Expected ${t} values, got ${e.values.length}`),new x(e)}get consumedValues(){return this.source.values.slice(0,this.index)}toMultipleRandomValues(){return this.source}takeOne(){let e=this.source.values[this.index];return s.Guard.againstUndefined(e,"RandomValuePool exhausted"),this.index+=1,e}take(e){s.Guard.against(this.index+e>this.source.values.length,`RandomValuePool exhausted: requested ${e} but only ${this.source.values.length-this.index} remain`);let t=this.source.values.slice(this.index,this.index+e);return this.index+=e,t}}var _=require("@betorigami/guard");class B{gameId;constructor(e){this.gameId=e}getGameResult(e){let t=this.supportedEdgeConfigurations.includes(e.edge);return _.Guard.against(!t,()=>o.createUnsupportedEdgeError(`${this.gameId} does not support ${e.edge}% edge. Supported edge configurations include: ${this.supportedEdgeConfigurations}`)),this.determineGameResult(e)}}var Z=(e,t)=>{return e.gt(t)?e:t};var q=(e,t)=>{return e.lt(t)?e:t};var g=m(require("big.js"));class N{static withMultiplier(e,t){return new g.default(e).times(new g.default(100-t).div(100))}static withWinChance(e,t){return g.default(100-e).div(t)}}var j=(e,t)=>{if(t<0||e<0||t>e)throw new Error("Invalid input: ensure 0 ≤ r ≤ n and n ≥ 0.");if(t>e-t)t=e-t;let r=1;for(let i=1;i<=t;i++)r=r*(e-i+1)/i;return r};

package/dist/index.d.ts

@@ -0,0 +1,267 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import Big$1 from 'big.js';
+
+export declare const MIN_CARD_VALUE = 0;
+export declare const MAX_CARD_VALUE = 51;
+export declare const CARD_VALUES: number[];
+export declare const CARD_SUITS: readonly [
+	"Spades",
+	"Hearts",
+	"Diamonds",
+	"Clubs"
+];
+export type CardSuit = (typeof CARD_SUITS)[number];
+export declare const CARD_RANKS: readonly [
+	"Ace",
+	"Two",
+	"Three",
+	"Four",
+	"Five",
+	"Six",
+	"Seven",
+	"Eight",
+	"Nine",
+	"Ten",
+	"Jack",
+	"Queen",
+	"King"
+];
+export type CardRank = (typeof CARD_RANKS)[number];
+export declare const FACE_CARD_RANKS: readonly CardRank[];
+export type CardValue = (typeof CARD_VALUES)[number];
+export type CardDto = {
+	rank: CardRank;
+	suit: CardSuit;
+	cardValue: CardValue;
+};
+export declare const CARD_SUIT_COLORS: Record<CardSuit, "red" | "black">;
+export declare class Card {
+	readonly value: CardValue;
+	constructor(rawValue: number);
+	get suit(): CardSuit;
+	get rank(): CardRank;
+	toDto(): CardDto;
+}
+export declare enum GameErrorCode {
+	UNSUPPORTED_EDGE = "UNSUPPORTED_EDGE",
+	INPUT_VALIDATION_ERROR = "INPUT_VALIDATION_ERROR"
+}
+export declare class GameError extends Error {
+	static createUnsupportedEdgeError(message: string): GameError;
+	static createValidationError(message: string): GameError;
+	static isGameError(error: unknown): error is GameError;
+	errorCode: GameErrorCode;
+	constructor(errorCode: GameErrorCode, message?: string);
+}
+export declare enum OrigamiGame {
+	DICE = "DICE",
+	MINES = "MINES",
+	KENO = "KENO",
+	LIMBO = "LIMBO",
+	ADVANCED_DICE = "ADVANCED_DICE",
+	BACCARAT = "BACCARAT",
+	DIAMONDS = "DIAMONDS",
+	PLINKO = "PLINKO",
+	ROULETTE = "ROULETTE",
+	WHEEL = "WHEEL",
+	BLACKJACK = "BLACKJACK",
+	BLITZ = "BLITZ",
+	DARTS = "DARTS"
+}
+export interface Game {
+	gameId: OrigamiGame;
+	supportedEdgeConfigurations: [
+		number,
+		...number[]
+	];
+}
+export type Proof = {
+	proofHash: string;
+	proofString: string;
+};
+export type SingleRandomValue = {
+	value: number;
+	values: number[];
+	count: 1;
+	min: number;
+	max: number;
+} & Proof;
+export type MultipleRandomValues = {
+	values: number[];
+	count: number;
+	min: number;
+	max: number;
+} & Proof;
+export interface RandomNumberGenerator {
+	getRandomInt({ min, max }: {
+		min: number;
+		max: number;
+	}): SingleRandomValue;
+	getUniqueRandomInts({ min, max, count }: {
+		min: number;
+		max: number;
+		count: number;
+	}): MultipleRandomValues;
+	getRandomIntsWithReplacement({ min, max, count }: {
+		min: number;
+		max: number;
+		count: number;
+	}): MultipleRandomValues;
+}
+/**
+ * A single exact payout amount from a game round.
+ *
+ * A round returns zero or more legs. Neither their order nor their count is
+ * significant: a leg is not tied to a particular bet, an amount may be zero,
+ * and the number of legs need not match the number of bets placed. The only
+ * supported operation is summing them.
+ *
+ * Amounts are gross — they include returned stake — and unrounded. Rounding to
+ * a currency's precision is the consuming service's decision, not this
+ * package's.
+ */
+export type PayoutLeg = Readonly<{
+	amount: Big$1;
+}>;
+/**
+ * A round's payout, expressed as its constituent legs.
+ */
+export type Payout = Readonly<{
+	legs: readonly PayoutLeg[];
+}>;
+/**
+ * Totals a round's payout.
+ *
+ * Summing the legs is lossless; reconstructing the total from a rounded
+ * payout multiplier is not, so this is the only supported way to arrive at
+ * what a round pays.
+ */
+export declare const sumPayout: (payout: Payout) => Big$1;
+export type EmptyGameOutput = {};
+export interface GetGameResultRequest<TGameInputs> {
+	generator: RandomNumberGenerator;
+	edge: number;
+	gameInputs: TGameInputs;
+}
+export interface GameResult<TGameOutputs = EmptyGameOutput> {
+	isFinished: boolean;
+	payout: Payout;
+	payoutMultiplier: Big$1;
+	outputs: TGameOutputs & {
+		result: number[];
+	};
+	randomValues: SingleRandomValue | MultipleRandomValues;
+}
+export declare abstract class SingleActionGame<TGameInputs, TGameOutputs = EmptyGameOutput> implements Game {
+	readonly gameId: OrigamiGame;
+	protected constructor(gameId: OrigamiGame);
+	abstract get supportedEdgeConfigurations(): [
+		number,
+		...number[]
+	];
+	abstract getBetAmount(gameInputs: TGameInputs): Big$1;
+	getGameResult(request: GetGameResultRequest<TGameInputs>): GameResult<TGameOutputs>;
+	protected abstract determineGameResult(request: GetGameResultRequest<TGameInputs>): GameResult<TGameOutputs>;
+}
+export interface GameDescriptor<TInputs, TOutputs = EmptyGameOutput> {
+	readonly id: OrigamiGame;
+	readonly create: () => SingleActionGame<TInputs, TOutputs>;
+	readonly suppliesOwnBetAmount: boolean;
+}
+export declare class RandomValuePool {
+	private readonly source;
+	private index;
+	private constructor();
+	static from(result: MultipleRandomValues, count: number): RandomValuePool;
+	get consumedValues(): number[];
+	toMultipleRandomValues(): MultipleRandomValues;
+	takeOne(): number;
+	take(count: number): ReadonlyArray<number>;
+}
+export type BaseInProgressState = Readonly<{
+	isFinished: false;
+	multiplier: Big$1;
+}>;
+export type BaseFinishedState = Readonly<{
+	isFinished: true;
+	payout: Payout;
+	multiplier: Big$1;
+	randomValues: number[];
+}>;
+export type BaseGameState = BaseInProgressState | BaseFinishedState;
+export type GameContext<TAction, TState extends BaseGameState, TConfig> = {
+	readonly playerArgument: TAction;
+	readonly state: TState;
+	readonly config: TConfig;
+	readonly additionalBetAmount?: Big$1;
+};
+export type RandomValuePoolEvent = Readonly<{
+	randomValuePool: RandomValuePool;
+}>;
+export type UntypedGameContext = GameContext<{
+	readonly type: string;
+}, BaseGameState, unknown>;
+export type PlayResult = UntypedGameContext & {
+	readonly proof: Proof;
+};
+export interface GameStore<TInternalState extends BaseGameState, TAction, TConfig> {
+	send(event: {
+		readonly type: string;
+	} & RandomValuePoolEvent & Record<string, unknown>): void;
+	getSnapshot(): {
+		readonly context: GameContext<TAction, TInternalState, TConfig>;
+	};
+}
+export declare abstract class MultiActionGame<TInternalState extends BaseGameState, TExternalState extends BaseGameState, TAction extends {
+	readonly type: string;
+}, TConfig> implements Game {
+	readonly gameId: OrigamiGame;
+	readonly edge: number;
+	protected constructor(gameId: OrigamiGame, edge: number);
+	abstract get supportedEdgeConfigurations(): [
+		number,
+		...number[]
+	];
+	abstract getValidNextActionTypes(state: TExternalState): ReadonlyArray<TAction["type"]>;
+	protected abstract createGameStore(): GameStore<TInternalState, TAction, TConfig>;
+	protected abstract generateRandomValues(generator: RandomNumberGenerator): RandomValuePool;
+	protected abstract toExternalState(internal: TInternalState): TExternalState;
+	play(generator: RandomNumberGenerator, action: {
+		readonly type: string;
+	} & Record<string, unknown>, previousActions?: readonly UntypedGameContext[]): PlayResult;
+	private validateEdge;
+}
+export declare class MultiplierContainer<TMultipliers> {
+	readonly multipliers: Map<number, TMultipliers>;
+	constructor(multipliers: Map<number, TMultipliers>);
+	getMultipliers(edge: number): TMultipliers;
+	getAllMultipliers(): {
+		edge: number;
+		multipliers: TMultipliers;
+	}[];
+}
+export type Outcome<TSlot extends string = string> = Readonly<{
+	slot: TSlot;
+	multiplier: Big$1;
+	weight: number;
+}>;
+export type OutcomeDistribution<TSlot extends string = string> = Readonly<{
+	outcomes: readonly Outcome<TSlot>[];
+	totalWeight: number;
+}>;
+export interface DescribesOutcomes<TSelection, TSlot extends string = string> {
+	describeOutcomes(selection: TSelection, edge: number): OutcomeDistribution<TSlot>;
+}
+export declare const rtpOf: ({ outcomes, totalWeight }: OutcomeDistribution) => Big$1;
+export declare const maxMultiplierOf: ({ outcomes }: OutcomeDistribution) => Big$1;
+export declare const probabilityOf: ({ outcomes, totalWeight }: OutcomeDistribution, slot: string) => Big$1;
+export declare const bigMax: (a: Big$1, b: Big$1) => Big$1;
+export declare const bigMin: (a: Big$1, b: Big$1) => Big$1;
+export declare abstract class MultiplierCalculator {
+	static withMultiplier(multiplier: Big$1, edge: number): Big$1;
+	static withWinChance(edge: number, winChance: Big$1): Big$1;
+}
+export declare const nCr: (n: number, r: number) => number;
+
+export {};

package/dist/index.mjs

@@ -0,0 +1 @@
+import{Guard as l}from"@betorigami/guard";var V=0,_=51,g=Array.from({length:52},(e,t)=>t),b=["Spades","Hearts","Diamonds","Clubs"],R=["Ace","Two","Three","Four","Five","Six","Seven","Eight","Nine","Ten","Jack","Queen","King"],B=["Jack","Queen","King"],N={Hearts:"red",Diamonds:"red",Spades:"black",Clubs:"black"};class D{value;constructor(e){let t=g[e];l.againstNullOrUndefined(t,`Invalid card value: ${e}`),this.value=t}get suit(){let e=Math.floor(this.value/13),t=b[e];return l.againstNullOrUndefined(t,`Invalid suit index: ${e}`),t}get rank(){let e=this.value%13,t=R[e];return l.againstNullOrUndefined(t,`Invalid rank index: ${e}`),t}toDto(){return{rank:this.rank,suit:this.suit,cardValue:this.value}}}var T;((r)=>{r.UNSUPPORTED_EDGE="UNSUPPORTED_EDGE";r.INPUT_VALIDATION_ERROR="INPUT_VALIDATION_ERROR"})(T||={});class o extends Error{static createUnsupportedEdgeError(e){return new o("UNSUPPORTED_EDGE",e)}static createValidationError(e){return new o("INPUT_VALIDATION_ERROR",e)}static isGameError(e){return e instanceof o}errorCode;constructor(e,t){super(t);this.errorCode=e}}import{Guard as C}from"@betorigami/guard";import I from"fast-deep-equal";class f{gameId;edge;constructor(e,t){this.gameId=e;this.edge=t;this.validateEdge(t)}play(e,t,r=[]){let i=this.createGameStore(),n=this.generateRandomValues(e),a=n.toMultipleRandomValues();for(let x of r)i.send({...x.playerArgument,randomValuePool:n});let c=r[r.length-1];if(c)C.against(!I(c.state,this.toExternalState(i.getSnapshot().context.state)),"The final state of the game does not match the expected state based on the previous actions");i.send({...t,randomValuePool:n});let s=i.getSnapshot().context;return{playerArgument:s.playerArgument,state:this.toExternalState(s.state),config:s.config,additionalBetAmount:s.additionalBetAmount,proof:{proofHash:a.proofHash,proofString:a.proofString}}}validateEdge(e){let t=this.supportedEdgeConfigurations.includes(e);C.against(!t,()=>o.createUnsupportedEdgeError(`${this.gameId} does not support ${e}% edge. Supported edge configurations include: ${this.supportedEdgeConfigurations}`))}}class S{multipliers;constructor(e){this.multipliers=e}getMultipliers(e){let t=this.multipliers.get(e);if(t===void 0)throw new Error(`Multipliers for ${e} not found`);return t}getAllMultipliers(){return Array.from(this.multipliers.entries()).map(([e,t])=>({edge:e,multipliers:t}))}}var O;((u)=>{u.DICE="DICE";u.MINES="MINES";u.KENO="KENO";u.LIMBO="LIMBO";u.ADVANCED_DICE="ADVANCED_DICE";u.BACCARAT="BACCARAT";u.DIAMONDS="DIAMONDS";u.PLINKO="PLINKO";u.ROULETTE="ROULETTE";u.WHEEL="WHEEL";u.BLACKJACK="BLACKJACK";u.BLITZ="BLITZ";u.DARTS="DARTS"})(O||={});import E from"big.js";import{Guard as m}from"@betorigami/guard";var q=({outcomes:e,totalWeight:t})=>{return m.against(t<=0,"An outcome distribution must have a positive total weight"),e.reduce((r,{multiplier:i,weight:n})=>r.plus(i.times(n)),E(0)).div(t)},j=({outcomes:e})=>{return m.againstEmptyArray(e,"An outcome distribution must have at least one outcome"),e.reduce((t,{multiplier:r})=>r.gt(t)?r:t,e[0].multiplier)},z=({outcomes:e,totalWeight:t},r)=>{m.against(t<=0,"An outcome distribution must have a positive total weight");let i=e.filter((n)=>n.slot===r).reduce((n,a)=>n+a.weight,0);return E(i).div(t)};import y from"big.js";var te=(e)=>e.legs.reduce((t,r)=>t.add(r.amount),new y("0"));import{Guard as p}from"@betorigami/guard";class A{source;index=0;constructor(e){this.source=e}static from(e,t){return p.against(t<=0,`Count must be positive, got ${t}`),p.against(e.values.length!==t,`Expected ${t} values, got ${e.values.length}`),new A(e)}get consumedValues(){return this.source.values.slice(0,this.index)}toMultipleRandomValues(){return this.source}takeOne(){let e=this.source.values[this.index];return p.againstUndefined(e,"RandomValuePool exhausted"),this.index+=1,e}take(e){p.against(this.index+e>this.source.values.length,`RandomValuePool exhausted: requested ${e} but only ${this.source.values.length-this.index} remain`);let t=this.source.values.slice(this.index,this.index+e);return this.index+=e,t}}import{Guard as h}from"@betorigami/guard";class G{gameId;constructor(e){this.gameId=e}getGameResult(e){let t=this.supportedEdgeConfigurations.includes(e.edge);return h.against(!t,()=>o.createUnsupportedEdgeError(`${this.gameId} does not support ${e.edge}% edge. Supported edge configurations include: ${this.supportedEdgeConfigurations}`)),this.determineGameResult(e)}}var se=(e,t)=>{return e.gt(t)?e:t};var le=(e,t)=>{return e.lt(t)?e:t};import d from"big.js";class M{static withMultiplier(e,t){return new d(e).times(new d(100-t).div(100))}static withWinChance(e,t){return d(100-e).div(t)}}var ge=(e,t)=>{if(t<0||e<0||t>e)throw new Error("Invalid input: ensure 0 ≤ r ≤ n and n ≥ 0.");if(t>e-t)t=e-t;let r=1;for(let i=1;i<=t;i++)r=r*(e-i+1)/i;return r};export{te as sumPayout,q as rtpOf,z as probabilityOf,ge as nCr,j as maxMultiplierOf,le as bigMin,se as bigMax,G as SingleActionGame,A as RandomValuePool,O as OrigamiGame,S as MultiplierContainer,M as MultiplierCalculator,f as MultiActionGame,V as MIN_CARD_VALUE,_ as MAX_CARD_VALUE,T as GameErrorCode,o as GameError,B as FACE_CARD_RANKS,D as Card,g as CARD_VALUES,N as CARD_SUIT_COLORS,b as CARD_SUITS,R as CARD_RANKS};

package/dist/testing/index.cjs

@@ -0,0 +1 @@
+var b=Object.create;var{getPrototypeOf:d,defineProperty:u,getOwnPropertyNames:l,getOwnPropertyDescriptor:c}=Object,s=Object.prototype.hasOwnProperty;var v=(e,n,r)=>{r=e!=null?b(d(e)):{};let t=n||!e||!e.__esModule?u(r,"default",{value:e,enumerable:!0}):r;for(let m of l(e))if(!s.call(t,m))u(t,m,{get:()=>e[m],enumerable:!0});return t},a=new WeakMap,R=(e)=>{var n=a.get(e),r;if(n)return n;if(n=u({},"__esModule",{value:!0}),e&&typeof e==="object"||typeof e==="function")l(e).map((t)=>!s.call(n,t)&&u(n,t,{get:()=>e[t],enumerable:!(r=c(e,t))||r.enumerable}));return a.set(e,n),n};var h=(e,n)=>{for(var r in n)u(e,r,{get:n[r],enumerable:!0,configurable:!0,set:(t)=>n[r]=()=>t})};var g={};h(g,{SingleRandomNumberGeneratorStub:()=>i,RandomNumberGeneratorStub:()=>o,MultipleRandomNumberGeneratorStub:()=>p});module.exports=R(g);class o{getRandomInt({}){throw new Error("Not implemented")}getRandomIntsWithReplacement({}){throw new Error("Not implemented")}getUniqueRandomInts({}){throw new Error("Not implemented")}}class i extends o{value;constructor(e){super();this.value=e}getRandomInt(e){return{...e,value:this.value,values:[this.value],count:1,proofHash:"stub-proof-hash",proofString:"stub-proof-string"}}}class p extends o{values;constructor(e){super();this.values=e}getRandomIntsWithReplacement(e){return{...e,values:this.values,proofHash:"stub-proof-hash",proofString:"stub-proof-string"}}getUniqueRandomInts(e){return{...e,values:this.values,proofHash:"stub-proof-hash",proofString:"stub-proof-string"}}}

package/dist/testing/index.d.ts

@@ -0,0 +1,75 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type Proof = {
+	proofHash: string;
+	proofString: string;
+};
+export type SingleRandomValue = {
+	value: number;
+	values: number[];
+	count: 1;
+	min: number;
+	max: number;
+} & Proof;
+export type MultipleRandomValues = {
+	values: number[];
+	count: number;
+	min: number;
+	max: number;
+} & Proof;
+export interface RandomNumberGenerator {
+	getRandomInt({ min, max }: {
+		min: number;
+		max: number;
+	}): SingleRandomValue;
+	getUniqueRandomInts({ min, max, count }: {
+		min: number;
+		max: number;
+		count: number;
+	}): MultipleRandomValues;
+	getRandomIntsWithReplacement({ min, max, count }: {
+		min: number;
+		max: number;
+		count: number;
+	}): MultipleRandomValues;
+}
+export declare abstract class RandomNumberGeneratorStub implements RandomNumberGenerator {
+	getRandomInt({}: {
+		min: number;
+		max: number;
+	}): SingleRandomValue;
+	getRandomIntsWithReplacement({}: {
+		min: number;
+		max: number;
+		count: number;
+	}): MultipleRandomValues;
+	getUniqueRandomInts({}: {
+		min: number;
+		max: number;
+		count: number;
+	}): MultipleRandomValues;
+}
+export declare class SingleRandomNumberGeneratorStub extends RandomNumberGeneratorStub {
+	private readonly value;
+	constructor(value: number);
+	getRandomInt(args: {
+		min: number;
+		max: number;
+	}): SingleRandomValue;
+}
+export declare class MultipleRandomNumberGeneratorStub extends RandomNumberGeneratorStub {
+	private readonly values;
+	constructor(values: number[]);
+	getRandomIntsWithReplacement(args: {
+		min: number;
+		max: number;
+		count: number;
+	}): MultipleRandomValues;
+	getUniqueRandomInts(args: {
+		min: number;
+		max: number;
+		count: number;
+	}): MultipleRandomValues;
+}
+
+export {};

package/dist/testing/index.mjs

@@ -0,0 +1 @@
+class n{getRandomInt({}){throw new Error("Not implemented")}getRandomIntsWithReplacement({}){throw new Error("Not implemented")}getUniqueRandomInts({}){throw new Error("Not implemented")}}class r extends n{value;constructor(e){super();this.value=e}getRandomInt(e){return{...e,value:this.value,values:[this.value],count:1,proofHash:"stub-proof-hash",proofString:"stub-proof-string"}}}class t extends n{values;constructor(e){super();this.values=e}getRandomIntsWithReplacement(e){return{...e,values:this.values,proofHash:"stub-proof-hash",proofString:"stub-proof-string"}}getUniqueRandomInts(e){return{...e,values:this.values,proofHash:"stub-proof-hash",proofString:"stub-proof-string"}}}export{r as SingleRandomNumberGeneratorStub,n as RandomNumberGeneratorStub,t as MultipleRandomNumberGeneratorStub};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@betorigami/game-engine",
+  "version": "0.0.0-sha-d6d1f10-20260907014734",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "require": "./dist/testing/index.cjs",
+      "import": "./dist/testing/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "tsc": "tsc",
+    "build": "bun run build.ts",
+    "watch": "bun run --watch src/index.ts",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "bundlemon": "bundlemon --subProject game-engine",
+    "format": "biome format --write"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "^1.0.8",
+    "@types/big.js": "^6.2.2",
+    "@types/bun": "^1.2.17",
+    "bun-plugin-dts": "^0.3.0",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@betorigami/guard": "^2.0.7",
+    "big.js": "^7.0.1",
+    "fast-deep-equal": "^3.1.3"
+  }
+}