@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/vue/markdown/types.d.ts

@@ -0,0 +1,59 @@
+import type { Style } from "../../core/types.js";
+export type TuiMarkdownNode = Readonly<{
+    type: string;
+    raw?: string;
+    children?: readonly TuiMarkdownNode[];
+    [key: string]: unknown;
+}>;
+export type TuiMarkdownInlineSegment = Readonly<{
+    text: string;
+    style?: Style;
+    hardBreak?: boolean;
+}>;
+export type TuiMarkdownTableCellAlign = "left" | "center" | "right";
+export type TuiMarkdownTableCell = Readonly<{
+    segments: readonly TuiMarkdownInlineSegment[];
+    align?: TuiMarkdownTableCellAlign;
+}>;
+export type TuiMarkdownBlock = Readonly<{
+    type: "inline";
+    key: string;
+    segments: readonly TuiMarkdownInlineSegment[];
+    prefixSegments?: readonly TuiMarkdownInlineSegment[];
+    continuationPrefixSegments?: readonly TuiMarkdownInlineSegment[];
+}> | Readonly<{
+    type: "code_block";
+    key: string;
+    lines: readonly string[];
+    style?: Style;
+    prefixSegments?: readonly TuiMarkdownInlineSegment[];
+    continuationPrefixSegments?: readonly TuiMarkdownInlineSegment[];
+}> | Readonly<{
+    type: "thematic_break";
+    key: string;
+    char?: string;
+    style?: Style;
+    prefixSegments?: readonly TuiMarkdownInlineSegment[];
+}> | Readonly<{
+    type: "table";
+    key: string;
+    header: readonly TuiMarkdownTableCell[];
+    rows: readonly (readonly TuiMarkdownTableCell[])[];
+    borderStyle?: Style;
+    prefixSegments?: readonly TuiMarkdownInlineSegment[];
+}> | Readonly<{
+    type: "blank";
+    key: string;
+}>;
+export type TuiMarkdownVisualSegment = Readonly<{
+    text: string;
+    style?: Style;
+    cells: number;
+}>;
+export type TuiMarkdownVisualRow = Readonly<{
+    key: string;
+    blockKey: string;
+    rowInBlock: number;
+    plainText: string;
+    segments: readonly TuiMarkdownVisualSegment[];
+}>;

package/dist/vue/overlay.d.ts

@@ -0,0 +1,27 @@
+export type TOverlayPlacement = "center" | "top" | "bottom" | "left" | "right" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export type TOverlayRect = Readonly<{
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}>;
+export type TOverlayPlacementOptions = Readonly<{
+    viewport: Pick<TOverlayRect, "w" | "h">;
+    size: Pick<TOverlayRect, "w" | "h">;
+    placement?: TOverlayPlacement;
+    offsetX?: number;
+    offsetY?: number;
+    anchor?: TOverlayRect;
+    shift?: boolean;
+}>;
+export declare function resolveOverlayPlacement(opts: TOverlayPlacementOptions): {
+    x: number;
+    y: number;
+};
+export type TOverlayFocusStack = {
+    push: (id: string | null) => void;
+    pop: () => string | null;
+    peek: () => string | null;
+    clear: () => void;
+};
+export declare function createOverlayFocusStack(): TOverlayFocusStack;

package/dist/vue/render/context.d.ts

@@ -0,0 +1,3 @@
+import type { InjectionKey, Ref } from "vue";
+import type { RenderStack } from "./render-manager.js";
+export declare const RenderStackKey: InjectionKey<Ref<RenderStack>>;

package/dist/vue/render/render-manager.d.ts

