@qilin-agent/client-ui-primitives 0.0.0-stage → 3.1.4

package/lib/types/icons/index.d.ts

@@ -0,0 +1,211 @@
+/**
+ * ic_ds_* icon set for the qilin web UI. All glyphs render fill="currentColor"
+ * and take {size, className}. Batch A mirrors the deepsuite icon library
+ * (same figma source); batch B glyphs are harness-only figma extracts.
+ */
+import type { IconProps } from './props.ts';
+export type { IconProps } from './props.ts';
+/** ic_ds_new_chat_outline_16 */
+export declare const IconNewChatOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_search_outline_16 */
+export declare const IconSearchOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_globe_outline_14 — meridian globe (harness-only figma extract). */
+export declare const IconGlobeOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_settings_outline_14 */
+export declare const IconSettingsOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_settings_outline_16 */
+export declare const IconSettingsOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_panel_left_outline_16 */
+export declare const IconPanelLeftOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_ellipsis_outline_16 */
+export declare const IconEllipsisOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_plus_outline_16 */
+export declare const IconPlusOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_check_outline_16 */
+export declare const IconCheckOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_check_outline_14 */
+export declare const IconCheckOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_branch_outline_16 */
+export declare const IconBranchOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_chevron_down_outline_14 */
+export declare const IconChevronDownOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_chevron_left_outline_14 */
+export declare const IconChevronLeftOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_chevron_right_outline_14 */
+export declare const IconChevronRightOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_triangle_right_fill_14 — tree expand arrow; points right, consumers rotate it 90° for the open state. */
+export declare const IconTriangleRightFill14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_chevron_up_outline_14 */
+export declare const IconChevronUpOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_close_outline_16 */
+export declare const IconCloseOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_close_fill_14 */
+export declare const IconCloseFill14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_copy_outline_16 */
+export declare const IconCopyOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_refresh_outline_16, inset 10%: the exported glyph fills its box edge
+ * to edge, one visual size above the neighbouring 16px glyphs. */
+export declare const IconRefreshOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_refresh_outline_14 */
+export declare const IconRefreshOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_like_outline_16 */
+export declare const IconLikeOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_like_fill_16 */
+export declare const IconLikeFill16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_dislike_outline_16 */
+export declare const IconDislikeOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_dislike_fill_16 */
+export declare const IconDislikeFill16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_share_outline_16 */
+export declare const IconShareOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_edit_outline_16 */
+export declare const IconEditOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_think_outline_14 */
+export declare const IconThinkOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_think_outline_16 */
+export declare const IconThinkOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_agent_preset_outline_16 (figma extract): node interiors knock out to transparency via mask, so the glyph sits on any fill. */
+export declare const IconAgentPresetOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_browse_outline_16 */
+export declare const IconBrowseOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_context_injection_outline_16 (figma extract): browse document frame with an open top and an arrow dropping in. */
+export declare const IconContextInjectionOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_link_outline_14 */
+export declare const IconLinkOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_link_outline_16 */
+export declare const IconLinkOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_right_up_outline_14 */
+export declare const IconRightUpOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_right_up_outline_16 */
+export declare const IconRightUpOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_enhance_outline_16 */
+export declare const IconEnhanceOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_trash_outline_16 */
+export declare const IconTrashOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_warning_outline_16 */
+export declare const IconWarningOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_user_outline_16 */
+export declare const IconUserOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_send_outline_16 */
+export declare const IconSendOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_stop_fill_16 */
+export declare const IconStopFill16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_paperclip_outline_16 */
+export declare const IconPaperclipOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_loading_outline_16 */
+export declare const IconLoadingOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_download_outline_16 */
+export declare const IconDownloadOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_play_outline_16 */
+export declare const IconPlayOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_pause_outline_16 */
+export declare const IconPauseOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_fullscreen_outline_16 */
+export declare const IconFullscreenOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_code_outline_16 */
+export declare const IconCodeOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_cordis_plugin_outline_14 */
+export declare const IconCordisPluginOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_api_outline (figma extract) */
+export declare const IconApiOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_personalization_outline_16 (figma extract) */
+export declare const IconPersonalizationOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_project_add_outline_16 (figma extract) */
+export declare const IconProjectAddOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/**
+ * folder_open_16, outline layer only: the duotone original above reads a rung
+ * heavier than the …Outline16 family, so an icon-button row mixing them looks
+ * mismatched — this is the same geometry without the 20%-opacity inner fill.
+ */
+export declare const IconFolderOpenOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** folder_open_16 (figma extract): outline at full ink + 20%-opacity inner fill riding the same currentColor. */
+export declare const IconFolderOpen16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** folder_close_16 (figma extract) */
+export declare const IconFolderClose16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** tree_corner_8x10 (figma extract; session-tree "L" connector, stroke geometry pre-expanded) */
+export declare const IconTreeCorner8x10: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_light_outline_16 */
+export declare const IconLightOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_dark_outline_16 */
+export declare const IconDarkOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_followsystem_outline_16 */
+export declare const IconFollowsystemOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_data_outline_16 */
+export declare const IconDataOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** IconDataOutline16 without its gear: a three-tier database cylinder. */
+export declare const IconDatabaseOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Thin-stroke clock: outlined dial with square-cut hour and minute hands. */
+export declare const IconClockOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Thin-stroke gauge: dial arc open at the bottom, filled hub, square-cut needle to the upper right.
+ * The dial center sits at y=8.75, not 8: the bottom opening leaves the glyph top-heavy, and the
+ * 0.75 drop optically centers the drawn extent in the 16 box. */
+export declare const IconGaugeOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_send_outline_14 (figma extract): thin-stroke upward send arrow. */
+export declare const IconSendOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_queue_outline_14 (figma extract): open chat bubble with two queued lines. */
+export declare const IconQueueOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_checklist_outline_14 (figma extract): two rings + two list bars. */
+export declare const IconChecklistOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_List_Pen_outline_16 */
+export declare const IconListPenOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_goal_outline_16 (goal strip leading glyph: dartboard with a landed arrow) */
+export declare const IconGoalOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** sparkle_16 (Others tool-row leading glyph; hand-authored three-star
+ *  approximation — the figma 43:31850 glyph is an SF Symbols "sparkles" text glyph,
+ *  not extractable as vector data) */
+export declare const IconSparkle16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** inspect_outline_12 (shared tool-row trajectory affordance glyph) */
+export declare const IconInspectOutline12: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** skill_outline_16 (skill tool-row glyph; document instructions + sparkle) */
+export declare const IconSkillOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_question_outline_14 (figma extract): ring + question glyph. */
+export declare const IconQuestionOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Info companion to the question outline: the same ring with an "i" glyph. */
+export declare const IconInfoOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Alarm clock outline for active scheduled-task indicators. */
+export declare const IconAlarmClockOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_archive_outline_20 (figma extract): lidded box + label slot. The export's
+ *  0.11px stroke ring around the box contour is dropped — it restates the same
+ *  contour in the same ink, which currentColor already carries. */
+export declare const IconArchiveOutline20: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Sign out: the door leaf left behind and an arrow leaving it. */
+export declare const IconLogoutOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Command prompt window with a caret and a trailing line (harness-only glyph). */
+export declare const IconTerminalOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Line-wrapping toggle glyph. */
+export declare const IconWrapLinesOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/**
+ * Compact row glyph of the composer menu: the composer's context-usage ring
+ * (ContextMeter) frozen at its resting look — a quiet track with one filled
+ * quarter arc. A restyle of the live ring revisits this copy.
+ */
+export declare const IconCompactOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_paper_plane_outline_14 */
+export declare const IconPaperPlaneOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/**
+ * Plan row glyph of the composer menu (#3567): a document with three ruled
+ * lines and a pencil over its corner. Drawn on a 14 grid whose content spans
+ * 0.5..13.5, so at the menu's 16px render it fills the same extent as the
+ * 16-grid glyphs beside it.
+ */
+export declare const IconPlanOutline14: ({ size, className }: IconProps) => import("react").JSX.Element;
+/**
+ * The permission shield contour on the 16 grid (design set 1556), stroked at
+ * {@link SHIELD_OUTLINE_STROKE}. The composer's permission selector composes
+ * its mode marks (check, pencil, exclamation) over this same path inside one
+ * svg, so the geometry lives here once.
+ */
+export declare const SHIELD_OUTLINE_PATH = "M8.20554 0.899994L14.7901 3.36857V7.01026C14.7901 12 11.0466 14.2103 8.20554 15.3C5.36446 14.2103 1.62012 12 1.62012 7.01026V3.36857L8.20554 0.899994Z";
+/** Stroke width of {@link SHIELD_OUTLINE_PATH}. */
+export declare const SHIELD_OUTLINE_STROKE = "1.31831";
+/** Permission row glyph of the composer menu: the shield contour alone, without a mode mark. */
+export declare const IconShieldOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Plugin pinwheel (design handoff for the plugin manager): four interleaved arcs on the 16 grid. */
+export declare const IconPluginPinwheelOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Microphone with uniform one-pixel strokes; speech-input record control. */
+export declare const IconMicrophoneOutline16: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** ic_ds_pin_outline_16: a push-pin seen at an angle, one-pixel outline. */
+export declare const IconPinOutlineRegular: ({ size, className }: IconProps) => import("react").JSX.Element;
+/** Filled twin of {@link IconPinOutlineRegular}: the pinned-row marker. */
+export declare const IconPinFillRegular: ({ size, className }: IconProps) => import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/icons/props.d.ts

