@inkami/blx 0.17.3

package/dist/caret/custom-caret.d.ts

@@ -0,0 +1,30 @@
+export declare class CustomCaret {
+    private _el;
+    private _container;
+    private _x;
+    private _y;
+    private _currentBlock;
+    private _suppressNextSnap;
+    private _instantNextMove;
+    private _enabled;
+    private _activeTimer;
+    private _trailCleanup;
+    private _destroyed;
+    private _bound_onSelectionChange;
+    private _bound_onKeyDown;
+    private _bound_onScroll;
+    private _bound_onResize;
+    private _resizeObserver;
+    constructor(container: HTMLElement);
+    hide(): void;
+    setEnabled(enabled: boolean): void;
+    destroy(): void;
+    private _onSelectionChange;
+    private _onKeyDown;
+    private _onScroll;
+    private _onResize;
+    private _update;
+    private _moveTo;
+    private _cancelTrail;
+    private _animateSnap;
+}

package/dist/clipboard/clipboard-manager.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Clipboard manager: handles copy/cut/paste of blocks.
+ *
+ * Uses the Clipboard API to write both a custom MIME type
+ * (`application/x-blx-blocks+json`) for lossless block round-trips
+ * and `text/plain` (Markdown) for interop with other apps.
+ *
+ * Since the Clipboard API only supports `text/plain` and `text/html`,
+ * we embed the JSON payload inside an HTML comment in the `text/html`
+ * slot so both rich paste (back into BLX) and plain paste (into other
+ * apps) work seamlessly.
+ */
+import type { Block, BlockJSON } from "../types";
+/**
+ * Copy an array of blocks to the system clipboard.
+ * Writes both `text/plain` (Markdown) and `text/html` (with embedded JSON).
+ */
+export declare function copyBlocksToClipboard(blocks: ReadonlyArray<Block>): Promise<void>;
+/**
+ * Read BLX block data from the clipboard.
+ * Returns the array of BlockJSON if found, or null if the clipboard
+ * contains no BLX data.
+ */
+export declare function readBlocksFromClipboard(): Promise<BlockJSON[] | null>;
+/**
+ * Extract BLX block JSON from an HTML string (e.g. from ClipboardEvent.clipboardData).
+ */
+export declare function extractBlocksFromHtml(html: string): BlockJSON[] | null;

package/dist/clipboard/index.d.ts

@@ -0,0 +1,2 @@
+export { copyBlocksToClipboard, readBlocksFromClipboard, extractBlocksFromHtml } from "./clipboard-manager";
+export { htmlToBlocks, markdownToBlocks, plainTextToBlocks } from "./paste-parser";

package/dist/clipboard/paste-parser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Parse external paste content (HTML or plain text) into BlockJSON arrays.
+ *
+ * When pasting from external apps (browsers, Google Docs, VS Code, etc.),
+ * the clipboard may contain HTML structure or multi-paragraph plain text.
+ * This module converts that content into BLX blocks so the editor can
+ * create proper multi-block structure instead of dumping everything into
+ * a single block.
+ */
+import type { BlockJSON } from "../types";
+/**
+ * Parse an HTML string from the clipboard into an array of BlockJSON.
+ * Returns null if the HTML doesn't contain meaningful block structure
+ * (i.e., it's just a single text fragment with no block-level elements).
+ */
+export declare function htmlToBlocks(html: string): BlockJSON[] | null;
+/**
+ * Parse a Markdown string into an array of BlockJSON.
+ * Handles headings, lists, checklists, code fences, horizontal rules,
+ * and inline formatting (**bold**, *italic*, `code`, ~~strikethrough~~, [links](url)).
+ * Returns null if the text doesn't look like Markdown (no Markdown-specific
+ * syntax found) so the caller can fall back to plain text splitting.
+ */
+export declare function markdownToBlocks(text: string): BlockJSON[] | null;
+/**
+ * Split multi-paragraph plain text into BlockJSON arrays.
+ * Paragraphs are separated by blank lines (`\n\n`).
+ * Returns null if the text is a single paragraph (let default paste handle it).
+ */
+export declare function plainTextToBlocks(text: string): BlockJSON[] | null;

package/dist/commands/command-registry.d.ts

