jaml-ui 0.11.1 → 0.14.0

package/dist/components/JamlAestheticSelector.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export type JamlAestheticOption = "Palindrome" | "Psychosis" | "Gross" | "Nsfw" | "Funny" | "Balatro";
+export interface JamlAestheticSelectorProps {
+    value?: JamlAestheticOption | null;
+    onChange: (aesthetic: JamlAestheticOption | null, numericValue: number) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function JamlAestheticSelector({ value, onChange, className, style }: JamlAestheticSelectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/JamlAestheticSelector.js

@@ -0,0 +1,36 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { JimboColorOption } from "../ui/tokens.js";
+import { JimboText } from "../ui/jimboText.js";
+const AESTHETICS = [
+    { id: "Palindrome", value: 0, label: "Palindrome", desc: "Seeds that read the same forwards and backwards" },
+    { id: "Psychosis", value: 1, label: "Psychosis", desc: "Unsettling or eerie seed patterns" },
+    { id: "Gross", value: 2, label: "Gross", desc: "Seeds with crude or disgusting words" },
+    { id: "Nsfw", value: 3, label: "NSFW", desc: "Seeds with adult content" },
+    { id: "Funny", value: 4, label: "Funny", desc: "Seeds that spell funny words" },
+    { id: "Balatro", value: 5, label: "Balatro", desc: "Seeds referencing the game itself" },
+];
+export function JamlAestheticSelector({ value, onChange, className, style }) {
+    return (_jsxs("div", { className: className, style: {
+            display: "flex",
+            flexDirection: "column",
+            gap: 4,
+            ...style,
+        }, children: [_jsx(JimboText, { size: "xs", tone: "grey", uppercase: true, children: "Seed Aesthetics" }), _jsx("div", { style: { display: "flex", flexWrap: "wrap", gap: 4 }, children: AESTHETICS.map((a) => {
+                    const isActive = value === a.id;
+                    return (_jsx("button", { type: "button", onClick: () => onChange(isActive ? null : a.id, a.value), title: a.desc, style: {
+                            padding: "4px 10px",
+                            borderRadius: 6,
+                            border: `2px solid ${isActive ? JimboColorOption.GOLD : JimboColorOption.PANEL_EDGE}`,
+                            background: isActive ? `${JimboColorOption.GOLD}22` : JimboColorOption.DARKEST,
+                            color: isActive ? JimboColorOption.GOLD_TEXT : JimboColorOption.GREY,
+                            cursor: "pointer",
+                            fontSize: 11,
+                            fontWeight: 700,
+                            fontFamily: "m6x11plus, monospace",
+                            textTransform: "uppercase",
+                            letterSpacing: 0.5,
+                            transition: "border-color 100ms, background 100ms",
+                        }, children: a.label }, a.id));
+                }) })] }));
+}

package/dist/components/JamlAnalyzerFullscreen.d.ts

@@ -0,0 +1,21 @@
+import type { AnalyzerAnteView, AnalyzerItem } from "./AnalyzerExplorer.js";
+import type { AnalyzerLive } from "../hooks/useAnalyzer.js";
+import { type AnalyzerStreamKey } from "../hooks/analyzerStreamRegistry.js";
+export interface JamlAnalyzerFullscreenProps {
+    /** Per-ante summaries from useAnalyzer.antes. */
+    antes: AnalyzerAnteView[];
+    /** Live ctx from useAnalyzer.live; null disables additional stream lanes. */
+    live: AnalyzerLive | null;
+    /** Stream lanes to surface. Defaults to shop + soul jokers. */
+    enabledStreams?: AnalyzerStreamKey[];
+    /** Called when the user toggles a stream in the picker. Owners persist if desired. */
+    onEnabledStreamsChange?: (next: AnalyzerStreamKey[]) => void;
+    /** Hide the built-in stream picker overlay (e.g. when host renders its own). */
+    hidePicker?: boolean;
+    /** Pull size on each lazy load. */
+    chunkSize?: number;
+    className?: string;
+}
+export declare function JamlAnalyzerFullscreen({ antes, live, enabledStreams, onEnabledStreamsChange, hidePicker, chunkSize, className, }: JamlAnalyzerFullscreenProps): import("react/jsx-runtime").JSX.Element;
+export type { AnalyzerItem };
+export { ANALYZER_STREAM_META, type AnalyzerStreamKey } from "../hooks/analyzerStreamRegistry.js";

package/dist/components/JamlAnalyzerFullscreen.js

@@ -0,0 +1,368 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { JamlBoss, JamlGameCard, JamlTag, JamlVoucher, resolveAnalyzerShopItem } from "./GameCard.js";
+import { useMotelyStream } from "../hooks/useShopStream.js";
+import { ANALYZER_STREAM_META, DEFAULT_ENABLED_STREAMS, buildStreamHandle, } from "../hooks/analyzerStreamRegistry.js";
+import { JimboColorOption, withAlpha } from "../ui/tokens.js";
+const C = JimboColorOption;
+const TONE_COLORS = {
+    gold: C.GOLD_TEXT,
+    purple: C.TAROT_BUTTON,
+    blue: C.PLANET_BUTTON,
+    spectral: C.SPECTRAL_BUTTON,
+    default: C.GOLD_TEXT,
+};
+export function JamlAnalyzerFullscreen({ antes, live, enabledStreams, onEnabledStreamsChange, hidePicker = false, chunkSize = 12, className = "", }) {
+    const [internalEnabled, setInternalEnabled] = useState(enabledStreams ?? DEFAULT_ENABLED_STREAMS);
+    const effectiveEnabled = enabledStreams ?? internalEnabled;
+    const setEnabled = useCallback((next) => {
+        setInternalEnabled(next);
+        onEnabledStreamsChange?.(next);
+    }, [onEnabledStreamsChange]);
+    const scrollRef = useRef(null);
+    const sectionRefs = useRef(new Map());
+    const [currentAnte, setCurrentAnte] = useState(antes[0]?.ante ?? 1);
+    const [pickerOpen, setPickerOpen] = useState(false);
+    useEffect(() => {
+        const root = scrollRef.current;
+        if (!root)
+            return;
+        const observer = new IntersectionObserver((entries) => {
+            const top = entries
+                .filter((e) => e.isIntersecting)
+                .sort((a, b) => b.intersectionRatio - a.intersectionRatio)[0];
+            if (!top)
+                return;
+            const ante = Number(top.target.dataset.ante);
+            if (!Number.isNaN(ante))
+                setCurrentAnte(ante);
+        }, { root, threshold: [0.4, 0.6, 0.8] });
+        sectionRefs.current.forEach((el) => observer.observe(el));
+        return () => observer.disconnect();
+    }, [antes]);
+    const scrollToAnte = useCallback((ante) => {
+        sectionRefs.current.get(ante)?.scrollIntoView({ behavior: "smooth", block: "start" });
+    }, []);
+    return (_jsxs("div", { className: className, style: styles.root, children: [_jsx("div", { ref: scrollRef, style: styles.scroller, children: antes.map((ante) => (_jsx(AnteSection, { ante: ante, live: live, enabledStreams: effectiveEnabled, chunkSize: chunkSize, registerRef: (el) => {
+                        if (el)
+                            sectionRefs.current.set(ante.ante, el);
+                        else
+                            sectionRefs.current.delete(ante.ante);
+                    } }, ante.ante))) }), _jsx(SideRail, { antes: antes.map((a) => a.ante), currentAnte: currentAnte, onJump: scrollToAnte }), !hidePicker && (_jsx(StreamPicker, { enabled: effectiveEnabled, onChange: setEnabled, open: pickerOpen, onToggle: () => setPickerOpen((v) => !v) }))] }));
+}
+function AnteSection({ ante, live, enabledStreams, chunkSize, registerRef }) {
+    return (_jsxs("section", { ref: registerRef, "data-ante": ante.ante, style: styles.section, children: [_jsxs("header", { style: styles.header, children: [_jsxs("div", { children: [_jsx("div", { style: styles.anteLabel, children: "ANTE" }), _jsx("div", { style: styles.anteNumber, children: ante.ante })] }), ante.voucher && (_jsxs("div", { style: styles.voucherBlock, children: [_jsx(JamlVoucher, { voucherName: ante.voucher, scale: 0.85 }), _jsx("div", { style: styles.voucherCaption, children: ante.voucher })] }))] }), _jsxs("div", { style: styles.blindRow, children: [_jsx(BlindCell, { label: "SMALL", tag: ante.smallBlindTag }), _jsx(BlindCell, { label: "BIG", tag: ante.bigBlindTag }), ante.boss && (_jsxs("div", { style: styles.bossCell, children: [_jsx("div", { style: styles.cellLabel, children: "BOSS" }), _jsx(JamlBoss, { bossName: ante.boss, scale: 0.7 }), _jsx("div", { style: styles.cellCaption, children: ante.boss })] }))] }), ante.packs && ante.packs.length > 0 && (_jsxs("div", { style: styles.streamLane, children: [_jsx("div", { style: styles.streamLabel, children: "PACKS" }), _jsx("div", { style: styles.packRow, children: ante.packs.map((pack, i) => (_jsx("div", { style: styles.packPill, children: pack }, `${ante.ante}-pack-${i}`))) })] })), enabledStreams.map((key) => {
+                const isShop = key === "shop";
+                const initialItems = isShop
+                    ? (ante.shop ?? []).map((item) => ({
+                        id: item.id,
+                        name: item.name,
+                        value: item.value,
+                    }))
+                    : [];
+                return (_jsx(StreamLane, { ante: ante.ante, streamKey: key, live: live, chunkSize: chunkSize, initialItems: initialItems }, `${ante.ante}-${key}`));
+            })] }));
+}
+function StreamLane({ ante, streamKey, live, chunkSize, initialItems }) {
+    const meta = ANALYZER_STREAM_META[streamKey];
+    const handle = useMemo(() => (live ? buildStreamHandle(live, ante, streamKey) : null), [live, ante, streamKey]);
+    const stream = useMotelyStream(handle?.initStream ?? null, handle?.nextItem ?? null, [ante, streamKey, live?.seed, live?.deck, live?.stake], initialItems);
+    const desired = live?.desiredNames ?? new Set();
+    const toneColor = TONE_COLORS[meta.tone] ?? TONE_COLORS.default;
+    return (_jsxs("div", { style: styles.streamLane, children: [_jsxs("div", { style: { ...styles.streamLabel, color: toneColor }, children: [meta.label.toUpperCase(), stream.items.length > 0 ? ` · ${stream.items.length}` : ""] }), _jsx(ShopRow, { items: stream.items, desired: desired, loadingMore: stream.loadingMore, ready: stream.ready, onPullMore: () => stream.pullMore(chunkSize) }), stream.error && _jsxs("div", { style: styles.errorLine, children: ["stream error: ", stream.error] })] }));
+}
+function BlindCell({ label, tag }) {
+    if (!tag)
+        return null;
+    return (_jsxs("div", { style: styles.blindCell, children: [_jsx("div", { style: styles.cellLabel, children: label }), _jsx(JamlTag, { tagName: tag, scale: 0.7 }), _jsx("div", { style: styles.cellCaption, children: tag })] }));
+}
+function ShopRow({ items, desired, loadingMore, ready, onPullMore }) {
+    const sentinelRef = useRef(null);
+    const lastTriggerRef = useRef(0);
+    useEffect(() => {
+        const el = sentinelRef.current;
+        if (!el || !ready)
+            return;
+        const observer = new IntersectionObserver((entries) => {
+            if (entries[0]?.isIntersecting && !loadingMore) {
+                const now = Date.now();
+                if (now - lastTriggerRef.current < 200)
+                    return;
+                lastTriggerRef.current = now;
+                onPullMore();
+            }
+        }, { root: el.parentElement, threshold: 0.1, rootMargin: "0px 200px 0px 0px" });
+        observer.observe(el);
+        return () => observer.disconnect();
+    }, [ready, loadingMore, onPullMore]);
+    return (_jsxs("div", { style: styles.shopRow, children: [items.map((item) => (_jsx(ShopItem, { item: item, desired: desired.has(item.name.toLowerCase()) }, item.id))), _jsx("div", { ref: sentinelRef, style: styles.sentinel, children: loadingMore ? "…" : "" })] }));
+}
+function ShopItem({ item, desired }) {
+    const resolved = resolveAnalyzerShopItem({ id: item.id, name: item.name, value: item.value });
+    const wrapperStyle = {
+        flexShrink: 0,
+        position: "relative",
+        filter: desired ? `drop-shadow(0 0 6px ${C.GOLD})` : undefined,
+    };
+    const labelStyle = {
+        fontSize: 10,
+        color: desired ? C.GOLD : C.GREY,
+        textAlign: "center",
+        marginTop: 2,
+        maxWidth: 80,
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap",
+    };
+    return (_jsxs("div", { style: wrapperStyle, children: [resolved.kind === "joker" || resolved.kind === "consumable" || resolved.kind === "playing" ? (_jsx(JamlGameCard, { card: resolved.card, type: resolved.type })) : resolved.kind === "voucher" ? (_jsx(JamlVoucher, { voucherName: resolved.voucherName, scale: 0.7 })) : (_jsx("div", { style: styles.unknownTile, children: ("label" in resolved ? resolved.label : item.name) || "?" })), _jsx("div", { style: labelStyle, children: item.name })] }));
+}
+function SideRail({ antes, currentAnte, onJump }) {
+    return (_jsx("div", { style: styles.sideRail, children: antes.map((ante) => {
+            const active = ante === currentAnte;
+            return (_jsx("button", { type: "button", onClick: () => onJump(ante), "aria-label": `Jump to ante ${ante}`, style: {
+                    ...styles.sideRailDot,
+                    background: active ? C.GOLD : withAlpha(C.WHITE, 0.25),
+                    transform: active ? "scale(1.4)" : "scale(1)",
+                    boxShadow: active ? `0 0 8px ${C.GOLD}` : "none",
+                } }, ante));
+        }) }));
+}
+function StreamPicker({ enabled, onChange, open, onToggle }) {
+    const enabledSet = new Set(enabled);
+    const all = Object.values(ANALYZER_STREAM_META);
+    function toggle(key) {
+        const next = new Set(enabledSet);
+        if (next.has(key))
+            next.delete(key);
+        else
+            next.add(key);
+        onChange(all.map((m) => m.key).filter((k) => next.has(k)));
+    }
+    return (_jsxs(_Fragment, { children: [_jsx("button", { type: "button", onClick: onToggle, style: styles.pickerButton, "aria-label": "Toggle stream picker", children: open ? "✕" : "≡" }), open && (_jsxs("div", { style: styles.pickerPanel, children: [_jsx("div", { style: styles.pickerHeader, children: "STREAMS" }), all.map((meta) => {
+                        const isOn = enabledSet.has(meta.key);
+                        const tone = TONE_COLORS[meta.tone] ?? TONE_COLORS.default;
+                        return (_jsxs("button", { type: "button", onClick: () => toggle(meta.key), style: {
+                                ...styles.pickerChip,
+                                borderColor: isOn ? tone : withAlpha(C.WHITE, 0.15),
+                                color: isOn ? tone : C.GREY,
+                                background: isOn ? withAlpha(tone, 0.1) : "transparent",
+                            }, children: [isOn ? "●" : "○", " ", meta.label] }, meta.key));
+                    })] }))] }));
+}
+const styles = {
+    root: {
+        position: "relative",
+        width: "100%",
+        height: "100svh",
+        background: C.DARKEST,
+        color: C.WHITE,
+        fontFamily: "var(--font-sans, m6x11plus), monospace",
+        overflow: "hidden",
+    },
+    scroller: {
+        width: "100%",
+        height: "100%",
+        overflowY: "scroll",
+        scrollSnapType: "y mandatory",
+        scrollBehavior: "smooth",
+        WebkitOverflowScrolling: "touch",
+    },
+    section: {
+        width: "100%",
+        minHeight: "100svh",
+        scrollSnapAlign: "start",
+        padding: "20px 16px 28px",
+        display: "flex",
+        flexDirection: "column",
+        gap: 12,
+        boxSizing: "border-box",
+        borderBottom: `1px solid ${withAlpha(C.WHITE, 0.05)}`,
+    },
+    header: {
+        display: "flex",
+        justifyContent: "space-between",
+        alignItems: "flex-start",
+        gap: 12,
+    },
+    anteLabel: {
+        fontSize: 12,
+        color: C.GREY,
+        letterSpacing: "0.16em",
+    },
+    anteNumber: {
+        fontSize: 72,
+        color: C.GOLD,
+        lineHeight: 0.9,
+        textShadow: `3px 3px 0 ${C.BLACK}`,
+    },
+    voucherBlock: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        gap: 4,
+    },
+    voucherCaption: {
+        fontSize: 10,
+        color: C.PURPLE,
+        letterSpacing: "0.1em",
+    },
+    blindRow: {
+        display: "flex",
+        gap: 16,
+        flexWrap: "wrap",
+    },
+    blindCell: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        gap: 4,
+    },
+    bossCell: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        gap: 4,
+    },
+    cellLabel: {
+        fontSize: 10,
+        color: C.GREY,
+        letterSpacing: "0.12em",
+    },
+    cellCaption: {
+        fontSize: 10,
+        color: C.WHITE,
+        maxWidth: 90,
+        textAlign: "center",
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap",
+    },
+    streamLane: {
+        display: "flex",
+        flexDirection: "column",
+        gap: 6,
+        minHeight: 0,
+    },
+    streamLabel: {
+        fontSize: 11,
+        color: C.GOLD_TEXT,
+        letterSpacing: "0.16em",
+    },
+    shopRow: {
+        display: "flex",
+        gap: 10,
+        overflowX: "auto",
+        overflowY: "hidden",
+        paddingBottom: 6,
+        scrollbarWidth: "thin",
+    },
+    packRow: {
+        display: "flex",
+        flexWrap: "wrap",
+        gap: 6,
+    },
+    packPill: {
+        padding: "4px 10px",
+        background: withAlpha(C.PANEL_EDGE, 0.9),
+        border: `1px solid ${C.INNER_BORDER}`,
+        borderRadius: 4,
+        fontSize: 11,
+        color: C.WHITE,
+    },
+    sentinel: {
+        flexShrink: 0,
+        width: 28,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        color: C.GREY,
+        fontSize: 14,
+    },
+    unknownTile: {
+        width: 71,
+        height: 95,
+        border: `1px dashed ${C.GREY}`,
+        borderRadius: 4,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        fontSize: 9,
+        color: C.GREY,
+        padding: 4,
+        textAlign: "center",
+    },
+    errorLine: {
+        fontSize: 10,
+        color: C.RED,
+    },
+    sideRail: {
+        position: "absolute",
+        top: "50%",
+        right: 6,
+        transform: "translateY(-50%)",
+        display: "flex",
+        flexDirection: "column",
+        gap: 8,
+        zIndex: 5,
+        pointerEvents: "auto",
+    },
+    sideRailDot: {
+        width: 8,
+        height: 8,
+        borderRadius: "50%",
+        border: "none",
+        cursor: "pointer",
+        padding: 0,
+        transition: "transform 0.15s ease, background 0.15s ease, box-shadow 0.15s ease",
+    },
+    pickerButton: {
+        position: "absolute",
+        top: 12,
+        right: 12,
+        width: 32,
+        height: 32,
+        borderRadius: 4,
+        border: `1px solid ${withAlpha(C.WHITE, 0.2)}`,
+        background: withAlpha(C.DARK_GREY, 0.85),
+        color: C.WHITE,
+        fontSize: 16,
+        cursor: "pointer",
+        zIndex: 6,
+        fontFamily: "inherit",
+    },
+    pickerPanel: {
+        position: "absolute",
+        top: 50,
+        right: 12,
+        width: 220,
+        maxHeight: "70vh",
+        overflowY: "auto",
+        padding: 10,
+        background: withAlpha(C.DARK_GREY, 0.95),
+        border: `1px solid ${withAlpha(C.WHITE, 0.15)}`,
+        borderRadius: 6,
+        display: "flex",
+        flexDirection: "column",
+        gap: 4,
+        zIndex: 6,
+        backdropFilter: "blur(4px)",
+    },
+    pickerHeader: {
+        fontSize: 10,
+        color: C.GREY,
+        letterSpacing: "0.16em",
+        marginBottom: 4,
+    },
+    pickerChip: {
+        padding: "6px 10px",
+        border: "1px solid",
+        borderRadius: 4,
+        fontSize: 11,
+        fontFamily: "inherit",
+        cursor: "pointer",
+        textAlign: "left",
+        transition: "all 0.12s ease",
+    },
+};
+export { ANALYZER_STREAM_META } from "../hooks/analyzerStreamRegistry.js";

