jaml-ui 4.4.0 → 4.6.0

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

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { ReactSpec } from '@json-render/react';
+import { Spec } from '@json-render/core';
+import { jimboCatalog } from './catalog.js';
+export interface JimboJsonRendererProps {
+    /** The AI-generated JSON UI specification */
+    spec: ReactSpec<typeof jimboCatalog> | Spec | null;
+    /** Whether the spec is currently streaming / loading from an LLM */
+    loading?: boolean;
+    /** Optional container className */
+    className?: string;
+    /** Optional container style */
+    style?: React.CSSProperties;
+}
+/**
+ * Jimbo Generative UI Renderer (powered by Vercel Labs `@json-render`).
+ *
+ * Automatically mounts inside `<JimboApp>` so all generated components receive
+ * the authentic pixel font, felt background, and zero-flex CSS Grid layout.
+ */
+export declare function JimboJsonRenderer({ spec, loading, className, style, }: JimboJsonRendererProps): React.JSX.Element | null;

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

@@ -1,204 +1,328 @@
-import { BadgeTone } from './components/layout.js';
+import { z } from 'zod';
 /**
- * Balatro Catalog — Component vocabulary for AI-generated UI.
+ * Jimbo generative-UI catalog for Vercel Labs' `@json-render`.
  *
- * Type-safe at compile time. Zero runtime overhead.
- * The AI sees these names + descriptions + prop shapes.
+ * Defines the type-safe catalog of Jimbo design system components and
+ * Balatro card sprites that an AI model may emit specs against.
  */
