jaml-ui 2.4.0 → 3.0.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,204 @@
+import { BadgeTone } from './components/layout.js';
+/**
+ * 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;
+    };
+    JammyMascot: {
+        props: {
+            mood?: "idle" | "happy" | "surprised";
+            size?: number;
+            menuItems?: {
+                label: string;
+                action: string;
+                tone?: BadgeTone;
+            }[];
+            onMenuAction?: boolean;
+        };
+        description: string;
+    };
+    JammyOrbitalMenu: {
+        props: {
+            items: {
+                label: string;
+                action: string;
+                tone?: BadgeTone;
+            }[];
+            radius?: 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 { FC } 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: FC<SearchStatsProps>;
+export interface ErrorBannerProps {
+    message: string;
+    onDismiss?: boolean;
+    className?: string;
+}
+export declare const ErrorBanner: FC<ErrorBannerProps>;
+export interface LoadingPulseProps {
+    text?: string;
+    className?: string;
+}
+export declare const LoadingPulse: 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: FC<SeedCardProps>;
+export interface SeedListProps {
+    seeds: string[];
+    scores?: number[];
+    total?: number;
+    pageSize?: number;
+    className?: string;
+}
+export declare const SeedList: FC<SeedListProps>;
+export interface JokerBadgeProps {
+    name: string;
+    edition?: "Foil" | "Holographic" | "Polychrome" | "Negative";
+    rarity?: "Common" | "Uncommon" | "Rare" | "Legendary";
+    className?: string;
+}
+export declare const JokerBadge: FC<JokerBadgeProps>;
+export interface EditionBadgeProps {
+    edition: "Foil" | "Holographic" | "Polychrome" | "Negative";
+    className?: string;
+}
+export declare const EditionBadge: FC<EditionBadgeProps>;

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

@@ -0,0 +1,18 @@
+import { FC } from 'react';
+/**
+ * Game Card wrapper — bridges json-render to jaml-ui's sprite system.
+ */
+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: FC<JamlGameCardProps>;

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

@@ -0,0 +1,51 @@
+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 type BadgeTone = "red" | "blue" | "green" | "orange" | "gold" | "purple" | "grey";
+export interface BadgeProps {
+    label: string;
+    tone?: BadgeTone;
+    className?: string;
+}
+export declare const Badge: React.FC<BadgeProps>;

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

@@ -0,0 +1,22 @@
+import { FC } from 'react';
+import { BadgeTone } from './layout.js';
+export interface JammyOrbitalMenuItem {
+    label: string;
+    action: string;
+    tone?: BadgeTone;
+}
+export interface JammyOrbitalMenuProps {
+    items: JammyOrbitalMenuItem[];
+    onAction?: (action: string) => void;
+    radius?: number;
+    className?: string;
+}
+export declare const JammyOrbitalMenu: FC<JammyOrbitalMenuProps>;
+export interface JammyMascotProps {
+    mood?: "idle" | "happy" | "surprised";
+    size?: number;
+    menuItems?: JammyOrbitalMenuItem[];
+    onMenuAction?: (action: string) => void;
+    className?: string;
+}
+export declare const JammyMascot: FC<JammyMascotProps>;

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

@@ -0,0 +1,38 @@
+import { FC } 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: FC<JokerCardProps>;
+export interface SynergyCardProps {
+    name: string;
+    className?: string;
+}
+export declare const SynergyCard: FC<SynergyCardProps>;
+export interface BossBlindCardProps {
+    name: string;
+    className?: string;
+}
+export declare const BossBlindCard: FC<BossBlindCardProps>;
+export interface DeckCardProps {
+    name: string;
+    className?: string;
+}
+export declare const DeckCard: FC<DeckCardProps>;
+export interface StakeCardProps {
+    name: string;
+    className?: string;
+}
+export declare const StakeCard: FC<StakeCardProps>;
+export interface StrategyAdvisorProps {
+    jokers: string[];
+    className?: string;
+}
+export declare const StrategyAdvisor: FC<StrategyAdvisorProps>;

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

@@ -0,0 +1,38 @@
+import { default as React, ReactNode } 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?: 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): ReactNode;
+/**
+ * Render a list of JsonNode trees.
+ */
+export declare function renderList(nodes: JsonNode[], registry: Registry): 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,30 @@
+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 { JammyMascot, JammyOrbitalMenu } from './components/mascot.js';
+export type { JammyMascotProps, JammyOrbitalMenuProps, JammyOrbitalMenuItem, } from './components/mascot.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/motely.d.ts

@@ -1,7 +1,4 @@
 export { default as bootsharp } from 'motely-wasm';
-export { Program as Motely } from 'motely-wasm/motely/wasm';
+export * as Motely from 'motely-wasm';
 export { decodeMotelyItem, decodeMotelyItemToJamlCard, motelyItemTypeName, motelyItemCategory, motelyItemDisplayName, motelyItemRenderCategory, motelyItemEditionName, motelyItemSealName, motelyItemEnhancementName, motelyStandardcardRankName, motelyStandardcardSuitName, decodeMotelyItemName, resolveMotelyItemType, type DecodedMotelyItem, type MotelyItemInput, type MotelyJamlCard, type MotelyRenderableCategory, type MotelyRuntimeItem, } from './decode/motelyItemDecoder.js';
 export { motelyItemToSprite, getMotelySpriteByName, type MotelySpriteData, } from './decode/motelySprite.js';
-export { motelyBossDisplayName, motelyBossDisplayNameFromKey, motelyBoosterPackDisplayName, motelyBoosterPackDisplayNameFromKey, motelyItemDisplayNameFromKey, motelyItemDisplayNameFromValue, motelyTagDisplayName, motelyTagDisplayNameFromKey, motelyVoucherDisplayName, motelyVoucherDisplayNameFromKey, } from './motelyDisplay.js';
-export { useJamlLibrary, type JamlLibraryStatus, type UseJamlLibraryState, } from './hooks/useJamlLibrary.js';
-export { ensureMotelyReady, MOTELY_BIN_PATH, type MotelyRuntimeStatus, } from './lib/motely/runtime.js';