@arbidocs/blocks 0.3.184 → 0.4.0

package/dist/agents/workflows/WorkflowConfigDialog.d.ts

@@ -0,0 +1,73 @@
+import { type ReactNode } from 'react';
+import { type ScopeFolder, type ScopeLabel } from '../../home/ScopePicker';
+import { type AgentOption, type AgentSelectLabels } from './AgentSelect';
+import { type SchemaFormLabels } from './SchemaForm';
+import type { OnWorkflowLaunch, WorkflowDefinition, WorkflowField, WorkflowInputs, WorkflowScope } from './types';
+/** The workspace's files, as the scope picker needs them. Matching stays with the host. */
+export interface WorkflowScopeSource {
+    folders: ScopeFolder[];
+    unfiledCount: number;
+    labels: ScopeLabel[];
+    totalCount: number;
+    /** How many files a scope selects. */
+    countMatching: (scope: WorkflowScope) => number;
+}
+export interface WorkflowConfigDialogLabels {
+    /** Primary button when the workflow gives no label of its own. */
+    start: string;
+    starting: string;
+    /** Shown instead of the form when `requiresFiles` and the workspace has none. */
+    addFilesReason: string;
+    agentLabel: string;
+}
+export declare const DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS: WorkflowConfigDialogLabels;
+export interface WorkflowConfigDialogProps {
+    workflow: WorkflowDefinition;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onLaunch: OnWorkflowLaunch;
+    /** Values the form opens with, over each field's default (e.g. text typed after a slash). */
+    initialInputs?: Partial<WorkflowInputs>;
+    /** Controlled inputs; omit to let the dialog hold them. */
+    inputs?: WorkflowInputs;
+    onInputsChange?: (inputs: WorkflowInputs) => void;
+    /** Files behind `scope` fields. Without it a scope field renders through `renderScope` or not at all. */
+    scopeSource?: WorkflowScopeSource;
+    renderScope?: (field: WorkflowField, value: WorkflowScope, onChange: (s: WorkflowScope) => void) => ReactNode;
+    /** Renders a `documents` field: the host owns the file list behind the pick. */
+    renderDocuments?: (field: WorkflowField, value: WorkflowScope, onChange: (s: WorkflowScope) => void) => ReactNode;
+    renderIcon?: (key: string) => ReactNode;
+    /** The host's own "Add" control, shown when the workflow needs files and there are none. */
+    addFilesAction?: ReactNode;
+    /** Agents the user can hand the work to. Empty/omitted hides the "Run as" row. */
+    agents?: AgentOption[];
+    agentId?: string;
+    onAgentChange?: (agentId: string) => void;
+    isLaunching?: boolean;
+    /** Primary button text from the current inputs and matched file count. */
+    submitLabel?: (ctx: {
+        workflow: WorkflowDefinition;
+        inputs: WorkflowInputs;
+        matchedCount: number | null;
+    }) => string | undefined;
+    /** Per-field placeholder derived from the inputs (e.g. a name taken from a description). */
+    fieldPlaceholder?: (field: WorkflowField, inputs: WorkflowInputs, workflow: WorkflowDefinition) => string | undefined;
+    /** Anything the host wants to say about the current inputs, above the footer. */
+    renderNotice?: (ctx: {
+        workflow: WorkflowDefinition;
+        inputs: WorkflowInputs;
+    }) => ReactNode;
+    labels?: Partial<WorkflowConfigDialogLabels>;
+    formLabels?: Partial<SchemaFormLabels>;
+    agentLabels?: Partial<AgentSelectLabels>;
+    /** Dialog id; fields use `<testId>-field-<name>`. Default `workflow-dialog`. */
+    testId?: string;
+    startTestId?: string;
+    className?: string;
+}
+/**
+ * One dialog for every workflow: the form comes from the workflow's declared inputs, scope fields
+ * use the shared folder/label picker, and the footer says who runs it. Launching hands
+ * `{workflow, inputs, scope, agentId}` to `onLaunch`; the host does the rest.
+ */
+export declare function WorkflowConfigDialog({ workflow, open, onOpenChange, onLaunch, initialInputs, inputs: inputsProp, onInputsChange, scopeSource, renderScope, renderDocuments, renderIcon, addFilesAction, agents, agentId: agentIdProp, onAgentChange, isLaunching, submitLabel, fieldPlaceholder, renderNotice, labels, formLabels, agentLabels, testId, startTestId, className, }: WorkflowConfigDialogProps): import("react").JSX.Element;

