@book.dev/ui 1.60.0

package/dist/lib/pageFont.d.ts

@@ -0,0 +1,25 @@
+export interface PageFonts {
+    /** Primary typeface — body / prose text. */
+    body?: string;
+    /** Secondary typeface — the title and headings. */
+    heading?: string;
+}
+/** The built-in typeface presets offered in the customisation pane. */
+export declare const FONT_PRESETS: ReadonlyArray<{
+    id: 'sans' | 'serif' | 'mono';
+    labelKey: string;
+    css: string;
+}>;
+/** Resolve a stored choice (preset id or custom family) to a CSS font-family. */
+export declare function fontCss(choice: string | undefined | null): string | undefined;
+/** Subscribe to per-page font changes (any page). Returns an unsubscribe fn. */
+export declare const subscribePageFonts: (cb: () => void) => (() => void);
+/** The fonts stored for a page, or `null` when it follows the app default. */
+export declare function readPageFonts(pageId: string): PageFonts | null;
+/** Persist (or clear, when empty) a page's font override. */
+export declare function writePageFonts(pageId: string, fonts: PageFonts | null): void;
+/** A page's fonts as scoped CSS variables, or `undefined` when none are set
+ *  (so callers can skip the wrapper class entirely). */
+export declare function pageFontStyle(fonts: PageFonts | null): Record<string, string> | undefined;
+/** React-subscribe to one page's fonts; re-renders when they change. */
+export declare function usePageFonts(pageId: string): PageFonts | null;

package/dist/lib/pageFullWidth.d.ts

@@ -0,0 +1,10 @@
+/** Subscribe to full-width changes (any page). Returns an unsubscribe fn. */
+export declare const subscribePageFullWidth: (cb: () => void) => (() => void);
+/** Whether a page is set to full width (defaults to the centered column). */
+export declare function readPageFullWidth(pageId: string): boolean;
+/** Persist (or clear, when false) a page's full-width preference. */
+export declare function writePageFullWidth(pageId: string, value: boolean): void;
+/** Flip a page between full-width and the centered column. */
+export declare function togglePageFullWidth(pageId: string): void;
+/** React-subscribe to one page's full-width flag; re-renders when it changes. */
+export declare function usePageFullWidth(pageId: string): boolean;

package/dist/lib/pageIcon.d.ts

@@ -0,0 +1,25 @@
+import { ICON_PROPERTY_ID } from '@book.dev/sdk';
+/** The default page icon when none has been chosen. */
+export declare const DEFAULT_PAGE_ICON = "\uD83D\uDCC4";
+/** Subscribe to icon changes (any page). Returns an unsubscribe fn. */
+export declare const subscribePageIcon: (cb: () => void) => (() => void);
+export declare function setIconPersister(fn: ((pageId: string, emoji: string | null) => void) | null): void;
+/** The emoji a page has been given, or `null` when none is set. Lets callers
+ *  (e.g. the sidebar tree) fall back to their own glyph instead of the default. */
+export declare const readStoredPageIcon: (pageId: string) => string | null;
+export declare const readPageIcon: (pageId: string) => string;
+export declare const writePageIcon: (pageId: string, emoji: string) => void;
+/**
+ * Bulk-hydrate icons from a list projection — {@link PageMeta} entries
+ * (`{id, icon}`) or database rows (`{id, icon: properties[sys_icon]}`). Lifts any
+ * legacy localStorage icon into the document the first time a page is seen
+ * without a stored one. The list is authoritative for the pages it names.
+ */
+export declare function hydratePageIcons(entries: Array<{
+    id: string;
+    icon?: string | null;
+}>): void;
+/** React-subscribe to one page's icon; re-renders when it changes. */
+export declare function usePageIcon(pageId: string): string;
+/** The reserved property id icons persist under (re-exported for hydration). */
+export { ICON_PROPERTY_ID };