@@ -0,0 +1,26 @@
+export interface CommandEntry {
+    description: string;
+    handler: (args?: string) => void;
+}
+export interface ExternalCommandEntry {
+    id: string;
+    label: string;
+    description: string;
+    execute: (args?: string) => void;
+}
+export declare class CommandRegistry {
+    private commands;
+    register(name: string, entry: CommandEntry): void;
+    unregister(name: string): void;
+    execute(name: string, args?: string): void;
+    list(): Array<{
+        name: string;
+        description: string;
+    }>;
+    has(name: string): boolean;
+    filter(prefix: string): Array<{
+        name: string;
+        description: string;
+    }>;
+    listFull(): ExternalCommandEntry[];
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,2 @@
+export { CommandRegistry } from "./command-registry";
+export type { CommandEntry } from "./command-registry";

package/dist/crdt/automerge-sync.d.ts

@@ -0,0 +1,157 @@
+/**
+ * AutomergeSync — bridges an Automerge CRDT document with a BLX Editor.
+ *
+ * Maintains a parallel Automerge document that mirrors the editor's block
+ * model. Local edits are translated into Automerge mutations (splice for
+ * text, mark/unmark for rich-text attributes, object changes for metadata).
+ * Remote Automerge changes are applied back to the editor.
+ *
+ * ## Automerge document schema
+ *
+ * ```
+ * {
+ *   blockOrder: string[],              // ordered block IDs
+ *   blocks: {
+ *     [blockId]: {
+ *       type: string,
+ *       text: string,                  // Automerge collaborative text
+ *       metadata: Record<string, any>,
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Rich-text attributes (bold, italic, etc.) are stored as Automerge marks
+ * on the `text` field of each block.
+ */
+import * as Automerge from "@automerge/automerge";
+import type { EventBus } from "../event-bus";
+import type { EditorEventMap } from "../event-bus";
+import type { Block } from "../types";
+import { AttributedString } from "../attributed-string";
+export interface AutomergeBlockData {
+    type: string;
+    text: string;
+    metadata: Record<string, unknown>;
+}
+export interface AutomergeDocSchema {
+    /** Ordered list of block IDs (determines document order) */
+    blockOrder: string[];
+    /** Map of blockId → block data */
+    blocks: Record<string, AutomergeBlockData>;
+}
+export interface AutomergeSyncOptions {
+    /** Optional hex actor ID for this peer (auto-generated if omitted) */
+    actorId?: string;
+}
+export declare class AutomergeSync {
+    private doc;
+    /** When true, editor events are ignored (we're applying remote changes) */
+    private _applying;
+    /**
+     * Cache of per-block span attribute signatures. Used to detect whether
+     * formatting changed on a keystroke so we can skip the expensive
+     * unmark-all / re-mark-all cycle when only text was inserted/deleted.
+     */
+    private _spanSigCache;
+    private _getBlocks;
+    private _getBlock;
+    private _addBlock;
+    private _removeBlock;
+    private _moveBlock;
+    private _updateBlockContent;
+    private _replaceAllBlocks;
+    private _bus;
+    private _unsubs;
+    constructor(editorApi: {
+        getBlocks: () => ReadonlyArray<Block>;
+        getBlock: (id: string) => Block | undefined;
+        addBlock: (block: Block, index?: number) => Block;
+        removeBlock: (id: string) => boolean;
+        moveBlock: (id: string, toIndex: number) => boolean;
+        updateBlockContent: (blockId: string, content: AttributedString, metadata?: Record<string, unknown>, blockType?: string) => void;
+        replaceAllBlocks?: (blocks: Block[]) => void;
+        bus: EventBus<EditorEventMap>;
+    }, options?: AutomergeSyncOptions);
+    /** Get the underlying Automerge document (read-only view) */
+    getDoc(): Automerge.Doc<AutomergeDocSchema>;
+    /** Get the actor ID of this Automerge instance */
+    getActorId(): string;
+    /** Save the document to a binary blob for persistence */
+    save(): Uint8Array;
+    /** Load a document from a previously saved binary blob */
+    load(data: Uint8Array, actorId?: string): void;
+    /**
+     * Merge another Automerge document into this one. Useful for
+     * initial sync when peers exchange full document state.
+     */
+    merge(otherDoc: Automerge.Doc<AutomergeDocSchema>): void;
+    /**
+     * Generate a sync message to send to a remote peer.
+     * Returns [updatedSyncState, message] where message may be null
+     * if there's nothing new to send.
+     */
+    generateSyncMessage(syncState: Automerge.SyncState): [Automerge.SyncState, Uint8Array | null];
+    /**
+     * Receive a sync message from a remote peer.
+     * Applies remote changes to both the Automerge doc and the editor.
+     * Returns the updated sync state.
+     */
+    receiveSyncMessage(syncState: Automerge.SyncState, message: Uint8Array): Automerge.SyncState;
+    /**
+     * Apply raw Automerge changes (from `getChanges` / `getAllChanges`).
+     * Useful for replaying history or applying batched changes.
+     */
+    applyChanges(changes: Uint8Array[]): void;
+    /** Get all changes since the document was created */
+    getAllChanges(): Uint8Array[];
+    /** Get changes since a set of heads */
+    getChanges(heads: Automerge.Heads): Uint8Array[];
+    /** Get the current document heads (for change tracking) */
+    getHeads(): Automerge.Heads;
+    /** Create a new sync state for a peer connection */
+    static initSyncState(): Automerge.SyncState;
+    /** Fork a copy of the document (for testing / branching) */
+    fork(): Automerge.Doc<AutomergeDocSchema>;
+    /** Clean up event listeners */
+    destroy(): void;
+    /** Whether we are currently applying remote changes (suppressing local events) */
+    get isApplying(): boolean;
+    /** Populate the Automerge doc from the current editor state */
+    private initFromEditor;
+    /** Listen to editor events and mirror changes to the Automerge doc */
+    private setupListeners;
+    private handleContentChanged;
+    private handleBlockAdded;
+    private handleBlockRemoved;
+    private handleBlockMoved;
+    private handleBlockTypeChanged;
+    /**
+     * Diff two Automerge document versions and apply the differences
+     * to the editor. This is called after receiving remote changes.
+     */
+    private diffAndApply;
+    /**
+     * Full replace: apply the entire Automerge doc to the editor.
+     * Used after `load()`.
+     */
+    private applyDocToEditor;
+    /**
+     * Apply Automerge marks from AttributedString spans.
+     * Must be called inside an `Automerge.change()` callback.
+     */
+    private applyMarksFromSpans;
+    /**
+     * Convert an Automerge block's text + marks back to an AttributedString.
+     *
+     * Uses an efficient O(M log M) interval sweep (M = mark count) rather
+     * than the previous O(M × N) per-character approach (N = text length).
+     */
+    private blockDataToAttributedString;
+}
+/** Simple text diff: find minimal insert/delete to go from `before` to `after` */
+export declare function diffText(before: string, after: string): {
+    pos: number;
+    del: number;
+    ins: string;
+};

package/dist/crdt/crdt-log.d.ts

@@ -0,0 +1,57 @@
+import type { UndoAction, CursorState } from "../undo/types";
+import type { BlockJSON } from "../types";
+import type { CrdtOperation, CrdtLogSnapshot } from "./types";
+/**
+ * Append-only operation log for CRDT-style change tracking.
+ *
+ * Captures an initial editor snapshot and every subsequent edit as an
+ * immutable operation entry. Supports compound grouping (e.g., block split
+ * = content change + block add) so multi-action edits replay atomically.
+ *
+ * Each operation is tagged with a `peerId` to identify which collaborating
+ * peer authored the change.
+ */
+export declare class CrdtLog {
+    private initialState;
+    private operations;
+    private nextId;
+    /** The local peer ID attached to new operations */
+    private _localPeerId;
+    private _grouping;
+    private _groupActions;
+    private _groupBeforeCursor;
+    /** Set the local peer ID for subsequent operations */
+    setLocalPeerId(peerId: string): void;
+    /** Get the current local peer ID */
+    getLocalPeerId(): string | null;
+    /** Capture the initial editor state */
+    setInitialState(blocks: BlockJSON[]): void;
+    /** Start grouping actions into a single atomic operation */
+    beginGroup(beforeCursor: CursorState | null): void;
+    /** Whether a compound group is currently active */
+    get isGrouping(): boolean;
+    /**
+     * Record an action. If a compound group is active, the action is
+     * buffered until `endGroup()` is called.
+     */
+    record(action: UndoAction, beforeCursor: CursorState | null, afterCursor: CursorState | null): void;
+    /**
+     * Append an externally-built operation (e.g. from a remote peer).
+     * Assigns a new sequential ID but preserves the original peerId.
+     */
+    appendRemote(op: Omit<CrdtOperation, "id">): void;
+    /** End compound group and push as a single atomic operation */
+    endGroup(afterCursor: CursorState | null): void;
+    /** Total number of operations in the log */
+    getOperationCount(): number;
+    /** Get a specific operation by index */
+    getOperation(index: number): CrdtOperation | undefined;
+    /** Get the initial editor state */
+    getInitialState(): BlockJSON[];
+    /** Get all operations */
+    getOperations(): readonly CrdtOperation[];
+    /** Clear all recorded operations (keeps initial state) */
+    clear(): void;
+    /** Serialize the log */
+    toJSON(): CrdtLogSnapshot;
+}

package/dist/crdt/index.d.ts

@@ -0,0 +1,8 @@
+export { CrdtLog } from "./crdt-log";
+export { ReplayUI } from "./replay-ui";
+export { renderRemoteCursors, clearRemoteCursors } from "./remote-cursor-renderer";
+export { AutomergeSync, diffText } from "./automerge-sync";
+export type { AutomergeDocSchema, AutomergeBlockData, AutomergeSyncOptions } from "./automerge-sync";
+export type { ReplayUICallbacks } from "./replay-ui";
+export type { CrdtOperation, CrdtLogSnapshot, CrdtPeer, RemoteCursor } from "./types";
+export { PEER_COLORS } from "./types";

package/dist/crdt/remote-cursor-renderer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Remote cursor renderer — positions colored caret indicators and selection
+ * highlights as absolute overlays above the editor, using getBoundingClientRect
+ * to compute positions.
+ *
+ * Cursors are rendered into a dedicated overlay container that sits outside
+ * the contenteditable DOM. This avoids contaminating textContent,
+ * Range.toString(), and TreeWalker traversals that the editor relies on
+ * for offset calculations.
+ */
+import type { RemoteCursor } from "./types";
+/**
+ * Render remote cursors (and optional selection highlights) as absolutely
+ * positioned overlays.
+ *
+ * @param contentEditable - The block's contenteditable element (used for position measurement)
+ * @param cursors - Array of remote cursors targeting this block
+ */
+export declare function renderRemoteCursors(contentEditable: HTMLElement, cursors: RemoteCursor[]): void;
+/** Remove all remote cursor elements for a specific block (or all blocks) */
+export declare function clearRemoteCursors(contentEditable: HTMLElement): void;
+/** Remove cursor overlays for a non-text block (uses the block container directly) */
+export declare function clearRemoteCursorsFromContainer(container: HTMLElement): void;
+/**
+ * Render a colored left-border indicator on a block to show it's part of
+ * a remote peer's multi-block selection.
+ */
+export declare function renderBlockSelectionBorder(container: HTMLElement, cursors: RemoteCursor[]): void;

package/dist/crdt/replay-ui.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Replay UI — slider + transport controls anchored below the editor.
+ *
+ * Shows a timeline slider and play/pause/step controls that let the user
+ * scrub through the CRDT operation log to see how the document was built.
+ */
+export interface ReplayUICallbacks {
+    onSeek(position: number): void;
+    onPlay(): void;
+    onPause(): void;
+    onStepForward(): void;
+    onStepBackward(): void;
+    onExit(): void;
+    getIsPlaying(): boolean;
+    getCurrentPosition(): number;
+    getTotalOperations(): number;
+}
+export declare class ReplayUI {
+    private container;
+    private slider;
+    private playBtn;
+    private stepBackBtn;
+    private stepFwdBtn;
+    private exitBtn;
+    private posLabel;
+    private callbacks;
+    constructor(editorRoot: HTMLElement, callbacks: ReplayUICallbacks);
+    /** Refresh slider range, position, and play/pause icon */
+    update(): void;
+    private updateLabel;
+    private updatePlayIcon;
+    destroy(): void;
+    private createButton;
+}

package/dist/crdt/types.d.ts

@@ -0,0 +1,47 @@
+import type { UndoAction, CursorState } from "../undo/types";
+import type { BlockJSON } from "../types";
+/** Identity and display info for a collaborating peer */
+export interface CrdtPeer {
+    /** Unique peer identifier */
+    id: string;
+    /** Display name shown on cursor labels */
+    displayName: string;
+    /** CSS color for cursor and selection highlights */
+    color: string;
+}
+/** A single CRDT operation entry in the log */
+export interface CrdtOperation {
+    /** Sequential operation ID */
+    id: number;
+    /** Timestamp of the operation */
+    timestamp: number;
+    /** Peer who authored this operation (null = local before peers were set up) */
+    peerId: string | null;
+    /** One or more actions forming an atomic unit (compound ops like split) */
+    actions: UndoAction[];
+    /** Cursor state before the operation */
+    beforeCursor: CursorState | null;
+    /** Cursor state after the operation */
+    afterCursor: CursorState | null;
+}
+/** A remote peer's cursor position, optionally with a selection range */
+export interface RemoteCursor {
+    peerId: string;
+    displayName: string;
+    color: string;
+    blockId: string;
+    offset: number;
+    /** If set, the peer has a selection from offset..endOffset */
+    endOffset?: number;
+    /** If set, the selection spans into this block (multi-block selection) */
+    endBlockId?: string;
+    /** Timestamp of last cursor update (ms since epoch) */
+    lastUpdated?: number;
+}
+/** Serializable snapshot of a CRDT log */
+export interface CrdtLogSnapshot {
+    initialState: BlockJSON[];
+    operations: CrdtOperation[];
+}
+/** Default peer colors for multiplayer (soft, distinct hues) */
+export declare const PEER_COLORS: readonly ["#e06c75", "#61afef", "#e5c07b", "#98c379", "#c678dd", "#d19a66", "#56b6c2", "#be5046"];

package/dist/date-picker/agenda-utils.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Utilities for agenda date formatting and state classification.
+ *
+ * All dates are ISO 8601 date-only strings ("YYYY-MM-DD").
+ * No time component, no timezone — dates are interpreted in the user's local timezone.
+ */
+/** Agenda item urgency states, used for badge/label styling. */
+export type AgendaState = "overdue" | "today" | "tomorrow" | "upcoming" | "future" | "past" | "ongoing";
+export interface AgendaDisplay {
+    /** Human-readable label for the badge/label (e.g. "Tomorrow", "Mar 15", "Overdue: Mar 1"). */
+    label: string;
+    /** CSS class suffix for styling (e.g. "blx-agenda-overdue"). */
+    state: AgendaState;
+}
+/**
+ * Parse an ISO date string ("YYYY-MM-DD") into a Date at midnight local time.
+ * Returns null for invalid inputs.
+ */
+export declare function parseAgendaDate(iso: string): Date | null;
+/**
+ * Format a Date as "YYYY-MM-DD" (ISO 8601 date-only).
+ */
+export declare function formatAgendaDateISO(date: Date): string;
+/** Full month names for calendar header. */
+export declare const MONTH_NAMES_FULL: string[];
+/**
+ * Classify an agenda date and produce a display label + state.
+ *
+ * @param agendaDate - ISO date string ("YYYY-MM-DD")
+ * @param now - Reference date (defaults to current date). Pass explicitly for testability.
+ * @param role - Date role: "due" (default), "scheduled", or "event". Affects past-date classification.
+ */
+export declare function classifyAgendaDate(agendaDate: string, now?: Date, role?: "due" | "scheduled" | "event"): AgendaDisplay;
+/**
+ * CSS class for a given agenda state.
+ */
+export declare function agendaStateClass(state: AgendaState): string;

package/dist/date-picker/date-parser.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Natural language date parser for the @ agenda trigger.
+ *
+ * Parses common date phrases ("tomorrow", "next friday", "march 15") into
+ * date suggestions. Designed to be lightweight (no external dependencies)
+ * and handle the most common patterns users type.
+ */
+/** A parsed date suggestion shown in the picker. */
+export interface DateSuggestion {
+    /** Human-readable label (e.g. "Tomorrow", "Next Friday") */
+    label: string;
+    /** Formatted date description (e.g. "Wed, Mar 11") */
+    description: string;
+    /** The resolved Date object */
+    date: Date;
+    /** ISO date string ("YYYY-MM-DD") */
+    isoDate: string;
+}
+/**
+ * Parse a natural language date query into suggestions.
+ *
+ * Returns up to 5 suggestions sorted by relevance. Empty query returns
+ * empty array (the caller should show the default calendar UI).
+ */
+export declare function parseDateQuery(query: string, now?: Date): DateSuggestion[];

package/dist/date-picker/date-picker.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Date picker for task agenda items with role selection, explicit confirmation,
+ * and recurrence configuration.
+ *
+ * Features:
+ * - Role tabs: Due | Scheduled | Event (context-sensitive defaults)
+ * - Natural language date suggestions (type "tomorrow", "next friday", etc.)
+ * - Mini calendar grid (month view) with keyboard navigation
+ * - Explicit confirm/cancel (tick/cross) in footer bar
+ * - Repeat configuration (interval + unit + fromCompletion flag)
+ * - Remove agenda item button (when editing an existing agenda date)
+ *
+ * Follows the same lifecycle pattern as EmojiPicker:
+ * - `show(anchorRect, options?)` positions and displays the picker
+ * - `reposition(anchorRect)` follows the caret on scroll
+ * - `hide()` / `visible` / `destroy()` for cleanup
+ * - `handleKeyDown(e)` returns true if the event was consumed
+ */
+import type { DateSuggestion } from "./date-parser";
+export type DateRole = "due" | "scheduled" | "event";
+export interface Recurrence {
+    interval: number;
+    unit: "day" | "week" | "month" | "year";
+    anchor?: string;
+    fromCompletion?: boolean;
+}
+export declare class DatePicker {
+    private el;
+    private onSelect;
+    private onRemove;
+    private onClose;
+    private pendingInteraction;
+    private currentMonth;
+    private selectedDate;
+    private pendingDate;
+    private selectedRole;
+    private blockType;
+    private repeatEnabled;
+    private repeatInterval;
+    private repeatUnit;
+    private fromCompletion;
+    private showingRepeatConfig;
+    private roleTabBar;
+    private calendarGrid;
+    private monthLabel;
+    private removeBtn;
+    private footerBar;
+    private tickBtn;
+    private repeatToggleBtn;
+    private repeatConfigEl;
+    private calendarSection;
+    private suggestionList;
+    private headerEl;
+    private dowRow;
+    private inSuggestionMode;
+    private suggestions;
+    private suggestionIndex;
+    constructor(onSelect: (isoDate: string, role: DateRole, recurrence?: Recurrence) => void, onRemove: () => void, onClose: () => void);
+    get element(): HTMLElement;
+    /**
+     * Show the picker anchored to the given rect.
+     * @param anchorRect - Caret or block bounding rect
+     * @param options - Optional initial state for role, date, recurrence, blockType
+     */
+    show(anchorRect: DOMRect, options?: {
+        initialRole?: DateRole;
+        initialDate?: string;
+        initialRecurrence?: Recurrence;
+        blockType?: string;
+    } | string | null): void;
+    reposition(anchorRect: DOMRect): void;
+    /** Clamp the picker within the viewport, flipping or pinning as needed. */
+    private clampToViewport;
+    hide(): void;
+    get visible(): boolean;
+    isInteracting(): boolean;
+    /**
+     * Update displayed date suggestions.
+     * Called by the editor on each keystroke while @ search is active.
+     * Pass an empty array or null to exit suggestion mode.
+     */
+    updateSuggestions(suggestions: DateSuggestion[] | null): void;
+    /**
+     * Programmatically set the role (due/scheduled/event).
+     * Used by inline syntax detection (e.g., @due(...) sets role to "due").
+     */
+    setRole(role: DateRole): void;
+    /**
+     * Programmatically confirm the current suggestion (like pressing Enter).
+     * Used by inline syntax auto-confirm (typing the closing paren).
+     * If in suggestion mode with suggestions, selects the highlighted one.
+     * If a pending date is set, confirms it.
+     */
+    confirmSelection(): void;
+    /** Handle keyboard events. Returns true if the event was consumed. */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    destroy(): void;
+    private renderRoleTabs;
+    private confirmDate;
+    private updateConfirmState;
+    private formatRecurrenceLabel;
+    private updateRepeatLabel;
+    private setPendingDate;
+    private toggleRepeatConfig;
+    private updateRepeatSection;
+    /** Format pending date as "Wed, Mar 25" for the repeat config chip. */
+    private formatDateChip;
+    private buildRepeatConfig;
+    private enterSuggestionMode;
+    private exitSuggestionMode;
+    private renderSuggestions;
+    private updateSuggestionSelection;
+    private navigateMonth;
+    private renderCalendar;
+}

package/dist/date-picker/index.d.ts

@@ -0,0 +1,6 @@
+export { DatePicker } from "./date-picker";
+export type { DateRole, Recurrence } from "./date-picker";
+export { classifyAgendaDate, parseAgendaDate, formatAgendaDateISO, agendaStateClass, MONTH_NAMES_FULL } from "./agenda-utils";
+export type { AgendaState, AgendaDisplay } from "./agenda-utils";
+export { parseDateQuery } from "./date-parser";
+export type { DateSuggestion } from "./date-parser";