@book.dev/ui 1.60.0

package/dist/components/database/useDatabase.d.ts

@@ -0,0 +1,129 @@
+import { type RelationCardinality, type DatabasePropertyType, type DatabaseRow, type DatabaseSelectOption, type DatabaseView, type DatabaseViewType, type NumberDisplay, type NumberFormat, type PropertyGroup, type RollupConfig, type RowTemplate, type StoredDatabase } from '@book.dev/sdk';
+export interface NewPropertyInput {
+    name: string;
+    type: DatabasePropertyType;
+    /** For `select`/`multi_select`: initial option labels. */
+    options?: string[];
+    /** For `expr`: the exported cell name to read. */
+    cellName?: string;
+    /** For `formula`: the expression source. */
+    formula?: string;
+    /** For `number`/`formula`: the display format. */
+    numberFormat?: NumberFormat;
+    /** For `date`: store a start→end range. */
+    dateRange?: boolean;
+    /** For `relation`: the target database whose rows this links to. */
+    relationDatabaseId?: string;
+    /** For `relation`: the cardinality (drives the single/many cap per side). */
+    relationCardinality?: RelationCardinality;
+    /** A short helper description. */
+    description?: string;
+}
+/** Fields editable on an existing property (any subset). */
+export interface PropertyPatch {
+    name?: string;
+    type?: DatabasePropertyType;
+    options?: DatabaseSelectOption[];
+    cellName?: string;
+    formula?: string;
+    numberFormat?: NumberFormat;
+    numberDisplay?: NumberDisplay;
+    numberTarget?: number;
+    idPrefix?: string;
+    dateRange?: boolean;
+    includeTime?: boolean;
+    dateDisplay?: 'absolute' | 'relative';
+    description?: string;
+    groupId?: string | null;
+    pageHidden?: boolean;
+    rollup?: RollupConfig;
+    relationDatabaseId?: string;
+    relationSingle?: boolean;
+    relationCardinality?: RelationCardinality;
+}
+export interface UseDatabase {
+    database: StoredDatabase | null;
+    loading: boolean;
+    /** All rows (unfiltered), in manual order. */
+    rows: DatabaseRow[];
+    /** Rows after the active view's filters + sorts + the quick-search query. */
+    visibleRows: DatabaseRow[];
+    activeView: DatabaseView | null;
+    setActiveViewId: (viewId: string) => void;
+    /** The quick-search query applied across every column. */
+    search: string;
+    setSearch: (query: string) => void;
+    /** Create a row, optionally pre-setting property values. Returns the new id. */
+    addRow: (initial?: Record<string, unknown>) => Promise<string | undefined>;
+    /** Create a sub-item nested under `parentId`. Returns the new row id. */
+    addSubItem: (parentId: string) => Promise<string | undefined>;
+    /** Re-parent a row (`null` = top level). Reverts if the server refuses (e.g. a cycle). */
+    setRowParent: (rowId: string, parentId: string | null) => Promise<void>;
+    renameRow: (rowId: string, name: string) => Promise<void>;
+    setRowProperty: (rowId: string, propertyId: string, value: unknown) => Promise<void>;
+    /** Set several properties of one row atomically (single optimistic update + PATCH). */
+    setRowProperties: (rowId: string, patch: Record<string, unknown>) => Promise<void>;
+    /** Duplicate a row (its title, properties, and document), at the same nesting level. */
+    duplicateRow: (rowId: string) => Promise<void>;
+    /** Import CSV text: first column → title, others map to (or create) columns. Returns the row count. */
+    importCsv: (text: string) => Promise<number>;
+    /** Set the manual order of rows (full ordered id list). */
+    reorderRows: (orderedIds: string[]) => Promise<void>;
+    /** Create a row positioned immediately after `rowId` in the manual order. */
+    addRowAfter: (rowId: string) => Promise<void>;
+    /** Create a row positioned immediately before `rowId` in the manual order. */
+    addRowBefore: (rowId: string) => Promise<void>;
+    deleteRow: (rowId: string) => Promise<void>;
+    /** Open a row in the split pane for editing its document. */
+    openRow: (rowId: string) => void;
+    /** The database's saved row templates. */
+    templates: RowTemplate[];
+    /** Capture a row's current property values as a named, reusable template. */
+    saveAsTemplate: (rowId: string, name?: string) => Promise<void>;
+    /** Create a row pre-filled from a template. Returns the new row id. */
+    addRowFromTemplate: (templateId: string) => Promise<string | undefined>;
+    /** Remove a saved template. */
+    deleteTemplate: (templateId: string) => Promise<void>;
+    addProperty: (input: NewPropertyInput) => Promise<void>;
+    /** Clone a property (its full config) into a new column just after it. */
+    duplicateProperty: (propertyId: string) => Promise<void>;
+    updateProperty: (propertyId: string, patch: PropertyPatch) => Promise<void>;
+    /** Move a property left/right among the columns (delta -1 or +1). */
+    moveProperty: (propertyId: string, delta: number) => Promise<void>;
+    /** Move a property to sit just before `beforeId` (or to the end when null). */
+    reorderProperty: (propertyId: string, beforeId: string | null) => Promise<void>;
+    deleteProperty: (propertyId: string) => Promise<void>;
+    addSelectOption: (propertyId: string, label: string) => Promise<DatabaseSelectOption | null>;
+    /** Pair a `dependency` property with a new inverse column (two-way / synced links). */
+    makeDependencyTwoWay: (propertyId: string) => Promise<void>;
+    /** Pair a `relation` property with a new reverse column on its target database
+     *  (a two-way, cross-database link). No-op if it isn't a relation or is already paired. */
+    pairRelation: (propertyId: string, opts?: {
+        name?: string;
+        reverseSingle?: boolean;
+    }) => Promise<void>;
+    addPropertyGroup: (name?: string) => Promise<string | undefined>;
+    updatePropertyGroup: (groupId: string, patch: Partial<PropertyGroup>) => Promise<void>;
+    deletePropertyGroup: (groupId: string) => Promise<void>;
+    updateView: (viewId: string, patch: Partial<DatabaseView>) => Promise<void>;
+    /** Add a view of a given type and switch to it. */
+    addView: (type: DatabaseViewType, name?: string) => Promise<void>;
+    renameView: (viewId: string, name: string) => Promise<void>;
+    duplicateView: (viewId: string) => Promise<void>;
+    deleteView: (viewId: string) => Promise<void>;
+    /** Move a view tab to sit just before `toId` (drag-to-reorder the tabs). */
+    reorderView: (fromId: string, toId: string) => Promise<void>;
+    /** Rename the database itself. */
+    renameDatabase: (name: string) => Promise<void>;
+}
+/**
+ * Loads the database hosted by `pageId` (if any), keeps its rows live, and
+ * exposes the row/schema mutations the database screen needs. Returns
+ * `database: null` for ordinary pages so the caller can render nothing.
+ *
+ * `databaseIdHint` lets the caller short-circuit the lookup: `null` means "this
+ * page hosts no database" (skip the request entirely — avoids a 404 probe on
+ * every ordinary page), a string fetches that database by id, and `undefined`
+ * falls back to looking it up by page.
+ */
+export declare function useDatabase(pageId: string, databaseIdHint?: string | null): UseDatabase;

