@hex-core/components 1.8.1 → 1.10.0

package/dist/_tsup-dts-rollup.d.ts

@@ -44,6 +44,7 @@ import * as ProgressPrimitive from '@radix-ui/react-progress';
 import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
 import * as React_2 from 'react';
 import { RefAttributes } from 'react';
+import type { Root } from 'mdast';
 import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
 import * as SelectPrimitive from '@radix-ui/react-select';
 import { Separator as Separator_2 } from 'react-resizable-panels';
@@ -401,6 +402,275 @@ export { AudioWaveformProps as AudioWaveformProps_alias_1 }
 
 export declare const audioWaveformSchema: ComponentSchemaDefinition;
 
+declare interface AuthAdapter {
+    signInWithPassword?(p: {
+        email: string;
+        password: string;
+        remember: boolean;
+    }): Promise<AuthAdapterResult>;
+    signUpWithPassword?(p: {
+        email: string;
+        password: string;
+        name?: string;
+    }): Promise<AuthAdapterResult>;
+    signInWithSocial?(p: {
+        provider: AuthSocialProvider;
+    }): Promise<AuthAdapterResult>;
+    sendMagicLink?(p: {
+        email: string;
+    }): Promise<AuthAdapterResult>;
+    verifyOtp?(p: {
+        code: string;
+        intent: AuthOtpIntent;
+    }): Promise<AuthAdapterResult>;
+    requestPasswordReset?(p: {
+        email: string;
+    }): Promise<AuthAdapterResult>;
+    resetPassword?(p: {
+        token: string;
+        password: string;
+    }): Promise<AuthAdapterResult>;
+    registerPasskey?(): Promise<AuthAdapterResult>;
+    signInWithPasskey?(): Promise<AuthAdapterResult>;
+    /**
+     * Re-send a magic link to the same address. Distinct from {@link sendMagicLink}
+     * so consumers can throttle resends and surface different analytics / error
+     * copy for the second-and-onward attempt. Used by the verify-email block.
+     */
+    resendMagicLink?(p: {
+        email: string;
+    }): Promise<AuthAdapterResult>;
+    /**
+     * Re-send a one-time code for the given intent. Distinct from the initial
+     * code dispatch so consumers can throttle and log resends separately. Used
+     * by the verify-otp block.
+     */
+    resendOtp?(p: {
+        intent: AuthOtpIntent;
+    }): Promise<AuthAdapterResult>;
+}
+export { AuthAdapter }
+export { AuthAdapter as AuthAdapter_alias_1 }
+export { AuthAdapter as AuthAdapter_alias_2 }
+
+/**
+ * The contract every Hex Core auth block consumes via its `adapter` prop.
+ *
+ * Hex Core does not ship session management — auth blocks are presentation-
+ * only and delegate every credential, OTP, and OAuth handoff to whatever
+ * the consumer wires up (better-auth, Clerk, NextAuth, Supabase Auth, a
+ * custom server, …). The adapter is the single seam.
+ *
+ * Every method is **optional**. A block that needs `signInWithPassword` but
+ * not passkeys passes an adapter implementing only the methods it needs;
+ * the block surfaces a runtime error if the user hits a code path the
+ * adapter doesn't implement, rather than failing to render. This lets a
+ * consumer ship password-only on day one and add passkeys later without
+ * forking the block source.
+ *
+ * A reference {@link mockAuthAdapter} lives below — used by the docs
+ * showcase routes and unit tests; never ship it in production.
+ */
+declare interface AuthAdapterResult {
+    ok: boolean;
+    error?: {
+        code: string;
+        message: string;
+    };
+    redirect?: string;
+}
+export { AuthAdapterResult }
+export { AuthAdapterResult as AuthAdapterResult_alias_1 }
+export { AuthAdapterResult as AuthAdapterResult_alias_2 }
+
+/**
+ * "Forgot password" page. Single email field; on success swaps to a
+ * confirmation state composed from `Empty` ("we sent you a link") plus a
+ * "back to sign in" affordance. Routes the dispatch through
+ * `adapter.requestPasswordReset`.
+ */
+declare function AuthForgotPassword({ adapter, signInHref, className, onSuccess, }: AuthForgotPasswordProps): JSX.Element;
+export { AuthForgotPassword }
+export { AuthForgotPassword as AuthForgotPassword_alias_1 }
+export { AuthForgotPassword as AuthForgotPassword_alias_2 }
+
+declare interface AuthForgotPasswordProps {
+    adapter: AuthAdapter;
+    signInHref?: string;
+    className?: string;
+    onSuccess?: () => void;
+}
+export { AuthForgotPasswordProps }
+export { AuthForgotPasswordProps as AuthForgotPasswordProps_alias_1 }
+export { AuthForgotPasswordProps as AuthForgotPasswordProps_alias_2 }
+
+export declare const authForgotPasswordSchema: ComponentSchemaDefinition;
+
+declare type AuthOtpIntent = "sign-in" | "verify-email" | "mfa";
+export { AuthOtpIntent }
+export { AuthOtpIntent as AuthOtpIntent_alias_1 }
+export { AuthOtpIntent as AuthOtpIntent_alias_2 }
+
+/**
+ * "Reset password" page. Two fields (new password + confirm) with manual
+ * confirm-match and minLength validation. The opaque `token` is forwarded
+ * verbatim to `adapter.resetPassword`. Routes the consumer-supplied adapter
+ * is responsible for binding the token to a user account on the backend.
+ */
+declare function AuthResetPassword({ adapter, token, signInHref, passwordMinLength, className, onSuccess, }: AuthResetPasswordProps): JSX.Element;
+export { AuthResetPassword }
+export { AuthResetPassword as AuthResetPassword_alias_1 }
+export { AuthResetPassword as AuthResetPassword_alias_2 }
+
+declare interface AuthResetPasswordProps {
+    adapter: AuthAdapter;
+    /** Reset token, typically read from `?token=…` by the showcase / consumer route. */
+    token: string;
+    signInHref?: string;
+    passwordMinLength?: number;
+    className?: string;
+    onSuccess?: (redirect: string | undefined) => void;
+}
+export { AuthResetPasswordProps }
+export { AuthResetPasswordProps as AuthResetPasswordProps_alias_1 }
+export { AuthResetPasswordProps as AuthResetPasswordProps_alias_2 }
+
+export declare const authResetPasswordSchema: ComponentSchemaDefinition;
+
+declare interface AuthSignInSocialProvider {
+    provider: AuthSocialProvider;
+    label: string;
+    icon?: React_2.ReactNode;
+}
+export { AuthSignInSocialProvider }
+export { AuthSignInSocialProvider as AuthSignInSocialProvider_alias_1 }
+export { AuthSignInSocialProvider as AuthSignInSocialProvider_alias_2 }
+
+/**
+ * Split-screen sign-in page. Marketing panel on the left (≥lg), credential
+ * form on the right. All submit paths route through the supplied
+ * `AuthAdapter` — Hex Core never touches credentials directly.
+ */
+declare function AuthSignInSplit({ adapter, socialProviders, brand, marketing, signUpHref, forgotPasswordHref, className, onSuccess, }: AuthSignInSplitProps): JSX.Element;
+export { AuthSignInSplit }
+export { AuthSignInSplit as AuthSignInSplit_alias_1 }
+export { AuthSignInSplit as AuthSignInSplit_alias_2 }
+
+declare interface AuthSignInSplitProps {
+    /** Wires every credential / OAuth call to the consumer's auth library. */
+    adapter: AuthAdapter;
+    /** Optional list of social-login buttons rendered above the email field. */
+    socialProviders?: ReadonlyArray<AuthSignInSocialProvider>;
+    /** Brand block (logo + product name) shown at the top of the marketing panel. */
+    brand?: React_2.ReactNode;
+    /** Marketing copy / quote / illustration shown below the brand block. */
+    marketing?: React_2.ReactNode;
+    /** Href for the "Sign up" link rendered below the form. */
+    signUpHref?: string;
+    /** Href for the "Forgot?" link inline with the password label. */
+    forgotPasswordHref?: string;
+    /** Additional classes applied to the root grid wrapper. */
+    className?: string;
+    /** Called after a successful sign-in (any flow) with the adapter's redirect target. */
+    onSuccess?: (redirect: string | undefined) => void;
+}
+export { AuthSignInSplitProps }
+export { AuthSignInSplitProps as AuthSignInSplitProps_alias_1 }
+export { AuthSignInSplitProps as AuthSignInSplitProps_alias_2 }
+
+export declare const authSignInSplitSchema: ComponentSchemaDefinition;
+
+/** Centered-card sign-up page. Composes Card + form fields + optional social. */
+declare function AuthSignUpCard({ adapter, socialProviders, signInHref, termsHref, privacyHref, passwordMinLength, className, onSuccess, }: AuthSignUpCardProps): JSX.Element;
+export { AuthSignUpCard }
+export { AuthSignUpCard as AuthSignUpCard_alias_1 }
+export { AuthSignUpCard as AuthSignUpCard_alias_2 }
+
+declare interface AuthSignUpCardProps {
+    adapter: AuthAdapter;
+    socialProviders?: ReadonlyArray<AuthSignUpCardSocialProvider>;
+    signInHref?: string;
+    termsHref?: string;
+    privacyHref?: string;
+    passwordMinLength?: number;
+    className?: string;
+    onSuccess?: (redirect: string | undefined) => void;
+}
+export { AuthSignUpCardProps }
+export { AuthSignUpCardProps as AuthSignUpCardProps_alias_1 }
+export { AuthSignUpCardProps as AuthSignUpCardProps_alias_2 }
+
+export declare const authSignUpCardSchema: ComponentSchemaDefinition;
+
+declare interface AuthSignUpCardSocialProvider {
+    provider: AuthSocialProvider;
+    label: string;
+    icon?: React_2.ReactNode;
+}
+export { AuthSignUpCardSocialProvider }
+export { AuthSignUpCardSocialProvider as AuthSignUpCardSocialProvider_alias_1 }
+export { AuthSignUpCardSocialProvider as AuthSignUpCardSocialProvider_alias_2 }
+
+declare type AuthSocialProvider = "github" | "google" | "microsoft" | (string & {});
+export { AuthSocialProvider }
+export { AuthSocialProvider as AuthSocialProvider_alias_1 }
+export { AuthSocialProvider as AuthSocialProvider_alias_2 }
+
+/**
+ * Transactional "verify your email" page. Mostly visual — composes the
+ * `Empty` primitive with a mail icon plus an optional resend button. The
+ * resend button is hidden when `adapter.resendMagicLink` is absent. Rate-
+ * limit pressure handled client-side via a cooldown timer.
+ */
+declare function AuthVerifyEmail({ adapter, email, resendCooldownSeconds, signInHref, className, }: AuthVerifyEmailProps): JSX.Element;
+export { AuthVerifyEmail }
+export { AuthVerifyEmail as AuthVerifyEmail_alias_1 }
+export { AuthVerifyEmail as AuthVerifyEmail_alias_2 }
+
+declare interface AuthVerifyEmailProps {
+    adapter: AuthAdapter;
+    /** Optional address shown in the description ("we sent a link to <email>"). */
+    email?: string;
+    /** Seconds to disable the resend button after each successful resend. */
+    resendCooldownSeconds?: number;
+    /** Href for the "Back to sign in" affordance. */
+    signInHref?: string;
+    className?: string;
+}
+export { AuthVerifyEmailProps }
+export { AuthVerifyEmailProps as AuthVerifyEmailProps_alias_1 }
+export { AuthVerifyEmailProps as AuthVerifyEmailProps_alias_2 }
+
+export declare const authVerifyEmailSchema: ComponentSchemaDefinition;
+
+/**
+ * One-time-code verification page. Renders an `InputOTP` of `length` slots
+ * and submits automatically when the code is full. Routes verification
+ * through `adapter.verifyOtp({ code, intent })`. Optional resend button
+ * calls `adapter.resendOtp({ intent })` when implemented.
+ */
+declare function AuthVerifyOtp({ adapter, intent, length, resendCooldownSeconds, className, onSuccess, }: AuthVerifyOtpProps): JSX.Element;
+export { AuthVerifyOtp }
+export { AuthVerifyOtp as AuthVerifyOtp_alias_1 }
+export { AuthVerifyOtp as AuthVerifyOtp_alias_2 }
+
+declare interface AuthVerifyOtpProps {
+    adapter: AuthAdapter;
+    /** Forwarded verbatim to adapter.verifyOtp({ code, intent }). */
+    intent: AuthOtpIntent;
+    /** Total number of digits in the code. Defaults to 6. */
+    length?: number;
+    /** Seconds the resend button stays disabled after each successful resend. */
+    resendCooldownSeconds?: number;
+    className?: string;
+    onSuccess?: (redirect: string | undefined) => void;
+}
+export { AuthVerifyOtpProps }
+export { AuthVerifyOtpProps as AuthVerifyOtpProps_alias_1 }
+export { AuthVerifyOtpProps as AuthVerifyOtpProps_alias_2 }
+
+export declare const authVerifyOtpSchema: ComponentSchemaDefinition;
+
 /** Root container for an avatar (image + fallback). */
 declare const Avatar: React_2.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React_2.RefAttributes<HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
 export { Avatar }
