@nukleas/cyberdesign 0.1.0

package/dist/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/react/Accordion.d.ts

@@ -0,0 +1,34 @@
+import type { HTMLAttributes, DetailsHTMLAttributes, ReactNode } from 'react';
+export interface AccordionItemData {
+    /** Trigger heading text. */
+    title: ReactNode;
+    /** Body content revealed when open. */
+    content: ReactNode;
+    /** Optional icon glyph before the title. */
+    icon?: ReactNode;
+    /** Render this item open initially. */
+    defaultOpen?: boolean;
+}
+export interface AccordionItemProps extends Omit<DetailsHTMLAttributes<HTMLDetailsElement>, 'title'> {
+    /** Trigger heading text. */
+    title: ReactNode;
+    /** Optional icon glyph before the title. */
+    icon?: ReactNode;
+    /** Body content. */
+    children?: ReactNode;
+}
+/** Single `<details>` accordion row — for manual composition under `<Accordion>`. */
+declare function AccordionItem({ title, icon, children, className, ...rest }: AccordionItemProps): import("react").JSX.Element;
+export interface AccordionProps extends HTMLAttributes<HTMLDivElement> {
+    /** Data-driven rows. Omit to compose `<Accordion.Item>` children manually. */
+    items?: AccordionItemData[];
+    /** `sep` adds gaps between items; `flush` drops side borders. */
+    variant?: 'default' | 'sep' | 'flush';
+    children?: ReactNode;
+}
+/** Disclosure accordion — native `<details>` rows, data-driven or composed via `Accordion.Item`. */
+declare function AccordionRoot({ items, variant, className, children, ...rest }: AccordionProps): import("react").JSX.Element;
+export declare const Accordion: typeof AccordionRoot & {
+    Item: typeof AccordionItem;
+};
+export {};

package/dist/react/Accordion.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Single `<details>` accordion row — for manual composition under `<Accordion>`. */
+function AccordionItem({ title, icon, children, className = '', ...rest }) {
+    return (_jsxs("details", { className: cx('cd-accordion__item', className), ...rest, children: [_jsxs("summary", { className: "cd-accordion__trigger", children: [icon != null && _jsx("span", { className: "cd-accordion__icon", children: icon }), title] }), _jsx("div", { className: "cd-accordion__body", children: _jsx("div", { className: "cd-accordion__content", children: _jsx("div", { className: "cd-accordion__content-inner", children: children }) }) })] }));
+}
+/** Disclosure accordion — native `<details>` rows, data-driven or composed via `Accordion.Item`. */
+function AccordionRoot({ items, variant = 'default', className = '', children, ...rest }) {
+    return (_jsx("div", { className: cx('cd-accordion', variant !== 'default' && `cd-accordion--${variant}`, className), ...rest, children: items
+            ? items.map((item, i) => (_jsx(AccordionItem, { title: item.title, icon: item.icon, open: item.defaultOpen, children: item.content }, i)))
+            : children }));
+}
+export const Accordion = Object.assign(AccordionRoot, { Item: AccordionItem });

package/dist/react/Alert.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Semantic color. `accent` follows the active theme accent. */
+    variant?: 'info' | 'success' | 'warning' | 'error' | 'accent';
+    /** Compact padding/type. */
+    size?: 'sm';
+    /** Drop the left accent bar for a flatter inline banner. */
+    inline?: boolean;
+    /** Bold uppercase heading line. */
+    title?: ReactNode;
+    /** Leading glyph (e.g. ℹ ✓ ⚠ ✕ ⬡). */
+    icon?: ReactNode;
+    /** When provided, renders a dismiss ✕ that calls this on click. */
+    onDismiss?: () => void;
+    /** Body text. */
+    children?: ReactNode;
+}
+/** Banner / alert with semantic color, optional icon, title and dismiss. */
+export declare function Alert({ variant, size, inline, title, icon, onDismiss, className, children, ...rest }: AlertProps): import("react").JSX.Element;

