@nastechai-research/ui 0.18.2

package/dist/ui/components/blend-mode.d.ts

@@ -0,0 +1,28 @@
+import { type PolyProps } from '../../utils';
+declare const LAYER_KEYS: {
+    readonly bg: "bgColor";
+    readonly fg: "fgColor";
+    readonly mg: "mgColor";
+};
+type Layer = keyof typeof LAYER_KEYS;
+type LayerSpec = `${Layer}/${number}` | Layer;
+export declare const useBlendMode: (opts?: BlendModeOpts) => BlendColors;
+export declare const withBlendMode: <P extends BlendColors>(Component: React.ComponentType<P>, opts?: BlendModeOpts) => {
+    (props: Omit<P, keyof BlendColors> & Partial<BlendModeOpts>): import("react").JSX.Element;
+    displayName: string;
+};
+export declare const BlendMode: import("../..").PolyComponent<"div", BlendModeOwnProps>;
+interface BlendModeOwnProps extends BlendModeOpts {
+    children?: ((colors: BlendColors) => React.ReactNode) | React.ReactNode;
+}
+export interface BlendColors {
+    backgroundColor?: string;
+    color?: string;
+}
+interface BlendModeOpts {
+    against?: Layer;
+    background?: LayerSpec | string;
+    color?: LayerSpec | string;
+}
+export type BlendModeProps<T extends React.ElementType = 'div'> = PolyProps<T, BlendModeOwnProps>;
+export {};

package/dist/ui/components/blend-mode.js

@@ -0,0 +1,69 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useStore } from "@nanostores/react";
+import { createElement, useMemo } from "react";
+import { getControlAtom } from "../../hooks/use-smooth-controls.js";
+import { cn, polyRef } from "../../utils/index.js";
+import { colorDodge, colorMix } from "../../utils/color.js";
+const LAYER_KEYS = { bg: "bgColor", fg: "fgColor", mg: "mgColor" };
+const parseSpec = (spec) => {
+  const [layer, alpha] = spec.split("/");
+  return [layer, alpha ? parseFloat(alpha) : void 0];
+};
+const useControlColor = (key, fallback) => {
+  const atom = getControlAtom("Lens", key);
+  return (atom ? useStore(atom) : void 0) ?? fallback;
+};
+const useBlend = (against, spec) => {
+  const layerKey = spec?.split("/")[0];
+  const isLayerSpec = layerKey && layerKey in LAYER_KEYS;
+  const [target, alpha] = isLayerSpec ? parseSpec(spec) : [void 0, void 0];
+  const againstColor = useControlColor(LAYER_KEYS[against], "#041c1c");
+  const fgColor = useControlColor(LAYER_KEYS.fg, "#ffe6cb");
+  const mgColor = useControlColor(LAYER_KEYS.mg, "#ffe6cb");
+  const bgColor = useControlColor(LAYER_KEYS.bg, "#ffe6cb");
+  const targetColor = target ? target === "fg" ? fgColor : target === "mg" ? mgColor : bgColor : spec;
+  return useMemo(() => {
+    if (!spec || !targetColor) {
+      return void 0;
+    }
+    const result = colorDodge(againstColor, targetColor);
+    return alpha != null ? colorMix(result, alpha) : result;
+  }, [spec, againstColor, targetColor, alpha]);
+};
+export const useBlendMode = (opts = {}) => {
+  const { against = "bg", background, color } = opts;
+  return {
+    backgroundColor: useBlend(against, background),
+    color: useBlend(against, color)
+  };
+};
+export const withBlendMode = (Component, opts) => {
+  const Wrapped = (props) => {
+    const { against, background, color, ...rest } = props;
+    const colors = useBlendMode({
+      against: against ?? opts?.against,
+      background: background ?? opts?.background,
+      color: color ?? opts?.color
+    });
+    return /* @__PURE__ */ jsx(Component, { ...rest, ...colors });
+  };
+  Wrapped.displayName = `withBlendMode(${Component.displayName ?? Component.name ?? "Component"})`;
+  return Wrapped;
+};
+export const BlendMode = polyRef(
+  ({ against, as, background, children, className, color, style, ...rest }, ref) => {
+    const colors = useBlendMode({ against, background, color });
+    if (typeof children === "function") {
+      return /* @__PURE__ */ jsx(Fragment, { children: children(colors) });
+    }
+    return createElement(as ?? "div", {
+      ...rest,
+      children,
+      className: cn(className),
+      ref,
+      style: { ...colors, ...style }
+    });
+  }
+);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/blink.d.ts