package/dist/components/JamlSeedInput.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export interface JamlSeedInputProps {
+    value?: string;
+    onChange?: (seed: string) => void;
+    placeholder?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function JamlSeedInput({ value, onChange, placeholder, className, style }: JamlSeedInputProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/JamlSeedInput.js

@@ -0,0 +1,30 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { JimboColorOption } from "../ui/tokens.js";
+import { JimboText } from "../ui/jimboText.js";
+const SEED_PATTERN = /^[A-Z0-9]{0,8}$/;
+export function JamlSeedInput({ value, onChange, placeholder = "Enter seed (e.g. J4SPZMWW)", className, style }) {
+    const [internal, setInternal] = useState(value ?? "");
+    const display = value ?? internal;
+    const isValid = display.length === 0 || SEED_PATTERN.test(display);
+    const handleChange = (e) => {
+        const raw = e.target.value.toUpperCase().replace(/[^A-Z0-9]/g, "").slice(0, 8);
+        setInternal(raw);
+        onChange?.(raw);
+    };
+    return (_jsxs("div", { className: className, style: { display: "flex", flexDirection: "column", gap: 4, ...style }, children: [_jsx(JimboText, { size: "xs", tone: "grey", uppercase: true, children: "Seed" }), _jsx("input", { type: "text", value: display, onChange: handleChange, placeholder: placeholder, maxLength: 8, spellCheck: false, autoComplete: "off", style: {
+                    padding: "6px 10px",
+                    borderRadius: 6,
+                    border: `2px solid ${!isValid ? JimboColorOption.RED : display.length === 8 ? JimboColorOption.GREEN : JimboColorOption.PANEL_EDGE}`,
+                    background: JimboColorOption.DARKEST,
+                    color: JimboColorOption.GOLD_TEXT,
+                    fontSize: 16,
+                    fontWeight: 900,
+                    fontFamily: "m6x11plus, monospace",
+                    letterSpacing: 2,
+                    textTransform: "uppercase",
+                    outline: "none",
+                    transition: "border-color 100ms",
+                } }), display.length > 0 && display.length < 8 && (_jsxs(JimboText, { size: "xs", tone: "grey", children: [8 - display.length, " more characters"] }))] }));
+}

package/dist/components/JamlSpeedometer.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { SearchStatus } from "../hooks/useSearch.js";
+export interface JamlSpeedometerProps {
+    seedsPerSecond: number;
+    totalSearched: bigint;
+    matchingSeeds: bigint;
+    status: SearchStatus;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function JamlSpeedometer({ seedsPerSecond, totalSearched, matchingSeeds, status, className, style, }: JamlSpeedometerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/JamlSpeedometer.js

@@ -0,0 +1,54 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { JimboColorOption } from "../ui/tokens.js";
+import { JimboText } from "../ui/jimboText.js";
+function formatCount(n) {
+    if (n >= 1000000000n)
+        return `${(Number(n / 1000000n) / 1000).toFixed(1)}B`;
+    if (n >= 1000000n)
+        return `${(Number(n / 1000n) / 1000).toFixed(1)}M`;
+    if (n >= 1000n)
+        return `${(Number(n) / 1000).toFixed(1)}K`;
+    return n.toString();
+}
+function formatSpeed(sps) {
+    if (sps >= 1_000_000)
+        return `${(sps / 1_000_000).toFixed(1)}M`;
+    if (sps >= 1_000)
+        return `${(sps / 1_000).toFixed(0)}K`;
+    return sps.toString();
+}
+function needleAngle(sps) {
+    if (sps <= 0)
+        return -90;
+    const maxLog = Math.log10(5_000_000);
+    const clamped = Math.min(sps, 5_000_000);
+    const pct = Math.log10(Math.max(clamped, 1)) / maxLog;
+    return -90 + pct * 180;
+}
+export function JamlSpeedometer({ seedsPerSecond, totalSearched, matchingSeeds, status, className, style, }) {
+    const isActive = status === "running" || status === "booting";
+    const angle = needleAngle(seedsPerSecond);
+    const speedColor = seedsPerSecond >= 500_000
+        ? JimboColorOption.GREEN
+        : seedsPerSecond >= 100_000
+            ? JimboColorOption.GOLD
+            : seedsPerSecond > 0
+                ? JimboColorOption.ORANGE
+                : JimboColorOption.GREY;
+    return (_jsxs("div", { className: className, style: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            gap: 6,
+            padding: "12px 16px",
+            borderRadius: 10,
+            background: `${JimboColorOption.DARKEST}cc`,
+            border: `1px solid ${JimboColorOption.PANEL_EDGE}`,
+            ...style,
+        }, children: [_jsx("div", { style: { position: "relative", width: 120, height: 68, overflow: "hidden" }, children: _jsxs("svg", { viewBox: "0 0 120 68", width: 120, height: 68, children: [_jsx("path", { d: "M 10 65 A 50 50 0 0 1 110 65", fill: "none", stroke: JimboColorOption.DARK_GREY, strokeWidth: 6, strokeLinecap: "round" }), isActive && (_jsx("path", { d: "M 10 65 A 50 50 0 0 1 110 65", fill: "none", stroke: speedColor, strokeWidth: 6, strokeLinecap: "round", strokeDasharray: "157", strokeDashoffset: 157 - (157 * ((angle + 90) / 180)), style: { transition: "stroke-dashoffset 300ms ease, stroke 300ms ease" } })), _jsx("line", { x1: 60, y1: 65, x2: 60, y2: 20, stroke: isActive ? JimboColorOption.RED : JimboColorOption.GREY, strokeWidth: 2, strokeLinecap: "round", style: {
+                                transformOrigin: "60px 65px",
+                                transform: `rotate(${angle}deg)`,
+                                transition: "transform 300ms ease",
+                            } }), _jsx("circle", { cx: 60, cy: 65, r: 4, fill: JimboColorOption.RED })] }) }), _jsxs("div", { style: { textAlign: "center" }, children: [_jsx("div", { style: { fontSize: 20, fontWeight: 900, fontFamily: "m6x11plus, monospace", color: isActive ? speedColor : JimboColorOption.GREY }, children: isActive ? formatSpeed(seedsPerSecond) : "---" }), _jsx(JimboText, { size: "xs", tone: "grey", uppercase: true, children: "seeds / sec" })] }), _jsxs("div", { style: { display: "flex", gap: 16, marginTop: 2 }, children: [_jsxs("div", { style: { textAlign: "center" }, children: [_jsx("div", { style: { fontSize: 13, fontWeight: 700, fontFamily: "m6x11plus, monospace", color: JimboColorOption.WHITE }, children: formatCount(totalSearched) }), _jsx(JimboText, { size: "xs", tone: "grey", uppercase: true, children: "searched" })] }), _jsxs("div", { style: { textAlign: "center" }, children: [_jsx("div", { style: { fontSize: 13, fontWeight: 700, fontFamily: "m6x11plus, monospace", color: JimboColorOption.GREEN_TEXT }, children: formatCount(matchingSeeds) }), _jsx(JimboText, { size: "xs", tone: "grey", uppercase: true, children: "matches" })] })] })] }));
+}

package/dist/hooks/analyzerStreamRegistry.d.ts

@@ -0,0 +1,35 @@
+import type { StreamItem } from "./useShopStream.js";
+import type { AnalyzerLive } from "./useAnalyzer.js";
+/**
+ * Registry of motely-wasm streams the fullscreen analyzer can surface as
+ * lanes. Each entry knows how to (a) open a stream against a live ctx +
+ * runState for a given ante, and (b) pull the next item.
+ *
+ * Streams that produce raw item *values* (jokers, tarots, planets,
+ * spectrals) are normalized through `motelyItemDisplayNameFromValue` so
+ * downstream rendering uses one shared resolver. Pack-contents streams
+ * return arrays in a single call; we flatten to per-card items keyed by
+ * pack-pull index so React keys stay stable across reloads.
+ */
+export type AnalyzerStreamKey = "shop" | "soulJoker" | "rareTagJoker" | "uncommonTagJoker" | "riffRaffJoker" | "buffoonJoker" | "judgementJoker" | "wraithJoker" | "shopJoker" | "shopTarot" | "shopPlanet" | "shopSpectral" | "purpleSealTarot";
+export interface AnalyzerStreamMeta {
+    key: AnalyzerStreamKey;
+    label: string;
+    /** Tone hint for the lane header. */
+    tone: "gold" | "purple" | "blue" | "spectral" | "default";
+    /** Whether this stream is on by default in the picker. */
+    defaultEnabled: boolean;
+}
+export declare const ANALYZER_STREAM_META: Record<AnalyzerStreamKey, AnalyzerStreamMeta>;
+export declare const DEFAULT_ENABLED_STREAMS: AnalyzerStreamKey[];
+interface StreamHandle {
+    initStream: () => void;
+    nextItem: () => StreamItem;
+}
+/**
+ * Build init/next callbacks for a (key, ante) pair against the live ctx.
+ * The component wraps these with useMotelyStream. Items are normalized to
+ * { id, name, value } so the same ShopItem renderer can show every lane.
+ */
+export declare function buildStreamHandle(live: AnalyzerLive, ante: number, key: AnalyzerStreamKey): StreamHandle | null;
+export {};

package/dist/hooks/analyzerStreamRegistry.js

@@ -0,0 +1,148 @@
+"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 },
+    shopJoker: { key: "shopJoker", label: "Shop Jokers", tone: "default", defaultEnabled: false },
+    soulJoker: { key: "soulJoker", label: "Soul (Legendary)", tone: "gold", defaultEnabled: true },
+    rareTagJoker: { key: "rareTagJoker", label: "Rare Tag Jokers", tone: "default", defaultEnabled: false },
+    uncommonTagJoker: { key: "uncommonTagJoker", label: "Uncommon Tag Jokers", tone: "default", defaultEnabled: false },
+    riffRaffJoker: { key: "riffRaffJoker", label: "Riff Raff", tone: "default", defaultEnabled: false },
+    buffoonJoker: { key: "buffoonJoker", label: "Buffoon Pack Jokers", tone: "default", defaultEnabled: false },
+    judgementJoker: { key: "judgementJoker", label: "Judgement Jokers", tone: "purple", defaultEnabled: false },
+    wraithJoker: { key: "wraithJoker", label: "Wraith Jokers", tone: "spectral", defaultEnabled: false },
+    shopTarot: { key: "shopTarot", label: "Shop Tarots", tone: "purple", defaultEnabled: false },
+    shopPlanet: { key: "shopPlanet", label: "Shop Planets", tone: "blue", defaultEnabled: false },
+    shopSpectral: { key: "shopSpectral", label: "Shop Spectrals", tone: "spectral", defaultEnabled: false },
+    purpleSealTarot: { key: "purpleSealTarot", label: "Purple Seal Tarots", tone: "purple", defaultEnabled: false },
+};
+export const DEFAULT_ENABLED_STREAMS = (Object.values(ANALYZER_STREAM_META)
+    .filter((m) => m.defaultEnabled)
+    .map((m) => m.key));
+/**
+ * Build init/next callbacks for a (key, ante) pair against the live ctx.
+ * The component wraps these with useMotelyStream. Items are normalized to
+ * { id, name, value } so the same ShopItem renderer can show every lane.
+ */
+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) {
+        return {
+            initStream: () => {
+                stream = ctx[streamFactoryName](ante, Motely.MotelyJokerStreamFlags.Default);
+                cursor = 0;
+            },
+            nextItem: () => {
+                const r = ctx[nextName](stream);
+                const value = r.joker?.value ?? r.item?.value ?? 0;
+                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 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 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 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 };
+            },
+        };
+    }
+    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 };
+                },
+            };
+        case "shopJoker":
+            return joker("createShopJokerStream", "getNextShopJoker");
+        case "soulJoker":
+            return fixedRarityJoker("createSoulJokerStream", "getNextSoulJoker");
+        case "rareTagJoker":
+            return fixedRarityJoker("createRareTagJokerStream", "getNextRareTagJoker");
+        case "uncommonTagJoker":
+            return fixedRarityJoker("createUncommonTagJokerStream", "getNextUncommonTagJoker");
+        case "riffRaffJoker":
+            return fixedRarityJoker("createRiffRaffJokerStream", "getNextRiffRaffJoker");
+        case "buffoonJoker":
+            return joker("createBuffoonPackJokerStream", "getNextBuffoonPackJoker");
+        case "judgementJoker":
+            return joker("createJudgementJokerStream", "getNextJudgementJoker");
+        case "wraithJoker":
+            return joker("createWraithJokerStream", "getNextWraithJoker");
+        case "shopTarot":
+            return tarot("createShopTarotStream", "getNextShopTarot");
+        case "shopPlanet":
+            return planet("createShopPlanetStream", "getNextShopPlanet");
+        case "shopSpectral":
+            return spectral("createShopSpectralStream", "getNextShopSpectral");
+        case "purpleSealTarot":
+            return tarot("createPurpleSealTarotStream", "getNextPurpleSealTarot");
+        default:
+            return null;
+    }
+}

