@exegia/corpora-ui 1.0.0 → 3.0.0

package/dist-lib/components/atoms/text/heading.d.ts

@@ -0,0 +1,2 @@
+import { THeadingProps } from './types';
+export declare function Heading({ children, selected, popover, component, componentProps, popoverComponent, popoverProps, renderPopover, onSelectionStart, onSelectionEnd, onPopoverShow, onPopoverHide, offset, zIndex, className, alignment, minSelectionLength, ...textProps }: THeadingProps): import("react").JSX.Element;

package/dist-lib/components/atoms/text/index.d.ts

@@ -0,0 +1,18 @@
+import { Text as TextDefault } from './default';
+import { Heading } from './heading';
+import { Paragraph } from './paragraph';
+import { Span } from './span';
+import { Label } from './label';
+export type { THeadingProps, TParagraphProps, TSpanProps, TTextProps, TTextSize, TTextVariant, } from './types';
+export declare const Text: {
+    /** The polymorphic base the presets below are built on — the only member
+     * that takes `type`, so it is what reaches `link` and `subscript`. The
+     * presets are reachable through the atoms barrel, and without this it
+     * would not be: `export *` does not carry a default export. */
+    Root: typeof TextDefault;
+    Heading: typeof Heading;
+    Paragraph: typeof Paragraph;
+    Span: typeof Span;
+    Label: typeof Label;
+};
+export { TextDefault as default };

package/dist-lib/components/atoms/text/label.d.ts

@@ -0,0 +1,2 @@
+import { TLabelProps } from './types';
+export declare function Label({ children, level, className }: TLabelProps): import("react").JSX.Element;

package/dist-lib/components/atoms/text/paragraph.d.ts

@@ -0,0 +1,2 @@
+import { TParagraphProps } from './types';
+export declare function Paragraph({ children, selected, popover, component, componentProps, popoverComponent, popoverProps, renderPopover, onSelectionStart, onSelectionEnd, onPopoverShow, onPopoverHide, offset, zIndex, alignment, className, minSelectionLength, ...textProps }: TParagraphProps): import("react").JSX.Element;

package/dist-lib/components/atoms/text/span.d.ts

@@ -0,0 +1,2 @@
+import { TSpanProps } from './types';
+export declare function Span(props: TSpanProps): import("react").JSX.Element;

package/dist-lib/components/atoms/text/types.d.ts