package/dist/lib/pageLinks.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A small bridge between the EditorJS subpage/database blocks and the app's
+ * navigation. EditorJS instantiates block tools outside React's context (each
+ * block mounts its own React root), so the blocks can't use `useNavigation`.
+ * Instead {@link NavigationProvider} registers its actions here — the same
+ * singleton pattern the reactive store uses — and the blocks call them.
+ */
+export type SubpageKind = 'page' | 'database';
+/** A page candidate for the `@` link menu. */
+export interface PageLinkResult {
+    id: string;
+    label: string;
+    icon: string;
+}
+export interface PageLinkBridge {
+    /** Create a child page nested under `parentId`; resolves to the new page id. */
+    createSubpage: (parentId: string, kind: SubpageKind) => Promise<string>;
+    /** Navigate to a page. Pass `pane` to drive a specific pane (the one the link
+     *  was clicked in) rather than whichever pane is focused. */
+    openPage: (id: string, pane?: 'primary' | 'secondary') => void;
+    /** A display title for a page id. */
+    label: (id: string) => string;
+    /** The emoji icon for a page id. */
+    icon: (id: string) => string;
+    /** Pages whose title matches `query` (best matches first). Pass
+     *  `{databasesOnly: true}` to restrict to pages that host a database. */
+    searchPages: (query: string, opts?: {
+        databasesOnly?: boolean;
+    }) => PageLinkResult[];
+    /** Create a new page titled `name` (no navigation); resolves its id. */
+    createPage: (name: string) => Promise<string>;
+}
+/**
+ * Install (or clear) the live bridge. Re-installing also notifies subscribers,
+ * so the provider re-calling this when page titles change refreshes the blocks.
+ */
+export declare const setPageLinkBridge: (next: PageLinkBridge | null) => void;
+/** Subscribe to bridge changes (title/icon updates). Returns an unsubscribe. */
+export declare const subscribePageLinks: (cb: () => void) => (() => void);
+/** The bridge actions, safe to call before the provider mounts (they no-op). */
+export declare const pageLinks: PageLinkBridge;