package/dist/agents/workflows/WorkflowLauncher.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from 'react';
+import { type StartTile } from '../../home/StartTiles';
+import { type WorkflowConfigDialogProps } from './WorkflowConfigDialog';
+import type { OnWorkflowLaunch, WorkflowDefinition, WorkflowInputs } from './types';
+export interface WorkflowLauncherProps extends Omit<WorkflowConfigDialogProps, 'workflow' | 'open' | 'onOpenChange' | 'onLaunch' | 'isLaunching' | 'initialInputs'> {
+    workflows: WorkflowDefinition[];
+    /** Which of `workflows` get a tile (a filtered or capped view); default all. */
+    tileWorkflows?: WorkflowDefinition[];
+    /** The host performs the launch (open a chat, scope files, send, land). */
+    onLaunch: OnWorkflowLaunch;
+    /** Render the tile band. Off when something else (the slash menu) opens the dialog. */
+    showTiles?: boolean;
+    caption?: string;
+    captionTestId?: string;
+    /** Tile ids: `<prefix>-<workflow id>` unless `tileTestId` returns one. */
+    tileTestId?: (workflow: WorkflowDefinition) => string | undefined;
+    /** A reason the workflow cannot run now (greys its tile out). */
+    disabledReason?: (workflow: WorkflowDefinition) => string | undefined;
+    /** Controlled open workflow (by id); `null` = none. Omit for uncontrolled. */
+    activeId?: string | null;
+    onActiveIdChange?: (id: string | null) => void;
+    /** Inputs to seed the dialog with when `activeId` opens (slash-typed text etc.). */
+    initialInputsFor?: (workflow: WorkflowDefinition) => Partial<WorkflowInputs> | undefined;
+    /** Extra content inside the tile band's section, after the tiles. */
+    /** Plain tiles appended to the band (tier A actions that are not workflows). */
+    extraTiles?: StartTile[];
+    /** Test id of the tile band. */
+    testId?: string;
+    className?: string;
+    children?: ReactNode;
+}
+/**
+ * The one place a workflow is launched from: a band of tiles plus the config dialog. Choosing a
+ * workflow opens the dialog, which asks what it declares; only an operation with no inputs
+ * launches on the click.
+ * Also usable headless (`showTiles={false}`) when another surface picks the workflow.
+ */
+export declare function WorkflowLauncher({ workflows, tileWorkflows, onLaunch, showTiles, caption, captionTestId, tileTestId, disabledReason, activeId: activeIdProp, onActiveIdChange, initialInputsFor, testId, extraTiles, className, children, renderIcon, ...dialog }: WorkflowLauncherProps): import("react").JSX.Element;

package/dist/agents/workflows/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export { composeWorkflowPrompt, buildLaunch, defaultInputs, validateInputs, isWorkflowScope, isEmptyWorkflowScope, skillToWorkflow, promptFieldName, SKILL_PROMPT_LABEL, SKILL_PROMPT_FALLBACK_PLACEHOLDER, workflowFromFrontmatter, workflowAccepts, workflowsAccepting, workflowsForHost, inputsFromContext, type SkillLike, type WorkflowComposeContext, type WorkflowContext, } from './workflow';
+export { SchemaForm, DEFAULT_SCHEMA_FORM_LABELS, type SchemaFormProps, type SchemaFormLabels, } from './SchemaForm';
+export { AgentSelect, DEFAULT_AGENT_SELECT_LABELS, type AgentSelectProps, type AgentSelectLabels, type AgentOption, } from './AgentSelect';
+export { WorkflowConfigDialog, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, type WorkflowConfigDialogProps, type WorkflowConfigDialogLabels, type WorkflowScopeSource, } from './WorkflowConfigDialog';
+export { WorkflowLauncher, type WorkflowLauncherProps } from './WorkflowLauncher';

