@exegia/corpora-ui 0.20.0 → 0.22.0

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

@@ -0,0 +1,77 @@
+import { AuthStatus } from './auth-shell';
+import { AuthFlowChannel, AuthFlowId, AuthFlowState, AuthFlowStep, AuthUser, BeginAuthVerificationOptions } from './auth-state-type';
+export declare const DEFAULT_AUTH_FLOW_ID: AuthFlowId;
+/**
+ * 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 Family<AtomType> = ((id: AuthFlowId) => AtomType) & {
+    remove: (id: AuthFlowId) => 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: Family<import('jotai').PrimitiveAtom<AuthFlowStep> & {
+    init: AuthFlowStep;
+}>;
+/** An email or phone number in flight — never a password or a code. */
+export declare const authFlowIdentifierAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const authFlowChannelAtom: Family<import('jotai').PrimitiveAtom<AuthFlowChannel> & {
+    init: AuthFlowChannel;
+}>;
+export declare const authFlowStatusAtom: Family<import('jotai').PrimitiveAtom<AuthStatus> & {
+    init: AuthStatus;
+}>;
+export declare const authFlowErrorAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+/** `identifier` masked for display, `null` while nothing is in flight. */
+export declare const authFlowMaskedIdentifierAtom: Family<import('jotai').Atom<string | null>>;
+export declare const authFlowStateAtom: Family<import('jotai').Atom<AuthFlowState>>;
+/** 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: Family<import('jotai').WritableAtom<null, [step: AuthFlowStep], void> & {
+    init: null;
+}>;
+/** Record the identifier in flight and move to the verification step. */
+export declare const beginAuthVerificationAtom: Family<import('jotai').WritableAtom<null, [options: BeginAuthVerificationOptions], void> & {
+    init: null;
+}>;
+/** Mark the flow `"loading"` while an async attempt is in flight. */
+export declare const beginAuthAttemptAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+export declare const failAuthFlowAtom: Family<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: Family<import('jotai').WritableAtom<null, [user?: AuthUser | undefined], void> & {
+    init: null;
+}>;
+/** Back to the initial values (login step, no identifier, `"email"`,
+ * `"idle"`, no error). */
+export declare const resetAuthFlowAtom: Family<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: AuthFlowId): void;
+export {};

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

@@ -0,0 +1,28 @@
+import { AuthSessionState, AuthSessionStatus, AuthUser } from './auth-state-type';
+/** `"unknown"` until the app restores or rejects a session at boot. */
+export declare const authSessionStatusAtom: import('jotai').PrimitiveAtom<AuthSessionStatus> & {
+    init: AuthSessionStatus;
+};
+export declare const authUserAtom: import('jotai').PrimitiveAtom<AuthUser | null> & {
+    init: AuthUser | null;
+};
+export declare const isAuthenticatedAtom: import('jotai').Atom<boolean>;
+export declare const authSessionStateAtom: import('jotai').Atom<AuthSessionState>;
+export declare const signInAtom: import('jotai').WritableAtom<null, [user: AuthUser], void> & {
+    init: null;
+};
+export declare const updateAuthUserAtom: import('jotai').WritableAtom<null, [patch: Partial<AuthUser>], 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-state-type.d.ts