@@ -0,0 +1,9 @@
+/** Shared props for every ic_ds_* icon component. */
+export interface IconProps {
+    /** Square edge in px; defaults to the glyph's own drawn size. */
+    size?: number | undefined;
+    /** Extra class for layout placement; color rides currentColor.
+     * (`| undefined` for exactOptionalPropertyTypes: callers forward their own optional prop.) */
+    className?: string | undefined;
+}
+//# sourceMappingURL=props.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Cordis-free React primitives styled only through `--qilin-*` tokens.
+ */
+export { SettingsForm } from './settings-form/SettingsForm.tsx';
+export type { SettingsFormLabels, SettingsFormProps } from './settings-form/SettingsForm.tsx';
+export { SettingsSecretField, SettingsValueField } from './settings-form/fields.tsx';
+export type { SettingsFieldProps } from './settings-form/fields.tsx';
+export { SettingsFormModel, settingsNumberField, settingsTextField } from './settings-form/form-model.ts';
+export type { SettingsFieldSpec, SettingsFieldState, SettingsFieldWrite, SettingsFormActions, SettingsFormPathOp, SettingsFormScope, SettingsFormScopeSnapshot, SettingsFormShell, SettingsSecretSpec, } from './settings-form/form-model.ts';
+export { CommandText } from './CommandText.tsx';
+export type { CommandTextProps } from './CommandText.tsx';
+export { StateDot } from './StateDot.tsx';
+export type { StateDotState } from './StateDot.tsx';
+export { DisclosureRow } from './DisclosureRow.tsx';
+export type { DisclosureRowProps } from './DisclosureRow.tsx';
+export { Button } from './Button.tsx';
+export type { ButtonVariant } from './Button.tsx';
+export { Pill } from './Pill.tsx';
+export { SegmentedControl } from './SegmentedControl.tsx';
+export type { SegmentedControlOption } from './SegmentedControl.tsx';
+export { Tag } from './Tag.tsx';
+export type { TagTone } from './Tag.tsx';
+export { Switch } from './Switch.tsx';
+export { Checkbox } from './Checkbox.tsx';
+export { Input } from './Input.tsx';
+export { Menu, MenuItemButton } from './Menu.tsx';
+export type { MenuItemButtonProps, MenuEntry, MenuItem, MenuSeparator, MenuLabel } from './Menu.tsx';
+export { ShortcutKeys } from './ShortcutKeys.tsx';
+export { useAnchoredMaxHeight } from './useAnchoredMaxHeight.ts';
+export { overlayTopMargin } from './overlay-top-margin.ts';
+export { TextShimmer } from './TextShimmer.tsx';
+export type { TextShimmerProps } from './TextShimmer.tsx';
+export { useAnchoredPosition } from './useAnchoredPosition.ts';
+export type { AnchoredPositionOptions } from './useAnchoredPosition.ts';
+export { useDismissOnOutsidePointer } from './useDismissOnOutsidePointer.ts';
+export { HoverCard } from './HoverCard.tsx';
+export { Modal } from './Modal.tsx';
+export { OnboardingSurface } from './OnboardingSurface.tsx';
+export { RiskConfirmation } from './RiskConfirmation.tsx';
+export type { RiskConfirmationProps } from './RiskConfirmation.tsx';
+export { ConnectionIndicator } from './ConnectionIndicator.tsx';
+export type { ConnectionIndicatorState } from './ConnectionIndicator.tsx';
+export { QilinSeal } from './QilinSeal.tsx';
+export { ReferenceIcon } from './ReferenceIcon.tsx';
+export type { ReferenceIconKind, ReferenceIconProps } from './ReferenceIcon.tsx';
+export { LinkIcon, classifyLinkPath } from './LinkIcon.tsx';
+export type { LinkIconKind, LinkIconProps } from './LinkIcon.tsx';
+export { FileTypeIcon, classifyFileType, fileExtension } from './FileTypeIcon.tsx';
+export type { CodeFileType, FileType, FileTypeIconProps, FileTypeKind, FileTypeProjectContext, } from './FileTypeIcon.tsx';
+export { PathLabel } from './PathLabel.tsx';
+export { projectUserText, type UserTextReferences } from './user-text.tsx';
+export { Tooltip } from './Tooltip.tsx';
+export type { TooltipSide } from './Tooltip.tsx';
+export { focusWithoutRing } from './focus.ts';
+export { observeComposition } from './keyboard-composition.ts';
+export { closeTopModal, isBehindModal, modalSelector, useModalLayer } from './useModalLayer.ts';
+export { Toast } from './Toast.tsx';
+export { fileSizeText, fileSizeRoundedText } from './file-size.ts';
+export { writeClipboard } from './clipboard.ts';
+export { useCopyFeedback } from './use-copy-feedback.ts';
+export type { CopyFeedback } from './use-copy-feedback.ts';
+export { relativeTime } from './relative-time.ts';
+export { rankByName } from './rank-by-name.ts';
+export { isDarwinDesktop, watchDarwinDesktop } from './darwin-desktop.ts';
+export type { RelativeTime, RelativeTimeUnit } from './relative-time.ts';
+export { JsonTree } from './JsonTree.tsx';
+export type { JsonTreeProps, JsonTreeLabels } from './JsonTree.tsx';
+export { TerminalBlock, DEFAULT_TERMINAL_MAX_LINES } from './TerminalBlock.tsx';
+export type { TerminalBlockProps, TerminalBlockLabels } from './TerminalBlock.tsx';
+export { ReadBlock, DEFAULT_READ_MAX_LINES } from './ReadBlock.tsx';
+export type { ReadBlockProps, ReadBlockLine, ReadBlockLabels } from './ReadBlock.tsx';
+export { DiffBlock, DEFAULT_DIFF_MAX_LINES, diffTotals } from './DiffBlock.tsx';
+export type { DiffBlockProps, DiffHunk, DiffBlockLabels } from './DiffBlock.tsx';
+export { SearchBlock, DEFAULT_SEARCH_MAX_LINES } from './SearchBlock.tsx';
+export type { SearchBlockProps, SearchMatchesBlockProps, SearchPathsBlockProps, SearchFileGroup, SearchBlockLineMatch, SearchBlockLabels, } from './SearchBlock.tsx';
+export { WebBlock } from './WebBlock.tsx';
+export type { WebBlockProps, WebSearchBlockProps, WebFetchBlockProps, WebSourceView, WebBlockLabels, } from './WebBlock.tsx';
+export { CodeBlock } from './markdown/CodeBlock.tsx';
+export type { CodeBlockProps } from './markdown/CodeBlock.tsx';
+export { JsonBlock } from './markdown/JsonBlock.tsx';
+export { MarkdownDelegateProvider } from './markdown/MarkdownDelegate.tsx';
+export type { MarkdownDelegate, MarkdownDelegateProviderProps, MarkdownExternalLinkHandler } from './markdown/MarkdownDelegate.tsx';
+export { MarkdownText } from './markdown/MarkdownText.tsx';
+export type { MarkdownCodeLabels, MarkdownFileMentions, MarkdownLabels, MarkdownPathImages } from './markdown/MarkdownText.tsx';
+export { extractMarkdownPlainText } from './markdown/plain-text.ts';
+export type { MarkdownPlainTextMode, MarkdownPlainTextOptions } from './markdown/plain-text.ts';
+export * from './icons/index.tsx';
+export { ImageLightbox } from './ImageLightbox.tsx';
+export type { ImageLightboxLabels } from './ImageLightbox.tsx';
+export { MenuGroup, observeStickyMenuGroups } from './MenuGroup.tsx';
+export { MenuSurface } from './MenuSurface.tsx';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/input-modality.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Document-wide input tracking shared by tooltips and focus-ring styles.
+ * Tooltips follow the last input; rings follow navigation or a key followed by
+ * focus on a different control. Modifiers and refocusing alone keep rings silent.
+ * Module-level listeners live for the document lifetime; Node imports are inert.
+ */
+/** Modality values published on the document element. */
+export declare const INPUT_MODALITY: {
+    readonly pointer: "pointer";
+    readonly keyboard: "keyboard";
+};
+/** Attribute carrying whether focus navigation last owned focus. */
+export declare const INPUT_MODALITY_ATTRIBUTE = "data-input-modality";
+/**
+ * Whether the last input came from a pointer, independently of ring visibility.
+ * @returns True after pointer input; false after any key.
+ */
+export declare function pointerModality(): boolean;
+//# sourceMappingURL=input-modality.d.ts.map

