jaml-ui 2.3.1 → 2.5.1

package/dist/json-render/builders/analyzer.d.ts

@@ -0,0 +1,23 @@
+import { JsonNode } from '../engine.js';
+/**
+ * Build a json-render spec for seed analysis results.
+ *
+ * Shows the full breakdown of a single seed: jokers, shop, blinds, etc.
+ */
+export interface AnalyzerResult {
+    seed: string;
+    jokers: Array<{
+        name: string;
+        edition?: string;
+        seal?: string;
+        isEternal?: boolean;
+    }>;
+    shopItems?: Array<{
+        name: string;
+        type: string;
+        edition?: string;
+    }>;
+    score?: number;
+    notes?: string[];
+}
+export declare function buildAnalyzerSpec(result: AnalyzerResult): JsonNode;

package/dist/json-render/builders/encyclopedia.d.ts

@@ -0,0 +1,14 @@
+import { JsonNode } from '../engine.js';
+/**
+ * Build a json-render spec for the encyclopedia view.
+ *
+ * Shows joker info, synergies, and strategy advice for a set of jokers.
+ */
+export interface EncyclopediaParams {
+    jokers: string[];
+    decks?: string[];
+    stakes?: string[];
+    bosses?: string[];
+    showStrategies?: boolean;
+}
+export declare function buildEncyclopediaSpec(params: EncyclopediaParams): JsonNode;

package/dist/json-render/builders/search.d.ts

@@ -0,0 +1,24 @@
+import { JsonNode } from '../engine.js';
+/**
+ * Build a json-render spec for search results.
+ *
+ * Pure function. Converts raw Motely search data into a JsonNode tree.
+ * The tree renders into a full search UI via `render(spec, registry)`.
+ */
+export interface SearchResult {
+    seed: string;
+    score: number;
+    highlights?: string[];
+    jokers?: string[];
+    edition?: string;
+}
+export interface SearchParams {
+    status: "idle" | "running" | "completed" | "error";
+    seedsSearched?: string;
+    matchesFound?: number;
+    seedsPerSecond?: number;
+    elapsed?: string;
+    error?: string | null;
+    results: SearchResult[];
+}
+export declare function buildSearchSpec(params: SearchParams): JsonNode;

