@exegia/corpora-ui 0.22.0 → 0.23.0

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,123 @@
+import { SocialProvider } from '../../composed/social-providers';
+import { AuthAccent } from '../../../lib/auth-accent';
+import { CodeAuthBlockProps } from './code-auth-block';
+import { ForgotPasswordBlockProps } from './forgot-password-block';
+import { LoginBlockProps } from './login-block';
+import { OnboardingBlockProps, OnboardingStepConfig, OnboardingValue } from './onboarding-block';
+import { SignupBlockProps } from './signup-block';
+import { UpdatePasswordBlockProps } from './update-password-block';
+import { AuthFlowId, AuthFlowState, AuthFlowStep, AuthUser, BeginAuthVerificationOptions } from './auth-state-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").
+ */
+export type AuthFlowDirective = {
+    user: AuthUser;
+} | {
+    verify: BeginAuthVerificationOptions;
+} | {
+    step: AuthFlowStep;
+} | void;
+export type AuthFlowHandler<Data = void> = (data: Data) => Promise<AuthFlowDirective> | AuthFlowDirective;
+/** Per-step prop overrides, merged over the orchestrator's wiring — spread
+ * last, so an app can restyle a block or unhook a default navigation link
+ * (`{ login: { onSignup: undefined } }` removes the sign-up hand-off). */
+export interface AuthFlowStepOverrides {
+    login?: Partial<LoginBlockProps>;
+    signup?: Partial<SignupBlockProps>;
+    "verify-code"?: Partial<CodeAuthBlockProps>;
+    "forgot-password"?: Partial<ForgotPasswordBlockProps>;
+    "update-password"?: Partial<UpdatePasswordBlockProps>;
+    onboarding?: Partial<OnboardingBlockProps>;
+}
+export interface AuthFlowBlockProps {
+    /** Which flow instance to orchestrate. The default flow unless a re-auth
+     * modal or a second surface needs its own. */
+    flowId?: AuthFlowId;
+    /** Brand mark handed to every step's card. */
+    logo?: React.ReactNode;
+    /** Brand accent handed to every step's card. */
+    accent?: AuthAccent;
+    /** Social providers offered on the login and signup steps. */
+    providers?: SocialProvider[];
+    /** The login attempt. Resolve with a directive; reject to show the error
+     * in the block. */
+    onLogin?: AuthFlowHandler<{
+        email: string;
+        password: string;
+        remember: boolean;
+    }>;
+    /** The signup attempt. */
+    onSignup?: AuthFlowHandler<{
+        name: string;
+        email: string;
+        password: string;
+    }>;
+    /** A social provider chosen on the login or signup step. */
+    onProviderSelect?: AuthFlowHandler<SocialProvider>;
+    /** The forgot-password request. Resolving without a directive stays on the
+     * step (the block shows its own "link sent" state). */
+    onRequestReset?: AuthFlowHandler<{
+        email: string;
+    }>;
+    /** The code entered on the verification step. */
+    onVerifyCode?: AuthFlowHandler<string>;
+    /** "Resend code" on the verification step. */
+    onResendCode?: AuthFlowHandler;
+    /** The update-password submit. */
+    onUpdatePassword?: AuthFlowHandler<{
+        password: string;
+    }>;
+    /** Onboarding finished, with the merged profile. */
+    onOnboardingComplete?: AuthFlowHandler<Record<string, OnboardingValue>>;
+    /** Declared onboarding steps, handed to `OnboardingBlock`. */
+    onboardingSteps?: OnboardingStepConfig[];
+    /** Per-step prop overrides, merged over the orchestrator's wiring. */
+    steps?: AuthFlowStepOverrides;
+    /** Replace any step's UI entirely; return `undefined` to keep the default
+     * for that step. Receives the flow state for destination copy etc. */
+    renderStep?: (step: AuthFlowStep, flow: AuthFlowState) => React.ReactNode | undefined;
+    /** Replaces the whole default success card. */
+    success?: React.ReactNode;
+    /** Card title of the default success step. */
+    successTitle?: string;
+    /** Body under the default success step's "You're signed in" check. */
+    successDescription?: string;
+    className?: string;
+}
+/**
+ * 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 AuthFlowDirective}.
+ *
+ * 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, }: AuthFlowBlockProps): React.ReactElement;

package/dist-lib/components/blocks/scaffold/__tests__/scaffold-atom.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-lib/components/blocks/scaffold/index.d.ts

@@ -11,6 +11,8 @@ import { ScaffoldTab } from './scaffold-tab';
 import { ScaffoldSubPanel } from './scaffold-sub-panel.tsx';
 export { useScaffoldContext } from './scaffold-context';
 export { useScaffold } from './use-scaffold';
+export { useScaffoldActions, useScaffoldState } from './use-scaffold-state';
+export { removeScaffoldInstance, resetScaffoldAtom, scaffoldHiddenPanelIdsAtom, scaffoldHoveredPanelIdAtom, scaffoldInspectorOpenAtom, scaffoldPanelCapacityAtom, scaffoldPanelDimmedAtom, scaffoldPanelHiddenAtom, scaffoldStateAtom, setScaffoldInspectorOpenAtom, toggleScaffoldInspectorAtom, toggleScaffoldPanelAtom, } from './scaffold-atom';
 export type * from './type';
 export * from './constants';
 export { PanelCloseButton, PanelMenuButton, ScaffoldActions, ScaffoldCanvas, ScaffoldInspector, ScaffoldMain, ScaffoldPanel, ScaffoldRoot, ScaffoldSidebar, ScaffoldTab, };

package/dist-lib/components/blocks/scaffold/scaffold-atom.d.ts

@@ -0,0 +1,97 @@
+import { Atom } from 'jotai';
+import { ScaffoldConfig, ScaffoldHandlers, ScaffoldInstanceId, ScaffoldPanelVisibility, ScaffoldState } from './type';
+type Family<AtomType> = ((id: ScaffoldInstanceId) => AtomType) & {
+    remove: (id: ScaffoldInstanceId) => void;
+};
+export declare const scaffoldInspectorOpenAtom: Family<import('jotai').PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+/** @internal The canvas's ordered panel ids, as registered each render. */
+export declare const scaffoldPanelIdsAtom: Family<import('jotai').PrimitiveAtom<readonly string[]> & {
+    init: readonly string[];
+}>;
+/** @internal The capacity derived from the canvas's measured width — the
+ * derived number is stored, not the raw width, so resize storms only touch
+ * the store when a panel actually gains or loses room. */
+export declare const scaffoldMeasuredCapacityAtom: Family<import('jotai').PrimitiveAtom<number | null> & {
+    init: number | null;
+}>;
+/** @internal The three visibility lists, settled as one value. */
+export declare const scaffoldVisibilityAtom: Family<import('jotai').PrimitiveAtom<ScaffoldPanelVisibility> & {
+    init: ScaffoldPanelVisibility;
+}>;
+export declare const scaffoldHoveredPanelIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+/** @internal */
+export declare const scaffoldConfigAtom: Family<import('jotai').PrimitiveAtom<ScaffoldConfig> & {
+    init: ScaffoldConfig;
+}>;
+/** @internal */
+export declare const scaffoldHandlersAtom: Family<import('jotai').PrimitiveAtom<ScaffoldHandlers> & {
+    init: ScaffoldHandlers;
+}>;
+/** How many panels fit side by side; the cap while the canvas is unmeasured. */
+export declare const scaffoldPanelCapacityAtom: Family<Atom<number>>;
+/** Ids of panels currently hidden (auto + user), for tabs to reflect. */
+export declare const scaffoldHiddenPanelIdsAtom: Family<Atom<readonly string[]>>;
+/** Whether one panel is hidden. A tab subscribes here and sits still while
+ * its siblings toggle. Empty `panelId` (a tab without one) reads false. */
+export declare const scaffoldPanelHiddenAtom: (id: ScaffoldInstanceId, panelId: string) => Atom<boolean>;
+/** Whether one panel fades back while another panel's tab holds the
+ * spotlight. Moving the hover between two tabs re-renders those panels
+ * only — everyone else's boolean holds. */
+export declare const scaffoldPanelDimmedAtom: (id: ScaffoldInstanceId, panelId: string) => Atom<boolean>;
+/** The whole state of one scaffold. This changes on every hover move, so a
+ * component that reads one field should subscribe to that field's atom
+ * instead: `useAtomValue(scaffoldInspectorOpenAtom("workspace"))`. */
+export declare const scaffoldStateAtom: Family<Atom<ScaffoldState>>;
+/** Reports through `onInspectorOpenChange` always; writes the store only
+ * when no `inspectorOpen` prop controls the root — the prop is truth then. */
+export declare const setScaffoldInspectorOpenAtom: Family<import('jotai').WritableAtom<null, [open: boolean], void> & {
+    init: null;
+}>;
+export declare const toggleScaffoldInspectorAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Show/hide an id'd panel. Showing past capacity auto-hides the
+ * least-recently-activated visible panel; the last visible one never hides. */
+export declare const toggleScaffoldPanelAtom: Family<import('jotai').WritableAtom<null, [panelId: string], void> & {
+    init: null;
+}>;
+/** @internal Tabs report pointer enter/leave on their label. Leaving clears
+ * only its own id — a tab that unmounts mid-hover must not wipe out a hover
+ * the pointer has already moved on to. */
+export declare const setScaffoldPanelHoveredAtom: Family<import('jotai').WritableAtom<null, [panelId: string, hovered: boolean], void> & {
+    init: null;
+}>;
+/** @internal Canvas reports its ordered panel ids each render. Inert when
+ * the ids did not move; otherwise the visibility settles in the same write. */
+export declare const registerScaffoldPanelIdsAtom: Family<import('jotai').WritableAtom<null, [ids: readonly string[]], void> & {
+    init: null;
+}>;
+/** @internal Canvas reports its measured width. Only the derived capacity is
+ * stored, so resize storms settle to at most one visibility change. */
+export declare const measureScaffoldCanvasAtom: Family<import('jotai').WritableAtom<null, [width: number], void> & {
+    init: null;
+}>;
+/** @internal Projection of the mounted root's controlled props. */
+export declare const projectScaffoldPropsAtom: Family<import('jotai').WritableAtom<null, [config: ScaffoldConfig, inspectorOpen: boolean | undefined], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const setScaffoldHandlersAtom: Family<import('jotai').WritableAtom<null, [handlers: ScaffoldHandlers], void> & {
+    init: null;
+}>;
+/** @internal Seed the uncontrolled inspector on mount without firing
+ * `onInspectorOpenChange`. */
+export declare const seedScaffoldInspectorAtom: Family<import('jotai').WritableAtom<null, [open: boolean], void> & {
+    init: null;
+}>;
+export declare const resetScaffoldAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Forget a scaffold entirely — every family drops the key so the store can
+ * release its state. Call on teardown of a named instance. */
+export declare function removeScaffoldInstance(id: ScaffoldInstanceId): void;
+export {};