@@ -0,0 +1,71 @@
+import { AuthStatus } from './auth-shell';
+export type AuthFlowId = string;
+/** Which auth block the app is showing. */
+export type AuthFlowStep = "login" | "signup" | "verify-code" | "forgot-password" | "update-password" | "onboarding" | "success";
+export type AuthFlowChannel = "email" | "sms";
+export interface AuthFlowState {
+    step: AuthFlowStep;
+    /** The identifier in flight — an email or phone number. Cleared by reset
+     * and by signOut. Never store passwords or codes here. */
+    identifier: string | null;
+    /** `identifier` masked for display — "y•••@example.com", "•••1234". */
+    maskedIdentifier: string | null;
+    channel: AuthFlowChannel;
+    status: AuthStatus;
+    error: string | null;
+}
+/** Options for `beginAuthVerificationAtom` / `beginVerification`. */
+export interface BeginAuthVerificationOptions {
+    identifier: string;
+    /** @default "email" */
+    channel?: AuthFlowChannel;
+    /** @default "verify-code" */
+    step?: AuthFlowStep;
+}
+/** What `useAuthFlowActions(flowId)` returns. */
+export interface AuthFlowActions {
+    /** Show a step; resets status to `"idle"` and clears the error. Keeps the
+     * identifier. */
+    goToStep: (step: AuthFlowStep) => void;
+    /** Record the identifier in flight and move to the verification step. */
+    beginVerification: (options: BeginAuthVerificationOptions) => void;
+    /** Mark the flow `"loading"` while an async attempt is in flight. */
+    beginAttempt: () => void;
+    /** Mark the flow `"error"` with a message. */
+    fail: (message: string) => void;
+    /** Mark the flow `"success"`; when a user is given, also sign the session
+     * in. */
+    complete: (user?: AuthUser) => void;
+    /** Back to the initial values (login step, no identifier). */
+    reset: () => void;
+}
+/** The signed-in identity, kept for the whole session. Structurally
+ * assignable to `ProfileCardUser`, so it drops into `ProfileCardBlock`. */
+export interface AuthUser {
+    id: string;
+    name: string;
+    /** Secondary line — a handle, an email, a role. */
+    username?: string;
+    email?: string;
+    /** Avatar image URL. */
+    avatar?: string;
+    initials?: string;
+    /** App-specific extras the library never interprets. */
+    metadata?: Record<string, unknown>;
+}
+/** `unknown` until the app restores or rejects a session at boot. */
+export type AuthSessionStatus = "unknown" | "unauthenticated" | "authenticated";
+export interface AuthSessionState {
+    status: AuthSessionStatus;
+    user: AuthUser | null;
+}
+/** What `useAuthSessionActions()` returns. */
+export interface AuthSessionActions {
+    signIn: (user: AuthUser) => void;
+    /** Shallow-merge a patch into the signed-in user; no-op when signed out. */
+    updateUser: (patch: Partial<AuthUser>) => void;
+    /** What an app calls at boot when session restore fails. */
+    markUnauthenticated: () => void;
+    /** Sign out AND return the default auth flow to the login step. */
+    signOut: () => void;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * 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';
+export type { AuthFlowActions, AuthFlowChannel, AuthFlowId, AuthFlowState, AuthFlowStep, AuthSessionActions, AuthSessionState, AuthSessionStatus, AuthUser, BeginAuthVerificationOptions, } from './auth-state-type';

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

@@ -0,0 +1,52 @@
+import { AuthFlowActions, AuthFlowId, AuthFlowState, AuthSessionActions, AuthSessionState } from './auth-state-type';
+/**
+ * Read the auth flow registered under `flowId` from anywhere below
+ * `ExegiaProvider`. Pairs with `useAuthFlowActions` to wire the auth blocks
+ * into one flow — the blocks keep passwords and codes in local state, the
+ * flow tracks which block shows and what identifier is in flight:
+ *
+ * ```tsx
+ * const flow = useAuthFlow()
+ * const { beginVerification, complete, fail } = useAuthFlowActions()
+ *
+ * {flow.step === "login" && (
+ *   <LoginBlock
+ *     onSubmit={async ({ email }) => {
+ *       await api.requestCode(email)
+ *       beginVerification({ identifier: email })
+ *     }}
+ *   />
+ * )}
+ * {flow.step === "verify-code" && (
+ *   <CodeAuthBlock
+ *     destination={flow.maskedIdentifier ?? undefined}
+ *     onVerify={async (code) => complete(await api.verify(code))}
+ *   />
+ * )}
+ * ```
+ *
+ * This returns the whole state object, so the caller re-renders on any
+ * change. A component that reads one field should subscribe to that field's
+ * atom instead: `useAtomValue(authFlowStepAtom(flowId))`.
+ */
+export declare function useAuthFlow(flowId?: AuthFlowId): AuthFlowState;
+/**
+ * Drive the auth flow registered under `flowId` from anywhere. Writes only —
+ * the caller never re-renders when the flow changes. See `useAuthFlow` for
+ * the intended wiring; a block's submit handler typically runs
+ * `beginAttempt()` → the API call → `complete(user)` or `fail(message)`.
+ */
+export declare function useAuthFlowActions(flowId?: AuthFlowId): AuthFlowActions;
+/**
+ * Read the session: `status` (`"unknown"` until the app restores or rejects
+ * a session at boot), the signed-in `user`, and derived `isAuthenticated`.
+ */
+export declare function useAuthSession(): AuthSessionState & {
+    isAuthenticated: boolean;
+};
+/**
+ * Drive the session. Writes only. `signOut` is the composite
+ * `endAuthSessionAtom`: it clears the session AND returns the default flow
+ * to the login step — the one to wire to a logout button.
+ */
+export declare function useAuthSessionActions(): AuthSessionActions;

package/dist-lib/components/blocks/layout.d.ts

@@ -1,5 +1,8 @@
-import { default as ShellLayout } from './shell';
+import { default as ShellLayout, AnimatedPanel, useShellPanels, resetShellPanelWidthAtom, resizeShellPanelAtom, shellFitFitsAtom, shellFitMeasuredAtom, shellFitMetricsAtom, shellFitPanelBoundsAtom, shellFitPanelWidthAtom, shellFitRequestedWidthAtom, shellFitStateAtom } from './shell';
 declare const Layout: {
     Main: typeof ShellLayout;
+    Panel: typeof AnimatedPanel;
+    Trigger: import('react').ForwardRefExoticComponent<import('./shell').AnimatedSidebarTriggerProps & import('react').RefAttributes<HTMLButtonElement>>;
 };
+export { useShellPanels, resetShellPanelWidthAtom, resizeShellPanelAtom, shellFitFitsAtom, shellFitMeasuredAtom, shellFitMetricsAtom, shellFitPanelBoundsAtom, shellFitPanelWidthAtom, shellFitRequestedWidthAtom, shellFitStateAtom, };
 export default Layout;

package/dist-lib/components/blocks/nav/sidebar/__tests__/ai-sidebar-atom.test.d.ts

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

package/dist-lib/components/blocks/nav/sidebar/ai-sidebar-atom.d.ts

@@ -0,0 +1,217 @@
+import { Atom } from 'jotai';
+import { AISidebarConfig, AISidebarHandlers, AISidebarInstanceId, AISidebarSeed, AISidebarState, DropTarget, FlatResource, SidebarResource, SidebarResourceDropPosition, SidebarResourceMove } from './type.ts';
+/** What a sidebar reads as before `useAISidebar` publishes its options. */
+export declare const DEFAULT_AI_SIDEBAR_CONFIG: AISidebarConfig;
+/**
+ * A string-keyed atom family.
+ *
+ * `jotai/utils`' `atomFamily` is deprecated for Jotai v3, and we need only
+ * the string-keyed case with a `remove` — so this stays in-house rather than
+ * adding `jotai-family` as a second Jotai package to keep version-aligned.
+ * Dropping a key lets the store's WeakMap release that instance's state.
+ */
+type Family<AtomType> = ((id: AISidebarInstanceId) => AtomType) & {
+    remove: (id: AISidebarInstanceId) => void;
+};
+/** @internal */
+export declare const aiSidebarConfigAtom: Family<import('jotai').PrimitiveAtom<AISidebarConfig> & {
+    init: AISidebarConfig;
+}>;
+/** @internal Refreshed every commit; nothing subscribes, so it is free. */
+export declare const aiSidebarHandlersAtom: Family<import('jotai').PrimitiveAtom<AISidebarHandlers> & {
+    init: AISidebarHandlers;
+}>;
+/** The sidebar's current data — hook-owned, or the projection of a
+ * controlled `items` prop. */
+export declare const aiSidebarItemsAtom: Family<import('jotai').PrimitiveAtom<SidebarResource[]> & {
+    init: SidebarResource[];
+}>;
+/** @internal The hook-owned selection. `select` writes it only while no
+ * `activeId` prop owns the selection — read `aiSidebarActiveIdAtom` for the
+ * value the sidebar actually renders. */
+export declare const aiSidebarOwnActiveIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+/** @internal Projection of a controlled `activeId` prop; `undefined` while
+ * the selection is hook-owned. */
+export declare const aiSidebarControlledActiveIdAtom: Family<import('jotai').PrimitiveAtom<string | null | undefined> & {
+    init: string | null | undefined;
+}>;
+/** Open rows — hook-owned, or the projection of a controlled `expandedIds`
+ * prop. */
+export declare const aiSidebarExpandedIdsAtom: Family<import('jotai').PrimitiveAtom<ReadonlySet<string>> & {
+    init: ReadonlySet<string>;
+}>;
+/** Roving-focus target. DOM focus is moved by the block, which owns the row
+ * refs; this is only which row is tabbable. */
+export declare const aiSidebarFocusedIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const aiSidebarDraggingIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const aiSidebarDropTargetAtom: Family<import('jotai').PrimitiveAtom<DropTarget | null> & {
+    init: DropTarget | null;
+}>;
+export declare const aiSidebarMenuOpenIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const aiSidebarRenamingIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+export declare const aiSidebarHoveredIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+/** Live-region text for the last move or rename outcome. */
+export declare const aiSidebarAnnouncementAtom: Family<import('jotai').PrimitiveAtom<string> & {
+    init: string;
+}>;
+/** A move is in flight. Read synchronously by `moveAISidebarRowAtom` before
+ * it starts another — the store needs no ref to see its own latest write. */
+export declare const aiSidebarMovePendingAtom: Family<import('jotai').PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+/** @internal The only items atom `useAISidebar` may subscribe to: empty
+ * while a controlled `items` prop owns the data, so the projection write
+ * never feeds back into the render that produced it. An inline `items={[…]}`
+ * array is a new reference every render, and a subscribed round-trip would
+ * loop. */
+export declare const aiSidebarOwnedItemsAtom: Family<Atom<SidebarResource[]>>;
+/** @internal The same guard for `expandedIds`, which is controllable here
+ * and arrives as an array — just as unstable an identity as `items`. */
+export declare const aiSidebarOwnedExpandedIdsAtom: Family<Atom<ReadonlySet<string>>>;
+/** The selected row: the controlled `activeId` when there is one, the
+ * hook-owned selection otherwise. Kept as two atoms because a controlled
+ * `activeId` of `null` falls through to the hook-owned value — the block has
+ * always read `activeId ?? internalActiveId`. */
+export declare const aiSidebarActiveIdAtom: Family<Atom<string | null>>;
+/** Visible rows in order, each with its depth and parent id. */
+export declare const aiSidebarFlatAtom: Family<Atom<FlatResource[]>>;
+/** Some row is hovered and no drag is running — mounts the pill wrapper. */
+export declare const aiSidebarHoverActiveAtom: Family<Atom<boolean>>;
+/** Whether this one row is the current selection. */
+export declare const aiSidebarRowSelectedAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
+/** Whether this one row is open. */
+export declare const aiSidebarRowExpandedAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
+/** Whether this one row is the roving-focus target. */
+export declare const aiSidebarRowFocusedAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
+/** Whether this one row is in rename mode. */
+export declare const aiSidebarRowRenamingAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
+/** Whether this one row's action menu is open. */
+export declare const aiSidebarRowMenuOpenAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
+/** Whether this one row is the row in flight. */
+export declare const aiSidebarRowDraggingAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
+/** Where a drop on this one row would land, `null` when it is not hovered
+ * by a drag. */
+export declare const aiSidebarRowDropAtom: (id: AISidebarInstanceId, rowId: string) => Atom<SidebarResourceDropPosition | null>;
+/** Whether this one row owns the sliding hover pill. */
+export declare const aiSidebarRowHoveredAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
+/** The whole state of one sidebar. Components reading a single field should
+ * subscribe to that field's atom instead — this one changes on every edit. */
+export declare const aiSidebarStateAtom: Family<Atom<AISidebarState>>;
+export declare const expandAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
+    init: null;
+}>;
+export declare const collapseAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
+    init: null;
+}>;
+export declare const toggleAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
+    init: null;
+}>;
+export declare const expandAllAISidebarRowsAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+export declare const collapseAllAISidebarRowsAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Open every ancestor of `rowId` without touching the rest of the tree. */
+export declare const revealAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
+    init: null;
+}>;
+export declare const selectAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
+    init: null;
+}>;
+/** The store half of `focus`: which row is tabbable. Moving DOM focus is the
+ * block's job — it owns the row refs. */
+export declare const focusAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
+    init: null;
+}>;
+/** @internal Keeps the roving target on a row that still renders: a focused
+ * row that folds away hands focus to the first visible row instead of
+ * pointing at nothing. `useAISidebar` runs it after every projection. */
+export declare const normalizeAISidebarFocusAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+export declare const startAISidebarRenameAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
+    init: null;
+}>;
+export declare const cancelAISidebarRenameAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Commit a rename and leave rename mode. Applied optimistically and rolled
+ * back if `onRename` rejects. Blank and unchanged labels are dropped. */
+export declare const renameAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string, label: string], void> & {
+    init: null;
+}>;
+export declare const openAISidebarMenuAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
+    init: null;
+}>;
+/** Closes the menu and hands the roving target back to the row that owned
+ * it, then returns that id so the block can move DOM focus there — otherwise
+ * focus falls back to the body and the keyboard user loses their place. */
+export declare const closeAISidebarMenuAtom: Family<import('jotai').WritableAtom<null, [], string | null> & {
+    init: null;
+}>;
+/**
+ * Reorder, applied optimistically and rolled back if `onMove` rejects.
+ *
+ * The pending flag is read straight back out of the store, which is why this
+ * needs no ref to guard overlapping moves the way React state did: the write
+ * is visible to the next call immediately, not after a commit.
+ */
+export declare const moveAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [move: SidebarResourceMove], Promise<void>> & {
+    init: null;
+}>;
+/** Replace the data. Reports through `onItemsChange`; writes the atom only
+ * when no controlled `items` prop owns it. */
+export declare const setAISidebarItemsAtom: Family<import('jotai').WritableAtom<null, [items: SidebarResource[]], void> & {
+    init: null;
+}>;
+export declare const setAISidebarHoveredAtom: Family<import('jotai').WritableAtom<null, [rowId: string, hovered: boolean], void> & {
+    init: null;
+}>;
+export declare const clearAISidebarHoverAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+export declare const endAISidebarDragAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** @internal Publish the latest options; seed the instance once. */
+export declare const mountAISidebarAtom: Family<import('jotai').WritableAtom<null, [config: AISidebarConfig, seed: AISidebarSeed], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const setAISidebarHandlersAtom: Family<import('jotai').WritableAtom<null, [handlers: AISidebarHandlers], void> & {
+    init: null;
+}>;
+/** @internal One-way projections of controlled props — no callbacks fire. */
+export declare const projectAISidebarItemsAtom: Family<import('jotai').WritableAtom<null, [items: SidebarResource[]], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const projectAISidebarActiveIdAtom: Family<import('jotai').WritableAtom<null, [activeId: string | null], void> & {
+    init: null;
+}>;
+/** @internal */
+export declare const projectAISidebarExpandedIdsAtom: Family<import('jotai').WritableAtom<null, [expandedIds: string[]], void> & {
+    init: null;
+}>;
+/** Back to the values the instance mounted with. */
+export declare const resetAISidebarAtom: Family<import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+}>;
+/** Drop every atom for `id`. `useAISidebar` calls this on unmount for
+ * sidebars it keyed itself; an explicit `sidebarId` outlives its component,
+ * so an app-named sidebar keeps its open rows across a route change. */
+export declare function removeAISidebarInstance(id: AISidebarInstanceId): void;
+export {};