package/dist/react/Alert.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Banner / alert with semantic color, optional icon, title and dismiss. */
+export function Alert({ variant = 'info', size, inline = false, title, icon, onDismiss, className = '', children, ...rest }) {
+    return (_jsxs("div", { className: cx('cd-alert', `cd-alert--${variant}`, size === 'sm' && 'cd-alert--sm', inline && 'cd-alert--inline', className), ...rest, children: [icon != null && _jsx("span", { className: "cd-alert__icon", children: icon }), _jsxs("div", { className: "cd-alert__content", children: [title != null && _jsx("div", { className: "cd-alert__title", children: title }), children != null && _jsx("div", { className: "cd-alert__body", children: children })] }), onDismiss && (_jsx("button", { className: "cd-alert__dismiss", onClick: onDismiss, "aria-label": "Dismiss", children: "\u2715" }))] }));
+}

package/dist/react/AugButton.d.ts

@@ -0,0 +1,12 @@
+import type { ButtonHTMLAttributes, ReactNode } from 'react';
+export interface AugButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** `primary` fills with the accent-subtle background and a drop-shadow glow. */
+    variant?: 'default' | 'primary';
+    /** `sm` and `lg` adjust height, padding and clip size; `md` is the default. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Reverse the diagonal clip to cut the TR+BL corners instead of TL+BR. */
+    reverse?: boolean;
+    children?: ReactNode;
+}
+/** Augmented clip-path button — neon-bordered diagonal-corner button matching cd-aug-btn. */
+export declare function AugButton({ variant, size, reverse, className, children, ...rest }: AugButtonProps): import("react").JSX.Element;

package/dist/react/AugButton.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Augmented clip-path button — neon-bordered diagonal-corner button matching cd-aug-btn. */
+export function AugButton({ variant = 'default', size = 'md', reverse = false, className = '', children, ...rest }) {
+    return (_jsx("button", { className: cx('cd-aug-btn', variant === 'primary' && 'cd-aug-btn--primary', size === 'sm' && 'cd-aug-btn--sm', size === 'lg' && 'cd-aug-btn--lg', reverse && 'cd-aug-btn--rev', className), ...rest, children: children }));
+}

package/dist/react/AugPanel.d.ts

@@ -0,0 +1,10 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface AugPanelProps extends HTMLAttributes<HTMLDivElement> {
+    /** Clip/padding size: `sm` (6px clip), `md` (default, 20px clip) or `lg` (32px clip). */
+    size?: 'sm' | 'md' | 'lg';
+    /** Clip all four corners instead of the default diagonal TL+BR pair. */
+    corners4?: boolean;
+    children?: ReactNode;
+}
+/** Augmented clip-path panel — neon drop-shadow border with clipped corners (cd-aug-panel). */
+export declare function AugPanel({ size, corners4, className, children, ...rest }: AugPanelProps): import("react").JSX.Element;

package/dist/react/AugPanel.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Augmented clip-path panel — neon drop-shadow border with clipped corners (cd-aug-panel). */
+export function AugPanel({ size = 'md', corners4 = false, className = '', children, ...rest }) {
+    return (_jsx("div", { className: cx('cd-aug-panel', size === 'sm' && 'cd-aug-panel--sm', size === 'lg' && 'cd-aug-panel--lg', corners4 && 'cd-aug-panel--4', className), ...rest, children: children }));
+}

package/dist/react/Avatar.d.ts

@@ -0,0 +1,28 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface AvatarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Image source. When set, renders `<img>`; otherwise shows `fallback` initials. */
+    src?: string;
+    /** Alt text for the image. */
+    alt?: string;
+    /** Initials shown when no `src` (e.g. "NH"). */
+    fallback?: ReactNode;
+    /** Diameter preset. `md` is the default (no modifier). */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Neon ring around the avatar. */
+    glow?: boolean;
+    /** Presence dot rendered via `data-status`. */
+    status?: 'online' | 'away' | 'busy' | 'offline';
+}
+/** Circular avatar — image or fallback initials, sized presets, neon glow ring and presence dot. */
+export declare function Avatar({ src, alt, fallback, size, glow, status, className, ...rest }: AvatarProps): import("react").JSX.Element;
+export declare namespace Avatar {
+    var Group: typeof AvatarGroup;
+}
+export interface AvatarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /** Overflow count rendered as a trailing `+N` badge. */
+    more?: number;
+    /** Avatars to stack, in order. */
+    children?: ReactNode;
+}
+/** Overlapping stack of avatars with an optional `+N` overflow badge. */
+export declare function AvatarGroup({ more, className, children, ...rest }: AvatarGroupProps): import("react").JSX.Element;