-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;
+export declare const jimboCatalog: import('@json-render/core').Catalog<{
+    spec: import('@json-render/core').SchemaType<"object", {
+        root: import('@json-render/core').SchemaType<"string", unknown>;
+        elements: import('@json-render/core').SchemaType<"record", import('@json-render/core').SchemaType<"object", {
+            type: import('@json-render/core').SchemaType<"ref", string>;
+            props: import('@json-render/core').SchemaType<"propsOf", string>;
+            children: import('@json-render/core').SchemaType<"array", import('@json-render/core').SchemaType<"string", unknown>>;
+            slots: {
+                optional: true;
+                kind: "record";
+                inner?: import('@json-render/core').SchemaType<"array", import('@json-render/core').SchemaType<"string", unknown>> | undefined;
+            };
+            visible: {
+                optional: true;
+                kind: "any";
+                inner?: unknown;
+            };
+            repeat: {
+                optional: true;
+                kind: "any";
+                inner?: unknown;
+            };
+        }>>;
+    }>;
+    catalog: import('@json-render/core').SchemaType<"object", {
+        components: import('@json-render/core').SchemaType<"map", {
+            props: import('@json-render/core').SchemaType<"zod", unknown>;
+            slots: import('@json-render/core').SchemaType<"array", import('@json-render/core').SchemaType<"string", unknown>>;
+            description: import('@json-render/core').SchemaType<"string", unknown>;
+            example: import('@json-render/core').SchemaType<"any", unknown>;
+        }>;
+        actions: import('@json-render/core').SchemaType<"map", {
+            params: import('@json-render/core').SchemaType<"zod", unknown>;
+            description: import('@json-render/core').SchemaType<"string", unknown>;
+        }>;
+    }>;
+}, {
+    components: {
+        JimboPanel: {
+            props: z.ZodObject<{
+                title: z.ZodOptional<z.ZodString>;
+                tone: z.ZodOptional<z.ZodEnum<{
+                    red: "red";
+                    orange: "orange";
+                    blue: "blue";
+                    green: "green";
+                    purple: "purple";
+                    gold: "gold";
+                    dark: "dark";
+                }>>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                title: string;
+                tone: string;
+            };
         };
-        description: string;
-    };
-    Spacer: {
-        props: {
-            size?: number;
+        JimboInnerPanel: {
+            props: z.ZodObject<{
+                className: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {};
         };
-        description: string;
-    };
-    Divider: {
-        props: {
-            className?: string;
+        JimboRow: {
+            props: z.ZodObject<{
+                gap: z.ZodOptional<z.ZodEnum<{
+                    xs: "xs";
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+                wrap: z.ZodOptional<z.ZodBoolean>;
+                align: z.ZodOptional<z.ZodEnum<{
+                    start: "start";
+                    center: "center";
+                    end: "end";
+                    stretch: "stretch";
+                }>>;
+                justify: z.ZodOptional<z.ZodEnum<{
+                    start: "start";
+                    center: "center";
+                    end: "end";
+                    between: "between";
+                }>>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                gap: string;
+                align: string;
+            };
         };
-        description: string;
-    };
-    Badge: {
-        props: {
-            label: string;
-            tone?: "red" | "blue" | "green" | "orange" | "gold" | "purple" | "grey";
-            className?: string;
+        JimboStack: {
+            props: z.ZodObject<{
+                gap: z.ZodOptional<z.ZodEnum<{
+                    xs: "xs";
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+                align: z.ZodOptional<z.ZodEnum<{
+                    start: "start";
+                    center: "center";
+                    end: "end";
+                    stretch: "stretch";
+                }>>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                gap: string;
+                align: 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;
+        JimboBox: {
+            props: z.ZodObject<{
+                className: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {};
         };
-        description: string;
-    };
-    LoadingPulse: {
-        props: {
-            text?: string;
+        JamlGameCard: {
+            props: z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodDefault<z.ZodEnum<{
+                    playing: "playing";
+                    joker: "joker";
+                    consumable: "consumable";
+                }>>;
+                scale: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                name: string;
+                type: string;
+                scale: number;
+            };
         };
-        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";
+        StandardCard: {
+            props: z.ZodObject<{
+                rank: z.ZodString;
+                suit: z.ZodDefault<z.ZodEnum<{
+                    Hearts: "Hearts";
+                    Clubs: "Clubs";
+                    Diamonds: "Diamonds";
+                    Spades: "Spades";
+                }>>;
+                enhancement: z.ZodOptional<z.ZodString>;
+                edition: z.ZodOptional<z.ZodString>;
+                seal: z.ZodOptional<z.ZodString>;
+                size: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                rank: string;
+                suit: string;
+                size: number;
+            };
         };
-        description: string;
-    };
-    EditionBadge: {
-        props: {
-            edition: "Foil" | "Holographic" | "Polychrome" | "Negative";
+        DeckSprite: {
+            props: z.ZodObject<{
+                deck: z.ZodDefault<z.ZodString>;
+                stake: z.ZodOptional<z.ZodString>;
+                size: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                deck: string;
+                stake: string;
+                size: number;
+            };
         };
-        description: string;
-    };
-    JamlGameCard: {
-        props: {
-            type: "joker" | "consumable" | "playing";
-            card: {
-                name: string;
-                edition?: string;
-                seal?: string;
-                isEternal?: boolean;
-                isPerishable?: boolean;
-                isRental?: boolean;
-                scale?: number;
+        JamlyzerSeedCard: {
+            props: z.ZodObject<{
+                seed: z.ZodString;
+                score: z.ZodOptional<z.ZodNumber>;
+                pinned: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                seed: string;
+                score: number;
+                pinned: boolean;
             };
         };
-        description: string;
-    };
-    JammyMascot: {
-        props: {
-            mood?: "idle" | "happy" | "surprised";
-            size?: number;
-            menuItems?: {
+        JimboButton: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                tone: z.ZodDefault<z.ZodEnum<{
+                    red: "red";
+                    orange: "orange";
+                    blue: "blue";
+                    green: "green";
+                }>>;
+                size: z.ZodDefault<z.ZodEnum<{
+                    xs: "xs";
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+                action: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
                 label: string;
-                action: string;
-                tone?: BadgeTone;
-            }[];
-            onMenuAction?: boolean;
+                tone: string;
+                size: string;
+            };
         };
-        description: string;
-    };
-    JammyOrbitalMenu: {
-        props: {
-            items: {
-                label: string;
-                action: string;
-                tone?: BadgeTone;
-            }[];
-            radius?: number;
+        JimboBadge: {
+            props: z.ZodObject<{
+                text: z.ZodString;
+                tone: z.ZodDefault<z.ZodEnum<{
+                    red: "red";
+                    orange: "orange";
+                    blue: "blue";
+                    green: "green";
+                    purple: "purple";
+                    grey: "grey";
+                    dark: "dark";
+                }>>;
+                size: z.ZodDefault<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                }>>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                text: string;
+                tone: string;
+                size: string;
+            };
         };
-        description: string;
-    };
-    JokerCard: {
-        props: {
-            name: string;
-            showSynergies?: boolean;
+        JimboText: {
+            props: z.ZodObject<{
+                text: z.ZodString;
+                size: z.ZodDefault<z.ZodEnum<{
+                    title: "title";
+                    micro: "micro";
+                    xs: "xs";
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+                tone: z.ZodDefault<z.ZodEnum<{
+                    red: "red";
+                    blue: "blue";
+                    green: "green";
+                    gold: "gold";
+                    grey: "grey";
+                    white: "white";
+                }>>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                text: string;
+                tone: string;
+                size: string;
+            };
         };
-        description: string;
-    };
-    SynergyCard: {
-        props: {
-            name: string;
+        JimboSeedCopyChip: {
+            props: z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                value: string;
+            };
         };
-        description: string;
-    };
-    BossBlindCard: {
-        props: {
-            name: string;
+        JimboStatusPill: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                status: z.ZodDefault<z.ZodEnum<{
+                    error: "error";
+                    idle: "idle";
+                    paused: "paused";
+                    running: "running";
+                    ok: "ok";
+                }>>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                status: string;
+            };
         };
-        description: string;
     };
-    DeckCard: {
-        props: {
-            name: string;
+    actions: {
+        copySeed: {
+            params: z.ZodObject<{
+                seed: z.ZodString;
+            }, z.core.$strip>;
+            description: string;
         };
-        description: string;
-    };
-    StakeCard: {
-        props: {
-            name: string;
+        selectSeed: {
+            params: z.ZodObject<{
+                seed: z.ZodString;
+            }, z.core.$strip>;
+            description: string;
         };
-        description: string;
-    };
-    StrategyAdvisor: {
-        props: {
-            jokers: string[];
+        loadJaml: {
+            params: z.ZodObject<{
+                jaml: z.ZodString;
+            }, z.core.$strip>;
+            description: 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/index.d.ts

@@ -1,30 +1,5 @@
-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';
+export { jimboCatalog } from './catalog.js';
+export { jimboRegistry, jimboHandlers, executeJimboAction, } from './registry.js';
+export { JimboJsonRenderer, type JimboJsonRendererProps, } from './JimboJsonRenderer.js';
+export { defineCatalog, defineDirective, validateSpec, autoFixSpec, buildUserPrompt, type Catalog, type Spec, type InferSpec, type InferCatalogComponents, } from '@json-render/core';
+export { Renderer, defineRegistry, createRenderer, StateProvider, JSONUIProvider, useStateStore, useStateValue, type ReactSpec, type ReactSchema, } from '@json-render/react';

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

@@ -1,14 +1,4 @@
-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.
+ * Official Jimbo Component Registry for Vercel `@json-render/react`.
  */
-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;
+export declare const jimboRegistry: import('@json-render/react').ComponentRegistry, jimboHandlers: (getSetState: () => import('@json-render/react').SetState | undefined, getState: () => import('@json-render/core').StateModel) => Record<string, (params: Record<string, unknown>) => Promise<void>>, executeJimboAction: (actionName: string, params: Record<string, unknown> | undefined, setState: import('@json-render/react').SetState, state?: import('@json-render/core').StateModel) => Promise<void>;

package/dist/lib/daily/ritual.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A daily ritual is a single JAML file. Nothing is hardcoded: the filter body is
+ * real, engine-valid JAML (deck/stake/must/should), and the presentation metadata
+ * rides as `# key: value` header comments so the validator never sees a key it
+ * would reject. One `.jaml` file fully defines a ritual — title, flavor, hint, the
+ * cards to show, and the filter to search.
+ *
+ * This is the shape `DailyRitualView` renders and the app authors in the UX. It is
+ * pure parsing — no React, no hooks, no engine — so it runs in Node and the browser
+ * alike and never needs a client boundary.
+ */
+export interface DailyRitual {
+    /** Display title. From the JAML `name:` key, or a `# title:` comment, else "Daily Ritual". */
+    title: string;
+    /** One-line summary. From the JAML `description:` key or a `# description:` comment. */
+    description?: string;
+    /** Metadata carried as header comments so the filter stays engine-valid. */
+    emoji?: string;
+    flavor?: string;
+    hint?: string;
+    /** Rank to spotlight as a card sprite, e.g. "2", "K", "A". */
+    focusRank?: string;
+    /** Joker to spotlight as a card sprite, e.g. "WeeJoker". */
+    targetJoker?: string;
+    /** Optional theme label, e.g. "Foil Friday". */
+    theme?: string;
+    /** The raw JAML source, exactly as authored — the single source of truth. */
+    jaml: string;
+}
+/**
+ * Parse a ritual from its JAML source.
+ *
+ * Two channels, by design:
+ * - `# key: value` comment lines carry presentation metadata (emoji, flavor, hint,
+ *   focusRank, targetJoker, theme, and optionally title/description).
+ * - top-level `name:` and `description:` JAML keys are read as title/description
+ *   when no comment overrides them, so a ritual authored as plain JAML still titles
+ *   itself. Only single-line scalars are read here; a block scalar (`>` or `|`) is
+ *   left to the metadata comment instead of half-parsed.
+ *
+ * The raw text is preserved verbatim on `.jaml`; the filter body is never rewritten.
+ */
+export declare function parseRitual(jamlText: string): DailyRitual;