@@ -0,0 +1,94 @@
+import type { TerminalRenderPlane, TerminalRenderPlanes } from "../../core/render-plane.js";
+import type { Terminal } from "../../core/types.js";
+import type { WidthProvider } from "../../core/buffer/width.js";
+import { type CreateTuiProfilerOptions } from "../../observability/tui-profiler.js";
+export type RenderRect = Readonly<{
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}>;
+export type RenderStack = Readonly<{
+    id: string;
+    parent: RenderStack | null;
+    zIndex: number;
+    order: number;
+}>;
+export type RenderNode = Readonly<{
+    id: string;
+    stack: RenderStack;
+    plane: TerminalRenderPlane;
+    zIndex: number;
+    order: number;
+    rect: RenderRect | null;
+    rectY0: number;
+    rectY1: number;
+    /**
+     * dirtyRows are absolute terminal rows for this node's plane.
+     * Components must ignore rows outside their rect.
+     */
+    paint: (dirtyRows?: readonly number[]) => void;
+}>;
+export type RenderManager = Readonly<{
+    rootStack: RenderStack;
+    createStack: (parent: RenderStack, zIndex: number) => RenderStack;
+    invalidatePlane: (plane: TerminalRenderPlane) => void;
+    /**
+     * Dangerous escape hatch: shifts whole terminal rows for the target plane, not a
+     * component-local region. Only call when the active renderer consumes terminal
+     * scrollOperations or when the caller repaints the whole affected viewport.
+     */
+    unsafeScrollPlaneRows: (plane: TerminalRenderPlane, startY: number, endY: number, delta: number) => void;
+    register: (node: {
+        stack: RenderStack;
+        plane?: TerminalRenderPlane;
+        zIndex?: number;
+        rect?: RenderRect | null;
+        paint: (dirtyRows?: readonly number[]) => void;
+    }) => RenderNode;
+    update: (id: string, next: Partial<{
+        stack: RenderStack;
+        plane: TerminalRenderPlane;
+        zIndex: number;
+        rect: RenderRect | null;
+        /**
+         * Consumed synchronously during update() and must not be retained.
+         * Callers may pass scratch arrays for hot-path invalidation.
+         * Rows are absolute terminal Y coordinates for the node's plane.
+         */
+        dirtyRowsHint: readonly number[];
+        paint: (dirtyRows?: readonly number[]) => void;
+    }>) => void;
+    /**
+     * Hot-path dirty row marker for stable nodes. Consumed synchronously and does
+     * not replace the RenderNode object.
+     *
+     * rows are absolute terminal Y coordinates, not local component row offsets.
+     * For rect-bound nodes, rows outside the node rect are ignored.
+     */
+    markDirtyRows: (id: string, rows: readonly number[]) => boolean;
+    unregister: (id: string) => void;
+    render: (options?: {
+        activePlanes?: TerminalRenderPlanes | null;
+    }) => RenderStats | null;
+    dispose: () => void;
+}>;
+export type CreateRenderManagerOptions = Readonly<{
+    profiler?: CreateTuiProfilerOptions;
+    widthProvider?: WidthProvider;
+}>;
+export type RowBucketFallback = Readonly<{
+    plane: TerminalRenderPlane;
+    reason: "dirty-ratio" | "candidate-ratio";
+    dirtyRows: number;
+    planeNodes: number;
+    candidates?: number;
+}>;
+export type RenderStats = Readonly<{
+    rows: number;
+    scannedNodes: number;
+    paintedNodes: number;
+    candidatePlanes: readonly TerminalRenderPlane[];
+    rowBucketFallbacks?: readonly RowBucketFallback[];
+}>;
+export declare function createRenderManager(terminal: Terminal, options?: CreateRenderManagerOptions): RenderManager;

package/dist/vue/router/RouterView.d.ts

@@ -0,0 +1,25 @@
+import type { PropType } from "vue";
+import type { TerminalRouteRecord } from "./types.js";
+export declare const TRouterView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    routes: {
+        type: PropType<TerminalRouteRecord[]>;
+        required: true;
+    };
+    forceRemount: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, (import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps), Readonly<import("vue").ExtractPropTypes<{
+    routes: {
+        type: PropType<TerminalRouteRecord[]>;
+        required: true;
+    };
+    forceRemount: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    forceRemount: boolean;
+}, {}>;

package/dist/vue/router/composables.d.ts

@@ -0,0 +1,4 @@
+import type { ComputedRef } from "vue";
+import type { TerminalRoute, TerminalRouter } from "./types.js";
+export declare function useRouter(): TerminalRouter;
+export declare function useRoute(): ComputedRef<TerminalRoute>;

