restty 0.1.34 → 0.2.0

package/dist/runtime/create-runtime/highlight-terminal-color-utils.types.d.ts

@@ -0,0 +1,9 @@
+import type { Color } from "../../renderer";
+export type RuntimeTerminalColor = {
+    kind: "color";
+    color: Color;
+} | {
+    kind: "cell-foreground";
+} | {
+    kind: "cell-background";
+};

package/dist/runtime/create-runtime/input-hooks.d.ts

@@ -1,12 +1,2 @@
-import type { ResttyAppInputPayload } from "../types";
-type RuntimeInputHook = ((payload: ResttyAppInputPayload) => string | null | void) | null | undefined;
-export type CreateRuntimeInputHooksOptions = {
-    beforeInputHook?: RuntimeInputHook;
-    beforeRenderOutputHook?: RuntimeInputHook;
-};
-export type RuntimeInputHooks = {
-    runBeforeInputHook: (text: string, source: string) => string | null;
-    runBeforeRenderOutputHook: (text: string, source: string) => string | null;
-};
-export declare function createRuntimeInputHooks(options: CreateRuntimeInputHooksOptions): RuntimeInputHooks;
-export {};
+import type { RuntimeInputHooks, RuntimeInputHooksOptions } from "./input-hooks.types";
+export declare function createRuntimeInputHooks(options: RuntimeInputHooksOptions): RuntimeInputHooks;

package/dist/runtime/create-runtime/input-hooks.types.d.ts

@@ -0,0 +1,10 @@
+import type { ResttyRuntimeInputPayload } from "../core/models";
+export type RuntimeInputHook = ((payload: ResttyRuntimeInputPayload) => string | null | void) | null | undefined;
+export type RuntimeInputHooksOptions = {
+    beforeInputHook?: RuntimeInputHook;
+    beforeRenderOutputHook?: RuntimeInputHook;
+};
+export type RuntimeInputHooks = {
+    runBeforeInputHook: (text: string, source: string) => string | null;
+    runBeforeRenderOutputHook: (text: string, source: string) => string | null;
+};

package/dist/runtime/create-runtime/interaction-runtime/bind-ime-events.d.ts