package/dist/json-render/catalog.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Balatro Catalog — Component vocabulary for AI-generated UI.
+ *
+ * Type-safe at compile time. Zero runtime overhead.
+ * The AI sees these names + descriptions + prop shapes.
+ */
+export declare const balatroCatalog: {
+    Panel: {
+        props: {
+            title?: string;
+            subtitle?: string;
+            variant?: "default" | "accent" | "muted";
+            className?: string;
+        };
+        description: string;
+    };
+    Stack: {
+        props: {
+            gap?: number;
+            align?: "start" | "center" | "end" | "stretch";
+            className?: string;
+        };
+        description: string;
+    };
+    Grid: {
+        props: {
+            columns?: number;
+            gap?: number;
+            className?: string;
+        };
+        description: string;
+    };
+    Text: {
+        props: {
+            body: string;
+            variant?: "title" | "body" | "muted" | "accent" | "error";
+            className?: string;
+        };
+        description: string;
+    };
+    Spacer: {
+        props: {
+            size?: number;
+        };
+        description: string;
+    };
+    Divider: {
+        props: {
+            className?: string;
+        };
+        description: string;
+    };
+    Badge: {
+        props: {
+            label: string;
+            tone?: "red" | "blue" | "green" | "orange" | "gold" | "purple" | "grey";
+            className?: string;
+        };
+        description: string;
+    };
+    SearchStats: {
+        props: {
+            status: "idle" | "running" | "completed" | "error";
+            seedsSearched?: string;
+            matchesFound?: number;
+            seedsPerSecond?: number;
+            elapsed?: string;
+        };
+        description: string;
+    };
+    ErrorBanner: {
+        props: {
+            message: string;
+            onDismiss?: boolean;
+        };
+        description: string;
+    };
+    LoadingPulse: {
+        props: {
+            text?: string;
+        };
+        description: string;
+    };
+    SeedCard: {
+        props: {
+            seed: string;
+            score?: number;
+            rank?: number;
+            highlights?: string[];
+            jokers?: string[];
+            edition?: string;
+            onClick?: boolean;
+        };
+        description: string;
+    };
+    SeedList: {
+        props: {
+            seeds: string[];
+            scores?: number[];
+            total?: number;
+            pageSize?: number;
+        };
+        description: string;
+    };
+    JokerBadge: {
+        props: {
+            name: string;
+            edition?: "Foil" | "Holographic" | "Polychrome" | "Negative";
+            rarity?: "Common" | "Uncommon" | "Rare" | "Legendary";
+        };
+        description: string;
+    };
+    EditionBadge: {
+        props: {
+            edition: "Foil" | "Holographic" | "Polychrome" | "Negative";
+        };
+        description: string;
+    };
+    JamlGameCard: {
+        props: {
+            type: "joker" | "consumable" | "playing";
+            card: {
+                name: string;
+                edition?: string;
+                seal?: string;
+                isEternal?: boolean;
+                isPerishable?: boolean;
+                isRental?: boolean;
+            };
+            scale?: number;
+        };
+        description: string;
+    };
+    JokerCard: {
+        props: {
+            name: string;
+            showSynergies?: boolean;
+        };
+        description: string;
+    };
+    SynergyCard: {
+        props: {
+            name: string;
+        };
+        description: string;
+    };
+    BossBlindCard: {
+        props: {
+            name: string;
+        };
+        description: string;
+    };
+    DeckCard: {
+        props: {
+            name: string;
+        };
+        description: string;
+    };
+    StakeCard: {
+        props: {
+            name: string;
+        };
+        description: string;
+    };
+    StrategyAdvisor: {
+        props: {
+            jokers: string[];
+        };
+        description: string;
+    };
+};
+export type BalatroCatalog = typeof balatroCatalog;
+export type BalatroComponentName = keyof BalatroCatalog;
+/**
+ * Extract the props type for a given catalog component.
+ */
+export type CatalogProps<K extends BalatroComponentName> = BalatroCatalog[K] extends {
+    props: infer P;
+} ? P : never;

package/dist/json-render/components/domain.d.ts

@@ -0,0 +1,58 @@
+import { default as React } from 'react';
+/**
+ * Domain components — SearchStats, ErrorBanner, LoadingPulse, SeedCard, etc.
+ *
+ * These are Balatro-specific UI components used by the json-render system.
+ * All use CSS tokens and the layout primitives above.
+ */
+export interface SearchStatsProps {
+    status: "idle" | "running" | "completed" | "error";
+    seedsSearched?: string;
+    matchesFound?: number;
+    seedsPerSecond?: number;
+    elapsed?: string;
+    className?: string;
+}
+export declare const SearchStats: React.FC<SearchStatsProps>;
+export interface ErrorBannerProps {
+    message: string;
+    onDismiss?: boolean;
+    className?: string;
+}
+export declare const ErrorBanner: React.FC<ErrorBannerProps>;
+export interface LoadingPulseProps {
+    text?: string;
+    className?: string;
+}
+export declare const LoadingPulse: React.FC<LoadingPulseProps>;
+export interface SeedCardProps {
+    seed: string;
+    score?: number;
+    rank?: number;
+    highlights?: string[];
+    jokers?: string[];
+    edition?: string;
+    onClick?: boolean;
+    className?: string;
+}
+export declare const SeedCard: React.FC<SeedCardProps>;
+export interface SeedListProps {
+    seeds: string[];
+    scores?: number[];
+    total?: number;
+    pageSize?: number;
+    className?: string;
+}
+export declare const SeedList: React.FC<SeedListProps>;
+export interface JokerBadgeProps {
+    name: string;
+    edition?: "Foil" | "Holographic" | "Polychrome" | "Negative";
+    rarity?: "Common" | "Uncommon" | "Rare" | "Legendary";
+    className?: string;
+}
+export declare const JokerBadge: React.FC<JokerBadgeProps>;
+export interface EditionBadgeProps {
+    edition: "Foil" | "Holographic" | "Polychrome" | "Negative";
+    className?: string;
+}
+export declare const EditionBadge: React.FC<EditionBadgeProps>;