package/dist/components/index.d.ts

@@ -0,0 +1,12 @@
+export * from './brand';
+export { default as Drawer } from './Drawer';
+export { default as NavBar } from './NavBar';
+export { default as SideNav } from './SideNav';
+export { default as TrashDialog } from './TrashDialog';
+export { default as DocumentArea } from './DocumentArea';
+export { default as TitlebarTabs } from './TitlebarTabs';
+export { DatabaseView } from './database/DatabaseView';
+export { useDatabase } from './database/useDatabase';
+export { default as Settings } from './Settings';
+export { default as SettingsPanel } from './SettingsPanel';
+export { default as SettingsButton } from './SettingsButton';

package/dist/components/review/BlockReviewMarkers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Inline review affordances: for every block that has an OPEN suggestion or a
+ * standalone comment, this adds a quiet highlight (a left border accent via the
+ * `ob-block-reviewed` class) to the block's `[data-block-row]` element and
+ * floats a small clickable indicator at the row's right edge. Clicking it opens
+ * the Review pane focused on that block/suggestion.
+ *
+ * The block editor renders its own React root outside the app providers, so we
+ * cannot decorate from within it; instead this component (rendered from
+ * `BlockPageDocument`, inside providers) reaches into the editor's DOM by id —
+ * the robust integration point, since block ids are stable across re-renders.
+ * Highlighting and the indicator are presentation-only; nothing mutates the
+ * CRDT, so concurrent edits are unaffected.
+ */
+export declare function BlockReviewMarkers({ pageId, containerRef }: {
+    pageId: string;
+    containerRef: React.RefObject<HTMLElement | null>;
+}): import("react").ReactPortal | null;
+export default BlockReviewMarkers;