@@ -448,6 +718,52 @@ declare const badgeVariants: (props?: ({
 export { badgeVariants }
 export { badgeVariants as badgeVariants_alias_1 }
 
+/**
+ * Render a single-active-branch navigator with prev/next controls.
+ * @param props - current/total + change handler + body
+ * @returns A nav landmark wrapping the active branch and a control chip
+ */
+declare function Branch({ current, total, onCurrentChange, children, "aria-label": ariaLabel, className, }: BranchProps): JSX.Element | null;
+export { Branch }
+export { Branch as Branch_alias_1 }
+
+/**
+ * Headless alternate-response navigator. Renders the active branch
+ * (`children`) with a prev/next control chip beneath it. Stateless —
+ * the consumer owns `current` (zero-indexed) and `total`.
+ *
+ * Keyboard: ArrowLeft / ArrowRight step through branches when focus
+ * lives anywhere inside the group (the wrapper itself is not focusable;
+ * the prev/next buttons or any focusable descendant carry the keys).
+ * Read-only when `onCurrentChange` is omitted.
+ *
+ * @example
+ * <Branch current={index} total={alternatives.length} onCurrentChange={setIndex}>
+ *   <Message role="assistant">
+ *     <Markdown>{alternatives[index]}</Markdown>
+ *   </Message>
+ * </Branch>
+ */
+declare interface BranchProps {
+    /** Zero-indexed active branch. */
+    current: number;
+    /** Total number of branches. */
+    total: number;
+    /** Optional change handler — when omitted, the controls render disabled. */
+    onCurrentChange?: (next: number) => void;
+    /** The active branch content (typically a `<Message>` or `<Markdown>`). */
+    children: React_2.ReactNode;
+    /** Override the accessible label for the navigator landmark. */
+    "aria-label"?: string;
+    className?: string;
+}
+export { BranchProps }
+export { BranchProps as BranchProps_alias_1 }
+
+declare const branchSchema: ComponentSchemaDefinition;
+export { branchSchema }
+export { branchSchema as branchSchema_alias_1 }
+
 /** Root nav landmark for breadcrumb navigation. */
 declare const Breadcrumb: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React_2.RefAttributes<HTMLElement>>;
 export { Breadcrumb }
@@ -637,6 +953,68 @@ declare const CardTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttribute
 export { CardTitle }
 export { CardTitle as CardTitle_alias_1 }
 
+/**
+ * Render a structured reasoning trace + optional final answer.
+ * @param props - The ordered steps and optional final answer.
+ * @returns A Reasoning collapsible wrapping per-step rows, then the final answer.
+ */
+declare function ChainOfThought({ steps, finalAnswer, label, defaultOpen, className, }: ChainOfThoughtProps): JSX.Element;
+export { ChainOfThought }
+export { ChainOfThought as ChainOfThought_alias_1 }
+
+/**
+ * Structured reasoning trace following the canonical ReAct shape — each
+ * step has a `thought`, an optional `action`, and an optional
+ * `observation`. The final answer renders below the trace.
+ *
+ * Distinct from `<Reasoning>`: Reasoning is unstructured prose;
+ * `<ChainOfThought>` enforces the per-step structure agents emit when
+ * doing tool-augmented reasoning. Internally composes `<Reasoning>` for
+ * the collapsible shell so the visual rhythm matches.
+ *
+ * @example
+ * <ChainOfThought
+ *   steps={[
+ *     {
+ *       thought: "Need to look up the auth module",
+ *       action: "read auth.ts",
+ *       observation: "200 lines, uses bcrypt + jwt",
+ *     },
+ *     { thought: "The bug is on line 42 — missing salt rounds." },
+ *   ]}
+ *   finalAnswer={<Markdown>{summary}</Markdown>}
+ * />
+ */
+declare interface ChainOfThoughtProps {
+    /** Ordered ReAct steps. */
+    steps: ChainOfThoughtStep[];
+    /** Optional final answer rendered beneath the trace. */
+    finalAnswer?: React_2.ReactNode;
+    /** Header label for the collapsible. Defaults to "Chain of thought". */
+    label?: string;
+    /** Whether the trace is expanded by default. */
+    defaultOpen?: boolean;
+    className?: string;
+}
+export { ChainOfThoughtProps }
+export { ChainOfThoughtProps as ChainOfThoughtProps_alias_1 }
+
+declare const chainOfThoughtSchema: ComponentSchemaDefinition;
+export { chainOfThoughtSchema }
+export { chainOfThoughtSchema as chainOfThoughtSchema_alias_1 }
+
+/** A single ReAct step. */
+declare interface ChainOfThoughtStep {
+    /** What the model is thinking right now. Required — every step has a thought. */
+    thought: React_2.ReactNode;
+    /** Optional action the model is about to take (e.g. "read auth.ts"). */
+    action?: React_2.ReactNode;
+    /** Optional observation returned by the action. */
+    observation?: React_2.ReactNode;
+}
+export { ChainOfThoughtStep }
+export { ChainOfThoughtStep as ChainOfThoughtStep_alias_1 }
+
 /**
  * Categorical chart palette for diagram primitives that encode categorical
  * data (sunburst, treemap, sankey, chord, funnel, pyramid, venn, matrix).
@@ -781,6 +1159,38 @@ declare const citationSchema: ComponentSchemaDefinition;
 export { citationSchema }
 export { citationSchema as citationSchema_alias_1 }
 
+/**
+ * Streaming-safe markdown pre-processor. Detects unterminated tokens at
+ * end-of-input and appends synthetic closers so `react-markdown`'s
+ * parser doesn't render half-tokens as raw text or throw.
+ *
+ * Used by the `Markdown` component when consumers stream LLM output
+ * one chunk at a time. Pure function — no I/O, no React, no plugins —
+ * so it's trivially unit-testable as a truth table.
+ *
+ * Order matters. We close in this priority:
+ *   1. Fenced code blocks (` ``` `) — most disruptive if open.
+ *   2. HTML tags (`<tag` without `>`) — would consume rest of stream as attribute.
+ *   3. Link parentheses (`[text](url`) — `react-markdown` falls back to text on these.
+ *   4. Link brackets (`[text` no `]`) — consumes potentially huge bodies.
+ *   5. Inline backticks (`` ` ``) — small but visible.
+ *   6. Strikethrough (`~~`) — GFM extension.
+ *   7. Bold (`**`) — must close before single `*` so we don't double-count.
+ *   8. Italic (`*`, `_`) — last (most ambiguous).
+ *
+ * For tokens 5–8 we operate over a mask-view that replaces fenced
+ * regions with whitespace of the same length, so an unclosed `**`
+ * inside ` ``` ` doesn't trigger a closer.
+ */
+/**
+ * Pre-process raw markdown for the streaming-safe renderer.
+ * @param input - Raw markdown string, possibly mid-stream.
+ * @returns Input with synthetic closers appended for each open-at-EOF token.
+ */
+declare function closeUnterminated(input: string): string;
+export { closeUnterminated }
+export { closeUnterminated as closeUnterminated_alias_1 }
+
 declare function Cloze({ parts, revealMode, onReveal, className, ...rest }: ClozeProps): JSX.Element;
 export { Cloze }
 export { Cloze as Cloze_alias_1 }
@@ -1435,6 +1845,76 @@ declare const ContextMenuTrigger: React_2.ForwardRefExoticComponent<ContextMenuP
 export { ContextMenuTrigger }
 export { ContextMenuTrigger as ContextMenuTrigger_alias_1 }
 
+/**
+ * Render a chat conversation shell.
+ * @param props - messages + submit handler + optional streaming/sources state
+ * @returns A flex column with a scrolling message list, optional sources/shimmer, and a composer row
+ */
+declare function Conversation({ messages, onSubmit, placeholder, value: valueProp, onValueChange: onValueChangeProp, isStreaming, sources, disabled, composerActions, className, }: ConversationProps): JSX.Element;
+export { Conversation }
+export { Conversation as Conversation_alias_1 }
+
+/** A single message in a `<Conversation>`. */
+declare interface ConversationMessage {
+    /** Stable identifier — used for the React key. */
+    id: string;
+    /** Speaker. */
+    role: Role_2;
+    /** Message content. Pass a string for plain text or a node (e.g. `<Markdown>`) for formatted output. */
+    content: React_2.ReactNode;
+}
+export { ConversationMessage }
+export { ConversationMessage as ConversationMessage_alias_1 }
+
+/**
+ * High-level chat shell. Composes `<MessageList>` over `messages`, an
+ * optional `<Sources>` panel beneath the latest assistant turn, an
+ * optional `<Shimmer>` placeholder for the in-flight assistant response,
+ * and a `<Composer>` row at the bottom.
+ *
+ * Presentational: the consumer owns the `messages` array and the
+ * `onSubmit` handler. The composer's text state is internal by default
+ * so simple consumers don't thread input plumbing; pass `value` +
+ * `onValueChange` together to take full control (suggested-prompt
+ * injection, voice transcription, form-library integration).
+ *
+ * @example
+ * <Conversation
+ *   messages={messages}
+ *   onSubmit={(text) => sendMessage(text)}
+ *   isStreaming={isWaitingForFirstToken}
+ *   sources={lastResponse.sources}
+ *   placeholder="Ask anything…"
+ * />
+ */
+declare interface ConversationProps {
+    /** Ordered chat history. Each item renders as one `<Message>`. */
+    messages: ConversationMessage[];
+    /** Called with the trimmed text when the user submits the composer. */
+    onSubmit: (text: string) => void;
+    /** Composer placeholder. */
+    placeholder?: string;
+    /** Controlled composer text. Pass with `onValueChange` to take control of the input — useful for suggested prompts, voice transcripts, or form-library integration. */
+    value?: string;
+    /** Called whenever the composer text changes. Required when `value` is set. */
+    onValueChange?: (value: string) => void;
+    /** When true, render a `<Shimmer>` placeholder above the composer (use during the dead time before the first stream token). */
+    isStreaming?: boolean;
+    /** Optional citations rendered as a `<Sources>` panel beneath the message stream. */
+    sources?: SourceRef[];
+    /** Disable the composer (e.g. while waiting on a tool call). */
+    disabled?: boolean;
+    /** Trailing slot inside the composer — typically a Send button. */
+    composerActions?: React_2.ReactNode;
+    className?: string;
+}
+export { ConversationProps }
+export { ConversationProps as ConversationProps_alias_1 }
+
+declare const conversationSchema: ComponentSchemaDefinition;
+export { conversationSchema }
+export { conversationSchema as conversationSchema_alias_1 }
+
 /**
  * Render a data-driven table from TanStack column definitions.
  * @param props - Columns, data, and optional accessible labelling (`caption` or `aria-label`)
@@ -2473,7 +2953,7 @@ export { gridSchema as gridSchema_alias_1 }
  * the schema's `enumValues` serializes them as strings for JSON-shape parity.
  */
 declare const gridVariants: (props?: ({
-    cols?: 1 | 2 | 3 | 4 | 6 | "auto-fit" | null | undefined;
+    cols?: 3 | 1 | 2 | 4 | 6 | "auto-fit" | null | undefined;
     gap?: "sm" | "lg" | "md" | "xl" | "xs" | null | undefined;
     align?: "center" | "start" | "end" | "stretch" | null | undefined;
 } & ClassProp) | undefined) => string;
@@ -2569,6 +3049,51 @@ declare const imageOcclusionSchema: ComponentSchemaDefinition;
 export { imageOcclusionSchema }
 export { imageOcclusionSchema as imageOcclusionSchema_alias_1 }
 
+/**
+ * Render an inline citation reference with hover preview.
+ * @param props - Index, title, optional url + excerpt.
+ * @returns A `<sup>` with a Radix HoverCard popover.
+ */
+declare function InlineCitation({ index, title, url: rawUrl, excerpt, openDelay, className, }: InlineCitationProps): JSX.Element;
+export { InlineCitation }
+export { InlineCitation as InlineCitation_alias_1 }
+
+/**
+ * Inline footnote-style reference with a hover-preview popover.
+ *
+ * Pairs with `<Sources>` for the bottom-of-card list. Block-level
+ * `<Citation>` chips are too large to embed mid-sentence; this primitive
+ * fills the inline-text gap with a `<sup>[N]</sup>` and an
+ * Anthropic-style hover preview showing the source title + URL.
+ *
+ * The Markdown component routes `[N](url)` shapes through this slot —
+ * authors don't write the JSX directly in the streaming path.
+ *
+ * @example
+ * The frontier models all publish reasoning evals
+ * <InlineCitation index={1} title="Anthropic — Claude Sonnet 4.5"
+ *   url="https://anthropic.com/claude" />.
+ */
+declare interface InlineCitationProps {
+    /** Footnote number (1-based). Renders inside the visible `<sup>`. */
+    index: number;
+    /** Source title shown in the hover preview. */
+    title: string;
+    /** Optional URL — when set, the trigger becomes a focusable anchor. */
+    url?: string;
+    /** Optional excerpt or context shown under the title in the preview. */
+    excerpt?: string;
+    /** Open delay in ms (matches Radix default ~700). */
+    openDelay?: number;
+    className?: string;
+}
+export { InlineCitationProps }
+export { InlineCitationProps as InlineCitationProps_alias_1 }
+
+declare const inlineCitationSchema: ComponentSchemaDefinition;
+export { inlineCitationSchema }
+export { inlineCitationSchema as inlineCitationSchema_alias_1 }
+
 declare const Input: React_2.ForwardRefExoticComponent<InputProps & React_2.RefAttributes<HTMLInputElement>>;
 export { Input }
 export { Input as Input_alias_1 }
@@ -2725,31 +3250,35 @@ export { loadingVariants }
 export { loadingVariants as loadingVariants_alias_1 }
 
 /**
- * Renders streaming-safe markdown.
- * @param props - children string + optional Streamdown overrides
- * @returns A Streamdown root scoped with prose styles
+ * Render streaming-safe markdown with AI-aware slot wiring.
+ *
+ * @param props - The markdown source string + optional className.
+ * @returns A `<div>` wrapping the rendered markdown tree.
  */
 declare function Markdown({ children, className }: MarkdownProps): JSX.Element;
 export { Markdown }
 export { Markdown as Markdown_alias_1 }
 
 /**
- * Streaming-safe markdown renderer. Wraps Vercel's `streamdown` so partial
- * input mid-stream — unclosed code fences, half-typed tags, dangling
- * brackets — renders gracefully instead of throwing or flashing raw text.
+ * Streaming-safe markdown renderer with AI-aware element slots.
  *
- * Public prop surface is intentionally minimal (`children` + `className`)
- * so this primitive's DTS doesn't drag in `streamdown`'s full type graph.
- * Doing so would transitively pull Shiki's 600-literal `BundledLanguage`
- * union into the rollup-dts pass and exhaust heap. For per-element
- * overrides (custom `pre`, `code`, `a`, `img`, mermaid, math, line
- * numbers, plugins, etc.) drop down to `Streamdown` directly:
+ * Native pipeline (no `streamdown`): `react-markdown` + `remark-gfm`
+ * for tables/task lists, `rehype-raw` to preserve the custom
+ * `<tool-call>` element, `rehype-sanitize` to whitelist our slot tags,
+ * `closeUnterminated` for streaming recovery (closes mid-stream `**`,
+ * fences, links, tags before the parser sees them).
  *
- * ```tsx
- * import { Streamdown } from "streamdown";
- * import { CodeBlock } from "@hex-core/components";
- * <Streamdown components={{ pre: (p) => <CodeBlock {...p} /> }}>{md}</Streamdown>
- * ```
+ * Slot wiring:
+ * - **Fenced code** (` ```lang `) → `<pre><code class="language-*">` (client-safe; consumers post-highlight).
+ * - **Footnote-style links** (`[1](url)`) → `<InlineCitation>` (inline `<sup>` with hover preview).
+ * - **`<sources data='[…]' />`** → `<Sources>` (collapsible RAG-source list).
+ * - **`<tool-call name=… state=… args=… result=…/>`** → `<ToolCall>`.
+ * - **`> [!think]\n> body`** blockquotes → `<Reasoning>`.
+ *
+ * The fenced-code slot doesn't route to the in-house `<CodeBlock>`
+ * because CodeBlock is an async Server Component and Markdown runs
+ * client-side. Consumers in an RSC tree can compose `<CodeBlock>`
+ * directly when they need server-side Shiki highlighting.
  *
  * @example
  * <Message role="assistant">
@@ -3059,6 +3588,17 @@ declare const mindMapSchema: ComponentSchemaDefinition;
 export { mindMapSchema }
 export { mindMapSchema as mindMapSchema_alias_1 }
 
+/**
+ * In-memory mock adapter for docs showcase + tests. Every method delays
+ * 400ms to simulate a network round-trip and resolves `{ ok: true }`. Do
+ * not use in production — there is no validation, no persistence, and no
+ * security.
+ */
+declare const mockAuthAdapter: Required<AuthAdapter>;
+export { mockAuthAdapter }
+export { mockAuthAdapter as mockAuthAdapter_alias_1 }
+export { mockAuthAdapter as mockAuthAdapter_alias_2 }
+
 /**
  * Searchable multi-select input built on Command + Popover.
  *
@@ -3342,6 +3882,74 @@ export { parseHslTriplet as parseHslTriplet_alias_1 }
  */
 export declare function pickChartHue(index: number): string;
 
+/**
+ * Render a pre-execution multi-step plan with an optional approval gate.
+ * @param props - The plan label, steps, and optional approve/cancel handlers.
+ * @returns A card wrapping a numbered step list and (optionally) an action footer.
+ */
+declare function Plan({ label, description, steps, onApprove, onCancel, approveLabel, cancelLabel, className, }: PlanProps): JSX.Element;
+export { Plan }
+export { Plan as Plan_alias_1 }
+
+/**
+ * Pre-execution plan card. Shown BEFORE the agent starts executing —
+ * the body lists the proposed steps; an optional `onApprove` /
+ * `onCancel` footer renders an approval gate.
+ *
+ * Distinct from `<Task>`: Task is during/post-execution status (steps
+ * carry a lifecycle state); Plan is pre-execution intent (steps are
+ * just labels). Once approved, consumers typically swap the rendered
+ * `<Plan>` for a `<Task>` driven by the running agent.
+ *
+ * @example
+ * <Plan
+ *   label="Refactor auth module"
+ *   description="Three-step refactor with tests."
+ *   steps={[
+ *     { id: "read", label: "Read existing auth" },
+ *     { id: "apply", label: "Apply changes" },
+ *     { id: "test", label: "Run tests" },
+ *   ]}
+ *   onApprove={() => execute()}
+ *   onCancel={() => discard()}
+ * />
+ */
+declare interface PlanProps {
+    /** Optional title shown above the step list. */
+    label?: string;
+    /** Optional secondary description shown under the label. */
+    description?: string;
+    /** Ordered list of steps. Each carries an id, label, and optional detail. */
+    steps: PlanStep[];
+    /** When provided, an "Approve" button is rendered in the footer. */
+    onApprove?: () => void;
+    /** When provided, a "Cancel" button is rendered in the footer. */
+    onCancel?: () => void;
+    /** Override the approve button label. Defaults to "Approve". */
+    approveLabel?: string;
+    /** Override the cancel button label. Defaults to "Cancel". */
+    cancelLabel?: string;
+    className?: string;
+}
+export { PlanProps }
+export { PlanProps as PlanProps_alias_1 }
+
+declare const planSchema: ComponentSchemaDefinition;
+export { planSchema }
+export { planSchema as planSchema_alias_1 }
+
+/** A single proposed step in a Plan. */
+declare interface PlanStep {
+    /** Stable identifier — used for the React key. */
+    id: string;
+    /** Human-readable step label. */
+    label: string;
+    /** Optional secondary detail shown beneath the label. */
+    detail?: string;
+}
+export { PlanStep }
+export { PlanStep as PlanStep_alias_1 }
+
 /** Root container for a popover. */
 declare const Popover: React_2.FC<PopoverPrimitive.PopoverProps>;
 export { Popover }
@@ -3544,6 +4152,25 @@ declare const reasoningSchema: ComponentSchemaDefinition;
 export { reasoningSchema }
 export { reasoningSchema as reasoningSchema_alias_1 }
 
+/**
+ * Tag blockquotes that start with `[!think]` as admonitions of type
+ * `think`. Strips the marker text from the rendered content and writes
+ * the type onto `node.data.hProperties` so the rehype pass surfaces it
+ * as a `data-admonition` attribute on the `<blockquote>` element. Slot
+ * renderers in the React layer then route that attribute to
+ * `<Reasoning>`.
+ *
+ * Pure transform; no I/O. Operates on the mdast tree before
+ * `remark-rehype` produces hast.
+ *
+ * Only ships `[!think]` in Phase 2. Other admonitions
+ * (`[!warn]`/`[!info]`/`[!error]`) can be added by extending the
+ * `SUPPORTED` set without touching slot wiring.
+ *
+ * @returns A unified plugin transformer.
+ */
+export declare function remarkAdmonitions(): (tree: Root) => void;
+
 /**
  * Draggable separator between panels. Optionally renders a grab-grip dot.
  * @returns A slim, focusable resize handle.
@@ -3614,6 +4241,35 @@ export { Role }
 export { Role as Role_alias_1 }
 export { Role as Role_alias_2 }
 
+/**
+ * Speaker of a message. Mirrors the canonical `Role` union from
+ * `@hex-core/components` exactly — kept inline (rather than imported
+ * from `../types.js`) so the registry CLI distribution path (`npx hex
+ * add conversation`) ships a self-contained file. Same precedent as
+ * `task.tsx`'s inlined `ToolCallState`. The build-registry script
+ * doesn't bundle `types.ts`, so importing from it would leave consumer
+ * TS strict-mode unable to resolve the type at the install location.
+ */
+declare type Role_2 = "user" | "assistant" | "system" | "tool";
+
+/**
+ * Allowlist a URL for use as an `<a href>` against untrusted input.
+ *
+ * Returns the raw string when it's `http(s):` / `mailto:` / a relative
+ * URL (no scheme); returns `undefined` otherwise. Defends against
+ * `javascript:` / `data:` / `vbscript:` injection from streamed model
+ * output or third-party JSON payloads that flow into citation chips.
+ *
+ * Inside a Markdown render path, `rehype-sanitize` already strips
+ * `javascript:` from inline-link hrefs — but it does NOT introspect
+ * JSON nested inside attribute values (e.g. `<sources data='[…]'/>`),
+ * so the components that consume that data must guard themselves.
+ *
+ * @param raw - The candidate URL, or `undefined` when none was supplied.
+ * @returns The URL when safe to render, otherwise `undefined`.
+ */
+export declare function safeUrl(raw: string | undefined): string | undefined;
+
 declare function Sankey({ nodes, links, width, height, nodeAlign, nodeWidth, nodePadding, onLinkHover, onNodeClick, className, ...rest }: SankeyProps): JSX.Element;
 export { Sankey }
 export { Sankey as Sankey_alias_1 }
@@ -3902,6 +4558,55 @@ declare const sheetVariants: (props?: ({
     side?: "top" | "right" | "bottom" | "left" | null | undefined;
 } & ClassProp) | undefined) => string;
 
+/**
+ * Render a streaming placeholder bar.
+ *
+ * Uses Tailwind's `animate-pulse` for the loading effect — same
+ * approach as `<Skeleton>` so consumers don't need extra global CSS or
+ * keyframes. The `durationMs` prop scales the pulse cycle via a CSS
+ * variable so the animation stays in pulse's vertical-opacity family
+ * rather than introducing a custom sweep keyframe (which would
+ * conflict with React 19's stricter style-tag handling).
+ *
+ * @param props - Optional sizing + duration + label overrides.
+ * @returns A pulsing placeholder bar.
+ */
+declare function Shimmer({ width, height, durationMs, label, className, }: ShimmerProps): JSX.Element;
+export { Shimmer }
+export { Shimmer as Shimmer_alias_1 }
+
+/**
+ * Single-line streaming placeholder. Used during the dead-time between
+ * a user submitting a prompt and the first stream token arriving — a
+ * gradient sweep across a flat bar that signals "the model is thinking
+ * but hasn't started speaking yet."
+ *
+ * Wider than `<Loading>` (which is a multi-row skeleton) and narrower
+ * than `<Skeleton>` (which is a sized placeholder block); use Shimmer
+ * for the conversation pane, Loading for whole-screen states, Skeleton
+ * for arbitrary placeholder shapes.
+ *
+ * @example
+ * {isStreaming && <Shimmer width="80%" />}
+ */
+declare interface ShimmerProps {
+    /** CSS width — accepts any width value (e.g. `"60%"`, `"24rem"`). Defaults to full width. */
+    width?: string;
+    /** Override the default 1.5rem height for taller streaming bars. */
+    height?: string;
+    /** Sweep duration in ms. Defaults to 1500. */
+    durationMs?: number;
+    /** Accessible label announced to screen readers. */
+    label?: string;
+    className?: string;
+}
+export { ShimmerProps }
+export { ShimmerProps as ShimmerProps_alias_1 }
+
+declare const shimmerSchema: ComponentSchemaDefinition;
+export { shimmerSchema }
+export { shimmerSchema as shimmerSchema_alias_1 }
+
 /**
  * App-shell sidebar. Reads open state from SidebarProvider and animates width.
  * @returns An aside element that expands/collapses.
@@ -4037,6 +4742,61 @@ declare const sonnerSchema: ComponentSchemaDefinition;
 export { sonnerSchema }
 export { sonnerSchema as sonnerSchema_alias_1 }
 
+/** Per-source data passed to a Citation chip. */
+declare interface SourceRef {
+    title: string;
+    url?: string;
+    page?: number;
+    /** Optional 1-based index. Falls back to array position. Use to keep
+     * the inline `<InlineCitation>` index aligned with the panel row when
+     * the model emits non-1-based numbering. */
+    index?: number;
+}
+export { SourceRef }
+export { SourceRef as SourceRef_alias_1 }
+
+/**
+ * Render a sources panel for an LLM response. Returns null when the
+ * sources array is empty — consumers don't get a "0 sources" empty
+ * card; they just don't render the panel at all.
+ *
+ * @param props - The list of sources + open-state default.
+ * @returns A Collapsible wrapping a Citation cluster, or null if empty.
+ */
+declare function Sources({ sources, defaultOpen, className }: SourcesProps): JSX.Element | null;
+export { Sources }
+export { Sources as Sources_alias_1 }
+
+/**
+ * Bordered card listing 1–N citation chips for a RAG response.
+ *
+ * Header reads "N sources" and is a clickable Radix Collapsible trigger;
+ * body renders one `<Citation>` per source (re-using the in-house chip).
+ * Defaults to open so consumers don't have to expand to see what was
+ * cited.
+ *
+ * @example
+ * <Sources
+ *   sources={[
+ *     { title: "Auth research", url: "https://example.com/auth", page: 3 },
+ *     { title: "OAuth 2.1 spec", url: "https://oauth.net/2.1" },
+ *   ]}
+ * />
+ */
+declare interface SourcesProps {
+    /** Citation rows. Each becomes a `<Citation>` chip. */
+    sources: SourceRef[];
+    /** Whether the list is expanded by default. */
+    defaultOpen?: boolean;
+    className?: string;
+}
+export { SourcesProps }
+export { SourcesProps as SourcesProps_alias_1 }
+
+declare const sourcesSchema: ComponentSchemaDefinition;
+export { sourcesSchema }
+export { sourcesSchema as sourcesSchema_alias_1 }
+
 declare function SpacedRepetition({ cardId, onRate, labels, className, ...rest }: SpacedRepetitionProps): JSX.Element;
 export { SpacedRepetition }
 export { SpacedRepetition as SpacedRepetition_alias_1 }
@@ -4502,6 +5262,70 @@ declare const tagVariants: (props?: ({
 export { tagVariants }
 export { tagVariants as tagVariants_alias_1 }
 
+/**
+ * Render a multi-step task progress card.
+ * @param props - The task label, steps, and optional duration.
+ * @returns A Collapsible wrapping a step list.
+ */
+declare function Task({ label, steps, durationMs, defaultOpen, className }: TaskProps): JSX.Element;
+export { Task }
+export { Task as Task_alias_1 }
+
+/**
+ * Multi-step task progress for an AI workflow.
+ *
+ * Each step's `state` re-uses the canonical `ToolCallState` enum
+ * (`pending` / `running` / `result` / `error`) so the vocabulary stays
+ * consistent across the AI surface. The header tracks aggregate
+ * progress ("3 of 5 steps", or "Done in X.Xs" once `durationMs` is
+ * set).
+ *
+ * Composes well with `<Reasoning>` for in-step thinking traces and
+ * `<ToolCall>` for individual tool invocations.
+ *
+ * @example
+ * <Task
+ *   label="Refactoring auth"
+ *   steps={[
+ *     { id: "read", label: "Read existing auth", state: "result" },
+ *     { id: "write", label: "Apply changes", state: "running" },
+ *     { id: "test", label: "Run tests", state: "pending" },
+ *   ]}
+ *   durationMs={12_400}
+ * />
+ */
+declare interface TaskProps {
+    /** Optional title shown above the step list. Skipped if absent. */
+    label?: string;
+    /** Ordered list of steps. Each carries an id, label, and state. */
+    steps: TaskStep[];
+    /** Time spent on the task in milliseconds. Renders "Done in X.Xs" when set. */
+    durationMs?: number;
+    /** Whether the step list is expanded by default. */
+    defaultOpen?: boolean;
+    className?: string;
+}
+export { TaskProps }
+export { TaskProps as TaskProps_alias_1 }
+
+declare const taskSchema: ComponentSchemaDefinition;
+export { taskSchema }
+export { taskSchema as taskSchema_alias_1 }
+
+/** A single row in a Task. */
+declare interface TaskStep {
+    /** Stable identifier — used for the React key and any consumer tracking. */
+    id: string;
+    /** Human-readable step label. */
+    label: string;
+    /** Lifecycle status — same vocabulary as `<ToolCall>`'s `state`. */
+    state: ToolCallState_2;
+    /** Optional detail line shown beneath the label. */
+    detail?: string;
+}
+export { TaskStep }
+export { TaskStep as TaskStep_alias_1 }
+
 /**
  * Renders an xterm.js terminal display.
  * @param props - Terminal output + input handler + display options
@@ -4920,6 +5744,19 @@ export { ToolCallState }
 export { ToolCallState as ToolCallState_alias_1 }
 export { ToolCallState as ToolCallState_alias_2 }
 
+/**
+ * Lifecycle of a Task step. Mirrors `@hex-core/components`'
+ * `ToolCallState` exactly — kept inline (rather than imported from
+ * `../types.js`) so the registry CLI distribution path (`npx hex add
+ * task`) ships a self-contained file. ToolCall has the same enum
+ * imported from `../types.js` for backwards-compat with its earlier
+ * shape; new consumers should treat the two unions as one vocabulary.
+ *
+ * KEEP IN SYNC with `../types.js`'s `ToolCallState` enum. Drift is
+ * locked down by an `expectTypeOf` assertion in `task.test.tsx`.
+ */
+declare type ToolCallState_2 = "pending" | "running" | "result" | "error";
+
 /** Root container for a single tooltip. */
 declare const Tooltip: React_2.FC<TooltipPrimitive.TooltipProps>;
 export { Tooltip }