@hex-core/payload

function buildAppContext(input: {
	theme: { requested: string; resolved: Theme | null };
	components: { slug: string; item: RegistryItem | null }[];
	recipes: { slug: string; recipe: Recipe | null }[];
	density?: "compact" | "comfortable" | "spacious";
	overrides?: Record<string, string>;
}): string;

import { buildAppContext, loadRegistryItem } from "@hex-core/payload";
import { defaultTheme } from "@hex-core/tokens";

const components = ["button", "card", "input"].map((slug) => ({
	slug,
	item: loadRegistryItem(slug),
}));

const markdown = buildAppContext({
	theme: { requested: "default", resolved: defaultTheme },
	components,
	recipes: [],
	density: "comfortable",
});

// Render markdown in a Server Component, write to disk, etc.

interface FigmaTokensInput {
	theme: { requested: string; resolved: FigmaTokensTheme | null };
}

function buildFigmaTokens(input: FigmaTokensInput): string;

import { buildFigmaTokens, getTheme } from "@hex-core/payload";

const slug = "midnight";
const markdown = buildFigmaTokens({
	theme: { requested: slug, resolved: getTheme(slug) ?? null },
});
console.log(markdown.slice(0, 80));
// → "## Figma Variables payload — midnight\n..."

interface FigmaTokensTheme {
	name: string;
	displayName: string;
	tokens: { light: Record<string, TokenValue>; dark: Record<string, TokenValue>; };
}

interface FigmaPayloadResult {
	payload: FigmaVariablesPayload;
	skipped: Array<{ key: string; type: TokenValue["type"] }>;
}

function buildFigmaPayload(theme: FigmaTokensTheme): FigmaPayloadResult;

import { buildFigmaPayload } from "@hex-core/payload";
import { defaultTheme } from "@hex-core/tokens";

const { payload, skipped } = buildFigmaPayload(defaultTheme);

console.log(payload.variables.length);
// → number of tokens emitted as Figma Variables

if (skipped.length > 0) {
	console.warn("Figma can't represent:", skipped);
	// → [{ key: "shadow-md", type: "shadow" }, ...]
}

function loadRegistryItem(slug: string): RegistryItem | null;
function loadRegistry(): RegistryIndex;

interface RegistryIndex {
	name: string;
	version: string;
	description: string;
	homepage: string;
	items: Array<{
		name: string;
		displayName: string;
		description: string;
		category: string;
		subcategory?: string;
		tags: string[];
		internalDeps: string[];
		tokenBudget?: number;
	}>;
}

import { loadRegistry, loadRegistryItem } from "@hex-core/payload";

const idx = loadRegistry();
console.log(idx.items.length); // 185 (at @0.4.1)

const button = loadRegistryItem("button");
if (button) {
	console.log(button.ai.whenToUse);
}

function loadRecipes(): RecipeIndex;
function loadRecipe(slug: string): Recipe | null;

interface RecipeIndex {
	name: string;
	version: string;
	items: Array<{
		slug: string;
		title: string;
		summary: string;
		tags: string[];
		components: string[];   // flat slug list, derived from steps
		tokenBudget?: number;
	}>;
}

import { loadRecipes, loadRecipe } from "@hex-core/payload";

// Index path: pull the components list straight off the index entry.
const idx = loadRecipes();
const auth = idx.items.find((i) => i.slug === "auth-form");
console.log(auth?.components); // ["button", "input", "label", ...]

// Full-recipe path: components live under steps, not directly on Recipe.
const full = loadRecipe("auth-form");
console.log(full?.steps.map((s) => s.component));

function getTheme(name: string): Theme | undefined;
function listThemes(): readonly {
	name: string;
	displayName: string;
	description: string;
	category?: string;
	tags?: string[];
	brand?: string;
}[];

import { getTheme, listThemes } from "@hex-core/payload";

const theme = getTheme("midnight") ?? getTheme("default");
console.log(listThemes().map((t) => t.name));

interface ComponentMatch {
	component: string;
	displayName: string;
	score: number;
	matchReason: string[];
	whenToUse: string;
	whenNotToUse: string;
	relatedComponents: string[];
	tokenBudget?: number;
}

interface RecipeMatch {
	slug: string;
	title: string;
	summary: string;
	score: number;
	matchReason: string[];
}

interface ResolveResult {
	brief: string;
	components: ComponentMatch[];
	recipes: RecipeMatch[];
}

interface ResolverOptions {
	limit?: number;
	registry?: RegistryIndex;
	recipes?: RecipeIndex;
}

function resolveSpec(brief: string, options?: ResolverOptions): ResolveResult;

import { resolveSpec } from "@hex-core/payload";

const result = resolveSpec("confirm-destructive dialog with checkbox and dual-action footer");

for (const m of result.components.slice(0, 3)) {
	console.log(`${m.score.toFixed(2)} ${m.component} — ${m.matchReason[0]}`);
}
// → 0.92 dialog — "destructive" matched whenToUse
// → 0.81 button — "dual-action footer" matched whenToUse
// → 0.74 checkbox — explicit slug match

// app/llm-context/page.tsx
import { buildAppContext, loadRegistryItem } from "@hex-core/payload";
import { defaultTheme } from "@hex-core/tokens";

export default function LlmContextPage() {
	const components = ["button", "card", "input", "dialog"].map((slug) => ({
		slug,
		item: loadRegistryItem(slug),
	}));

	const markdown = buildAppContext({
		theme: { requested: "default", resolved: defaultTheme },
		components,
		recipes: [],
	});

	return <pre>{markdown}</pre>;
}

// scripts/sync-figma-tokens.ts
import { buildFigmaTokens, getTheme } from "@hex-core/payload";
import { writeFileSync } from "node:fs";

const requested = process.env.THEME ?? "default";
const theme = getTheme(requested);
if (!theme) throw new Error("Unknown theme");

const markdown = buildFigmaTokens({
	theme: { requested, resolved: theme },
});

writeFileSync("./design/figma-tokens.md", markdown);
console.log("Wrote figma-tokens.md");