@50arms/ui 0.0.0-stage → 35.1.0

package/dist/types/components/Toggle.d.ts

@@ -0,0 +1,168 @@
+import type { Ref } from "react";
+import { Toggle as BaseToggle } from "@base-ui/react/toggle";
+import { ToggleGroup as BaseToggleGroup } from "@base-ui/react/toggle-group";
+import { Toolbar as BaseToolbar } from "@base-ui/react/toolbar";
+import { type VariantProps } from "tailwind-variants";
+import { type ButtonProps } from "./Button";
+import { type InputProps } from "./Input";
+declare const toggle: import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: "h-control-sm px-2.5 text-xs";
+        md: "h-control-md px-3 text-sm";
+        lg: "h-control-lg px-4 text-md";
+    };
+    iconOnly: {
+        true: "px-0 aspect-square";
+        false: "";
+    };
+}, undefined, string[], {
+    size: {
+        sm: "h-control-sm px-2.5 text-xs";
+        md: "h-control-md px-3 text-sm";
+        lg: "h-control-lg px-4 text-md";
+    };
+    iconOnly: {
+        true: "px-0 aspect-square";
+        false: "";
+    };
+}, undefined, import("tailwind-variants").TVReturnTypeLike<{
+    size: {
+        sm: "h-control-sm px-2.5 text-xs";
+        md: "h-control-md px-3 text-sm";
+        lg: "h-control-lg px-4 text-md";
+    };
+    iconOnly: {
+        true: "px-0 aspect-square";
+        false: "";
+    };
+}, undefined>>;
+export interface ToggleProps extends Omit<BaseToggle.Props, "className" | "render">, VariantProps<typeof toggle> {
+    className?: string;
+    ref?: Ref<HTMLButtonElement>;
+}
+export declare function Toggle({ size, iconOnly, className, children, ref, ...props }: ToggleProps): import("react").JSX.Element;
+export interface ToggleGroupProps extends Omit<BaseToggleGroup.Props, "className" | "render"> {
+    className?: string;
+    /** Segmented gives the group a shared inset background. */
+    variant?: "plain" | "segmented";
+    /**
+     * DX-6426 - the choice this group sends is out and unanswered: every option is disabled and a veil with a spinner covers the set until it is
+     * answered. Pass it from the pending state of the write; the pressed option stays the saved one until the answer repaints.
+     */
+    loading?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * A set of related toggles.
+ *
+ * `multiple` decides the meaning: false makes it a single choice (list
+ * view OR grid view), true makes it independent formats (bold AND italic).
+ * There is no separate "type" prop, because the multiplicity IS the type.
+ */
+export declare function ToggleGroup({ className, variant, loading, disabled, children, ref, ...props }: ToggleGroupProps): import("react").JSX.Element;
+export interface ToolbarProps extends Omit<BaseToolbar.Root.Props, "className" | "render"> {
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function Toolbar({ className, children, ref, ...props }: ToolbarProps): import("react").JSX.Element;
+/** A hairline between groups of toolbar controls. */
+export declare function ToolbarSeparator({ className }: {
+    className?: string;
+}): import("react").JSX.Element;
+type ToolbarButtonBase = Omit<BaseToolbar.Button.Props, "className" | "nativeButton" | "render"> & {
+    className?: string;
+    ref?: Ref<HTMLButtonElement>;
+};
+/**
+ * TWO FORMS, AND THE TYPE REFUSES TO MIX THEM.
+ *
+ * Either this renders its own `<button>` and wears `buttonVariants` — in which
+ * case `variant` / `size` / `iconOnly` choose which row of that table — or it
+ * renders somebody else's control through `render`, in which case that control
+ * already carries a variant table and this one must not add a second. The two
+ * are mutually exclusive rather than merely discouraged, because a `render`
+ * plus a `size` is not a preference somebody expressed: it is two size classes
+ * in one attribute with no rule for which wins. See `ToolbarButton`'s own doc
+ * for the measurement.
+ */
+export type ToolbarButtonProps = (ToolbarButtonBase & Pick<ButtonProps, "variant" | "size" | "iconOnly"> & {
+    /** The styled form owns the element, so there is nothing to render into. */
+    render?: undefined;
+}) | (ToolbarButtonBase & {
+    render: NonNullable<BaseToolbar.Button.Props["render"]>;
+    variant?: never;
+    size?: never;
+    iconOnly?: never;
+});
+/**
+ * A button that is part of the toolbar's rotation.
+ *
+ * It wears `buttonVariants` — the same recipe `Button` compiles — rather than a
+ * second class list, so the two can never drift apart. It is not `Button`
+ * itself because the registration has to own the element: Base UI needs to put
+ * its own `tabIndex` and key handling on the rendered node, and the
+ * `focusableWhenDisabled` behaviour below depends on NOT setting the native
+ * `disabled` attribute, which `Button` sets unconditionally.
+ *
+ * `ghost` at `sm` by default — the right resting state in a row of controls,
+ * the same default `IconButton` picks. A row of solid buttons reads as a row of
+ * primary actions, which no toolbar is.
+ *
+ * ANYTHING ALREADY BUILT ON `Button` GOES IN THROUGH `render`, which is what
+ * keeps this from becoming a second button component:
+ * `<ToolbarButton render={<IconButton icon={…} label="Bold" />} />` registers
+ * exactly the same and keeps the tooltip and the `disabledReason`.
+ *
+ * THAT PATH APPLIES NO VARIANT TABLE AT ALL, and the type enforces it —
+ * `variant`, `size` and `iconOnly` are not accepted beside `render`. Base UI's
+ * render slot CONCATENATES `className`; it does not run `cn`. So a recipe
+ * applied here landed in the same attribute as the rendered component's own,
+ * and which one won was decided by Tailwind's emission order rather than by
+ * either component. It measured fine while the two happened to agree — a
+ * default `render={<IconButton/>}` came out 36×36, identical to a standalone
+ * one, while carrying both `aspect-square` and `px-3.5` — and broke visibly the
+ * moment they disagreed: `<ToolbarButton size="lg" render={<IconButton
+ * size="sm" …/>} />` carried `h-control-lg` AND `h-control-sm` and rendered
+ * 48 × 36 with 24px of padding, a squashed oval neither component asked for.
+ *
+ * Unrepresentable beats documented, and it is free to do NOW: nothing has
+ * adopted the pair yet, so narrowing the type costs nothing that removing the
+ * props after adoption would have cost.
+ */
+export declare function ToolbarButton({ variant, size, iconOnly, className, children, ref, ...props }: ToolbarButtonProps): import("react").JSX.Element;
+export interface ToolbarInputProps extends Omit<InputProps, "ref">, Pick<BaseToolbar.Input.Props, "focusableWhenDisabled"> {
+    ref?: Ref<HTMLInputElement>;
+}
+/**
+ * A text field that is part of the toolbar's rotation — a filter box beside the
+ * buttons that filter with it.
+ *
+ * Renders this library's own `Input` through Base UI's `render` slot, so the
+ * adornments, sizes and focus ring are the ones every other field in the
+ * application already has. The composite's props land on the `<input>` itself
+ * rather than on `Input`'s adornment wrapper, which is what keeps DOM order —
+ * and therefore the arrow-key order — matching what the reader sees.
+ *
+ * Arrow keys still move OUT of it, which is Base UI's deliberate call and not
+ * an oversight: a toolbar field is a filter box, not a document, and a caret
+ * that traps the only navigation key in the pattern is worse than one that
+ * moves on.
+ */
+export declare function ToolbarInput({ focusableWhenDisabled, ref, ...props }: ToolbarInputProps): import("react").JSX.Element;
+export interface ToolbarGroupProps extends Omit<BaseToolbar.Group.Props, "className"> {
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * A labelled cluster of toolbar controls — "Alignment", "Text style".
+ *
+ * IT IS NOT ITSELF A STOP. The group renders `role="group"` and its CHILDREN
+ * register; a group that registered would insert a phantom position between the
+ * controls it contains. Give it an `aria-label`: a group announced as an
+ * unnamed group is noise in the rotation rather than context for it.
+ *
+ * Distinct from `ToggleGroup`, which is a set of related toggles with a shared
+ * VALUE. This one shares only a name.
+ */
+export declare function ToolbarGroup({ className, children, ref, ...props }: ToolbarGroupProps): import("react").JSX.Element;
+export {};

package/dist/types/components/ToggleMatrix.d.ts

@@ -0,0 +1,51 @@
+export interface ToggleMatrixRow {
+    id: string;
+    label: string;
+    /** More about the row. Printed under the label by default, or in a tooltip on it with `rowDescription="tooltip"`. */
+    description?: string;
+    /** A heading the row sits under. Headings appear only when at least one row names one; rows with none then sit under "Other". */
+    group?: string;
+    /** DXUI-29 - present: the row cannot be edited (a lock appears beside its label in an editable matrix, named by this text). */
+    lockedReason?: string;
+}
+export interface ToggleMatrixColumn {
+    id: string;
+    label: string;
+    /** Present: the column cannot be edited (a lock appears in the header of an editable matrix, named by this text). */
+    lockedReason?: string;
+}
+export type ToggleMatrixCell = {
+    state: "on" | "off"; /** This one cell is being saved: a spinner, and the press is refused. */
+    busy?: boolean;
+} | {
+    state: "unavailable"; /** Why this pair cannot be switched. Printed in the cell. */
+    reason: string;
+};
+export interface ToggleMatrixProps {
+    /** Screen-reader caption: what the grid is. */
+    caption: string;
+    /** Header of the row-label column. */
+    rowHeader: string;
+    rows: readonly ToggleMatrixRow[];
+    columns: readonly ToggleMatrixColumn[];
+    /** The state of the cell where a row and a column cross. */
+    cell: (rowId: string, columnId: string) => ToggleMatrixCell;
+    /** Draws no control anywhere. Default `false`. */
+    readOnly?: boolean;
+    /** A cell was pressed; `next` is the NEW value to save. */
+    onChange?: (rowId: string, columnId: string, next: boolean) => void;
+    /** Turns on the header checkbox that sets a whole column. `rowIds` are the switchable rows whose value differs from `next`. */
+    onColumnChange?: (columnId: string, next: boolean, rowIds: string[]) => void;
+    /** `inline` (default) prints a row's description under its label; `tooltip` keeps the label alone and shows it on hover or focus. */
+    rowDescription?: "inline" | "tooltip";
+    /** Tighter cell padding and wrapping column headers, for a phone or a grid of few columns. Default `false`. */
+    dense?: boolean;
+    /** The sentence a screen reader gets for a cell. Default: "<column>: <row> on|off". */
+    cellLabel?: (row: ToggleMatrixRow, column: ToggleMatrixColumn, on: boolean) => string;
+    /** Heading for rows with no `group` when others have one. Default: the catalog's "Other". */
+    otherGroupLabel?: string;
+    /** Names the header checkbox of a column. Default: the catalog's "Set every switch in <column>". */
+    columnSetLabel?: (column: ToggleMatrixColumn) => string;
+    className?: string;
+}
+export declare function ToggleMatrix({ caption, rowHeader, rows, columns, cell, readOnly, onChange, onColumnChange, rowDescription, dense, cellLabel, otherGroupLabel, columnSetLabel, className, }: ToggleMatrixProps): import("react").JSX.Element;

package/dist/types/components/Tree.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+import { type IconName } from "./Icon";
+export type TreeNode = {
+    id: string;
+    label: ReactNode;
+    icon?: IconName;
+    /** Trailing content — a count, a status dot, a menu. */
+    meta?: ReactNode;
+    children?: TreeNode[];
+    disabled?: boolean;
+};
+export interface TreeProps {
+    nodes: TreeNode[];
+    /** Ids expanded on first render. */
+    defaultExpanded?: string[];
+    selectedId?: string;
+    onSelect?: (node: TreeNode) => void;
+    className?: string;
+}
+export declare function Tree({ nodes, defaultExpanded, selectedId, onSelect, className }: TreeProps): import("react").JSX.Element;

package/dist/types/components/TriStateSwitch.d.ts

@@ -0,0 +1,63 @@
+import { type VariantProps } from "tailwind-variants";
+declare const track: import("tailwind-variants").TVReturnType<{
+    size: {
+        sm: "h-(--tri-h) w-(--tri-w) [--tri-h:calc(1.25rem*var(--ui-scale))] [--tri-w:calc(3.125rem*var(--ui-scale))]";
+        md: "h-(--tri-h) w-(--tri-w) [--tri-h:calc(1.5rem*var(--ui-scale))] [--tri-w:calc(3.75rem*var(--ui-scale))]";
+        lg: "h-(--tri-h) w-(--tri-w) [--tri-h:calc(1.75rem*var(--ui-scale))] [--tri-w:calc(4.375rem*var(--ui-scale))]";
+    };
+    state: {
+        no: "border-border bg-switch-track-off";
+        unset: "border-dashed border-border-strong bg-transparent";
+        yes: "border-control bg-control";
+    };
+    disabled: {
+        true: "cursor-not-allowed opacity-45";
+        false: "";
+    };
+}, undefined, string[], {
+    size: {
+        sm: "h-(--tri-h) w-(--tri-w) [--tri-h:calc(1.25rem*var(--ui-scale))] [--tri-w:calc(3.125rem*var(--ui-scale))]";
+        md: "h-(--tri-h) w-(--tri-w) [--tri-h:calc(1.5rem*var(--ui-scale))] [--tri-w:calc(3.75rem*var(--ui-scale))]";
+        lg: "h-(--tri-h) w-(--tri-w) [--tri-h:calc(1.75rem*var(--ui-scale))] [--tri-w:calc(4.375rem*var(--ui-scale))]";
+    };
+    state: {
+        no: "border-border bg-switch-track-off";
+        unset: "border-dashed border-border-strong bg-transparent";
+        yes: "border-control bg-control";
+    };
+    disabled: {
+        true: "cursor-not-allowed opacity-45";
+        false: "";
+    };
+}, undefined, import("tailwind-variants").TVReturnTypeLike<{
+    size: {
+        sm: "h-(--tri-h) w-(--tri-w) [--tri-h:calc(1.25rem*var(--ui-scale))] [--tri-w:calc(3.125rem*var(--ui-scale))]";
+        md: "h-(--tri-h) w-(--tri-w) [--tri-h:calc(1.5rem*var(--ui-scale))] [--tri-w:calc(3.75rem*var(--ui-scale))]";
+        lg: "h-(--tri-h) w-(--tri-w) [--tri-h:calc(1.75rem*var(--ui-scale))] [--tri-w:calc(4.375rem*var(--ui-scale))]";
+    };
+    state: {
+        no: "border-border bg-switch-track-off";
+        unset: "border-dashed border-border-strong bg-transparent";
+        yes: "border-control bg-control";
+    };
+    disabled: {
+        true: "cursor-not-allowed opacity-45";
+        false: "";
+    };
+}, undefined>>;
+export type TriStateSwitchSize = NonNullable<VariantProps<typeof track>["size"]>;
+export interface TriStateSwitchProps {
+    /** `true` Yes, `false` No, `null` not answered. */
+    value: boolean | null;
+    onValueChange: (value: boolean | null) => void;
+    /** The question being answered — the group's accessible name. Required. */
+    "aria-label": string;
+    /** Shows the current state's word beside the track. @default true */
+    showCaption?: boolean;
+    disabled?: boolean;
+    /** @default "md" */
+    size?: TriStateSwitchSize;
+    className?: string;
+}
+export declare function TriStateSwitch({ value, onValueChange, "aria-label": ariaLabel, showCaption, disabled, size, className, }: TriStateSwitchProps): import("react").JSX.Element;
+export {};

package/dist/types/components/VideoPlayer.d.ts

@@ -0,0 +1,26 @@
+import { type Ref } from "react";
+export interface VideoTrack {
+    /** URL of a WebVTT file. */
+    src: string;
+    /** Shown in the browser's caption menu — "English". */
+    label: string;
+    /** BCP-47 language tag — "en". */
+    srcLang: string;
+    default?: boolean;
+}
+export interface VideoPlayerProps {
+    src: string;
+    /** The accessible name of the player — usually the file name. */
+    title: string;
+    /** A still shown until playback starts. */
+    poster?: string;
+    muted?: boolean;
+    /** Caption tracks. Rendered as `kind="captions"`. */
+    tracks?: VideoTrack[];
+    /** When passed, the can't-play fallback offers a Download button that calls it. */
+    onDownload?: () => void;
+    /** Sizes the player's frame. A `max-h-*` here caps the video, which then letterboxes. */
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function VideoPlayer({ src, title, poster, muted, tracks, onDownload, className, ref, }: VideoPlayerProps): import("react").JSX.Element;

package/dist/types/components/auth/AcceptInvitationCard.d.ts

@@ -0,0 +1,54 @@
+import { type ProviderContinuation, type VerifiedIdentity } from "./SignInProviders";
+import { type TermsAcceptanceProps } from "./TermsAcceptance";
+/** What the new-account form hands over; the password mode adds `password`, the verified mode does not. */
+type AcceptInvitationAccount = {
+    name: string;
+    username: string;
+    acceptedTerms: true;
+};
+/** What the person typed before a provider round trip, handed back on return. */
+export interface AcceptInvitationInitialValues {
+    name?: string;
+    username?: string;
+    acceptedTerms?: boolean;
+}
+type AcceptInvitationCardBase = {
+    teamName: string;
+    teamLogoUrl?: string;
+    inviterName: string;
+    roleLabel: string;
+    email: string;
+    /** True when an account already exists for `email`, server-reported. */
+    accountExists: boolean;
+    /** Set when the CURRENT VIEWER is already signed in with a session whose
+     *  email matches `email` — consumer-computed (this component has no notion
+     *  of sessions). Renders a one-click join instead of a form. */
+    signedInAsMatchingUser?: {
+        name: string;
+    } | null;
+    loading?: boolean;
+    /** A server-side error surfaced after a failed submit (username taken, expired token, ...). */
+    error?: string;
+    /** Where the Terms of Use are read, linked from the new-account form's agreement row. */
+    termsHref: string;
+    /** Runs on that link's click; see `TermsAcceptance`. */
+    onOpenTerms?: TermsAcceptanceProps["onOpenTerms"];
+    /** Seeds the new-account form (read once, on mount): what `onContinueWithProvider` reported before the redirect. */
+    initialValues?: AcceptInvitationInitialValues;
+    onJoinAsSignedInUser?: () => void;
+    /** Offered when `accountExists` is true but the viewer isn't signed in as that email. */
+    onSignInInstead?: () => void;
+    className?: string;
+};
+export type AcceptInvitationCardProps = AcceptInvitationCardBase & ProviderContinuation<AcceptInvitationAccount> & ({
+    verifiedIdentity?: undefined;
+    onCreateAccount: (input: AcceptInvitationAccount & {
+        password: string;
+    }) => void;
+} | {
+    /** Set once a provider has verified the person; replaces the password field. */
+    verifiedIdentity: VerifiedIdentity;
+    onCreateAccount: (input: AcceptInvitationAccount) => void;
+});
+export declare function AcceptInvitationCard(props: AcceptInvitationCardProps): import("react").JSX.Element;
+export {};

package/dist/types/components/auth/AuthLayout.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+export interface AuthLayoutProps {
+    /** The team/product mark — an `<img>`, an SVG, or a text wordmark. Omit for no logo slot at all. */
+    logo?: ReactNode;
+    title: ReactNode;
+    subtitle?: ReactNode;
+    /** A link or note below the card ("Don't have an account? Ask your team admin.", "Back to sign in"). */
+    footer?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+export declare function AuthLayout({ logo, title, subtitle, footer, children, className }: AuthLayoutProps): import("react").JSX.Element;

package/dist/types/components/auth/ForgotPasswordForm.d.ts

@@ -0,0 +1,6 @@
+export interface ForgotPasswordFormProps {
+    onSubmit: (email: string) => Promise<void>;
+    submitLabel?: string;
+    className?: string;
+}
+export declare function ForgotPasswordForm({ onSubmit, submitLabel, className }: ForgotPasswordFormProps): import("react").JSX.Element;

package/dist/types/components/auth/LoginForm.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+import { type ProviderSelection } from "./SignInProviders";
+export type LoginFormProps = {
+    onSubmit: (identifier: string, password: string) => Promise<void>;
+    /**
+     * Rendered below the password box, right-aligned, after it in DOM order (DX-5555) — typically a "Forgot password?"
+     * link. Tab runs identifier, password, the show-password toggle, this link, then Sign in.
+     */
+    forgotPasswordLink?: ReactNode;
+    submitLabel?: string;
+    className?: string;
+} & ProviderSelection;
+export declare function LoginForm({ onSubmit, forgotPasswordLink, submitLabel, providers, onSelectProvider, pendingProvider, className, }: LoginFormProps): import("react").JSX.Element;

package/dist/types/components/auth/ResetPasswordForm.d.ts

@@ -0,0 +1,9 @@
+import { type PasswordRequirementRule } from "../PasswordRequirements";
+export interface ResetPasswordFormProps {
+    /** Pure — recomputed against the current draft of the new password on every render. */
+    passwordRules: (nextPassword: string) => PasswordRequirementRule[];
+    onSubmit: (next: string) => Promise<void>;
+    submitLabel?: string;
+    className?: string;
+}
+export declare function ResetPasswordForm({ passwordRules, onSubmit, submitLabel, className, }: ResetPasswordFormProps): import("react").JSX.Element;

package/dist/types/components/auth/SignInProviders.d.ts

@@ -0,0 +1,56 @@
+export type SignInProviderId = "google" | "github";
+export interface SignInProvider {
+    id: SignInProviderId;
+    /** The provider's name as the button shows it ("Google"). */
+    label: string;
+}
+export interface SignInProvidersProps {
+    providers: readonly SignInProvider[];
+    onSelect: (id: SignInProviderId) => void;
+    /** The provider whose sign-in has started; disables the whole row. */
+    pending?: SignInProviderId | null;
+    /** Blocks the row without a pending provider. */
+    disabled?: boolean;
+    /**
+     * Draws the "or" rule above the row. The rule belongs to the row, not to the form around it, so an empty `providers`
+     * list renders neither: there is no way to get an orphan divider (DX-5095).
+     */
+    divided?: boolean;
+    className?: string;
+}
+export declare function SignInProviders({ providers, onSelect, pending, disabled, divided, className, }: SignInProvidersProps): import("react").JSX.Element | null;
+/** A verified identity from a provider: the account is created from it, so no password exists to ask for. */
+export interface VerifiedIdentity {
+    provider: SignInProviderId;
+    handle: string;
+    email: string;
+}
+/**
+ * The provider buttons of a card that creates an account: all three props or none. `Ctx` is what the card has
+ * collected that the provider round trip must carry.
+ */
+export type ProviderContinuation<Ctx> = {
+    providers?: undefined;
+    onContinueWithProvider?: undefined;
+    pendingProvider?: undefined;
+} | {
+    providers: readonly SignInProvider[];
+    onContinueWithProvider: (id: SignInProviderId, context: Ctx) => void;
+    /** The provider whose round trip has started; disables the row. */
+    pendingProvider?: SignInProviderId | null;
+};
+/** The provider buttons of a form that signs an existing account in: all three props or none. */
+export type ProviderSelection = {
+    providers?: undefined;
+    onSelectProvider?: undefined;
+    pendingProvider?: undefined;
+} | {
+    providers: readonly SignInProvider[];
+    onSelectProvider: (id: SignInProviderId) => void;
+    /** The provider whose round trip has started; disables the row. */
+    pendingProvider?: SignInProviderId | null;
+};
+/** The "or" rule between a form and its provider buttons. */
+export declare function OrDivider({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/dist/types/components/auth/SignupCard.d.ts

@@ -0,0 +1,62 @@
+import { type PasswordRequirementRule } from "../PasswordRequirements";
+import { type ProviderContinuation, type VerifiedIdentity } from "./SignInProviders";
+import { type TermsAcceptanceProps } from "./TermsAcceptance";
+/** What the account form hands over; the password mode adds `password`, the verified mode does not. */
+type SignupAccount = {
+    code: string;
+    name: string;
+    username: string;
+    email: string;
+    teamName: string;
+    acceptedTerms: true;
+};
+/** What the person typed before a provider round trip, handed back on return (the code comes back as `initialCode`). */
+export interface SignupInitialValues {
+    name?: string;
+    username?: string;
+    teamName?: string;
+    acceptedTerms?: boolean;
+}
+type SignupCardBase = {
+    /** A code already known (the sign-up link's). Checked on mount, then shown read-only while it is good. */
+    initialCode?: string;
+    /**
+     * Checks a code. Resolves when it is usable — with the email it is reserved for, or `null` when
+     * any address may use it. Rejects with an `Error` whose message is shown to the person when it is not.
+     */
+    onValidateCode: (code: string) => Promise<{
+        emailLock: string | null;
+    }>;
+    /** Pure — recomputed against the current draft of the password on every render. */
+    passwordRules: (password: string) => PasswordRequirementRule[];
+    /** Where the Terms of Use are read, linked from the agreement row. */
+    termsHref: string;
+    /** Runs on that link's click; see `TermsAcceptance`. */
+    onOpenTerms?: TermsAcceptanceProps["onOpenTerms"];
+    /** Seeds the account form (read once, on mount): what `onContinueWithProvider` reported before the redirect. */
+    initialValues?: SignupInitialValues;
+    loading?: boolean;
+    /** A server-side error surfaced after a failed submit (username taken, rate limited, ...). */
+    error?: string;
+    /** Offered beneath the card for a visitor who already has an account. */
+    onSignInInstead?: () => void;
+    className?: string;
+};
+export type SignupCardProps = SignupCardBase & ProviderContinuation<{
+    code: string;
+    name: string;
+    username: string;
+    teamName: string;
+    acceptedTerms: true;
+}> & ({
+    verifiedIdentity?: undefined;
+    onSignup: (input: SignupAccount & {
+        password: string;
+    }) => void;
+} | {
+    /** Set once a provider has verified the person; replaces the password field and fills the email. */
+    verifiedIdentity: VerifiedIdentity;
+    onSignup: (input: SignupAccount) => void;
+});
+export declare function SignupCard(props: SignupCardProps): import("react").JSX.Element;
+export {};

package/dist/types/components/auth/TermsAcceptance.d.ts

@@ -0,0 +1,14 @@
+import type { MouseEvent, ReactNode } from "react";
+export interface TermsAcceptanceProps {
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    /** Where the Terms of Use are read. Opens in a new tab so a half-filled form is not lost. */
+    termsHref: string;
+    /** Runs on the link's click. Call `event.preventDefault()` to open the terms in the app's own router. */
+    onOpenTerms?: (event: MouseEvent<HTMLAnchorElement>) => void;
+    disabled?: boolean;
+    /** A message that marks the row invalid, e.g. "You must accept the Terms of Use to continue". */
+    error?: ReactNode;
+    className?: string;
+}
+export declare function TermsAcceptance({ checked, onCheckedChange, termsHref, onOpenTerms, disabled, error, className, }: TermsAcceptanceProps): import("react").JSX.Element;

package/dist/types/components/auth/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./AuthLayout";
+export * from "./AcceptInvitationCard";
+export * from "./SignupCard";
+export * from "./LoginForm";
+export * from "./SignInProviders";
+export * from "./ForgotPasswordForm";
+export * from "./ResetPasswordForm";
+export * from "./TermsAcceptance";

package/dist/types/components/board/context.d.ts

@@ -0,0 +1,65 @@
+import type { BoardColumnId, BoardColumnModel, BoardItemId, BoardMoveRequest, BoardMoveOutcome, BoardReorderLabels } from "../../lib/board";
+import type { CrossDrop } from "../../lib/dnd";
+export declare const BoardCardSurfaceContext: import("react").Context<boolean>;
+/** `true` when an ancestor `BoardCardSurface` makes this whole card draggable. */
+export declare function useBoardCardIsDragSource(): boolean;
+export interface BoardContextValue<T> {
+    /** Every declared column, in order, as `useBoard` last computed it. The
+     *  "Move to…" menu reads `id` / `label` / `count` off this to offer every
+     *  OTHER column as a destination and to compute an append index. */
+    columns: readonly BoardColumnModel<T>[];
+    /**
+     * The single funnel — see `lib/board/use-board.ts`. Every input source
+     * (drag, keyboard, the menu) calls exactly THIS and nothing else.
+     *
+     * This is `Board.tsx`'s own wrapper around `useBoard`'s `requestMove`, not
+     * the raw hook result — it ALSO surfaces a rejected verdict's reason (see
+     * `types.ts`'s own doc on `BoardMoveVerdict`: "written for a person to
+     * read, not logged") before returning it. Routing that through the same
+     * function every caller already has to call — rather than a second
+     * `reportRejection` a caller could forget — is what makes "a rejected move
+     * never fails silently" true of every source by construction, not by
+     * convention.
+     */
+    requestMove: (request: BoardMoveRequest) => BoardMoveOutcome;
+    /** The words for the card menu's within-column items (`Board`'s `reorderLabels`). */
+    reorderLabels: BoardReorderLabels;
+    /** What a card dropped on another lane means — `Board`'s `crossLaneDrop`. */
+    crossLaneDrop: CrossDrop;
+}
+export interface BoardColumnContextValue {
+    columnId: BoardColumnId;
+    label: string;
+}
+export interface BoardCardContextValue {
+    itemId: BoardItemId;
+    /** Position within ITS OWN column right now — the `from.index` half of any
+     *  move this card's handle constructs. */
+    index: number;
+    label: string | undefined;
+    /**
+     * Called by the card's move control on mount, returning its own cleanup.
+     *
+     * WHY A REGISTRATION RATHER THAN TRUST. `BoardCard` hands its control out
+     * through a render prop, which is what keeps card layout entirely
+     * consumer-owned — but a render prop can be received and never placed, and
+     * the thing that would go missing is the WCAG 2.2 SC 2.5.7 pointer
+     * alternative: the one control a touchscreen user with no keyboard has. That
+     * failure has no error, no type error and no visible symptom for anyone
+     * testing with a mouse, which is precisely the class this project keeps
+     * finding.
+     *
+     * So the control announces itself and `BoardCard` checks. React runs child
+     * effects before parent effects, so by the time the card's own effect runs
+     * the answer is already known. This is the same shape `DragDrop` uses to
+     * learn whether an overlay was rendered (`registerOverlay`) — a part reports
+     * its own existence rather than the parent trying to inspect its children.
+     */
+    registerHandle: () => () => void;
+}
+export declare const BoardProvider: import("react").Provider<BoardContextValue<unknown> | null>;
+export declare const BoardColumnProvider: import("react").Provider<BoardColumnContextValue | null>;
+export declare const BoardCardProvider: import("react").Provider<BoardCardContextValue | null>;
+export declare function useBoardContext<T>(component: string): BoardContextValue<T>;
+export declare function useBoardColumnContext(component: string): BoardColumnContextValue;
+export declare function useBoardCardContext(component: string): BoardCardContextValue;