package/dist/hooks/searchWorkerCode.d.ts

@@ -1 +1 @@
-export declare const SEARCH_WORKER_CODE = "\nlet MotelyWasm = null;\nlet MotelyWasmEvents = null;\nlet activeSearch = null;\n\nself.addEventListener('message', async function(e) {\n  const msg = e.data;\n\n  if (msg.type === 'init') {\n    try {\n      const mod = await import(msg.url);\n      await mod.default.boot();\n      MotelyWasm = mod.MotelyWasm;\n      MotelyWasmEvents = mod.MotelyWasmEvents;\n      self.postMessage({ type: 'ready' });\n    } catch (err) {\n      self.postMessage({ type: 'error', message: String(err) });\n    }\n    return;\n  }\n\n  if (msg.type === 'start') {\n    if (!MotelyWasm) { self.postMessage({ type: 'error', message: 'Not initialized' }); return; }\n    const validation = MotelyWasm.validateJaml(msg.jaml);\n    if (validation !== 'valid') { self.postMessage({ type: 'error', message: validation }); return; }\n\n    let rId, pId, cId;\n    function cleanup() {\n      MotelyWasmEvents.onResult.unsubscribeById(rId);\n      MotelyWasmEvents.onProgress.unsubscribeById(pId);\n      MotelyWasmEvents.onComplete.unsubscribeById(cId);\n      activeSearch = null;\n    }\n\n    rId = MotelyWasmEvents.onResult.subscribe(function(seed, score) {\n      self.postMessage({ type: 'result', seed, score });\n    });\n    pId = MotelyWasmEvents.onProgress.subscribe(function(searched, matching) {\n      self.postMessage({ type: 'progress', searched: searched.toString(), matching: matching.toString() });\n    });\n    cId = MotelyWasmEvents.onComplete.subscribe(function(status, searched, matched) {\n      cleanup();\n      self.postMessage({ type: 'complete', status, searched: searched.toString(), matched: matched.toString() });\n    });\n\n    try {\n      activeSearch = MotelyWasm.startRandomSearch(msg.jaml, msg.count);\n    } catch (err) {\n      cleanup();\n      self.postMessage({ type: 'error', message: String(err) });\n    }\n    return;\n  }\n\n  if (msg.type === 'stop') {\n    if (activeSearch) { activeSearch.cancel(); activeSearch = null; }\n    self.postMessage({ type: 'cancelled' });\n  }\n});\n";
+export declare const SEARCH_WORKER_CODE = "\nlet MotelyWasm = null;\nlet MotelyWasmEvents = null;\nlet Filters = null;\nlet activeSearch = null;\n\nself.addEventListener('message', async function(e) {\n  const msg = e.data;\n\n  if (msg.type === 'init') {\n    try {\n      const mod = await import(msg.url);\n      await mod.default.boot();\n      MotelyWasm = mod.MotelyWasm;\n      MotelyWasmEvents = mod.MotelyWasmEvents;\n      Filters = mod.Filters;\n      self.postMessage({ type: 'ready' });\n    } catch (err) {\n      self.postMessage({ type: 'error', message: String(err) });\n    }\n    return;\n  }\n\n  if (msg.type === 'start') {\n    if (!MotelyWasm) { self.postMessage({ type: 'error', message: 'Not initialized' }); return; }\n    const validation = MotelyWasm.validateJaml(msg.jaml);\n    if (validation !== 'valid') { self.postMessage({ type: 'error', message: validation }); return; }\n\n    let rId, pId, cId;\n    function cleanup() {\n      MotelyWasmEvents.onResult.unsubscribeById(rId);\n      MotelyWasmEvents.onProgress.unsubscribeById(pId);\n      MotelyWasmEvents.onComplete.unsubscribeById(cId);\n      activeSearch = null;\n    }\n\n    rId = MotelyWasmEvents.onResult.subscribe(function(seed, score, tallyColumns) {\n      self.postMessage({ type: 'result', seed, score, tallyColumns: Array.from(tallyColumns) });\n    });\n    pId = MotelyWasmEvents.onProgress.subscribe(function(searched, matching) {\n      self.postMessage({ type: 'progress', searched: searched.toString(), matching: matching.toString() });\n    });\n    cId = MotelyWasmEvents.onComplete.subscribe(function(status, searched, matched) {\n      cleanup();\n      self.postMessage({ type: 'complete', status, searched: searched.toString(), matched: matched.toString() });\n    });\n\n    try {\n      const mode = msg.mode || 'random';\n\n      if (mode === 'random') {\n        activeSearch = MotelyWasm.startRandomSearch(msg.jaml, msg.count);\n      } else if (mode === 'aesthetic') {\n        activeSearch = MotelyWasm.startAestheticSearch(msg.jaml, msg.aesthetic);\n      } else if (mode === 'seedList') {\n        activeSearch = MotelyWasm.startSeedListSearch(msg.jaml, msg.seeds);\n      } else if (mode === 'keyword') {\n        activeSearch = MotelyWasm.startKeywordSearch(msg.jaml, msg.keywords, msg.padding || '');\n      } else if (mode === 'sequential') {\n        activeSearch = MotelyWasm.startSequentialSearch(msg.jaml, msg.batchCharCount, BigInt(msg.startBatch), BigInt(msg.endBatch));\n      } else {\n        self.postMessage({ type: 'error', message: 'Unknown search mode: ' + mode });\n        cleanup();\n        return;\n      }\n    } catch (err) {\n      cleanup();\n      self.postMessage({ type: 'error', message: String(err) });\n    }\n    return;\n  }\n\n  if (msg.type === 'stop') {\n    if (activeSearch) { activeSearch.cancel(); activeSearch = null; }\n    self.postMessage({ type: 'cancelled' });\n  }\n\n  if (msg.type === 'get_tally_labels') {\n    if (!MotelyWasm) { self.postMessage({ type: 'error', message: 'Not initialized' }); return; }\n    try {\n      const labels = MotelyWasm.getTallyLabels(msg.jaml);\n      self.postMessage({ type: 'tally_labels', labels });\n    } catch (err) {\n      self.postMessage({ type: 'error', message: String(err) });\n    }\n  }\n});\n";