package/lib/types/keyboard-composition.d.ts

@@ -0,0 +1,11 @@
+/** Composition lifetime for local keyboard handlers, including a late closing keydown. */
+/**
+ * Observe composition until its closing key is released or consumed.
+ * @param document - document whose input events belong to the caller.
+ * @returns an event guard and a disposer for all listeners.
+ */
+export declare function observeComposition(document: Document): {
+    guards(event: KeyboardEvent): boolean;
+    dispose(): void;
+};
+//# sourceMappingURL=keyboard-composition.d.ts.map

package/lib/types/markdown/CodeBlock.d.ts

@@ -0,0 +1,30 @@
+import type { Ref } from 'react';
+export interface CodeBlockProps {
+    /** The source text, rendered verbatim (trailing newline trimmed for display). */
+    code: string;
+    /** Grammar hint (markdown fence info string or a fixed caller id); unknown = plain. */
+    lang?: string | undefined;
+    /**
+     * The code is still growing (a streaming markdown fence): highlight through
+     * a per-instance {@link StreamingHighlightSession}, which re-tokenizes only
+     * appended text and keeps completed line groups (and DOM) untouched. The
+     * caller must keep the component instance stable across growth (a
+     * stream-stable React key); an unchanged streamed fence also retains that
+     * tree when it settles. Cold settled callers get shiki's HTML.
+     */
+    streaming?: boolean | undefined;
+    /** Extra class merged onto the wrapper (callers position; this component draws). */
+    className?: string | undefined;
+    /** Ref for the stable source-content wrapper, for owners that use it as a scrollport. */
+    contentRef?: Ref<HTMLDivElement> | undefined;
+    /** Show a numbered gutter without adding numbers to copied source. Defaults to false. */
+    lineNumbers?: boolean | undefined;
+    /** Show the language and copy header; false when the caller supplies a toolbar. Defaults to true. */
+    showHeader?: boolean | undefined;
+    /** Copy-button idle label; the owner passes localized copy (this package is cordis-free, so copy arrives via props). */
+    copyLabel: string;
+    /** Copy-button label during the post-copy confirmation window. */
+    copiedLabel: string;
+}
+export declare function CodeBlock({ code, lang, streaming, className, contentRef, lineNumbers, showHeader, copyLabel, copiedLabel, }: CodeBlockProps): import("react").JSX.Element;
+//# sourceMappingURL=CodeBlock.d.ts.map