package/dist/agents/workflows/types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * The one workflow model: a skill with a declared input schema. Everything launchable (a quick
+ * action, a slash skill, a task body, an agent's job) is a `WorkflowDefinition`.
+ *
+ * The shape maps 1:1 onto future SKILL.md frontmatter (`inputs:` etc., snake_case on disk; see
+ * `workflowFromFrontmatter`), so the backend can adopt it without a UI change. Blocks hold no
+ * domain wording: titles, labels and prompt text are data supplied by the host.
+ */
+export type WorkflowFieldType = 'text' | 'longtext' | 'boolean' | 'select' | 'number' | 'date' | 'scope' | 'documents';
+/**
+ * What a launching surface can hand a workflow without asking the user: the files it is looking at
+ * (`documents`), the text the user selected (`selection`), or the image on screen (`image`, a file
+ * id). A field binds to one with `context`; a surface offers a workflow when it can supply one of
+ * the kinds the workflow declares (`workflowAccepts`).
+ */
+export type WorkflowContextKind = 'documents' | 'selection' | 'image';
+/** Where the user ends up after launching. `current-chat` sends into the chat already on screen. */
+export type WorkflowLanding = 'chat' | 'current-chat' | 'files';
+/** Which files a run is limited to. Empty folders and labels = every file. */
+export interface WorkflowScope {
+    /** Folder paths; `''` is the unfiled bucket. */
+    folders: string[];
+    /** Label (tag) ids. */
+    labels: string[];
+    /** Exactly these files (ids). When present it wins over folders and labels: a `documents` field or a context launch. */
+    documents?: string[];
+}
+export declare const EMPTY_WORKFLOW_SCOPE: WorkflowScope;
+export type WorkflowInputValue = string | number | boolean | WorkflowScope;
+export interface WorkflowFieldOption {
+    value: string;
+    label: string;
+    description?: string;
+    /** Prompt fragment substituted for `{{name}}` when chosen (falls back to the label). */
+    text?: string;
+    /** Key into the host's icon map. */
+    icon?: string;
+}
+export interface WorkflowField {
+    /** Key in `inputs`; also the `{{placeholder}}` in the prompt template. */
+    name: string;
+    type: WorkflowFieldType;
+    label: string;
+    description?: string;
+    placeholder?: string;
+    required?: boolean;
+    default?: WorkflowInputValue;
+    /** `select` only. */
+    options?: WorkflowFieldOption[];
+    /** `number` only. */
+    min?: number;
+    max?: number;
+    /** `boolean`: prompt fragments substituted for `{{name}}`. */
+    trueText?: string;
+    falseText?: string;
+    /** Fold behind a disclosure: advanced wording the common run does not need. */
+    advanced?: boolean;
+    /** `scope` only: which dimensions are offered. Default both. */
+    by?: Array<'folders' | 'labels'>;
+    /** `documents` only: what kind of file is offered; `max` is how many may be picked (default 1). */
+    accept?: 'image';
+    /** Prefilled by a launching surface that supplies this kind of context (see `WorkflowContextKind`). */
+    context?: WorkflowContextKind;
+}
+export type WorkflowRun = 
+/** Compose a message from `promptTemplate` and send it. */
+{
+    kind: 'prompt';
+    promptTemplate: string;
+}
+/** The host performs it (bound by workflow id), e.g. create a label then generate. */
+ | {
+    kind: 'operation';
+};
+export interface WorkflowDefinition {
+    /** The skill slug. */
+    id: string;
+    title: string;
+    /** One line: the tile text and the task picker's hint. */
+    description: string;
+    /** Longer explanation shown in the dialog header; defaults to `description`. */
+    details?: string;
+    /** Key into the host's icon map. */
+    icon?: string;
+    /** Primary button text; defaults to the dialog's generic "Start". */
+    startLabel?: string;
+    /** Shipped with the app/deployment (pinned, not deletable, forkable into the user's own skills). */
+    builtin?: boolean;
+    /** Backed by a server skill (its slug): a task runs it as a skill rather than as a prompt. */
+    skill?: string;
+    inputs: WorkflowField[];
+    run: WorkflowRun;
+    /** Where the user ends up after launching by default; a launch may override it. */
+    landing: WorkflowLanding;
+    /** A model this run asks for (a run option the host applies, e.g. a stronger one for summaries). */
+    model?: string;
+    /** Only offered by this host (e.g. `'word'`); absent = offered everywhere. */
+    host?: string;
+    /** Needs workspace files to make sense: the dialog offers the host's add-files slot when none. */
+    requiresFiles?: boolean;
+    /** Default agent; absent = the user's own assistant. */
+    defaultAgentId?: string;
+    /** Can be the body of a task (unattended). `action` workflows are not. */
+    schedulable?: boolean;
+    /** Run options the form offers (all shown by default). */
+    options?: {
+        agent?: boolean;
+    };
+}
+/** What `onLaunch` receives. The host performs the launch (chat, scoping, send). */
+export interface WorkflowLaunch {
+    workflow: WorkflowDefinition;
+    inputs: Record<string, WorkflowInputValue>;
+    /** The first `scope` field's value, hoisted: the host scopes documents with it. */
+    scope: WorkflowScope;
+    /** `undefined` = the user's own assistant, in this chat. */
+    agentId?: string;
+    /** Overrides `workflow.landing` for this launch (the empty chat sends in place). */
+    landing?: WorkflowLanding;
+}
+export type OnWorkflowLaunch = (launch: WorkflowLaunch) => void | Promise<void>;
+export type WorkflowInputs = Record<string, WorkflowInputValue>;
+/** Validation problem of one field: the dialog maps the code to a label. */
+export type WorkflowFieldError = 'required' | 'min' | 'max' | 'number';
+export type WorkflowErrors = Record<string, WorkflowFieldError>;

package/dist/agents/workflows/workflow.d.ts

@@ -0,0 +1,62 @@
+import { type WorkflowDefinition, type WorkflowErrors, type WorkflowContextKind, type WorkflowInputs, type WorkflowLaunch, type WorkflowScope } from './types';
+export declare const isWorkflowScope: (value: unknown) => value is WorkflowScope;
+export declare const isEmptyWorkflowScope: (scope: WorkflowScope) => boolean;
+/** The inputs a fresh form starts with: each field's default, else an empty value of its type. */
+export declare function defaultInputs(workflow: WorkflowDefinition): WorkflowInputs;
+/** Required-field and range problems, keyed by field name. Empty object = launchable. */
+export declare function validateInputs(workflow: WorkflowDefinition, inputs: WorkflowInputs): WorkflowErrors;
+/**
+ * The field that holds what the user asks for: the first common (not folded away) free-text field.
+ * Text typed after a slash pre-fills it; the form puts the cursor in it when it comes first.
+ */
+export declare function promptFieldName(workflow: WorkflowDefinition): string | undefined;
+/** What the host knows that the inputs alone do not: file ids resolved to names for the wording. */
+export interface WorkflowComposeContext {
+    documentTitles?: Record<string, string>;
+}
+/**
+ * The single place a prompt string is composed from (workflow, inputs): `{{name}}` placeholders in
+ * the template are replaced by each field's text. Whitespace left by empty fragments is tidied.
+ */
+export declare function composeWorkflowPrompt(workflow: WorkflowDefinition, inputs: WorkflowInputs, ctx?: WorkflowComposeContext): string;
+/** Assemble the launch the host receives: inputs, the hoisted scope and the chosen agent. */
+export declare function buildLaunch(workflow: WorkflowDefinition, inputs: WorkflowInputs, agentId?: string): WorkflowLaunch;
+/** What a surface hands a workflow: the files in view, the selected text, the image on screen. */
+export interface WorkflowContext {
+    documents?: string[];
+    selection?: string;
+    /** A file id. */
+    image?: string;
+}
+/** The kinds of context a workflow declares it can be started from. */
+export declare function workflowAccepts(workflow: WorkflowDefinition): WorkflowContextKind[];
+/** Workflows a surface can offer: those that accept at least one kind of context it supplies. */
+export declare function workflowsAccepting(workflows: WorkflowDefinition[], supplied: WorkflowContextKind[]): WorkflowDefinition[];
+/** Workflows a host offers: its own plus every one that is not tied to another host. */
+export declare function workflowsForHost(workflows: WorkflowDefinition[], host: string): WorkflowDefinition[];
+/**
+ * The inputs a context pre-fills: each field bound to a kind the surface supplied. Fields it does
+ * not supply are left to the form's defaults, so the dialog still asks for them.
+ */
+export declare function inputsFromContext(workflow: WorkflowDefinition, context: WorkflowContext): WorkflowInputs;
+/** The slice of a skill listing row the model needs (`SkillSummaryResponse`). */
+export interface SkillLike {
+    name: string;
+    slug: string;
+    description?: string;
+    arg_hint?: string;
+}
+/** The prompt field's label when a skill brings none of its own. */
+export declare const SKILL_PROMPT_LABEL = "What should it work on?";
+export declare const SKILL_PROMPT_FALLBACK_PLACEHOLDER = "Describe what you want";
+/**
+ * A skill is run WITH a prompt, so it always gets a one-field form: a required free-text field
+ * (`args`) whose placeholder is the skill's `arg_hint` (brackets removed). Starting one with
+ * nothing is never offered; text typed after the slash pre-fills the field.
+ */
+export declare function skillToWorkflow(skill: SkillLike): WorkflowDefinition;
+/**
+ * Build a workflow from parsed SKILL.md frontmatter (snake_case keys) and its body (the prompt
+ * template). The inverse of what the backend will publish; seeded workflows use the same shape.
+ */
+export declare function workflowFromFrontmatter(id: string, frontmatter: Record<string, unknown>, body: string): WorkflowDefinition;

package/dist/auth/AuthFooter.d.ts

@@ -0,0 +1,56 @@
+import { type ReactNode } from 'react';
+export interface AuthLegalLink {
+    href: string;
+    label: string;
+}
+export interface AuthConsentProps {
+    termsAccepted: boolean;
+    onTermsAcceptedChange: (accepted: boolean) => void;
+    /** Whether to download a recovery key on signup (opt-out; unchecking shows the warning). */
+    saveRecoveryKey: boolean;
+    onSaveRecoveryKeyChange: (save: boolean) => void;
+    termsLink: AuthLegalLink;
+    privacyLink: AuthLegalLink;
+    /** Shown (role="alert") only when the recovery-key box is unchecked. */
+    noRecoveryKeyWarning: string;
+    labels?: Partial<AuthConsentLabels>;
+    /** Part ids; defaults are the current ids. */
+    testIds?: Partial<Record<'termsCheckbox' | 'recoveryKeyCheckbox' | 'noRecoveryKeyWarning', string>>;
+}
+/** Every fixed string of the sign-up consent block. */
+export interface AuthConsentLabels {
+    /** Text before the terms link. */
+    acknowledge: string;
+    /** Text between the terms and privacy links. */
+    and: string;
+    downloadRecoveryKey: string;
+}
+export declare const DEFAULT_AUTH_CONSENT_LABELS: AuthConsentLabels;
+/** Every fixed string of the sign-in footer. */
+export interface AuthFooterLinksLabels {
+    installOptions: string;
+    install: string;
+}
+export declare const DEFAULT_AUTH_FOOTER_LINKS_LABELS: AuthFooterLinksLabels;
+/** Sign-up consent: required terms checkbox and the opt-out "download recovery key" checkbox. */
+export declare function AuthConsent({ termsAccepted, onTermsAcceptedChange, saveRecoveryKey, onSaveRecoveryKeyChange, termsLink, privacyLink, noRecoveryKeyWarning, labels, testIds, }: AuthConsentProps): import("react").JSX.Element;
+export interface AuthInstallOption {
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    onSelect: () => void;
+    disabled?: boolean;
+    testId?: string;
+}
+export interface AuthFooterLinksProps {
+    privacyLink: AuthLegalLink;
+    /** Entries of the "Install" kebab menu. Omit/empty to hide the menu. */
+    installOptions?: AuthInstallOption[];
+    /** Dialog or other overlay owned by the host, rendered inside the footer. */
+    children?: ReactNode;
+    labels?: Partial<AuthFooterLinksLabels>;
+    /** Install menu trigger id (default `install-options-trigger`). */
+    installTriggerTestId?: string;
+}
+/** Sign-in footer: privacy link on the left, an "Install" kebab menu on the right. */
+export declare function AuthFooterLinks({ privacyLink, installOptions, children, labels, installTriggerTestId, }: AuthFooterLinksProps): import("react").JSX.Element;

package/dist/auth/AuthForm.d.ts

@@ -0,0 +1,105 @@
+import { type ComponentProps, type ReactNode } from 'react';
+import { Button, Input } from '@arbidocs/react/ui';
+/** Title + one-line description above an auth form. */
+export declare function AuthHeading({ title, description }: {
+    title: ReactNode;
+    description?: ReactNode;
+}): import("react").JSX.Element;
+/** A text-style action under or beside a field ("Forgot your password?", "Clear form"). */
+export declare function AuthLink({ className, type, ...props }: ComponentProps<'button'>): import("react").JSX.Element;
+export interface AuthFieldProps {
+    /** Id of the control inside, for the label. Omit it to use a generated (`useId`) id that the
+     *  `AuthInput` / `RevealablePasswordInput` inside picks up automatically. */
+    htmlFor?: string;
+    /** Field-level error: shown under the control, linked with `aria-describedby`, and marks the
+     *  control `aria-invalid`. */
+    error?: ReactNode;
+    errorTestId?: string;
+    label: ReactNode;
+    required?: boolean;
+    /** Right-aligned action in the label row (e.g. "Clear form"). */
+    labelAction?: ReactNode;
+    /** Overlaid at the right edge of the control (e.g. a "Verified" badge). */
+    trailing?: ReactNode;
+    className?: string;
+    children: ReactNode;
+}
+/** Label (with required marker) above a control. */
+export declare function AuthField({ htmlFor, error, errorTestId, label, required, labelAction, trailing, className, children, }: AuthFieldProps): import("react").JSX.Element;
+/** Input styled for auth forms (faint placeholder). */
+export declare function AuthInput({ className, id, 'aria-describedby': describedBy, 'aria-invalid': invalid, ...props }: ComponentProps<typeof Input>): import("react").JSX.Element;
+/** Every fixed string of the revealable password input. */
+export interface RevealablePasswordInputLabels {
+    hidePassword: string;
+    showPassword: string;
+}
+export declare const DEFAULT_REVEALABLE_PASSWORD_INPUT_LABELS: RevealablePasswordInputLabels;
+/** Every fixed string of the offline badge. */
+export interface AuthOfflineBadgeLabels {
+    offline: string;
+}
+export declare const DEFAULT_AUTH_OFFLINE_BADGE_LABELS: AuthOfflineBadgeLabels;
+export interface RevealablePasswordInputProps extends Omit<ComponentProps<typeof Input>, 'type'> {
+    /** Controlled reveal state. Omit it and the input manages its own (see `defaultRevealed`). */
+    isRevealed?: boolean;
+    /** Initial state when uncontrolled. */
+    defaultRevealed?: boolean;
+    /** Called on every toggle press, controlled or not. */
+    onToggleReveal?: () => void;
+    labels?: Partial<RevealablePasswordInputLabels>;
+    /** Show/hide button id (default `toggle-password-visibility`); `data-testid` goes to the input. */
+    toggleTestId?: string;
+}
+/** Password input with a show/hide button inside the field. */
+export declare function RevealablePasswordInput({ isRevealed: controlledRevealed, defaultRevealed, onToggleReveal, className, labels, toggleTestId, ...props }: RevealablePasswordInputProps): import("react").JSX.Element;
+/** Small pill on a locked field, e.g. "Verified". */
+export declare function AuthFieldBadge({ icon, children, testId, }: {
+    icon?: ReactNode;
+    children: ReactNode;
+    testId?: string;
+}): import("react").JSX.Element;
+/** Centred muted sentence under a step's primary action. */
+export declare function AuthNote({ className, ...props }: ComponentProps<'p'>): import("react").JSX.Element;
+/** Error / status message box for a form. */
+export declare function AuthAlert({ children, withIcon, testId, id, }: {
+    children: ReactNode;
+    withIcon?: boolean;
+    testId?: string;
+    /** Lets a field point at this message with `aria-describedby`. */
+    id?: string;
+}): import("react").JSX.Element;
+export interface AuthSubmitButtonProps extends ComponentProps<typeof Button> {
+    /** Shows a spinner and sets `aria-busy`. */
+    isBusy?: boolean;
+    /** Shorthand for `data-testid`. */
+    testId?: string;
+}
+/** Full-width primary submit with a spinner while busy. */
+export declare function AuthSubmitButton({ isBusy, testId, children, className, ...props }: AuthSubmitButtonProps): import("react").JSX.Element;
+/** "or continue with" separator between the form and the SSO button. */
+export declare function AuthDivider({ label, testId }: {
+    label: string;
+    testId?: string;
+}): import("react").JSX.Element;
+export interface AuthTabOption<T extends string> {
+    value: T;
+    label: string;
+    testId?: string;
+}
+/**
+ * Underline tab pair (Login / Register) above the form. Radix Tabs: one tab stop, arrow keys,
+ * Home and End move between tabs and select them (the form below swaps with the selection).
+ */
+export declare function AuthTabs<T extends string>({ value, onChange, tabs, ariaLabel, }: {
+    value: T;
+    onChange: (value: T) => void;
+    tabs: AuthTabOption<T>[];
+    ariaLabel: string;
+}): import("react").JSX.Element;
+/** Pill shown instead of the tabs when the device is offline. */
+export declare function AuthOfflineBadge({ label, title, testId, labels, }: {
+    label?: string;
+    title?: string;
+    testId?: string;
+    labels?: Partial<AuthOfflineBadgeLabels>;
+}): import("react").JSX.Element;

package/dist/auth/AuthLayout.d.ts

@@ -0,0 +1,46 @@
+import type { LucideIcon } from 'lucide-react';
+import type { ReactNode } from 'react';
+export interface AuthLayoutProps {
+    /** The form column content. */
+    children: ReactNode;
+    /** Sits above the form: the Login / Register tabs, or an offline badge. */
+    headerRight?: ReactNode;
+    /** Hero panel: the right half on desktop, hidden on mobile. Omit for a single centred column. */
+    aside?: ReactNode;
+    /** Brand mark shown top-left of the form column (logo + name). */
+    brand?: ReactNode;
+    /** Pinned bottom-right over the hero on desktop (e.g. a deployment indicator). */
+    corner?: ReactNode;
+    className?: string;
+    testId?: string;
+}
+/**
+ * Full-bleed split: a calm form column on the left, the hero (`aside`) on the right. On mobile the
+ * hero is hidden and the form fills the screen. With no `aside` it is a single centred column.
+ */
+export declare function AuthLayout({ children, headerRight, aside, brand, corner, className, testId, }: AuthLayoutProps): import("react").JSX.Element;
+export interface AuthHeroPillar {
+    icon: LucideIcon;
+    title: string;
+    body: string;
+}
+export interface AuthHeroProps {
+    /** First line of the headline. */
+    headline?: ReactNode;
+    /** Second headline line, set in italic accent. */
+    emphasis?: string;
+    lead?: ReactNode;
+    pillars?: AuthHeroPillar[];
+    link?: {
+        href: string;
+        label: string;
+    };
+    /** Cover image behind the content (any CSS `url(...)` source). A tint keeps text legible. */
+    backgroundImage?: string;
+    /** Extra content under the pillars (a quote, a logo row, a screenshot). */
+    children?: ReactNode;
+    className?: string;
+    testId?: string;
+}
+/** The value-proposition panel for {@link AuthLayout}'s `aside`: headline, lead, pillars, link. */
+export declare function AuthHero({ headline, emphasis, lead, pillars, link, backgroundImage, children, className, testId, }: AuthHeroProps): import("react").JSX.Element;

package/dist/auth/PasswordStrengthInput.d.ts

@@ -0,0 +1,44 @@
+/** Overridable ids of the password input; defaults are the current ids. */
+export type PasswordStrengthInputTestIds = Partial<Record<'input' | 'strengthIndicator' | 'strengthBar' | 'confirmInput' | 'confirmIndicator' | 'confirmStrengthBar' | 'mismatchError' | 'requirements' | 'strengthInfoButton' | 'strengthLabel', string>>;
+/** Every fixed string of the password input. `passwordLabel` / `confirmLabel` props win. */
+export interface PasswordStrengthInputLabels {
+    password: string;
+    confirmPassword: string;
+    passwordsMatch: string;
+    passwordsDoNotMatch: string;
+    /** Accessible name of the strength button; `strength` is the meter's label. */
+    strengthInfo: (strength: string) => string;
+    /** Tooltip when the password is acceptable and there is no specific hint. */
+    strengthFallbackHint: string;
+}
+export declare const DEFAULT_PASSWORD_STRENGTH_INPUT_LABELS: PasswordStrengthInputLabels;
+export interface PasswordStrengthInputProps {
+    labels?: Partial<PasswordStrengthInputLabels>;
+    password: string;
+    confirmPassword?: string;
+    onPasswordChange: (value: string) => void;
+    onConfirmPasswordChange?: (value: string) => void;
+    /** Show the confirmation field, the match indicator and the requirement line. */
+    showConfirmation?: boolean;
+    disabled?: boolean;
+    passwordLabel?: string;
+    confirmLabel?: string;
+    layout?: 'stacked' | 'side-by-side';
+    autoFocus?: boolean;
+    showStrengthIndicator?: boolean;
+    /** Shown in the requirements line while no password is entered. */
+    emptyStateMessage?: string;
+    /**
+     * The host's password policy: returns the first unmet requirement (as a message), or `null` when
+     * the password is acceptable. Kept in the host so the policy has one source of truth.
+     */
+    getUnmetRequirement: (password: string) => string | null;
+    /** Part ids; defaults are the current ids. */
+    testIds?: PasswordStrengthInputTestIds;
+}
+/**
+ * Password input with a strength meter and optional confirmation field. The match verdict only
+ * appears once the confirmation field loses focus, so the user is never nagged mid-keystroke, and
+ * the requirement line has a fixed height so typing never shifts the form.
+ */
+export declare function PasswordStrengthInput({ password, confirmPassword, onPasswordChange, onConfirmPasswordChange, showConfirmation, disabled, passwordLabel, confirmLabel, layout, autoFocus, showStrengthIndicator, emptyStateMessage, getUnmetRequirement, labels, testIds, }: PasswordStrengthInputProps): import("react").JSX.Element;

package/dist/auth/RecoveryDialogs.d.ts

@@ -0,0 +1,90 @@
+import { type ReactNode } from 'react';
+/** Every fixed string of the recovery-key dialog. `title` / description props win. */
+export interface RecoveryKeyDialogLabels {
+    title: string;
+    verifiedDescription: string;
+    unverifiedDescription: string;
+    done: string;
+    currentPassword: string;
+    passwordPlaceholder: string;
+    cancel: string;
+    verifying: string;
+    verify: string;
+}
+export declare const DEFAULT_RECOVERY_KEY_DIALOG_LABELS: RecoveryKeyDialogLabels;
+/** Every fixed string of the account-recovery dialog. */
+export interface AccountRecoveryDialogLabels {
+    title: string;
+    description: string;
+    emailAddress: string;
+    emailPlaceholder: string;
+    keyLoadedFromLink: string;
+    ssoProtectedKeyNotice: string;
+    recoveryKey: string;
+    ssoProtectedKey: string;
+    dropKeyHere: string;
+    uploadKeyPrompt: string;
+    ssoSignInNotice: string;
+    ssoSignIn: string;
+    afterRecoveryNotice: string;
+    cancel: string;
+    recovering: string;
+    recoverAccount: string;
+}
+export declare const DEFAULT_ACCOUNT_RECOVERY_DIALOG_LABELS: AccountRecoveryDialogLabels;
+export interface RecoveryKeyDialogProps {
+    labels?: Partial<RecoveryKeyDialogLabels>;
+    open: boolean;
+    onClose: () => void;
+    /** Content shown once the password is verified (the key download). `null` while verifying. */
+    verified: ReactNode | null;
+    password: string;
+    onPasswordChange: (password: string) => void;
+    onVerify: () => void;
+    isVerifying: boolean;
+    error: string | null;
+    title?: string;
+    verifiedDescription?: string;
+    unverifiedDescription?: string;
+    /** Dialog test id (default `download-recovery-key-dialog`). */
+    testId?: string;
+    /** Part ids; defaults are the current ids. */
+    testIds?: Partial<Record<'passwordInput', string>>;
+}
+/**
+ * "Save your recovery key": confirm the account password first, then reveal the key download
+ * (`verified`) with a Done button.
+ */
+export declare function RecoveryKeyDialog({ open, onClose, verified, password, onPasswordChange, onVerify, isVerifying, error, title, verifiedDescription, unverifiedDescription, labels, testId, testIds, }: RecoveryKeyDialogProps): import("react").JSX.Element;
+export interface AccountRecoveryDialogProps {
+    labels?: Partial<AccountRecoveryDialogLabels>;
+    open: boolean;
+    onClose: () => void;
+    email: string;
+    onEmailChange: (email: string) => void;
+    /** The key arrived in the page URL (the /recover link): show a "loaded" notice, no file picker. */
+    isKeyFromLink: boolean;
+    /** Name of the chosen key file, once one is loaded. */
+    keyFileName: string | null;
+    /** The loaded key is wrapped with the user's SSO identity. */
+    isKeyEncrypted: boolean;
+    /** A file was picked or dropped. */
+    onKeyFile: (file: File) => void;
+    error: string | null;
+    /** SSO sign-in is the next required step (SSO-wrapped key or SSO-linked account). */
+    needsSsoSignIn: boolean;
+    onSsoSignIn: () => void;
+    isProcessing: boolean;
+    /** Enables the submit button (email and key present). */
+    canSubmit: boolean;
+    onSubmit: () => void;
+    /** Dialog test id (default `forgot-password-modal`). */
+    testId?: string;
+    /** Part ids; defaults are the current ids. */
+    testIds?: Partial<Record<'emailInput' | 'keyDropzone' | 'keyInput' | 'ssoSignIn' | 'cancel' | 'submit', string>>;
+}
+/**
+ * Account recovery: email + recovery key (file or link) -> sign in with the key. When the account
+ * is SSO-linked, the SSO prompt replaces the submit button.
+ */
+export declare function AccountRecoveryDialog({ open, onClose, email, onEmailChange, isKeyFromLink, keyFileName, isKeyEncrypted, onKeyFile, error, needsSsoSignIn, onSsoSignIn, isProcessing, canSubmit, onSubmit, labels, testId, testIds, }: AccountRecoveryDialogProps): import("react").JSX.Element;