package/dist/hooks/searchWorkerCode.js

@@ -1,8 +1,7 @@
-// Worker code as an inline string — created as a Blob URL at runtime.
-// This avoids bundler/import.meta.url issues when shipped as an npm package.
 export const SEARCH_WORKER_CODE = `
 let MotelyWasm = null;
 let MotelyWasmEvents = null;
+let Filters = null;
 let activeSearch = null;
 
 self.addEventListener('message', async function(e) {
@@ -14,6 +13,7 @@ self.addEventListener('message', async function(e) {
       await mod.default.boot();
       MotelyWasm = mod.MotelyWasm;
       MotelyWasmEvents = mod.MotelyWasmEvents;
+      Filters = mod.Filters;
       self.postMessage({ type: 'ready' });
     } catch (err) {
       self.postMessage({ type: 'error', message: String(err) });
@@ -34,8 +34,8 @@ self.addEventListener('message', async function(e) {
       activeSearch = null;
     }
 
-    rId = MotelyWasmEvents.onResult.subscribe(function(seed, score) {
-      self.postMessage({ type: 'result', seed, score });
+    rId = MotelyWasmEvents.onResult.subscribe(function(seed, score, tallyColumns) {
+      self.postMessage({ type: 'result', seed, score, tallyColumns: Array.from(tallyColumns) });
     });
     pId = MotelyWasmEvents.onProgress.subscribe(function(searched, matching) {
       self.postMessage({ type: 'progress', searched: searched.toString(), matching: matching.toString() });
@@ -46,7 +46,23 @@ self.addEventListener('message', async function(e) {
     });
 
     try {
-      activeSearch = MotelyWasm.startRandomSearch(msg.jaml, msg.count);
+      const mode = msg.mode || 'random';
+
+      if (mode === 'random') {
+        activeSearch = MotelyWasm.startRandomSearch(msg.jaml, msg.count);
+      } else if (mode === 'aesthetic') {
+        activeSearch = MotelyWasm.startAestheticSearch(msg.jaml, msg.aesthetic);
+      } else if (mode === 'seedList') {
+        activeSearch = MotelyWasm.startSeedListSearch(msg.jaml, msg.seeds);
+      } else if (mode === 'keyword') {
+        activeSearch = MotelyWasm.startKeywordSearch(msg.jaml, msg.keywords, msg.padding || '');
+      } else if (mode === 'sequential') {
+        activeSearch = MotelyWasm.startSequentialSearch(msg.jaml, msg.batchCharCount, BigInt(msg.startBatch), BigInt(msg.endBatch));
+      } else {
+        self.postMessage({ type: 'error', message: 'Unknown search mode: ' + mode });
+        cleanup();
+        return;
+      }
     } catch (err) {
       cleanup();
       self.postMessage({ type: 'error', message: String(err) });
@@ -58,5 +74,15 @@ self.addEventListener('message', async function(e) {
     if (activeSearch) { activeSearch.cancel(); activeSearch = null; }
     self.postMessage({ type: 'cancelled' });
   }
+
+  if (msg.type === 'get_tally_labels') {
+    if (!MotelyWasm) { self.postMessage({ type: 'error', message: 'Not initialized' }); return; }
+    try {
+      const labels = MotelyWasm.getTallyLabels(msg.jaml);
+      self.postMessage({ type: 'tally_labels', labels });
+    } catch (err) {
+      self.postMessage({ type: 'error', message: String(err) });
+    }
+  }
 });
 `;