@@ -0,0 +1,27 @@
+import { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+import { ITextSelectionProps } from '../text-selection';
+export type TTextVariant = "default" | "heading" | "paragraph" | "link" | "subscript";
+export type TTextSize = "small" | "medium" | "large" | number;
+export type TTextProps = Omit<HTMLAttributes<HTMLElement>, "children" | "style"> & {
+    id?: string;
+    children?: ReactNode;
+    className?: string;
+    /** Named sizes use the type scale; a number is interpreted as pixels. */
+    size?: TTextSize;
+    type?: TTextVariant;
+    href?: string;
+    /** Marks a reader selection. A string is also exposed as data-selection. */
+    selection?: string | boolean;
+    style?: CSSProperties;
+};
+export type THeadingProps = Omit<TTextProps, "type"> & Omit<ITextSelectionProps, "children" | "className">;
+export type TSpanProps = Omit<TTextProps, "type">;
+export type TParagraphProps = Omit<TTextProps, "type"> & Omit<ITextSelectionProps, "children" | "className">;
+export type TLabelLevel = "heading" | "title" | "caption" | "subtitle";
+export type TLabelProps = {
+    children: ReactNode;
+    className?: string;
+    /** Type scale of the label. Defaults to "title". */
+    level?: TLabelLevel;
+    id?: string;
+};

package/dist-lib/components/atoms/text/utils.d.ts

@@ -0,0 +1,4 @@
+import { ClassValue } from 'clsx';
+import { TLabelProps } from './types';
+export declare const twClasses: Record<string, ClassValue>;
+export declare const twLabelClasses: Record<NonNullable<TLabelProps["level"]>, Element["className"]>;

package/dist-lib/components/atoms/text-selection/click-popover.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from 'react';
+import { ITextClickPopoverProps } from './types';
+export declare function TextClickPopover({ children, popover, renderPopover, popoverProps, open: controlledOpen, defaultOpen, onOpenChange, className, ...textProps }: ITextClickPopoverProps): ReactElement;

package/dist-lib/components/atoms/text-selection/index.d.ts

@@ -0,0 +1,6 @@
+export { TextClickPopover } from './click-popover';
+export { HighlightPopover } from './popover';
+export { TextSelection } from './selection';
+export { initialSelectionState, resetSelectionAtom, selectionAtom, setCurrentSelectionAtom, setPopoverPositionAtom, setSelectionAtom, setSelectionPopoverAtom, setSelectionPositionAtom, setShowPopoverAtom, updateSelectionAtom, } from './selection-atom';
+export { useSelection } from './use-selection';
+export type { THighlightPopoverPrimitiveProps, IHighlightPopoverProps, ISelectionPosition, TSelectionPopoverComponent, ISelectionRenderProps, ISelectionState, TSelectionStateUpdate, ITextClickPopoverProps, ITextPopoverRenderProps, ITextSelectionProps, IUseSelectionOptions, IUseSelectionResult, } from './types';

package/dist-lib/components/atoms/text-selection/popover.d.ts

@@ -0,0 +1,3 @@
+import { IHighlightPopoverProps } from './types';
+import type * as React from "react";
+export declare function HighlightPopover({ children, component: Component, componentProps, render, className, ...props }: IHighlightPopoverProps): React.ReactElement;

package/dist-lib/components/atoms/text-selection/selection-atom.d.ts

@@ -0,0 +1,30 @@
+import { ISelectionPosition, ISelectionState, TSelectionStateUpdate } from './types';
+export declare const initialSelectionState: ISelectionState;
+export declare const selectionAtom: import('jotai').PrimitiveAtom<ISelectionState> & {
+    init: ISelectionState;
+};
+/** Update only the fields that changed, keeping selection state atomic. */
+export declare const updateSelectionAtom: import('jotai').WritableAtom<null, [update: TSelectionStateUpdate], void> & {
+    init: null;
+};
+export declare const setSelectionAtom: import('jotai').WritableAtom<null, [selection: string], void> & {
+    init: null;
+};
+export declare const setSelectionPositionAtom: import('jotai').WritableAtom<null, [popoverPosition: ISelectionPosition], void> & {
+    init: null;
+};
+export declare const setSelectionPopoverAtom: import('jotai').WritableAtom<null, [showPopover: boolean], void> & {
+    init: null;
+};
+export declare const setCurrentSelectionAtom: import('jotai').WritableAtom<null, [selection: string], void> & {
+    init: null;
+};
+export declare const setPopoverPositionAtom: import('jotai').WritableAtom<null, [popoverPosition: ISelectionPosition], void> & {
+    init: null;
+};
+export declare const setShowPopoverAtom: import('jotai').WritableAtom<null, [showPopover: boolean], void> & {
+    init: null;
+};
+export declare const resetSelectionAtom: import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+};

package/dist-lib/components/atoms/text-selection/selection.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from 'react';
+import { ITextSelectionProps } from './types';
+export declare function TextSelection({ children, selected, popover, component, componentProps, popoverComponent, popoverProps, renderPopover, onSelectionStart, onSelectionEnd, onPopoverShow, onPopoverHide, ...props }: ITextSelectionProps): ReactElement;

package/dist-lib/components/atoms/text-selection/types.d.ts