@@ -1,4 +1,5 @@
-import type { BindCanvasEventsOptions, RuntimeImeState } from "./types";
+import type { BindCanvasEventsOptions } from "./runtime.types";
+import type { RuntimeImeState } from "./state.types";
 export type BindImeEventsOptions = {
     bindOptions: BindCanvasEventsOptions;
     imeInput: HTMLTextAreaElement;

package/dist/runtime/create-runtime/interaction-runtime/bind-pointer-aux-handlers.d.ts

@@ -1,9 +1,9 @@
 import type { InputHandler } from "../../../input";
-import type { RuntimeCell, RuntimeDesktopSelectionState, RuntimeGridState, RuntimeScrollbarDragState, RuntimeSelectionState, RuntimeTouchSelectionState } from "./types";
+import type { RuntimeCell, RuntimeDesktopSelectionState, RuntimeGridState, RuntimeSelectionState, RuntimeTouchSelectionState } from "./state.types";
 type CreatePointerAuxHandlersOptions = {
     inputHandler: InputHandler;
     shouldRoutePointerToAppMouse: (shiftKey: boolean) => boolean;
-    scrollViewportByLines: (lines: number) => void;
+    scrollViewportByWheel?: (event: WheelEvent) => void;
     getWasmReady: () => boolean;
     getWasmHandle: () => number;
     getGridState: () => RuntimeGridState;
@@ -14,7 +14,6 @@ type CreatePointerAuxHandlersOptions = {
     selectionState: RuntimeSelectionState;
     touchSelectionState: RuntimeTouchSelectionState;
     desktopSelectionState: RuntimeDesktopSelectionState;
-    scrollbarDragState: RuntimeScrollbarDragState;
     updateCanvasCursor: () => void;
     markNeedsRender: () => void;
 };

package/dist/runtime/create-runtime/interaction-runtime/bind-pointer-events.d.ts

@@ -1,5 +1,5 @@
-import { type OverlayScrollbarLayout } from "../../overlay-scrollbar";
-import type { BindCanvasEventsOptions, RuntimeCell, RuntimeDesktopSelectionState, RuntimeGridState, RuntimeLinkState, RuntimeScrollbarDragState, RuntimeSelectionState, RuntimeTouchSelectionState } from "./types";
+import type { BindCanvasEventsOptions } from "./runtime.types";
+import type { RuntimeCell, RuntimeDesktopSelectionState, RuntimeGridState, RuntimeLinkState, RuntimeSelectionState, RuntimeTouchSelectionState } from "./state.types";
 export type BindPointerEventsOptions = {
     canvas: HTMLCanvasElement;
     bindOptions: BindCanvasEventsOptions;
@@ -9,7 +9,6 @@ export type BindPointerEventsOptions = {
     selectionState: RuntimeSelectionState;
     touchSelectionState: RuntimeTouchSelectionState;
     desktopSelectionState: RuntimeDesktopSelectionState;
-    scrollbarDragState: RuntimeScrollbarDragState;
     linkState: RuntimeLinkState;
     cleanupCanvasFns: Array<() => void>;
     isTouchPointer: (event: PointerEvent) => boolean;
@@ -17,13 +16,9 @@ export type BindPointerEventsOptions = {
     clearPendingDesktopSelection: () => void;
     tryActivatePendingTouchSelection: (pointerId: number) => boolean;
     beginSelectionDrag: (cell: RuntimeCell, pointerId: number) => void;
-    noteScrollActivity: () => void;
-    getOverlayScrollbarLayout: () => OverlayScrollbarLayout | null;
-    pointerToCanvasPx: (event: PointerEvent) => {
-        x: number;
-        y: number;
-    };
-    setViewportScrollOffset: (nextOffset: number) => void;
+    selectWordAtCell?: (cell: RuntimeCell) => boolean;
+    selectLineAtCell?: (cell: RuntimeCell) => boolean;
+    scrollViewportByWheel?: (event: WheelEvent) => void;
     normalizeSelectionCell: (cell: RuntimeCell) => RuntimeCell;
     positionToCell: (event: {
         clientX: number;

package/dist/runtime/create-runtime/interaction-runtime/bind-pointer-up-handler.d.ts

@@ -1,10 +1,9 @@
 import type { InputHandler } from "../../../input";
-import type { RuntimeCell, RuntimeDesktopSelectionState, RuntimeLinkState, RuntimeScrollbarDragState, RuntimeSelectionState, RuntimeTouchSelectionState } from "./types";
+import type { RuntimeCell, RuntimeDesktopSelectionState, RuntimeLinkState, RuntimeSelectionState, RuntimeTouchSelectionState } from "./state.types";
 type CreatePointerUpHandlerOptions = {
     inputHandler: InputHandler;
     sendKeyInput: (text: string) => void;
     openLink: (url: string) => void;
-    scrollbarDragState: RuntimeScrollbarDragState;
     isTouchPointer: (event: PointerEvent) => boolean;
     touchSelectionState: RuntimeTouchSelectionState;
     selectionState: RuntimeSelectionState;
@@ -17,6 +16,8 @@ type CreatePointerUpHandlerOptions = {
     clearPendingDesktopSelection: () => void;
     desktopSelectionState: RuntimeDesktopSelectionState;
     clearSelection: () => void;
+    selectWordAtCell?: (cell: RuntimeCell) => boolean;
+    selectLineAtCell?: (cell: RuntimeCell) => boolean;
     updateCanvasCursor: () => void;
     markNeedsRender: () => void;
     shouldRoutePointerToAppMouse: (shiftKey: boolean) => boolean;

package/dist/runtime/create-runtime/interaction-runtime/desktop-word-selection.d.ts

@@ -0,0 +1,8 @@
+import type { RenderState } from "../../../wasm";
+import type { RuntimeCell } from "./types";
+type DesktopWordSelectionRange = {
+    start: number;
+    end: number;
+};
+export declare function resolveDesktopWordSelectionRange(render: RenderState | null, cell: RuntimeCell): DesktopWordSelectionRange | null;
+export {};

package/dist/runtime/create-runtime/{interaction-runtime.d.ts → interaction-runtime/index.d.ts}

@@ -1,3 +1,4 @@
-import type { CreateRuntimeInteractionOptions, RuntimeInteraction } from "./interaction-runtime/types";
-export type { BindCanvasEventsOptions, CreateRuntimeInteractionOptions, RuntimeCell, RuntimeInteraction, } from "./interaction-runtime/types";
+import type { CreateRuntimeInteractionOptions, RuntimeInteraction } from "./runtime.types";
+export type { BindCanvasEventsOptions, CreateRuntimeInteractionOptions, RuntimeInteraction, } from "./runtime.types";
+export type { RuntimeCell } from "./state.types";
 export declare function createRuntimeInteraction(options: CreateRuntimeInteractionOptions): RuntimeInteraction;

package/dist/runtime/create-runtime/interaction-runtime/kitty-image-cache.d.ts

@@ -1,18 +1,3 @@
-import type { KittyPlacement, ResttyWasm } from "../../../wasm";
-export type KittyDecodedImage = {
-    key: string;
-    width: number;
-    height: number;
-    source: CanvasImageSource;
-    pixels?: Uint8Array;
-};
-export type KittyImageCache = {
-    resolveKittyImage: (placement: KittyPlacement) => KittyDecodedImage | null;
-    clearKittyImageCache: () => void;
-    pruneInactiveImages: (activeImageIds: Set<number>) => boolean;
-};
-export type CreateKittyImageCacheOptions = {
-    getWasm: () => ResttyWasm | null;
-    markNeedsRender: () => void;
-};
+import type { CreateKittyImageCacheOptions, KittyImageCache } from "./kitty-image-cache.types";
+export type { CreateKittyImageCacheOptions, KittyDecodedImage, KittyImageCache, } from "./kitty-image-cache.types";
 export declare function createKittyImageCache(options: CreateKittyImageCacheOptions): KittyImageCache;

package/dist/runtime/create-runtime/interaction-runtime/kitty-image-cache.types.d.ts

@@ -0,0 +1,17 @@
+import type { KittyPlacement, ResttyWasm } from "../../../wasm";
+export type KittyDecodedImage = {
+    key: string;
+    width: number;
+    height: number;
+    source: CanvasImageSource;
+    pixels?: Uint8Array;
+};
+export type KittyImageCache = {
+    resolveKittyImage: (placement: KittyPlacement) => KittyDecodedImage | null;
+    clearKittyImageCache: () => void;
+    pruneInactiveImages: (activeImageIds: Set<number>) => boolean;
+};
+export type CreateKittyImageCacheOptions = {
+    getWasm: () => ResttyWasm | null;
+    markNeedsRender: () => void;
+};

package/dist/runtime/create-runtime/interaction-runtime/{types.d.ts → runtime.types.d.ts}

@@ -1,53 +1,6 @@
 import type { InputHandler } from "../../../input";
-import type { createSelectionState } from "../../../selection";
 import type { RenderState, ResttyWasm, ResttyWasmExports } from "../../../wasm";
-export type RuntimeCell = {
-    row: number;
-    col: number;
-};
-export type RuntimeGridState = {
-    cols: number;
-    rows: number;
-    cellW: number;
-    cellH: number;
-};
-export type RuntimeImeState = {
-    composing: boolean;
-    preedit: string;
-    selectionStart: number;
-    selectionEnd: number;
-};
-export type RuntimeTouchSelectionState = {
-    pendingPointerId: number | null;
-    activePointerId: number | null;
-    panPointerId: number | null;
-    pendingCell: RuntimeCell | null;
-    pendingStartedAt: number;
-    pendingStartX: number;
-    pendingStartY: number;
-    panLastY: number;
-    pendingTimer: number;
-};
-export type RuntimeDesktopSelectionState = {
-    pendingPointerId: number | null;
-    pendingCell: RuntimeCell | null;
-    startedWithActiveSelection: boolean;
-};
-export type RuntimeLinkState = {
-    hoverId: number;
-    hoverUri: string;
-};
-export type RuntimeScrollbarState = {
-    lastInputAt: number;
-    lastTotal: number;
-    lastOffset: number;
-    lastLen: number;
-};
-export type RuntimeScrollbarDragState = {
-    pointerId: number | null;
-    thumbGrabRatio: number;
-};
-export type RuntimeSelectionState = ReturnType<typeof createSelectionState>;
+import type { RuntimeCell, RuntimeGridState, RuntimeImeState, RuntimeLinkState, RuntimeScrollbarState, RuntimeSelectionState } from "./state.types";
 export type BindCanvasEventsOptions = {
     inputHandler: InputHandler;
     sendKeyInput: (text: string) => void;
@@ -63,7 +16,6 @@ export type CreateRuntimeInteractionOptions = {
     touchSelectionMode: "off" | "drag" | "long-press";
     touchSelectionLongPressMs: number;
     touchSelectionMoveThresholdPx: number;
-    showOverlayScrollbar: boolean;
     imeInput: HTMLTextAreaElement | null;
     cleanupCanvasFns: Array<() => void>;
     getCanvas: () => HTMLCanvasElement;
@@ -76,6 +28,7 @@ export type CreateRuntimeInteractionOptions = {
     getWasmExports: () => ResttyWasmExports | null;
     updateLinkHover: (cell: RuntimeCell | null) => void;
     markNeedsRender: () => void;
+    markSearchDirty?: () => void;
 };
 export type RuntimeInteraction = {
     selectionState: RuntimeSelectionState;
@@ -95,11 +48,12 @@ export type RuntimeInteraction = {
         x: number;
         y: number;
     };
+    selectWordAtClientPoint: (clientX: number, clientY: number) => boolean;
     clearSelection: () => void;
     updateImePosition: (cursor: {
         row: number;
         col: number;
     } | null | undefined, cellW: number, cellH: number) => void;
-    appendOverlayScrollbar: (overlayData: number[], total: number, offset: number, len: number) => void;
+    syncScrollbar: (total: number, offset: number, len: number) => void;
     bindCanvasEvents: (bindOptions: BindCanvasEventsOptions) => void;
 };

package/dist/runtime/create-runtime/interaction-runtime/scrollbar-runtime.d.ts

@@ -1,30 +1,2 @@
-import { type OverlayScrollbarLayout } from "../../overlay-scrollbar";
-import type { RuntimeGridState, RuntimeLinkState, RuntimeScrollbarState, RuntimeSelectionState } from "./types";
-import type { ResttyWasm, ResttyWasmExports } from "../../../wasm";
-export type CreateScrollbarRuntimeOptions = {
-    showOverlayScrollbar: boolean;
-    scrollbarState: RuntimeScrollbarState;
-    selectionState: RuntimeSelectionState;
-    linkState: RuntimeLinkState;
-    getCanvas: () => HTMLCanvasElement;
-    getCurrentDpr: () => number;
-    getGridState: () => RuntimeGridState;
-    getWasmReady: () => boolean;
-    getWasm: () => ResttyWasm | null;
-    getWasmHandle: () => number;
-    getWasmExports: () => ResttyWasmExports | null;
-    updateLinkHover: (cell: null) => void;
-    markNeedsRender: () => void;
-};
-export type ScrollbarRuntime = {
-    noteScrollActivity: () => void;
-    scrollViewportByLines: (lines: number) => void;
-    setViewportScrollOffset: (nextOffset: number) => void;
-    pointerToCanvasPx: (event: PointerEvent) => {
-        x: number;
-        y: number;
-    };
-    getOverlayScrollbarLayout: () => OverlayScrollbarLayout | null;
-    appendOverlayScrollbar: (overlayData: number[], total: number, offset: number, len: number) => void;
-};
+import type { CreateScrollbarRuntimeOptions, ScrollbarRuntime } from "./scrollbar-runtime.types";
 export declare function createScrollbarRuntime(options: CreateScrollbarRuntimeOptions): ScrollbarRuntime;

package/dist/runtime/create-runtime/interaction-runtime/scrollbar-runtime.types.d.ts

@@ -0,0 +1,23 @@
+import type { ResttyWasm, ResttyWasmExports } from "../../../wasm";
+import type { RuntimeGridState, RuntimeLinkState, RuntimeScrollbarState, RuntimeSelectionState } from "./state.types";
+export type CreateScrollbarRuntimeOptions = {
+    scrollbarState: RuntimeScrollbarState;
+    selectionState: RuntimeSelectionState;
+    linkState: RuntimeLinkState;
+    getCanvas: () => HTMLCanvasElement;
+    getGridState: () => RuntimeGridState;
+    getWasmReady: () => boolean;
+    getWasm: () => ResttyWasm | null;
+    getWasmHandle: () => number;
+    getWasmExports: () => ResttyWasmExports | null;
+    updateLinkHover: (cell: null) => void;
+    markNeedsRender: () => void;
+    markSearchDirty?: () => void;
+};
+export type ScrollbarRuntime = {
+    destroy: () => void;
+    noteScrollActivity: () => void;
+    scrollViewportByLines: (lines: number) => void;
+    scrollViewportByWheel: (event: WheelEvent) => void;
+    syncScrollbar: (total: number, offset: number, len: number) => void;
+};

package/dist/runtime/create-runtime/interaction-runtime/state.types.d.ts

@@ -0,0 +1,47 @@
+import type { createSelectionState } from "../../../selection";
+export type RuntimeCell = {
+    row: number;
+    col: number;
+};
+export type RuntimeGridState = {
+    cols: number;
+    rows: number;
+    cellW: number;
+    cellH: number;
+};
+export type RuntimeImeState = {
+    composing: boolean;
+    preedit: string;
+    selectionStart: number;
+    selectionEnd: number;
+};
+export type RuntimeTouchSelectionState = {
+    pendingPointerId: number | null;
+    activePointerId: number | null;
+    panPointerId: number | null;
+    pendingCell: RuntimeCell | null;
+    pendingStartedAt: number;
+    pendingStartX: number;
+    pendingStartY: number;
+    panLastY: number;
+    pendingTimer: number;
+};
+export type RuntimeDesktopSelectionState = {
+    pendingPointerId: number | null;
+    pendingCell: RuntimeCell | null;
+    startedWithActiveSelection: boolean;
+    lastPrimaryClickAt: number;
+    lastPrimaryClickCell: RuntimeCell | null;
+    lastPrimaryClickCount: number;
+};
+export type RuntimeLinkState = {
+    hoverId: number;
+    hoverUri: string;
+};
+export type RuntimeScrollbarState = {
+    lastInputAt: number;
+    lastTotal: number;
+    lastOffset: number;
+    lastLen: number;
+};
+export type RuntimeSelectionState = ReturnType<typeof createSelectionState>;

package/dist/runtime/create-runtime/kitty-render-runtime.d.ts

@@ -1,36 +1,2 @@
-import type { WebGPUState } from "../../renderer";
-import type { KittyPlacement, ResttyWasm } from "../../wasm";
-export type KittyDrawSlice = {
-    imageId: number;
-    key: string;
-    source: CanvasImageSource;
-    pixels?: Uint8Array;
-    imageWidth: number;
-    imageHeight: number;
-    sx: number;
-    sy: number;
-    sw: number;
-    sh: number;
-    dx: number;
-    dy: number;
-    dw: number;
-    dh: number;
-    z: number;
-};
-export type KittyDrawPlan = {
-    underlay: KittyDrawSlice[];
-    overlay: KittyDrawSlice[];
-};
-type CreateKittyRenderRuntimeOptions = {
-    getWasm: () => ResttyWasm | null;
-    markNeedsRender: () => void;
-};
-export declare function createKittyRenderRuntime(options: CreateKittyRenderRuntimeOptions): {
-    collectKittyDrawPlan: (placements: KittyPlacement[], cellW: number, cellH: number) => KittyDrawPlan;
-    resolveKittyWebGLTexture: (gl: WebGL2RenderingContext, slice: KittyDrawSlice) => WebGLTexture | null;
-    resolveKittyWebGPUBindGroup: (state: WebGPUState, slice: KittyDrawSlice, nearest?: boolean) => GPUBindGroup | null;
-    clearWebGLKittyTextures: () => void;
-    clearWebGPUKittyTextures: () => void;
-    clearKittyRenderCaches: () => void;
-};
-export {};
+import type { KittyRenderRuntime, KittyRenderRuntimeOptions } from "./kitty-render-runtime.types";
+export declare function createKittyRenderRuntime(options: KittyRenderRuntimeOptions): KittyRenderRuntime;

package/dist/runtime/create-runtime/kitty-render-runtime.types.d.ts

@@ -0,0 +1,33 @@
+import type { WebGPUState } from "../../renderer";
+import type { KittyPlacement } from "../../wasm";
+import type { CreateKittyImageCacheOptions } from "./interaction-runtime/kitty-image-cache.types";
+export type KittyDrawSlice = {
+    imageId: number;
+    key: string;
+    source: CanvasImageSource;
+    pixels?: Uint8Array;
+    imageWidth: number;
+    imageHeight: number;
+    sx: number;
+    sy: number;
+    sw: number;
+    sh: number;
+    dx: number;
+    dy: number;
+    dw: number;
+    dh: number;
+    z: number;
+};
+export type KittyDrawPlan = {
+    underlay: KittyDrawSlice[];
+    overlay: KittyDrawSlice[];
+};
+export type KittyRenderRuntimeOptions = CreateKittyImageCacheOptions;
+export type KittyRenderRuntime = {
+    collectKittyDrawPlan: (placements: KittyPlacement[], cellW: number, cellH: number) => KittyDrawPlan;
+    resolveKittyWebGLTexture: (gl: WebGL2RenderingContext, slice: KittyDrawSlice) => WebGLTexture | null;
+    resolveKittyWebGPUBindGroup: (state: WebGPUState, slice: KittyDrawSlice, nearest?: boolean) => GPUBindGroup | null;
+    clearWebGLKittyTextures: () => void;
+    clearWebGPUKittyTextures: () => void;
+    clearKittyRenderCaches: () => void;
+};

package/dist/runtime/create-runtime/{lifecycle-theme-size-canvas.d.ts → lifecycle-theme-size/canvas.d.ts}

@@ -1,4 +1,4 @@
-import type { LifecycleThemeSizeDeps } from "./lifecycle-theme-size.types";
+import type { LifecycleThemeSizeDeps } from "./types";
 export declare function createLifecycleCanvasHandlers(deps: LifecycleThemeSizeDeps): {
     replaceCanvas: () => void;
     updateSize: (force?: boolean) => void;

package/dist/runtime/create-runtime/{lifecycle-theme-size.d.ts → lifecycle-theme-size/index.d.ts}

@@ -1,6 +1,6 @@
-import type { LifecycleThemeSizeDeps } from "./lifecycle-theme-size.types";
+import type { LifecycleThemeSizeDeps } from "./types";
 export declare function createRuntimeLifecycleThemeSize(deps: LifecycleThemeSizeDeps): {
-    applyTheme: (theme: import("../..").GhosttyTheme | null | undefined, sourceLabel?: string) => void;
+    applyTheme: (theme: import("../../..").GhosttyTheme | null | undefined, _sourceLabel?: string) => void;
     resetTheme: () => void;
     replaceCanvas: () => void;
     updateSize: (force?: boolean) => void;
@@ -12,5 +12,5 @@ export declare function createRuntimeLifecycleThemeSize(deps: LifecycleThemeSize
     bindFocusEvents: () => void;
     bindAutoResizeEvents: () => void;
     cancelScheduledSizeUpdate: () => void;
-    getActiveTheme: () => import("../..").GhosttyTheme | null;
+    getActiveTheme: () => GhosttyTheme | null;
 };

package/dist/runtime/create-runtime/lifecycle-theme-size/theme.d.ts

@@ -0,0 +1,6 @@
+import { type GhosttyTheme } from "../../../theme";
+import type { LifecycleThemeSizeDeps } from "./types";
+export declare function createLifecycleThemeHandlers(deps: LifecycleThemeSizeDeps): {
+    applyTheme: (theme: GhosttyTheme | null | undefined, _sourceLabel?: string) => void;
+    resetTheme: () => void;
+};

package/dist/runtime/create-runtime/{lifecycle-theme-size.types.d.ts → lifecycle-theme-size/types.d.ts}

@@ -2,8 +2,8 @@ import type { InputHandler } from "../../input";
 import type { FontManagerState } from "../../fonts";
 import type { Color, WebGLState, WebGPUState } from "../../renderer";
 import type { GhosttyTheme } from "../../theme";
+import type { RuntimeTerminalColor } from "./highlight-terminal-color-utils.types";
 import type { ResttyWasm } from "../../wasm";
-import type { ResttyAppCallbacks } from "../types";
 export type ActiveState = WebGPUState | WebGLState | null;
 export type GridStateRef = {
     cols: number;
@@ -34,9 +34,6 @@ export type LifecycleThemeSizeDeps = {
     attachWindowEvents: boolean;
     autoResize: boolean;
     imeInput: HTMLTextAreaElement | null;
-    dprEl: HTMLElement | null;
-    sizeEl: HTMLElement | null;
-    callbacks: ResttyAppCallbacks | undefined;
     cleanupFns: Array<() => void>;
     cleanupCanvasFns: Array<() => void>;
     gridState: GridStateRef;
@@ -44,7 +41,12 @@ export type LifecycleThemeSizeDeps = {
     fontState: FontManagerState;
     defaultBgBase: Color;
     defaultFgBase: Color;
-    selectionBase: Color;
+    selectionBackgroundBase: RuntimeTerminalColor;
+    selectionForegroundBase: RuntimeTerminalColor | null;
+    searchMatchBackgroundBase: RuntimeTerminalColor;
+    searchCurrentMatchBackgroundBase: RuntimeTerminalColor;
+    searchMatchTextBase: RuntimeTerminalColor;
+    searchCurrentMatchTextBase: RuntimeTerminalColor;
     cursorBase: Color;
     getCanvas: () => HTMLCanvasElement;
     setCanvas: (canvas: HTMLCanvasElement) => void;
@@ -58,12 +60,16 @@ export type LifecycleThemeSizeDeps = {
     setActiveTheme: (theme: GhosttyTheme | null) => void;
     setDefaultBg: (value: Color) => void;
     setDefaultFg: (value: Color) => void;
-    setSelectionColor: (value: Color) => void;
+    setSelectionBackgroundColor: (value: RuntimeTerminalColor) => void;
+    setSelectionForegroundColor: (value: RuntimeTerminalColor | null) => void;
+    setSearchMatchBackgroundColor: (value: RuntimeTerminalColor) => void;
+    setSearchCurrentMatchBackgroundColor: (value: RuntimeTerminalColor) => void;
+    setSearchMatchTextColor: (value: RuntimeTerminalColor) => void;
+    setSearchCurrentMatchTextColor: (value: RuntimeTerminalColor) => void;
     setCursorFallback: (value: Color) => void;
     getWasmReady: () => boolean;
     getWasm: () => ResttyWasm | null;
     getWasmHandle: () => number;
-    appendLog: (line: string) => void;
     bindCanvasEvents: () => void;
     computeCellMetrics: () => {
         cellW: number;

package/dist/runtime/create-runtime/ligature-runs.d.ts

@@ -0,0 +1,52 @@
+type CellCluster = {
+    cp: number;
+    text: string;
+    span: number;
+};
+type CursorCell = {
+    row: number;
+    col: number;
+    wide: boolean;
+};
+type ResolveLigatureRunOptions = {
+    idx: number;
+    row: number;
+    col: number;
+    cols: number;
+    contentTags: Uint8Array | null;
+    styleFlags: Uint16Array | null;
+    linkIds: Uint32Array | null;
+    fgBytes: Uint8Array;
+    bgBytes: Uint8Array | null;
+    ulBytes: Uint8Array | null;
+    ulStyle: Uint8Array | null;
+    cursorBlock: boolean;
+    cursorCell: CursorCell | null;
+    readCellCluster: (cellIndex: number) => CellCluster | null;
+};
+type LigatureRun = {
+    text: string;
+    span: number;
+    indices: number[];
+};
+type ShapedGlyphLike = {
+    glyphId: number;
+    xAdvance: number;
+    xOffset: number;
+};
+type ShapedClusterLike = {
+    glyphs: ShapedGlyphLike[];
+    advance: number;
+};
+type ResolveRenderableLigatureRunOptions<FontEntry> = {
+    ligatureRun: LigatureRun;
+    stylePreference: string;
+    fonts: FontEntry[];
+    pickFontIndexForText: (text: string, expectedSpan?: number, stylePreference?: string) => number;
+    shapeClusterWithFont: (entry: FontEntry, text: string) => ShapedClusterLike;
+    readCellCluster: (cellIndex: number) => CellCluster | null;
+};
+export declare function resolveLigatureRun(options: ResolveLigatureRunOptions): LigatureRun | null;
+export declare function shouldUseLigatureShape(combined: ShapedClusterLike, singles: ShapedClusterLike[]): boolean;
+export declare function resolveRenderableLigatureRun<FontEntry>(options: ResolveRenderableLigatureRunOptions<FontEntry>): LigatureRun | null;
+export {};

package/dist/runtime/{max-scrollback.d.ts → create-runtime/max-scrollback.d.ts}

@@ -1,9 +1,6 @@
+import type { MaxScrollbackOptions } from "./max-scrollback.types";
 export declare const DEFAULT_MAX_SCROLLBACK_BYTES = 10000000;
 export declare const MAX_MAX_SCROLLBACK_BYTES = 256000000;
-type MaxScrollbackOptions = {
-    maxScrollbackBytes?: number;
-    maxScrollback?: number;
-};
+export type { MaxScrollbackOptions } from "./max-scrollback.types";
 export declare function normalizeMaxScrollbackBytes(value: number | undefined): number;
 export declare function resolveMaxScrollbackBytes(options: MaxScrollbackOptions): number;
-export {};

package/dist/runtime/create-runtime/max-scrollback.types.d.ts

@@ -0,0 +1,4 @@
+export type MaxScrollbackOptions = {
+    maxScrollbackBytes?: number;
+    maxScrollback?: number;
+};

package/dist/runtime/create-runtime/native-scrollbar-host.d.ts

@@ -0,0 +1,2 @@
+import type { NativeScrollbarHost, NativeScrollbarHostOptions } from "./native-scrollbar-host.types";
+export declare function createNativeScrollbarHost(options: NativeScrollbarHostOptions): NativeScrollbarHost;

package/dist/runtime/create-runtime/native-scrollbar-host.types.d.ts

@@ -0,0 +1,13 @@
+export type NativeScrollbarHostOptions = {
+    canvas: HTMLCanvasElement;
+    getGridState: () => {
+        cellH: number;
+    };
+    noteScrollActivity: () => void;
+    setViewportScrollOffset: (nextOffset: number) => void;
+};
+export type NativeScrollbarHost = {
+    flash: () => void;
+    sync: (total: number, offset: number, len: number) => void;
+    destroy: () => void;
+};

package/dist/runtime/create-runtime/overlay-scrollbar.d.ts

@@ -0,0 +1,6 @@
+import type { OverlayScrollbarLayout } from "./overlay-scrollbar.types";
+export declare const OVERLAY_SCROLLBAR_WIDTH_CSS_PX = 7;
+export declare const OVERLAY_SCROLLBAR_MARGIN_CSS_PX = 4;
+export declare const OVERLAY_SCROLLBAR_INSET_Y_CSS_PX = 2;
+export declare const OVERLAY_SCROLLBAR_MIN_THUMB_CSS_PX = 28;
+export declare function computeOverlayScrollbarLayout(total: number, offset: number, len: number, canvasWidth: number, canvasHeight: number, currentDpr: number): OverlayScrollbarLayout | null;

package/dist/runtime/create-runtime/overlay-scrollbar.types.d.ts

@@ -0,0 +1,12 @@
+export type OverlayScrollbarLayout = {
+    total: number;
+    offset: number;
+    len: number;
+    denom: number;
+    width: number;
+    trackX: number;
+    trackY: number;
+    trackH: number;
+    thumbY: number;
+    thumbH: number;
+};