package/dist/components/review/CommentThread.d.ts

@@ -0,0 +1,20 @@
+import type { CommentInput, StoredComment } from '@book.dev/sdk';
+/**
+ * A threaded rich-text discussion: the comments for a target (a suggestion's
+ * review thread, or a block's standalone comments) plus a composer. Comment
+ * bodies are rich text (bold/italic/underline/links) via the shared
+ * {@link RichTextEditor}. Posting and deleting bubble up to the host so it can
+ * persist through the data client and refetch.
+ */
+export interface CommentThreadProps {
+    comments: StoredComment[];
+    /** The new-comment skeleton minus body (pageId + suggestionId/blockId). */
+    newComment: Omit<CommentInput, 'body' | 'authorName'>;
+    authorName: string;
+    onPost: (input: CommentInput) => Promise<void> | void;
+    onDelete: (id: string) => Promise<void> | void;
+    /** Compact spacing when nested inside a suggestion card. */
+    compact?: boolean;
+}
+export declare function CommentThread({ comments, newComment, authorName, onPost, onDelete, compact }: CommentThreadProps): import("react/jsx-runtime").JSX.Element;
+export default CommentThread;

package/dist/components/review/ReviewPaneBody.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The Review side-pane body: lists a page's open suggestions (each with a
+ * before→after diff, accept/reject, and its rich-text thread) and any
+ * standalone block comments. Reads the target page from the `reviewPane`
+ * bridge (set by the "Review" affordance / inline accept/reject / agent panel),
+ * mirroring how the Customise pane reads `pageCustomise`. Mounted by SplitPane
+ * for the {@link REVIEW_PANE_ID} pseudo-pane.
+ */
+/** The human author name for new suggestions/comments (profile → "You"). */
+export declare function useAuthorName(): string;
+export declare function ReviewPaneBody(): import("react/jsx-runtime").JSX.Element;
+export default ReviewPaneBody;

package/dist/components/review/SuggestHost.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Bridges the (provider-less) block editor's inline "Suggest edit" / "Comment"
+ * affordances to the app's data client + Review pane. Rendered from
+ * `BlockPageDocument` (which sits inside the providers the editor's own React
+ * root does not), it registers handlers on the `suggestBridge` singleton:
+ *
+ *  - Suggest edit → a small composer dialog; submitting persists a human
+ *    `replace-text` suggestion (same model as an AI one) targeting the block,
+ *    then opens the Review pane focused on it.
+ *  - Comment → opens the Review pane focused on the block's comment thread.
+ */
+export declare function SuggestHost(): import("react/jsx-runtime").JSX.Element;
+export default SuggestHost;

package/dist/components/review/SuggestionCard.d.ts

@@ -0,0 +1,21 @@
+import type { CommentInput, StoredComment, StoredSuggestion } from '@book.dev/sdk';
+/**
+ * One suggestion in the Review pane: a before→after diff, accept / reject
+ * controls, and its threaded rich-text discussion. Accepting applies the change
+ * to the document (via the editor bridge, in one CRDT transaction) and resolves
+ * the suggestion's status; rejecting just resolves it. Both flow up to the host.
+ */
+export interface SuggestionCardProps {
+    suggestion: StoredSuggestion;
+    comments: StoredComment[];
+    authorName: string;
+    /** Highlighted (e.g. focused from an inline affordance or the agent panel). */
+    focused?: boolean;
+    busy?: boolean;
+    onAccept: (s: StoredSuggestion) => Promise<void> | void;
+    onReject: (s: StoredSuggestion) => Promise<void> | void;
+    onPostComment: (input: CommentInput) => Promise<void> | void;
+    onDeleteComment: (id: string) => Promise<void> | void;
+}
+export declare function SuggestionCard({ suggestion: s, comments, authorName, focused, busy, onAccept, onReject, onPostComment, onDeleteComment, }: SuggestionCardProps): import("react/jsx-runtime").JSX.Element;
+export default SuggestionCard;

