@arcanahq/cardgames 1.0.0 → 1.0.1

package/.as-test/output/test.js

@@ -0,0 +1,830 @@
+import * as __import0 from "__unittest_framework_env";
+async function instantiate(module, imports = {}) {
+  const __module0 = imports.__unittest_framework_env;
+  const adaptedImports = {
+    env: Object.assign(Object.create(globalThis), imports.env || {}, {
+      abort(message, fileName, lineNumber, columnNumber) {
+        // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void
+        message = __liftString(message >>> 0);
+        fileName = __liftString(fileName >>> 0);
+        lineNumber = lineNumber >>> 0;
+        columnNumber = columnNumber >>> 0;
+        (() => {
+          // @external.js
+          throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);
+        })();
+      },
+    }),
+    __unittest_framework_env: Object.assign(Object.create(__module0), {
+      collectCheckResult(result, codeInfoIndex, actualValue, expectValue) {
+        // ~lib/assemblyscript-unittest-framework/assembly/env/assertResult.collectCheckResult(bool, f64, ~lib/string/String, ~lib/string/String) => void
+        result = result != 0;
+        actualValue = __liftString(actualValue >>> 0);
+        expectValue = __liftString(expectValue >>> 0);
+        __module0.collectCheckResult(result, codeInfoIndex, actualValue, expectValue);
+      },
+      addDescription(description) {
+        // ~lib/assemblyscript-unittest-framework/assembly/env/assertResult.addDescription(~lib/string/String) => void
+        description = __liftString(description >>> 0);
+        __module0.addDescription(description);
+      },
+      registerTestFunction(index) {
+        // ~lib/assemblyscript-unittest-framework/assembly/env/assertResult.registerTestFunction(u32) => void
+        index = index >>> 0;
+        __module0.registerTestFunction(index);
+      },
+    }),
+  };
+  const { exports } = await WebAssembly.instantiate(module, adaptedImports);
+  const memory = exports.memory || imports.env.memory;
+  const adaptedExports = Object.setPrototypeOf({
+    createStandardDeck() {
+      // assembly/cardgames/createStandardDeck() => ~lib/array/Array<assembly/cards/Card>
+      return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.createStandardDeck() >>> 0);
+    },
+    shuffleDeck(deck, seed) {
+      // assembly/cardgames/shuffleDeck(~lib/array/Array<assembly/cards/Card>, ~lib/@arcanahq/core/assembly/primitives/random/RandomSeed) => ~lib/@arcanahq/core/assembly/primitives/random/RandomSeed
+      deck = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, deck) || __notnull());
+      seed = __lowerInternref(seed) || __notnull();
+      try {
+        return __liftInternref(exports.shuffleDeck(deck, seed) >>> 0);
+      } finally {
+        __release(deck);
+      }
+    },
+    createShuffledDeck(seed) {
+      // assembly/cardgames/createShuffledDeck(~lib/@arcanahq/core/assembly/primitives/random/RandomSeed) => assembly/cardgames/ShuffledDeckResult
+      seed = __lowerInternref(seed) || __notnull();
+      return __liftInternref(exports.createShuffledDeck(seed) >>> 0);
+    },
+    dealCard(deck) {
+      // assembly/cardgames/dealCard(~lib/array/Array<assembly/cards/Card>) => assembly/cards/Card | null
+      deck = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, deck) || __notnull();
+      return __liftInternref(exports.dealCard(deck) >>> 0);
+    },
+    dealCards(deck, count) {
+      // assembly/cardgames/dealCards(~lib/array/Array<assembly/cards/Card>, i32) => ~lib/array/Array<assembly/cards/Card>
+      deck = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, deck) || __notnull();
+      return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.dealCards(deck, count) >>> 0);
+    },
+    dealCardFromDeck(deck, seed) {
+      // assembly/cardgames/dealCardFromDeck(~lib/array/Array<assembly/cards/Card>, ~lib/@arcanahq/core/assembly/primitives/random/RandomSeed) => assembly/cardgames/DealCardResult
+      deck = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, deck) || __notnull());
+      seed = __lowerInternref(seed) || __notnull();
+      try {
+        return __liftInternref(exports.dealCardFromDeck(deck, seed) >>> 0);
+      } finally {
+        __release(deck);
+      }
+    },
+    getDeckSize(deck) {
+      // assembly/cardgames/getDeckSize(~lib/array/Array<assembly/cards/Card>) => i32
+      deck = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, deck) || __notnull();
+      return exports.getDeckSize(deck);
+    },
+    isDeckEmpty(deck) {
+      // assembly/cardgames/isDeckEmpty(~lib/array/Array<assembly/cards/Card>) => bool
+      deck = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, deck) || __notnull();
+      return exports.isDeckEmpty(deck) != 0;
+    },
+    cloneDeck(deck) {
+      // assembly/cardgames/cloneDeck(~lib/array/Array<assembly/cards/Card>) => ~lib/array/Array<assembly/cards/Card>
+      deck = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, deck) || __notnull();
+      return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.cloneDeck(deck) >>> 0);
+    },
+    cardToInt(card) {
+      // assembly/cardgames/cardToInt(assembly/cards/Card) => i32
+      card = __lowerInternref(card) || __notnull();
+      return exports.cardToInt(card);
+    },
+    intToCard(value) {
+      // assembly/cardgames/intToCard(i32) => assembly/cards/Card | null
+      return __liftInternref(exports.intToCard(value) >>> 0);
+    },
+    deckToIntArray(deck) {
+      // assembly/cardgames/deckToIntArray(~lib/array/Array<assembly/cards/Card>) => ~lib/array/Array<i32>
+      deck = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, deck) || __notnull();
+      return __liftArray(__getI32, 2, exports.deckToIntArray(deck) >>> 0);
+    },
+    intArrayToDeck(ints) {
+      // assembly/cardgames/intArrayToDeck(~lib/array/Array<i32>) => ~lib/array/Array<assembly/cards/Card>
+      ints = __lowerArray(__setU32, 11, 2, ints) || __notnull();
+      return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.intArrayToDeck(ints) >>> 0);
+    },
+    evaluateHand(holeCards, community) {
+      // assembly/poker/evaluateHand(~lib/array/Array<assembly/cards/Card>, ~lib/array/Array<assembly/cards/Card>) => assembly/cards/HandRank
+      holeCards = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, holeCards) || __notnull());
+      community = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, community) || __notnull();
+      try {
+        return __liftInternref(exports.evaluateHand(holeCards, community) >>> 0);
+      } finally {
+        __release(holeCards);
+      }
+    },
+    compareHands(hand1, hand2) {
+      // assembly/poker/compareHands(assembly/cards/HandRank, assembly/cards/HandRank) => i32
+      hand1 = __retain(__lowerInternref(hand1) || __notnull());
+      hand2 = __lowerInternref(hand2) || __notnull();
+      try {
+        return exports.compareHands(hand1, hand2);
+      } finally {
+        __release(hand1);
+      }
+    },
+    getBestFiveCards(holeCards, community) {
+      // assembly/poker/getBestFiveCards(~lib/array/Array<assembly/cards/Card>, ~lib/array/Array<assembly/cards/Card>) => ~lib/array/Array<assembly/cards/Card>
+      holeCards = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, holeCards) || __notnull());
+      community = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, community) || __notnull();
+      try {
+        return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.getBestFiveCards(holeCards, community) >>> 0);
+      } finally {
+        __release(holeCards);
+      }
+    },
+    getBlackjackCardValue(card) {
+      // assembly/blackjack/blackjack/getBlackjackCardValue(assembly/cards/Card) => i32
+      card = __lowerInternref(card) || __notnull();
+      return exports.getBlackjackCardValue(card);
+    },
+    calculateBlackjackHandValue(cards) {
+      // assembly/blackjack/blackjack/calculateBlackjackHandValue(~lib/array/Array<assembly/cards/Card>) => i32
+      cards = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, cards) || __notnull();
+      return exports.calculateBlackjackHandValue(cards);
+    },
+    isBlackjack(cards) {
+      // assembly/blackjack/blackjack/isBlackjack(~lib/array/Array<assembly/cards/Card>) => bool
+      cards = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, cards) || __notnull();
+      return exports.isBlackjack(cards) != 0;
+    },
+    isBusted(cards) {
+      // assembly/blackjack/blackjack/isBusted(~lib/array/Array<assembly/cards/Card>) => bool
+      cards = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, cards) || __notnull();
+      return exports.isBusted(cards) != 0;
+    },
+    canSplitCards(cards) {
+      // assembly/blackjack/blackjack/canSplitCards(~lib/array/Array<assembly/cards/Card>) => bool
+      cards = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, cards) || __notnull();
+      return exports.canSplitCards(cards) != 0;
+    },
+    isSoftHand(cards) {
+      // assembly/blackjack/blackjack/isSoftHand(~lib/array/Array<assembly/cards/Card>) => bool
+      cards = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, cards) || __notnull();
+      return exports.isSoftHand(cards) != 0;
+    },
+    dealerShouldHit(cards, rules) {
+      // assembly/blackjack/blackjack/dealerShouldHit(~lib/array/Array<assembly/cards/Card>, assembly/blackjack/blackjack/BlackjackRules) => bool
+      cards = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 6, 2, cards) || __notnull());
+      rules = __lowerInternref(rules) || __notnull();
+      try {
+        return exports.dealerShouldHit(cards, rules) != 0;
+      } finally {
+        __release(cards);
+      }
+    },
+    evaluatePairPlus(card1, card2) {
+      // assembly/blackjack/blackjack/evaluatePairPlus(assembly/cards/Card, assembly/cards/Card) => assembly/blackjack/blackjack/PairPlusResult
+      card1 = __retain(__lowerInternref(card1) || __notnull());
+      card2 = __lowerInternref(card2) || __notnull();
+      try {
+        return __liftRecord18(exports.evaluatePairPlus(card1, card2) >>> 0);
+      } finally {
+        __release(card1);
+      }
+    },
+    evaluateTwentyOnePlusThree(card1, card2, card3) {
+      // assembly/blackjack/blackjack/evaluateTwentyOnePlusThree(assembly/cards/Card, assembly/cards/Card, assembly/cards/Card) => assembly/blackjack/blackjack/TwentyOnePlusThreeResult
+      card1 = __retain(__lowerInternref(card1) || __notnull());
+      card2 = __retain(__lowerInternref(card2) || __notnull());
+      card3 = __lowerInternref(card3) || __notnull();
+      try {
+        return __liftRecord19(exports.evaluateTwentyOnePlusThree(card1, card2, card3) >>> 0);
+      } finally {
+        __release(card1);
+        __release(card2);
+      }
+    },
+    calculateAvailableActions(handCardsLength, handIsFromSplit, handIsSplitAces, handIsStanding, handIsBusted, gamePhase, playerHandsCount, canSplit, rules) {
+      // assembly/blackjack/actions/calculateAvailableActions(i32, bool, bool, bool, bool, ~lib/string/String, i32, bool, assembly/blackjack/blackjack/BlackjackRules) => assembly/blackjack/actions/AvailableActions
+      handIsFromSplit = handIsFromSplit ? 1 : 0;
+      handIsSplitAces = handIsSplitAces ? 1 : 0;
+      handIsStanding = handIsStanding ? 1 : 0;
+      handIsBusted = handIsBusted ? 1 : 0;
+      gamePhase = __retain(__lowerString(gamePhase) || __notnull());
+      canSplit = canSplit ? 1 : 0;
+      rules = __lowerInternref(rules) || __notnull();
+      try {
+        return __liftRecord20(exports.calculateAvailableActions(handCardsLength, handIsFromSplit, handIsSplitAces, handIsStanding, handIsBusted, gamePhase, playerHandsCount, canSplit, rules) >>> 0);
+      } finally {
+        __release(gamePhase);
+      }
+    },
+    shouldDealerHit(handValue, dealerStandValue, hitOnSoft17, isSoftHand) {
+      // assembly/blackjack/actions/shouldDealerHit(i32, i32, bool, bool) => bool
+      hitOnSoft17 = hitOnSoft17 ? 1 : 0;
+      isSoftHand = isSoftHand ? 1 : 0;
+      return exports.shouldDealerHit(handValue, dealerStandValue, hitOnSoft17, isSoftHand) != 0;
+    },
+    validateActionPhase(gamePhase, action, requiredPhase) {
+      // assembly/blackjack/actions/validateActionPhase(~lib/string/String, ~lib/string/String, ~lib/string/String) => void
+      gamePhase = __retain(__lowerString(gamePhase) || __notnull());
+      action = __retain(__lowerString(action) || __notnull());
+      requiredPhase = __lowerString(requiredPhase) || __notnull();
+      try {
+        exports.validateActionPhase(gamePhase, action, requiredPhase);
+      } finally {
+        __release(gamePhase);
+        __release(action);
+      }
+    },
+    validateCanHit(handIsStanding, handIsBusted, handIsSplitAces) {
+      // assembly/blackjack/actions/validateCanHit(bool, bool, bool) => void
+      handIsStanding = handIsStanding ? 1 : 0;
+      handIsBusted = handIsBusted ? 1 : 0;
+      handIsSplitAces = handIsSplitAces ? 1 : 0;
+      exports.validateCanHit(handIsStanding, handIsBusted, handIsSplitAces);
+    },
+    validateCanStand(handIsStanding, handIsBusted) {
+      // assembly/blackjack/actions/validateCanStand(bool, bool) => void
+      handIsStanding = handIsStanding ? 1 : 0;
+      handIsBusted = handIsBusted ? 1 : 0;
+      exports.validateCanStand(handIsStanding, handIsBusted);
+    },
+    validateCanDouble(handCardsLength, handIsSplitAces, handIsFromSplit, rules) {
+      // assembly/blackjack/actions/validateCanDouble(i32, bool, bool, assembly/blackjack/blackjack/BlackjackRules) => void
+      handIsSplitAces = handIsSplitAces ? 1 : 0;
+      handIsFromSplit = handIsFromSplit ? 1 : 0;
+      rules = __lowerInternref(rules) || __notnull();
+      exports.validateCanDouble(handCardsLength, handIsSplitAces, handIsFromSplit, rules);
+    },
+    validateCanSplit(handCardsLength, playerHandsCount, canSplit, rules) {
+      // assembly/blackjack/actions/validateCanSplit(i32, i32, bool, assembly/blackjack/blackjack/BlackjackRules) => void
+      canSplit = canSplit ? 1 : 0;
+      rules = __lowerInternref(rules) || __notnull();
+      exports.validateCanSplit(handCardsLength, playerHandsCount, canSplit, rules);
+    },
+    validateCanSurrender(handCardsLength, handIsFromSplit, rules) {
+      // assembly/blackjack/actions/validateCanSurrender(i32, bool, assembly/blackjack/blackjack/BlackjackRules) => void
+      handIsFromSplit = handIsFromSplit ? 1 : 0;
+      rules = __lowerInternref(rules) || __notnull();
+      exports.validateCanSurrender(handCardsLength, handIsFromSplit, rules);
+    },
+    shouldOfferInsurance(dealerUpCardRank, rules) {
+      // assembly/blackjack/actions/shouldOfferInsurance(~lib/string/String, assembly/blackjack/blackjack/BlackjackRules) => bool
+      dealerUpCardRank = __retain(__lowerString(dealerUpCardRank) || __notnull());
+      rules = __lowerInternref(rules) || __notnull();
+      try {
+        return exports.shouldOfferInsurance(dealerUpCardRank, rules) != 0;
+      } finally {
+        __release(dealerUpCardRank);
+      }
+    },
+    validateBuyInAmount(amount, minBuyIn, maxBuyIn) {
+      // assembly/cashgames/cash_game_utils/validateBuyInAmount(~lib/string/String, ~lib/string/String, ~lib/string/String) => bool
+      amount = __retain(__lowerString(amount) || __notnull());
+      minBuyIn = __retain(__lowerString(minBuyIn) || __notnull());
+      maxBuyIn = __lowerString(maxBuyIn) || __notnull();
+      try {
+        return exports.validateBuyInAmount(amount, minBuyIn, maxBuyIn) != 0;
+      } finally {
+        __release(amount);
+        __release(minBuyIn);
+      }
+    },
+    calculateRake(potAmount, rakePercentage, rakeCap) {
+      // assembly/cashgames/cash_game_utils/calculateRake(i64, f64, i64) => i64
+      potAmount = potAmount || 0n;
+      rakeCap = rakeCap || 0n;
+      return exports.calculateRake(potAmount, rakePercentage, rakeCap);
+    },
+    calculateRakeString(potAmount, rakePercentage, rakeCap) {
+      // assembly/cashgames/cash_game_utils/calculateRakeString(~lib/string/String, f64, ~lib/string/String) => ~lib/string/String
+      potAmount = __retain(__lowerString(potAmount) || __notnull());
+      rakeCap = __lowerString(rakeCap) || __notnull();
+      try {
+        return __liftString(exports.calculateRakeString(potAmount, rakePercentage, rakeCap) >>> 0);
+      } finally {
+        __release(potAmount);
+      }
+    },
+    canRebuy(seat, gamePhase, rebuyAllowed, cooldownMs, nowMs) {
+      // assembly/cashgames/cash_game_utils/canRebuy(assembly/cashgames/cash_game_types/CashGameSeatBase, ~lib/string/String, bool, i64, i64) => bool
+      seat = __retain(__lowerInternref(seat) || __notnull());
+      gamePhase = __lowerString(gamePhase) || __notnull();
+      rebuyAllowed = rebuyAllowed ? 1 : 0;
+      cooldownMs = cooldownMs || 0n;
+      nowMs = nowMs || 0n;
+      try {
+        return exports.canRebuy(seat, gamePhase, rebuyAllowed, cooldownMs, nowMs) != 0;
+      } finally {
+        __release(seat);
+      }
+    },
+    canTopUp(seat, topUpAmount, maxBuyIn, gamePhase) {
+      // assembly/cashgames/cash_game_utils/canTopUp(assembly/cashgames/cash_game_types/CashGameSeatBase, ~lib/string/String, ~lib/string/String, ~lib/string/String) => bool
+      seat = __retain(__lowerInternref(seat) || __notnull());
+      topUpAmount = __retain(__lowerString(topUpAmount) || __notnull());
+      maxBuyIn = __retain(__lowerString(maxBuyIn) || __notnull());
+      gamePhase = __lowerString(gamePhase) || __notnull();
+      try {
+        return exports.canTopUp(seat, topUpAmount, maxBuyIn, gamePhase) != 0;
+      } finally {
+        __release(seat);
+        __release(topUpAmount);
+        __release(maxBuyIn);
+      }
+    },
+    initializeCashGameSeats(maxSeats) {
+      // assembly/cashgames/cash_game_utils/initializeCashGameSeats(i32) => ~lib/array/Array<assembly/cashgames/cash_game_types/CashGameSeatBase>
+      return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.initializeCashGameSeats(maxSeats) >>> 0);
+    },
+    deterministicShuffleIndices(indices, shuffleId, shuffleSalt, seedIndex) {
+      // assembly/deck/deck/deterministicShuffleIndices(~lib/array/Array<i32>, ~lib/string/String, ~lib/string/String, i32) => ~lib/array/Array<i32>
+      indices = __retain(__lowerArray(__setU32, 11, 2, indices) || __notnull());
+      shuffleId = __retain(__lowerString(shuffleId) || __notnull());
+      shuffleSalt = __lowerString(shuffleSalt) || __notnull();
+      try {
+        return __liftArray(__getI32, 2, exports.deterministicShuffleIndices(indices, shuffleId, shuffleSalt, seedIndex) >>> 0);
+      } finally {
+        __release(indices);
+        __release(shuffleId);
+      }
+    },
+    dealCardByIndex(shuffleId, shuffleSalt, dealtCardCount, config) {
+      // assembly/deck/deck/dealCardByIndex(~lib/string/String, ~lib/string/String, i32, assembly/deck/deck/DeckConfig) => assembly/cards/Card
+      shuffleId = __retain(__lowerString(shuffleId) || __notnull());
+      shuffleSalt = __retain(__lowerString(shuffleSalt) || __notnull());
+      config = __lowerRecord27(config) || __notnull();
+      try {
+        return __liftInternref(exports.dealCardByIndex(shuffleId, shuffleSalt, dealtCardCount, config) >>> 0);
+      } finally {
+        __release(shuffleId);
+        __release(shuffleSalt);
+      }
+    },
+    dealCardFromShoe(shuffleId, shuffleSalt, shoePosition, shoeConfig) {
+      // assembly/deck/deck/dealCardFromShoe(~lib/string/String, ~lib/string/String, i32, assembly/deck/deck/ShoeConfig) => assembly/cards/Card
+      shuffleId = __retain(__lowerString(shuffleId) || __notnull());
+      shuffleSalt = __retain(__lowerString(shuffleSalt) || __notnull());
+      shoeConfig = __lowerInternref(shoeConfig) || __notnull();
+      try {
+        return __liftInternref(exports.dealCardFromShoe(shuffleId, shuffleSalt, shoePosition, shoeConfig) >>> 0);
+      } finally {
+        __release(shuffleId);
+        __release(shuffleSalt);
+      }
+    },
+    getShuffledShoeIndices(shuffleId, shuffleSalt, shoeIteration, shoeConfig) {
+      // assembly/deck/deck/getShuffledShoeIndices(~lib/string/String, ~lib/string/String, i32, assembly/deck/deck/ShoeConfig) => ~lib/array/Array<i32>
+      shuffleId = __retain(__lowerString(shuffleId) || __notnull());
+      shuffleSalt = __retain(__lowerString(shuffleSalt) || __notnull());
+      shoeConfig = __lowerInternref(shoeConfig) || __notnull();
+      try {
+        return __liftArray(__getI32, 2, exports.getShuffledShoeIndices(shuffleId, shuffleSalt, shoeIteration, shoeConfig) >>> 0);
+      } finally {
+        __release(shuffleId);
+        __release(shuffleSalt);
+      }
+    },
+    dealCardsFromShoe(shuffleId, shuffleSalt, shoePosition, count, shoeConfig) {
+      // assembly/deck/deck/dealCardsFromShoe(~lib/string/String, ~lib/string/String, i32, i32, assembly/deck/deck/ShoeConfig) => ~lib/array/Array<assembly/cards/Card>
+      shuffleId = __retain(__lowerString(shuffleId) || __notnull());
+      shuffleSalt = __retain(__lowerString(shuffleSalt) || __notnull());
+      shoeConfig = __lowerInternref(shoeConfig) || __notnull();
+      try {
+        return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.dealCardsFromShoe(shuffleId, shuffleSalt, shoePosition, count, shoeConfig) >>> 0);
+      } finally {
+        __release(shuffleId);
+        __release(shuffleSalt);
+      }
+    },
+    createShuffledDeck(shuffleId, shuffleSalt, seedIndex, config) {
+      // assembly/deck/deck/createShuffledDeck(~lib/string/String, ~lib/string/String, i32, assembly/deck/deck/DeckConfig) => ~lib/array/Array<assembly/cards/Card>
+      shuffleId = __retain(__lowerString(shuffleId) || __notnull());
+      shuffleSalt = __retain(__lowerString(shuffleSalt) || __notnull());
+      config = __lowerRecord27(config) || __notnull();
+      try {
+        return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.createShuffledDeck(shuffleId, shuffleSalt, seedIndex, config) >>> 0);
+      } finally {
+        __release(shuffleId);
+        __release(shuffleSalt);
+      }
+    },
+    getShuffledIndices(shuffleId, shuffleSalt, seedIndex, config) {
+      // assembly/deck/deck/getShuffledIndices(~lib/string/String, ~lib/string/String, i32, assembly/deck/deck/DeckConfig) => ~lib/array/Array<i32>
+      shuffleId = __retain(__lowerString(shuffleId) || __notnull());
+      shuffleSalt = __retain(__lowerString(shuffleSalt) || __notnull());
+      config = __lowerRecord27(config) || __notnull();
+      try {
+        return __liftArray(__getI32, 2, exports.getShuffledIndices(shuffleId, shuffleSalt, seedIndex, config) >>> 0);
+      } finally {
+        __release(shuffleId);
+        __release(shuffleSalt);
+      }
+    },
+    dealCards(shuffleId, shuffleSalt, dealtCardCount, count, config) {
+      // assembly/deck/deck/dealCards(~lib/string/String, ~lib/string/String, i32, i32, assembly/deck/deck/DeckConfig) => ~lib/array/Array<assembly/cards/Card>
+      shuffleId = __retain(__lowerString(shuffleId) || __notnull());
+      shuffleSalt = __retain(__lowerString(shuffleSalt) || __notnull());
+      config = __lowerRecord27(config) || __notnull();
+      try {
+        return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.dealCards(shuffleId, shuffleSalt, dealtCardCount, count, config) >>> 0);
+      } finally {
+        __release(shuffleId);
+        __release(shuffleSalt);
+      }
+    },
+    createUnshuffledDeck(config) {
+      // assembly/deck/deck/createUnshuffledDeck(assembly/deck/deck/DeckConfig) => ~lib/array/Array<assembly/cards/Card>
+      config = __lowerRecord27(config) || __notnull();
+      return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.createUnshuffledDeck(config) >>> 0);
+    },
+    calculatePokerRake(potAmount, rakeConfig) {
+      // assembly/poker/poker_game_utils/calculatePokerRake(i64, assembly/poker/poker_game_types/PokerRakeConfig) => i64
+      potAmount = potAmount || 0n;
+      rakeConfig = __lowerInternref(rakeConfig) || __notnull();
+      return exports.calculatePokerRake(potAmount, rakeConfig);
+    },
+    calculateRakeSimple(potAmount, rakePercentage, rakeCap) {
+      // assembly/poker/poker_game_utils/calculateRakeSimple(i64, f64, i64) => i64
+      potAmount = potAmount || 0n;
+      rakeCap = rakeCap || 0n;
+      return exports.calculateRakeSimple(potAmount, rakePercentage, rakeCap);
+    },
+    constructSidePots(contributions, startPotId) {
+      // assembly/poker/poker_game_utils/constructSidePots(~lib/map/Map<i32,i64>, i32?) => ~lib/array/Array<assembly/poker/poker_game_types/Pot>
+      contributions = __lowerInternref(contributions) || __notnull();
+      exports.__setArgumentsLength(arguments.length);
+      return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.constructSidePots(contributions, startPotId) >>> 0);
+    },
+    splitPotForRuns(pot, runCount) {
+      // assembly/poker/poker_game_utils/splitPotForRuns(assembly/poker/poker_game_types/Pot, i32) => assembly/poker/poker_game_types/Pot
+      pot = __lowerInternref(pot) || __notnull();
+      return __liftInternref(exports.splitPotForRuns(pot, runCount) >>> 0);
+    },
+    splitAllPotsForRuns(pots, runCount) {
+      // assembly/poker/poker_game_utils/splitAllPotsForRuns(~lib/array/Array<assembly/poker/poker_game_types/Pot>, i32) => ~lib/array/Array<assembly/poker/poker_game_types/Pot>
+      pots = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 33, 2, pots) || __notnull();
+      return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.splitAllPotsForRuns(pots, runCount) >>> 0);
+    },
+    calculateOddChips(amount, numWinners, winners, buttonSeatId) {
+      // assembly/poker/poker_game_utils/calculateOddChips(i64, i32, ~lib/array/Array<i32>, i32) => ~lib/array/Array<i64>
+      amount = amount || 0n;
+      winners = __lowerArray(__setU32, 11, 2, winners) || __notnull();
+      return __liftArray(__getI64, 3, exports.calculateOddChips(amount, numWinners, winners, buttonSeatId) >>> 0);
+    },
+    distributePot(pot, winners, runIndex, buttonSeatId, rakeConfig) {
+      // assembly/poker/poker_game_utils/distributePot(assembly/poker/poker_game_types/Pot, ~lib/array/Array<i32>, i32, i32, assembly/poker/poker_game_types/PokerRakeConfig) => assembly/poker/poker_game_types/PotDistributionResult
+      pot = __retain(__lowerInternref(pot) || __notnull());
+      winners = __retain(__lowerArray(__setU32, 11, 2, winners) || __notnull());
+      rakeConfig = __lowerInternref(rakeConfig) || __notnull();
+      try {
+        return __liftInternref(exports.distributePot(pot, winners, runIndex, buttonSeatId, rakeConfig) >>> 0);
+      } finally {
+        __release(pot);
+        __release(winners);
+      }
+    },
+    distributePotSimple(pot, winners, runIndex, buttonSeatId, rakePercentage, rakeCap) {
+      // assembly/poker/poker_game_utils/distributePotSimple(assembly/poker/poker_game_types/Pot, ~lib/array/Array<i32>, i32, i32, f64?, i64?) => assembly/poker/poker_game_types/PotDistributionResult
+      pot = __retain(__lowerInternref(pot) || __notnull());
+      winners = __lowerArray(__setU32, 11, 2, winners) || __notnull();
+      rakeCap = rakeCap || 0n;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        return __liftInternref(exports.distributePotSimple(pot, winners, runIndex, buttonSeatId, rakePercentage, rakeCap) >>> 0);
+      } finally {
+        __release(pot);
+      }
+    },
+    lockPots(pots) {
+      // assembly/poker/poker_game_utils/lockPots(~lib/array/Array<assembly/poker/poker_game_types/Pot>) => ~lib/array/Array<assembly/poker/poker_game_types/Pot>
+      pots = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 33, 2, pots) || __notnull();
+      return __liftArray(pointer => __liftInternref(__getU32(pointer)), 2, exports.lockPots(pots) >>> 0);
+    },
+    getTotalPotAmount(pots) {
+      // assembly/poker/poker_game_utils/getTotalPotAmount(~lib/array/Array<assembly/poker/poker_game_types/Pot>) => i64
+      pots = __lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 33, 2, pots) || __notnull();
+      return exports.getTotalPotAmount(pots);
+    },
+    calculateAnteAmount(stakes, anteType, antePercentage) {
+      // assembly/poker/poker_game_utils/calculateAnteAmount(assembly/poker/poker_game_types/Stakes, ~lib/string/String, f64?) => i64
+      stakes = __retain(__lowerInternref(stakes) || __notnull());
+      anteType = __lowerString(anteType) || __notnull();
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        return exports.calculateAnteAmount(stakes, anteType, antePercentage);
+      } finally {
+        __release(stakes);
+      }
+    },
+    postAntes(seats, stakes, anteType, antePercentage, bettingState) {
+      // assembly/poker/poker_game_utils/postAntes(~lib/array/Array<assembly/poker/poker_game_types/PokerSeatBase>, assembly/poker/poker_game_types/Stakes, ~lib/string/String, f64, assembly/poker/poker_game_types/BettingRoundState) => assembly/poker/poker_game_utils/PostAntesResult
+      seats = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 38, 2, seats) || __notnull());
+      stakes = __retain(__lowerInternref(stakes) || __notnull());
+      anteType = __retain(__lowerString(anteType) || __notnull());
+      bettingState = __lowerInternref(bettingState) || __notnull();
+      try {
+        return __liftInternref(exports.postAntes(seats, stakes, anteType, antePercentage, bettingState) >>> 0);
+      } finally {
+        __release(seats);
+        __release(stakes);
+        __release(anteType);
+      }
+    },
+    postBlinds(seats, stakes, sbSeatId, bbSeatId, bettingState) {
+      // assembly/poker/poker_game_utils/postBlinds(~lib/array/Array<assembly/poker/poker_game_types/PokerSeatBase>, assembly/poker/poker_game_types/Stakes, i32, i32, assembly/poker/poker_game_types/BettingRoundState) => assembly/poker/poker_game_utils/PostBlindsResult
+      seats = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 38, 2, seats) || __notnull());
+      stakes = __retain(__lowerInternref(stakes) || __notnull());
+      bettingState = __lowerInternref(bettingState) || __notnull();
+      try {
+        return __liftInternref(exports.postBlinds(seats, stakes, sbSeatId, bbSeatId, bettingState) >>> 0);
+      } finally {
+        __release(seats);
+        __release(stakes);
+      }
+    },
+    getNextActingSeat(seats, buttonSeatId, isPreflop, bettingState) {
+      // assembly/poker/poker_game_utils/getNextActingSeat(~lib/array/Array<assembly/poker/poker_game_types/PokerSeatBase>, i32, bool, assembly/poker/poker_game_types/BettingRoundState) => i32
+      seats = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 38, 2, seats) || __notnull());
+      isPreflop = isPreflop ? 1 : 0;
+      bettingState = __lowerInternref(bettingState) || __notnull();
+      try {
+        return exports.getNextActingSeat(seats, buttonSeatId, isPreflop, bettingState);
+      } finally {
+        __release(seats);
+      }
+    },
+    validateBuyIn(buyInAmount, minBuyIn, maxBuyIn) {
+      // assembly/poker/poker_game_utils/validateBuyIn(i64, i64, i64) => bool
+      buyInAmount = buyInAmount || 0n;
+      minBuyIn = minBuyIn || 0n;
+      maxBuyIn = maxBuyIn || 0n;
+      return exports.validateBuyIn(buyInAmount, minBuyIn, maxBuyIn) != 0;
+    },
+    processBuyIn(seat, buyInAmount, minBuyIn, maxBuyIn) {
+      // assembly/poker/poker_game_utils/processBuyIn(assembly/poker/poker_game_types/PokerSeatBase, i64, i64, i64) => assembly/poker/poker_game_types/PokerSeatBase | null
+      seat = __lowerInternref(seat) || __notnull();
+      buyInAmount = buyInAmount || 0n;
+      minBuyIn = minBuyIn || 0n;
+      maxBuyIn = maxBuyIn || 0n;
+      return __liftInternref(exports.processBuyIn(seat, buyInAmount, minBuyIn, maxBuyIn) >>> 0);
+    },
+    isBettingRoundComplete(seats, bettingState) {
+      // assembly/poker/poker_game_utils/isBettingRoundComplete(~lib/array/Array<assembly/poker/poker_game_types/PokerSeatBase>, assembly/poker/poker_game_types/BettingRoundState) => bool
+      seats = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerInternref(value) || __notnull()); }, 38, 2, seats) || __notnull());
+      bettingState = __lowerInternref(bettingState) || __notnull();
+      try {
+        return exports.isBettingRoundComplete(seats, bettingState) != 0;
+      } finally {
+        __release(seats);
+      }
+    },
+  }, exports);
+  function __liftRecord18(pointer) {
+    // assembly/blackjack/blackjack/PairPlusResult
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      hasPair: __getU8(pointer + 0) != 0,
+      pairType: __liftString(__getU32(pointer + 4)),
+      payoutMultiplier: __getI32(pointer + 8),
+    };
+  }
+  function __liftRecord19(pointer) {
+    // assembly/blackjack/blackjack/TwentyOnePlusThreeResult
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      hasMatch: __getU8(pointer + 0) != 0,
+      handType: __liftString(__getU32(pointer + 4)),
+      payoutMultiplier: __getI32(pointer + 8),
+    };
+  }
+  function __liftRecord20(pointer) {
+    // assembly/blackjack/actions/AvailableActions
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      canStand: __getU8(pointer + 0) != 0,
+      canDouble: __getU8(pointer + 1) != 0,
+      canSplit: __getU8(pointer + 2) != 0,
+      canSurrender: __getU8(pointer + 3) != 0,
+    };
+  }
+  function __lowerRecord27(value) {
+    // assembly/deck/deck/DeckConfig
+    // Hint: Opt-out from lowering as a record by providing an empty constructor
+    if (value == null) return 0;
+    const pointer = exports.__pin(exports.__new(0, 27));
+    exports.__unpin(pointer);
+    return pointer;
+  }
+  function __liftString(pointer) {
+    if (!pointer) return null;
+    const
+      end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1,
+      memoryU16 = new Uint16Array(memory.buffer);
+    let
+      start = pointer >>> 1,
+      string = "";
+    while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+    return string + String.fromCharCode(...memoryU16.subarray(start, end));
+  }
+  function __lowerString(value) {
+    if (value == null) return 0;
+    const
+      length = value.length,
+      pointer = exports.__new(length << 1, 2) >>> 0,
+      memoryU16 = new Uint16Array(memory.buffer);
+    for (let i = 0; i < length; ++i) memoryU16[(pointer >>> 1) + i] = value.charCodeAt(i);
+    return pointer;
+  }
+  function __liftArray(liftElement, align, pointer) {
+    if (!pointer) return null;
+    const
+      dataStart = __getU32(pointer + 4),
+      length = __dataview.getUint32(pointer + 12, true),
+      values = new Array(length);
+    for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0));
+    return values;
+  }
+  function __lowerArray(lowerElement, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__pin(exports.__new(16, id)) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    __dataview.setUint32(header + 12, length, true);
+    for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]);
+    exports.__unpin(buffer);
+    exports.__unpin(header);
+    return header;
+  }
+  class Internref extends Number {}
+  const registry = new FinalizationRegistry(__release);
+  function __liftInternref(pointer) {
+    if (!pointer) return null;
+    const sentinel = new Internref(__retain(pointer));
+    registry.register(sentinel, pointer);
+    return sentinel;
+  }
+  function __lowerInternref(value) {
+    if (value == null) return 0;
+    if (value instanceof Internref) return value.valueOf();
+    throw TypeError("internref expected");
+  }
+  const refcounts = new Map();
+  function __retain(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount) refcounts.set(pointer, refcount + 1);
+      else refcounts.set(exports.__pin(pointer), 1);
+    }
+    return pointer;
+  }
+  function __release(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer);
+      else if (refcount) refcounts.set(pointer, refcount - 1);
+      else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`);
+    }
+  }
+  function __notnull() {
+    throw TypeError("value must not be null");
+  }
+  let __dataview = new DataView(memory.buffer);
+  function __setU32(pointer, value) {
+    try {
+      __dataview.setUint32(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint32(pointer, value, true);
+    }
+  }
+  function __getU8(pointer) {
+    try {
+      return __dataview.getUint8(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint8(pointer, true);
+    }
+  }
+  function __getI32(pointer) {
+    try {
+      return __dataview.getInt32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getInt32(pointer, true);
+    }
+  }
+  function __getU32(pointer) {
+    try {
+      return __dataview.getUint32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint32(pointer, true);
+    }
+  }
+  function __getI64(pointer) {
+    try {
+      return __dataview.getBigInt64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getBigInt64(pointer, true);
+    }
+  }
+  exports.__unit_test_start();
+  return adaptedExports;
+}
+export const {
+  memory,
+  __new,
+  __pin,
+  __unpin,
+  __collect,
+  __rtti_base,
+  createStandardDeck,
+  shuffleDeck,
+  createShuffledDeck,
+  dealCard,
+  dealCards,
+  dealCardFromDeck,
+  getDeckSize,
+  isDeckEmpty,
+  cloneDeck,
+  cardToInt,
+  intToCard,
+  deckToIntArray,
+  intArrayToDeck,
+  evaluateHand,
+  compareHands,
+  getBestFiveCards,
+  getBlackjackCardValue,
+  calculateBlackjackHandValue,
+  isBlackjack,
+  isBusted,
+  canSplitCards,
+  isSoftHand,
+  dealerShouldHit,
+  evaluatePairPlus,
+  evaluateTwentyOnePlusThree,
+  calculateAvailableActions,
+  shouldDealerHit,
+  validateActionPhase,
+  validateActiveHand,
+  validateCanHit,
+  validateCanStand,
+  validateCanDouble,
+  validateCanSplit,
+  validateCanSurrender,
+  shouldOfferInsurance,
+  validateBuyInAmount,
+  calculateRake,
+  calculateRakeString,
+  canRebuy,
+  canTopUp,
+  initializeCashGameSeats,
+  deterministicShuffleIndices,
+  dealCardByIndex,
+  dealCardFromShoe,
+  getShuffledShoeIndices,
+  dealCardsFromShoe,
+  createShuffledDeck,
+  getShuffledIndices,
+  dealCards,
+  createUnshuffledDeck,
+  calculatePokerRake,
+  calculateRakeSimple,
+  constructSidePots,
+  splitPotForRuns,
+  splitAllPotsForRuns,
+  calculateOddChips,
+  distributePot,
+  distributePotSimple,
+  lockPots,
+  getTotalPotAmount,
+  calculateAnteAmount,
+  postAntes,
+  postBlinds,
+  getNextActingSeat,
+  validateBuyIn,
+  processBuyIn,
+  isBettingRoundComplete,
+} = await (async url => instantiate(
+  await (async () => {
+    const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null);
+    if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); }
+    else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); }
+  })(), {
+    __unittest_framework_env: __maybeDefault(__import0),
+  }
+))(new URL("test.wasm", import.meta.url));
+function __maybeDefault(module) {
+  return typeof module.default === "object" && Object.keys(module).length == 1
+    ? module.default
+    : module;
+}