package/dist-lib/components/blocks/scaffold/scaffold-context.d.ts

@@ -1,5 +1,7 @@
 import { ScaffoldContextValue } from './type';
 import * as React from "react";
 export declare const ScaffoldContext: React.Context<ScaffoldContextValue | null>;
-/** Read the scaffold's shared state; must run under `Scaffold.Root`. */
+/** Read the scaffold's identity (`scaffoldId`, `inspectorWidth`); must run
+ * under `Scaffold.Root`. State itself lives in the store — subscribe to the
+ * atoms, or reach them by id through `useScaffoldState` / `useScaffoldActions`. */
 export declare function useScaffoldContext(): ScaffoldContextValue;

package/dist-lib/components/blocks/scaffold/scaffold-root.d.ts

@@ -2,7 +2,16 @@ import { ScaffoldRootProps } from './type';
 import * as React from "react";
 /**
  * The scaffold's viewport: desktop backdrop + horizontal row of rail and
- * main region, and the provider for the shared inspector state. Fills its
- * container — size it from the outside (e.g. `h-svh` for a full page).
+ * main region, and the binding between this instance's props and its slice
+ * of the store. Fills its container — size it from the outside (e.g.
+ * `h-svh` for a full page).
+ *
+ * State lives in the store under `scaffoldId`; the context carries only the
+ * id and the drawer width, so its value never changes while the scaffold is
+ * mounted and parts subscribe to exactly the atoms they render from. A
+ * controlled `inspectorOpen` stays the source of truth: it is projected
+ * one-way into the store (so remote readers see current data), and the
+ * inspector actions report through `onInspectorOpenChange` instead of
+ * writing.
  */