package/dist/lib/pageSaveStatus.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Per-page save status, published by the open document(s) and read by the shell
+ * chrome (the page-actions cluster shows the *targeted* page's status). A module
+ * singleton with a small listener registry — same bridge pattern as
+ * {@link lib/pageDocActions} — so the documents and the chrome never reference
+ * each other, and a split view can show each pane's page status independently.
+ */
+export type SaveStatus = 'idle' | 'saving' | 'saved' | 'save failed';
+/** Publish a page's save status (call from the document; clears on unmount). */
+export declare function setPageSaveStatus(pageId: string | null | undefined, status: SaveStatus | null): void;
+export declare const pageSaveStatus: (pageId: string | null | undefined) => SaveStatus;
+export declare const subscribePageSaveStatus: (cb: () => void) => (() => void);
+/** Monotonic change counter — pair with useSyncExternalStore. */
+export declare const pageSaveStatusVersion: () => number;

package/dist/lib/pageTheme.d.ts

@@ -0,0 +1,15 @@
+import { type AppearanceOptions, type AppearanceOverride } from '@/lib/themes';
+/** Subscribe to per-page theme changes (any page). Returns an unsubscribe fn. */
+export declare const subscribePageTheme: (cb: () => void) => (() => void);
+/** The override stored for a page, or `null` when the page follows the app. */
+export declare function readPageTheme(pageId: string): AppearanceOverride | null;
+/** Persist (or, with `null`/empty, clear) a page's override. */
+export declare function writePageTheme(pageId: string, override: AppearanceOverride | null): void;
+/** Whether a page carries any override (i.e. doesn't simply follow the app). */
+export declare const hasPageTheme: (pageId: string) => boolean;
+/** React-subscribe to one page's override; re-renders when it changes. */
+export declare function usePageTheme(pageId: string): AppearanceOverride | null;
+/** Merge a page's override over the global appearance for the active scheme,
+ *  returning a CSS-variable style map — or `undefined` when there's no override
+ *  (so callers can skip the scoped wrapper entirely). */
+export declare function composePageAppearance(global: AppearanceOptions, override: AppearanceOverride | null, scheme: 'light' | 'dark'): Record<string, string> | undefined;

package/dist/lib/pageThemePresets.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Whole-page theme presets: one click sets a page's accent (control colour),
+ * background tint, typefaces, and cover together — a coordinated look you can
+ * then fine-tune with the individual pickers. Applied per page through the same
+ * localStorage stores as the manual controls ({@link writePageTheme} /
+ * {@link writePageFonts} / {@link writePageCover}), so a preset is just a bundle
+ * of those writes.
+ */
+import type { AppearanceOverride } from '@/lib/themes';
+import type { PageFonts } from '@/lib/pageFont';
+import { type PageCover } from '@/lib/pageCover';
+export interface PageThemePreset {
+    id: string;
+    /** i18n key for the display name (see messages `appearance.preset.*`). */
+    labelKey: string;
+    /** Accent + background (an empty override means "follow the app" — a reset). */
+    override: AppearanceOverride;
+    /** Body / heading typefaces, or null to clear them. */
+    fonts: PageFonts | null;
+    /** A curated gradient cover, or null to clear it. */
+    cover: PageCover | null;
+}
+export declare const PAGE_THEME_PRESETS: PageThemePreset[];

package/dist/lib/recents.d.ts

@@ -0,0 +1,9 @@
+export declare const MAX_RECENTS = 12;
+/** Pure: move `id` to the front (deduped), capped to `max`. */
+export declare function recordRecentId(list: string[], id: string, max?: number): string[];
+/** The current recents, most-recent first. */
+export declare const readRecents: () => string[];
+/** Record a visit to `id` (moves it to the front). */
+export declare const recordRecent: (id: string) => void;
+/** Subscribe to recents changes. Returns an unsubscribe fn. */
+export declare const subscribeRecents: (cb: () => void) => (() => void);

package/dist/lib/reviewPane.d.ts

@@ -0,0 +1,23 @@
+/** Subscribe to review-target changes. Returns an unsubscribe fn. */
+export declare const subscribeReviewPane: (cb: () => void) => (() => void);
+export interface ReviewTarget {
+    pageId: string | null;
+    focusSuggestionId: string | null;
+    focusBlockId: string | null;
+    revision: number;
+}
+/** The page currently under review (plus any focused suggestion/block), or null. */
+export declare const getReviewTarget: () => ReviewTarget;
+/**
+ * Point the Review side pane at a page (does NOT open the pane itself — the
+ * caller also calls `openInSplit(REVIEW_PANE_ID)`). Optionally focuses a
+ * suggestion or a block's comment thread.
+ */
+export declare function setReviewTarget(pageId: string | null, opts?: {
+    suggestionId?: string | null;
+    blockId?: string | null;
+}): void;
+/** Subscribe to "a suggestion/comment changed" pings. Returns an unsubscribe fn. */
+export declare const subscribeReviewData: (cb: () => void) => (() => void);
+/** Notify every review surface that suggestions/comments changed (refetch). */
+export declare const pingReviewData: () => void;

package/dist/lib/selection.d.ts

@@ -0,0 +1,2 @@
+/** The last document text selection (excluding app chrome), or '' if none. */
+export declare const lastSelection: () => string;

package/dist/lib/shortcuts.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The keyboard-shortcut vocabulary, shared by the global key handler
+ * ({@link useGlobalShortcuts}), the command palette, and the menus — so a
+ * shortcut is defined once and every surface that displays or fires it stays in
+ * sync.
+ *
+ * A {@link ShortcutCombo} is platform-neutral: `mod` means ⌘ on macOS and Ctrl
+ * elsewhere. {@link formatShortcut} renders it for display (`⌘K` vs `Ctrl+K`)
+ * and {@link matchShortcut} tests a `KeyboardEvent` against it.
+ */
+export interface ShortcutCombo {
+    /** The `KeyboardEvent.key` to match (compared case-insensitively). */
+    key: string;
+    /** ⌘ on macOS, Ctrl elsewhere. */
+    mod?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+}
+/**
+ * Client-side platform flag. Surfaces rendered during SSR (e.g. the sidebar
+ * search button) should prefer {@link useIsMac} so the first client render
+ * matches the server HTML; menus and the palette open only after mount, so the
+ * module-level value is correct for them.
+ */
+export declare const isMacPlatform: boolean;
+/**
+ * Render a combo for display: macOS stacks symbols with no separator (`⌘⇧L`),
+ * other platforms join with `+` (`Ctrl+Shift+L`). The modifier order follows
+ * each platform's convention.
+ */
+export declare function formatShortcut(combo: ShortcutCombo, mac?: boolean): string;
+/** True when `e` is exactly this combo (modifiers must match, not just be present). */
+export declare function matchShortcut(e: KeyboardEvent, combo: ShortcutCombo): boolean;
+/**
+ * The canonical shortcut for each app command, keyed by command id. Every combo
+ * here uses a modifier, so the global handler can fire it even while a text
+ * field or the editor has focus without stealing ordinary typing.
+ */
+export declare const SHORTCUTS: {
+    readonly commandPalette: {
+        readonly key: "k";
+        readonly mod: true;
+    };
+    readonly newPage: {
+        readonly key: "n";
+        readonly mod: true;
+    };
+    readonly toggleSidebar: {
+        readonly key: "\\";
+        readonly mod: true;
+    };
+    readonly openSettings: {
+        readonly key: ",";
+        readonly mod: true;
+    };
+    readonly goBack: {
+        readonly key: "[";
+        readonly mod: true;
+    };
+    readonly goForward: {
+        readonly key: "]";
+        readonly mod: true;
+    };
+    readonly toggleFullWidth: {
+        readonly key: ".";
+        readonly mod: true;
+    };
+    readonly toggleTheme: {
+        readonly key: "l";
+        readonly mod: true;
+        readonly shift: true;
+    };
+    readonly openTrash: {
+        readonly key: "delete";
+        readonly mod: true;
+        readonly shift: true;
+    };
+};
+export type ShortcutId = keyof typeof SHORTCUTS;

package/dist/lib/sidebarStyles.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared sidebar item styling. The old hover was `bg-accent` — a neutral gray
+ * on the (also-neutral) sheet, so the highlight barely read. These tint the
+ * highlight with the theme colour instead: still subtle, but with real contrast
+ * against the surface. Applied via `cn`, so they override a Button variant's
+ * own `hover:bg-accent` through tailwind-merge.
+ */
+export declare const SIDEBAR_HOVER = "hover:bg-primary/10 hover:text-foreground dark:hover:bg-primary/20";
+/** The selected / active sidebar item — a stronger tint of the same colour. */
+export declare const SIDEBAR_ACTIVE = "bg-primary/15 text-foreground dark:bg-primary/25";

package/dist/lib/suggestBridge.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A tiny in-memory bridge for human-authored suggestions + block comments from
+ * inside the (provider-less) block editor. The editor's row menu calls
+ * `requestSuggestEdit` / `requestComment` with the target block; a host
+ * portaled from `BlockPageDocument` (which DOES sit inside the app providers /
+ * data client — the editor's own React root does not) renders the composer and
+ * persists through the data client. Mirrors the `kitPanel` / `aiBridge`
+ * singleton pattern.
+ */
+export interface SuggestEditRequest {
+    pageId: string;
+    blockId: string;
+    /** The block's current plain text (the suggestion's "before"). */
+    before: string;
+}
+export interface CommentRequest {
+    pageId: string;
+    blockId: string;
+}
+type SuggestHandler = (req: SuggestEditRequest) => void;
+type CommentHandler = (req: CommentRequest) => void;
+/** The host (BlockPageDocument) registers how to open each composer. */
+export declare const registerSuggestHost: (handlers: {
+    onSuggestEdit: SuggestHandler;
+    onComment: CommentHandler;
+}) => (() => void);
+/** Whether a host is mounted (gate the menu items so they don't no-op). */
+export declare const suggestHostReady: () => boolean;
+/** Open the "Suggest edit" composer for a block (from the editor row menu). */
+export declare const requestSuggestEdit: (req: SuggestEditRequest) => void;
+/** Open the comment composer/thread for a block (from the editor row menu). */
+export declare const requestComment: (req: CommentRequest) => void;
+export {};

package/dist/lib/textMerge.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Three-way plain-text merge (a word-level diff3), used when accepting a
+ * suggestion whose target text has changed since the suggestion was made —
+ * e.g. two suggestions edit the SAME block and both are accepted. Replaying the
+ * second as a full-text replacement would clobber the first; merging it against
+ * the common ancestor keeps both edits when they touch different regions.
+ *
+ * Granularity is the token (a whitespace run, a word, or a single punctuation
+ * char), so disjoint word edits merge cleanly. When both sides changed the same
+ * region differently it is a true conflict, resolved in favour of `theirs` (the
+ * change being accepted) — the closest match to the prior "last write wins"
+ * behaviour, but now confined to the genuinely-overlapping span.
+ */
+/**
+ * Merge `theirs` into `ours` relative to their common ancestor `base`. Edits the
+ * two sides make in different regions are both kept; a region both sides changed
+ * differently resolves to `theirs`.
+ */
+export declare function merge3(base: string, ours: string, theirs: string): string;

package/dist/lib/themes.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Named color themes + a small parametric appearance model on top of them.
+ *
+ * Like zxcv's, each theme keeps the shared warm-minimal neutral base and swaps
+ * the *accent* family (`--primary` / `--ring` plus open-book's `--brand*`), so
+ * the design language stays consistent while the highlight color changes.
+ *
+ * On top of the accent palette the user controls a couple of knobs (see
+ * {@link AppearanceOptions}): the **interface intensity** (how saturated the
+ * neutral gray surfaces read — and how strongly the sidebar adopts the accent
+ * tint) and the **control intensity** of the faded control accent (`--accent`).
+ * The neutral *temperature* (warm / cool / neutral gray) rides on the accent
+ * theme rather than being a separate control. {@link composeAppearance} folds an
+ * accent palette + those knobs into one token set; {@link applyAppearance}
+ * writes it onto an element (the document root globally, or a page wrapper for a
+ * per-page override).
+ *
+ * The content surfaces of {@link DEFAULT_APPEARANCE} match the legacy palette
+ * (verbatim from index.css) in both schemes; the one intended departure is the
+ * sidebar, which is always tinted (the sheets adopt the accent hue, with a
+ * strength that follows the interface intensity — level 0 falls back to a flat
+ * neutral panel).
+ *
+ * `--radius` is intentionally not themed (it's part of the brand geometry).
+ */
+/** One palette: every themable token as an `H S% L%` triple (no `hsl(...)`). */
+export interface ThemeTokens {
+    background: string;
+    foreground: string;
+    card: string;
+    cardForeground: string;
+    popover: string;
+    popoverForeground: string;
+    primary: string;
+    primaryForeground: string;
+    secondary: string;
+    secondaryForeground: string;
+    muted: string;
+    mutedForeground: string;
+    accent: string;
+    accentForeground: string;
+    destructive: string;
+    destructiveForeground: string;
+    border: string;
+    input: string;
+    ring: string;
+    sheet1: string;
+    sheet1Foreground: string;
+    sheet2: string;
+    sheet2Foreground: string;
+    brand: string;
+    brandForeground: string;
+    brandSubtle: string;
+}
+/** Accent palettes are grouped in the picker so bold and soft hues don't mix.
+ *  `gray` holds the whole-application gray accents (warm / neutral / cool). */
+export type AccentGroup = 'gray' | 'bold' | 'pastel';
+export interface Theme {
+    id: string;
+    /** i18n key for the display name (see messages `theme.*`). */
+    nameKey: string;
+    /** Picker grouping (default `bold`). */
+    group?: AccentGroup;
+    /** The neutral gray *temperature* this accent carries (warm / neutral / cool).
+     *  Gray accents set it explicitly; coloured accents leave it `warm` (the
+     *  warm-minimal brand). It's a property of the accent now, not a separate
+     *  control — so picking "Cool" makes the whole app a cool gray. */
+    neutral?: NeutralFamily;
+    light: ThemeTokens;
+    dark: ThemeTokens;
+}
+export declare const DEFAULT_THEME_ID = "default";
+export declare const themes: Theme[];
+export declare const getTheme: (id: string) => Theme;
+/** Resolve the OS color-scheme preference. */
+export declare function getSystemColorScheme(): 'light' | 'dark';
+/**
+ * The temperature of the neutral grays. The interface is always a gray; this
+ * only leans it warm or cool (or keeps it dead neutral). There's no longer a
+ * "tint the whole UI with the accent" option — that mechanism was removed.
+ */
+export type NeutralFamily = 'warm' | 'cool' | 'neutral';
+/** 0 = off … 3 = strong. Shared scale for the interface- and control-intensity knobs. */
+export type Level = 0 | 1 | 2 | 3;
+/**
+ * The user's full appearance choice. `DEFAULT_APPEARANCE` reproduces the legacy
+ * palette exactly, so any field left at its default is a visual no-op.
+ */
+export interface AppearanceOptions {
+    /** Accent palette id (see {@link themes}). The accent also carries the neutral
+     *  gray temperature — the gray accents (warm / neutral / cool) make the whole
+     *  app that temperature; coloured accents stay warm. */
+    themeId: string;
+    /** How saturated the neutral surfaces are — also how strongly the sidebar
+     *  sheets take the accent tint (the sidebar is always tinted; level 0 falls
+     *  back to a flat neutral panel). */
+    interfaceIntensity: Level;
+    /** How colored the faded control surface (`--accent`) is. */
+    controlIntensity: Level;
+    /** Blur the canvas behind modal/search overlays. Off by default — it's a
+     *  global preference, not a per-page one. */
+    blurOverlays?: boolean;
+    /** Optional page-canvas tint (a {@link PAGE_BACKGROUNDS} token). Mostly used
+     *  per page; unset means the canvas keeps the theme's default `--background`. */
+    background?: string;
+}
+/** Soft full-canvas tints for the per-page "Background" control (token → HSL). */
+export declare const PAGE_BACKGROUNDS: Record<string, {
+    light: string;
+    dark: string;
+}>;
+export declare const DEFAULT_APPEARANCE: AppearanceOptions;
+/** A per-page override: any subset of the global appearance. */
+export type AppearanceOverride = Partial<AppearanceOptions>;
+/**
+ * Migrate a persisted (possibly older-shape) appearance to the current model:
+ * `tint`→`interfaceIntensity`, `accentIntensity`→`controlIntensity`, and the
+ * renamed gray theme ids. The old `neutral` temperature knob and the retired
+ * `tintedSidebar` toggle are dropped (the sidebar is always tinted now). Unknown
+ * keys are dropped by the `{...DEFAULT_APPEARANCE, ...}` merge at the call site.
+ */
+export declare function normalizeAppearance(raw: Record<string, unknown>): AppearanceOverride;
+/** Merge a (possibly partial) override over a base, dropping undefined keys. */
+export declare function mergeAppearance(base: AppearanceOptions, override?: AppearanceOverride | null): AppearanceOptions;
+/**
+ * Fold an accent palette + the appearance knobs into a full token set for one
+ * color scheme. Pure (no DOM) so it powers both the global apply and the inline
+ * per-page style, and is unit-testable.
+ */
+export declare function composeAppearance(opts: AppearanceOptions, scheme: 'light' | 'dark'): ThemeTokens;
+/** A composed appearance as a CSS-variable map, for use as an inline `style`. */
+export declare function appearanceStyle(opts: AppearanceOptions, scheme: 'light' | 'dark'): Record<string, string>;
+/** Write a composed appearance onto an element (defaults to the document root). */
+export declare function applyAppearance(opts: AppearanceOptions, scheme: 'light' | 'dark', target?: HTMLElement): void;
+/** Write a theme's palette (for the given scheme) onto the document root.
+ *  Legacy entry point — prefer {@link applyAppearance}. */
+export declare function applyTheme(theme: Theme, scheme: 'light' | 'dark'): void;

package/dist/lib/treeMove.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pure logic for sidebar drag-and-drop: given the flat page list and a drop
+ * (drag page X onto page Y, `before` / `after` / `inside`), compute the new
+ * parent and the reordered sibling list to send to the server's `movePage`.
+ *
+ * Kept free of React/DOM so it can be unit-tested directly (`treeMove.test.ts`);
+ * the DnD glue lives in `components/ui/tree.tsx`.
+ */
+import type { PageMeta } from '@book.dev/sdk';
+/** Where a row was dropped relative to the target row. */
+export type DropWhere = 'before' | 'after' | 'inside';
+export interface MovePlan {
+    /** The dragged page's new parent (`null` = top level). */
+    parentId: string | null;
+    /** The full ordered list of sibling ids under `parentId`, including the dragged page. */
+    orderedIds: string[];
+}
+/**
+ * Resolve the move, or `null` when it's invalid (dropping a page onto itself, or
+ * nesting it inside its own subtree — which would create a cycle). The server
+ * enforces the same cycle rule; this just avoids a doomed round-trip and lets
+ * the UI suppress the drop indicator.
+ */
+export declare function planTreeMove(pages: PageMeta[], draggedId: string, targetId: string, where: DropWhere): MovePlan | null;

package/dist/lib/useModifierHeld.d.ts

@@ -0,0 +1 @@
+export declare function useModifierHeld(): boolean;

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;