Skip to content
VEXA
Newv0.1.0 · 24 primitives

Interfaces, engineered.

VEXA is the Valfiguer Experience Architecture — an Open Code interface system. You do not install a runtime component library; you copy accessible component source into your product and own it, styled entirely through semantic design tokens.

npx shadcn@latest add https://vexa.valfiguer.com/r/button.json

Own the code. Shape the system.

components/vexa

Deployment

Production · vexa

Live
v0.1.024 components3 themes

Server-first by default

This card is a Server Component — no client JavaScript.

Rendered live — Server Components, zero client JS.

Built on the standards you already use

Open Code

The source you install is the source you own

No black box, no wrapper API. Pick a primitive and read the exact file that lands in components/vexa — the same code the registry serves.

components/vexa/button.tsxtsx
import type * as React from "react";
import { Slot } from "@radix-ui/react-slot";
import { cva, type VariantProps } from "class-variance-authority";

import { cn } from "@/lib/utils";

export const buttonVariants = cva(
  [
    "inline-flex select-none items-center justify-center gap-2 whitespace-nowrap",
    "rounded-vexa-md text-sm font-medium",
    "transition-[color,background-color,border-color,box-shadow]",
    "duration-[var(--vexa-duration-fast)] ease-[var(--vexa-ease-standard)]",
    "outline-none focus-visible:ring-2 focus-visible:ring-vexa-ring",
    "focus-visible:ring-offset-2 focus-visible:ring-offset-vexa-background",
    "disabled:pointer-events-none disabled:opacity-50",
    "aria-[busy=true]:pointer-events-none aria-[busy=true]:cursor-progress",
    "[&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
  ],
  {
    variants: {
      variant: {
        primary:
          "bg-vexa-primary text-vexa-primary-foreground hover:bg-vexa-primary/90 active:bg-vexa-primary/95",
        secondary:
          "border border-vexa-border bg-vexa-secondary text-vexa-secondary-foreground hover:bg-vexa-accent active:bg-vexa-accent",
        outline:
          "border border-vexa-input bg-transparent text-vexa-foreground hover:bg-vexa-accent hover:text-vexa-accent-foreground active:bg-vexa-accent",
        ghost:
          "bg-transparent text-vexa-foreground hover:bg-vexa-accent hover:text-vexa-accent-foreground active:bg-vexa-accent",
        danger:
          "bg-vexa-danger text-vexa-danger-foreground hover:bg-vexa-danger/90 active:bg-vexa-danger/95",
        link: "bg-transparent text-vexa-focus underline-offset-4 hover:underline focus-visible:ring-offset-0",
      },
      size: {
        sm: "h-8 px-3 text-xs",
        md: "h-10 px-4",
        lg: "h-12 px-6 text-base",
      },
    },
    defaultVariants: {
      variant: "primary",
      size: "md",
    },
  },
);

export interface ButtonProps
  extends React.ComponentProps<"button">, VariantProps<typeof buttonVariants> {
  /**
   * Render the button's styles onto its single child element instead of a
   * native `<button>` (e.g. to style a link). The child owns its own
   * semantics; ensure it remains keyboard-operable.
   */
  asChild?: boolean;
}

/**
 * Button — triggers an action or submits a form.
 *
 * RSC-safe: contains no state or effects, so it renders on the server. Attach
 * `onClick` from a Client Component when interactivity is required. Refs are
 * accepted as a regular prop (React 19).
 */
export function Button({
  className,
  variant,
  size,
  asChild = false,
  type,
  ...props
}: ButtonProps) {
  const Comp = asChild ? Slot : "button";
  return (
    <Comp
      data-slot="button"
      className={cn(buttonVariants({ variant, size }), className)}
      type={asChild ? undefined : (type ?? "button")}
      {...props}
    />
  );
}

Install this file

npx shadcn@latest add https://vexa.valfiguer.com/r/button.json
Why VEXA

A system, not a dependency

Everything VEXA ships is readable, editable, and yours — from the token contract to the last focus ring.

Open Code

Install component source, not a black box. Read it, change it, delete it — the interface belongs to your repository.

Server-first (RSC)

Primitives render as Server Components by default. The 'use client' boundary sits only at the smallest interactive leaf.

Three themes, one contract

Light, Obsidian, and Graphite ship from a single set of semantic HSL tokens. Switch with one data attribute.

Accessible by architecture

WCAG 2.2 AA is built into the primitives, examples, and tests — keyboard models, focus, and contrast, never bolted on.

AI-native

An MCP server and a Design Skill expose the catalog, tokens, and rules so coding agents assemble VEXA UI correctly.

shadcn-compatible registry

Items follow the shadcn registry schema, so you can install with tooling you already know or copy the source by hand.

Architecture

Engineered for how you actually build

The same three ideas run through every primitive — ownership, server-first rendering, and a single token contract.

button.tsx
card.tsx
field.tsx

Copy the source, own the system

Every primitive installs as a file in components/vexa — the same code the registry serves. Edit behavior where it lives, not through a sprawling prop API.

server
use client

Server-first, client at the leaf

Primitives render as Server Components. Interactivity is isolated to the smallest 'use client' leaf, so pages stay fast and streamable.

Light
Obsidian
Graphite

One token contract, three themes

Light, Obsidian, and Graphite come from a single set of semantic HSL tokens. Switch the whole system with one data attribute.

Workflow

The Open Code loop

Four steps take a primitive from the registry into code you own.

  1. 01

    Find it

    Browse the gallery or ask the MCP server to search the catalog.

  2. 02

    Add it

    Run the install command, or copy the source into components/vexa.

  3. 03

    Own it

    The files are yours: edit behavior in the source instead of a prop API.

  4. 04

    Theme it

    Style only through --vexa-* tokens so every theme stays consistent.

By the numbers

Small surface, serious rigor

24Accessible primitives
3Themes, one contract
7MCP tools for agents
AAWCAG 2.2 baseline
Design tenets

The rules the whole system answers to

VEXA has no customers to quote yet — so here are the load-bearing rules every primitive is built against instead.

Install the source, not a dependency. You copy accessible component code into your repository and own it outright — read it, change it, delete it.

Open Code

Render on the server by default. The 'use client' boundary sits at the smallest interactive leaf, never a whole page or section.

RSC boundaries

Never hardcode a color. Every visual decision resolves through a --vexa-* semantic token, so one contract drives all three themes.

Token contract

Meaning never rides on color alone. State is carried by icon, text, border, and shape too — validated against WCAG 2.2 AA.

Accessibility

Every applicable state gets a visible treatment: hover, focus-visible, active, disabled, invalid, busy, and read-only.

Component API

The catalog is never hardcoded. The MCP server reads VEXA's own source at request time, so agents always see what actually ships.

AI-native

Get started

Start building

Configure the registry once, then add your first accessible primitive.