package/dist/react/Avatar.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Circular avatar — image or fallback initials, sized presets, neon glow ring and presence dot. */
+export function Avatar({ src, alt = '', fallback, size = 'md', glow = false, status, className = '', ...rest }) {
+    return (_jsx("div", { className: cx('cd-avatar', size !== 'md' && `cd-avatar--${size}`, glow && 'cd-avatar--glow', className), "data-status": status, ...rest, children: src != null ? (_jsx("img", { className: "cd-avatar__image", src: src, alt: alt })) : (_jsx("span", { className: "cd-avatar__fallback", children: fallback })) }));
+}
+/** Overlapping stack of avatars with an optional `+N` overflow badge. */
+export function AvatarGroup({ more, className = '', children, ...rest }) {
+    return (_jsxs("div", { className: cx('cd-avatar-group', className), ...rest, children: [children, more != null && more > 0 && _jsxs("span", { className: "cd-avatar-group__more", children: ["+", more] })] }));
+}
+Avatar.Group = AvatarGroup;

package/dist/react/Badge.d.ts

@@ -0,0 +1,10 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+type CdColor = 'orange' | 'amber' | 'gold' | 'cyan' | 'magenta' | 'green' | 'red' | 'blue' | 'purple' | 'yellow';
+export interface BadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'color'> {
+    /** Color variant. Defaults to `orange`. */
+    color?: CdColor;
+    children?: ReactNode;
+}
+/** Inline status badge — uppercase, pixel-corner, with a neon color variant. */
+export declare function Badge({ color, className, children, ...rest }: BadgeProps): import("react").JSX.Element;
+export {};

package/dist/react/Badge.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Inline status badge — uppercase, pixel-corner, with a neon color variant. */
+export function Badge({ color = 'orange', className = '', children, ...rest }) {
+    return (_jsx("span", { className: cx('cd-badge', `cd-badge--${color}`, className), ...rest, children: children }));
+}

package/dist/react/Breadcrumb.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface BreadcrumbItem {
+    /** Crumb text. */
+    label: ReactNode;
+    /** Link target. Omitted (or on the active crumb) renders plain text. */
+    href?: string;
+    /** Marks this crumb as the current page (plain, non-interactive). */
+    active?: boolean;
+}
+export interface BreadcrumbProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    /** Crumbs in order. The last item is treated as active if none is flagged. */
+    items: BreadcrumbItem[];
+    /** Separator style: `/` (default), `›` arrow, or `·` dot. */
+    variant?: 'default' | 'arrow' | 'dot';
+    /** Accessible label for the `<nav>`. */
+    'aria-label'?: string;
+}
+/** Breadcrumb trail — data-driven crumbs with slash / arrow / dot separators; renders `<nav><ol>`. */
+export declare function Breadcrumb({ items, variant, className, 'aria-label': ariaLabel, ...rest }: BreadcrumbProps): import("react").JSX.Element;

package/dist/react/Breadcrumb.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Breadcrumb trail — data-driven crumbs with slash / arrow / dot separators; renders `<nav><ol>`. */
+export function Breadcrumb({ items, variant = 'default', className = '', 'aria-label': ariaLabel = 'breadcrumb', ...rest }) {
+    const lastIndex = items.length - 1;
+    return (_jsx("nav", { "aria-label": ariaLabel, ...rest, children: _jsx("ol", { className: cx('cd-breadcrumb', variant === 'arrow' && 'cd-breadcrumb--arrow', variant === 'dot' && 'cd-breadcrumb--dot', className), children: items.map((item, i) => {
+                const isActive = item.active ?? i === lastIndex;
+                return (_jsx("li", { className: cx('cd-breadcrumb__item', isActive && 'cd-breadcrumb__item--active'), children: isActive || item.href == null ? (_jsx("span", { children: item.label })) : (_jsx("a", { className: "cd-breadcrumb__link", href: item.href, children: item.label })) }, i));
+            }) }) }));
+}