package/dist/vue/router/context.d.ts

@@ -0,0 +1,4 @@
+import type { InjectionKey, Ref } from "vue";
+import type { TerminalRoute, TerminalRouter } from "./types.js";
+export declare const TerminalRouterKey: InjectionKey<TerminalRouter>;
+export declare const TerminalRouteKey: InjectionKey<Ref<TerminalRoute>>;

package/dist/vue/router/router.d.ts

@@ -0,0 +1,7 @@
+import type { Component } from "vue";
+import type { TerminalRouteLocationRaw, TerminalRouter, TerminalRouteRecord } from "./types.js";
+export declare function createTerminalRouter(options: Readonly<{
+    routes: readonly TerminalRouteRecord[];
+    initialRoute: TerminalRouteLocationRaw;
+}>): TerminalRouter;
+export declare function resolveTerminalRouteComponent(router: TerminalRouter, routes: readonly TerminalRouteRecord[]): Component | null;

package/dist/vue/router/types.d.ts

@@ -0,0 +1,29 @@
+import type { Component } from "vue";
+export type TerminalRoute = Readonly<{
+    name: string;
+    params?: Readonly<Record<string, string>>;
+    meta?: unknown;
+}>;
+export type TerminalRouteRecord = Readonly<{
+    name: string;
+    component: Component;
+    meta?: unknown;
+    onEnter?: (to: TerminalRoute, from: TerminalRoute | null) => void | Promise<void>;
+    onLeave?: (to: TerminalRoute, from: TerminalRoute | null) => void | Promise<void>;
+}>;
+export type TerminalRouteLocationRaw = string | Readonly<{
+    name: string;
+    params?: Record<string, string>;
+}>;
+export type NavigationGuardReturn = void | boolean | TerminalRouteLocationRaw;
+export type NavigationGuard = (to: TerminalRoute, from: TerminalRoute | null) => NavigationGuardReturn | Promise<NavigationGuardReturn>;
+export type TerminalRouter = Readonly<{
+    currentRoute: import("vue").Ref<TerminalRoute>;
+    push: (to: TerminalRouteLocationRaw) => Promise<void>;
+    replace: (to: TerminalRouteLocationRaw) => Promise<void>;
+    back: () => Promise<void>;
+    beforeEach: (guard: NavigationGuard) => () => void;
+    beforeResolve: (guard: NavigationGuard) => () => void;
+    afterEach: (guard: (to: TerminalRoute, from: TerminalRoute | null) => void) => () => void;
+    install: (app: import("vue").App) => void;
+}>;

package/dist/vue/scheduler/frame-mailbox.d.ts

@@ -0,0 +1,55 @@
+import type { TerminalFrameContext, TerminalFrameTaskPriority, TerminalScheduler } from "../context.js";
+import type { FramePerfReason } from "../../observability/frame-perf.js";
+export type FrameMailboxApply<T> = (value: T, ctx: TerminalFrameContext, meta: {
+    queued: number;
+    dropped: number;
+}) => void;
+export type FrameMailboxOptions<T> = Readonly<{
+    scheduler: TerminalScheduler;
+    id: string | (() => string);
+    reason?: FramePerfReason;
+    priority?: TerminalFrameTaskPriority;
+    sync?: boolean;
+    merge?: (prev: T, next: T) => T;
+    apply: FrameMailboxApply<T>;
+}>;
+/**
+ * Coalesces many producer updates into a single scheduler frame task.
+ *
+ * This helper is currently internal to vue-tui. It is used by library
+ * components and internal tests, but it is not exported from the package root.
+ *
+ * Default behavior keeps only the latest queued value. If `merge` is provided,
+ * the pending value is updated with `merge(prev, next)`.
+ *
+ * Only the first queue() call in a pending cycle schedules a frame task.
+ * Later queue() calls update the pending payload and are reported as dropped
+ * producer updates when the frame task runs.
+ *
+ * droppedUpdates are reported after apply() succeeds. They only appear in
+ * framePerf when apply() also invalidates and produces a rendered frame sample.
+ * If apply() throws, scheduler error stats include mailbox queued/dropped
+ * metadata for the failed delivery attempt. The pending payload has already
+ * been cleared; mailbox delivery is fail-fast and does not retry stale payloads
+ * on later frames.
+ *
+ * cancel() is best-effort at scheduler level. The run callback still guards
+ * `disposed || !hasPending`, because a scheduler may already have taken a
+ * snapshot of tasks for the current frame.
+ *
+ * queue() returns false only when the scheduler explicitly rejects the task.
+ * Legacy void-returning schedulers are treated as accepted for compatibility.
+ * Owners should call dispose() before the component/scope that owns the
+ * mailbox is destroyed.
+ *
+ * id is scheduler-global. Components should include instance id and producer
+ * name, for example `TList:${uid}:wheel`.
+ */
+export declare function createFrameMailbox<T>(options: FrameMailboxOptions<T>): {
+    readonly queue: (value: T) => boolean;
+    readonly replacePending: (value: T) => boolean;
+    readonly cancel: () => void;
+    readonly dispose: () => void;
+    readonly hasPending: () => boolean;
+    readonly peek: () => T | undefined;
+};