-export declare function ScaffoldRoot({ inspectorOpen: inspectorOpenProp, defaultInspectorOpen, onInspectorOpenChange, inspectorWidth, className, children, ...rest }: ScaffoldRootProps): React.ReactElement;
+export declare function ScaffoldRoot({ scaffoldId: scaffoldIdProp, inspectorOpen: inspectorOpenProp, defaultInspectorOpen, onInspectorOpenChange, inspectorWidth, className, children, ...rest }: ScaffoldRootProps): React.ReactElement;

package/dist-lib/components/blocks/scaffold/type.d.ts

@@ -1,35 +1,69 @@
 import { default as React, ComponentProps, ReactElement, ReactNode } from 'react';
-/** Inspector state shared by every scaffold part through ScaffoldContext. */
+/** Key of one scaffold's slice of the store. */
+export type ScaffoldInstanceId = string;
+/** The identity every scaffold part shares through ScaffoldContext. State
+ * itself lives in the store — parts subscribe to the atoms they render from,
+ * so this value never changes identity while the scaffold is mounted. */
 export interface ScaffoldContextValue {
-    /** Whether the inspector drawer is currently shown. */
-    inspectorOpen: boolean;
+    scaffoldId: ScaffoldInstanceId;
     /** Drawer width in px — Actions reads it to slide out of the drawer's way. */
     inspectorWidth: number;
-    setInspectorOpen: (open: boolean) => void;
-    toggleInspector: () => void;
+}
+/** One scaffold's whole state, as `useScaffoldState` returns it. A component
+ * that watches one field should subscribe to that field's atom instead. */
+export interface ScaffoldState {
+    /** Whether the inspector drawer is currently shown. */
+    inspectorOpen: boolean;
     /** How many panels currently fit side by side, from the measured canvas
      * width at `SCAFFOLD_PANEL_MIN_WIDTH` per panel (1..`SCAFFOLD_PANEL_CAPACITY`). */
     panelCapacity: number;
     /** Ids of id'd panels the scaffold is currently hiding — auto-hidden by
      * capacity pressure or toggled away from a tab. */
     hiddenPanelIds: readonly string[];
-    isPanelHidden: (id: string) => boolean;
-    /** Show/hide an id'd panel. Showing past capacity auto-hides the
-     * least-recently-activated visible panel; the last visible one never hides. */
-    togglePanelVisibility: (id: string) => void;
     /** Id of the panel whose tab the pointer is resting on — the canvas
      * spotlights it by fading every other id'd panel to 0.35 opacity. */
     hoveredPanelId: string | null;
-    /** @internal Tabs report pointer enter/leave on their label. */
-    setPanelHovered: (id: string, hovered: boolean) => void;
-    /** @internal Canvas reports its ordered panel ids. */
-    registerPanelIds: (ids: readonly string[]) => void;
-    /** @internal Canvas reports its measured width. */
-    setCanvasWidth: (width: number) => void;
+}
+/** Drive a scaffold by id from anywhere, as `useScaffoldActions` returns it. */
+export interface ScaffoldStateActions {
+    setInspectorOpen: (open: boolean) => void;
+    toggleInspector: () => void;
+    /** Show/hide an id'd panel. Showing past capacity auto-hides the
+     * least-recently-activated visible panel; the last visible one never hides. */
+    togglePanel: (panelId: string) => void;
+    reset: () => void;
+}
+/** @internal Which props currently control the scaffold — write gates for
+ * the action atoms, so the store never overwrites a prop. */
+export interface ScaffoldConfig {
+    controlsInspector: boolean;
+}
+/** @internal The mounted root's callbacks, published into the store so
+ * action atoms can report changes wherever they were fired from. */
+export interface ScaffoldHandlers {
+    onInspectorOpenChange?: (open: boolean) => void;
+}
+/** @internal Bookkeeping for responsive panel hiding.
+ * - `visibleOrder`: visible panel ids, least-recently-activated first — the
+ *   front is what capacity pressure evicts next.
+ * - `autoHidden`: panels the scaffold hid because the canvas shrank, most
+ *   recent last. They return on their own when room comes back.
+ * - `userHidden`: panels hidden by a tab press. They stay hidden until the
+ *   tab is pressed again, however wide the canvas grows. */
+export interface ScaffoldPanelVisibility {
+    visibleOrder: string[];
+    autoHidden: string[];
+    userHidden: string[];
 }
 export interface ScaffoldRootProps extends ComponentProps<"div"> {
-    /** Controlled inspector state — pair with `onInspectorOpenChange`, or
-     * spread `useScaffold().providerProps` instead of wiring by hand. */
+    /** Names this scaffold's slice of the store, so `useScaffoldState` /
+     * `useScaffoldActions` can drive it by id and its state outlives the
+     * component. Omitted, the root keys off `useId` and drops its state on
+     * unmount. `useScaffold().providerProps` carries one. */
+    scaffoldId?: ScaffoldInstanceId;
+    /** Controlled inspector state — pair with `onInspectorOpenChange`. The
+     * prop stays the source of truth: store writes are gated off, and actions
+     * report through the callback instead. */
     inspectorOpen?: boolean;
     /** Initial inspector state when uncontrolled. Closed by default. */
     defaultInspectorOpen?: boolean;
@@ -148,16 +182,22 @@ export interface PanelMenuButtonProps extends PanelFloatingButtonProps {
     swapped?: boolean;
 }
 export interface UseScaffoldOptions {
+    /** Names the scaffold's slice of the store. Omitted, the hook generates
+     * one and drops its state on unmount. */
+    scaffoldId?: ScaffoldInstanceId;
     /** Initial inspector state. Closed by default. */
     defaultInspectorOpen?: boolean;
     /** Fires on every inspector open/close. */
     onInspectorChange?: (open: boolean) => void;
 }
 export interface ScaffoldControls {
+    /** The id the hook and the root share — hand it to `useScaffoldState` /
+     * `useScaffoldActions` to drive the scaffold from elsewhere. */
+    scaffoldId: ScaffoldInstanceId;
     inspectorOpen: boolean;
     setInspectorOpen: (open: boolean) => void;
     toggleInspector: () => void;
     /** Spread onto Scaffold.Root. */
-    providerProps: Pick<ScaffoldRootProps, "inspectorOpen" | "onInspectorOpenChange">;
+    providerProps: Pick<ScaffoldRootProps, "scaffoldId" | "defaultInspectorOpen" | "onInspectorOpenChange">;
 }
 export {};

package/dist-lib/components/blocks/scaffold/use-scaffold-state.d.ts

@@ -0,0 +1,26 @@
+import { ScaffoldInstanceId, ScaffoldState, ScaffoldStateActions } from './type';
+/**
+ * Read the scaffold registered under `scaffoldId` from anywhere below
+ * `ExegiaProvider` — no controller, no props, no provider of its own.
+ *
+ * ```tsx
+ * const { inspectorOpen, hiddenPanelIds } = useScaffoldState("workspace")
+ * ```
+ *
+ * This returns the whole state object, so the caller re-renders on every
+ * change, hovers included. A component that reads one field should subscribe
+ * to that field's atom instead:
+ * `useAtomValue(scaffoldInspectorOpenAtom("workspace"))`.
+ */
+export declare function useScaffoldState(scaffoldId: ScaffoldInstanceId): ScaffoldState;
+/**
+ * Drive the scaffold registered under `scaffoldId` from anywhere. Writes
+ * only — the caller never re-renders when the scaffold changes, so this is
+ * what a command palette or a keyboard shortcut should reach for.
+ *
+ * ```tsx
+ * const scaffold = useScaffoldActions("workspace")
+ * <Button onClick={scaffold.toggleInspector}>Inspect</Button>
+ * ```
+ */
+export declare function useScaffoldActions(scaffoldId: ScaffoldInstanceId): ScaffoldStateActions;

package/dist-lib/components/blocks/scaffold/use-scaffold.d.ts

@@ -4,5 +4,11 @@ import { ScaffoldControls, UseScaffoldOptions } from './type';
  * (title-bar buttons, command palette, shortcuts). Spread the returned
  * `providerProps` onto `Scaffold.Root`; without this hook the root manages
  * the same state internally via `defaultInspectorOpen`.
+ *
+ * The hook and the root meet in the store: `providerProps` carries a
+ * `scaffoldId`, both sides read and write that instance's atoms, and
+ * `useScaffoldState` / `useScaffoldActions` reach the same slice from
+ * anywhere else by id. Unnamed scaffolds key off `useId` and are dropped on
+ * unmount; an explicit `scaffoldId` outlives its component.
  */
-export declare function useScaffold({ defaultInspectorOpen, onInspectorChange, }?: UseScaffoldOptions): ScaffoldControls;
+export declare function useScaffold({ scaffoldId: scaffoldIdProp, defaultInspectorOpen, onInspectorChange, }?: UseScaffoldOptions): ScaffoldControls;

package/dist-lib/components/blocks/scaffold/utils.d.ts

@@ -1,12 +1,22 @@
 import { Variants } from 'motion/react';
 import { ClassNameValue } from 'tailwind-merge';
-import { TSubPanelVariant } from './type.ts';
+import { ScaffoldPanelVisibility, TSubPanelVariant } from './type.ts';
 /**
  * How many panels fit on a canvas of `width` px, granting each
  * `SCAFFOLD_PANEL_MIN_WIDTH` plus the gaps between them. Clamped to
  * [1, SCAFFOLD_PANEL_CAPACITY]; an unmeasured canvas (`null`) fits the cap.
  */
 export declare function getPanelCapacity(width: number | null): number;
+/** @internal An untracked scaffold: nothing registered, nothing hidden. */
+export declare const EMPTY_SCAFFOLD_VISIBILITY: ScaffoldPanelVisibility;
+/**
+ * @internal Fold the registered ids and current capacity into a settled
+ * visibility: prune departed panels, admit new ones, evict the
+ * least-recently-activated visible panels past capacity, and restore
+ * auto-hidden ones when room returns. Returns `prev` untouched when nothing
+ * changes, so callers can compare identities instead of contents.
+ */
+export declare function reconcileVisibility(prev: ScaffoldPanelVisibility, ids: readonly string[], capacity: number): ScaffoldPanelVisibility;
 /** Desktop backdrop the whole scaffold sits on — a soft warm-gray wash. */
 export declare const scaffoldBackgroundClass: ClassNameValue;
 /** Card surface shared by a panel's primary area and secondary strip. */

package/dist-lib/components/ui/switch.d.ts

@@ -0,0 +1,4 @@
+import { Switch as SwitchPrimitive } from '@base-ui/react/switch';
+import { default as React } from 'react';
+export declare function Switch({ className, ...props }: SwitchPrimitive.Root.Props): React.ReactElement;
+export { SwitchPrimitive };

package/dist-lib/index.d.ts

@@ -27,6 +27,7 @@ export * from './components/composed/tree';
 export { DEFAULT_BEZEL_ANGLE, PresenceBadge, UserAvatar, initialsFrom, removeUserAvatarInstance, resetUserAvatarAtom, setUserAvatarBezelAngleAtom, setUserAvatarPresenceAtom, toggleUserAvatarPresenceAtom, useUserAvatar, useUserAvatarActions, useUserAvatarState, userAvatarBezelAngleAtom, userAvatarIsOnlineAtom, userAvatarPresenceAtom, userAvatarStateAtom, } from './components/user-avatar';
 export type { UseUserAvatarOptions, UserAvatarActions, UserAvatarBinding, UserAvatarInstanceId, UserAvatarProps, UserAvatarState, UserPresence, } from './components/user-avatar';
 export * from './components/blocks/auth/auth-shell';
+export * from './components/blocks/auth/auth-flow-block';
 export * from './components/blocks/auth/auth-state';
 export * from './components/blocks/auth/code-auth-block';
 export * from './components/blocks/auth/forgot-password-block';