package/dist/components/review/__tests__/review.test.d.ts

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

package/dist/components/review/useReview.d.ts

@@ -0,0 +1,27 @@
+import type { CommentInput, StoredComment, StoredSuggestion } from '@book.dev/sdk';
+/**
+ * Loads and mutates a page's review layer (suggestions + comments) and keeps it
+ * in sync across surfaces. Suggestions/comments have no SSE channel, so every
+ * mutation pings a module-level signal (`pingReviewData`) that all `useReview`
+ * consumers listen to and refetch from — the inline indicators, the Review
+ * pane, and the agent panel stay consistent without a live stream.
+ *
+ * Accepting a suggestion applies the change through the editor bridge (one CRDT
+ * transaction when the editor is mounted; a savePage fallback otherwise), then
+ * marks it accepted. Rejecting only marks it rejected.
+ */
+export interface UseReview {
+    suggestions: StoredSuggestion[];
+    comments: StoredComment[];
+    loading: boolean;
+    /** Comments anchored to a specific suggestion (its review thread). */
+    commentsForSuggestion: (suggestionId: string) => StoredComment[];
+    /** Standalone comments anchored to a block (no suggestion). */
+    commentsForBlock: (blockId: string) => StoredComment[];
+    acceptSuggestion: (s: StoredSuggestion) => Promise<void>;
+    rejectSuggestion: (s: StoredSuggestion) => Promise<void>;
+    postComment: (input: CommentInput) => Promise<void>;
+    deleteComment: (id: string) => Promise<void>;
+    reload: () => Promise<void>;
+}
+export declare function useReview(pageId: string | null): UseReview;

package/dist/components/settings/AccountSettings.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Account & sync: connect this device to account.book.pub (the deep-link OAuth
+ * flow) and mirror preferences + the workspace list there. The data server is
+ * untouched — only settings sync through the account service.
+ */
+export default function AccountSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/components/settings/AdminSettings.d.ts

@@ -0,0 +1,2 @@
+/** Workspace maintenance: backup & restore, plus a guarded danger zone. */
+export default function AdminSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/components/settings/ConnectionSettings.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Server connection: connect to a remote server, or (on the desktop) manage the
+ * local server's network sharing. The desktop keeps its books in an always-on
+ * local server reached over IPC; connecting to a remote server reloads the app
+ * so the data client re-initializes against the new target.
+ */
+export default function ConnectionSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/components/settings/CustomisationSettings.d.ts

@@ -0,0 +1,2 @@
+/** Layout toggles (backed by the live HUD) + a reference list of shortcuts. */
+export default function CustomisationSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/components/settings/ProfileSettings.d.ts

@@ -0,0 +1,2 @@
+/** The user's local identity: name, display name, avatar, and a short bio. */
+export default function ProfileSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/components/settings/primitives.d.ts

