jaml-ui 0.14.4 → 0.17.0

package/dist/decode/motelyItemDecoder.js

@@ -1,290 +1,145 @@
 /**
- * Motely item decoder.
- *
- * MotelyItem.Value is a packed integer. The MotelyItemType enum
- * uses packed integers where the top nibble encodes category:
- *   0x1000 = Standardcard, 0x2000 = Spectral, 0x3000 = Tarot,
- *   0x4000 = Planet, 0x5000 = Joker, 0xF000 = Invalid
+ * Motely item decoder — thin wrapper over motely-wasm runtime enums.
+ * No hand-rolled bitmask tables. The WASM enum IS the source of truth.
  */
 import { Motely } from "motely-wasm";
-import { getItemCategory, getItemDisplayName } from "../utils/itemUtils.js";
-// ─── Category from MotelyItemType integer ────────────────────────────────────
-const CATEGORY_MASK = 0xf000;
-const VALUE_TYPE_MASK = 0xffff;
-const VALUE_SEAL_MASK = 0x70000;
-const VALUE_ENHANCEMENT_MASK = 0x780000;
-const VALUE_EDITION_MASK = 0x3800000;
-const CATEGORY_TO_TYPE = {
-    0x1000: "Standard card",
-    0x2000: "Spectral",
-    0x3000: "Tarot",
-    0x4000: "Planet",
-    0x5000: "Joker",
+// ─── Helpers using motely-wasm runtime enums directly ────────────────────────
+function enumKey(e, value) {
+    const k = e[String(value)];
+    return typeof k === "string" ? k : null;
+}
+function spaceSplit(value) {
+    return value.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
+}
+const CATEGORY_MAP = {
+    [Motely.MotelyItemTypeCategory.Standardcard]: "playing",
+    [Motely.MotelyItemTypeCategory.SpectralCard]: "spectral",
+    [Motely.MotelyItemTypeCategory.TarotCard]: "tarot",
+    [Motely.MotelyItemTypeCategory.PlanetCard]: "planet",
+    [Motely.MotelyItemTypeCategory.Joker]: "joker",
 };
-// ─── Reverse lookup: MotelyItemType integer → string name ────────────────────
-const _itemTypeToName = new Map();
-function ensureItemTypeMap() {
-    if (_itemTypeToName.size > 0)
-        return;
-    const e = Motely.MotelyItemType;
-    for (const [key, val] of Object.entries(e)) {
-        if (typeof val === "number" && typeof key === "string" && !/^\d+$/.test(key)) {
-            _itemTypeToName.set(val, key);
-        }
-    }
-}
-function asRuntimeItem(input) {
-    return input !== null && typeof input === "object" ? input : null;
-}
-function finiteNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function runtimeEnumName(enumObject, value) {
-    if (value === null || !enumObject || typeof enumObject !== "object")
-        return null;
-    const enumKey = enumObject[String(value)];
-    return typeof enumKey === "string" && enumKey.length > 0 ? enumKey : null;
-}
-function parseStandardcardEnumKey(enumKey) {
-    const match = /^([CDHS])(10|[2-9JQKA])$/.exec(enumKey);
-    if (!match)
-        return null;
-    const suitMap = {
-        C: "Clubs",
-        D: "Diamonds",
-        H: "Hearts",
-        S: "Spades",
-    };
-    const rankMap = {
-        J: "Jack",
-        Q: "Queen",
-        K: "King",
-        A: "Ace",
-    };
-    return {
-        rank: rankMap[match[2]] ?? match[2],
-        suit: suitMap[match[1]],
-    };
-}
-function rankNameFromEnum(enumKey) {
-    if (!enumKey)
-        return null;
-    const rankMap = {
-        Two: "2",
-        Three: "3",
-        Four: "4",
-        Five: "5",
-        Six: "6",
-        Seven: "7",
-        Eight: "8",
-        Nine: "9",
-        Ten: "10",
-        Jack: "Jack",
-        Queen: "Queen",
-        King: "King",
-        Ace: "Ace",
-    };
-    return rankMap[enumKey] ?? null;
-}
+// ─── Core decoder ────────────────────────────────────────────────────────────
 function resolvePackedValue(input) {
+    if (input == null)
+        return null;
     if (typeof input === "number")
         return Number.isFinite(input) ? input : null;
-    const runtimeItem = asRuntimeItem(input);
-    return finiteNumber(runtimeItem?.value);
+    return input.value ?? input.type ?? null;
 }
-function resolveEditionValue(input) {
-    const runtimeItem = asRuntimeItem(input);
-    const direct = finiteNumber(runtimeItem?.edition);
-    if (direct !== null)
-        return direct;
-    const packedValue = resolvePackedValue(input);
-    return packedValue !== null ? packedValue & VALUE_EDITION_MASK : null;
-}
-function resolveSealValue(input) {
-    const runtimeItem = asRuntimeItem(input);
-    const direct = finiteNumber(runtimeItem?.seal);
-    if (direct !== null)
-        return direct;
-    const packedValue = resolvePackedValue(input);
-    return packedValue !== null ? packedValue & VALUE_SEAL_MASK : null;
+export function resolveMotelyItemType(input) {
+    const val = resolvePackedValue(input);
+    return val !== null ? val & 0xffff : null;
 }
-function resolveEnhancementValue(input) {
-    const runtimeItem = asRuntimeItem(input);
-    const direct = finiteNumber(runtimeItem?.enhancement);
-    if (direct !== null)
-        return direct;
-    const packedValue = resolvePackedValue(input);
-    return packedValue !== null ? packedValue & VALUE_ENHANCEMENT_MASK : null;
+export function motelyItemTypeName(input) {
+    const itemType = resolveMotelyItemType(input);
+    if (itemType === null)
+        return "Unknown";
+    return enumKey(Motely.MotelyItemType, itemType) ?? `item#${itemType}`;
 }
-export function resolveMotelyItemType(input) {
-    if (typeof input === "number")
-        return Number.isFinite(input) ? (input & VALUE_TYPE_MASK) : null;
-    const runtimeItem = asRuntimeItem(input);
-    const directType = finiteNumber(runtimeItem?.type);
-    if (directType !== null)
-        return directType & VALUE_TYPE_MASK;
-    const packedValue = finiteNumber(runtimeItem?.value);
-    return packedValue !== null ? packedValue & VALUE_TYPE_MASK : null;
+export function motelyItemCategory(itemType) {
+    const catValue = (itemType >> 12) & 0xf;
+    return CATEGORY_MAP[catValue] ?? "unknown";
 }
 export function motelyItemRenderCategory(input) {
-    const enumKey = motelyItemTypeName(input);
-    return enumKey === "Unknown" ? "unknown" : getItemCategory(enumKey);
+    const itemType = resolveMotelyItemType(input);
+    if (itemType === null)
+        return "unknown";
+    return motelyItemCategory(itemType);
+}
+export function motelyItemDisplayName(input) {
+    return spaceSplit(motelyItemTypeName(input));
 }
 export function motelyItemEditionName(input) {
-    const enumKey = runtimeEnumName(Motely.MotelyItemEdition, resolveEditionValue(input));
-    return enumKey === null || enumKey === "None" ? null : enumKey;
+    if (input == null)
+        return null;
+    const val = typeof input === "number" ? input : input.edition;
+    if (val == null)
+        return null;
+    const key = enumKey(Motely.MotelyItemEdition, typeof val === "number" ? val : 0);
+    if (!key || key === "None")
+        return null;
+    return key;
 }
 export function motelyItemSealName(input) {
-    const enumKey = runtimeEnumName(Motely.MotelyItemSeal, resolveSealValue(input));
-    return enumKey === null || enumKey === "None" ? null : enumKey;
+    if (input == null)
+        return null;
+    const val = typeof input === "number" ? null : input.seal;
+    if (val == null)
+        return null;
+    const key = enumKey(Motely.MotelyItemSeal, val);
+    if (!key || key === "None")
+        return null;
+    return key;
 }
 export function motelyItemEnhancementName(input) {
-    const enumKey = runtimeEnumName(Motely.MotelyItemEnhancement, resolveEnhancementValue(input));
-    return enumKey === null || enumKey === "None" ? null : enumKey;
-}
-export function motelyStandardcardSuitName(input) {
-    const runtimeItem = asRuntimeItem(input);
-    const directSuit = runtimeEnumName(Motely.MotelyStandardcardSuit, finiteNumber(runtimeItem?.suit));
-    if (directSuit === "Clubs" || directSuit === "Diamonds" || directSuit === "Hearts" || directSuit === "Spades") {
-        return directSuit;
-    }
-    const parsed = parseStandardcardEnumKey(motelyItemTypeName(input));
-    return parsed?.suit ?? null;
+    if (input == null)
+        return null;
+    const val = typeof input === "number" ? null : input.enhancement;
+    if (val == null)
+        return null;
+    const key = enumKey(Motely.MotelyItemEnhancement, val);
+    if (!key || key === "None")
+        return null;
+    return key;
 }
 export function motelyStandardcardRankName(input) {
-    const runtimeItem = asRuntimeItem(input);
-    const directRank = runtimeEnumName(Motely.MotelyStandardcardRank, finiteNumber(runtimeItem?.rank));
-    const normalizedDirect = rankNameFromEnum(directRank);
-    if (normalizedDirect !== null)
-        return normalizedDirect;
-    const parsed = parseStandardcardEnumKey(motelyItemTypeName(input));
-    return parsed?.rank ?? null;
-}
-/** Get the enum key name for a MotelyItemType value. */
-export function motelyItemTypeName(input) {
-    const itemType = resolveMotelyItemType(input);
-    if (itemType === null)
-        return "Unknown";
-    ensureItemTypeMap();
-    return _itemTypeToName.get(itemType) ?? "Unknown";
+    if (input == null)
+        return null;
+    const val = typeof input === "number" ? null : input.rank;
+    if (val == null)
+        return null;
+    return enumKey(Motely.MotelyStandardcardRank, val);
 }
-/** Get the category string for a MotelyItemType value. */
-export function motelyItemCategory(input) {
-    const itemType = resolveMotelyItemType(input);
-    if (itemType === null)
-        return "Unknown";
-    const renderCategory = motelyItemRenderCategory(itemType);
-    if (renderCategory === "playing")
-        return "Standard card";
-    if (renderCategory === "spectral")
-        return "Spectral";
-    if (renderCategory === "tarot")
-        return "Tarot";
-    if (renderCategory === "planet")
-        return "Planet";
-    if (renderCategory === "joker")
-        return "Joker";
-    return CATEGORY_TO_TYPE[itemType & CATEGORY_MASK] ?? "Unknown";
+export function motelyStandardcardSuitName(input) {
+    if (input == null)
+        return null;
+    const val = typeof input === "number" ? null : input.suit;
+    if (val == null)
+        return null;
+    return enumKey(Motely.MotelyStandardcardSuit, val);
 }
-/** Convert PascalCase enum key to display name. */
-export function motelyItemDisplayName(input) {
-    const enumKey = motelyItemTypeName(input);
-    return enumKey === "Unknown" ? "Unknown" : getItemDisplayName(enumKey);
+export function decodeMotelyItemName(input) {
+    return motelyItemTypeName(input);
 }
-// ─── Module-level cache ──────────────────────────────────────────────────────
-const _cache = new Map();
-const _decodedBaseCache = new Map();
 export function decodeMotelyItem(input) {
     const itemType = resolveMotelyItemType(input);
     if (itemType === null)
         return null;
-    let base = _decodedBaseCache.get(itemType) ?? null;
-    if (!_decodedBaseCache.has(itemType)) {
-        const enumKey = motelyItemTypeName(itemType);
-        if (enumKey === "Unknown") {
-            _decodedBaseCache.set(itemType, null);
-            return null;
-        }
-        const category = motelyItemRenderCategory(itemType);
-        const rank = motelyStandardcardRankName(itemType);
-        const suit = motelyStandardcardSuitName(itemType);
-        base = {
-            itemType,
-            enumKey,
-            displayName: category === "playing" && rank && suit ? `${rank} of ${suit}` : getItemDisplayName(enumKey),
-            category,
-            rank,
-            suit,
-        };
-        _decodedBaseCache.set(itemType, base);
-    }
-    if (!base)
-        return null;
-    const decoded = {
-        ...base,
+    const enumKeyStr = enumKey(Motely.MotelyItemType, itemType) ?? `Unknown_${itemType}`;
+    const category = motelyItemCategory(itemType);
+    const displayName = spaceSplit(enumKeyStr);
+    return {
+        itemType,
+        enumKey: enumKeyStr,
+        displayName,
+        category,
         edition: motelyItemEditionName(input),
         seal: motelyItemSealName(input),
         enhancement: motelyItemEnhancementName(input),
+        rank: motelyStandardcardRankName(input),
+        suit: motelyStandardcardSuitName(input),
     };
-    return decoded;
 }
-export function decodeMotelyItemToJamlCard(input, scale = 1) {
+export function decodeMotelyItemToJamlCard(input, scale) {
     const decoded = decodeMotelyItem(input);
-    if (!decoded || decoded.category === "unknown")
+    if (!decoded)
         return null;
-    if (decoded.category === "playing") {
-        if (!decoded.rank || !decoded.suit)
-            return null;
-        return {
-            type: "playing",
-            card: {
-                name: `${decoded.rank} of ${decoded.suit}`,
-                edition: decoded.edition ?? undefined,
-                seal: decoded.seal ? `${decoded.seal} Seal` : undefined,
-                enhancements: decoded.enhancement ? [decoded.enhancement] : undefined,
-                rank: decoded.rank,
-                suit: decoded.suit,
-                scale,
-            },
-        };
-    }
+    const type = decoded.category === "joker" ? "joker"
+        : decoded.category === "playing" ? "playing"
+            : "consumable";
     return {
-        type: decoded.category === "joker" ? "joker" : "consumable",
+        type,
         card: {
             name: decoded.displayName,
             edition: decoded.edition ?? undefined,
+            seal: decoded.seal ?? undefined,
+            enhancements: decoded.enhancement ? [decoded.enhancement] : undefined,
+            rank: decoded.rank ?? undefined,
+            suit: decoded.suit ?? undefined,
             scale,
         },
     };
 }
-/**
- * Decode a MotelyItemType integer to a display name for sprite lookup.
- * Cached per value.
- */
-export function decodeMotelyItemName(input) {
-    const itemType = resolveMotelyItemType(input);
-    if (itemType === null)
-        return null;
-    if (_cache.has(itemType))
-        return _cache.get(itemType) ?? null;
-    const category = motelyItemCategory(itemType);
-    if (category === "Unknown") {
-        _cache.set(itemType, null);
-        return null;
-    }
-    const decoded = decodeMotelyItem(input);
-    const name = decoded?.displayName ?? motelyItemDisplayName(itemType);
-    _cache.set(itemType, name);
-    return name;
-}
-/** Warm the cache for a batch of item type values. */
-export function warmMotelyItemCache(itemTypes) {
-    for (const t of itemTypes) {
-        decodeMotelyItemName(t);
-        decodeMotelyItem(t);
-    }
-}
-/** Number of unique items decoded so far. */
-export function motelyItemCacheSize() {
-    return _cache.size;
-}
+// Cache warming is now a no-op since we use runtime enums directly
+export function warmMotelyItemCache() { }
+export function motelyItemCacheSize() { return 0; }

package/dist/decode/motelySprite.d.ts

@@ -0,0 +1,19 @@
+import { type MotelyRenderableCategory } from "./motelyItemDecoder.js";
+export interface MotelySpriteData {
+    atlasPath: string;
+    gridCol: number;
+    gridRow: number;
+    gridCols: number;
+    gridRows: number;
+    displayName: string;
+    category: MotelyRenderableCategory;
+}
+/**
+ * Given a raw motely-wasm item value (which may be a bitpacked integer or raw MotelyItemType),
+ * resolves it to a sprite atlas path and grid coordinates for rendering.
+ */
+export declare function motelyItemToSprite(rawValue: number): MotelySpriteData | null;
+/**
+ * Resolves a sprite by name and category without needing a Motely integer.
+ */
+export declare function getMotelySpriteByName(name: string, category?: MotelyRenderableCategory): MotelySpriteData | null;

package/dist/decode/motelySprite.js

@@ -0,0 +1,84 @@
+import { decodeMotelyItem } from "./motelyItemDecoder.js";
+import { getSpriteData, SHEET_META } from "../sprites/spriteMapper.js";
+import { RANK_MAP, SUIT_MAP } from "../sprites/spriteData.js";
+import { resolveJamlAssetUrl } from "../assets.js";
+/**
+ * Given a raw motely-wasm item value (which may be a bitpacked integer or raw MotelyItemType),
+ * resolves it to a sprite atlas path and grid coordinates for rendering.
+ */
+export function motelyItemToSprite(rawValue) {
+    const decoded = decodeMotelyItem(rawValue);
+    if (!decoded)
+        return null;
+    if (decoded.category === "playing" && decoded.rank && decoded.suit) {
+        const col = RANK_MAP[decoded.rank];
+        const row = SUIT_MAP[decoded.suit];
+        if (col !== undefined && row !== undefined) {
+            return {
+                atlasPath: resolveJamlAssetUrl('deck'),
+                gridCol: col,
+                gridRow: row,
+                gridCols: 13,
+                gridRows: 4,
+                displayName: decoded.displayName,
+                category: "playing"
+            };
+        }
+    }
+    const sprite = getSpriteData(decoded.displayName);
+    if (!sprite)
+        return null;
+    const meta = SHEET_META[sprite.type];
+    if (!meta)
+        return null;
+    return {
+        atlasPath: resolveJamlAssetUrl(meta.assetKey),
+        gridCol: sprite.pos.x,
+        gridRow: sprite.pos.y,
+        gridCols: meta.cols,
+        gridRows: meta.rows,
+        displayName: decoded.displayName,
+        category: decoded.category
+    };
+}
+/**
+ * Resolves a sprite by name and category without needing a Motely integer.
+ */
+export function getMotelySpriteByName(name, category = "unknown") {
+    if (category === "playing") {
+        // Attempt to parse "Rank of Suit"
+        const match = /^(.*?)\s+of\s+(.*?)$/i.exec(name);
+        if (match) {
+            const rank = match[1];
+            const suit = match[2];
+            const col = RANK_MAP[rank];
+            const row = SUIT_MAP[suit];
+            if (col !== undefined && row !== undefined) {
+                return {
+                    atlasPath: resolveJamlAssetUrl('deck'),
+                    gridCol: col,
+                    gridRow: row,
+                    gridCols: 13,
+                    gridRows: 4,
+                    displayName: name,
+                    category: "playing"
+                };
+            }
+        }
+    }
+    const sprite = getSpriteData(name);
+    if (!sprite)
+        return null;
+    const meta = SHEET_META[sprite.type];
+    if (!meta)
+        return null;
+    return {
+        atlasPath: resolveJamlAssetUrl(meta.assetKey),
+        gridCol: sprite.pos.x,
+        gridRow: sprite.pos.y,
+        gridCols: meta.cols,
+        gridRows: meta.rows,
+        displayName: name,
+        category
+    };
+}

package/dist/hooks/analyzerStreamRegistry.js

@@ -1,5 +1,4 @@
 "use client";
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { motelyItemDisplayNameFromValue } from "../motelyDisplay.js";
 export const ANALYZER_STREAM_META = {
     shop: { key: "shop", label: "Shop", tone: "default", defaultEnabled: true },
@@ -28,120 +27,69 @@ export function buildStreamHandle(live, ante, key) {
     const ctx = live.ctx;
     const Motely = live.Motely;
     const runState = live.runStates[ante];
-    let stream = null;
     let cursor = 0;
     const idBase = `${ante}-${key}`;
     function nameFromValue(value) {
         return motelyItemDisplayNameFromValue(value);
     }
-    function joker(streamFactoryName, nextName) {
+    function streamHandle(createStream, getNextValue) {
+        let stream = null;
         return {
             initStream: () => {
-                stream = ctx[streamFactoryName](ante, Motely.MotelyJokerStreamFlags.Default);
+                stream = createStream();
                 cursor = 0;
             },
             nextItem: () => {
-                const r = ctx[nextName](stream);
-                const value = r.joker?.value ?? r.item?.value ?? 0;
+                if (stream === null)
+                    throw new Error(`Analyzer stream ${key} was read before initialization.`);
+                const value = getNextValue(stream);
                 const id = `${idBase}-${cursor++}`;
                 return { id, name: nameFromValue(value), value };
             },
         };
     }
-    function fixedRarityJoker(streamFactoryName, nextName) {
-        return {
-            initStream: () => {
-                stream = ctx[streamFactoryName](ante, Motely.MotelyJokerFixedRarityStreamFlags.Default);
-                cursor = 0;
-            },
-            nextItem: () => {
-                const r = ctx[nextName](stream);
-                const value = r.joker?.value ?? 0;
-                const id = `${idBase}-${cursor++}`;
-                return { id, name: nameFromValue(value), value };
-            },
-        };
+    function joker(createStream, getNext) {
+        return streamHandle(createStream, (stream) => getNext(stream).item.value);
     }
-    function tarot(streamFactoryName, nextName) {
-        return {
-            initStream: () => {
-                stream = ctx[streamFactoryName](ante);
-                cursor = 0;
-            },
-            nextItem: () => {
-                const r = ctx[nextName](stream);
-                const value = r.tarot?.value ?? r.item?.value ?? 0;
-                const id = `${idBase}-${cursor++}`;
-                return { id, name: nameFromValue(value), value };
-            },
-        };
+    function fixedRarityJoker(createStream, getNext) {
+        return streamHandle(createStream, (stream) => getNext(stream).item.value);
     }
-    function planet(streamFactoryName, nextName) {
-        return {
-            initStream: () => {
-                stream = ctx[streamFactoryName](ante);
-                cursor = 0;
-            },
-            nextItem: () => {
-                const r = ctx[nextName](stream);
-                const value = r.planet?.value ?? 0;
-                const id = `${idBase}-${cursor++}`;
-                return { id, name: nameFromValue(value), value };
-            },
-        };
+    function tarot(createStream, getNext) {
+        return streamHandle(createStream, (stream) => getNext(stream).item.value);
     }
-    function spectral(streamFactoryName, nextName) {
-        return {
-            initStream: () => {
-                stream = ctx[streamFactoryName](ante);
-                cursor = 0;
-            },
-            nextItem: () => {
-                const r = ctx[nextName](stream);
-                const value = r.spectral?.value ?? 0;
-                const id = `${idBase}-${cursor++}`;
-                return { id, name: nameFromValue(value), value };
-            },
-        };
+    function planet(createStream, getNext) {
+        return streamHandle(createStream, (stream) => getNext(stream).item.value);
+    }
+    function spectral(createStream, getNext) {
+        return streamHandle(createStream, (stream) => getNext(stream).item.value);
     }
     switch (key) {
         case "shop":
-            return {
-                initStream: () => {
-                    stream = ctx.createShopItemStream(ante, runState, Motely.MotelyShopStreamFlags.Default, Motely.MotelyJokerStreamFlags.Default);
-                    cursor = 0;
-                },
-                nextItem: () => {
-                    const r = ctx.getNextShopItem(stream);
-                    const value = r.item.value;
-                    const id = `${idBase}-${cursor++}`;
-                    return { id, name: nameFromValue(value), value };
-                },
-            };
+            return streamHandle(() => ctx.createShopItemStream(ante, runState, Motely.MotelyShopStreamFlags.Default, Motely.MotelyJokerStreamFlags.Default), (stream) => ctx.getNextShopItem(stream).item.value);
         case "shopJoker":
-            return joker("createShopJokerStream", "getNextShopJoker");
+            return joker(() => ctx.createShopJokerStream(ante, Motely.MotelyJokerStreamFlags.Default), (stream) => ctx.getNextShopJoker(stream));
         case "soulJoker":
-            return fixedRarityJoker("createSoulJokerStream", "getNextSoulJoker");
+            return fixedRarityJoker(() => ctx.createSoulJokerStream(ante, Motely.MotelyJokerFixedRarityStreamFlags.Default), (stream) => ctx.getNextSoulJoker(stream));
         case "rareTagJoker":
-            return fixedRarityJoker("createRareTagJokerStream", "getNextRareTagJoker");
+            return fixedRarityJoker(() => ctx.createRareTagJokerStream(ante, Motely.MotelyJokerFixedRarityStreamFlags.Default), (stream) => ctx.getNextRareTagJoker(stream));
         case "uncommonTagJoker":
-            return fixedRarityJoker("createUncommonTagJokerStream", "getNextUncommonTagJoker");
+            return fixedRarityJoker(() => ctx.createUncommonTagJokerStream(ante, Motely.MotelyJokerFixedRarityStreamFlags.Default), (stream) => ctx.getNextUncommonTagJoker(stream));
         case "riffRaffJoker":
-            return fixedRarityJoker("createRiffRaffJokerStream", "getNextRiffRaffJoker");
+            return fixedRarityJoker(() => ctx.createRiffRaffJokerStream(ante, Motely.MotelyJokerFixedRarityStreamFlags.Default), (stream) => ctx.getNextRiffRaffJoker(stream));
         case "buffoonJoker":
-            return joker("createBuffoonPackJokerStream", "getNextBuffoonPackJoker");
+            return joker(() => ctx.createBuffoonPackJokerStream(ante, Motely.MotelyJokerStreamFlags.Default), (stream) => ctx.getNextBuffoonPackJoker(stream));
         case "judgementJoker":
-            return joker("createJudgementJokerStream", "getNextJudgementJoker");
+            return joker(() => ctx.createJudgementJokerStream(ante, Motely.MotelyJokerStreamFlags.Default), (stream) => ctx.getNextJudgementJoker(stream));
         case "wraithJoker":
-            return joker("createWraithJokerStream", "getNextWraithJoker");
+            return joker(() => ctx.createWraithJokerStream(ante, Motely.MotelyJokerStreamFlags.Default), (stream) => ctx.getNextWraithJoker(stream));
         case "shopTarot":
-            return tarot("createShopTarotStream", "getNextShopTarot");
+            return tarot(() => ctx.createShopTarotStream(ante), (stream) => ctx.getNextShopTarot(stream));
         case "shopPlanet":
-            return planet("createShopPlanetStream", "getNextShopPlanet");
+            return planet(() => ctx.createShopPlanetStream(ante), (stream) => ctx.getNextShopPlanet(stream));
         case "shopSpectral":
-            return spectral("createShopSpectralStream", "getNextShopSpectral");
+            return spectral(() => ctx.createShopSpectralStream(ante), (stream) => ctx.getNextShopSpectral(stream));
         case "purpleSealTarot":
-            return tarot("createPurpleSealTarotStream", "getNextPurpleSealTarot");
+            return tarot(() => ctx.createPurpleSealTarotStream(ante), (stream) => ctx.getNextPurpleSealTarot(stream));
         default:
             return null;
     }