package/dist/hooks/useAnalyzer.d.ts

@@ -1,9 +1,31 @@
 import type { AnalyzerAnteView } from "../components/AnalyzerExplorer.js";
 export type AnalyzerStatus = "idle" | "running" | "done" | "error";
+export type MotelyJsRunState = {
+    voucherBitfield: number;
+    bossBitfield: number;
+};
+/**
+ * Snapshot of the live search context after `analyze()` resolves, exposed so
+ * higher-level components can open additional streams (shop chunks, soul-
+ * joker chunks, pack contents) on demand without re-walking the seed. The
+ * `runStates` map is keyed by ante and holds the runState AFTER the boss +
+ * voucher have been resolved for that ante — i.e. the correct input for
+ * `createShopItemStream(ante, runState, ...)`.
+ */
+export interface AnalyzerLive {
+    ctx: any;
+    Motely: any;
+    runStates: Record<number, MotelyJsRunState>;
+    desiredNames: ReadonlySet<string>;
+    seed: string;
+    deck: string;
+    stake: string;
+}
 export declare function useAnalyzer(motelyWasmUrl: string): {
     antes: AnalyzerAnteView[];
     status: AnalyzerStatus;
     error: string | null;
     analyze: (seed: string, deck: string, stake: string, jaml?: string) => Promise<void>;
     clearError: () => void;
+    live: AnalyzerLive | null;
 };