package/lib/types/markdown/JsonBlock.d.ts

@@ -0,0 +1,8 @@
+export declare function JsonBlock({ label, payload, defaultOpen, truncatedLabel }: {
+    label: string;
+    payload: unknown;
+    defaultOpen?: boolean;
+    /** Footer appended when the body exceeds the char cap, given the full length (this package is cordis-free, so copy arrives via props). */
+    truncatedLabel: (total: number) => string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=JsonBlock.d.ts.map

package/lib/types/markdown/MarkdownDelegate.d.ts

@@ -0,0 +1,46 @@
+import type { ReactNode } from 'react';
+import type { ImageLightboxLabels } from '../ImageLightbox.tsx';
+/**
+ * Handle one sanitized absolute HTTP(S) URL selected from Markdown.
+ * @param href - destination URL.
+ */
+export type MarkdownExternalLinkHandler = (href: string) => void;
+/** Navigation capabilities supplied by the nearest Markdown owner. */
+export interface MarkdownDelegate {
+    /** Image previews for decoded local paths in this owner's workspace. */
+    readonly fileImages?: {
+        resolve: (path: string) => string | undefined;
+        labels: ImageLightboxLabels & {
+            open: string;
+            loading: string;
+            failed: string;
+        };
+    } | undefined;
+    /** Ordinary HTTP(S) activation; absent handlers retain native anchor behavior. */
+    readonly openExternalLink?: MarkdownExternalLinkHandler | undefined;
+    /**
+     * Open a decoded local destination from settled Markdown; absent handlers leave plain text.
+     * @param path - Absolute or workspace-relative file path.
+     * @param options - First line to reveal when the destination specifies a line or range.
+     */
+    readonly openFile?: ((path: string, options?: {
+        line?: number;
+    }) => void) | undefined;
+}
+/** Props for one Markdown navigation scope. */
+export interface MarkdownDelegateProviderProps extends MarkdownDelegate {
+    readonly children: ReactNode;
+}
+/**
+ * Scope Markdown navigation without threading callbacks through renderers.
+ * Nested providers replace the enclosing capabilities. Handler changes reach cached links.
+ * @param props - Child tree and its file and HTTP(S) link handlers.
+ * @returns the scoped child tree.
+ */
+export declare function MarkdownDelegateProvider({ children, openExternalLink, openFile, fileImages, }: MarkdownDelegateProviderProps): ReactNode;
+/**
+ * Read the nearest Markdown navigation capabilities.
+ * @returns Owner callbacks, or an empty delegate outside a provider.
+ */
+export declare function useMarkdownDelegate(): MarkdownDelegate;
+//# sourceMappingURL=MarkdownDelegate.d.ts.map

package/lib/types/markdown/MarkdownText.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Untrusted assistant-Markdown renderer over the direct mdast pipeline:
+ * `parse.ts` grammars, the incremental streaming parser, and `render.tsx`.
+ * While a message streams, all but the trailing two blocks freeze as cached
+ * React elements and only the source tail behind them re-parses per chunk,
+ * so per-chunk work tracks the tail size instead of the whole reply. Frozen
+ * blocks keep their source-offset keys when they cross the freeze boundary,
+ * so React reconciles instead of remounting. Known deviation while
+ * streaming: a reference-style link or footnote whose definition sits on the
+ * other side of the freeze boundary renders literally until the settled
+ * full parse self-heals it.
+ */
+import type { MarkdownFileMentions, MarkdownHtmlRenderer, MarkdownLabels, MarkdownPathImages } from './render.tsx';
+import 'katex/dist/katex.min.css';
+export type { MarkdownCodeLabels, MarkdownFileMentions, MarkdownHtmlRenderer, MarkdownLabels, MarkdownPathImages } from './render.tsx';
+/**
+ * Render untrusted assistant-authored Markdown as semantic React elements.
+ * @param props - Markdown source text preserved by the session projection;
+ * `streaming` parses incrementally across chunks and highlights fences as
+ * they grow (each fence re-tokenizes only appended text; TeX stays literal
+ * until the finalize swap so incomplete formulae never flash errors);
+ * `labels` forwards localized fence and footnote chrome — pass a
+ * reference-stable object (memoized per locale revision), because a new
+ * identity discards the streaming render cache mid-message. `fileMentions`
+ * links inline-code tokens its resolver recognizes as real files, and
+ * `pathImages` rewrites image destinations that are local file paths into
+ * displayable URLs its resolver vouches for. Those two vocabularies are the
+ * single streaming gate — they apply to settled renders only, because a
+ * streaming message's vocabulary is not final and frozen cached elements
+ * must not bake in handlers that could go stale. `html` renders authored raw
+ * HTML through the owner's own sanitizer; without it the runs stay literal
+ * text, and it joins `labels` in the streaming cache identity because frozen
+ * elements bake it in. A surrounding
+ * `MarkdownDelegateProvider` can delegate ordinary HTTP(S) activation while
+ * modified clicks retain native behavior. `variant="compact"` uses secondary
+ * text sizing, uniform bold headings, and tight block spacing; the default
+ * `body` variant uses the full document typography.
+ * The provider's `openFile` enables local Markdown links in settled messages,
+ * including `#L24` and `#L24-L30` destinations (ranges open at their first line).
+ * @returns A GFM document with TeX math rendered through KaTeX; raw HTML
+ * stays literal unless `html` supplies a renderer, and unsafe protocols are
+ * disabled. Local links without an opener remain text; absolute HTTP(S)
+ * images render directly.
+ */
+export declare const MarkdownText: import("react").MemoExoticComponent<({ text, streaming, labels, fileMentions, pathImages, html, variant, }: {
+    text: string;
+    streaming?: boolean;
+    labels: MarkdownLabels;
+    fileMentions?: MarkdownFileMentions | undefined;
+    pathImages?: MarkdownPathImages | undefined;
+    html?: MarkdownHtmlRenderer | undefined;
+    variant?: "body" | "compact";
+}) => import("react").JSX.Element>;
+//# sourceMappingURL=MarkdownText.d.ts.map

package/lib/types/markdown/cjkFriendlyStrong.d.ts

@@ -0,0 +1,9 @@
+/** Let asterisk strong emphasis close after punctuation when CJK prose continues without whitespace. */
+import type { Extension } from 'micromark-util-types';
+/**
+ * Extend CommonMark asterisk strong emphasis for punctuation-delimited CJK
+ * prose, as a micromark syntax extension for `fromMarkdown`.
+ * @returns The micromark syntax extension.
+ */
+export declare function cjkFriendlyStrong(): Extension;
+//# sourceMappingURL=cjkFriendlyStrong.d.ts.map

package/lib/types/markdown/file-link.d.ts

@@ -0,0 +1,13 @@
+/** Local Markdown destinations accepted by the file-preview callback. */
+/**
+ * Decode a file destination and its optional GitHub-style line fragment.
+ * Literal `?` and `#` in filenames must be percent-encoded.
+ * @param value - Parsed Markdown link destination.
+ * @returns A local path and optional first line, or undefined for URLs,
+ * fragment-only links, queries, malformed escapes, or invalid line ranges.
+ */
+export declare function parseFileLink(value: string): {
+    path: string;
+    line?: number;
+} | undefined;
+//# sourceMappingURL=file-link.d.ts.map