package/dist/react/Button.d.ts

@@ -0,0 +1,12 @@
+import type { ButtonHTMLAttributes, ReactNode } from 'react';
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Visual emphasis. `primary` uses the theme accent; `danger` is destructive. */
+    variant?: 'default' | 'primary' | 'danger';
+    /** `sm` is the compact height; `md` is the default. */
+    size?: 'sm' | 'md';
+    /** Square icon-only button (no horizontal padding). */
+    icon?: boolean;
+    children?: ReactNode;
+}
+/** Cyber terminal button — uppercase, pixel-corner accent, neon hover glow. */
+export declare function Button({ variant, size, icon, className, children, ...rest }: ButtonProps): import("react").JSX.Element;

package/dist/react/Button.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Cyber terminal button — uppercase, pixel-corner accent, neon hover glow. */
+export function Button({ variant = 'default', size = 'md', icon = false, className = '', children, ...rest }) {
+    return (_jsx("button", { className: cx('cd-btn', variant !== 'default' && `cd-btn--${variant}`, size === 'sm' && 'cd-btn--sm', icon && 'cd-btn--icon', className), ...rest, children: children }));
+}

package/dist/react/Checkbox.d.ts

@@ -0,0 +1,9 @@
+import type { InputHTMLAttributes, ReactNode } from 'react';
+export interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    /** Text shown beside the box. When set, wraps the input in a `cd-control` label. */
+    label?: ReactNode;
+    /** Smaller helper line below the label. */
+    description?: ReactNode;
+}
+/** Cyber checkbox — neon fill + checkmark; renders inside a `cd-control` label when labelled. */
+export declare function Checkbox({ label, description, className, ...rest }: CheckboxProps): import("react").JSX.Element;

package/dist/react/Checkbox.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Cyber checkbox — neon fill + checkmark; renders inside a `cd-control` label when labelled. */
+export function Checkbox({ label, description, className = '', ...rest }) {
+    const input = (_jsx("input", { type: "checkbox", className: cx('cd-checkbox', !label && className), ...rest }));
+    if (label == null && description == null)
+        return input;
+    return (_jsxs("label", { className: cx('cd-control', className), children: [_jsx("input", { type: "checkbox", className: "cd-checkbox", ...rest }), _jsxs("span", { className: "cd-control__label", children: [label, description != null && _jsx("span", { className: "cd-control__desc", children: description })] })] }));
+}

package/dist/react/Dropdown.d.ts

@@ -0,0 +1,35 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface DropdownItem {
+    /** Item label text. */
+    label: ReactNode;
+    /** Leading icon glyph rendered in the `__item-icon` slot. */
+    icon?: ReactNode;
+    /** Right-aligned keyboard shortcut hint (`__item-kbd`). */
+    kbd?: ReactNode;
+    /** Destructive styling (red on hover). */
+    danger?: boolean;
+    /** Disable selection. */
+    disabled?: boolean;
+    /** Fired when the item is clicked (closes the menu). */
+    onSelect?: () => void;
+}
+export type DropdownEntry = DropdownItem | {
+    sep: true;
+} | {
+    label: ReactNode;
+    heading: true;
+};
+export interface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /** Trigger node — rendered as the `cd-dropdown__trigger` button content. */
+    trigger: ReactNode;
+    /** Menu entries: items, `{ sep: true }` separators, or `{ heading: true }` labels. */
+    items: DropdownEntry[];
+    /** Right-align the menu panel under the trigger. */
+    align?: 'left' | 'right';
+    /** Extra classes for the trigger button (e.g. `cd-btn cd-btn--primary`). */
+    triggerClassName?: string;
+    /** Initial open state (uncontrolled). */
+    defaultOpen?: boolean;
+}
+/** Dropdown menu — a trigger button toggling a `cd-dropdown__menu` of data-driven items. */
+export declare function Dropdown({ trigger, items, align, triggerClassName, defaultOpen, className, ...rest }: DropdownProps): import("react").JSX.Element;