@@ -0,0 +1,6 @@
+export declare function Blink({ className, cursor }: BlinkProps): import("react").JSX.Element;
+interface BlinkProps {
+    className?: string;
+    cursor?: 'block' | 'line';
+}
+export {};

package/dist/ui/components/blink.js

@@ -0,0 +1,17 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../utils/index.js";
+export function Blink({ className, cursor = "block" }) {
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: cn(
+        "blink hidden group-hover:inline-block",
+        "dither ml-1 w-[1.2ch]",
+        cursor === "block" ? "-mb-[0.15em] h-[1.1em]" : "-mb-[0.1em] h-[2px]",
+        className
+      )
+    }
+  );
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiJ3VzZSBjbGllbnQnXG5cbmltcG9ydCB7IGNuIH0gZnJvbSAnLi4vLi4vdXRpbHMnXG5cbmV4cG9ydCBmdW5jdGlvbiBCbGluayh7IGNsYXNzTmFtZSwgY3Vyc29yID0gJ2Jsb2NrJyB9OiBCbGlua1Byb3BzKSB7XG4gIHJldHVybiAoXG4gICAgPHNwYW5cbiAgICAgIGNsYXNzTmFtZT17Y24oXG4gICAgICAgICdibGluayBoaWRkZW4gZ3JvdXAtaG92ZXI6aW5saW5lLWJsb2NrJyxcbiAgICAgICAgJ2RpdGhlciBtbC0xIHctWzEuMmNoXScsXG4gICAgICAgIGN1cnNvciA9PT0gJ2Jsb2NrJyA/ICctbWItWzAuMTVlbV0gaC1bMS4xZW1dJyA6ICctbWItWzAuMWVtXSBoLVsycHhdJyxcbiAgICAgICAgY2xhc3NOYW1lXG4gICAgICApfVxuICAgIC8+XG4gIClcbn1cblxuaW50ZXJmYWNlIEJsaW5rUHJvcHMge1xuICBjbGFzc05hbWU/OiBzdHJpbmdcbiAgY3Vyc29yPzogJ2Jsb2NrJyB8ICdsaW5lJ1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjtBQU1JO0FBSkosU0FBUyxVQUFVO0FBRVosZ0JBQVMsTUFBTSxFQUFFLFdBQVcsU0FBUyxRQUFRLEdBQWU7QUFDakUsU0FDRTtBQUFBLElBQUM7QUFBQTtBQUFBLE1BQ0MsV0FBVztBQUFBLFFBQ1Q7QUFBQSxRQUNBO0FBQUEsUUFDQSxXQUFXLFVBQVUsMkJBQTJCO0FBQUEsUUFDaEQ7QUFBQSxNQUNGO0FBQUE7QUFBQSxFQUNGO0FBRUo7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/ui/components/bottom-sheet.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+/**
+ * Mobile-first bottom sheet with slide + fade enter/exit, drag-to-dismiss
+ * handle, body scroll lock, and reduced-motion support. Portaled to
+ * `document.body` to escape ancestor stacking contexts.
+ */
+export declare function BottomSheet({ backdropDismissLabel, children, onClose, open, title }: BottomSheetProps): import("react").ReactPortal | null;
+interface BottomSheetProps {
+    backdropDismissLabel?: string;
+    children: ReactNode;
+    onClose: () => void;
+    open: boolean;
+    title: string;
+}
+export {};

package/dist/ui/components/bottom-sheet.js

