@tai42/studio-sdk 0.2.0

package/dist/components/primitives.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Owned DS primitives, wearing the design-system classes from
+ * `components.css`. These cover the shared UI states every feature drives from
+ * TanStack Query: loading skeletons, a shared empty state, and a loud error
+ * surface. Plugins consume these — never raw Tailwind utilities.
+ *
+ * `Button` is ONE implementation for both an action and a link. Given an `href`
+ * it renders an anchor, and that href is checked against an http/https
+ * allow-list: a reference beginning `/`, `?`, `#`, `./` or `../` stays in-app, an
+ * absolute `http://`/`https://` URL opens in a new tab with
+ * `rel="noopener noreferrer external"`, and everything else — another scheme
+ * (`javascript:`, `data:`, …), a protocol-relative `//host`, a bare `page.html` —
+ * is NEUTRALIZED, rendered as plain text with no href, so a hostile URL can never
+ * become a live navigation target. This is an XSS pin. The neutralized text names
+ * BOTH admitted forms, because an in-app reference is not an http(s) URL either
+ * and saying only "not an http(s) URL" would describe `/tools` as blocked.
+ *
+ * The check reads the NORMALIZED reference and the anchor is given that same
+ * normalized string, because the raw input and the URL the browser resolves are
+ * not the same URL. See `normalizeHref`.
+ */
+import type { AnchorHTMLAttributes, ButtonHTMLAttributes, CSSProperties, ReactNode, Ref } from 'react';
+/**
+ * The absolute http(s) URL `href` denotes, or `undefined` when it denotes none.
+ *
+ * The `//` is required rather than inferred from a successful `new URL()`,
+ * because for a scheme that matches the document's own, the authority-less
+ * spelling is a PATH: an anchor with `href="https:/settings"` on an https page
+ * navigates to `/settings` on the CURRENT origin, while `new URL()` with no base
+ * reads the same string as the host `settings`. Only the `//` form means the same
+ * thing to both.
+ *
+ * Callers render the returned string rather than their input, so the URL that was
+ * judged is always the URL that is navigated.
+ */
+export declare function safeHttpUrl(href: string): string | undefined;
+/** True only for an absolute `http://`/`https://` URL. Everything else is unsafe. */
+export declare function isSafeHttpUrl(url: string): boolean;
+/**
+ * A blocked href, rendered as inert text: no anchor, no `href`, no handlers, so
+ * it can never become a live navigation target. Shared by `Button`'s link form
+ * and by `ExternalLinkButton`, which applies the stricter http(s)-only policy.
+ *
+ * Its surface is DELIBERATELY narrow. It takes the paint, the id and the name,
+ * and nothing else the caller wrote on the anchor: the props a live link needs
+ * are the props a dead one must not have, so they are refused here rather than
+ * spread onto the span.
+ *
+ * It stays ROLE-LESS on purpose — it is not a link and must not be announced as
+ * one. That is also why the caller's name arrives as visually-hidden TEXT rather
+ * than `aria-label`: ARIA prohibits both naming attributes on the `generic` role
+ * a bare `<span>` maps to, so a platform that honours the prohibition computes NO
+ * name from them and an icon-only blocked link announces as nothing at all. Text
+ * has no such restriction — a generic element contributes no accessible NAME, but
+ * its content is still read. `aria-disabled` stays because
+ * `.tai-btn[aria-disabled='true']` is what paints the disabled look; it is inert
+ * on a role-less element, and the missing `href` is what actually says this does
+ * not navigate.
+ *
+ * A caller-supplied `label` REPLACES the children for assistive tech, exactly as
+ * the `aria-label` it comes from would have done on the live anchor: the children
+ * go behind an `aria-hidden` wrapper that is `display: contents`, so it generates
+ * no box and the button's own flex layout is unchanged. Without that the children
+ * and the label are both read and a blocked link announces its name twice.
+ */
+export declare function NeutralizedLink({ className, style, children, id, label, }: {
+    readonly className?: string;
+    readonly style?: CSSProperties;
+    readonly children?: ReactNode;
+    /** Kept so an external `aria-labelledby`/`aria-describedby` IDREF still lands. */
+    readonly id?: string;
+    /**
+     * The name the caller gave the link, rendered as hidden text. An icon-only
+     * link carries its whole meaning here, and when it is given the children are
+     * hidden from assistive tech so the name is read once, not twice.
+     */
+    readonly label?: string;
+}): import("react").JSX.Element;
+/**
+ * What every primitive in this file accepts alongside its own props: the
+ * design-system class it wears is its own, and the caller's `className` is
+ * APPENDED to it rather than replacing it, so a surface can never lose its paint
+ * by being positioned.
+ */
+interface SurfaceProps {
+    readonly className?: string;
+    readonly style?: CSSProperties;
+}
+export type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger';
+/** The variant a `Button` wears when the caller names none. */
+export declare const DEFAULT_BUTTON_VARIANT: ButtonVariant;
+/**
+ * The one prop both forms share. Deliberately NOT on the public surface: it is a
+ * shared base, and declaration emit keeps it visible inside `primitives.d.ts`
+ * where `ButtonProps`/`LinkButtonProps` reference it, so consumers still see
+ * `variant` and can still `extends` either interface.
+ */
+interface ButtonVariantProps {
+    readonly variant?: ButtonVariant;
+}
+/**
+ * The ACTION form of `Button`: button attributes, no anchor ones.
+ *
+ * This stays an INTERFACE extending `ButtonHTMLAttributes<HTMLButtonElement>`
+ * because it is published plugin API: a plugin may write
+ * `interface MyButton extends ButtonProps {}` (a union cannot be extended —
+ * TS2312) and may hand a `ButtonProps` value to a slot typed as plain
+ * `ButtonHTMLAttributes<HTMLButtonElement>` (a union including anchor attributes
+ * is not assignable — TS2322). The link form is the ADDITIVE `LinkButtonProps`,
+ * and `Button` accepts either.
+ *
+ * It declares NO `href` member. `href?: undefined` here would make
+ * `interface MyButton extends ButtonProps { href: string }` a TS2430
+ * ("incorrectly extends"), which is a narrowing of a surface that is additive
+ * only. The discriminant `Button` narrows on lives on `ButtonActionProps`.
+ */
+export interface ButtonProps extends ButtonVariantProps, ButtonHTMLAttributes<HTMLButtonElement> {
+    /** A consumer ref for the `<button>`; the prop spread forwards it. */
+    readonly ref?: Ref<HTMLButtonElement>;
+}
+/**
+ * The action form as `Button` ACCEPTS it: `ButtonProps` plus the absent-`href`
+ * discriminant, which is what lets the body narrow `props.href` without a cast.
+ *
+ * Like `ButtonVariantProps` this is deliberately off the public surface — a
+ * plugin extends `ButtonProps` — and declaration emit keeps it visible inside
+ * `primitives.d.ts`, where `Button`'s signature references it.
+ */
+interface ButtonActionProps extends ButtonProps {
+    readonly href?: undefined;
+}
+/**
+ * The LINK form of `Button`: an `href`, so it carries anchor attributes and no
+ * button ones.
+ *
+ * `target` and `rel` are inherited from `AnchorHTMLAttributes` and are settable,
+ * but on the EXTERNAL branch they are not the caller's to choose: an absolute
+ * http(s) URL always renders `target="_blank"` with
+ * `rel="noopener noreferrer external"`, whatever the caller passed. On the
+ * in-app branch `target` is the caller's and `rel` is pinned only when they ask
+ * for `_blank`.
+ *
+ * It declares NO `ref`, and that is a REFUSAL rather than an omission: a blocked
+ * href renders a {@link NeutralizedLink} span and no anchor at all, so a
+ * `Ref<HTMLAnchorElement>` would be filled on two of the three renderings and
+ * left null on the third — a ref that silently does nothing for exactly the
+ * input the check exists to catch. A caller that needs the element wraps the
+ * button.
+ */
+export interface LinkButtonProps extends ButtonVariantProps, AnchorHTMLAttributes<HTMLAnchorElement> {
+    readonly href: string;
+}
+/** The variant class plus the caller's, which sorts last so it can override. */
+export declare function buttonClass(variant: ButtonVariant, className: string | undefined): string;
+export declare function Button(props: ButtonActionProps | LinkButtonProps): import("react").JSX.Element;
+export interface CardProps extends SurfaceProps {
+    readonly children: ReactNode;
+    /** Opt in to the hover/focus lift. A card that is not itself an affordance stays flat. */
+    readonly interactive?: boolean;
+    /** A consumer ref for the card element itself. */
+    readonly ref?: Ref<HTMLDivElement>;
+}
+export declare function Card({ children, interactive, className, style, ref }: CardProps): import("react").JSX.Element;
+export interface SkeletonProps extends SurfaceProps {
+    readonly height?: number | string;
+    readonly width?: number | string;
+}
+export declare function Skeleton({ height, width, className, style }: SkeletonProps): import("react").JSX.Element;
+export interface EmptyStateProps extends SurfaceProps {
+    readonly title: string;
+    readonly description?: string;
+    /** The guidance line's on-screen action — the control the description names. */
+    readonly action?: ReactNode;
+}
+export declare function EmptyState({ title, description, action, className, style }: EmptyStateProps): import("react").JSX.Element;
+export interface ErrorStateProps extends SurfaceProps {
+    readonly message: string;
+    readonly onRetry?: () => void;
+}
+export declare function ErrorState({ message, onRetry, className, style }: ErrorStateProps): import("react").JSX.Element;
+export interface SpinnerProps extends SurfaceProps {
+    readonly label?: string;
+}
+export declare function Spinner({ label, className, style }: SpinnerProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=primitives.d.ts.map

package/dist/components/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../src/components/primitives.tsx"],"names":[],"mappings":"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"}

package/dist/components/primitives.js

@@ -0,0 +1,204 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { XCircleIcon } from './icons';
+// -- Link safety --------------------------------------------------------------
+/**
+ * The reference with the characters the URL parser throws away before it parses:
+ * ASCII tab, LF and CR ANYWHERE in the string, plus leading and trailing C0
+ * controls and spaces.
+ *
+ * Reading the raw string instead means checking a different URL from the one the
+ * browser resolves. `/<TAB>/evil.com` is not a root-relative path — the parser
+ * deletes the tab, making it the protocol-relative `//evil.com`, which is
+ * cross-origin.
+ */
+function normalizeHref(href) {
+    const inner = href.replaceAll(/[\t\n\r]/g, '');
+    // The leading/trailing strip walks code points rather than using a character
+    // class, so it covers every C0 control without a control-character regex.
+    let start = 0;
+    let end = inner.length;
+    while (start < end && inner.charCodeAt(start) <= 0x20)
+        start++;
+    while (end > start && inner.charCodeAt(end - 1) <= 0x20)
+        end--;
+    return inner.slice(start, end);
+}
+/**
+ * The absolute http(s) URL `href` denotes, or `undefined` when it denotes none.
+ *
+ * The `//` is required rather than inferred from a successful `new URL()`,
+ * because for a scheme that matches the document's own, the authority-less
+ * spelling is a PATH: an anchor with `href="https:/settings"` on an https page
+ * navigates to `/settings` on the CURRENT origin, while `new URL()` with no base
+ * reads the same string as the host `settings`. Only the `//` form means the same
+ * thing to both.
+ *
+ * Callers render the returned string rather than their input, so the URL that was
+ * judged is always the URL that is navigated.
+ */
+export function safeHttpUrl(href) {
+    const normalized = normalizeHref(href);
+    if (!/^https?:\/\//i.test(normalized))
+        return undefined;
+    try {
+        return new URL(normalized).href;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** True only for an absolute `http://`/`https://` URL. Everything else is unsafe. */
+export function isSafeHttpUrl(url) {
+    return safeHttpUrl(url) !== undefined;
+}
+/**
+ * A same-document, root-relative or explicitly relative reference. The negative
+ * lookahead rejects a protocol-relative `//host` (and its `/\` spelling), which
+ * inherits the page scheme and so resolves to a cross-origin target rather than
+ * an in-app one. Tested against the NORMALIZED reference — see `normalizeHref`.
+ *
+ * The lookahead belongs to the `/` branch ALONE. Applied to `#` and `?` as well
+ * it rejected `#/agents` — a hash route, the most common client-routed reference
+ * form there is, and one of the five spellings this module's own docblock says
+ * "stays in-app" — sending it to the neutralized span reserved for
+ * `javascript:`. Neither `#//evil.example` nor `?//evil.example` can be
+ * cross-origin: both resolve against the current document, so the lookahead
+ * bought nothing on those two branches and cost a whole routing style.
+ */
+const RELATIVE_HREF = /^(?:\/(?![/\\])|[?#]|\.{1,2}\/)/;
+/**
+ * The text a neutralized href carries in place of a navigation. It names both
+ * admitted forms: `/tools` and `#/agents` are in-app references rather than
+ * http(s) URLs and DO render as live anchors, so a reason citing only the
+ * http(s) rule would state a rule this component does not enforce.
+ */
+const BLOCKED_HREF_TITLE = 'This link was blocked because it is neither an in-app reference nor an http(s) URL.';
+/**
+ * Takes a subtree out of the accessibility tree without taking it out of the
+ * layout: `display: contents` generates no box, so wrapped children stay direct
+ * flex items of the button surface around them.
+ */
+const hiddenFromReadersStyle = { display: 'contents' };
+/**
+ * A blocked href, rendered as inert text: no anchor, no `href`, no handlers, so
+ * it can never become a live navigation target. Shared by `Button`'s link form
+ * and by `ExternalLinkButton`, which applies the stricter http(s)-only policy.
+ *
+ * Its surface is DELIBERATELY narrow. It takes the paint, the id and the name,
+ * and nothing else the caller wrote on the anchor: the props a live link needs
+ * are the props a dead one must not have, so they are refused here rather than
+ * spread onto the span.
+ *
+ * It stays ROLE-LESS on purpose — it is not a link and must not be announced as
+ * one. That is also why the caller's name arrives as visually-hidden TEXT rather
+ * than `aria-label`: ARIA prohibits both naming attributes on the `generic` role
+ * a bare `<span>` maps to, so a platform that honours the prohibition computes NO
+ * name from them and an icon-only blocked link announces as nothing at all. Text
+ * has no such restriction — a generic element contributes no accessible NAME, but
+ * its content is still read. `aria-disabled` stays because
+ * `.tai-btn[aria-disabled='true']` is what paints the disabled look; it is inert
+ * on a role-less element, and the missing `href` is what actually says this does
+ * not navigate.
+ *
+ * A caller-supplied `label` REPLACES the children for assistive tech, exactly as
+ * the `aria-label` it comes from would have done on the live anchor: the children
+ * go behind an `aria-hidden` wrapper that is `display: contents`, so it generates
+ * no box and the button's own flex layout is unchanged. Without that the children
+ * and the label are both read and a blocked link announces its name twice.
+ */
+export function NeutralizedLink({ className, style, children, id, label, }) {
+    return (_jsxs("span", { "data-neutralized": "true", "aria-disabled": "true", title: BLOCKED_HREF_TITLE, className: className, style: style, id: id, children: [label === undefined ? (children) : (_jsx("span", { "aria-hidden": "true", style: hiddenFromReadersStyle, children: children })), _jsx("span", { className: "tai-visually-hidden", children: label === undefined ? BLOCKED_HREF_TITLE : `${label}. ${BLOCKED_HREF_TITLE}` })] }));
+}
+/**
+ * Sorts an href into the three link forms the button renders, and returns the
+ * normalized reference alongside. Rendering the caller's raw string instead
+ * would let the anchor navigate somewhere the check never saw.
+ */
+function resolveHref(href) {
+    const external = safeHttpUrl(href);
+    if (external !== undefined)
+        return { kind: 'external', href: external };
+    const normalized = normalizeHref(href);
+    if (RELATIVE_HREF.test(normalized))
+        return { kind: 'internal', href: normalized };
+    return { kind: 'blocked', href: '' };
+}
+/** The surface's own class plus the caller's, which sorts last so it can override. */
+function surfaceClass(base, className) {
+    return className === undefined ? base : `${base} ${className}`;
+}
+/** The variant a `Button` wears when the caller names none. */
+export const DEFAULT_BUTTON_VARIANT = 'secondary';
+const VARIANT_CLASS = {
+    primary: 'tai-btn tai-btn-primary',
+    secondary: 'tai-btn tai-btn-secondary',
+    ghost: 'tai-btn tai-btn-ghost',
+    danger: 'tai-btn tai-btn-danger',
+};
+/** The variant class plus the caller's, which sorts last so it can override. */
+export function buttonClass(variant, className) {
+    return surfaceClass(VARIANT_CLASS[variant], className);
+}
+export function Button(props) {
+    if (props.href === undefined) {
+        const { variant = DEFAULT_BUTTON_VARIANT, className, href: _href, ...rest } = props;
+        return _jsx("button", { ...rest, className: buttonClass(variant, className) });
+    }
+    const { variant = DEFAULT_BUTTON_VARIANT, className, style, href, children, ...rest } = props;
+    const classes = buttonClass(variant, className);
+    const link = resolveHref(href);
+    if (link.kind === 'blocked') {
+        // Only the four props that survive the neutralization cross: the paint, the
+        // id an external IDREF may point at, and the caller's name (as text). Every
+        // other anchor prop is REFUSED rather than forwarded — `target`/`rel`
+        // describe a navigation that is not happening, and a handler spread onto the
+        // span would make the dead link live again, which is the whole defect.
+        return (_jsx(NeutralizedLink, { className: classes, style: style, id: rest.id, label: rest['aria-label'], children: children }));
+    }
+    if (link.kind === 'internal') {
+        return (_jsx("a", { ...rest, href: link.href, ...(rest.target === '_blank' ? { rel: 'noopener noreferrer' } : {}), className: classes, style: style, children: children }));
+    }
+    return (_jsx("a", { ...rest, 
+        // REVERSE TABNABBING. `target`/`rel` are settable on `LinkButtonProps`, so
+        // the hardening is carried by JSX property ORDER alone: the spread comes
+        // FIRST and these two are written after it, which is what makes them
+        // unoverridable. Below the spread, `rel="opener" target="_self"` from a
+        // caller would open a cross-origin `_blank` with a live `window.opener`
+        // onto the operator's authenticated tab.
+        href: link.href, target: "_blank", rel: "noopener noreferrer external", className: classes, style: style, children: children }));
+}
+export function Card({ children, interactive = false, className, style, ref }) {
+    const base = interactive ? 'tai-card tai-card-interactive' : 'tai-card';
+    return (_jsx("div", { className: surfaceClass(base, className), style: style, ref: ref, children: children }));
+}
+export function Skeleton({ height = 16, width = '100%', className, style }) {
+    // The block's extent is per-instance; the sheen animation lives in the class.
+    return (_jsx("div", { "aria-hidden": "true", className: surfaceClass('tai-skeleton', className), style: { height, width, ...style } }));
+}
+export function EmptyState({ title, description, action, className, style }) {
+    return (_jsxs("div", { role: "status", className: surfaceClass('tai-empty-state', className), style: style, children: [_jsx("p", { className: "tai-empty-state-title", children: title }), description === undefined ? null : (_jsx("p", { style: { margin: 'var(--tai-space-2) 0 0' }, children: description })), action === undefined ? null : (_jsx("div", { style: { marginTop: 'var(--tai-space-4)' }, children: action }))] }));
+}
+// -- ErrorState (loud, visible) ----------------------------------------------
+/**
+ * The headline every `ErrorState` wears.
+ *
+ * It is fixed, and the whole surface says one thing with it: `role="alert"`
+ * interrupts, the crossed circle is the ERROR mark, and `.tai-error-state` is the
+ * error ground. A DELIBERATE refusal — a permission denial, a server's dry-run
+ * "no" — is an answer rather than a malfunction, and swapping this headline alone
+ * would leave the mark, the ground and the live-region politeness all still
+ * announcing a system failure. Such a surface takes the design system's warn
+ * ground instead — `.tai-warn-state` for a warning block (`advisories.tsx`,
+ * `fleet-report.tsx`, `RunPanel.tsx`), or `role="status"` with a warn `Badge` for
+ * a verdict that only lands after the reader acts (`verdict.tsx`). The live-region
+ * politeness — `role="alert"` for a warning that interrupts, `role="status"` for
+ * one the reader came to find — is the surface's to choose, not this headline's.
+ */
+const ERROR_TITLE = 'Something went wrong';
+export function ErrorState({ message, onRetry, className, style }) {
+    return (_jsxs("div", { role: "alert", className: surfaceClass('tai-error-state', className), style: style, children: [_jsxs("strong", { className: "tai-error-state-title", children: [_jsx(XCircleIcon, {}), ERROR_TITLE] }), _jsx("p", { style: { margin: 'var(--tai-space-2) 0 0', whiteSpace: 'pre-wrap' }, children: message }), onRetry === undefined ? null : (_jsx("div", { style: { marginTop: 'var(--tai-space-3)' }, children: _jsx(Button, { type: "button", onClick: onRetry, children: "Retry" }) }))] }));
+}
+export function Spinner({ label = 'Loading', className, style }) {
+    return (_jsx("span", { role: "status", "aria-label": label, className: surfaceClass('tai-spinner', className), style: style }));
+}
+//# sourceMappingURL=primitives.js.map

package/dist/components/primitives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.js","sourceRoot":"","sources":["../../src/components/primitives.tsx"],"names":[],"mappings":"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"}

package/dist/components/progress-bar.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `ProgressBar` — a design-system, accessible progress indicator for a running
+ * tool that reports progress (`ctx.report_progress`). Determinate when a
+ * positive `total` is known (fills to `value/total`); otherwise indeterminate.
+ *
+ * The track and fill are classes; only the determinate fill's WIDTH stays inline,
+ * because it is the one genuinely per-instance value here. The indeterminate
+ * sweep is `tai-progress-fill-indeterminate`.
+ *
+ * Reusable by any feature's run surface — it takes only the raw
+ * progress/total/message a `report_progress` notification carries and renders
+ * a native `role="progressbar"` element with the ARIA value fields set.
+ */
+import type { ReactNode } from 'react';
+export interface ProgressBarProps {
+    /** Current progress. Clamped to `[0, total]` when `total` is known. */
+    readonly value?: number;
+    /** Upper bound. When absent or non-positive the bar is INDETERMINATE. */
+    readonly total?: number;
+    /** Optional human-readable status shown alongside the bar. */
+    readonly message?: string;
+}
+/**
+ * Render a progress bar. With a positive `total`, `value/total` fills the track
+ * and the percentage is announced via `aria-valuenow`; without one, the bar is
+ * indeterminate (no `aria-valuenow`, per ARIA).
+ */
+export declare function ProgressBar({ value, total, message }: ProgressBarProps): ReactNode;
+//# sourceMappingURL=progress-bar.d.ts.map

package/dist/components/progress-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-bar.d.ts","sourceRoot":"","sources":["../../src/components/progress-bar.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAC;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,uEAAuE;IACvE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,yEAAyE;IACzE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AA6BD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,KAAS,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,gBAAgB,GAAG,SAAS,CA2CtF"}

package/dist/components/progress-bar.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+function clampFraction(value, total) {
+    if (!(total > 0))
+        return 0;
+    const fraction = value / total;
+    // Written as `>= 0` rather than `< 0` so that NaN — which compares false to
+    // everything, and would otherwise reach the width and the label as `NaN%` —
+    // falls through to the floor.
+    if (!(fraction >= 0))
+        return 0;
+    if (fraction > 1)
+        return 1;
+    return fraction;
+}
+/**
+ * The value to ANNOUNCE, clamped into `[0, total]`. Derived from `value`
+ * directly rather than by multiplying the fraction back up: `value / total *
+ * total` does not round-trip in binary floating point, so `value={7}
+ * total={25}` announced `7.000000000000001`, and a non-finite `total` announced
+ * `NaN`. The same `>= 0` shape as `clampFraction` keeps NaN at the floor.
+ */
+function clampValue(value, total) {
+    if (!(value >= 0))
+        return 0;
+    if (!(value <= total))
+        return total;
+    return value;
+}
+/** The status sits at one end of the row and the percentage at the other. */
+const labelRowStyle = { justifyContent: 'space-between' };
+/**
+ * Render a progress bar. With a positive `total`, `value/total` fills the track
+ * and the percentage is announced via `aria-valuenow`; without one, the bar is
+ * indeterminate (no `aria-valuenow`, per ARIA).
+ */
+export function ProgressBar({ value = 0, total, message }) {
+    // A determinate bar has to announce a real `aria-valuemax`. `Number.isFinite`
+    // rather than `> 0` alone: `total={Infinity}` passes the positivity test but
+    // announces `aria-valuemax="Infinity"`, which is not a number any assistive
+    // technology can place `aria-valuenow` against, and draws a 0 % fill while
+    // announcing the raw value. An unbounded total is exactly the indeterminate
+    // case, so it renders as one.
+    const determinate = typeof total === 'number' && Number.isFinite(total) && total > 0;
+    const fraction = determinate ? clampFraction(value, total) : undefined;
+    const percent = fraction === undefined ? undefined : Math.round(fraction * 100);
+    return (_jsxs("div", { className: "tai-stack tai-stack-2", children: [_jsxs("div", { className: "tai-row tai-field-hint", style: labelRowStyle, children: [_jsx("span", { children: message ?? 'Working…' }), percent !== undefined && _jsxs("span", { children: [percent, "%"] })] }), _jsx("div", { role: "progressbar", className: "tai-progress-track", "aria-valuemin": 0, "aria-valuemax": determinate ? total : undefined, "aria-valuenow": determinate && fraction !== undefined ? clampValue(value, total) : undefined, "aria-label": message ?? 'Progress', children: determinate ? (_jsx("div", { className: "tai-progress-fill", style: { width: `${String((fraction ?? 0) * 100)}%` } })) : (_jsx("div", { className: "tai-progress-fill tai-progress-fill-indeterminate" })) })] }));
+}
+//# sourceMappingURL=progress-bar.js.map

package/dist/components/progress-bar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-bar.js","sourceRoot":"","sources":["../../src/components/progress-bar.tsx"],"names":[],"mappings":";AAwBA,SAAS,aAAa,CAAC,KAAa,EAAE,KAAa;IACjD,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAC3B,MAAM,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC;IAC/B,4EAA4E;IAC5E,4EAA4E;IAC5E,8BAA8B;IAC9B,IAAI,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAC/B,IAAI,QAAQ,GAAG,CAAC;QAAE,OAAO,CAAC,CAAC;IAC3B,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;GAMG;AACH,SAAS,UAAU,CAAC,KAAa,EAAE,KAAa;IAC9C,IAAI,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAC5B,IAAI,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACpC,OAAO,KAAK,CAAC;AACf,CAAC;AAED,6EAA6E;AAC7E,MAAM,aAAa,GAAkB,EAAE,cAAc,EAAE,eAAe,EAAE,CAAC;AAEzE;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,EAAE,OAAO,EAAoB;IACzE,8EAA8E;IAC9E,6EAA6E;IAC7E,4EAA4E;IAC5E,2EAA2E;IAC3E,4EAA4E;IAC5E,8BAA8B;IAC9B,MAAM,WAAW,GAAG,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC;IACrF,MAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,MAAM,OAAO,GAAG,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,GAAG,CAAC,CAAC;IAEhF,OAAO,CACL,eAAK,SAAS,EAAC,uBAAuB,aAKpC,eAAK,SAAS,EAAC,wBAAwB,EAAC,KAAK,EAAE,aAAa,aAC1D,yBAAO,OAAO,IAAI,UAAU,GAAQ,EACnC,OAAO,KAAK,SAAS,IAAI,2BAAO,OAAO,SAAS,IAC7C,EACN,cACE,IAAI,EAAC,aAAa,EAClB,SAAS,EAAC,oBAAoB,mBACf,CAAC,mBACD,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,mBAI/B,WAAW,IAAI,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,gBAC/E,OAAO,IAAI,UAAU,YAEhC,WAAW,CAAC,CAAC,CAAC,CACb,cACE,SAAS,EAAC,mBAAmB,EAC7B,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE,GACrD,CACH,CAAC,CAAC,CAAC,CACF,cAAK,SAAS,EAAC,mDAAmD,GAAG,CACtE,GACG,IACF,CACP,CAAC;AACJ,CAAC"}

package/dist/components/radio-group.d.ts

@@ -0,0 +1,37 @@
+import type { ReactNode } from 'react';
+export interface RadioOption {
+    readonly value: string;
+    readonly label: string;
+    readonly disabled?: boolean;
+    /** Mark rendered alongside the label. Decorative — the label carries the name. */
+    readonly icon?: ReactNode;
+    /** Render the label for screen readers only; it stays the option's accessible name. */
+    readonly visuallyHiddenLabel?: boolean;
+}
+export interface RadioGroupProps {
+    readonly options: readonly RadioOption[];
+    readonly value?: string;
+    readonly defaultValue?: string;
+    readonly onValueChange?: (value: string) => void;
+    readonly disabled?: boolean;
+    readonly name?: string;
+    /** Visible group label, rendered above the options and wired as the group's name. */
+    readonly label?: string;
+    /**
+     * Accessible group name when `label` supplies none. `label` wins where both are
+     * given — it names the group from visible text, and emitting both would leave
+     * this string computed by nothing.
+     */
+    readonly 'aria-label'?: string;
+    /**
+     * Layout, and — when given — the arrow-key axis. Omitted, the options stack
+     * and BOTH axes move between them, which is what Radix does with no
+     * orientation and what every caller that never passed one already had. Pass a
+     * value only to pin the axis as well.
+     */
+    readonly orientation?: 'horizontal' | 'vertical';
+    /** `list` is a stack of labelled radios; `segmented` is a compact segment strip. */
+    readonly variant?: 'list' | 'segmented';
+}
+export declare function RadioGroup({ options, value, defaultValue, onValueChange, disabled, name, label, 'aria-label': ariaLabel, orientation, variant, }: RadioGroupProps): import("react").JSX.Element;
+//# sourceMappingURL=radio-group.d.ts.map

package/dist/components/radio-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group.d.ts","sourceRoot":"","sources":["../../src/components/radio-group.tsx"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,kFAAkF;IAClF,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAC1B,uFAAuF;IACvF,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACxC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,YAAY,GAAG,UAAU,CAAC;IACjD,oFAAoF;IACpF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;CACzC;AAWD,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,KAAK,EACL,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,IAAI,EACJ,KAAK,EACL,YAAY,EAAE,SAAS,EACvB,WAAW,EACX,OAAgB,GACjB,EAAE,eAAe,+BA0EjB"}

package/dist/components/radio-group.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * `RadioGroup` — a design-system wrapper over Radix RadioGroup (role `radiogroup`
+ * with `radio` items), in two shapes.
+ *
+ * `list` (the default) renders one row per option: a dot indicator inside a
+ * linked `<label>`, so the option text is the radio's accessible name.
+ * `segmented` renders each option AS a segment — the Radix item itself is the
+ * control, carrying its icon and its label with no dot — which is the shape a
+ * compact single-choice control (a light / dark / system switcher) needs.
+ *
+ * The group takes its accessible name from a `label` it renders itself or from
+ * `aria-label`. It does NOT read one from an enclosing `Field`: a group `Field`
+ * renders its own named `role="group"` container around this component, so the
+ * name lives one level up and this component would otherwise duplicate it. A
+ * `Field` WITHOUT `group` around a RadioGroup is a mistake — the field's
+ * `<label for>` dangles at an id no element carries and neither element ends up
+ * named — and `field-group.test.ts` fails the build on it.
+ *
+ * Roving tabindex and arrow-key movement belong to Radix; this component only
+ * chooses the layout that matches `orientation` and passes the prop straight
+ * through, so a caller that names no orientation keeps Radix's both-axes default
+ * rather than being pinned to one.
+ */
+import * as RadixRadioGroup from '@radix-ui/react-radio-group';
+import { useId } from 'react';
+import { useFieldControl } from './field';
+/** The option's name text, hidden from sight but not from assistive tech on request. */
+function OptionLabel({ option }) {
+    return (_jsx("span", { className: option.visuallyHiddenLabel === true ? 'tai-visually-hidden' : undefined, children: option.label }));
+}
+export function RadioGroup({ options, value, defaultValue, onValueChange, disabled, name, label, 'aria-label': ariaLabel, orientation, variant = 'list', }) {
+    const field = useFieldControl();
+    const baseId = useId();
+    const ownLabelId = `${baseId}-label`;
+    // `label` is the STANDALONE fallback name. Inside a group `Field`, the Field
+    // renders the named `role="group"` container itself, so this component neither
+    // knows nor needs the field's label id — the group is named by construction.
+    const labelledBy = label === undefined ? undefined : ownLabelId;
+    const rootClassName = variant === 'segmented'
+        ? 'tai-segmented'
+        : orientation === 'horizontal'
+            ? 'tai-row'
+            : 'tai-stack tai-stack-2';
+    const group = (_jsx(RadixRadioGroup.Root, { className: rootClassName, "aria-labelledby": labelledBy, "aria-label": labelledBy === undefined ? ariaLabel : undefined, "aria-describedby": field['aria-describedby'], "aria-invalid": field['aria-invalid'], value: value, defaultValue: defaultValue, onValueChange: onValueChange, disabled: disabled, name: name, orientation: orientation, children: options.map((option) => {
+            if (variant === 'segmented') {
+                return (_jsxs(RadixRadioGroup.Item, { className: "tai-segment", value: option.value, disabled: option.disabled, children: [option.icon, _jsx(OptionLabel, { option: option })] }, option.value));
+            }
+            const itemId = `${baseId}-${option.value}`;
+            return (_jsxs("label", { htmlFor: itemId, className: "tai-choice", children: [_jsx(RadixRadioGroup.Item, { id: itemId, className: "tai-radio", value: option.value, disabled: option.disabled, children: _jsx(RadixRadioGroup.Indicator, { className: "tai-radio-indicator" }) }), option.icon, _jsx(OptionLabel, { option: option })] }, option.value));
+        }) }));
+    if (label === undefined)
+        return group;
+    return (_jsxs("div", { className: "tai-stack tai-stack-2", children: [_jsx("span", { id: ownLabelId, className: "tai-field-label", children: label }), group] }));
+}
+//# sourceMappingURL=radio-group.js.map

package/dist/components/radio-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group.js","sourceRoot":"","sources":["../../src/components/radio-group.tsx"],"names":[],"mappings":"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"}

package/dist/components/reveal-input.d.ts

@@ -0,0 +1,13 @@
+export interface RevealInputProps {
+    readonly value: string;
+    readonly onChange?: (value: string) => void;
+    readonly readOnly?: boolean;
+    readonly disabled?: boolean;
+    readonly idPrefix?: string;
+    readonly label?: string;
+    readonly placeholder?: string;
+    /** Accessible name for the inner input when no visual `label` is rendered. */
+    readonly 'aria-label'?: string;
+}
+export declare function RevealInput({ value, onChange, readOnly, disabled, idPrefix, label, placeholder, 'aria-label': ariaLabel, }: RevealInputProps): import("react").JSX.Element;
+//# sourceMappingURL=reveal-input.d.ts.map

package/dist/components/reveal-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal-input.d.ts","sourceRoot":"","sources":["../../src/components/reveal-input.tsx"],"names":[],"mappings":"AAkBA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,QAAyB,EACzB,KAAK,EACL,WAAW,EACX,YAAY,EAAE,SAAS,GACxB,EAAE,gBAAgB,+BA+ClB"}