package/dist/react/Dropdown.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Dropdown menu — a trigger button toggling a `cd-dropdown__menu` of data-driven items. */
+export function Dropdown({ trigger, items, align = 'left', triggerClassName = 'cd-btn', defaultOpen = false, className = '', ...rest }) {
+    const [open, setOpen] = useState(defaultOpen);
+    return (_jsxs("div", { className: cx('cd-dropdown', open && 'is-open', className), ...rest, children: [_jsx("button", { type: "button", className: cx(triggerClassName, 'cd-dropdown__trigger'), "aria-expanded": open, onClick: () => setOpen((o) => !o), children: trigger }), _jsx("div", { className: cx('cd-dropdown__menu', align === 'right' && 'cd-dropdown__menu--right'), role: "menu", children: items.map((entry, i) => {
+                    if ('sep' in entry && entry.sep) {
+                        return _jsx("div", { className: "cd-dropdown__sep" }, i);
+                    }
+                    if ('heading' in entry && entry.heading) {
+                        return (_jsx("div", { className: "cd-dropdown__label", children: entry.label }, i));
+                    }
+                    const item = entry;
+                    return (_jsxs("button", { type: "button", role: "menuitem", className: cx('cd-dropdown__item', item.danger && 'cd-dropdown__item--danger'), disabled: item.disabled, "aria-disabled": item.disabled || undefined, onClick: () => {
+                            item.onSelect?.();
+                            setOpen(false);
+                        }, children: [item.icon != null && (_jsx("span", { className: "cd-dropdown__item-icon", children: item.icon })), item.label, item.kbd != null && (_jsx("span", { className: "cd-dropdown__item-kbd", children: item.kbd }))] }, i));
+                }) })] }));
+}

package/dist/react/Field.d.ts

@@ -0,0 +1,13 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface FieldProps extends HTMLAttributes<HTMLDivElement> {
+    /** Inline layout: label left, control right. */
+    inline?: boolean;
+    /** Helper / description text below the control. */
+    description?: ReactNode;
+    /** Error message below the control (rendered with a ⚠ marker). */
+    error?: ReactNode;
+    /** Label + control (e.g. a `Label` followed by an input). */
+    children?: ReactNode;
+}
+/** Form field wrapper — stacks a label, control, and optional helper/error text. */
+export declare function Field({ inline, description, error, className, children, ...rest }: FieldProps): import("react").JSX.Element;

package/dist/react/Field.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Form field wrapper — stacks a label, control, and optional helper/error text. */
+export function Field({ inline = false, description, error, className = '', children, ...rest }) {
+    return (_jsxs("div", { className: cx('cd-field', inline && 'cd-field--inline', className), ...rest, children: [children, description != null && _jsx("p", { className: "cd-field-desc", children: description }), error != null && _jsx("p", { className: "cd-field-error", children: error })] }));
+}

package/dist/react/Gauge.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface GaugeProps extends HTMLAttributes<HTMLDivElement> {
+    /** Fill amount, 0–100. Drives the conic `--value` CSS variable. */
+    value: number;
+    /** Text shown in the center; defaults to `value`. */
+    display?: ReactNode;
+    /** Uppercase caption under the value. */
+    label?: ReactNode;
+    /** `small` is the compact radial. */
+    size?: 'small';
+    /** Color theme: accent (default), or a semantic override. */
+    variant?: 'danger' | 'success' | 'warn';
+    /** Concentric-ring radar style with sweep fill. */
+    radar?: boolean;
+    /** Extra center content (rendered after value/label). */
+    children?: ReactNode;
+}
+/** Radial neon gauge — conic fill driven by a 0–100 `value`, with center readout. */
+export declare function Gauge({ value, display, label, size, variant, radar, className, style, children, ...rest }: GaugeProps): import("react").JSX.Element;