@@ -0,0 +1,90 @@
+import { ComponentProps, ComponentType, ElementType, HTMLAttributes, ReactNode } from 'react';
+import { HighlightPopover as HighlightPopoverPrimitive } from '@omsimos/react-highlight-popover';
+import { PopoverPopup } from '../../ui/popover';
+import { TTextProps } from '../text/types';
+export interface ISelectionPosition {
+    top: number;
+    left: number;
+}
+export interface ISelectionState {
+    selected: boolean;
+    currentSelection: string;
+    showPopover: boolean;
+    popoverPosition: ISelectionPosition | null;
+}
+export type TSelectionStateUpdate = Partial<ISelectionState> | ((state: ISelectionState) => Partial<ISelectionState>);
+export interface ISelectionRenderProps {
+    position: ISelectionPosition;
+    selection: string;
+    selected: boolean;
+    showPopover: boolean;
+    setCurrentSelection: (selection: string) => void;
+    setShowPopover: (show: boolean) => void;
+    close: () => void;
+}
+export type TSelectionPopoverComponent = ComponentType<ISelectionRenderProps>;
+export type THighlightPopoverPrimitiveProps = ComponentProps<typeof HighlightPopoverPrimitive>;
+export interface IHighlightPopoverProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    children?: ReactNode;
+    /** Render a component around the popover content. */
+    component?: ElementType;
+    /** Props forwarded to the custom component. */
+    componentProps?: Record<string, unknown>;
+    /** Render function for applications that need full control of the markup. */
+    render?: (props: ISelectionRenderProps) => ReactNode;
+}
+export interface ITextSelectionProps extends Omit<THighlightPopoverPrimitiveProps, "children" | "renderPopover" | "onSelectionStart" | "onSelectionEnd" | "onPopoverShow" | "onPopoverHide"> {
+    children: ReactNode;
+    selected?: boolean;
+    popover?: ReactNode;
+    component?: ElementType;
+    componentProps?: Record<string, unknown>;
+    popoverComponent?: ElementType;
+    popoverProps?: Record<string, unknown>;
+    renderPopover?: (props: ISelectionRenderProps) => ReactNode;
+    onSelectionStart?: () => void;
+    onSelectionEnd?: (selection: string) => void;
+    onPopoverShow?: () => void;
+    onPopoverHide?: () => void;
+}
+export interface ITextPopoverRenderProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    close: () => void;
+}
+export interface ITextClickPopoverProps extends Omit<TTextProps, "popover"> {
+    /** Popover content rendered when the text is clicked. */
+    popover?: ReactNode;
+    /** Render function for applications that need full control of the markup. */
+    renderPopover?: (props: ITextPopoverRenderProps) => ReactNode;
+    /** Props forwarded to the popup (side, align, className, …). */
+    popoverProps?: ComponentProps<typeof PopoverPopup>;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export interface IUseSelectionOptions {
+    selected?: boolean;
+    onSelectionStart?: () => void;
+    onSelectionEnd?: (selection: string) => void;
+    onPopoverShow?: () => void;
+    onPopoverHide?: () => void;
+}
+export interface IUseSelectionResult {
+    state: ISelectionState;
+    selected: boolean;
+    currentSelection: string;
+    showPopover: boolean;
+    popoverPosition: ISelectionState["popoverPosition"];
+    setSelection: (selection: string) => void;
+    setPosition: (position: NonNullable<ISelectionState["popoverPosition"]>) => void;
+    setShowPopover: (show: boolean) => void;
+    update: (update: TSelectionStateUpdate) => void;
+    reset: () => void;
+    selectionProps: {
+        onSelectionStart: () => void;
+        onSelectionEnd: (selection: string) => void;
+        onPopoverShow: () => void;
+        onPopoverHide: () => void;
+    };
+}

package/dist-lib/components/atoms/text-selection/use-selection.d.ts

@@ -0,0 +1,7 @@
+import { IUseSelectionOptions, IUseSelectionResult } from './types';
+/**
+ * Coordinates the third-party highlight popover callbacks with the shared
+ * selection atom. The returned `selectionProps` can be spread directly onto
+ * `@omsimos/react-highlight-popover`.
+ */
+export declare function useSelection(options?: IUseSelectionOptions): IUseSelectionResult;

package/dist-lib/components/atoms/types.d.ts

@@ -0,0 +1,39 @@
+import { TInputProps } from '../ui/input';
+export type TAtomSize = "xs" | "sm" | "default" | "lg" | "xl" | "xxl";
+export type TAtomIconSize = "xs" | "sm" | "default" | "lg" | "xl" | "xxl";
+export type TMacroAtomSize = Exclude<TAtomSize, "xs" | "xl" | "xxl">;
+export type TInputFieldSize = Record<"label" | "input" | "description" | "icon", Record<TMacroAtomSize, string>>;
+export interface IReferenceProps {
+    /** With an href the chip renders as a link, otherwise as a button. */
+    href?: string;
+    target?: React.HTMLAttributeAnchorTarget;
+    rel?: string;
+    id?: string;
+    className?: string;
+    children?: React.ReactNode;
+    "aria-label"?: string;
+    onClick?: React.MouseEventHandler<HTMLElement>;
+    /**
+     * The passage the chip points at, shown in a preview card on hover or
+     * focus. Omitted, the chip is just a link.
+     */
+    preview?: React.ReactNode;
+}
+export interface IInputFieldProps extends Omit<TInputProps, "size"> {
+    label?: string;
+    description?: string;
+    error?: string;
+    size?: TMacroAtomSize;
+    invalid?: boolean;
+}
+export type TLoaderType = "spinner" | "dots";
+export interface ILoaderProps {
+    type?: TLoaderType;
+    className?: string;
+    size?: TAtomSize;
+}
+export type * from './avatar/types';
+export type * from './background/type';
+export type * from './bubble/types';
+export type * from './text/types';
+export type * from './text-selection/types';

package/dist-lib/components/blocks/auth/auth-flow-atom.d.ts

@@ -0,0 +1,76 @@
+import { TAuthStatus, TAuthFlowChannel, TAuthFlowId, IAuthFlowState, TAuthFlowStep, IAuthUser, IBeginAuthVerificationOptions } from './type';
+export declare const DEFAULT_AUTH_FLOW_ID: TAuthFlowId;
+/**
+ * A string-keyed atom family (same in-house shape as `tree-atom.ts`:
+ * `jotai/utils`' `atomFamily` is deprecated for Jotai v3, and we need only
+ * the string-keyed case with a `remove`). Dropping a key lets the store's
+ * WeakMap release that instance's state.
+ */
+type TFamily<AtomType> = ((id: TAuthFlowId) => AtomType) & {
+    remove: (id: TAuthFlowId) => void;
+};
+/**
+ * Mask an identifier for display. Email → first character of the local part
+ * plus `"•••"`, domain intact (`"y•••@example.com"`; a 1-char local part
+ * still gets `"y•••@…"`). Non-email (sms) → `"•••"` + last 4 characters;
+ * fewer than 4 characters masks everything as `"•••"`.
+ */
+export declare function maskAuthIdentifier(identifier: string): string;
+export declare const authFlowStepAtom: TFamily<import('jotai').PrimitiveAtom<TAuthFlowStep> & {
+    init: TAuthFlowStep;
+}>;
+/** An email or phone number in flight — never a password or a code. */
+export declare const authFlowIdentifierAtom: TFamily<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const authFlowChannelAtom: TFamily<import('jotai').PrimitiveAtom<TAuthFlowChannel> & {
+    init: TAuthFlowChannel;
+}>;
+export declare const authFlowStatusAtom: TFamily<import('jotai').PrimitiveAtom<TAuthStatus> & {
+    init: TAuthStatus;
+}>;
+export declare const authFlowErrorAtom: TFamily<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+/** `identifier` masked for display, `null` while nothing is in flight. */
+export declare const authFlowMaskedIdentifierAtom: TFamily<import('jotai').Atom<string | null>>;
+export declare const authFlowStateAtom: TFamily<import('jotai').Atom<IAuthFlowState>>;
+/** Show a step with a clean slate (`"idle"`, no error). Keeps the
+ * identifier so "back to verify" flows don't lose the destination. */
+export declare const goToAuthStepAtom: TFamily<import('jotai').WritableAtom<null, [step: TAuthFlowStep], void> & {
+    init: null;
+}>;
+/** Record the identifier in flight and move to the verification step. */
+export declare const beginAuthVerificationAtom: TFamily<import('jotai').WritableAtom<null, [options: IBeginAuthVerificationOptions], void> & {
+    init: null;
+}>;
+/** Mark the flow `"loading"` while an async attempt is in flight. */
+export declare const beginAuthAttemptAtom: TFamily<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+export declare const failAuthFlowAtom: TFamily<import('jotai').WritableAtom<null, [message: string], void> & {
+    init: null;
+}>;
+/** Mark the flow `"success"` and land on the success step. When `user` is
+ * given, also sign the session in — one atomic write for the whole
+ * "verification passed" transition. */
+export declare const completeAuthFlowAtom: TFamily<import('jotai').WritableAtom<null, [user?: IAuthUser | undefined], void> & {
+    init: null;
+}>;
+/** Back to the initial values (login step, no identifier, `"email"`,
+ * `"idle"`, no error). */
+export declare const resetAuthFlowAtom: TFamily<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/**
+ * Sign out and return the default flow to the login step — the one to wire
+ * to a logout button. `useAuthSessionActions().signOut` is this atom;
+ * `signOutAtom` in `auth-session-atom.ts` clears the session only.
+ */
+export declare const endAuthSessionAtom: import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+};
+/** Drop every atom for `id`. Call on teardown of an explicit flow id; the
+ * default flow usually just gets `resetAuthFlowAtom`. */
+export declare function removeAuthFlowInstance(id: TAuthFlowId): void;
+export {};