package/dist/vue/scheduler/frame-scheduler.d.ts

@@ -0,0 +1,51 @@
+import type { FramePerfReason } from "../../observability/frame-perf.js";
+import type { TerminalFrameTask, TerminalSchedulerConfig, TerminalSchedulerInvalidateOptions } from "../context.js";
+export type SchedulerFrameMailboxDeliveryAttempt = Readonly<{
+    id: string;
+    queued: number;
+    dropped: number;
+}>;
+export type SchedulerFrameTaskRunStats = Readonly<{
+    frameTaskCount: number;
+    /**
+     * Number of scheduler-level tasks merged by task id before execution.
+     */
+    coalescedFrameTasks: number;
+    frameTaskQueueDepthBeforeRun: number;
+    frameTaskQueueDepthAfterRun: number;
+    remainingFrameTasks: number;
+    /**
+     * Number of producer-level values that were not applied individually.
+     * For latest-only mailboxes these are dropped intermediate states.
+     * For merge mailboxes they may be folded into the applied payload.
+     */
+    droppedUpdates: number;
+    reason: FramePerfReason;
+    sync: boolean;
+    requestMore: boolean;
+    error?: unknown;
+    mailboxFailure?: SchedulerFrameMailboxDeliveryAttempt;
+}>;
+export declare const EMPTY_FRAME_TASK_RUN_STATS: SchedulerFrameTaskRunStats;
+type SchedulerFrameTasksOptions = Readonly<{
+    isActive: () => boolean;
+    invalidate: (options?: TerminalSchedulerInvalidateOptions) => void;
+    flushFrame: (stats: SchedulerFrameTaskRunStats) => void;
+}>;
+export declare function createSchedulerFrameTasks(options: SchedulerFrameTasksOptions): {
+    readonly configure: (config: TerminalSchedulerConfig) => void;
+    readonly queueFrameTask: (task: TerminalFrameTask) => boolean;
+    readonly cancelFrameTask: (id: string) => boolean;
+    readonly requestLive: (reason: string) => () => void;
+    readonly dropLive: (reason: string) => void;
+    readonly isInsideFrame: () => boolean;
+    readonly cancelScheduledFrame: () => void;
+    readonly runPendingFrameTasks: (optionsForRun?: Readonly<{
+        force?: boolean;
+    }>) => SchedulerFrameTaskRunStats;
+    readonly scheduleIfNeeded: (requestMore?: boolean) => void;
+    readonly remainingFrameTasks: () => number;
+    readonly liveReasonList: () => string[];
+    readonly queueDepth: () => 1 | 0;
+};
+export {};

package/dist/vue/theme.d.ts