package/dist/react/Gauge.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Radial neon gauge — conic fill driven by a 0–100 `value`, with center readout. */
+export function Gauge({ value, display, label, size, variant, radar = false, className = '', style, children, ...rest }) {
+    return (_jsxs("div", { className: cx('cd-gauge', size === 'small' && 'cd-gauge--small', variant && `cd-gauge--${variant}`, radar && 'cd-gauge--radar', className), style: { ['--value']: value, ...style }, ...rest, children: [_jsx("div", { className: "cd-gauge__track" }), _jsx("div", { className: "cd-gauge__fill" }), _jsxs("div", { className: "cd-gauge__center", children: [_jsx("div", { className: "cd-gauge__value", children: display ?? value }), label != null && _jsx("div", { className: "cd-gauge__label", children: label }), children] })] }));
+}

package/dist/react/GlowCard.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode, MouseEvent } from 'react';
+type GlowCardColor = 'orange' | 'amber' | 'gold' | 'cyan' | 'magenta' | 'green' | 'red' | 'blue' | 'purple';
+interface GlowCardProps {
+    children: ReactNode;
+    color?: GlowCardColor;
+    active?: boolean;
+    className?: string;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+    style?: React.CSSProperties;
+}
+export declare function GlowCard({ color, active, className, onClick, style, children }: GlowCardProps): import("react").JSX.Element;
+export {};

package/dist/react/GlowCard.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export function GlowCard({ color = 'orange', active, className = '', onClick, style, children }) {
+    return (_jsx("div", { className: `cd-glow-card cd-glow-card--${color}${className ? ` ${className}` : ''}`, "data-active": active ? 'true' : undefined, onClick: onClick, style: style, children: children }));
+}

package/dist/react/HudBar.d.ts

@@ -0,0 +1,34 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+/** Status color for a segment value — maps to `cd-hud-segment__value--*`. */
+export type HudSegmentStatus = 'ok' | 'warn' | 'err';
+export interface HudSegmentProps extends HTMLAttributes<HTMLDivElement> {
+    /** Small uppercase caption. */
+    label?: ReactNode;
+    /** Accent-colored value. */
+    value?: ReactNode;
+    /** Color the value by status. */
+    status?: HudSegmentStatus;
+    children?: ReactNode;
+}
+/** One label/value cell inside a `HudBar`. */
+export declare function HudSegment({ label, value, status, className, children, ...rest }: HudSegmentProps): import("react").JSX.Element;
+export interface HudBarSegment {
+    /** Small uppercase caption. */
+    label?: ReactNode;
+    /** Accent-colored value. */
+    value?: ReactNode;
+    /** Color the value by status. */
+    status?: HudSegmentStatus;
+}
+export interface HudBarProps extends HTMLAttributes<HTMLDivElement> {
+    /** Data-driven segments rendered left-to-right. */
+    segments?: HudBarSegment[];
+    /** Glowing accent edge: `top` or `bottom` bar, or `side` for vertical. */
+    position?: 'top' | 'bottom' | 'side';
+    /** Tighter segment padding/type. */
+    compact?: boolean;
+    /** Custom segment markup (e.g. `HudSegment` children) instead of `segments`. */
+    children?: ReactNode;
+}
+/** Persistent HUD status bar — a row of label/value segments with a glowing accent edge. */
+export declare function HudBar({ segments, position, compact, className, children, ...rest }: HudBarProps): import("react").JSX.Element;

package/dist/react/HudBar.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** One label/value cell inside a `HudBar`. */
+export function HudSegment({ label, value, status, className = '', children, ...rest }) {
+    return (_jsxs("div", { className: cx('cd-hud-segment', className), ...rest, children: [label != null && _jsx("span", { className: "cd-hud-segment__label", children: label }), value != null && (_jsx("span", { className: cx('cd-hud-segment__value', status && `cd-hud-segment__value--${status}`), children: value })), children] }));
+}
+/** Persistent HUD status bar — a row of label/value segments with a glowing accent edge. */
+export function HudBar({ segments, position, compact = false, className = '', children, ...rest }) {
+    return (_jsxs("div", { className: cx('cd-hud-bar', position && `cd-hud-bar--${position}`, compact && 'cd-hud-bar--compact', className), ...rest, children: [segments?.map((seg, i) => (_jsx(HudSegment, { label: seg.label, value: seg.value, status: seg.status }, i))), children] }));
+}