package/dist-lib/components/blocks/auth/auth-flow-block.d.ts

@@ -0,0 +1,41 @@
+import { IAuthFlowBlockProps } from './type';
+import * as React from "react";
+/**
+ * Where the flow goes after a step callback resolves. Returned from every
+ * `AuthFlowBlock` handler:
+ *
+ * - `{ user }` — the attempt signed someone in: mark the flow complete AND
+ *   sign the session in (one atomic write, `completeAuthFlowAtom`).
+ * - `{ verify }` — a code went out: record the identifier and move to the
+ *   verification step (`beginAuthVerificationAtom`).
+ * - `{ step }` — plain navigation with a clean slate (`goToAuthStepAtom`).
+ * - `void` — stay put; the block renders its own success state.
+ *
+ * Rejections are NOT handled here — they propagate back into the block,
+ * which owns its transient error/shake state (see `react/CLAUDE.md`,
+ * "Third implementation: auth").
+ */
+/**
+ * Renders the right auth block for the flow's current step with the store
+ * wiring built in — the switchboard every host app was hand-rolling around
+ * `useAuthFlow`. Navigation links between steps (login ↔ signup, forgot
+ * password, back from verification) are pre-wired to `goToStep`; each
+ * submit-shaped prop awaits your handler and applies the returned
+ * {@link TAuthFlowDirective}.
+ *
+ * The blocks themselves stay untouched: passwords, codes and field drafts
+ * live in their local state, and a rejected handler renders as the block's
+ * own error — the orchestrator never mirrors transients into the store.
+ * Needs `ExegiaProvider` above it, like every stateful block.
+ *
+ * ```tsx
+ * <AuthFlowBlock
+ *   onLogin={async ({ email, password }) => {
+ *     const outcome = await api.signIn(email, password)
+ *     return outcome.mfa ? { verify: { identifier: email } } : { user: outcome.user }
+ *   }}
+ *   onVerifyCode={async (code) => ({ user: await api.verify(code) })}
+ * />
+ * ```
+ */
+export declare function AuthFlowBlock({ flowId, logo, accent, providers, onLogin, onSignup, onProviderSelect, onRequestReset, onVerifyCode, onResendCode, onUpdatePassword, onOnboardingComplete, onboardingSteps, steps, renderStep, success, successTitle, successDescription, className, }: IAuthFlowBlockProps): React.ReactElement;