@@ -0,0 +1,48 @@
+import type { Ref } from "vue";
+import type { Style } from "../core/types.js";
+export type TuiThemeColorTokens = Readonly<{
+    link?: string;
+    linkVisited?: string;
+    danger?: string;
+    success?: string;
+    warning?: string;
+    info?: string;
+    muted?: string;
+    accent?: string;
+}>;
+export type TuiThemeComponentTokens = Readonly<{
+    TLink?: Readonly<{
+        style?: Style;
+        hoverStyle?: Style;
+        focusStyle?: Style;
+        visitedStyle?: Style;
+        underline?: boolean;
+        hoverUnderline?: boolean;
+    }>;
+    TTable?: Readonly<{
+        headerStyle?: Style;
+        borderStyle?: Style;
+        rowStyle?: Style;
+        selectedStyle?: Style;
+        activeStyle?: Style;
+    }>;
+    TFormField?: Readonly<{
+        labelStyle?: Style;
+        helpStyle?: Style;
+        errorStyle?: Style;
+    }>;
+}>;
+export type TuiTheme = Readonly<{
+    colors: TuiThemeColorTokens;
+    components: TuiThemeComponentTokens;
+}>;
+export type TuiThemeOverrides = Readonly<{
+    colors?: TuiThemeColorTokens;
+    components?: TuiThemeComponentTokens;
+}>;
+export declare const tuiDefaultTheme: TuiTheme;
+export declare function createTheme(overrides?: TuiThemeOverrides): TuiTheme;
+export declare const TuiThemeContextKey: import("vue").InjectionKey<Readonly<Ref<Readonly<{
+    colors: TuiThemeColorTokens;
+    components: TuiThemeComponentTokens;
+}>>>>;

package/dist/vue/transcript/hit-regions.d.ts

@@ -0,0 +1,2 @@
+import type { TTranscriptHitRegion, TTranscriptVisualRow } from "./types.js";
+export declare function findTranscriptHitRegion(visualRow: TTranscriptVisualRow | undefined, x: number): TTranscriptHitRegion | null;

package/dist/vue/transcript/layout.d.ts

@@ -0,0 +1,20 @@
+import type { TTranscriptRow, TTranscriptVisualRow } from "./types.js";
+import type { Style } from "../../core/types.js";
+export type TTranscriptRowLayoutOptions = Readonly<{
+    row: TTranscriptRow;
+    rowIndex: number;
+    rowKey: string | number;
+    width: number;
+    baseStyle: Style;
+    hoverRegionId?: string | null;
+    focusedRegionId?: string | null;
+    hoverStyle?: Style;
+    focusStyle?: Style;
+    wrap?: boolean;
+}>;
+export declare function transcriptActionRegionId(rowKey: string | number, actionId: string): string;
+export declare function transcriptLinkRegionId(rowKey: string | number, sourceSegmentIndex: number, tokenId?: string): string;
+export declare function transcriptFoldToggleRegionId(rowKey: string | number): string;
+export declare function transcriptToolCallRegionId(rowKey: string | number): string;
+export declare function layoutTranscriptRow(options: TTranscriptRowLayoutOptions): TTranscriptVisualRow[];
+export declare function layoutTranscriptRows(rows: readonly TTranscriptRow[], options: Omit<TTranscriptRowLayoutOptions, "row" | "rowIndex" | "rowKey">): TTranscriptVisualRow[];

package/dist/vue/transcript/plain-text.d.ts

@@ -0,0 +1,2 @@
+import type { TTranscriptRow } from "./types.js";
+export declare function plainTextForTranscriptRow(row: TTranscriptRow): string;

package/dist/vue/transcript/types.d.ts