package/dist-lib/components/blocks/nav/sidebar/index.d.ts

@@ -3,11 +3,13 @@ import { MarqueeLabel } from './marquee-label.tsx';
 import { ResourceRow } from './sidebar-row.tsx';
 import { SidebarIcon } from './sidebar-icon.tsx';
 export { useAISidebar, type UseAISidebarOptions } from './use-ai-sidebar.ts';
+export { useAISidebarActions, useAISidebarState, } from './use-ai-sidebar-state.ts';
 export type * from './type.ts';
+export { aiSidebarActiveIdAtom, aiSidebarAnnouncementAtom, aiSidebarDraggingIdAtom, aiSidebarDropTargetAtom, aiSidebarExpandedIdsAtom, aiSidebarFlatAtom, aiSidebarFocusedIdAtom, aiSidebarHoverActiveAtom, aiSidebarHoveredIdAtom, aiSidebarItemsAtom, aiSidebarMenuOpenIdAtom, aiSidebarMovePendingAtom, aiSidebarRenamingIdAtom, aiSidebarRowDraggingAtom, aiSidebarRowDropAtom, aiSidebarRowExpandedAtom, aiSidebarRowFocusedAtom, aiSidebarRowHoveredAtom, aiSidebarRowMenuOpenAtom, aiSidebarRowRenamingAtom, aiSidebarRowSelectedAtom, aiSidebarStateAtom, cancelAISidebarRenameAtom, clearAISidebarHoverAtom, closeAISidebarMenuAtom, collapseAISidebarRowAtom, collapseAllAISidebarRowsAtom, endAISidebarDragAtom, expandAISidebarRowAtom, expandAllAISidebarRowsAtom, focusAISidebarRowAtom, moveAISidebarRowAtom, openAISidebarMenuAtom, removeAISidebarInstance, renameAISidebarRowAtom, resetAISidebarAtom, revealAISidebarRowAtom, selectAISidebarRowAtom, setAISidebarHoveredAtom, setAISidebarItemsAtom, startAISidebarRenameAtom, toggleAISidebarRowAtom, } from './ai-sidebar-atom.ts';
 export { AISidebar, MarqueeLabel, ResourceRow, SidebarIcon };
 export declare const Sidebar: {
     Wrapper: typeof AISidebar;
     MarqueeLabel: typeof MarqueeLabel;
-    Row: typeof ResourceRow;
+    Row: import('react').MemoExoticComponent<({ row }: import('./type.ts').ResourceRowProps) => import("react").JSX.Element>;
     Icon: typeof SidebarIcon;
 };

package/dist-lib/components/blocks/nav/sidebar/sidebar-context.d.ts

@@ -0,0 +1,3 @@
+import { AISidebarContextValue } from './type.ts';
+export declare const AISidebarContext: import('react').Context<AISidebarContextValue | null>;
+export declare function useAISidebarContext(): AISidebarContextValue;

package/dist-lib/components/blocks/nav/sidebar/sidebar-row.d.ts

@@ -1,2 +1,4 @@
 import { ResourceRowProps } from './type';
-export declare function ResourceRow({ row, active, expanded, focused, draggingId, dropTarget, menuOpen, renaming, onDragEnd, onDragOver, onDragStart, onDrop, onFocus, onKeyDown, onMenuOpenChange, onRenameCancel, onRenameCommit, onRenameStart, onSelect, onToggle, hoverActive, hoverPill, hoverLayoutId, onHoverChange, renderIcon, renderMenu, renderActionsTrigger, setRef, }: ResourceRowProps): import("react").JSX.Element;
+declare function ResourceRowImpl({ row }: ResourceRowProps): import("react").JSX.Element;
+export declare const ResourceRow: import('react').MemoExoticComponent<typeof ResourceRowImpl>;
+export {};