package/dist-lib/components/blocks/auth/auth-session-atom.d.ts

@@ -0,0 +1,28 @@
+import { IAuthSessionState, TAuthSessionStatus, IAuthUser } from './type';
+/** `"unknown"` until the app restores or rejects a session at boot. */
+export declare const authSessionStatusAtom: import('jotai').PrimitiveAtom<TAuthSessionStatus> & {
+    init: TAuthSessionStatus;
+};
+export declare const authUserAtom: import('jotai').PrimitiveAtom<IAuthUser | null> & {
+    init: IAuthUser | null;
+};
+export declare const isAuthenticatedAtom: import('jotai').Atom<boolean>;
+export declare const authSessionStateAtom: import('jotai').Atom<IAuthSessionState>;
+export declare const signInAtom: import('jotai').WritableAtom<null, [user: IAuthUser], void> & {
+    init: null;
+};
+export declare const updateAuthUserAtom: import('jotai').WritableAtom<null, [patch: Partial<IAuthUser>], void> & {
+    init: null;
+};
+/** What an app calls at boot when session restore fails. */
+export declare const markUnauthenticatedAtom: import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+};
+/**
+ * Clears the session only. Most consumers want `endAuthSessionAtom` from
+ * `auth-flow-atom.ts` instead, which also returns the default flow to the
+ * login step — the hooks expose that one as `signOut`.
+ */
+export declare const signOutAtom: import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+};

package/dist-lib/components/blocks/auth/auth-shell.d.ts