package/dist/hooks/useAnalyzer.js

@@ -7,8 +7,10 @@ export function useAnalyzer(motelyWasmUrl) {
     const [antes, setAntes] = useState([]);
     const [status, setStatus] = useState("idle");
     const [error, setError] = useState(null);
+    const [live, setLive] = useState(null);
     const analyze = useCallback(async (seed, deck, stake, jaml) => {
         setAntes([]);
+        setLive(null);
         setStatus("running");
         setError(null);
         try {
@@ -26,6 +28,7 @@ export function useAnalyzer(motelyWasmUrl) {
             const bossStream = ctx.createBossStream();
             let runState = { voucherBitfield: 0, bossBitfield: 0 };
             const results = [];
+            const runStates = {};
             for (let ante = 1; ante <= 8; ante++) {
                 const bossResult = ctx.getNextBossForAnte(bossStream, ante, runState);
                 const bossName = Motely.MotelyBossBlind[bossResult.boss] ?? `Unknown(${bossResult.boss})`;
@@ -33,6 +36,7 @@ export function useAnalyzer(motelyWasmUrl) {
                 const voucherResult = ctx.getAnteFirstVoucher(ante, runState);
                 const voucherName = Motely.MotelyVoucher[voucherResult.voucher] ?? `Unknown(${voucherResult.voucher})`;
                 runState = voucherResult.runState;
+                runStates[ante] = { ...runState };
                 const tagStream = ctx.createTagStream(ante);
                 const tag1 = ctx.getNextTag(tagStream);
                 const tag2 = ctx.getNextTag(tagStream);
@@ -61,6 +65,7 @@ export function useAnalyzer(motelyWasmUrl) {
                 });
             }
             setAntes(results);
+            setLive({ ctx, Motely, runStates, desiredNames, seed, deck, stake });
             setStatus("done");
         }
         catch (e) {
@@ -72,5 +77,5 @@ export function useAnalyzer(motelyWasmUrl) {
         setError(null);
         setStatus((s) => (s === "error" ? "idle" : s));
     }, []);
-    return { antes, status, error, analyze, clearError };
+    return { antes, status, error, analyze, clearError, live };
 }

package/dist/hooks/useSearch.d.ts

@@ -1,6 +1,7 @@
 export interface SearchResult {
     seed: string;
     score: number;
+    tallyColumns?: number[];
 }
 export type SearchStatus = "idle" | "booting" | "running" | "completed" | "cancelled" | "error";
 export interface UseSearchState {
@@ -9,14 +10,22 @@ export interface UseSearchState {
     matchingSeeds: bigint;
     status: SearchStatus;
     error: string | null;
+    seedsPerSecond: number;
+    tallyLabels: string[];
 }
 export declare function useSearch(motelyWasmUrl: string): {
     start: (jaml: string, count: number) => void;
+    startAesthetic: (jaml: string, aesthetic: number) => void;
+    startSeedList: (jaml: string, seeds: string[]) => void;
+    startKeyword: (jaml: string, keywords: string, padding?: string) => void;
     cancel: () => void;
     clearError: () => void;
+    fetchTallyLabels: (jaml: string) => void;
     results: SearchResult[];
     totalSearched: bigint;
     matchingSeeds: bigint;
     status: SearchStatus;
     error: string | null;
+    seedsPerSecond: number;
+    tallyLabels: string[];
 };

package/dist/hooks/useSearch.js

@@ -8,16 +8,20 @@ function createWorker(motelyWasmUrl) {
     worker.postMessage({ type: "init", url: motelyWasmUrl });
     return worker;
 }
+const INITIAL_STATE = {
+    results: [],
+    totalSearched: 0n,
+    matchingSeeds: 0n,
+    status: "idle",
+    error: null,
+    seedsPerSecond: 0,
+    tallyLabels: [],
+};
 export function useSearch(motelyWasmUrl) {
-    const [state, setState] = useState({
-        results: [],
-        totalSearched: 0n,
-        matchingSeeds: 0n,
-        status: "idle",
-        error: null,
-    });
+    const [state, setState] = useState(INITIAL_STATE);
     const workerRef = useRef(null);
     const readyRef = useRef(false);
+    const speedRef = useRef({ lastSearched: 0n, lastTime: 0, ema: 0 });
     useEffect(() => {
         setState((s) => ({ ...s, status: "booting" }));
         const worker = createWorker(motelyWasmUrl);
@@ -30,16 +34,51 @@ export function useSearch(motelyWasmUrl) {
                 setState((s) => s.status === "booting" ? { ...s, status: "idle" } : s);
             }
             else if (msg.type === "result") {
-                setState((s) => ({ ...s, results: [...s.results, { seed: msg.seed, score: msg.score }] }));
+                setState((s) => ({
+                    ...s,
+                    results: [...s.results, {
+                            seed: msg.seed,
+                            score: msg.score,
+                            tallyColumns: msg.tallyColumns,
+                        }],
+                }));
             }
             else if (msg.type === "progress") {
-                setState((s) => ({ ...s, totalSearched: BigInt(msg.searched), matchingSeeds: BigInt(msg.matching) }));
+                const searched = BigInt(msg.searched);
+                const matching = BigInt(msg.matching);
+                const now = performance.now();
+                const ref = speedRef.current;
+                let sps = ref.ema;
+                if (ref.lastTime > 0) {
+                    const dtMs = now - ref.lastTime;
+                    if (dtMs > 0) {
+                        const delta = Number(searched - ref.lastSearched);
+                        const instantSps = delta / (dtMs / 1000);
+                        sps = ref.ema === 0 ? instantSps : ref.ema * 0.7 + instantSps * 0.3;
+                    }
+                }
+                ref.lastSearched = searched;
+                ref.lastTime = now;
+                ref.ema = sps;
+                setState((s) => ({ ...s, totalSearched: searched, matchingSeeds: matching, seedsPerSecond: Math.round(sps) }));
             }
             else if (msg.type === "complete") {
-                setState((s) => ({ ...s, status: msg.status === "Completed" ? "completed" : "error", error: msg.status !== "Completed" ? msg.status : null, totalSearched: BigInt(msg.searched), matchingSeeds: BigInt(msg.matched) }));
+                speedRef.current = { lastSearched: 0n, lastTime: 0, ema: 0 };
+                setState((s) => ({
+                    ...s,
+                    status: msg.status === "Completed" ? "completed" : "error",
+                    error: msg.status !== "Completed" ? msg.status : null,
+                    totalSearched: BigInt(msg.searched),
+                    matchingSeeds: BigInt(msg.matched),
+                    seedsPerSecond: 0,
+                }));
             }
             else if (msg.type === "cancelled") {
-                setState((s) => ({ ...s, status: "cancelled" }));
+                speedRef.current = { lastSearched: 0n, lastTime: 0, ema: 0 };
+                setState((s) => ({ ...s, status: "cancelled", seedsPerSecond: 0 }));
+            }
+            else if (msg.type === "tally_labels") {
+                setState((s) => ({ ...s, tallyLabels: msg.labels }));
             }
             else if (msg.type === "error") {
                 setState((s) => ({ ...s, status: "error", error: msg.message }));
@@ -50,13 +89,15 @@ export function useSearch(motelyWasmUrl) {
             workerRef.current = null;
         };
     }, [motelyWasmUrl]);
-    const start = useCallback((jaml, count) => {
+    const sendStart = useCallback((payload) => {
         const worker = workerRef.current;
         if (!worker)
             return;
-        setState({ results: [], totalSearched: 0n, matchingSeeds: 0n, status: "running", error: null });
+        speedRef.current = { lastSearched: 0n, lastTime: 0, ema: 0 };
+        setState({ ...INITIAL_STATE, status: "running", tallyLabels: state.tallyLabels });
+        const send = () => worker.postMessage(payload);
         if (readyRef.current) {
-            worker.postMessage({ type: "start", jaml, count });
+            send();
         }
         else {
             const orig = worker.onmessage;
@@ -64,16 +105,31 @@ export function useSearch(motelyWasmUrl) {
                 orig?.call(worker, e);
                 if (e.data.type === "ready") {
                     worker.onmessage = orig;
-                    worker.postMessage({ type: "start", jaml, count });
+                    send();
                 }
             };
         }
-    }, []);
+    }, [state.tallyLabels]);
+    const start = useCallback((jaml, count) => {
+        sendStart({ type: "start", mode: "random", jaml, count });
+    }, [sendStart]);
+    const startAesthetic = useCallback((jaml, aesthetic) => {
+        sendStart({ type: "start", mode: "aesthetic", jaml, aesthetic });
+    }, [sendStart]);
+    const startSeedList = useCallback((jaml, seeds) => {
+        sendStart({ type: "start", mode: "seedList", jaml, seeds });
+    }, [sendStart]);
+    const startKeyword = useCallback((jaml, keywords, padding) => {
+        sendStart({ type: "start", mode: "keyword", jaml, keywords, padding });
+    }, [sendStart]);
     const cancel = useCallback(() => {
         workerRef.current?.postMessage({ type: "stop" });
     }, []);
     const clearError = useCallback(() => {
         setState((s) => (s.error || s.status === "error" ? { ...s, error: null, status: "idle" } : s));
     }, []);
-    return { ...state, start, cancel, clearError };
+    const fetchTallyLabels = useCallback((jaml) => {
+        workerRef.current?.postMessage({ type: "get_tally_labels", jaml });
+    }, []);
+    return { ...state, start, startAesthetic, startSeedList, startKeyword, cancel, clearError, fetchTallyLabels };
 }

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export { Layer, type LayerOptions } from "./render/Layer.js";
 export { JamlCardRenderer, type JamlCardRendererProps } from "./render/CanvasRenderer.js";
 export { JamlGameCard, JamlVoucher, JamlTag, JamlBoss, resolveAnalyzerShopItem, type JamlGameCardProps, type AnalyzerShopItem, type AnalyzerResolvedItem, } from "./components/GameCard.js";
 export { AnalyzerExplorer, type AnalyzerAnteView, type AnalyzerBadge, type AnalyzerExplorerProps, type AnalyzerFact, type AnalyzerHighlight, type AnalyzerItem, } from "./components/AnalyzerExplorer.js";
+export { JamlAnalyzerFullscreen, type JamlAnalyzerFullscreenProps, } from "./components/JamlAnalyzerFullscreen.js";
+export { ANALYZER_STREAM_META, DEFAULT_ENABLED_STREAMS, type AnalyzerStreamKey, type AnalyzerStreamMeta, } from "./hooks/analyzerStreamRegistry.js";
 export { JamlMapPreview, type JamlMapPreviewProps } from "./components/JamlMapPreview.js";
 export { JamlIde, type JamlIdeProps, type JamlIdeSearchResult, type JamlVisualFilter, type JamlVisualClause, type JamlZone, } from "./components/JamlIde.js";
 export { JamlIdeVisual, type JamlIdeVisualProps, } from "./components/JamlIdeVisual.js";
@@ -16,9 +18,13 @@ export { JimboTooltip, type JimboTooltipProps, type JimboTooltipMode, type Jimbo
 export { JamlIdeToolbar, type JamlIdeMode, type JamlIdeToolbarProps, } from "./components/JamlIdeToolbar.js";
 export { CardList, type CardListProps } from "./components/CardList.js";
 export { CardFan, type CardFanProps } from "./components/CardFan.js";
+export { RealPlayingCard, type CardSuit, type CardRank, type CardEnhancement, type CardSeal, type CardEdition, } from "./components/PlayingCard.js";
 export { DeckSprite, DECK_SPRITE_POS, STAKE_SPRITE_POS, type DeckSpriteProps, } from "./components/DeckSprite.js";
 export { MotelyVersionBadge, type MotelyVersionBadgeProps, type MotelyCapabilities, } from "./components/MotelyVersionBadge.js";
 export { extractVisualJamlItems, type JamlPreviewGroups, type JamlPreviewItem, type JamlPreviewSection, type JamlPreviewVisualType, } from "./utils/jamlMapPreview.js";
 export { useMotelyStream, type StreamItem, type StreamState } from "./hooks/useShopStream.js";
 export { useSearch, type SearchResult, type SearchStatus, type UseSearchState, } from "./hooks/useSearch.js";
-export { useAnalyzer, type AnalyzerStatus, } from "./hooks/useAnalyzer.js";
+export { useAnalyzer, type AnalyzerStatus, type AnalyzerLive, type MotelyJsRunState, } from "./hooks/useAnalyzer.js";
+export { JamlSpeedometer, type JamlSpeedometerProps, } from "./components/JamlSpeedometer.js";
+export { JamlAestheticSelector, type JamlAestheticSelectorProps, type JamlAestheticOption, } from "./components/JamlAestheticSelector.js";
+export { JamlSeedInput, type JamlSeedInputProps, } from "./components/JamlSeedInput.js";

package/dist/index.js

@@ -4,6 +4,8 @@ export { Layer } from "./render/Layer.js";
 export { JamlCardRenderer } from "./render/CanvasRenderer.js";
 export { JamlGameCard, JamlVoucher, JamlTag, JamlBoss, resolveAnalyzerShopItem, } from "./components/GameCard.js";
 export { AnalyzerExplorer, } from "./components/AnalyzerExplorer.js";
+export { JamlAnalyzerFullscreen, } from "./components/JamlAnalyzerFullscreen.js";
+export { ANALYZER_STREAM_META, DEFAULT_ENABLED_STREAMS, } from "./hooks/analyzerStreamRegistry.js";
 export { JamlMapPreview } from "./components/JamlMapPreview.js";
 export { JamlIde, } from "./components/JamlIde.js";
 export { JamlIdeVisual, } from "./components/JamlIdeVisual.js";
@@ -17,9 +19,13 @@ export { JimboTooltip, } from "./ui/jimboTooltip.js";
 export { JamlIdeToolbar, } from "./components/JamlIdeToolbar.js";
 export { CardList } from "./components/CardList.js";
 export { CardFan } from "./components/CardFan.js";
+export { RealPlayingCard, } from "./components/PlayingCard.js";
 export { DeckSprite, DECK_SPRITE_POS, STAKE_SPRITE_POS, } from "./components/DeckSprite.js";
 export { MotelyVersionBadge, } from "./components/MotelyVersionBadge.js";
 export { extractVisualJamlItems, } from "./utils/jamlMapPreview.js";
 export { useMotelyStream } from "./hooks/useShopStream.js";
 export { useSearch, } from "./hooks/useSearch.js";
 export { useAnalyzer, } from "./hooks/useAnalyzer.js";
+export { JamlSpeedometer, } from "./components/JamlSpeedometer.js";
+export { JamlAestheticSelector, } from "./components/JamlAestheticSelector.js";
+export { JamlSeedInput, } from "./components/JamlSeedInput.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaml-ui",
-  "version": "0.11.1",
+  "version": "0.14.0",
   "description": "Balatro rendering components, sprite metadata, and optional Motely helpers for React apps.",
   "type": "module",
   "main": "./dist/index.js",