package/dist/json-render/components/game.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+/**
+ * Game Card wrapper — bridges json-render to jaml-ui's sprite system.
+ *
+ * We lazily import the real JamlGameCard so json-render has no hard dependency
+ * on jaml-ui's heavy sprite imports. The consumer must import this component
+ * AND have jaml-ui available in their bundle.
+ */
+export interface JamlGameCardProps {
+    type: "joker" | "consumable" | "playing";
+    card: {
+        name: string;
+        edition?: string;
+        seal?: string;
+        isEternal?: boolean;
+        isPerishable?: boolean;
+        isRental?: boolean;
+    };
+    scale?: number;
+    className?: string;
+}
+export declare const JamlGameCard: React.FC<JamlGameCardProps>;

package/dist/json-render/components/layout.d.ts

@@ -0,0 +1,50 @@
+import { default as React } from 'react';
+/**
+ * Layout primitives — Panel, Stack, Grid, Text, Spacer, Divider, Badge.
+ *
+ * All use CSS custom properties from jimbo-tokens.css.
+ * No external classes. No BEM. Just inline styles + tokens.
+ */
+export interface PanelProps {
+    title?: string;
+    subtitle?: string;
+    variant?: "default" | "accent" | "muted";
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare const Panel: React.FC<PanelProps>;
+export interface StackProps {
+    gap?: number;
+    align?: "start" | "center" | "end" | "stretch";
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare const Stack: React.FC<StackProps>;
+export interface GridProps {
+    columns?: number;
+    gap?: number;
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare const Grid: React.FC<GridProps>;
+export interface TextProps {
+    body: string;
+    variant?: "title" | "body" | "muted" | "accent" | "error";
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare const Text: React.FC<TextProps>;
+export interface SpacerProps {
+    size?: number;
+}
+export declare const Spacer: React.FC<SpacerProps>;
+export interface DividerProps {
+    className?: string;
+}
+export declare const Divider: React.FC<DividerProps>;
+export interface BadgeProps {
+    label: string;
+    tone?: "red" | "blue" | "green" | "orange" | "gold" | "purple" | "grey";
+    className?: string;
+}
+export declare const Badge: React.FC<BadgeProps>;

package/dist/json-render/components/reference.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+/**
+ * Reference Components — Encyclopedia UI for Balatro entities.
+ *
+ * All components query the knowledge base and render rich info cards.
+ * Zero external dependencies. Pure React + CSS tokens.
+ */
+export interface JokerCardProps {
+    name: string;
+    showSynergies?: boolean;
+    className?: string;
+}
+export declare const JokerCard: React.FC<JokerCardProps>;
+export interface SynergyCardProps {
+    name: string;
+    className?: string;
+}
+export declare const SynergyCard: React.FC<SynergyCardProps>;
+export interface BossBlindCardProps {
+    name: string;
+    className?: string;
+}
+export declare const BossBlindCard: React.FC<BossBlindCardProps>;
+export interface DeckCardProps {
+    name: string;
+    className?: string;
+}
+export declare const DeckCard: React.FC<DeckCardProps>;
+export interface StakeCardProps {
+    name: string;
+    className?: string;
+}
+export declare const StakeCard: React.FC<StakeCardProps>;
+export interface StrategyAdvisorProps {
+    jokers: string[];
+    className?: string;
+}
+export declare const StrategyAdvisor: React.FC<StrategyAdvisorProps>;

package/dist/json-render/engine.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+/**
+ * json-render — Zero-dependency JSON-to-React engine.
+ *
+ * A JsonNode is a plain JSON object describing a UI tree.
+ * A Registry maps type names to React components.
+ * render() walks the tree and returns React nodes.
+ */
+export interface JsonNode {
+    type: string;
+    props?: Record<string, unknown>;
+    children?: JsonNode[];
+}
+export type ComponentProps<P = Record<string, unknown>> = P & {
+    children?: React.ReactNode;
+};
+export type Registry = Record<string, React.ComponentType<any>>;
+/**
+ * Render a JsonNode tree using the provided Registry.
+ *
+ * Unknown types log a warning and render null (graceful degradation).
+ * Each child gets a stable key from its index in the children array.
+ */
+export declare function render(node: JsonNode, registry: Registry): React.ReactNode;
+/**
+ * Render a list of JsonNode trees.
+ */
+export declare function renderList(nodes: JsonNode[], registry: Registry): React.ReactNode[];
+/**
+ * Type-safe catalog builder.
+ *
+ * Just returns the catalog object as-is, but enforces types at compile time.
+ * No runtime overhead. No zod. Just TypeScript.
+ */
+export declare function defineCatalog<C extends Record<string, {
+    props?: object;
+    description?: string;
+}>>(catalog: C): C;

package/dist/json-render/index.d.ts

@@ -0,0 +1,28 @@
+export { render, renderList, defineCatalog } from './engine.js';
+export type { JsonNode, ComponentProps, Registry } from './engine.js';
+export { balatroCatalog } from './catalog.js';
+export type { BalatroCatalog, BalatroComponentName, CatalogProps } from './catalog.js';
+export { balatroRegistry } from './registry.js';
+export type { BalatroRegistry } from './registry.js';
+export { Panel, Stack, Grid, Text, Spacer, Divider, Badge, } from './components/layout.js';
+export type { PanelProps, StackProps, GridProps, TextProps, SpacerProps, DividerProps, BadgeProps, } from './components/layout.js';
+export { SearchStats, ErrorBanner, LoadingPulse, SeedCard, SeedList, JokerBadge, EditionBadge, } from './components/domain.js';
+export type { SearchStatsProps, ErrorBannerProps, LoadingPulseProps, SeedCardProps, SeedListProps, JokerBadgeProps, EditionBadgeProps, } from './components/domain.js';
+export { JamlGameCard } from './components/game.js';
+export type { JamlGameCardProps } from './components/game.js';
+export { JokerCard, SynergyCard, BossBlindCard, DeckCard, StakeCard, StrategyAdvisor, } from './components/reference.js';
+export type { JokerCardProps, SynergyCardProps, BossBlindCardProps, DeckCardProps, StakeCardProps, StrategyAdvisorProps, } from './components/reference.js';
+export { buildSearchSpec } from './builders/search.js';
+export type { SearchResult, SearchParams } from './builders/search.js';
+export { buildEncyclopediaSpec } from './builders/encyclopedia.js';
+export type { EncyclopediaParams } from './builders/encyclopedia.js';
+export { buildAnalyzerSpec } from './builders/analyzer.js';
+export type { AnalyzerResult } from './builders/analyzer.js';
+export { JOKERS, getJoker, getJokersByCategory, getSynergies } from './knowledge/jokers.js';
+export type { JokerInfo, JokerRarity, JokerCategory } from './knowledge/jokers.js';
+export { SYNERGIES, findSynergies, findSynergiesByTag, getRecommendedSynergies } from './knowledge/synergies.js';
+export type { SynergyInfo } from './knowledge/synergies.js';
+export { DECKS, STAKES, getDeck, getStake } from './knowledge/decks.js';
+export type { DeckInfo, StakeInfo } from './knowledge/decks.js';
+export { BOSSES, FINISHERS, getBoss, getBossesByCategory, getAllBosses } from './knowledge/bosses.js';
+export type { BossInfo, BossCategory } from './knowledge/bosses.js';

package/dist/json-render/knowledge/bosses.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Balatro Boss Blind Knowledge Base
+ */
+export type BossCategory = "Debuffer" | "Restrictor" | "Obfuscator" | "Scaler" | "Economic";
+export interface BossInfo {
+    name: string;
+    jamlKey: string;
+    category: BossCategory;
+    effect: string;
+    counters: string[];
+    jamlAvoid: string;
+    threatLevel: "Low" | "Medium" | "High" | "Lethal";
+}
+export declare const BOSSES: Record<string, BossInfo>;
+export declare const FINISHERS: BossInfo[];
+export declare function getBoss(name: string): BossInfo | undefined;
+export declare function getBossesByCategory(category: BossCategory): BossInfo[];
+export declare function getAllBosses(): BossInfo[];

package/dist/json-render/knowledge/decks.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Balatro Deck & Stake Knowledge Base
+ */
+export interface DeckInfo {
+    name: string;
+    jamlKey: string;
+    effect: string;
+    strategy: string;
+    synergies: string[];
+    difficulty: "Easy" | "Medium" | "Hard";
+}
+export declare const DECKS: Record<string, DeckInfo>;
+export interface StakeInfo {
+    name: string;
+    jamlKey: string;
+    effect: string;
+    strategy: string;
+    difficulty: "Easy" | "Medium" | "Hard" | "Expert";
+}
+export declare const STAKES: StakeInfo[];
+export declare function getDeck(name: string): DeckInfo | undefined;
+export declare function getStake(name: string): StakeInfo | undefined;

package/dist/json-render/knowledge/jokers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Balatro Joker Knowledge Base
+ * Extracted from the Master Encyclopedia for json-render reference components.
+ */
+export type JokerRarity = "Common" | "Uncommon" | "Rare" | "Legendary";
+export type JokerCategory = "Copy" | "X-Mult" | "Flat" | "Economy" | "Retrigger" | "Utility";
+export interface JokerInfo {
+    name: string;
+    rarity: JokerRarity;
+    cost: number;
+    effect: string;
+    category: JokerCategory;
+    synergies: string[];
+    strategy: string;
+    jamlKey: string;
+}
+export declare const JOKERS: Record<string, JokerInfo>;
+/** Get joker info by name. Returns undefined if not found. */
+export declare function getJoker(name: string): JokerInfo | undefined;
+/** Get all jokers in a category. */
+export declare function getJokersByCategory(category: JokerCategory): JokerInfo[];
+/** Get jokers that synergize with a given joker. */
+export declare function getSynergies(jokerName: string): JokerInfo[];

package/dist/json-render/knowledge/synergies.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Balatro Synergy Knowledge Base
+ * Meta combinations and their mathematical breakdowns.
+ */
+export interface SynergyInfo {
+    name: string;
+    jokers: string[];
+    description: string;
+    math: string;
+    setup: string[];
+    difficulty: "Easy" | "Medium" | "Hard" | "Legendary";
+    bossCounters: string[];
+    tags: string[];
+}
+export declare const SYNERGIES: SynergyInfo[];
+/** Find synergies that involve a specific joker. */
+export declare function findSynergies(jokerName: string): SynergyInfo[];
+/** Find synergies by tag. */
+export declare function findSynergiesByTag(tag: string): SynergyInfo[];
+/** Get recommended synergies for a set of jokers. */
+export declare function getRecommendedSynergies(jokerNames: string[]): SynergyInfo[];

package/dist/json-render/registry.d.ts

@@ -0,0 +1,14 @@
+import { Registry } from './engine.js';
+/**
+ * Balatro Component Registry
+ *
+ * Maps catalog component names to real React implementations.
+ * This is the ONLY place where catalog names are bound to code.
+ * Add new components here → they instantly work in json-render specs.
+ */
+export declare const balatroRegistry: Registry;
+/**
+ * Type-safe registry helper.
+ * Ensures all catalog names have a matching component at compile time.
+ */
+export type BalatroRegistry = typeof balatroRegistry;

package/dist/lib/hooks/useSeedAnalyzer.d.ts

@@ -1,17 +1,5 @@
-import { Program as MotelyNamespace } from 'motely-wasm/motely/wasm';
-import { JamlyzerSnapshot } from 'motely-wasm/motely/analysis';
-type MotelyApi = typeof MotelyNamespace;
-/** Per-seed result shape, reassembled from the split motely-wasm 21.1 API
- *  (the old jamlyzer(config) bundled score + analysis per seed). */
-export interface SeedAnalyzerResult {
-    seed: string;
-    score: number;
-    tallies: number[];
-    analysis: JamlyzerSnapshot;
-}
-export declare function useSeedAnalyzer(motely: MotelyApi | null, seed: string | null, jaml?: string): {
-    data: SeedAnalyzerResult | null;
+export declare function useSeedAnalyzer(seed: string | null, jaml?: string): {
+    data: any;
     loading: boolean;
     error: string | null;
 };
-export {};

package/dist/lib/motely/runtime.d.ts

@@ -1,13 +1,40 @@
-import { MotelyScoredSeedResult } from 'motely-wasm/motely';
+import { JamlAesthetic, JamlConfig, MotelyJamlyzerSeedResult } from 'motely-wasm';
 export type MotelyRuntimeStatus = "idle" | "booting" | "ready" | "error";
-export type JimmolateProbe = (result: MotelyScoredSeedResult) => boolean;
+export declare function parseJaml(jaml: string): JamlConfig;
+/** Column labels for a parsed filter's score tallies (was `MotelyJamlyzerResult.tallyLabels`). */
+export declare function tallyLabelsFor(config: JamlConfig): string[];
+type JimmolateProbe = (seed: string, deck: number, stake: number) => boolean;
 /** Swap the active Jimmolate predicate. Safe before or after boot. */
 export declare function setJimmolateProbe(pred: JimmolateProbe): void;
 /** Reset the probe to pass-through (the engine's default: every survivor matches). */
 export declare function clearJimmolateProbe(): void;
+/** Turn the Jimmolate predicate layer on/off (was `Program.enableJimmolate()`). */
+export declare function enableJimmolate(on?: boolean): void;
+export type EngineSearchMode = "aesthetic" | "seedlist" | "random" | "sequential";
+export interface RunSearchOptions {
+    seeds?: string[];
+    count?: number;
+    aesthetic?: JamlAesthetic | number;
+    startBatchIndex?: bigint;
+    endBatchIndex?: bigint;
+    batchCharacterCount?: number;
+}
+export declare function aestheticSeeds(aesthetic: JamlAesthetic | number): string[];
+/**
+ * Run a search to completion against an already-parsed config.
+ *
+ * v23 searches are fire-and-forget Promises (no IMotelySearch handle, no
+ * mid-search cancel). Subscribe to MotelySearch.onProgress / onScoredResult /
+ * onSeedMatch BEFORE calling this; the returned Promise resolves when the engine
+ * finishes. Callers cancel by tearing down their runtime (e.g. terminating the
+ * worker) — there is no engine-level cancel in v23.
+ */
+export declare function runSearch(config: JamlConfig, mode: EngineSearchMode, opts?: RunSearchOptions): Promise<void>;
+/** Analyze one or more seeds against a parsed config (was `Program.jamlyzer`). */
+export declare function analyzeSeeds(config: JamlConfig): MotelyJamlyzerSeedResult[];
 export declare const MOTELY_BIN_PATH = "/motely-wasm/bin";
-/** True once the optional File System extension was bound before boot. */
 export declare function isFileSystemReady(): boolean;
-/** The error from a failed or absent File System init, if any. */
+/** The reason the File System Access API is unavailable, or null when it's ready. */
 export declare function getFileSystemError(): unknown;
 export declare function ensureMotelyReady(): Promise<void>;
+export {};

package/dist/lib/types.d.ts

@@ -1,4 +1,4 @@
-import { MotelyDeck, MotelyStake } from 'motely-wasm/motely/enums';
+import { MotelyDeck, MotelyStake } from 'motely-wasm';
 export type DeckType = MotelyDeck;
 export type StakeType = MotelyStake;
 /**

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): any;