@@ -0,0 +1,55 @@
+import { TAuthAccent } from '../../../lib/auth-accent';
+import * as React from "react";
+/** transitions.dev motion scale, shared by all auth blocks. */
+export declare const EASE: readonly [0.22, 1, 0.36, 1];
+/**
+ * Frame shell shared by the auth blocks (coss particle p-card-8): a raised
+ * Card inside a muted Frame, with the footer in the frame strip below the
+ * card. Wraps content in a MotionConfig that honors prefers-reduced-motion
+ * and layout-animates height changes so step swaps morph instead of jumping.
+ */
+export declare function AuthCard({ title, description, children, footer, className, logo, accent, }: {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+    className?: string;
+    /** Brand mark rendered above the title. Omit for no logo row at all. */
+    logo?: React.ReactNode;
+    /** Brand accent for the card's primary action. Omit to keep `bg-primary`. */
+    accent?: TAuthAccent;
+}): React.JSX.Element;
+/** Cross-morphs between steps (form → success, …) keyed by `step`. */
+export declare function MorphStep({ step, children, className, }: {
+    step: string;
+    children: React.ReactNode;
+    className?: string;
+}): React.JSX.Element;
+/**
+ * Progressive-disclosure wrapper: collapses/expands a step as `show` flips.
+ *
+ * `overflow-hidden` is only worn while the height is in flight — leaving it on
+ * would clip the focus ring of any full-width control inside (the ring sits
+ * 3px outside the input's border box, so the left/right edges would be cut).
+ */
+export declare function Reveal({ show, children, className, }: {
+    show: boolean;
+    children: React.ReactNode;
+    className?: string;
+}): React.JSX.Element;
+/** Inline error message that shakes each time `message` changes. */
+export declare function AuthError({ message }: {
+    message: string | null;
+}): React.JSX.Element;
+/** Success panel with a stroke-drawn check. */
+export declare function AuthSuccess({ title, description, children, }: {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    children?: React.ReactNode;
+}): React.JSX.Element;
+/** "Or continue with" style divider. */
+export declare function AuthSeparator({ label }: {
+    label?: string;
+}): React.JSX.Element;
+/** Countdown for resend links; restarts when `restartKey` changes. */
+export declare function useCountdown(seconds: number, restartKey: number): number;

package/dist-lib/components/blocks/auth/auth-state.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Public barrel for the auth coordination state. Explicit named exports
+ * only — never `export *` from the atom modules, so internals can move
+ * without becoming a breaking-change surface.
+ */
+export { DEFAULT_AUTH_FLOW_ID, authFlowChannelAtom, authFlowErrorAtom, authFlowIdentifierAtom, authFlowMaskedIdentifierAtom, authFlowStateAtom, authFlowStatusAtom, authFlowStepAtom, beginAuthAttemptAtom, beginAuthVerificationAtom, completeAuthFlowAtom, endAuthSessionAtom, failAuthFlowAtom, goToAuthStepAtom, maskAuthIdentifier, removeAuthFlowInstance, resetAuthFlowAtom, } from './auth-flow-atom';
+export { authSessionStateAtom, authSessionStatusAtom, authUserAtom, isAuthenticatedAtom, markUnauthenticatedAtom, signInAtom, signOutAtom, updateAuthUserAtom, } from './auth-session-atom';
+export { useAuthFlow, useAuthFlowActions, useAuthSession, useAuthSessionActions, } from './use-auth-state';

package/dist-lib/components/blocks/auth/code-auth-block.d.ts

@@ -0,0 +1,3 @@
+import { ICodeAuthBlockProps } from './type';
+import * as React from "react";
+export declare function CodeAuthBlock({ channel, logo, accent, destination, length, autoSubmit, resendSeconds, onVerify, onResend, onBack, }: ICodeAuthBlockProps): React.JSX.Element;

package/dist-lib/components/blocks/auth/forgot-password-block.d.ts

@@ -0,0 +1,3 @@
+import { IForgotPasswordBlockProps } from './type';
+import * as React from "react";
+export declare function ForgotPasswordBlock({ title, logo, accent, description, onSubmit, onBackToLogin, }: IForgotPasswordBlockProps): React.JSX.Element;

package/dist-lib/components/blocks/auth/linked-accounts-block.d.ts