@@ -0,0 +1,122 @@
+import type { Style } from "../../core/types.js";
+export type TTranscriptSegment = Readonly<{
+    text: string;
+    style?: Style;
+    href?: string;
+    selectable?: boolean;
+    tokenId?: string;
+    meta?: unknown;
+}>;
+export type TTranscriptAction = Readonly<{
+    id: string;
+    label: string;
+    disabled?: boolean;
+    kind?: "primary" | "secondary" | "danger";
+    style?: Style;
+    hoverStyle?: Style;
+    focusStyle?: Style;
+    payload?: unknown;
+}>;
+export type TTranscriptRow = {
+    kind: "message";
+    key: string | number;
+    role?: "user" | "assistant" | "system" | "tool";
+    segments: readonly TTranscriptSegment[];
+    selectableText?: string;
+    actions?: readonly TTranscriptAction[];
+    meta?: unknown;
+} | {
+    kind: "action";
+    key: string | number;
+    label: string;
+    actions: readonly TTranscriptAction[];
+    selectableText?: string;
+    meta?: unknown;
+} | {
+    kind: "tool-call";
+    key: string | number;
+    title: string;
+    collapsed: boolean;
+    summary?: readonly TTranscriptSegment[];
+    body?: readonly TTranscriptSegment[];
+    actions?: readonly TTranscriptAction[];
+    selectableText?: string;
+    meta?: unknown;
+} | {
+    kind: "approval";
+    key: string | number;
+    title: string;
+    description?: readonly TTranscriptSegment[];
+    actions: readonly TTranscriptAction[];
+    selectableText?: string;
+    meta?: unknown;
+};
+export type TTranscriptDataSource = Readonly<{
+    rowCount(): number;
+    getRow(index: number): TTranscriptRow;
+    getRowKey?: (index: number) => string | number;
+    getRowVersion?: (index: number) => string | number;
+    firstRowIndex?: () => number;
+}>;
+export type TTranscriptVisualSegment = Readonly<{
+    text: string;
+    cells: number;
+    style: Style;
+    selectable?: boolean;
+    sourceSegmentIndex?: number;
+}>;
+export type TTranscriptSelectionSegment = Readonly<{
+    x0: number;
+    x1: number;
+    text: string;
+    selectable: boolean;
+}>;
+export type TTranscriptHitRegion = Readonly<{
+    id: string;
+    kind: "link" | "action" | "fold-toggle" | "tool-call";
+    rowIndex: number;
+    visualRow: number;
+    x0: number;
+    x1: number;
+    payload?: unknown;
+    hoverStyle?: Style;
+    focusStyle?: Style;
+}>;
+export type TTranscriptVisualRow = Readonly<{
+    rowIndex: number;
+    rowKey: string | number;
+    partIndex: number;
+    startCell: number;
+    segments: readonly TTranscriptVisualSegment[];
+    selectionSegments: readonly TTranscriptSelectionSegment[];
+    hitRegions: readonly TTranscriptHitRegion[];
+    selectableText?: string;
+    text: string;
+}>;
+export type TTranscriptRegionEvent = Readonly<{
+    region: TTranscriptHitRegion;
+    row: TTranscriptRow;
+    rowIndex: number;
+    absoluteRowIndex: number;
+    event?: unknown;
+}>;
+export type TTranscriptRowEvent = Readonly<{
+    row: TTranscriptRow;
+    rowIndex: number;
+    absoluteRowIndex: number;
+    event?: unknown;
+}>;
+export type TTranscriptViewHandle = Readonly<{
+    scrollToBottom(): void;
+    scrollToTop(): void;
+    scrollToRow(index: number, options?: {
+        align?: "start" | "center" | "end";
+    }): void;
+    invalidateRow(index: number): void;
+    invalidateRange(start: number, end: number): void;
+    refreshViewport(): void;
+    focusNextRegion(): boolean;
+    focusPreviousRegion(): boolean;
+    activateFocusedRegion(): boolean;
+    getHoveredRegion(): TTranscriptHitRegion | null;
+}>;

package/dist/vue/utils/frame-task.d.ts

@@ -0,0 +1,6 @@
+export interface FrameCoalescer<T> {
+    request(value: T): void;
+    cancel(): void;
+    latest(): T | undefined;
+}
+export declare function createFrameCoalescer<T>(apply: (latest: T) => void): FrameCoalescer<T>;

package/dist/vue/utils/rect.d.ts

@@ -0,0 +1,4 @@
+import type { Rect } from "../../events/manager/types.js";
+export declare function intersectRect(a: Rect, b: Rect): Rect | null;
+export declare function translateRect(rect: Rect, dx: number, dy: number): Rect;
+export declare function normalizeCellRect(rect: Rect): Rect;

package/dist/vue/utils/row-scroll.d.ts