package/dist/react/HudFrame.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+/** Status color for a HUD value readout — maps to `cd-hud__value--*`. */
+export type HudValueStatus = 'ok' | 'warn' | 'err' | 'dim';
+export interface HudFrameProps extends HTMLAttributes<HTMLDivElement> {
+    /** Uppercase label line above the value. */
+    label?: ReactNode;
+    /** Primary readout value. */
+    value?: ReactNode;
+    /** Color the value by status. */
+    status?: HudValueStatus;
+    /** Tighter padding for dense UIs. */
+    compact?: boolean;
+    /** Frosted / AR-style translucent backdrop. */
+    floating?: boolean;
+    /** Extra content rendered after the label/value (e.g. nested gauges). */
+    children?: ReactNode;
+}
+/** Framed HUD stat panel — uppercase label over a glowing accent value readout. */
+export declare function HudFrame({ label, value, status, compact, floating, className, children, ...rest }: HudFrameProps): import("react").JSX.Element;

package/dist/react/HudFrame.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Framed HUD stat panel — uppercase label over a glowing accent value readout. */
+export function HudFrame({ label, value, status, compact = false, floating = false, className = '', children, ...rest }) {
+    return (_jsxs("div", { className: cx('cd-hud-frame', compact && 'cd-hud--compact', floating && 'cd-hud--floating', className), ...rest, children: [label != null && _jsx("div", { className: "cd-hud__label", children: label }), value != null && (_jsx("div", { className: cx('cd-hud__value', status && `cd-hud__value--${status}`), children: value })), children] }));
+}

package/dist/react/Input.d.ts

@@ -0,0 +1,11 @@
+import type { InputHTMLAttributes } from 'react';
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /** `sm` is compact, `lg` is taller; default is the standard height. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Adds a left accent border (corpus-search pattern). */
+    accent?: boolean;
+    /** Error state — red border and glow. */
+    error?: boolean;
+}
+/** Cyber text input — neon focus ring, optional left-accent border and error state. */
+export declare function Input({ size, accent, error, className, type, ...rest }: InputProps): import("react").JSX.Element;

package/dist/react/Input.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Cyber text input — neon focus ring, optional left-accent border and error state. */
+export function Input({ size = 'md', accent = false, error = false, className = '', type = 'text', ...rest }) {
+    return (_jsx("input", { type: type, className: cx('cd-input', size === 'sm' && 'cd-input--sm', size === 'lg' && 'cd-input--lg', accent && 'cd-input--accent', error && 'cd-input--error', className), ...rest }));
+}

package/dist/react/Interference.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface InterferenceProps extends HTMLAttributes<HTMLDivElement> {
+    /** Static intensity: `light`, default, or `heavy`. */
+    intensity?: 'light' | 'heavy';
+    /** Extra-aggressive noise (combine with `heavy`). */
+    intense?: boolean;
+    /** Enable the text/data corruption effect (uses `corruptText` as the clipped layer text). */
+    glitch?: boolean;
+    /**
+     * Text driving the glitch corruption layers (sets `data-text` on the content wrapper).
+     * Required for the corruption effect to render; should match the visible heading text.
+     */
+    corruptText?: string;
+    /** Content shown beneath the noise overlay. */
+    children?: ReactNode;
+}
+/** Animated static / data-corruption overlay — adds a `__noise` layer over wrapped content. */
+export declare function Interference({ intensity, intense, glitch, corruptText, className, children, ...rest }: InterferenceProps): import("react").JSX.Element;

package/dist/react/Interference.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const cx = (...parts) => parts.filter(Boolean).join(' ');
+/** Animated static / data-corruption overlay — adds a `__noise` layer over wrapped content. */
+export function Interference({ intensity, intense = false, glitch = false, corruptText, className = '', children, ...rest }) {
+    return (_jsxs("div", { className: cx('cd-interference', intensity && `cd-interference--${intensity}`, intense && 'cd-interference--intense', glitch && 'cd-interference--glitch', className), ...rest, children: [_jsx("div", { className: "cd-interference__noise" }), glitch ? (_jsx("div", { className: "cd-interference__content", "data-text": corruptText, children: children })) : (children)] }));
+}