@@ -0,0 +1,9 @@
+import { ILinkedAccountsBlockProps } from './type';
+import * as React from "react";
+/**
+ * Settings panel for the sign-in identities attached to an account: lists the
+ * connected ones, offers connect buttons for the rest, and guards the last
+ * remaining method from being disconnected — the guard is a disabled button
+ * plus an explanation rather than an error after the fact.
+ */
+export declare function LinkedAccountsBlock({ title, description, identities, providers, loading, hasOtherSignInMethods, onLink, onUnlink, className, }: ILinkedAccountsBlockProps): React.JSX.Element;

package/dist-lib/components/blocks/auth/login-block.d.ts

@@ -0,0 +1,3 @@
+import { ILoginBlockProps } from './type';
+import * as React from "react";
+export declare function LoginBlock({ title, description, logo, accent, providers, showRememberMe, showForgotPassword, onSubmit, onProviderSelect, onForgotPassword, onSignup, }: ILoginBlockProps): React.JSX.Element;

package/dist-lib/components/blocks/auth/onboarding/profile-step.d.ts

@@ -0,0 +1,8 @@
+import { IProfileStepProps } from '../type';
+import * as React from "react";
+/**
+ * Renders one declared profile step: `OnboardingFieldConfig[]` → labeled
+ * controls, validated locally before anything is handed to `onSubmit`. Mounted
+ * keyed by `step.id` so drafts re-seed per step.
+ */
+export declare function ProfileStep({ step, values, submitting, submitLabel, onSubmit, onBack, onDraftChange, }: IProfileStepProps): React.JSX.Element;

package/dist-lib/components/blocks/auth/onboarding-block.d.ts

@@ -0,0 +1,15 @@
+import { IOnboardingBlockProps, IOnboardingStepConfig } from './type';
+import * as React from "react";
+/** Default configuration: a single required display-name step. */
+export declare const DEFAULT_ONBOARDING_STEPS: IOnboardingStepConfig[];
+/**
+ * Multi-step profile onboarding: a declared `steps` config renders as
+ * progress-tracked forms with back/forward navigation, per-step submission and
+ * a single completion signal. Drafts survive back-navigation, and the step
+ * heading takes focus on advance so a screen reader announces where the flow
+ * moved.
+ *
+ * Account creation and email confirmation are separate blocks (`SignupBlock`,
+ * `CodeAuthBlock`) — this one picks up once the account exists.
+ */
+export declare function OnboardingBlock({ steps, logo, accent, onStepSubmit, onComplete, showCompleteScreen, autoFocus, className, }: IOnboardingBlockProps): React.JSX.Element | null;

package/dist-lib/components/blocks/auth/passkey-manager-block.d.ts

@@ -0,0 +1,10 @@
+import { IPasskeyManagerBlockProps } from './type';
+import * as React from "react";
+/**
+ * Settings panel for the passkeys on an account: register, inline rename with
+ * field-level validation, and delete behind an explicit confirmation. Deleting
+ * the last passkey is allowed — it is the account's passkey method that goes
+ * away, not its only way in — so the confirmation carries a warning instead of
+ * a block.
+ */
+export declare function PasskeyManagerBlock({ title, description, passkeys, available, loading, onRegister, onRename, onDelete, className, }: IPasskeyManagerBlockProps): React.JSX.Element;

package/dist-lib/components/blocks/auth/passkey-sign-in-block.d.ts

@@ -0,0 +1,8 @@
+import { IPasskeySignInBlockProps } from './type';
+import * as React from "react";
+/**
+ * Passkey sign-in entry point — a single button plus its error state, sized
+ * to drop into a login card next to the password form rather than to stand on
+ * its own. Renders `null` while passkeys are unavailable.
+ */
+export declare function PasskeySignInBlock({ available, label, onSignIn, fallbackHint, className, }: IPasskeySignInBlockProps): React.JSX.Element | null;

package/dist-lib/components/blocks/auth/signup-block.d.ts

@@ -0,0 +1,3 @@
+import { ISignupBlockProps } from './type';
+import * as React from "react";
+export declare function SignupBlock({ title, description, logo, accent, providers, showNameField, showTerms, termsChecked, defaultTermsChecked, onTermsCheckedChange, enforceStrongPassword, onSubmit, termsComponent, onProviderSelect, onLogin, onTerms, }: ISignupBlockProps): React.JSX.Element;