@@ -0,0 +1,25 @@
+import type { TerminalRenderPlane } from "../../core/render-plane.js";
+import type { Rect } from "../../events/manager/types.js";
+import type { RendererCapabilities } from "../../renderer/capabilities.js";
+import type { RenderManager } from "../render/render-manager.js";
+export type UnsafeFullRowScrollMode = "off" | "unsafe-full-row";
+export type UnsafeFullRowScrollPlan = Readonly<{
+    exposedRows: readonly number[];
+    apply: () => void;
+}>;
+export declare function exposedRowsForDelta(y0: number, h: number, delta: number): number[];
+export declare function prepareUnsafeFullRowScroll(options: Readonly<{
+    render: Pick<RenderManager, "unsafeScrollPlaneRows">;
+    plane: TerminalRenderPlane;
+    rect: Rect;
+    terminalSize: Readonly<{
+        cols: number;
+        rows: number;
+    }>;
+    delta: number;
+    rowScrollMode: UnsafeFullRowScrollMode;
+    rendererCapabilities: Pick<RendererCapabilities, "scrollOperations">;
+    isClipped: boolean;
+    hasPendingDirtyRows: boolean;
+    strategy?: "auto" | "viewport-repaint";
+}>): UnsafeFullRowScrollPlan | null;

package/dist/vue/utils/style-cache.d.ts

@@ -0,0 +1,3 @@
+import type { Style } from "../../core/types.js";
+export declare function defaultActiveStyle(base: Style): Style;
+export declare function defaultDimStyle(base: Style): Style;

package/dist/vue/utils/text.d.ts

@@ -0,0 +1,27 @@
+import { type WidthProvider } from "../../core/buffer/width.js";
+export interface TextCellSegment {
+    text: string;
+    cells: number;
+    start: number;
+    end: number;
+}
+export declare function currentTextWidthProvider(): WidthProvider;
+export declare function hasTextWidthAsciiFastPath(): boolean;
+export declare function withTextWidthProvider<T>(provider: WidthProvider | undefined, fn: () => T): T;
+export declare function withTextRenderPass<T>(fn: () => T, provider?: WidthProvider): T;
+export declare function forEachTextCellSegment(text: string, cb: (segment: TextCellSegment) => void | false, provider?: WidthProvider): void;
+export declare function graphemeRangeAt(text: string, index: number): {
+    start: number;
+    end: number;
+} | null;
+export declare function sanitizeInlineText(text: string): string;
+export declare function sanitizeTextBlock(text: string): string;
+export declare function textCellWidth(text: string, provider?: WidthProvider): number;
+export declare function spaces(count: number): string;
+export declare function repeatChar(ch: string, count: number): string;
+export declare function sliceByCells(text: string, maxCells: number, provider?: WidthProvider): string;
+export declare function sliceByCellsRange(text: string, startCells: number, endCells: number, provider?: WidthProvider): string;
+export declare function padEndByCells(text: string, width: number, provider?: WidthProvider): string;
+export declare function formatInlineCellLine(text: string, width: number, provider?: WidthProvider): string;
+export declare function clearTextCaches(): void;
+export declare function wrapByCells(text: string, width: number, provider?: WidthProvider): readonly string[];

package/dist/vue/utils/wheel-scroll.d.ts

@@ -0,0 +1,18 @@
+export interface WheelScrollState {
+    accumulator: number;
+    lastAt: number;
+    lastEdgeDir: number;
+    lastEdgeAt: number;
+}
+export interface WheelScrollResult {
+    nextTop: number;
+    dir: -1 | 0 | 1;
+    lines: number;
+}
+export type WheelDeltaMode = "auto" | "line" | "pixel";
+export interface WheelScrollOptions {
+    disableAcceleration?: boolean;
+}
+export declare function createWheelScrollState(): WheelScrollState;
+export declare function resetWheelScrollState(state: WheelScrollState): void;
+export declare function applyWheelScroll(state: WheelScrollState, deltaY: number, scrollTop: number, maxTop: number, now?: number, deltaMode?: WheelDeltaMode, options?: WheelScrollOptions): WheelScrollResult;