@refraction-ui/react 0.16.2 → 0.17.1

package/dist/internal/composer/index.d.ts

@@ -0,0 +1,590 @@
+import { MessageAttachment } from '../conversation/index.js';
+export { MessageAttachment } from '../conversation/index.js';
+
+/**
+ * Public types for the headless chat composer core.
+ *
+ * The composer models a single growing message buffer (flat string + selection)
+ * with inline triggers (@mention, /command, :emoji:, #tag, custom), committed
+ * atomic tokens, staged attachments, and one optimistic submit. Framework
+ * adapters (React/Astro/Flutter) wrap this contract without re-implementing
+ * any behavior.
+ */
+
+/** Where a trigger symbol is allowed to arm. */
+type ComposerTriggerScope = 'anywhere' | 'startOfLine' | 'startOfMessage';
+/** A candidate shown in the suggestion menu for an armed trigger. */
+interface ComposerCandidate {
+    id: string;
+    display: string;
+    subtitle?: string;
+    metadata?: Record<string, unknown>;
+}
+type ComposerTriggerResolver = (query: string) => ComposerCandidate[] | Promise<ComposerCandidate[]>;
+/**
+ * A trigger is configuration, not code — the engine is symbol-agnostic and
+ * never special-cases '@' / '/' / ':' in control flow.
+ */
+interface ComposerTrigger {
+    id: string;
+    /** Trigger symbol; any length ('@', '/', '#', '!!'). */
+    symbol: string;
+    /** Default 'anywhere'. Slash-style commands use 'startOfMessage'. */
+    scope?: ComposerTriggerScope;
+    /** Extra validation for the query; a violating query closes the trigger. */
+    queryPattern?: RegExp;
+    /** Queries longer than this silently cancel the trigger. Default 40. */
+    maxQueryLength?: number;
+    /** Default true. '#'-style triggers set false so '#weekend trip' stays armed. */
+    closeOnSpace?: boolean;
+    /** Default false. Trades away email/URL protection — must be justified. */
+    allowMidWord?: boolean;
+    /** Additional boundary characters allowed before the symbol (e.g. '(' or '"'). */
+    extraBoundaryChars?: string[];
+    /** Resolver debounce in ms. Default 0 (sync/local resolvers). */
+    debounceMs?: number;
+    /** Visible slice size for the adapter's menu. Default 6. */
+    maxVisibleResults?: number;
+    /** Whether ArrowUp/Down wrap around the ends. Default true. */
+    wrapNavigation?: boolean;
+    /**
+     * Builds the committed token's display text. Defaults to `symbol + display`
+     * ('@Jordan Lee'); the emoji recipe returns the unicode itself.
+     */
+    toDisplay?: (candidate: ComposerCandidate) => string;
+    resolve: ComposerTriggerResolver;
+}
+/** A committed, atomic inline unit (identity + frozen display). */
+interface ComposerToken {
+    triggerId: string;
+    symbol: string;
+    id: string;
+    label: string;
+    display: string;
+    metadata?: Record<string, unknown>;
+}
+/** A token placed in the value, with its live UTF-16 range. */
+interface PlacedToken extends ComposerToken {
+    start: number;
+    end: number;
+}
+/** Structured output token with derived UTF-16 offsets into plainText. */
+interface ResolvedToken {
+    type: string;
+    id: string;
+    display: string;
+    start: number;
+    end: number;
+}
+type ComposerAttachmentKind = 'text' | 'image' | 'video' | 'audio' | 'file';
+type ComposerAttachmentStatus = 'pending' | 'uploading' | 'ready' | 'error';
+interface ComposerAttachment {
+    id: string;
+    kind: ComposerAttachmentKind;
+    name: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    previewUrl?: string;
+    status: ComposerAttachmentStatus;
+    /** 0..1 while uploading. */
+    progress?: number;
+    errorMessage?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Input to `addAttachment` — id/status are core-owned defaults. */
+type ComposerAttachmentDraft = Omit<ComposerAttachment, 'id' | 'status'> & {
+    id?: string;
+    status?: ComposerAttachmentStatus;
+};
+interface ComposerSubmission {
+    /** Trimmed message text with token displays inlined. */
+    plainText: string;
+    tokens: ResolvedToken[];
+    attachments: ComposerAttachment[];
+    replyToMessageId?: string;
+    /** Present when submitting from edit mode. */
+    editingMessageId?: string;
+}
+interface ComposerOutput {
+    plainText: string;
+    tokens: ResolvedToken[];
+}
+interface ComposerSelection {
+    start: number;
+    end: number;
+}
+interface ActiveTriggerState {
+    triggerId: string;
+    symbol: string;
+    symbolStart: number;
+    caret: number;
+    query: string;
+}
+interface SuggestionState {
+    isOpen: boolean;
+    /** Full result list (overflow intact). */
+    items: ComposerCandidate[];
+    /** `items` sliced to the trigger's maxVisibleResults for the adapter. */
+    visibleItems: ComposerCandidate[];
+    activeIndex: number;
+    loading: boolean;
+    error: string | null;
+    /** Monotonic id of the latest resolve request (staleness guard). */
+    requestToken: number;
+}
+interface CounterState {
+    /** Visible once remaining budget is within 20% of maxLength. */
+    visible: boolean;
+    /** Remaining grapheme budget; null without a maxLength. */
+    remaining: number | null;
+    overLimit: boolean;
+}
+type ComposerMode = 'compose' | 'edit';
+interface ComposerState {
+    value: string;
+    selection: ComposerSelection;
+    isComposing: boolean;
+    isBusy: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    isEmpty: boolean;
+    canSend: boolean;
+    error: string | null;
+    attachments: ComposerAttachment[];
+    tokens: PlacedToken[];
+    activeTrigger: ActiveTriggerState | null;
+    suggestion: SuggestionState;
+    counter: CounterState;
+    mode: ComposerMode;
+    editingMessageId?: string;
+}
+interface ComposerValidationResult {
+    isValid: boolean;
+    reason?: string;
+}
+type ComposerValidator = (plainText: string, tokens: ResolvedToken[]) => ComposerValidationResult;
+/** Persisted draft snapshot (attachments by id only — blobs are host-owned). */
+interface ComposerDraft {
+    value: string;
+    tokens: PlacedToken[];
+    attachmentIds: string[];
+    updatedAt: number;
+}
+/** Injected persistence seam; the core ships only an in-memory default. */
+interface ComposerDraftStore {
+    read(key: string): ComposerDraft | null;
+    write(key: string, draft: ComposerDraft): void;
+    clear(key: string): void;
+}
+type ComposerEvent = {
+    type: 'paste-trimmed';
+} | {
+    type: 'insert-rejected';
+    reason: 'max-length' | 'composing' | 'disabled' | 'read-only';
+} | {
+    type: 'edit-rejected';
+    reason: 'inside-token';
+} | {
+    type: 'attachment-rejected';
+    reason: 'max-attachments' | 'max-size' | 'not-accepted';
+    name: string;
+    detail?: string;
+} | {
+    type: 'typing';
+};
+interface ComposerConfig {
+    initialValue?: string;
+    /** Tokens present in initialValue (e.g. when re-opening a draft the host owns). */
+    initialTokens?: PlacedToken[];
+    /** Grapheme-cluster budget (not UTF-16 units). */
+    maxLength?: number;
+    maxAttachments?: number;
+    /** Per-attachment size gate; larger drafts are rejected with an event. */
+    maxAttachmentSizeBytes?: number;
+    /** Predicate gate; return false or a reason string to reject a draft. */
+    acceptAttachment?: (draft: ComposerAttachmentDraft) => boolean | string;
+    minLines?: number;
+    maxLines?: number;
+    triggers?: ComposerTrigger[];
+    validator?: ComposerValidator;
+    draftStore?: ComposerDraftStore;
+    draftKey?: string;
+    /** Draft autosave debounce. Default 400ms. */
+    draftDebounceMs?: number;
+    /** Leading-edge throttle for the 'typing' event. Default 3000ms. */
+    typingSignalIntervalMs?: number;
+    replyToMessageId?: string;
+    /** Injected clock — the core never calls Date.now() in logic paths. */
+    now?: () => number;
+    /** Injected id factory — the core never calls Math.random(). */
+    generateId?: (prefix?: string) => string;
+    /** Notice channel ('paste-trimmed', 'attachment-rejected', 'typing', …). */
+    onEvent?: (event: ComposerEvent) => void;
+}
+/** Outcome of a physical Enter press routed through the core. */
+type EnterResult = 'submitted' | 'newline' | 'committed-suggestion' | 'noop';
+interface ComposerAPI {
+    getState(): ComposerState;
+    subscribe(listener: (state: ComposerState) => void): () => void;
+    /**
+     * The adapter's input path: full new text + selection after a user edit.
+     * Pass `{ programmatic: true }` for host-driven writes (suppresses the
+     * typing signal).
+     */
+    setValue(text: string, selection?: ComposerSelection, opts?: {
+        programmatic?: boolean;
+    }): void;
+    /** Caret/selection move without a text change (allowed while readOnly). */
+    setSelection(selection: ComposerSelection): void;
+    insertTextAtCursor(text: string): void;
+    setComposing(isComposing: boolean): void;
+    /** Routes a physical Enter; the return value tells the adapter whether to preventDefault. */
+    applyEnter(opts: {
+        shiftPressed: boolean;
+    }): EnterResult;
+    moveSuggestionNext(): void;
+    moveSuggestionPrevious(): void;
+    /** Pointer hover — last-input-wins with the keyboard. */
+    setSuggestionActiveIndex(index: number): void;
+    applySuggestion(index?: number): void;
+    /** Escape-style dismissal: closes now and marks the occurrence dismissed. */
+    dismissSuggestion(): void;
+    /** Blur-style dismissal: closes after a short grace so a click can land. */
+    dismissSuggestionDeferred(): void;
+    retrySuggestions(): void;
+    addAttachment(draft: ComposerAttachmentDraft): string | null;
+    updateAttachment(id: string, patch: Partial<Omit<ComposerAttachment, 'id'>>): void;
+    removeAttachment(id: string): void;
+    setBusy(busy: boolean): void;
+    setError(error: string | null): void;
+    setDisabled(disabled: boolean): void;
+    setReadOnly(readOnly: boolean): void;
+    beginEdit(args: {
+        value: string;
+        tokens?: PlacedToken[];
+        messageId: string;
+    }): void;
+    cancelEdit(): void;
+    /** Clipboard seam: returns the selected display text. */
+    copySelection(): string;
+    /** Clipboard seam: removes the selection, retaining token identity for same-instance paste. */
+    cutSelection(): string;
+    /** Clipboard seam: plain-text insert at caret (clamped); restores tokens only for a same-instance cut. */
+    pasteText(text: string): void;
+    submit(): ComposerSubmission | null;
+    reset(): void;
+    serialize(): ComposerOutput;
+    destroy(): void;
+}
+/**
+ * Bridge to the conversation layer: a ready composer attachment mapped onto
+ * `@refraction-ui/conversation`'s wire shape.
+ */
+declare function toMessageAttachment(attachment: ComposerAttachment): MessageAttachment;
+
+/**
+ * Grapheme-cluster utilities.
+ *
+ * Length limits and clamping must never bisect a user-perceived character —
+ * a 👨‍👩‍👧‍👦 ZWJ family emoji is 11 UTF-16 units but one cluster. We use
+ * `Intl.Segmenter` when available; the fallback treats each code point as a
+ * cluster (coarser, but it never splits a surrogate pair).
+ */
+/** Count of grapheme clusters (code points in the fallback), never UTF-16 units. */
+declare function graphemeLength(text: string): number;
+/**
+ * Clamp `text` to at most `max` grapheme clusters. A cluster that would cross
+ * the limit is rejected whole — the result is always a valid cluster boundary.
+ */
+declare function clampGraphemes(text: string, max: number): string;
+/** Whether `offset` sits on a grapheme-cluster boundary of `text`. */
+declare function isGraphemeBoundary(text: string, offset: number): boolean;
+
+/**
+ * Pure composer rules — the single source of truth shared by the enable-check,
+ * the Enter handler, and the submitted payload (so they can never disagree).
+ */
+
+/** One trim shared by the enable-check AND the sent payload. */
+declare function payloadFor(raw: string): string;
+interface CanSendArgs {
+    text: string;
+    attachments?: readonly unknown[];
+    disabled?: boolean;
+    readOnly?: boolean;
+    busy?: boolean;
+}
+/**
+ * Send is derived from BOTH trimmed text and attachments — an attachments-only
+ * message is valid; a whitespace-only message never is.
+ */
+declare function canSend({ text, attachments, disabled, readOnly, busy }: CanSendArgs): boolean;
+/**
+ * The platform-matrix resolver: physical Enter sends unless Shift is held or
+ * an IME composition is active (composing always wins — Enter confirms the
+ * candidate, never submits).
+ */
+declare function shouldSubmitOnEnter({ shiftPressed, isComposing, }: {
+    shiftPressed: boolean;
+    isComposing: boolean;
+}): boolean;
+/** The counter surfaces once remaining budget is within this fraction of maxLength. */
+declare const COUNTER_VISIBLE_FRACTION = 0.2;
+/**
+ * Counter math over grapheme budget. The counter is confirmatory, not the
+ * enforcement mechanism (clamping at the insert boundary prevents overflow).
+ */
+declare function computeCounter(text: string, maxLength: number | undefined): CounterState;
+
+/**
+ * Symbol-agnostic trigger detection (R10–R12).
+ *
+ * Detection runs once per mutation, scanning backward from the caret within a
+ * bounded window — cost is independent of how much text precedes the trigger.
+ * The simple single-char/anywhere case delegates to rich-editor's shared
+ * `detectTriggerInText` so the boundary rules live in exactly one place; the
+ * general path (multi-char symbols, scopes, extra boundary chars,
+ * closeOnSpace=false) layers on top of the same candidate/validation split.
+ */
+
+declare const DEFAULT_MAX_QUERY_LENGTH = 40;
+declare const DEFAULT_MAX_VISIBLE_RESULTS = 6;
+/**
+ * UTF-16 budget per grapheme when sizing the backward-scan window. The widest
+ * common cluster (ZWJ family emoji) is 11 units; 16 leaves headroom without
+ * unbounding the scan.
+ */
+declare const SCAN_UNITS_PER_GRAPHEME = 16;
+interface ResolvedTrigger {
+    id: string;
+    symbol: string;
+    scope: ComposerTriggerScope;
+    queryPattern: RegExp | null;
+    maxQueryLength: number;
+    closeOnSpace: boolean;
+    allowMidWord: boolean;
+    extraBoundaryChars: readonly string[];
+    debounceMs: number;
+    maxVisibleResults: number;
+    wrapNavigation: boolean;
+    toDisplay: (candidate: ComposerCandidate) => string;
+    resolve: ComposerTrigger['resolve'];
+}
+declare function resolveTriggerConfig(trigger: ComposerTrigger): ResolvedTrigger;
+/** UTF-16 size of the backward-scan window for a trigger (exported for tests). */
+declare function scanWindowFor(trigger: ResolvedTrigger): number;
+interface TriggerMatch {
+    trigger: ResolvedTrigger;
+    symbolStart: number;
+    caret: number;
+    query: string;
+}
+/** An occurrence dismissed via Escape — never re-arms until the symbol is retyped. */
+interface DismissedOccurrence {
+    triggerId: string;
+    symbolStart: number;
+}
+interface TokenRange {
+    start: number;
+    end: number;
+}
+interface DetectTriggerArgs {
+    text: string;
+    caret: number;
+    triggers: readonly ResolvedTrigger[];
+    isComposing?: boolean;
+    dismissed?: readonly DismissedOccurrence[];
+    tokenRanges?: readonly TokenRange[];
+}
+/**
+ * Backward-scan detection from the caret. Returns the nearest live trigger
+ * (only the last unescaped occurrence before the caret can be live), or null.
+ * Suspended entirely while an IME composition is active.
+ */
+declare function detectActiveTrigger({ text, caret, triggers, isComposing, dismissed, tokenRanges, }: DetectTriggerArgs): TriggerMatch | null;
+
+/**
+ * Suggestion menu state (R13, R14): debounced async resolution with a
+ * monotonic requestToken staleness guard, delayed loading state, empty/error
+ * states with retry, a per-trigger circuit breaker, and keyboard navigation.
+ *
+ * Timers are plain setTimeout/clearTimeout — cancelable and deterministic
+ * under vitest fake timers; the controller never touches DOM globals.
+ */
+
+/** Loading UI appears only if the resolver is still pending after this long. */
+declare const LOADING_DELAY_MS = 120;
+/** Deferred (blur) dismissal grace so a pointer tap on a row can land first. */
+declare const DISMISS_GRACE_MS = 120;
+/** Consecutive resolver throws for one trigger before remote calls stop for the session. */
+declare const CIRCUIT_BREAKER_THRESHOLD = 2;
+declare const CLOSED_SUGGESTION_STATE: SuggestionState;
+interface SuggestionController {
+    readonly state: SuggestionState;
+    /** Reconcile with the current trigger match after any mutation/caret move. */
+    sync(match: TriggerMatch | null): void;
+    moveNext(): void;
+    movePrevious(): void;
+    setActiveIndex(index: number): void;
+    retry(): void;
+    /** Close after a grace period (blur); a commit during the grace cancels it. */
+    dismissDeferred(onClosed: () => void): void;
+    cancelDeferredDismiss(): void;
+    /** Close immediately and invalidate any in-flight resolution. */
+    close(): void;
+    isTripped(triggerId: string): boolean;
+    destroy(): void;
+}
+declare function createSuggestionController({ emit }: {
+    emit: () => void;
+}): SuggestionController;
+
+/**
+ * Token bookkeeping over the flat string (R15–R18).
+ *
+ * Committed tokens are atomic: an edit touching part of a token removes the
+ * whole token; an insertion strictly inside a token is rejected; the caret
+ * never rests strictly inside a token. Every function here is pure — the
+ * composer owns the state and feeds it through these rules on each mutation.
+ */
+
+interface TextEdit {
+    /** Offset where old and new text diverge. */
+    start: number;
+    /** End of the replaced range in the OLD text. */
+    oldEnd: number;
+    /** End of the inserted range in the NEW text. */
+    newEnd: number;
+}
+/** Minimal single-span diff via common prefix/suffix. Null when texts are equal. */
+declare function diffEdit(oldText: string, newText: string): TextEdit | null;
+interface AppliedEdit {
+    value: string;
+    tokens: PlacedToken[];
+    selection: ComposerSelection;
+    /** Set when an insertion strictly inside a token was rejected (value restored). */
+    rejected: boolean;
+    /** True when maxLength clamping dropped part of the inserted text. */
+    trimmed: boolean;
+    removedTokens: PlacedToken[];
+    /** The edit as actually applied to the old value (post token expansion), or null. */
+    edit: TextEdit | null;
+}
+interface ApplyValueEditArgs {
+    oldValue: string;
+    newValue: string;
+    tokens: readonly PlacedToken[];
+    newSelection: ComposerSelection;
+    /** Grapheme budget; the INSERTED slice is clamped to fit, never bisecting a cluster. */
+    maxLength?: number;
+}
+/**
+ * Reconcile a raw text edit (as reported by the adapter's input) with the
+ * committed token list. Deletions touching part of a token expand to the whole
+ * token; insertions strictly inside a token are rejected outright.
+ */
+declare function applyValueEdit({ oldValue, newValue, tokens, newSelection, maxLength, }: ApplyValueEditArgs): AppliedEdit;
+/**
+ * Snap a selection so no endpoint rests strictly inside a token. A collapsed
+ * caret snaps in the direction of travel (so arrow keys skip a token as one
+ * unit); a range expands outward to the full token bounds.
+ */
+declare function snapSelectionToTokens(tokens: readonly PlacedToken[], selection: ComposerSelection, previous?: ComposerSelection): ComposerSelection;
+/** Expand a range outward so it covers any partially-included token whole. */
+declare function expandRangeOverTokens(tokens: readonly PlacedToken[], range: ComposerSelection): ComposerSelection;
+interface CommitTokenArgs {
+    value: string;
+    tokens: readonly PlacedToken[];
+    /** Replaced range: `[start, end)` — symbol + query for a trigger commit. */
+    start: number;
+    end: number;
+    token: ComposerToken;
+}
+interface CommitTokenResult {
+    value: string;
+    tokens: PlacedToken[];
+    selection: ComposerSelection;
+}
+/** Replace `[start, end)` with the token's display in one atomic transaction. */
+declare function commitTokenAt({ value, tokens, start, end, token }: CommitTokenArgs): CommitTokenResult;
+/**
+ * Structured output: plainText inlines every display; ranges are derived and
+ * guaranteed in sync (`plainText.substring(start, end) === display`).
+ */
+declare function serializeTokens(value: string, tokens: readonly PlacedToken[]): ComposerOutput;
+interface TypedEmojiHit {
+    shortcode: string;
+    unicode: string;
+    /** Offset of the opening colon. */
+    start: number;
+}
+/**
+ * Detect a just-completed `:shortcode:` immediately before the caret using
+ * rich-editor's EMOJI_MAP (via detectEmojiShortcode). Unknown shortcodes stay
+ * literal; the composer converts a hit into a committed token without the
+ * menu ever opening.
+ */
+declare function detectTypedEmoji(value: string, caret: number): TypedEmojiHit | null;
+
+/**
+ * `createComposer(config)` — the headless composer core.
+ *
+ * Owns the flat value + selection, committed tokens, staged attachments,
+ * trigger/suggestion lifecycle, drafts, and the optimistic submit. Pure of
+ * DOM/browser globals: `now`/`generateId` are injected (defaults live only at
+ * this boundary, matching the other cores in the repo), so the same instance
+ * is hydration-deterministic and portable to any framework adapter.
+ */
+
+declare const DEFAULT_DRAFT_DEBOUNCE_MS = 400;
+declare const DEFAULT_TYPING_SIGNAL_INTERVAL_MS = 3000;
+declare const DEFAULT_MIN_LINES = 1;
+declare const DEFAULT_MAX_LINES = 6;
+declare function createComposer(config?: ComposerConfig): ComposerAPI;
+
+/**
+ * cva style variants for the composer surface, pill, tray, and menu.
+ * Boolean-ish variants use string 'true'/'false' keys per repo convention
+ * (raw booleans fail the dts build).
+ */
+/** Outer surface (the rounded card wrapping tray + field + action row). */
+declare const composerSurfaceVariants: (props?: ({
+    disabled?: "true" | "false" | undefined;
+    error?: "true" | "false" | undefined;
+} & {
+    className?: string;
+}) | undefined) => string;
+/** The text field itself (borderless inside the surface). */
+declare const composerFieldClass = "block w-full resize-none bg-transparent px-3.5 py-3 text-sm placeholder:text-muted-foreground focus:outline-none";
+/** Attachment tray above the field, inside the dock. */
+declare const composerTrayClass = "flex flex-wrap gap-2 px-3 pt-3";
+/** A single attachment chip. */
+declare const composerAttachmentChipVariants: (props?: ({
+    status?: "pending" | "uploading" | "ready" | "error" | undefined;
+} & {
+    className?: string;
+}) | undefined) => string;
+/** A committed inline token pill rendered by adapters over the flat string. */
+declare const composerTokenPillClass = "rounded bg-accent/40 px-0.5 text-accent-foreground";
+/** The caret-anchored suggestion menu. */
+declare const composerMenuClass = "z-20 w-72 overflow-hidden rounded-xl border border-border bg-popover shadow-lg";
+/** A suggestion row; `active` follows keyboard/pointer last-input-wins. */
+declare const composerMenuItemVariants: (props?: ({
+    active?: "true" | "false" | undefined;
+} & {
+    className?: string;
+}) | undefined) => string;
+/** Character counter; switches to the attention treatment at/over the limit. */
+declare const composerCounterVariants: (props?: ({
+    overLimit?: "true" | "false" | undefined;
+} & {
+    className?: string;
+}) | undefined) => string;
+/** Primary action (send ⇄ stop swap driven by `{hasText, canSend, isBusy}`). */
+declare const composerPrimaryActionVariants: (props?: ({
+    enabled?: "true" | "false" | undefined;
+} & {
+    className?: string;
+}) | undefined) => string;
+
+export { type ActiveTriggerState, type AppliedEdit, type ApplyValueEditArgs, CIRCUIT_BREAKER_THRESHOLD, CLOSED_SUGGESTION_STATE, COUNTER_VISIBLE_FRACTION, type CanSendArgs, type CommitTokenArgs, type CommitTokenResult, type ComposerAPI, type ComposerAttachment, type ComposerAttachmentDraft, type ComposerAttachmentKind, type ComposerAttachmentStatus, type ComposerCandidate, type ComposerConfig, type ComposerDraft, type ComposerDraftStore, type ComposerEvent, type ComposerMode, type ComposerOutput, type ComposerSelection, type ComposerState, type ComposerSubmission, type ComposerToken, type ComposerTrigger, type ComposerTriggerResolver, type ComposerTriggerScope, type ComposerValidationResult, type ComposerValidator, type CounterState, DEFAULT_DRAFT_DEBOUNCE_MS, DEFAULT_MAX_LINES, DEFAULT_MAX_QUERY_LENGTH, DEFAULT_MAX_VISIBLE_RESULTS, DEFAULT_MIN_LINES, DEFAULT_TYPING_SIGNAL_INTERVAL_MS, DISMISS_GRACE_MS, type DetectTriggerArgs, type DismissedOccurrence, type EnterResult, LOADING_DELAY_MS, type PlacedToken, type ResolvedToken, type ResolvedTrigger, SCAN_UNITS_PER_GRAPHEME, type SuggestionController, type SuggestionState, type TextEdit, type TokenRange, type TriggerMatch, type TypedEmojiHit, applyValueEdit, canSend, clampGraphemes, commitTokenAt, composerAttachmentChipVariants, composerCounterVariants, composerFieldClass, composerMenuClass, composerMenuItemVariants, composerPrimaryActionVariants, composerSurfaceVariants, composerTokenPillClass, composerTrayClass, computeCounter, createComposer, createSuggestionController, detectActiveTrigger, detectTypedEmoji, diffEdit, expandRangeOverTokens, graphemeLength, isGraphemeBoundary, payloadFor, resolveTriggerConfig, scanWindowFor, serializeTokens, shouldSubmitOnEnter, snapSelectionToTokens, toMessageAttachment };