@@ -0,0 +1,192 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import {
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { createPortal } from "react-dom";
+import { cn } from "../../utils/index.js";
+import { Typography } from "./typography/index.js";
+const CLOSE_DRAG_MIN_PX = 72;
+const CLOSE_DRAG_RATIO = 0.18;
+const SHEET_TRANSITION_MS = 280;
+export function BottomSheet({
+  backdropDismissLabel = "Dismiss",
+  children,
+  onClose,
+  open,
+  title
+}) {
+  const [renderPortal, setRenderPortal] = useState(open);
+  const [entered, setEntered] = useState(false);
+  const [dragOffsetPx, setDragOffsetPx] = useState(0);
+  const [dragActive, setDragActive] = useState(false);
+  const closeTimerRef = useRef(null);
+  const sheetRef = useRef(null);
+  const dragTrackingRef = useRef(false);
+  const dragStartYRef = useRef(0);
+  const dragOffsetRef = useRef(0);
+  const reducedMotion = typeof window !== "undefined" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  const syncDragPx = (next) => {
+    dragOffsetRef.current = next;
+    setDragOffsetPx(next);
+  };
+  useEffect(() => {
+    if (closeTimerRef.current) {
+      clearTimeout(closeTimerRef.current);
+      closeTimerRef.current = null;
+    }
+    const ms = reducedMotion ? 0 : SHEET_TRANSITION_MS;
+    let openRafId = 0;
+    let exitRafId = 0;
+    if (open) {
+      openRafId = requestAnimationFrame(() => {
+        dragTrackingRef.current = false;
+        dragOffsetRef.current = 0;
+        setDragActive(false);
+        setDragOffsetPx(0);
+        setRenderPortal(true);
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => setEntered(true));
+        });
+      });
+    } else {
+      exitRafId = requestAnimationFrame(() => {
+        dragTrackingRef.current = false;
+        setDragActive(false);
+        setEntered(false);
+        closeTimerRef.current = window.setTimeout(() => {
+          dragOffsetRef.current = 0;
+          setDragOffsetPx(0);
+          setRenderPortal(false);
+          closeTimerRef.current = null;
+        }, ms);
+      });
+    }
+    return () => {
+      cancelAnimationFrame(openRafId);
+      cancelAnimationFrame(exitRafId);
+      if (closeTimerRef.current) {
+        clearTimeout(closeTimerRef.current);
+        closeTimerRef.current = null;
+      }
+    };
+  }, [open, reducedMotion]);
+  useEffect(() => {
+    if (!renderPortal) return;
+    const prev = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = prev;
+    };
+  }, [renderPortal]);
+  if (!renderPortal || typeof document === "undefined") return null;
+  const durationClass = reducedMotion ? "duration-0" : "duration-[280ms]";
+  const draggingVisual = dragActive || dragOffsetPx > 0;
+  const onDragPointerDown = (e) => {
+    if (reducedMotion || !entered) return;
+    if (e.pointerType === "mouse" && e.button !== 0) return;
+    dragTrackingRef.current = true;
+    setDragActive(true);
+    dragStartYRef.current = e.clientY;
+    syncDragPx(0);
+    e.currentTarget.setPointerCapture(e.pointerId);
+  };
+  const onDragPointerMove = (e) => {
+    if (!dragTrackingRef.current) return;
+    const dy = e.clientY - dragStartYRef.current;
+    const next = Math.max(0, dy);
+    const sheetH = sheetRef.current?.offsetHeight ?? 560;
+    syncDragPx(Math.min(next, sheetH));
+  };
+  const endDrag = (e) => {
+    if (!dragTrackingRef.current) return;
+    dragTrackingRef.current = false;
+    setDragActive(false);
+    try {
+      e.currentTarget.releasePointerCapture(e.pointerId);
+    } catch {
+    }
+    const sheetH = sheetRef.current?.offsetHeight ?? 560;
+    const threshold = Math.max(CLOSE_DRAG_MIN_PX, sheetH * CLOSE_DRAG_RATIO);
+    const d = dragOffsetRef.current;
+    if (d >= threshold) {
+      onClose();
+      return;
+    }
+    syncDragPx(0);
+  };
+  return createPortal(
+    /* @__PURE__ */ jsxs("div", { className: "fixed inset-0 z-[200] flex flex-col justify-end", children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          "aria-label": backdropDismissLabel,
+          className: cn(
+            "absolute inset-0 bg-black/55 backdrop-blur-[2px]",
+            "transition-opacity ease-out motion-reduce:transition-none",
+            durationClass,
+            entered ? "opacity-100" : "opacity-0"
+          ),
+          onClick: onClose,
+          type: "button"
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "div",
+        {
+          "aria-label": title,
+          "aria-modal": "true",
+          className: cn(
+            "relative flex max-h-[85dvh] min-h-0 flex-col rounded-t-xl border border-current/20",
+            "bg-background-base/98 pb-[max(1rem,env(safe-area-inset-bottom))]",
+            "shadow-[0_-12px_40px_-8px_rgba(0,0,0,0.55)] backdrop-blur-md",
+            "ease-out motion-reduce:transition-none transform-gpu",
+            draggingVisual ? "transition-none" : cn("transition-transform", durationClass),
+            entered ? "translate-y-0" : "translate-y-full"
+          ),
+          ref: sheetRef,
+          role: "dialog",
+          style: entered && dragOffsetPx > 0 ? { transform: `translateY(${dragOffsetPx}px)` } : void 0,
+          children: [
+            /* @__PURE__ */ jsxs(
+              "div",
+              {
+                className: cn(
+                  "flex shrink-0 flex-col gap-2 border-b border-current/15 px-4 pb-3 pt-2",
+                  "touch-none select-none",
+                  reducedMotion ? "cursor-default" : "cursor-grab active:cursor-grabbing"
+                ),
+                onPointerCancel: endDrag,
+                onPointerDown: onDragPointerDown,
+                onPointerMove: onDragPointerMove,
+                onPointerUp: endDrag,
+                children: [
+                  /* @__PURE__ */ jsx(
+                    "div",
+                    {
+                      "aria-hidden": true,
+                      className: "mx-auto h-1 w-10 shrink-0 rounded-full bg-current/20"
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    Typography,
+                    {
+                      className: "text-[0.65rem] tracking-[0.15em] uppercase text-midground/70",
+                      mondwest: true,
+                      children: title
+                    }
+                  )
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx("div", { className: "min-h-0 flex-1 overflow-y-auto overscroll-contain", children })
+          ]
+        }
+      )
+    ] }),
+    document.body
+  );
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport {\n  type PointerEvent as ReactPointerEvent,\n  type ReactNode,\n  useEffect,\n  useRef,\n  useState\n} from 'react'\nimport { createPortal } from 'react-dom'\n\nimport { cn } from '../../utils'\nimport { Typography } from './typography'\n\nconst CLOSE_DRAG_MIN_PX = 72\nconst CLOSE_DRAG_RATIO = 0.18\nconst SHEET_TRANSITION_MS = 280\n\n/**\n * Mobile-first bottom sheet with slide + fade enter/exit, drag-to-dismiss\n * handle, body scroll lock, and reduced-motion support. Portaled to\n * `document.body` to escape ancestor stacking contexts.\n */\nexport function BottomSheet({\n  backdropDismissLabel = 'Dismiss',\n  children,\n  onClose,\n  open,\n  title\n}: BottomSheetProps) {\n  const [renderPortal, setRenderPortal] = useState(open)\n  const [entered, setEntered] = useState(false)\n  const [dragOffsetPx, setDragOffsetPx] = useState(0)\n  const [dragActive, setDragActive] = useState(false)\n\n  const closeTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)\n  const sheetRef = useRef<HTMLDivElement>(null)\n  const dragTrackingRef = useRef(false)\n  const dragStartYRef = useRef(0)\n  const dragOffsetRef = useRef(0)\n\n  const reducedMotion =\n    typeof window !== 'undefined' &&\n    window.matchMedia('(prefers-reduced-motion: reduce)').matches\n\n  const syncDragPx = (next: number) => {\n    dragOffsetRef.current = next\n    setDragOffsetPx(next)\n  }\n\n  useEffect(() => {\n    if (closeTimerRef.current) {\n      clearTimeout(closeTimerRef.current)\n      closeTimerRef.current = null\n    }\n\n    const ms = reducedMotion ? 0 : SHEET_TRANSITION_MS\n\n    let openRafId = 0\n    let exitRafId = 0\n\n    if (open) {\n      openRafId = requestAnimationFrame(() => {\n        dragTrackingRef.current = false\n        dragOffsetRef.current = 0\n        setDragActive(false)\n        setDragOffsetPx(0)\n        setRenderPortal(true)\n        requestAnimationFrame(() => {\n          requestAnimationFrame(() => setEntered(true))\n        })\n      })\n    } else {\n      exitRafId = requestAnimationFrame(() => {\n        dragTrackingRef.current = false\n        setDragActive(false)\n        setEntered(false)\n        closeTimerRef.current = window.setTimeout(() => {\n          dragOffsetRef.current = 0\n          setDragOffsetPx(0)\n          setRenderPortal(false)\n          closeTimerRef.current = null\n        }, ms)\n      })\n    }\n\n    return () => {\n      cancelAnimationFrame(openRafId)\n      cancelAnimationFrame(exitRafId)\n      if (closeTimerRef.current) {\n        clearTimeout(closeTimerRef.current)\n        closeTimerRef.current = null\n      }\n    }\n  }, [open, reducedMotion])\n\n  useEffect(() => {\n    if (!renderPortal) return\n    const prev = document.body.style.overflow\n    document.body.style.overflow = 'hidden'\n    return () => {\n      document.body.style.overflow = prev\n    }\n  }, [renderPortal])\n\n  if (!renderPortal || typeof document === 'undefined') return null\n\n  const durationClass = reducedMotion ? 'duration-0' : 'duration-[280ms]'\n  const draggingVisual = dragActive || dragOffsetPx > 0\n\n  const onDragPointerDown = (e: ReactPointerEvent<HTMLDivElement>) => {\n    if (reducedMotion || !entered) return\n    if (e.pointerType === 'mouse' && e.button !== 0) return\n\n    dragTrackingRef.current = true\n    setDragActive(true)\n    dragStartYRef.current = e.clientY\n    syncDragPx(0)\n    e.currentTarget.setPointerCapture(e.pointerId)\n  }\n\n  const onDragPointerMove = (e: ReactPointerEvent<HTMLDivElement>) => {\n    if (!dragTrackingRef.current) return\n    const dy = e.clientY - dragStartYRef.current\n    const next = Math.max(0, dy)\n    const sheetH = sheetRef.current?.offsetHeight ?? 560\n    syncDragPx(Math.min(next, sheetH))\n  }\n\n  const endDrag = (e: ReactPointerEvent<HTMLDivElement>) => {\n    if (!dragTrackingRef.current) return\n    dragTrackingRef.current = false\n    setDragActive(false)\n    try {\n      e.currentTarget.releasePointerCapture(e.pointerId)\n    } catch {\n      /* already released */\n    }\n\n    const sheetH = sheetRef.current?.offsetHeight ?? 560\n    const threshold = Math.max(CLOSE_DRAG_MIN_PX, sheetH * CLOSE_DRAG_RATIO)\n    const d = dragOffsetRef.current\n\n    if (d >= threshold) {\n      onClose()\n      return\n    }\n    syncDragPx(0)\n  }\n\n  return createPortal(\n    <div className=\"fixed inset-0 z-[200] flex flex-col justify-end\">\n      <button\n        aria-label={backdropDismissLabel}\n        className={cn(\n          'absolute inset-0 bg-black/55 backdrop-blur-[2px]',\n          'transition-opacity ease-out motion-reduce:transition-none',\n          durationClass,\n          entered ? 'opacity-100' : 'opacity-0'\n        )}\n        onClick={onClose}\n        type=\"button\"\n      />\n\n      <div\n        aria-label={title}\n        aria-modal=\"true\"\n        className={cn(\n          'relative flex max-h-[85dvh] min-h-0 flex-col rounded-t-xl border border-current/20',\n          'bg-background-base/98 pb-[max(1rem,env(safe-area-inset-bottom))]',\n          'shadow-[0_-12px_40px_-8px_rgba(0,0,0,0.55)] backdrop-blur-md',\n          'ease-out motion-reduce:transition-none transform-gpu',\n          draggingVisual\n            ? 'transition-none'\n            : cn('transition-transform', durationClass),\n          entered ? 'translate-y-0' : 'translate-y-full'\n        )}\n        ref={sheetRef}\n        role=\"dialog\"\n        style={\n          entered && dragOffsetPx > 0\n            ? { transform: `translateY(${dragOffsetPx}px)` }\n            : undefined\n        }\n      >\n        <div\n          className={cn(\n            'flex shrink-0 flex-col gap-2 border-b border-current/15 px-4 pb-3 pt-2',\n            'touch-none select-none',\n            reducedMotion\n              ? 'cursor-default'\n              : 'cursor-grab active:cursor-grabbing'\n          )}\n          onPointerCancel={endDrag}\n          onPointerDown={onDragPointerDown}\n          onPointerMove={onDragPointerMove}\n          onPointerUp={endDrag}\n        >\n          <div\n            aria-hidden\n            className=\"mx-auto h-1 w-10 shrink-0 rounded-full bg-current/20\"\n          />\n\n          <Typography\n            className=\"text-[0.65rem] tracking-[0.15em] uppercase text-midground/70\"\n            mondwest\n          >\n            {title}\n          </Typography>\n        </div>\n\n        <div className=\"min-h-0 flex-1 overflow-y-auto overscroll-contain\">\n          {children}\n        </div>\n      </div>\n    </div>,\n    document.body\n  )\n}\n\ninterface BottomSheetProps {\n  backdropDismissLabel?: string\n  children: ReactNode\n  onClose: () => void\n  open: boolean\n  title: string\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/button.d.ts

@@ -0,0 +1,14 @@
+import { type VariantProps } from 'class-variance-authority';
+declare const buttonVariants: (props?: ({
+    destructive?: boolean | null | undefined;
+    ghost?: boolean | null | undefined;
+    invert?: boolean | null | undefined;
+    outlined?: boolean | null | undefined;
+    size?: "sm" | "default" | "icon" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const Button: ({ children, className, destructive, ghost, invert, outlined, prefix, size, suffix, ...props }: ButtonProps) => import("react").JSX.Element;
+interface ButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'prefix' | 'suffix'>, VariantProps<typeof buttonVariants> {
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+}
+export {};

package/dist/ui/components/button.js

@@ -0,0 +1,147 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { cloneElement } from "react";
+import { cn } from "../../utils/index.js";
+import { Typography } from "./typography/index.js";
+const SHADOW_DEFAULT = "shadow-[inset_-1px_-1px_0_0_#00000080,inset_1px_1px_0_0_#ffffff80]";
+const SHADOW_INVERT = "shadow-[inset_-1px_-1px_0_0_#00000080,inset_1px_1px_0_0_#ffffff29]";
+const SHADOW_INVERT_OUTLINED = "shadow-[inset_-1px_-1px_0_0_#ffffff12,inset_1px_1px_0_0_#ffffff29]";
+const ACTIVE_FILTER = "active:[filter:invert(1)_brightness(calc(100-99*var(--foreground-alpha,0)))]";
+const buttonVariants = cva(
+  [
+    "group relative grid cursor-pointer grid-cols-[auto_1fr_auto] items-center",
+    "text-display leading-0 font-bold tracking-[0.2em]",
+    "disabled:pointer-events-none disabled:bg-midground/15 disabled:text-midground disabled:shadow-none"
+  ],
+  {
+    compoundVariants: [
+      // ── invert × outlined matrix (default surface, no ghost/destructive) ──
+      {
+        class: `bg-midground text-background-base active:invert ${SHADOW_DEFAULT}`,
+        destructive: false,
+        ghost: false,
+        invert: false,
+        outlined: false
+      },
+      {
+        class: `bg-midground/15 text-midground ${SHADOW_INVERT} ${ACTIVE_FILTER}`,
+        destructive: false,
+        ghost: false,
+        invert: true,
+        outlined: false
+      },
+      {
+        class: `shadow-midground ${SHADOW_DEFAULT} ${ACTIVE_FILTER}`,
+        destructive: false,
+        ghost: false,
+        invert: false,
+        outlined: true
+      },
+      {
+        class: `${SHADOW_INVERT_OUTLINED} ${ACTIVE_FILTER}`,
+        destructive: false,
+        ghost: false,
+        invert: true,
+        outlined: true
+      },
+      // ── ghost: no chrome, hover bg only ──
+      {
+        class: "bg-transparent text-current hover:bg-midground/10 shadow-none",
+        destructive: false,
+        ghost: true
+      },
+      {
+        class: "bg-transparent text-destructive hover:bg-destructive/10 shadow-none",
+        destructive: true,
+        ghost: true
+      },
+      // ── solid destructive ──
+      {
+        class: `bg-destructive text-destructive-foreground hover:bg-destructive/90 ${SHADOW_INVERT}`,
+        destructive: true,
+        ghost: false,
+        outlined: false
+      },
+      // ── outlined destructive ──
+      {
+        class: "border border-destructive/40 bg-transparent text-destructive hover:bg-destructive/10 shadow-none",
+        destructive: true,
+        ghost: false,
+        outlined: true
+      }
+    ],
+    defaultVariants: {
+      destructive: false,
+      ghost: false,
+      invert: false,
+      outlined: false,
+      size: "default"
+    },
+    variants: {
+      destructive: { true: "" },
+      ghost: { true: "" },
+      invert: { true: "" },
+      outlined: { true: "text-midground bg-transparent" },
+      size: {
+        default: "px-[.9em_.75em] py-[1.25em]",
+        icon: "p-2 aspect-square grid-cols-1 place-items-center [&>svg]:size-3.5",
+        sm: "px-3 py-1.5 text-[0.7rem] tracking-[0.15em] [&>svg]:size-3",
+        xs: "p-1 aspect-square grid-cols-1 place-items-center [&>svg]:size-3"
+      }
+    }
+  }
+);
+const IconSlot = ({
+  icon,
+  side
+}) => /* @__PURE__ */ jsxs(Fragment, { children: [
+  /* @__PURE__ */ jsx("span", { className: "w-5" }),
+  /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: cn(
+        "absolute top-1/2 -translate-y-1/2",
+        side === "left" ? "left-3" : "right-3"
+      ),
+      children: typeof icon === "object" ? cloneElement(icon, {
+        className: "size-3.5"
+      }) : icon
+    }
+  )
+] });
+export const Button = ({
+  children,
+  className,
+  destructive,
+  ghost,
+  invert,
+  outlined,
+  prefix,
+  size,
+  suffix,
+  ...props
+}) => /* @__PURE__ */ jsxs(
+  Typography,
+  {
+    as: "button",
+    className: cn(
+      buttonVariants({ destructive, ghost, invert, outlined, size }),
+      className
+    ),
+    mono: true,
+    ...props,
+    children: [
+      !ghost && /* @__PURE__ */ jsx(
+        "span",
+        {
+          "aria-hidden": true,
+          className: "arc-border opacity-0 transition-opacity duration-200 group-hover:opacity-100 group-focus-visible:opacity-100 group-active:opacity-100"
+        }
+      ),
+      prefix && /* @__PURE__ */ jsx(IconSlot, { icon: prefix, side: "left" }),
+      children,
+      suffix && /* @__PURE__ */ jsx(IconSlot, { icon: suffix, side: "right" })
+    ]
+  }
+);
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["import { cva, type VariantProps } from 'class-variance-authority'\nimport { cloneElement } from 'react'\n\nimport { cn } from '../../utils'\n\nimport { Typography } from './typography'\n\nconst SHADOW_DEFAULT =\n  'shadow-[inset_-1px_-1px_0_0_#00000080,inset_1px_1px_0_0_#ffffff80]'\nconst SHADOW_INVERT =\n  'shadow-[inset_-1px_-1px_0_0_#00000080,inset_1px_1px_0_0_#ffffff29]'\nconst SHADOW_INVERT_OUTLINED =\n  'shadow-[inset_-1px_-1px_0_0_#ffffff12,inset_1px_1px_0_0_#ffffff29]'\nconst ACTIVE_FILTER =\n  'active:[filter:invert(1)_brightness(calc(100-99*var(--foreground-alpha,0)))]'\n\nconst buttonVariants = cva(\n  [\n    'group relative grid cursor-pointer grid-cols-[auto_1fr_auto] items-center',\n    'text-display leading-0 font-bold tracking-[0.2em]',\n    'disabled:pointer-events-none disabled:bg-midground/15 disabled:text-midground disabled:shadow-none'\n  ],\n  {\n    compoundVariants: [\n      // \u2500\u2500 invert \u00D7 outlined matrix (default surface, no ghost/destructive) \u2500\u2500\n      {\n        class: `bg-midground text-background-base active:invert ${SHADOW_DEFAULT}`,\n        destructive: false,\n        ghost: false,\n        invert: false,\n        outlined: false\n      },\n      {\n        class: `bg-midground/15 text-midground ${SHADOW_INVERT} ${ACTIVE_FILTER}`,\n        destructive: false,\n        ghost: false,\n        invert: true,\n        outlined: false\n      },\n      {\n        class: `shadow-midground ${SHADOW_DEFAULT} ${ACTIVE_FILTER}`,\n        destructive: false,\n        ghost: false,\n        invert: false,\n        outlined: true\n      },\n      {\n        class: `${SHADOW_INVERT_OUTLINED} ${ACTIVE_FILTER}`,\n        destructive: false,\n        ghost: false,\n        invert: true,\n        outlined: true\n      },\n      // \u2500\u2500 ghost: no chrome, hover bg only \u2500\u2500\n      {\n        class: 'bg-transparent text-current hover:bg-midground/10 shadow-none',\n        destructive: false,\n        ghost: true\n      },\n      {\n        class:\n          'bg-transparent text-destructive hover:bg-destructive/10 shadow-none',\n        destructive: true,\n        ghost: true\n      },\n      // \u2500\u2500 solid destructive \u2500\u2500\n      {\n        class: `bg-destructive text-destructive-foreground hover:bg-destructive/90 ${SHADOW_INVERT}`,\n        destructive: true,\n        ghost: false,\n        outlined: false\n      },\n      // \u2500\u2500 outlined destructive \u2500\u2500\n      {\n        class:\n          'border border-destructive/40 bg-transparent text-destructive hover:bg-destructive/10 shadow-none',\n        destructive: true,\n        ghost: false,\n        outlined: true\n      }\n    ],\n    defaultVariants: {\n      destructive: false,\n      ghost: false,\n      invert: false,\n      outlined: false,\n      size: 'default'\n    },\n    variants: {\n      destructive: { true: '' },\n      ghost: { true: '' },\n      invert: { true: '' },\n      outlined: { true: 'text-midground bg-transparent' },\n      size: {\n        default: 'px-[.9em_.75em] py-[1.25em]',\n        icon: 'p-2 aspect-square grid-cols-1 place-items-center [&>svg]:size-3.5',\n        sm: 'px-3 py-1.5 text-[0.7rem] tracking-[0.15em] [&>svg]:size-3',\n        xs: 'p-1 aspect-square grid-cols-1 place-items-center [&>svg]:size-3'\n      }\n    }\n  }\n)\n\nconst IconSlot = ({\n  icon,\n  side\n}: {\n  icon: React.ReactNode\n  side: 'left' | 'right'\n}) => (\n  <>\n    <span className=\"w-5\" />\n\n    <span\n      className={cn(\n        'absolute top-1/2 -translate-y-1/2',\n        side === 'left' ? 'left-3' : 'right-3'\n      )}\n    >\n      {typeof icon === 'object'\n        ? cloneElement(icon as React.ReactElement<any>, {\n            className: 'size-3.5'\n          })\n        : icon}\n    </span>\n  </>\n)\n\nexport const Button = ({\n  children,\n  className,\n  destructive,\n  ghost,\n  invert,\n  outlined,\n  prefix,\n  size,\n  suffix,\n  ...props\n}: ButtonProps) => (\n  <Typography\n    as=\"button\"\n    className={cn(\n      buttonVariants({ destructive, ghost, invert, outlined, size }),\n      className\n    )}\n    mono\n    {...props}\n  >\n    {!ghost && (\n      <span\n        aria-hidden\n        className=\"arc-border opacity-0 transition-opacity duration-200 group-hover:opacity-100 group-focus-visible:opacity-100 group-active:opacity-100\"\n      />\n    )}\n    {prefix && <IconSlot icon={prefix} side=\"left\" />}\n    {children}\n    {suffix && <IconSlot icon={suffix} side=\"right\" />}\n  </Typography>\n)\n\ninterface ButtonProps\n  extends Omit<\n      React.ButtonHTMLAttributes<HTMLButtonElement>,\n      'prefix' | 'suffix'\n    >,\n    VariantProps<typeof buttonVariants> {\n  prefix?: React.ReactNode\n  suffix?: React.ReactNode\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/card.d.ts

@@ -0,0 +1,5 @@
+export declare function Card({ className, style, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function CardHeader({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function CardTitle({ className, ...props }: React.HTMLAttributes<HTMLHeadingElement>): import("react").JSX.Element;
+export declare function CardDescription({ className, ...props }: React.HTMLAttributes<HTMLParagraphElement>): import("react").JSX.Element;
+export declare function CardContent({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/dist/ui/components/card.js

@@ -0,0 +1,74 @@
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../utils/index.js";
+const CARD_STYLE = {
+  background: "var(--component-card-background)",
+  borderImage: "var(--component-card-border-image)",
+  boxShadow: "var(--component-card-box-shadow)",
+  clipPath: "var(--component-card-clip-path)"
+};
+export function Card({
+  className,
+  style,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "border border-midground/15 bg-background-base/80 text-midground w-full",
+        className
+      ),
+      style: { ...CARD_STYLE, ...style },
+      ...props
+    }
+  );
+}
+export function CardHeader({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "flex flex-col gap-1.5 p-4 border-b border-midground/15",
+        className
+      ),
+      ...props
+    }
+  );
+}
+export function CardTitle({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "h3",
+    {
+      className: cn(
+        "font-expanded text-sm font-bold tracking-[0.08em] uppercase",
+        className
+      ),
+      ...props
+    }
+  );
+}
+export function CardDescription({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "p",
+    {
+      className: cn("font-mondwest text-xs text-midground/60", className),
+      ...props
+    }
+  );
+}
+export function CardContent({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx("div", { className: cn("p-4", className), ...props });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/checkbox.d.ts

@@ -0,0 +1,2 @@
+import { Checkbox as CheckboxPrimitive } from 'radix-ui';
+export declare const Checkbox: import("react").ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;