@@ -0,0 +1,47 @@
+import { type ComponentType, type ReactNode } from 'react';
+/**
+ * Shared layout for a settings sub-screen: a title, an optional lead paragraph,
+ * and a vertical stack of sections. Every screen opens with this so headings and
+ * spacing stay identical instead of each panel re-deriving them inline.
+ */
+export declare function SettingsScreen({ title, description, children, }: {
+    title: string;
+    description?: string;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** A labelled group within a screen — an optional heading + hint, then content. */
+export declare function SettingsSection({ title, description, children, className, }: {
+    title?: string;
+    description?: string;
+    children: ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/** A stacked label + hint + control, for inputs / selects / textareas. */
+export declare function SettingsField({ label, hint, htmlFor, children, className, }: {
+    label: string;
+    hint?: string;
+    htmlFor?: string;
+    children: ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/** A horizontal row — label + hint on the left, a Switch on the right. */
+export declare function SettingsToggle({ label, hint, checked, onCheckedChange, disabled, }: {
+    label: string;
+    hint?: string;
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    disabled?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * A placeholder for a sub-screen whose backend doesn't exist yet (the app is
+ * local-first — no accounts / payments / integrations). A calm, centered icon +
+ * copy, with an optional call to action, rather than a broken-looking empty tab.
+ */
+export declare function SettingsStub({ icon: Icon, title, description, action, }: {
+    icon: ComponentType<{
+        className?: string;
+    }>;
+    title: string;
+    description: string;
+    action?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/settings/stubs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Placeholder screens for capabilities that don't exist yet — OpenBook is
+ * local-first, with no accounts, payments, or integrations backend. Each is a
+ * calm "coming soon" panel rather than a misleading empty form.
+ */
+export declare function SignupSettings(): import("react/jsx-runtime").JSX.Element;
+export declare function SupportSettings(): import("react/jsx-runtime").JSX.Element;
+export declare function IntegrationsSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/__tests__/kbd.test.d.ts

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

package/dist/components/ui/__tests__/markdown.test.d.ts

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

package/dist/components/ui/__tests__/select.test.d.ts

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

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/components/ui/command.d.ts

@@ -0,0 +1,86 @@
+import * as React from "react";
+import { DialogProps } from "@radix-ui/react-dialog";
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface CommandDialogProps extends DialogProps {
+    /** Accessible name for the dialog (visually hidden). */
+    title?: string;
+    /** Accessible description for the dialog (visually hidden). */
+    description?: string;
+}
+declare const CommandDialog: ({ children, title, description, ...props }: CommandDialogProps) => import("react/jsx-runtime").JSX.Element;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "value" | "type" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "heading" | "value"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/components/ui/context-menu.d.ts

@@ -0,0 +1,24 @@
+import * as React from "react";
+import * as ContextMenuPrimitive from "@radix-ui/react-context-menu";
+declare const ContextMenu: React.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuShortcut, ContextMenuGroup, ContextMenuPortal, ContextMenuSub, ContextMenuSubTrigger, ContextMenuSubContent, };

package/dist/components/ui/dialog.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/dist/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/components/ui/icon-button.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+/**
+ * The muted ghost icon button used throughout the chrome (sidebar, toolbars,
+ * page actions, pane controls). One definition so every small icon control has
+ * the same hover, radius, focus ring, and muted-by-default color — instead of
+ * the `rounded p-1 … hover:bg-hover` snippet copy-pasted per call site.
+ */
+declare const iconButtonVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof iconButtonVariants> {
+    asChild?: boolean;
+}
+declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { IconButton, iconButtonVariants };

package/dist/components/ui/input.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const inputVariants: (props?: ({
+    inputSize?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof inputVariants> {
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input, inputVariants };

package/dist/components/ui/kbd.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { type ShortcutCombo } from '@/lib/shortcuts';
+/**
+ * Platform flag for rendering. Initialised to `false` (Ctrl-style) so the first
+ * client render matches the server HTML, then adopts the real platform after
+ * mount — surfaces shown during SSR (the sidebar search/settings buttons) can
+ * use this without a hydration mismatch. See the SSR-hydration note in the docs.
+ */
+export declare function useIsMac(): boolean;
+/**
+ * A keyboard-shortcut hint, styled as a subtle key cap. Hidden at rest to keep
+ * the UI quiet; it fades in only while ⌘/Ctrl is held (the space is reserved so
+ * nothing shifts). Decorative — `aria-hidden` so assistive tech reads the
+ * action label, not "Command K". The shortcut is also available on long hover
+ * via {@link ShortcutTooltip}.
+ */
+export declare function Kbd({ combo, className }: {
+    combo: ShortcutCombo;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Wrap a control to reveal its keyboard shortcut in a tooltip on long hover —
+ * the quiet way to discover a shortcut without a permanent badge. Self-contained
+ * provider with a deliberate delay so it only appears on a real, lingering hover.
+ */
+export declare function ShortcutTooltip({ combo, label, side, children, }: {
+    combo: ShortcutCombo;
+    label?: string;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/label.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { type VariantProps } from "class-variance-authority";
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import("class-variance-authority/types").ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };