blecsd 0.4.0 → 0.6.0

package/dist/utils/index.d.ts

@@ -1,256 +1,20 @@
-import { B as BorderCharset } from '../border-DGNDfT6T.js';
-export { c as colorToHex, h as hexToColor, p as packColor, a as parseColor, u as unpackColor } from '../color-B78w3zH-.js';
-export { C as ComponentMemoryReport, a as ComponentStore, b as ComponentStoreConfig, S as SparseStorageConfig, c as SparseStore, T as TypedArrayPool, d as createComponentStore, e as createSparseStore, f as createTypedArrayPool, g as estimateMemoryUsage, h as getComponentMemoryReport, i as isWithinMemoryBounds } from '../componentStorage-CJTh-TPO.js';
+import { c as renderBox, d as renderHLine, e as renderVLine, r as renderText, f as createCellBuffer, h as bufferToString$1, i as boxFillRect, j as charsetToBoxChars, B as BoxChars, k as createRope, l as createEmptyRope, m as insert, n as deleteRange, o as replaceRange, p as getText, g as getLine, q as getLineCount$1, s as append, t as prepend, u as charAt, v as substring, x as getLength, y as getLineStart, z as getLineEnd, A as getLineForIndex, a as getLines, C as getNewlineCount, b as getStats, D as isEmpty, E as verify, F as wordWrap, w as wrapText, G as truncate, H as alignLine, I as getVisibleWidth, J as stripAnsi, K as padHeight } from '../textWrap-Ct2J8gO6.js';
+export { L as BOX_ASCII, M as BOX_BOLD, N as BOX_DASHED, O as BOX_DOUBLE, P as BOX_ROUNDED, Q as BOX_SINGLE, R as Cell, S as CellBuffer, T as LEAF_MAX_SIZE, U as LEAF_MIN_SIZE, V as LineInfo, W as MAX_DEPTH, X as RenderBoxOptions, Y as Rope, Z as RopeLeaf, _ as RopeNode, $ as RopeStats, a0 as TextAlign, a1 as WrapOptions } from '../textWrap-Ct2J8gO6.js';
+import { c as colorToHex, h as hexToColor, p as packColor, u as unpackColor, a as parseColor } from '../color-B78w3zH-.js';
+import { c as createComponentStore, a as createSparseStore, b as createTypedArrayPool, g as getComponentMemoryReport, e as estimateMemoryUsage, i as isWithinMemoryBounds } from '../componentStorage-CXJvx4Lt.js';
+export { d as ComponentMemoryReport, C as ComponentStore, f as ComponentStoreConfig, S as SparseStorageConfig, h as SparseStore, T as TypedArrayPool } from '../componentStorage-CXJvx4Lt.js';
+import * as zod from 'zod';
 import { z } from 'zod';
-import { S as StyleData } from '../renderable-CwqGwrEV.js';
-export { C as CHUNKED_THRESHOLD, L as LineIndexSchema, a as LineRangeParamsSchema, b as LineStoreStats, T as TrimParamsSchema, c as VirtualizedLineInfo, d as VirtualizedLineRange, V as VirtualizedLineStore, e as VisibleLinesParamsSchema, f as appendLinesToStore, g as appendToStore, h as createEmptyLineStore, i as createLineStore, j as createLineStoreFromLines, k as exportContent, l as exportLineRange, m as getByteSize, n as getLineAtIndex, o as getLineForOffset, p as getLineInfo, q as getLineStoreLineCount, r as getLineStoreRange, s as getLineStoreVisibleLines, t as getOffsetForLine, u as getStoreStats, v as isStoreEmpty, w as trimLineStore } from '../virtualizedLineStore-DwPEvPkk.js';
-export { C as COMPRESSION_RATIO, a as Chunk, D as DEFAULT_CHUNK_SIZE, b as DEFAULT_MAX_CACHED, c as DEFAULT_MAX_MEMORY, L as LineRange, S as ScrollbackBuffer, d as ScrollbackConfig, e as ScrollbackLine, f as ScrollbackStats, g as appendLine, h as appendLines, i as clearScrollback, j as compressOldChunks, k as createScrollbackBuffer, l as decompressAll, m as exportToText, n as getLineRange, o as getMemoryUsage, p as getScrollbackLine, q as getScrollbackStats, r as getVisibleLines, s as jumpToLine, t as loadFromText, v as scrollBy, w as scrollToBottom, x as scrollToTop, u as trimToLineCount } from '../virtualScrollback-D9uLFe8l.js';
-import '../types-CPB4CpbH.js';
+import * as zod_v4_core from 'zod/v4/core';
+import { c as createLineStore, a as createLineStoreFromLines, b as createEmptyLineStore, d as appendToStore, e as appendLines, g as getLineAtIndex, f as getLineRange, h as getLineCount, i as getLineForOffset, j as getOffsetForLine, k as getLineInfo, l as getVisibleLines, m as exportContent, n as exportLineRange, o as getStoreStats, p as getByteSize, q as isStoreEmpty, t as trimToLineCount } from '../virtualizedLineStore-DfyhojPZ.js';
+export { C as CHUNKED_THRESHOLD, L as LineIndexSchema, r as LineRangeParamsSchema, s as LineStoreStats, T as TrimParamsSchema, u as VirtualizedLineInfo, v as VirtualizedLineRange, V as VirtualizedLineStore, w as VisibleLinesParamsSchema } from '../virtualizedLineStore-DfyhojPZ.js';
+import { S as StyleData } from '../renderable-IbSJao5y.js';
+import { c as createScrollbackBuffer, a as appendLine, b as appendLines$1, g as getLine$1, d as getLineRange$1, s as scrollbackScrollBy, e as scrollbackScrollToTop, f as scrollbackScrollToBottom, j as jumpToLine, h as exportToText, l as loadFromText, i as clearScrollback, t as trimToLineCount$1, k as getVisibleLines$1, m as getScrollbackStats, n as getMemoryUsage, o as compressOldChunks, p as decompressAll } from '../virtualScrollback-CiooIebp.js';
+export { C as COMPRESSION_RATIO, q as Chunk, D as DEFAULT_CHUNK_SIZE, r as DEFAULT_MAX_CACHED, u as DEFAULT_MAX_MEMORY, L as LineRange, S as ScrollbackBuffer, v as ScrollbackConfig, w as ScrollbackLine, x as ScrollbackStats } from '../virtualScrollback-CiooIebp.js';
+import '../border-Br-Jc027.js';
+import '../types-B8LmNkzG.js';
 import 'bitecs';
 
-/**
- * Box rendering utilities for drawing borders and boxes.
- * @module utils/box
- */
-
-/**
- * Box drawing characters as strings (for convenience).
- */
-interface BoxChars {
-    readonly topLeft: string;
-    readonly topRight: string;
-    readonly bottomLeft: string;
-    readonly bottomRight: string;
-    readonly horizontal: string;
-    readonly vertical: string;
-}
-/**
- * Converts a BorderCharset (code points) to BoxChars (strings).
- *
- * @param charset - Border character set with code points
- * @returns Box characters as strings
- *
- * @example
- * ```typescript
- * import { BORDER_ROUNDED, charsetToBoxChars } from 'blecsd';
- *
- * const chars = charsetToBoxChars(BORDER_ROUNDED);
- * console.log(chars.topLeft); // "╭"
- * ```
- */
-declare function charsetToBoxChars(charset: BorderCharset): BoxChars;
-/**
- * Preset box styles as string characters.
- */
-declare const BOX_SINGLE: BoxChars;
-declare const BOX_DOUBLE: BoxChars;
-declare const BOX_ROUNDED: BoxChars;
-declare const BOX_BOLD: BoxChars;
-/**
- * ASCII box characters (works in all terminals).
- */
-declare const BOX_ASCII: BoxChars;
-/**
- * Dashed box characters.
- */
-declare const BOX_DASHED: BoxChars;
-/**
- * Interface for a renderable cell buffer.
- * Any object implementing this interface can be used with renderBox.
- */
-interface CellBuffer {
-    /** Width of the buffer in cells */
-    readonly width: number;
-    /** Height of the buffer in cells */
-    readonly height: number;
-    /**
-     * Set a cell's character and colors.
-     * @param x - Column (0-indexed)
-     * @param y - Row (0-indexed)
-     * @param char - Character to display
-     * @param fg - Foreground color (optional)
-     * @param bg - Background color (optional)
-     */
-    setCell(x: number, y: number, char: string, fg?: number, bg?: number): void;
-}
-/**
- * Simple in-memory cell buffer for testing and rendering.
- */
-interface Cell {
-    char: string;
-    fg: number;
-    bg: number;
-}
-/**
- * Creates a simple cell buffer.
- *
- * @param width - Buffer width in cells
- * @param height - Buffer height in cells
- * @param defaultFg - Default foreground color (default: 0xffffffff white)
- * @param defaultBg - Default background color (default: 0x00000000 transparent)
- * @returns A CellBuffer instance
- *
- * @example
- * ```typescript
- * import { createCellBuffer, renderBox, BOX_SINGLE } from 'blecsd';
- *
- * const buffer = createCellBuffer(80, 24);
- * renderBox(buffer, 5, 2, 20, 10, BOX_SINGLE);
- * ```
- */
-declare function createCellBuffer(width: number, height: number, defaultFg?: number, defaultBg?: number): CellBuffer & {
-    cells: Cell[][];
-};
-/**
- * Options for rendering a box.
- */
-interface RenderBoxOptions {
-    /** Foreground color for the border (optional) */
-    fg?: number;
-    /** Background color for the border (optional) */
-    bg?: number;
-    /** Fill the interior with background color (default: false) */
-    fill?: boolean;
-    /** Fill character for interior (default: ' ') */
-    fillChar?: string;
-}
-/**
- * Renders a box to a cell buffer.
- *
- * Draws border characters around the specified rectangle.
- * Minimum size is 1x1 (just corners).
- *
- * @param buffer - The cell buffer to render to
- * @param x - Left column (0-indexed)
- * @param y - Top row (0-indexed)
- * @param width - Box width (including borders)
- * @param height - Box height (including borders)
- * @param chars - Box characters to use
- * @param options - Rendering options
- *
- * @example
- * ```typescript
- * import { createCellBuffer, renderBox, BOX_ROUNDED } from 'blecsd';
- *
- * const buffer = createCellBuffer(80, 24);
- *
- * // Draw a simple box
- * renderBox(buffer, 5, 2, 20, 10, BOX_ROUNDED);
- *
- * // Draw with colors
- * renderBox(buffer, 30, 2, 20, 10, BOX_DOUBLE, {
- *   fg: 0x00ff00ff, // Green
- *   fill: true
- * });
- * ```
- */
-declare function renderBox(buffer: CellBuffer, x: number, y: number, width: number, height: number, chars: BoxChars, options?: RenderBoxOptions): void;
-/**
- * Renders a horizontal line to a cell buffer.
- *
- * @param buffer - The cell buffer to render to
- * @param x - Starting column (0-indexed)
- * @param y - Row (0-indexed)
- * @param length - Line length
- * @param char - Character to use (default: horizontal box char)
- * @param fg - Foreground color (optional)
- * @param bg - Background color (optional)
- *
- * @example
- * ```typescript
- * import { createCellBuffer, renderHLine, BOX_SINGLE } from 'blecsd';
- *
- * const buffer = createCellBuffer(80, 24);
- * renderHLine(buffer, 5, 10, 20, BOX_SINGLE.horizontal);
- * ```
- */
-declare function renderHLine(buffer: CellBuffer, x: number, y: number, length: number, char?: string, fg?: number, bg?: number): void;
-/**
- * Renders a vertical line to a cell buffer.
- *
- * @param buffer - The cell buffer to render to
- * @param x - Column (0-indexed)
- * @param y - Starting row (0-indexed)
- * @param length - Line length
- * @param char - Character to use (default: vertical box char)
- * @param fg - Foreground color (optional)
- * @param bg - Background color (optional)
- *
- * @example
- * ```typescript
- * import { createCellBuffer, renderVLine, BOX_SINGLE } from 'blecsd';
- *
- * const buffer = createCellBuffer(80, 24);
- * renderVLine(buffer, 10, 5, 10, BOX_SINGLE.vertical);
- * ```
- */
-declare function renderVLine(buffer: CellBuffer, x: number, y: number, length: number, char?: string, fg?: number, bg?: number): void;
-/**
- * Fills a rectangular region with a character.
- *
- * @param buffer - The cell buffer to render to
- * @param x - Left column (0-indexed)
- * @param y - Top row (0-indexed)
- * @param width - Region width
- * @param height - Region height
- * @param char - Fill character (default: ' ')
- * @param fg - Foreground color (optional)
- * @param bg - Background color (optional)
- *
- * @example
- * ```typescript
- * import { createCellBuffer, fillRect } from 'blecsd';
- *
- * const buffer = createCellBuffer(80, 24);
- * fillRect(buffer, 5, 2, 20, 10, ' ', 0xffffffff, 0x0000aaff);
- * ```
- */
-declare function fillRect(buffer: CellBuffer, x: number, y: number, width: number, height: number, char?: string, fg?: number, bg?: number): void;
-/**
- * Renders text to a cell buffer.
- *
- * @param buffer - The cell buffer to render to
- * @param x - Starting column (0-indexed)
- * @param y - Row (0-indexed)
- * @param text - Text to render
- * @param fg - Foreground color (optional)
- * @param bg - Background color (optional)
- *
- * @example
- * ```typescript
- * import { createCellBuffer, renderText } from 'blecsd';
- *
- * const buffer = createCellBuffer(80, 24);
- * renderText(buffer, 10, 5, 'Hello, World!');
- * ```
- */
-declare function renderText(buffer: CellBuffer, x: number, y: number, text: string, fg?: number, bg?: number): void;
-/**
- * Converts a cell buffer to a string representation.
- * Useful for testing and debugging.
- *
- * @param buffer - The cell buffer with cells property
- * @returns String representation of the buffer
- *
- * @example
- * ```typescript
- * import { createCellBuffer, renderBox, BOX_SINGLE, bufferToString } from 'blecsd';
- *
- * const buffer = createCellBuffer(10, 5);
- * renderBox(buffer, 0, 0, 10, 5, BOX_SINGLE);
- * console.log(bufferToString(buffer));
- * // Output:
- * // ┌────────┐
- * // │        │
- * // │        │
- * // │        │
- * // └────────┘
- * ```
- */
-declare function bufferToString$1(buffer: CellBuffer & {
-    cells: Cell[][];
-}): string;
-
 /**
  * Text buffer change coalescing.
  *
@@ -937,50 +701,6 @@ declare function getDiffStats(result: DiffResult): {
     collapsedChunks: number;
 };
 
-/**
- * Codepage character mapping tables.
- *
- * Each codepage maps byte values (0-255) to their corresponding UTF-8 characters.
- * Bytes 0x00-0x7F are standard ASCII for all codepages.
- *
- * @module utils/encoding/codepages
- */
-/**
- * CP437 (IBM PC / DOS) extended character set.
- *
- * The high bytes (0x80-0xFF) contain box-drawing characters, block elements,
- * mathematical symbols, and Greek letters commonly used in DOS applications
- * and ANSI art.
- *
- * @see https://en.wikipedia.org/wiki/Code_page_437
- */
-declare const CP437_HIGH_BYTES: readonly string[];
-/**
- * CP437 control character symbols (0x00-0x1F).
- *
- * In CP437, these bytes can display as special symbols rather than control codes.
- */
-declare const CP437_CONTROL_CHARS: readonly string[];
-/**
- * CP850 (DOS Latin-1) extended character set.
- *
- * Similar to CP437 but with more accented Latin characters and fewer
- * box-drawing/Greek characters.
- */
-declare const CP850_HIGH_BYTES: readonly string[];
-/**
- * CP866 (DOS Cyrillic) extended character set.
- *
- * Provides Cyrillic characters for Russian and other Slavic languages.
- */
-declare const CP866_HIGH_BYTES: readonly string[];
-/**
- * CP1252 (Windows Latin-1) extended character set.
- *
- * Windows Western European codepage. More standardized than DOS codepages.
- */
-declare const CP1252_HIGH_BYTES: readonly string[];
-
 /**
  * Legacy codepage encoding utilities.
  *
@@ -1031,9 +751,9 @@ type CodePage = z.infer<typeof CodePageSchema>;
  * - `error`: Throw an error on unmappable characters
  */
 declare const UnmappableModeSchema: z.ZodEnum<{
-    error: "error";
-    skip: "skip";
     replace: "replace";
+    skip: "skip";
+    error: "error";
 }>;
 /**
  * Unmappable character handling mode type.
@@ -1050,9 +770,9 @@ declare const ConversionOptionsSchema: z.ZodObject<{
         cp1252: "cp1252";
     }>;
     unmappable: z.ZodDefault<z.ZodEnum<{
-        error: "error";
-        skip: "skip";
         replace: "replace";
+        skip: "skip";
+        error: "error";
     }>>;
     replacement: z.ZodDefault<z.ZodString>;
     interpretControlChars: z.ZodDefault<z.ZodBoolean>;
@@ -1217,29 +937,6 @@ declare function getSupportedCodePages(): readonly CodePage[];
  */
 declare function getCodePageMap(codepage: CodePage, options?: PartialConversionOptions): readonly string[];
 
-declare const index_CP1252_HIGH_BYTES: typeof CP1252_HIGH_BYTES;
-declare const index_CP437_CONTROL_CHARS: typeof CP437_CONTROL_CHARS;
-declare const index_CP437_HIGH_BYTES: typeof CP437_HIGH_BYTES;
-declare const index_CP850_HIGH_BYTES: typeof CP850_HIGH_BYTES;
-declare const index_CP866_HIGH_BYTES: typeof CP866_HIGH_BYTES;
-type index_CodePage = CodePage;
-declare const index_CodePageSchema: typeof CodePageSchema;
-type index_ConversionOptions = ConversionOptions;
-declare const index_ConversionOptionsSchema: typeof ConversionOptionsSchema;
-type index_PartialConversionOptions = PartialConversionOptions;
-type index_UnmappableMode = UnmappableMode;
-declare const index_UnmappableModeSchema: typeof UnmappableModeSchema;
-declare const index_bufferToString: typeof bufferToString;
-declare const index_byteToChar: typeof byteToChar;
-declare const index_charToByte: typeof charToByte;
-declare const index_getCodePageMap: typeof getCodePageMap;
-declare const index_getSupportedCodePages: typeof getSupportedCodePages;
-declare const index_isCodePageSupported: typeof isCodePageSupported;
-declare const index_stringToBuffer: typeof stringToBuffer;
-declare namespace index {
-  export { index_CP1252_HIGH_BYTES as CP1252_HIGH_BYTES, index_CP437_CONTROL_CHARS as CP437_CONTROL_CHARS, index_CP437_HIGH_BYTES as CP437_HIGH_BYTES, index_CP850_HIGH_BYTES as CP850_HIGH_BYTES, index_CP866_HIGH_BYTES as CP866_HIGH_BYTES, type index_CodePage as CodePage, index_CodePageSchema as CodePageSchema, type index_ConversionOptions as ConversionOptions, index_ConversionOptionsSchema as ConversionOptionsSchema, type index_PartialConversionOptions as PartialConversionOptions, type index_UnmappableMode as UnmappableMode, index_UnmappableModeSchema as UnmappableModeSchema, index_bufferToString as bufferToString, index_byteToChar as byteToChar, index_charToByte as charToByte, index_getCodePageMap as getCodePageMap, index_getSupportedCodePages as getSupportedCodePages, index_isCodePageSupported as isCodePageSupported, index_stringToBuffer as stringToBuffer };
-}
-
 /**
  * Fast Word Wrap with Caching
  *
@@ -1824,7 +1521,7 @@ declare function fuzzyMatch(query: string, text: string, options?: FuzzyOptions)
  * // ]
  * ```
  */
-declare function fuzzySearch(query: string, items: readonly string[], options?: FuzzyOptions): FuzzyMatch<string>[];
+declare function fuzzySearch$1(query: string, items: readonly string[], options?: FuzzyOptions): FuzzyMatch<string>[];
 /**
  * Performs fuzzy search on an array of objects.
  *
@@ -2517,12 +2214,9 @@ declare function gutterWidthChanged(oldTotal: number, newTotal: number, minWidth
 declare function renderGutterBlock(result: GutterResult, currentHighlight: string, normalStyle: string, reset?: string): readonly string[];
 
 /**
- * Incremental Syntax Highlighting
- *
- * Line-based tokenization with state tracking for efficient re-highlighting.
- * Only changed lines and affected multi-line constructs are re-processed.
+ * Type definitions for syntax highlighting.
  *
- * @module utils/syntaxHighlight
+ * @module utils/syntaxHighlight/types
  */
 /**
  * Token types for syntax highlighting.
@@ -2618,40 +2312,13 @@ interface HighlightStats {
     readonly lineCount: number;
     readonly fullInvalidate: boolean;
 }
-/** Default batch size for background highlighting */
-declare const DEFAULT_HIGHLIGHT_BATCH = 100;
-/** Initial empty line state */
-declare const EMPTY_STATE: LineState;
-/**
- * JavaScript/TypeScript grammar.
- */
-declare const GRAMMAR_JAVASCRIPT: Grammar;
-/**
- * Python grammar.
- */
-declare const GRAMMAR_PYTHON: Grammar;
-/**
- * Rust grammar.
- */
-declare const GRAMMAR_RUST: Grammar;
-/**
- * Go grammar.
- */
-declare const GRAMMAR_GO: Grammar;
-/**
- * Shell/Bash grammar.
- */
-declare const GRAMMAR_SHELL: Grammar;
-/**
- * JSON grammar.
- */
-declare const GRAMMAR_JSON: Grammar;
+
 /**
- * Plain text (no highlighting).
+ * Cache management for syntax highlighting.
+ *
+ * @module utils/syntaxHighlight/cache
  */
-declare const GRAMMAR_PLAINTEXT: Grammar;
-/** All available grammars */
-declare const GRAMMARS: readonly Grammar[];
+
 /**
  * Creates a new highlight cache.
  *
@@ -2700,15 +2367,75 @@ declare function invalidateLine(cache: HighlightCache, line: number): void;
  * @param cache - The cache to update
  */
 declare function invalidateAllLines(cache: HighlightCache): void;
+
 /**
- * Tokenizes a single line.
+ * Constants for syntax highlighting.
  *
- * @param grammar - The grammar to use
- * @param line - The line text
- * @param startState - The state at the start of the line
- * @returns The line entry with tokens and end state
+ * @module utils/syntaxHighlight/constants
  */
-declare function tokenizeLine(grammar: Grammar, line: string, startState: LineState): LineEntry;
+
+/** Default batch size for background highlighting */
+declare const DEFAULT_HIGHLIGHT_BATCH = 100;
+/** Initial empty line state */
+declare const EMPTY_STATE: LineState;
+
+/**
+ * Language grammar definitions for syntax highlighting.
+ *
+ * @module utils/syntaxHighlight/grammars
+ */
+
+/**
+ * JavaScript/TypeScript grammar.
+ */
+declare const GRAMMAR_SHELL: Grammar;
+/**
+ * JSON grammar.
+ */
+declare const GRAMMAR_JSON: Grammar;
+/**
+ * Plain text (no highlighting).
+ */
+declare const GRAMMAR_PLAINTEXT: Grammar;
+/** All available grammars */
+declare const GRAMMARS: readonly Grammar[];
+
+/**
+ * Language grammar definitions for syntax highlighting.
+ *
+ * @module utils/syntaxHighlight/grammars
+ */
+
+/**
+ * JavaScript/TypeScript grammar.
+ */
+declare const GRAMMAR_RUST: Grammar;
+/**
+ * Go grammar.
+ */
+declare const GRAMMAR_GO: Grammar;
+
+/**
+ * Language grammar definitions for syntax highlighting.
+ *
+ * @module utils/syntaxHighlight/grammars
+ */
+
+/**
+ * JavaScript/TypeScript grammar.
+ */
+declare const GRAMMAR_JAVASCRIPT: Grammar;
+/**
+ * Python grammar.
+ */
+declare const GRAMMAR_PYTHON: Grammar;
+
+/**
+ * Highlighting and language detection logic.
+ *
+ * @module utils/syntaxHighlight/highlighter
+ */
+
 /**
  * Highlights text and caches the results.
  *
@@ -2759,6 +2486,22 @@ declare function detectLanguageFromContent(content: string): Grammar;
  */
 declare function getGrammarByName(name: string): Grammar;
 
+/**
+ * Tokenization logic for syntax highlighting.
+ *
+ * @module utils/syntaxHighlight/tokenizer
+ */
+
+/**
+ * Tokenizes a single line.
+ *
+ * @param grammar - The grammar to use
+ * @param line - The line text
+ * @param startState - The state at the start of the line
+ * @returns The line entry with tokens and end state
+ */
+declare function tokenizeLine(grammar: Grammar, line: string, startState: LineState): LineEntry;
+
 /**
  * Efficient Markdown Rendering
  *
@@ -2969,377 +2712,477 @@ interface MarkdownStats {
  */
 declare function getMarkdownStats(result: MarkdownParseResult): MarkdownStats;
 
+declare const boxRender: Readonly<{
+    renderBox: typeof renderBox;
+    renderHLine: typeof renderHLine;
+    renderVLine: typeof renderVLine;
+    renderText: typeof renderText;
+    createCellBuffer: typeof createCellBuffer;
+    bufferToString: typeof bufferToString$1;
+    boxFillRect: typeof boxFillRect;
+    charsetToBoxChars: typeof charsetToBoxChars;
+    BOX_ASCII: BoxChars;
+    BOX_BOLD: BoxChars;
+    BOX_DASHED: BoxChars;
+    BOX_DOUBLE: BoxChars;
+    BOX_ROUNDED: BoxChars;
+    BOX_SINGLE: BoxChars;
+}>;
+type BoxRenderModule = typeof boxRender;
+
 /**
- * Rope Data Structure for Large Text Buffers
- *
- * A rope is a binary tree where leaf nodes contain text strings and internal
- * nodes contain the total length of text in their left subtree. This allows
- * for O(log n) insert, delete, and index operations.
- *
- * @module utils/rope
- *
- * @example
- * ```typescript
- * import { createRope, insert, deleteRange, getLine, getText } from 'blecsd';
- *
- * // Create a rope from text
- * let rope = createRope('Hello, World!');
- *
- * // Insert at position
- * rope = insert(rope, 7, 'Beautiful ');
- * // Result: "Hello, Beautiful World!"
- *
- * // Delete a range
- * rope = deleteRange(rope, 0, 7);
- * // Result: "Beautiful World!"
- *
- * // Get specific line
- * const line = getLine(rope, 0);
- * ```
- */
-/**
- * Maximum characters in a leaf node.
- * Smaller values give better balance but more nodes.
- * Larger values reduce overhead but slower operations.
- */
-declare const LEAF_MAX_SIZE = 512;
-/**
- * Minimum characters in a leaf node before merging.
- */
-declare const LEAF_MIN_SIZE = 256;
-/**
- * Maximum depth before forcing rebalance.
- */
-declare const MAX_DEPTH = 48;
-/**
- * A leaf node containing actual text content.
- */
-interface RopeLeaf {
-    readonly type: 'leaf';
-    /** The text content of this leaf */
-    readonly text: string;
-    /** Total number of characters */
-    readonly length: number;
-    /** Number of newlines in this leaf */
-    readonly newlines: number;
-    /** Line break positions within this leaf (relative to start) */
-    readonly lineBreaks: readonly number[];
-}
-/**
- * An internal node containing two subtrees.
- */
-interface RopeNode {
-    readonly type: 'node';
-    /** Left subtree */
-    readonly left: Rope;
-    /** Right subtree */
-    readonly right: Rope;
-    /** Total length of left subtree (weight) */
-    readonly leftLength: number;
-    /** Total length of entire subtree */
-    readonly length: number;
-    /** Total newlines in entire subtree */
-    readonly newlines: number;
-    /** Depth of tree from this node */
-    readonly depth: number;
-}
-/**
- * A rope is either a leaf or an internal node.
- */
-type Rope = RopeLeaf | RopeNode;
-/**
- * Line information returned by getLine.
- */
-interface LineInfo {
-    /** Line content (without newline) */
-    readonly text: string;
-    /** Start index in rope */
-    readonly start: number;
-    /** End index in rope (exclusive) */
-    readonly end: number;
-    /** Line number (0-based) */
-    readonly lineNumber: number;
-}
-/**
- * Statistics about a rope.
- */
-interface RopeStats {
-    /** Total characters */
-    readonly length: number;
-    /** Total newlines */
-    readonly newlines: number;
-    /** Number of leaf nodes */
-    readonly leafCount: number;
-    /** Maximum depth */
-    readonly depth: number;
-    /** Average leaf size */
-    readonly avgLeafSize: number;
-}
-/**
- * Creates a rope from a string.
- *
- * @param text - Initial text content
- * @returns A new Rope
+ * Change coalescing utilities namespace.
  *
  * @example
  * ```typescript
- * import { createRope } from 'blecsd';
+ * import { changeCoalesce } from 'blecsd/utils';
  *
- * const rope = createRope('Hello, World!');
+ * const coalescer = changeCoalesce.createCoalescer({ debounceMs: 50 });
+ * changeCoalesce.queueChange(coalescer, changeCoalesce.insertChange(10, 'hello'));
+ * const result = changeCoalesce.flushChanges(coalescer);
  * ```
  */
-declare function createRope(text?: string): Rope;
-/**
- * Creates an empty rope.
- *
- * @returns An empty Rope
- */
-declare function createEmptyRope(): Rope;
+
+declare const changeCoalesce: Readonly<{
+    createCoalescer: typeof createCoalescer;
+    queueChange: typeof queueChange;
+    flushChanges: typeof flushChanges;
+    insertChange: typeof insertChange;
+    deleteChange: typeof deleteChange;
+    replaceChange: typeof replaceChange;
+    getCoalescingState: typeof getCoalescingState;
+    destroyCoalescer: typeof destroyCoalescer;
+}>;
+type ChangeCoalesceModule = typeof changeCoalesce;
+
 /**
- * Gets the total length of the rope.
- *
- * @param rope - The rope to measure
- * @returns Total character count
+ * Color utilities namespace.
  *
  * @example
  * ```typescript
- * import { createRope, getLength } from 'blecsd';
+ * import { colors } from 'blecsd/utils';
  *
- * const rope = createRope('Hello');
- * console.log(getLength(rope)); // 5
+ * const hex = colors.colorToHex(255, 0, 0);
+ * const color = colors.hexToColor('#ff0000');
+ * const packed = colors.packColor(255, 0, 0);
  * ```
  */
-declare function getLength(rope: Rope): number;
-/**
- * Gets the total number of newlines in the rope.
- *
- * @param rope - The rope to measure
- * @returns Total newline count
- */
-declare function getNewlineCount(rope: Rope): number;
-/**
- * Gets the total number of lines (newlines + 1).
- *
- * @param rope - The rope to measure
- * @returns Line count
- */
-declare function getLineCount(rope: Rope): number;
-/**
- * Checks if the rope is empty.
- *
- * @param rope - The rope to check
- * @returns true if empty
- */
-declare function isEmpty(rope: Rope): boolean;
+
+declare const colors: Readonly<{
+    colorToHex: typeof colorToHex;
+    hexToColor: typeof hexToColor;
+    packColor: typeof packColor;
+    unpackColor: typeof unpackColor;
+    parseColor: typeof parseColor;
+}>;
+type ColorsModule = typeof colors;
+
 /**
- * Gets the character at a specific index.
- *
- * @param rope - The rope to query
- * @param index - Character index (0-based)
- * @returns Character at index, or undefined if out of bounds
+ * Component storage utilities namespace.
  *
  * @example
  * ```typescript
- * import { createRope, charAt } from 'blecsd';
+ * import { componentStore } from 'blecsd/utils';
  *
- * const rope = createRope('Hello');
- * console.log(charAt(rope, 0)); // 'H'
+ * const store = componentStore.createComponentStore({ maxEntities: 10000 });
+ * const sparse = componentStore.createSparseStore({ defaultValue: 0 });
+ * const report = componentStore.getComponentMemoryReport(store);
  * ```
  */
-declare function charAt(rope: Rope, index: number): string | undefined;
+
+declare const componentStore: Readonly<{
+    createComponentStore: typeof createComponentStore;
+    createSparseStore: typeof createSparseStore;
+    createTypedArrayPool: typeof createTypedArrayPool;
+    getComponentMemoryReport: typeof getComponentMemoryReport;
+    estimateMemoryUsage: typeof estimateMemoryUsage;
+    isWithinMemoryBounds: typeof isWithinMemoryBounds;
+}>;
+type ComponentStoreModule = typeof componentStore;
+
 /**
- * Gets a substring from the rope.
- *
- * @param rope - The rope to query
- * @param start - Start index (inclusive)
- * @param end - End index (exclusive), defaults to end of rope
- * @returns Substring
+ * Cursor navigation utilities namespace.
  *
  * @example
  * ```typescript
- * import { createRope, substring } from 'blecsd';
+ * import { cursorNav } from 'blecsd/utils';
  *
- * const rope = createRope('Hello, World!');
- * console.log(substring(rope, 0, 5)); // 'Hello'
+ * const cursor = cursorNav.createCursor(0, 0);
+ * const result = cursorNav.moveCursorDown(cursor, viewport, lineIndex);
+ * cursorNav.goToLine(cursor, 10);
  * ```
  */
-declare function substring(rope: Rope, start: number, end?: number): string;
+
+declare const cursorNav: Readonly<{
+    createCursor: typeof createCursor;
+    moveCursorUp: typeof moveCursorUp;
+    moveCursorDown: typeof moveCursorDown;
+    moveCursorLeft: typeof moveCursorLeft;
+    moveCursorRight: typeof moveCursorRight;
+    goToLine: typeof goToLine;
+    goToStart: typeof goToStart;
+    goToEnd: typeof goToEnd;
+    pageUp: typeof pageUp;
+    pageDown: typeof pageDown;
+    clampCursor: typeof clampCursor;
+    ensureCursorVisible: typeof ensureCursorVisible;
+    createViewport: typeof createViewport;
+    createNavConfig: typeof createNavConfig;
+    buildLineIndex: typeof buildLineIndex;
+    buildLineIndexFromLengths: typeof buildLineIndexFromLengths;
+    lineForOffset: typeof lineForOffset;
+    offsetForLine: typeof offsetForLine;
+}>;
+type CursorNavModule = typeof cursorNav;
+
 /**
- * Converts entire rope to string.
- *
- * @param rope - The rope to convert
- * @returns Full text content
+ * Diff rendering utilities namespace.
  *
  * @example
  * ```typescript
- * import { createRope, getText } from 'blecsd';
+ * import { diffRenderer } from 'blecsd/utils';
  *
- * const rope = createRope('Hello');
- * console.log(getText(rope)); // 'Hello'
+ * const diff = diffRenderer.computeDiff(oldLines, newLines);
+ * const cache = diffRenderer.createDiffCache();
+ * const cached = diffRenderer.computeDiffCached(cache, oldLines, newLines);
+ * const stats = diffRenderer.getDiffStats(diff);
  * ```
  */
-declare function getText(rope: Rope): string;
+
+declare const diffRenderer: Readonly<{
+    computeDiff: typeof computeDiff;
+    computeDiffCached: typeof computeDiffCached;
+    getDiffStats: typeof getDiffStats;
+    getSideBySideView: typeof getSideBySideView;
+    parseUnifiedDiff: typeof parseUnifiedDiff;
+    toUnifiedDiff: typeof toUnifiedDiff;
+    createDiffCache: typeof createDiffCache;
+    clearDiffCache: typeof clearDiffCache;
+    collapseUnchanged: typeof collapseUnchanged;
+    collapseChunk: typeof collapseChunk;
+    expandChunk: typeof expandChunk;
+    expandAll: typeof expandAll;
+    toggleChunk: typeof toggleChunk;
+    getVisibleDiffLines: typeof getVisibleDiffLines;
+    getTotalLineCount: typeof getTotalLineCount$1;
+    DEFAULT_CONTEXT: 3;
+    DEFAULT_COLLAPSE_THRESHOLD: 10;
+}>;
+type DiffRendererModule = typeof diffRenderer;
+
+declare const encoding: Readonly<{
+    byteToChar: typeof byteToChar;
+    charToByte: typeof charToByte;
+    bufferToString: typeof bufferToString;
+    stringToBuffer: typeof stringToBuffer;
+    isCodePageSupported: typeof isCodePageSupported;
+    getSupportedCodePages: typeof getSupportedCodePages;
+    getCodePageMap: typeof getCodePageMap;
+    CodePageSchema: zod.ZodEnum<{
+        cp437: "cp437";
+        cp850: "cp850";
+        cp866: "cp866";
+        cp1252: "cp1252";
+    }>;
+    UnmappableModeSchema: zod.ZodEnum<{
+        replace: "replace";
+        skip: "skip";
+        error: "error";
+    }>;
+    ConversionOptionsSchema: zod.ZodObject<{
+        codepage: zod.ZodEnum<{
+            cp437: "cp437";
+            cp850: "cp850";
+            cp866: "cp866";
+            cp1252: "cp1252";
+        }>;
+        unmappable: zod.ZodDefault<zod.ZodEnum<{
+            replace: "replace";
+            skip: "skip";
+            error: "error";
+        }>>;
+        replacement: zod.ZodDefault<zod.ZodString>;
+        interpretControlChars: zod.ZodDefault<zod.ZodBoolean>;
+    }, zod_v4_core.$strict>;
+    CP437_CONTROL_CHARS: readonly string[];
+    CP437_HIGH_BYTES: readonly string[];
+    CP850_HIGH_BYTES: readonly string[];
+    CP866_HIGH_BYTES: readonly string[];
+    CP1252_HIGH_BYTES: readonly string[];
+}>;
+type EncodingModule = typeof encoding;
+
 /**
- * Gets the line index for a character position.
- *
- * @param rope - The rope to query
- * @param index - Character index
- * @returns Line number (0-based)
+ * Fast word wrap utilities namespace with caching support.
  *
  * @example
  * ```typescript
- * import { createRope, getLineForIndex } from 'blecsd';
+ * import { fastWrap } from 'blecsd/utils';
  *
- * const rope = createRope('Line 1\nLine 2\nLine 3');
- * console.log(getLineForIndex(rope, 7)); // 1 (start of 'Line 2')
+ * const cache = fastWrap.createWrapCache();
+ * const result = fastWrap.wrapWithCache(cache, text, width);
+ * const visible = fastWrap.wrapVisibleFirst(cache, text, width, startLine, endLine);
  * ```
  */
-declare function getLineForIndex(rope: Rope, index: number): number;
-/**
- * Gets the start index of a line.
- *
- * @param rope - The rope to query
- * @param lineNumber - Line number (0-based)
- * @returns Start index of line, or -1 if out of bounds
- */
-declare function getLineStart(rope: Rope, lineNumber: number): number;
-/**
- * Gets the end index of a line (position of newline or end of rope).
- *
- * @param rope - The rope to query
- * @param lineNumber - Line number (0-based)
- * @returns End index of line, or -1 if out of bounds
- */
-declare function getLineEnd(rope: Rope, lineNumber: number): number;
+
+declare const fastWrap: Readonly<{
+    wrapWithCache: typeof wrapWithCache;
+    wrapVisibleFirst: typeof wrapVisibleFirst;
+    continueWrap: typeof continueWrap;
+    createWrapCache: typeof createWrapCache;
+    clearWrapCache: typeof clearWrapCache;
+    resizeWrapCache: typeof resizeWrapCache;
+    invalidateAll: typeof invalidateAll;
+    invalidateRange: typeof invalidateRange;
+    invalidateParagraph: typeof invalidateParagraph;
+    lineToPosition: typeof lineToPosition;
+    positionToLine: typeof positionToLine;
+    getWrapCacheStats: typeof getWrapCacheStats;
+    DEFAULT_BATCH_SIZE: 100;
+    MAX_PARAGRAPH_CHUNK: 1000;
+}>;
+type FastWrapModule = typeof fastWrap;
+
 /**
- * Gets a specific line's content.
- *
- * @param rope - The rope to query
- * @param lineNumber - Line number (0-based)
- * @returns Line info or undefined if out of bounds
+ * Fold regions utilities namespace.
  *
  * @example
  * ```typescript
- * import { createRope, getLine } from 'blecsd';
+ * import { fold } from 'blecsd/utils';
  *
- * const rope = createRope('Line 1\nLine 2\nLine 3');
- * const line = getLine(rope, 1);
- * console.log(line?.text); // 'Line 2'
+ * const state = fold.createFoldState(100);
+ * fold.addFoldRegion(state, { start: 10, end: 20, level: 0 });
+ * fold.foldRegion(state, 0);
+ * const visible = fold.getVisibleFoldLines(state, 0, 50);
  * ```
  */
-declare function getLine(rope: Rope, lineNumber: number): LineInfo | undefined;
+
+declare const fold: Readonly<{
+    createFoldState: typeof createFoldState;
+    addFoldRegion: typeof addFoldRegion;
+    removeFoldRegion: typeof removeFoldRegion;
+    foldRegion: typeof foldRegion;
+    unfoldRegion: typeof unfoldRegion;
+    toggleFold: typeof toggleFold;
+    foldAll: typeof foldAll;
+    unfoldAll: typeof unfoldAll;
+    foldAtDepth: typeof foldAtDepth;
+    getVisibleFoldLines: typeof getVisibleFoldLines;
+    getAllFoldRegions: typeof getAllFoldRegions;
+    getFoldAtLine: typeof getFoldAtLine;
+    getFoldStats: typeof getFoldStats;
+    originalToVisibleLine: typeof originalToVisibleLine;
+    visibleToOriginalLine: typeof visibleToOriginalLine;
+    updateTotalLines: typeof updateTotalLines;
+}>;
+type FoldModule = typeof fold;
+
+declare const fuzzySearch: Readonly<{
+    fuzzyMatch: typeof fuzzyMatch;
+    search: typeof fuzzySearch$1;
+    fuzzyFilter: typeof fuzzyFilter;
+    fuzzySearchBy: typeof fuzzySearchBy;
+    fuzzyTest: typeof fuzzyTest;
+    highlightMatch: typeof highlightMatch;
+    FuzzyOptionsSchema: zod.ZodObject<{
+        caseSensitive: zod.ZodDefault<zod.ZodBoolean>;
+        threshold: zod.ZodDefault<zod.ZodNumber>;
+        limit: zod.ZodOptional<zod.ZodNumber>;
+        consecutiveBonus: zod.ZodDefault<zod.ZodNumber>;
+        wordBoundaryBonus: zod.ZodDefault<zod.ZodNumber>;
+        prefixBonus: zod.ZodDefault<zod.ZodNumber>;
+        gapPenalty: zod.ZodDefault<zod.ZodNumber>;
+    }, zod_v4_core.$strip>;
+}>;
+type FuzzySearchModule = typeof fuzzySearch;
+
 /**
- * Gets a range of lines.
- *
- * @param rope - The rope to query
- * @param startLine - Start line (inclusive)
- * @param endLine - End line (exclusive)
- * @returns Array of line info
+ * Line gutter utilities namespace.
  *
  * @example
  * ```typescript
- * import { createRope, getLines } from 'blecsd';
+ * import { gutter } from 'blecsd/utils';
  *
- * const rope = createRope('Line 1\nLine 2\nLine 3');
- * const lines = getLines(rope, 0, 2);
- * // lines = [{ text: 'Line 1', ... }, { text: 'Line 2', ... }]
+ * const config = gutter.createGutterConfig({ mode: 'absolute' });
+ * const width = gutter.computeGutterWidth(100);
+ * const result = gutter.computeVisibleGutter(config, 0, 50, 100);
  * ```
  */
-declare function getLines(rope: Rope, startLine: number, endLine: number): LineInfo[];
+
+declare const gutter: Readonly<{
+    computeGutterWidth: typeof computeGutterWidth;
+    computeVisibleGutter: typeof computeVisibleGutter;
+    formatLineNumber: typeof formatLineNumber;
+    renderGutterBlock: typeof renderGutterBlock;
+    createGutterConfig: typeof createGutterConfig;
+    computeDigitWidth: typeof computeDigitWidth;
+    gutterWidthChanged: typeof gutterWidthChanged;
+}>;
+type GutterModule = typeof gutter;
+
 /**
- * Inserts text at a position.
- *
- * @param rope - The rope to modify
- * @param index - Position to insert at
- * @param text - Text to insert
- * @returns New rope with text inserted
+ * Helper utilities namespace for common operations.
  *
  * @example
  * ```typescript
- * import { createRope, insert } from 'blecsd';
+ * import { helpers } from 'blecsd/utils';
  *
- * let rope = createRope('Hello World');
- * rope = insert(rope, 6, 'Beautiful ');
- * // Result: 'Hello Beautiful World'
+ * const grouped = helpers.groupBy(items, item => item.category);
+ * const sorted = helpers.sortBy(items, item => item.priority);
+ * const unique = helpers.unique([1, 2, 2, 3]);
  * ```
  */
-declare function insert(rope: Rope, index: number, text: string): Rope;
+
+declare const helpers: Readonly<{
+    findFile: typeof findFile;
+    findAllFiles: typeof findAllFiles;
+    groupBy: typeof groupBy;
+    merge: typeof merge;
+    shallowMerge: typeof shallowMerge;
+    partition: typeof partition;
+    unique: typeof unique;
+    uniqueBy: typeof uniqueBy;
+    sortBy: typeof sortBy;
+    sortByIndex: typeof sortByIndex;
+    sortByName: typeof sortByName;
+    sortByPriority: typeof sortByPriority;
+}>;
+type HelpersModule = typeof helpers;
+
 /**
- * Appends text to the end.
- *
- * @param rope - The rope to modify
- * @param text - Text to append
- * @returns New rope with text appended
+ * Lazy content loading utilities namespace.
  *
  * @example
  * ```typescript
- * import { createRope, append } from 'blecsd';
+ * import { lazyContent } from 'blecsd/utils';
  *
- * let rope = createRope('Hello');
- * rope = append(rope, ' World');
- * // Result: 'Hello World'
+ * const source = lazyContent.createArraySource(lines);
+ * const content = lazyContent.createLazyContent(source, { chunkSize: 100 });
+ * const lines = lazyContent.getLazyLines(content, 0, 50);
+ * lazyContent.prefetchAround(content, 100);
  * ```
  */
-declare function append(rope: Rope, text: string): Rope;
-/**
- * Prepends text to the start.
- *
- * @param rope - The rope to modify
- * @param text - Text to prepend
- * @returns New rope with text prepended
- */
-declare function prepend(rope: Rope, text: string): Rope;
+
+declare const lazyContent: Readonly<{
+    createLazyContent: typeof createLazyContent;
+    createArraySource: typeof createArraySource;
+    getLazyLines: typeof getLazyLines;
+    prefetchAround: typeof prefetchAround;
+    evictChunks: typeof evictChunks;
+    isRangeLoaded: typeof isRangeLoaded;
+    getLazyContentState: typeof getLazyContentState;
+    clearLazyContent: typeof clearLazyContent;
+}>;
+type LazyContentModule = typeof lazyContent;
+
+declare const lineStore: Readonly<{
+    createLineStore: typeof createLineStore;
+    createLineStoreFromLines: typeof createLineStoreFromLines;
+    createEmptyLineStore: typeof createEmptyLineStore;
+    appendToStore: typeof appendToStore;
+    appendLines: typeof appendLines;
+    getLineAtIndex: typeof getLineAtIndex;
+    getLineRange: typeof getLineRange;
+    getLineCount: typeof getLineCount;
+    getLineForOffset: typeof getLineForOffset;
+    getOffsetForLine: typeof getOffsetForLine;
+    getLineInfo: typeof getLineInfo;
+    getVisibleLines: typeof getVisibleLines;
+    exportContent: typeof exportContent;
+    exportLineRange: typeof exportLineRange;
+    getStoreStats: typeof getStoreStats;
+    getByteSize: typeof getByteSize;
+    isStoreEmpty: typeof isStoreEmpty;
+    trimToLineCount: typeof trimToLineCount;
+    CHUNKED_THRESHOLD: 1000000;
+    LineIndexSchema: zod.ZodNumber;
+    LineRangeParamsSchema: zod.ZodObject<{
+        startLine: zod.ZodNumber;
+        endLine: zod.ZodNumber;
+    }, zod_v4_core.$strip>;
+    TrimParamsSchema: zod.ZodObject<{
+        maxLines: zod.ZodNumber;
+    }, zod_v4_core.$strip>;
+    VisibleLinesParamsSchema: zod.ZodObject<{
+        firstVisible: zod.ZodNumber;
+        visibleCount: zod.ZodNumber;
+        overscanBefore: zod.ZodDefault<zod.ZodNumber>;
+        overscanAfter: zod.ZodDefault<zod.ZodNumber>;
+    }, zod_v4_core.$strip>;
+}>;
+type LineStoreModule = typeof lineStore;
+
 /**
- * Deletes a range of text.
- *
- * @param rope - The rope to modify
- * @param start - Start index (inclusive)
- * @param end - End index (exclusive)
- * @returns New rope with range deleted
+ * Markdown rendering utilities namespace.
  *
  * @example
  * ```typescript
- * import { createRope, deleteRange } from 'blecsd';
+ * import { markdownRenderer } from 'blecsd/utils';
  *
- * let rope = createRope('Hello Beautiful World');
- * rope = deleteRange(rope, 6, 16);
- * // Result: 'Hello World'
+ * const result = markdownRenderer.parseMarkdown(text);
+ * const cache = markdownRenderer.createMarkdownCache();
+ * const cached = markdownRenderer.parseMarkdownCached(cache, text);
+ * const visible = markdownRenderer.getVisibleMarkdown(result, 0, 50);
  * ```
  */
-declare function deleteRange(rope: Rope, start: number, end: number): Rope;
+
+declare const markdownRenderer: Readonly<{
+    parseMarkdown: typeof parseMarkdown;
+    renderMarkdown: typeof renderMarkdown;
+    getVisibleMarkdown: typeof getVisibleMarkdown;
+    parseMarkdownCached: typeof parseMarkdownCached;
+    createMarkdownCache: typeof createMarkdownCache;
+    clearMarkdownCache: typeof clearMarkdownCache;
+    invalidateLines: typeof invalidateLines;
+    parseInline: typeof parseInline;
+    renderBlock: typeof renderBlock;
+    getMarkdownStats: typeof getMarkdownStats;
+    getTotalLineCount: typeof getTotalLineCount;
+    DEFAULT_PARSE_BATCH: 100;
+}>;
+type MarkdownRendererModule = typeof markdownRenderer;
+
 /**
- * Replaces a range of text.
- *
- * @param rope - The rope to modify
- * @param start - Start index (inclusive)
- * @param end - End index (exclusive)
- * @param text - Replacement text
- * @returns New rope with range replaced
+ * Rope data structure utilities namespace for efficient large text buffers.
  *
  * @example
  * ```typescript
- * import { createRope, replaceRange } from 'blecsd';
+ * import { rope } from 'blecsd/utils';
  *
- * let rope = createRope('Hello World');
- * rope = replaceRange(rope, 6, 11, 'Universe');
- * // Result: 'Hello Universe'
+ * const myRope = rope.createRope('Hello World');
+ * const updated = rope.insert(myRope, 5, ', Beautiful');
+ * const text = rope.getText(updated);
+ * const line = rope.getLine(updated, 0);
  * ```
  */
-declare function replaceRange(rope: Rope, start: number, end: number, text: string): Rope;
-/**
- * Gets statistics about the rope structure.
- *
- * @param rope - The rope to analyze
- * @returns Rope statistics
- */
-declare function getStats(rope: Rope): RopeStats;
-/**
- * Verifies rope integrity (for testing/debugging).
- *
- * @param rope - The rope to verify
- * @returns true if valid
- */
-declare function verify(rope: Rope): boolean;
+
+declare const rope: Readonly<{
+    createRope: typeof createRope;
+    createEmptyRope: typeof createEmptyRope;
+    insert: typeof insert;
+    deleteRange: typeof deleteRange;
+    replaceRange: typeof replaceRange;
+    getText: typeof getText;
+    getLine: typeof getLine;
+    getLineCount: typeof getLineCount$1;
+    append: typeof append;
+    prepend: typeof prepend;
+    charAt: typeof charAt;
+    substring: typeof substring;
+    getLength: typeof getLength;
+    getLineStart: typeof getLineStart;
+    getLineEnd: typeof getLineEnd;
+    getLineForIndex: typeof getLineForIndex;
+    getLines: typeof getLines;
+    getNewlineCount: typeof getNewlineCount;
+    getStats: typeof getStats;
+    isEmpty: typeof isEmpty;
+    verify: typeof verify;
+    LEAF_MAX_SIZE: 512;
+    LEAF_MIN_SIZE: 256;
+    MAX_DEPTH: 48;
+}>;
+type RopeModule = typeof rope;
 
 /**
  * Style attribute encoding for terminal rendering.
@@ -3459,7 +3302,7 @@ declare function attrsToStyle(attrs: number): {
  * // Uses provided defaults for fg/bg
  * ```
  */
-declare function sattr(style: StyleInput, defaultFg?: number, defaultBg?: number): StyleAttr;
+declare function sattr$1(style: StyleInput, defaultFg?: number, defaultBg?: number): StyleAttr;
 /**
  * Converts a StyleData object to a style attribute.
  * Convenience function for converting from Renderable component data.
@@ -3593,6 +3436,107 @@ declare function encodeStyleAttr(attr: StyleAttr): bigint;
  */
 declare function decodeStyleAttr(encoded: bigint): StyleAttr;
 
+/**
+ * Style attribute encoding utilities namespace.
+ *
+ * @example
+ * ```typescript
+ * import { sattr } from 'blecsd/utils';
+ *
+ * const attr = sattr.create({ fg: 0xffffff, bg: 0x000000, bold: true });
+ * const encoded = sattr.encodeStyleAttr(attr);
+ * const decoded = sattr.decodeStyleAttr(encoded);
+ * const merged = sattr.sattrMerge(attr, decoded);
+ * ```
+ */
+
+declare const sattr: Readonly<{
+    create: typeof sattr$1;
+    encodeStyleAttr: typeof encodeStyleAttr;
+    decodeStyleAttr: typeof decodeStyleAttr;
+    sattrMerge: typeof sattrMerge;
+    sattrEqual: typeof sattrEqual;
+    sattrInvert: typeof sattrInvert;
+    sattrCopy: typeof sattrCopy;
+    sattrEmpty: typeof sattrEmpty;
+    sattrAddFlag: typeof sattrAddFlag;
+    sattrRemoveFlag: typeof sattrRemoveFlag;
+    sattrHasFlag: typeof sattrHasFlag;
+    sattrFromStyleData: typeof sattrFromStyleData;
+    attrsToStyle: typeof attrsToStyle;
+    styleToAttrs: typeof styleToAttrs;
+    AttrFlags: typeof AttrFlags;
+}>;
+type SattrModule = typeof sattr;
+
+/**
+ * Virtualized scrollback buffer utilities namespace.
+ *
+ * @example
+ * ```typescript
+ * import { scrollback } from 'blecsd/utils';
+ *
+ * const buffer = scrollback.createScrollbackBuffer({ maxLines: 10000 });
+ * scrollback.appendLine(buffer, 'Log line 1');
+ * const line = scrollback.getScrollbackLine(buffer, 0);
+ * scrollback.scrollbackScrollBy(buffer, -10);
+ * ```
+ */
+
+declare const scrollback: Readonly<{
+    createScrollbackBuffer: typeof createScrollbackBuffer;
+    appendLine: typeof appendLine;
+    appendLines: typeof appendLines$1;
+    getLine: typeof getLine$1;
+    getLineRange: typeof getLineRange$1;
+    scrollbackScrollBy: typeof scrollbackScrollBy;
+    scrollbackScrollToTop: typeof scrollbackScrollToTop;
+    scrollbackScrollToBottom: typeof scrollbackScrollToBottom;
+    jumpToLine: typeof jumpToLine;
+    exportToText: typeof exportToText;
+    loadFromText: typeof loadFromText;
+    clearScrollback: typeof clearScrollback;
+    trimToLineCount: typeof trimToLineCount$1;
+    getVisibleLines: typeof getVisibleLines$1;
+    getScrollbackStats: typeof getScrollbackStats;
+    getMemoryUsage: typeof getMemoryUsage;
+    compressOldChunks: typeof compressOldChunks;
+    decompressAll: typeof decompressAll;
+    DEFAULT_CHUNK_SIZE: 1000;
+    DEFAULT_MAX_CACHED: 100;
+    DEFAULT_MAX_MEMORY: number;
+    COMPRESSION_RATIO: 0.5;
+}>;
+type ScrollbackModule = typeof scrollback;
+
+declare const syntaxHL: Readonly<{
+    highlightWithCache: typeof highlightWithCache;
+    createHighlightCache: typeof createHighlightCache;
+    tokenizeLine: typeof tokenizeLine;
+    detectLanguage: typeof detectLanguage;
+    setGrammar: typeof setGrammar;
+    clearHighlightCache: typeof clearHighlightCache;
+    highlightVisibleFirst: typeof highlightVisibleFirst;
+    continueHighlight: typeof continueHighlight;
+    invalidateLine: typeof invalidateLine;
+    invalidateLines: typeof invalidateLines$1;
+    invalidateAllLines: typeof invalidateAllLines;
+    getHighlightStats: typeof getHighlightStats;
+    detectLanguageFromContent: typeof detectLanguageFromContent;
+    getGrammarByName: typeof getGrammarByName;
+    GRAMMAR_JAVASCRIPT: Grammar;
+    GRAMMAR_PYTHON: Grammar;
+    GRAMMAR_RUST: Grammar;
+    GRAMMAR_GO: Grammar;
+    GRAMMAR_JSON: Grammar;
+    GRAMMAR_SHELL: Grammar;
+    GRAMMAR_PLAINTEXT: Grammar;
+    GRAMMARS: readonly Grammar[];
+    EMPTY_STATE: LineState;
+    DEFAULT_HIGHLIGHT_BATCH: 100;
+}>;
+type SyntaxHLModule = typeof syntaxHL;
+
 /**
  * Tag parsing system for styled terminal text.
  *
@@ -3911,6 +3855,51 @@ declare const ParsedContentSchema: z.ZodObject<{
     plainText: z.ZodString;
 }, z.core.$strip>;
 
+declare const tags: Readonly<{
+    parseTags: typeof parseTags;
+    stripTags: typeof stripTags;
+    hasTags: typeof hasTags;
+    escapeTags: typeof escapeTags;
+    cleanTags: typeof cleanTags;
+    wrapWithTags: typeof wrapWithTags;
+    createTaggedText: typeof createTaggedText;
+    parsedToTaggedText: typeof parsedToTaggedText;
+    segmentToTaggedText: typeof segmentToTaggedText;
+    taggedLength: typeof taggedLength;
+    mergeSegments: typeof mergeSegments;
+    generateTags: typeof generateTags;
+    generateCloseTags: typeof generateCloseTags;
+    colorToTag: typeof colorToTag;
+    attrToTag: typeof attrToTag;
+    attrsToTags: typeof attrsToTags;
+    AlignmentSchema: zod.ZodEnum<{
+        left: "left";
+        right: "right";
+        center: "center";
+    }>;
+    ParsedContentSchema: zod.ZodObject<{
+        segments: zod.ZodArray<zod.ZodObject<{
+            text: zod.ZodString;
+            fg: zod.ZodNumber;
+            bg: zod.ZodNumber;
+            attrs: zod.ZodNumber;
+        }, zod_v4_core.$strip>>;
+        alignment: zod.ZodEnum<{
+            left: "left";
+            right: "right";
+            center: "center";
+        }>;
+        plainText: zod.ZodString;
+    }, zod_v4_core.$strip>;
+    TextSegmentSchema: zod.ZodObject<{
+        text: zod.ZodString;
+        fg: zod.ZodNumber;
+        bg: zod.ZodNumber;
+        attrs: zod.ZodNumber;
+    }, zod_v4_core.$strip>;
+}>;
+type TagsModule = typeof tags;
+
 /**
  * Efficient Text Search
  *
@@ -4175,147 +4164,67 @@ declare function getMatchStatus(cache: SearchCache): {
 declare function searchReverse(text: string, query: string, options?: SearchOptions): SearchResult;
 
 /**
- * Text wrapping utilities with Unicode and ANSI support.
- * @module utils/textWrap
- */
-
-/**
- * Text alignment options.
- */
-type TextAlign = 'left' | 'center' | 'right';
-/**
- * Options for text wrapping.
- */
-interface WrapOptions {
-    /** Maximum width in characters */
-    width: number;
-    /** Whether to wrap text (default: true) */
-    wrap?: boolean;
-    /** Text alignment (default: 'left') */
-    align?: TextAlign;
-    /** Break mid-word if word exceeds width (default: false) */
-    breakWord?: boolean;
-}
-/**
- * Removes ANSI escape sequences from a string.
- *
- * @param text - Text with possible ANSI codes
- * @returns Text without ANSI codes
+ * Text search utilities namespace with caching support.
  *
  * @example
  * ```typescript
- * import { stripAnsi } from 'blecsd';
+ * import { textSearch } from 'blecsd/utils';
  *
- * const plain = stripAnsi('\x1b[31mRed\x1b[0m');
- * console.log(plain); // "Red"
+ * const cache = textSearch.createSearchCache();
+ * const result = textSearch.searchWithCache(cache, lines, 'query');
+ * const next = textSearch.getNextMatch(result, currentPos);
+ * const visible = textSearch.getVisibleMatches(result, startLine, endLine);
  * ```
  */
-declare function stripAnsi(text: string): string;
-/**
- * Gets the visible width of a string (excluding ANSI codes).
- * Currently handles ASCII only. East Asian width support to be added.
- *
- * @param text - Text to measure
- * @returns Visible character width
- *
- * @example
- * ```typescript
- * import { getVisibleWidth } from 'blecsd';
- *
- * console.log(getVisibleWidth('Hello')); // 5
- * console.log(getVisibleWidth('\x1b[31mHello\x1b[0m')); // 5 (ANSI codes not counted)
- * ```
- */
-declare function getVisibleWidth(text: string): number;
-/**
- * Truncates a string to fit within a specified width,
- * preserving ANSI codes and adding ellipsis if truncated.
- *
- * @param text - Text to truncate
- * @param width - Maximum width
- * @param ellipsis - Ellipsis string (default: '…')
- * @returns Truncated text
- *
- * @example
- * ```typescript
- * import { truncate } from 'blecsd';
- *
- * console.log(truncate('Hello World', 8)); // "Hello W…"
- * ```
- */
-declare function truncate(text: string, width: number, ellipsis?: string): string;
-/**
- * Aligns a line of text within a specified width.
- *
- * @param line - Line to align
- * @param width - Target width
- * @param align - Alignment type
- * @returns Aligned line (padded with spaces)
- *
- * @example
- * ```typescript
- * import { alignLine } from 'blecsd';
- *
- * console.log(alignLine('Hello', 10, 'left'));   // "Hello     "
- * console.log(alignLine('Hello', 10, 'center')); // "  Hello   "
- * console.log(alignLine('Hello', 10, 'right'));  // "     Hello"
- * ```
- */
-declare function alignLine(line: string, width: number, align: TextAlign): string;
-/**
- * Wraps text to fit within a specified width, breaking at word boundaries.
- *
- * @param text - Text to wrap
- * @param width - Maximum width per line
- * @returns Array of wrapped lines
- *
- * @example
- * ```typescript
- * import { wordWrap } from 'blecsd';
- *
- * const lines = wordWrap('The quick brown fox jumps over the lazy dog', 20);
- * // ["The quick brown fox", "jumps over the lazy", "dog"]
- * ```
- */
-declare function wordWrap(text: string, width: number): string[];
-/**
- * Wraps and aligns text with full options.
- *
- * @param text - Text to wrap
- * @param options - Wrapping options
- * @returns Array of wrapped and aligned lines
- *
- * @example
- * ```typescript
- * import { wrapText } from 'blecsd';
- *
- * const lines = wrapText('Hello world, this is a test', {
- *   width: 15,
- *   wrap: true,
- *   align: 'center'
- * });
- * // ["  Hello world  ", " this is a test"]
- * ```
- */
-declare function wrapText(text: string, options: WrapOptions): string[];
+
+declare const textSearch: Readonly<{
+    search: typeof search;
+    searchWithCache: typeof searchWithCache;
+    createSearchCache: typeof createSearchCache;
+    getNextMatch: typeof getNextMatch;
+    getPreviousMatch: typeof getPreviousMatch;
+    getVisibleMatches: typeof getVisibleMatches;
+    clearSearchCache: typeof clearSearchCache;
+    updateSearchQuery: typeof updateSearchQuery;
+    searchBatch: typeof searchBatch;
+    searchLiteral: typeof searchLiteral;
+    searchRegex: typeof searchRegex;
+    searchReverse: typeof searchReverse;
+    boyerMooreHorspool: typeof boyerMooreHorspool;
+    findNearestMatch: typeof findNearestMatch;
+    getMatchAt: typeof getMatchAt;
+    getMatchStatus: typeof getMatchStatus;
+    positionToLineColumn: typeof positionToLineColumn;
+    DEFAULT_SEARCH_BATCH: 100000;
+    DEFAULT_TIMEOUT: 5000;
+    WORD_BOUNDARY_BEFORE: RegExp;
+    WORD_BOUNDARY_AFTER: RegExp;
+}>;
+type TextSearchModule = typeof textSearch;
+
 /**
- * Pads text to a specific height by adding empty lines.
- *
- * @param lines - Array of lines
- * @param height - Target height
- * @param width - Line width for padding
- * @param valign - Vertical alignment ('top' | 'middle' | 'bottom')
- * @returns Array of lines padded to height
+ * Text wrapping utilities namespace.
  *
  * @example
  * ```typescript
- * import { padHeight } from 'blecsd';
+ * import { textWrap } from 'blecsd/utils';
  *
- * const lines = padHeight(['Hello'], 3, 10, 'middle');
- * // ["          ", "Hello     ", "          "]
+ * const wrapped = textWrap.wordWrap(text, 80);
+ * const truncated = textWrap.truncate(text, 50);
+ * const aligned = textWrap.alignLine(text, 80, 'center');
  * ```
  */
-declare function padHeight(lines: string[], height: number, width: number, valign?: 'top' | 'middle' | 'bottom'): string[];
+
+declare const textWrap: Readonly<{
+    wordWrap: typeof wordWrap;
+    wrapText: typeof wrapText;
+    truncate: typeof truncate;
+    alignLine: typeof alignLine;
+    getVisibleWidth: typeof getVisibleWidth;
+    stripAnsi: typeof stripAnsi;
+    padHeight: typeof padHeight;
+}>;
+type TextWrapModule = typeof textWrap;
 
 /**
  * Time Utilities
@@ -4396,6 +4305,26 @@ declare function unixTimestamp(date?: Date): number;
  */
 declare function unixTimestampMs(date?: Date): number;
 
+/**
+ * Time utilities namespace.
+ *
+ * @example
+ * ```typescript
+ * import { time } from 'blecsd/utils';
+ *
+ * const formatted = time.formatDate(new Date());
+ * const timestamp = time.unixTimestamp();
+ * const timestampMs = time.unixTimestampMs();
+ * ```
+ */
+
+declare const time: Readonly<{
+    formatDate: typeof formatDate;
+    unixTimestamp: typeof unixTimestamp;
+    unixTimestampMs: typeof unixTimestampMs;
+}>;
+type TimeModule = typeof time;
+
 /**
  * Unicode code point utilities for low-level string handling.
  * @module utils/unicode/codePoint
@@ -5948,4 +5877,122 @@ declare function getCategories(corpus: readonly WidthTestCase[]): readonly Width
  */
 declare function formatTestReport(results: WidthTestResult): string;
 
-export { AMBIGUOUS_RANGES, type Alignment, AlignmentSchema, AttrFlags, BOX_ASCII, BOX_BOLD, BOX_DASHED, BOX_DOUBLE, BOX_ROUNDED, BOX_SINGLE, type BlockData, type BlockType, type BlockquoteData, type BoxChars, COMBINING_RANGES, COMBINING_SET, type Cell, type CellBuffer, type CoalescingConfig, type CoalescingState, type CodeData, type CodePointRange, type ContentChunk, type ContentSource, type CursorNavConfig, type CursorPosition, DEFAULT_BATCH_SIZE, DEFAULT_COLLAPSE_THRESHOLD, DEFAULT_CONTEXT, DEFAULT_HIGHLIGHT_BATCH, DEFAULT_PARSE_BATCH, DEFAULT_SEARCH_BATCH, DEFAULT_TIMEOUT, type DiffCache, type DiffChunk, type DiffConfig, type DiffLine, type DiffResult, type DiffType, type DirtyRegion, type DropUnicodeOptions, EMOJI_WIDE_RANGES, EMPTY_STATE, FULLWIDTH_RANGES, type FastWrapOptions, type FlushResult, type FoldConfig, type FoldRegion, type FoldStats, type FuzzyMatch, type FuzzyOptions, FuzzyOptionsSchema, type FuzzySearchOptions, GRAMMARS, GRAMMAR_GO, GRAMMAR_JAVASCRIPT, GRAMMAR_JSON, GRAMMAR_PLAINTEXT, GRAMMAR_PYTHON, GRAMMAR_RUST, GRAMMAR_SHELL, type Grammar, type GraphemeSliceResult, type GutterConfig, type GutterLine, type GutterResult, HIGH_SURROGATE_END, HIGH_SURROGATE_START, type HeadingData, type HighlightCache, type HighlightResult, type HighlightStats, type HrData, type HtmlData, type InlineElement, type InlineType, type KnownBadSequence, LEAF_MAX_SIZE, LEAF_MIN_SIZE, LOW_SURROGATE_END, LOW_SURROGATE_START, type LazyContentConfig, type LazyContentState, type LineEntry, type LineIndex, type LineInfo, type LineNumberMode, type LinePosition, type LineState, type LineStyle, type ListData, type ListItem, MAX_DEPTH, MAX_PARAGRAPH_CHUNK, type MarkdownBlock, type MarkdownCache, type MarkdownParseResult, type MarkdownStats, type NavigationResult, type ParagraphData, type ParsedContent, ParsedContentSchema, type ProgressiveSearchResult, type ProgressiveWrapResult, type RenderBoxOptions, type RenderedLine, type Rope, type RopeLeaf, type RopeNode, type RopeStats, type SearchCache, type SearchMatch, type SearchOptions, type SearchResult, type SideBySideLine, type SliceResult, type StyleAttr, type StyleInput, type TableCell, type TableData, type TerminalWidthProfile, TerminalWidthProfileSchema, type TextAlign, type TextChange, type TextSegment, TextSegmentSchema, type Token, type TokenType, type ViewportState, type VisibleDiff, type VisibleLine, type VisibleMarkdown, WIDE_RANGES, WORD_BOUNDARY_AFTER, WORD_BOUNDARY_BEFORE, type WidthOptions, type WidthOverride, WidthOverrideSchema, type WidthTestCase, type WidthTestCategory, type WidthTestFailure, type WidthTestResult, type WrapCache, type WrapCacheStats, type WrapEntry, type WrapOptions, ZERO_WIDTH_RANGES, addFoldRegion, alignLine, append, attrToTag, attrsToStyle, attrsToTags, boyerMooreHorspool, bufferToString$1 as bufferToString, buildLineIndex, buildLineIndexFromLengths, buildTestCorpus, centerByWidth, charAt, charAtCodePoint, charWidth, charWidthAt, characters, charsetToBoxChars, clampCursor, cleanTags, clearDiffCache, clearHighlightCache, clearLazyContent, clearMarkdownCache, clearSearchCache, clearWidthOverrides, clearWrapCache, codePointAt, codePointLength, codePointToSurrogatePair, codePointWidth, codePoints, collapseChunk, collapseUnchanged, colorToTag, columnAtIndex, computeDiff, computeDiffCached, computeDigitWidth, computeGutterWidth, computeVisibleGutter, continueHighlight, continueWrap, createArraySource, createCellBuffer, createCoalescer, createCursor, createDiffCache, createEmptyRope, createFoldState, createGutterConfig, createHighlightCache, createLazyContent, createMarkdownCache, createNavConfig, createRope, createSearchCache, createTaggedText, createViewport, createWrapCache, decodeStyleAttr, deleteChange, deleteRange, destroyCoalescer, detectLanguage, detectLanguageFromContent, dropUnicode, encodeStyleAttr, index as encoding, ensureCursorVisible, escapeTags, evictChunks, expandAll, expandChunk, fillRect, filterByCategory, findAllFiles, findFile, findNearestMatch, flushChanges, foldAll, foldAtDepth, foldRegion, formatDate, formatLineNumber, formatTestReport, fromCodePoint, fuzzyFilter, fuzzyMatch, fuzzySearch, fuzzySearchBy, fuzzyTest, generateCloseTags, generateTags, getAllFoldRegions, getCategories, getCharWidth, getCoalescingState, getCombiningCharCount, getDiffStats, getFoldAtLine, getFoldStats, getGrammarByName, getHighlightStats, getKnownBadSequences, getLazyContentState, getLazyLines, getLength, getLine, getLineCount, getLineEnd, getLineForIndex, getLineStart, getLines, getTotalLineCount as getMarkdownLineCount, getMarkdownStats, getMatchAt, getMatchStatus, getNewlineCount, getNextMatch, getOverrideCount, getOverrideWidth, getPreviousMatch, getSideBySideView, getStats, getText, getTotalLineCount$1 as getTotalLineCount, getVisibleDiffLines, getVisibleFoldLines, getVisibleMarkdown, getVisibleMatches, getVisibleWidth, getWrapCacheStats, goToEnd, goToLine, goToStart, graphemeAt, graphemeClusters, graphemeCount, graphemeWidth, groupBy, gutterWidthChanged, hasGraphemeSegmenter, hasTags, hasWideChars, hasZeroWidthChars, highlightMatch, highlightVisibleFirst, highlightWithCache, indexAtColumn, insert, insertChange, installWidthOverrides, invalidateAll, invalidateAllLines, invalidateLine, invalidateLines$1 as invalidateLines, invalidateLines as invalidateMarkdownLines, invalidateParagraph, invalidateRange, isAmbiguousChar, isAstral, isBMP, isCombiningChar, isCombiningCharBinarySearch, isEmpty, isHighSurrogate, isLowSurrogate, isRangeLoaded, isSurrogate, isSurrogateCode, isValidCodePoint, isWideChar, isZeroWidthChar, lineForOffset, lineToPosition, measureWidthWithOverrides, merge, mergeSegments, moveCursorDown, moveCursorLeft, moveCursorRight, moveCursorUp, normalizeNFC, normalizeNFD, normalizeNFKC, normalizeNFKD, offsetForLine, originalToVisibleLine, padEndByWidth, padHeight, padStartByWidth, pageDown, pageUp, parseInline, parseMarkdown, parseMarkdownCached, parseTags, parseUnifiedDiff, parsedToTaggedText, partition, positionToLine, positionToLineColumn, prefetchAround, prepend, queueChange, removeFoldRegion, renderBlock, renderBox, renderGutterBlock, renderHLine, renderMarkdown, renderText, renderVLine, replaceChange, replaceRange, resizeWrapCache, reverseGraphemes, runWidthTests, sattr, sattrAddFlag, sattrCopy, sattrEmpty, sattrEqual, sattrFromStyleData, sattrHasFlag, sattrInvert, sattrMerge, sattrRemoveFlag, search, searchBatch, searchLiteral, searchRegex, searchReverse, searchWithCache, segmentToTaggedText, setGrammar, shallowMerge, sliceByWidth, sliceByWidthGrapheme, sliceCodePoints, sliceGraphemes, sortBy, sortByIndex, sortByName, sortByPriority, strWidth, stringWidth, stringWidthGrapheme, stripAnsi, stripCombining, stripControl, stripTags, stripZeroWidth, styleToAttrs, substring, surrogatePairToCodePoint, taggedLength, toAscii, toCodePoints, toGraphemes, toUnifiedDiff, toggleChunk, toggleFold, tokenizeLine, truncate, truncateByWidth, truncateWithEllipsis, truncateWithEllipsisGrapheme, unfoldAll, unfoldRegion, unique, uniqueBy, unixTimestamp, unixTimestampMs, updateSearchQuery, updateTotalLines, verify, visibleToOriginalLine, wordWrap, wrapText, wrapVisibleFirst, wrapWithCache, wrapWithTags };
+declare const unicode: Readonly<{
+    width: Readonly<{
+        stringWidth: typeof stringWidth;
+        charWidth: typeof charWidth;
+        charWidthAt: typeof charWidthAt;
+        codePointWidth: typeof codePointWidth;
+        graphemeWidth: typeof graphemeWidth;
+        stringWidthGrapheme: typeof stringWidthGrapheme;
+        strWidth: typeof strWidth;
+        getCharWidth: typeof getCharWidth;
+        hasWideChars: typeof hasWideChars;
+        hasZeroWidthChars: typeof hasZeroWidthChars;
+        isWideChar: typeof isWideChar;
+        isZeroWidthChar: typeof isZeroWidthChar;
+        isAmbiguousChar: typeof isAmbiguousChar;
+        isCombiningChar: typeof isCombiningChar;
+        isCombiningCharBinarySearch: typeof isCombiningCharBinarySearch;
+        getCombiningCharCount: typeof getCombiningCharCount;
+        truncateByWidth: typeof truncateByWidth;
+        sliceByWidth: typeof sliceByWidth;
+        sliceByWidthGrapheme: typeof sliceByWidthGrapheme;
+        truncateWithEllipsis: typeof truncateWithEllipsis;
+        truncateWithEllipsisGrapheme: typeof truncateWithEllipsisGrapheme;
+        padStartByWidth: typeof padStartByWidth;
+        padEndByWidth: typeof padEndByWidth;
+        centerByWidth: typeof centerByWidth;
+        columnAtIndex: typeof columnAtIndex;
+        indexAtColumn: typeof indexAtColumn;
+        WIDE_RANGES: readonly CodePointRange[];
+        ZERO_WIDTH_RANGES: readonly CodePointRange[];
+        AMBIGUOUS_RANGES: readonly CodePointRange[];
+        FULLWIDTH_RANGES: readonly CodePointRange[];
+        EMOJI_WIDE_RANGES: readonly CodePointRange[];
+        COMBINING_RANGES: readonly CodePointRange[];
+        COMBINING_SET: ReadonlySet<number>;
+    }>;
+    codePoint: Readonly<{
+        codePointAt: typeof codePointAt;
+        codePoints: typeof codePoints;
+        toCodePoints: typeof toCodePoints;
+        fromCodePoint: typeof fromCodePoint;
+        codePointLength: typeof codePointLength;
+        charAtCodePoint: typeof charAtCodePoint;
+        characters: typeof characters;
+        sliceCodePoints: typeof sliceCodePoints;
+        isValidCodePoint: typeof isValidCodePoint;
+        isBMP: typeof isBMP;
+        isAstral: typeof isAstral;
+    }>;
+    grapheme: Readonly<{
+        graphemeClusters: typeof graphemeClusters;
+        toGraphemes: typeof toGraphemes;
+        graphemeAt: typeof graphemeAt;
+        graphemeCount: typeof graphemeCount;
+        sliceGraphemes: typeof sliceGraphemes;
+        reverseGraphemes: typeof reverseGraphemes;
+        hasGraphemeSegmenter: typeof hasGraphemeSegmenter;
+    }>;
+    normalize: Readonly<{
+        normalizeNFC: typeof normalizeNFC;
+        normalizeNFD: typeof normalizeNFD;
+        normalizeNFKC: typeof normalizeNFKC;
+        normalizeNFKD: typeof normalizeNFKD;
+        dropUnicode: typeof dropUnicode;
+        toAscii: typeof toAscii;
+        stripCombining: typeof stripCombining;
+        stripZeroWidth: typeof stripZeroWidth;
+        stripControl: typeof stripControl;
+    }>;
+    surrogate: Readonly<{
+        codePointToSurrogatePair: typeof codePointToSurrogatePair;
+        surrogatePairToCodePoint: typeof surrogatePairToCodePoint;
+        isHighSurrogate: typeof isHighSurrogate;
+        isLowSurrogate: typeof isLowSurrogate;
+        isSurrogate: typeof isSurrogate;
+        isSurrogateCode: typeof isSurrogateCode;
+        HIGH_SURROGATE_START: 55296;
+        HIGH_SURROGATE_END: 56319;
+        LOW_SURROGATE_START: 56320;
+        LOW_SURROGATE_END: 57343;
+    }>;
+    stringWidth: typeof stringWidth;
+    charWidth: typeof charWidth;
+    truncateByWidth: typeof truncateByWidth;
+    hasWideChars: typeof hasWideChars;
+    isWideChar: typeof isWideChar;
+    graphemeClusters: typeof graphemeClusters;
+    toCodePoints: typeof toCodePoints;
+    normalizeNFC: typeof normalizeNFC;
+}>;
+type UnicodeModule = typeof unicode;
+
+declare const widthHarness: Readonly<{
+    buildTestCorpus: typeof buildTestCorpus;
+    runWidthTests: typeof runWidthTests;
+    formatTestReport: typeof formatTestReport;
+    installWidthOverrides: typeof installWidthOverrides;
+    clearWidthOverrides: typeof clearWidthOverrides;
+    getOverrideWidth: typeof getOverrideWidth;
+    measureWidthWithOverrides: typeof measureWidthWithOverrides;
+    getOverrideCount: typeof getOverrideCount;
+    getKnownBadSequences: typeof getKnownBadSequences;
+    getCategories: typeof getCategories;
+    filterByCategory: typeof filterByCategory;
+    TerminalWidthProfileSchema: zod.ZodObject<{
+        terminal: zod.ZodString;
+        overrides: zod.ZodArray<zod.ZodObject<{
+            codePoint: zod.ZodNumber;
+            width: zod.ZodNumber;
+        }, zod_v4_core.$strip>>;
+    }, zod_v4_core.$strip>;
+    WidthOverrideSchema: zod.ZodObject<{
+        codePoint: zod.ZodNumber;
+        width: zod.ZodNumber;
+    }, zod_v4_core.$strip>;
+}>;
+type WidthHarnessModule = typeof widthHarness;
+
+export { AMBIGUOUS_RANGES, type Alignment, AlignmentSchema, AttrFlags, type BlockData, type BlockType, type BlockquoteData, BoxChars, type BoxRenderModule, COMBINING_RANGES, COMBINING_SET, type ChangeCoalesceModule, type CoalescingConfig, type CoalescingState, type CodeData, type CodePage, type CodePointRange, type ColorsModule, type ComponentStoreModule, type ContentChunk, type ContentSource, type ConversionOptions, type CursorNavConfig, type CursorNavModule, type CursorPosition, DEFAULT_BATCH_SIZE, DEFAULT_COLLAPSE_THRESHOLD, DEFAULT_CONTEXT, DEFAULT_HIGHLIGHT_BATCH, DEFAULT_PARSE_BATCH, DEFAULT_SEARCH_BATCH, DEFAULT_TIMEOUT, type DiffCache, type DiffChunk, type DiffConfig, type DiffLine, type DiffRendererModule, type DiffResult, type DiffType, type DirtyRegion, type DropUnicodeOptions, EMOJI_WIDE_RANGES, EMPTY_STATE, type EncodingModule, FULLWIDTH_RANGES, type FastWrapModule, type FastWrapOptions, type FlushResult, type FoldConfig, type FoldModule, type FoldRegion, type FoldStats, type FuzzyMatch, type FuzzyOptions, FuzzyOptionsSchema, type FuzzySearchModule, type FuzzySearchOptions, GRAMMARS, GRAMMAR_GO, GRAMMAR_JAVASCRIPT, GRAMMAR_JSON, GRAMMAR_PLAINTEXT, GRAMMAR_PYTHON, GRAMMAR_RUST, GRAMMAR_SHELL, type Grammar, type GraphemeSliceResult, type GutterConfig, type GutterLine, type GutterModule, type GutterResult, HIGH_SURROGATE_END, HIGH_SURROGATE_START, type HeadingData, type HelpersModule, type HighlightCache, type HighlightResult, type HighlightStats, type HrData, type HtmlData, type InlineElement, type InlineType, type KnownBadSequence, LOW_SURROGATE_END, LOW_SURROGATE_START, type LazyContentConfig, type LazyContentModule, type LazyContentState, type LineEntry, type LineIndex, type LineNumberMode, type LinePosition, type LineState, type LineStoreModule, type LineStyle, type ListData, type ListItem, MAX_PARAGRAPH_CHUNK, type MarkdownBlock, type MarkdownCache, type MarkdownParseResult, type MarkdownRendererModule, type MarkdownStats, type NavigationResult, type ParagraphData, type ParsedContent, ParsedContentSchema, type PartialConversionOptions, type ProgressiveSearchResult, type ProgressiveWrapResult, type RenderedLine, type RopeModule, type SattrModule, type ScrollbackModule, type SearchCache, type SearchMatch, type SearchOptions, type SearchResult, type SideBySideLine, type SliceResult, type StyleAttr, type StyleInput, type SyntaxHLModule, type TableCell, type TableData, type TagsModule, type TerminalWidthProfile, TerminalWidthProfileSchema, type TextChange, type TextSearchModule, type TextSegment, TextSegmentSchema, type TextWrapModule, type TimeModule, type Token, type TokenType, type UnicodeModule, type UnmappableMode, type ViewportState, type VisibleDiff, type VisibleLine, type VisibleMarkdown, WIDE_RANGES, WORD_BOUNDARY_AFTER, WORD_BOUNDARY_BEFORE, type WidthHarnessModule, type WidthOptions, type WidthOverride, WidthOverrideSchema, type WidthTestCase, type WidthTestCategory, type WidthTestFailure, type WidthTestResult, type WrapCache, type WrapCacheStats, type WrapEntry, ZERO_WIDTH_RANGES, addFoldRegion, alignLine, append, appendLine, appendLines$1 as appendLines, appendLines as appendLinesToStore, appendToStore, attrToTag, attrsToStyle, attrsToTags, boxFillRect, boxRender, boyerMooreHorspool, bufferToString$1 as bufferToString, buildLineIndex, buildLineIndexFromLengths, buildTestCorpus, centerByWidth, changeCoalesce, charAt, charAtCodePoint, charWidth, charWidthAt, characters, charsetToBoxChars, clampCursor, cleanTags, clearDiffCache, clearHighlightCache, clearLazyContent, clearMarkdownCache, clearScrollback, clearSearchCache, clearWidthOverrides, clearWrapCache, codePointAt, codePointLength, codePointToSurrogatePair, codePointWidth, codePoints, collapseChunk, collapseUnchanged, colorToHex, colorToTag, colors, columnAtIndex, componentStore, compressOldChunks, computeDiff, computeDiffCached, computeDigitWidth, computeGutterWidth, computeVisibleGutter, continueHighlight, continueWrap, createArraySource, createCellBuffer, createCoalescer, createComponentStore, createCursor, createDiffCache, createEmptyLineStore, createEmptyRope, createFoldState, createGutterConfig, createHighlightCache, createLazyContent, createLineStore, createLineStoreFromLines, createMarkdownCache, createNavConfig, createRope, createScrollbackBuffer, createSearchCache, createSparseStore, createTaggedText, createTypedArrayPool, createViewport, createWrapCache, cursorNav, decodeStyleAttr, decompressAll, deleteChange, deleteRange, destroyCoalescer, detectLanguage, detectLanguageFromContent, diffRenderer, dropUnicode, encodeStyleAttr, encoding, ensureCursorVisible, escapeTags, estimateMemoryUsage, evictChunks, expandAll, expandChunk, exportContent, exportLineRange, exportToText, fastWrap, filterByCategory, findAllFiles, findFile, findNearestMatch, flushChanges, fold, foldAll, foldAtDepth, foldRegion, formatDate, formatLineNumber, formatTestReport, fromCodePoint, fuzzyFilter, fuzzyMatch, fuzzySearch, fuzzySearchBy, fuzzySearch$1 as fuzzySearchFn, fuzzyTest, generateCloseTags, generateTags, getAllFoldRegions, getByteSize, getCategories, getCharWidth, getCoalescingState, getCombiningCharCount, getComponentMemoryReport, getDiffStats, getFoldAtLine, getFoldStats, getGrammarByName, getHighlightStats, getKnownBadSequences, getLazyContentState, getLazyLines, getLength, getLine, getLineAtIndex, getLineCount$1 as getLineCount, getLineEnd, getLineForIndex, getLineForOffset, getLineInfo, getLineRange$1 as getLineRange, getLineStart, getLineCount as getLineStoreLineCount, getLineRange as getLineStoreRange, getVisibleLines as getLineStoreVisibleLines, getLines, getTotalLineCount as getMarkdownLineCount, getMarkdownStats, getMatchAt, getMatchStatus, getMemoryUsage, getNewlineCount, getNextMatch, getOffsetForLine, getOverrideCount, getOverrideWidth, getPreviousMatch, getLine$1 as getScrollbackLine, getScrollbackStats, getSideBySideView, getStats, getStoreStats, getText, getTotalLineCount$1 as getTotalLineCount, getVisibleDiffLines, getVisibleFoldLines, getVisibleLines$1 as getVisibleLines, getVisibleMarkdown, getVisibleMatches, getVisibleWidth, getWrapCacheStats, goToEnd, goToLine, goToStart, graphemeAt, graphemeClusters, graphemeCount, graphemeWidth, groupBy, gutter, gutterWidthChanged, hasGraphemeSegmenter, hasTags, hasWideChars, hasZeroWidthChars, helpers, hexToColor, highlightMatch, highlightVisibleFirst, highlightWithCache, indexAtColumn, insert, insertChange, installWidthOverrides, invalidateAll, invalidateAllLines, invalidateLine, invalidateLines$1 as invalidateLines, invalidateLines as invalidateMarkdownLines, invalidateParagraph, invalidateRange, isAmbiguousChar, isAstral, isBMP, isCombiningChar, isCombiningCharBinarySearch, isEmpty, isHighSurrogate, isLowSurrogate, isRangeLoaded, isStoreEmpty, isSurrogate, isSurrogateCode, isValidCodePoint, isWideChar, isWithinMemoryBounds, isZeroWidthChar, jumpToLine, lazyContent, lineForOffset, lineStore, lineToPosition, loadFromText, markdownRenderer, measureWidthWithOverrides, merge, mergeSegments, moveCursorDown, moveCursorLeft, moveCursorRight, moveCursorUp, normalizeNFC, normalizeNFD, normalizeNFKC, normalizeNFKD, offsetForLine, originalToVisibleLine, packColor, padEndByWidth, padHeight, padStartByWidth, pageDown, pageUp, parseColor, parseInline, parseMarkdown, parseMarkdownCached, parseTags, parseUnifiedDiff, parsedToTaggedText, partition, positionToLine, positionToLineColumn, prefetchAround, prepend, queueChange, removeFoldRegion, renderBlock, renderBox, renderGutterBlock, renderHLine, renderMarkdown, renderText, renderVLine, replaceChange, replaceRange, resizeWrapCache, reverseGraphemes, rope, runWidthTests, sattr, sattrAddFlag, sattrCopy, sattrEmpty, sattrEqual, sattr$1 as sattrFn, sattrFromStyleData, sattrHasFlag, sattrInvert, sattrMerge, sattrRemoveFlag, scrollback, scrollbackScrollBy, scrollbackScrollToBottom, scrollbackScrollToTop, search, searchBatch, searchLiteral, searchRegex, searchReverse, searchWithCache, segmentToTaggedText, setGrammar, shallowMerge, sliceByWidth, sliceByWidthGrapheme, sliceCodePoints, sliceGraphemes, sortBy, sortByIndex, sortByName, sortByPriority, strWidth, stringWidth, stringWidthGrapheme, stripAnsi, stripCombining, stripControl, stripTags, stripZeroWidth, styleToAttrs, substring, surrogatePairToCodePoint, syntaxHL, taggedLength, tags, textSearch, textWrap, time, toAscii, toCodePoints, toGraphemes, toUnifiedDiff, toggleChunk, toggleFold, tokenizeLine, trimToLineCount as trimLineStore, trimToLineCount$1 as trimToLineCount, truncate, truncateByWidth, truncateWithEllipsis, truncateWithEllipsisGrapheme, unfoldAll, unfoldRegion, unicode, unique, uniqueBy, unixTimestamp, unixTimestampMs, unpackColor, updateSearchQuery, updateTotalLines, verify, visibleToOriginalLine, widthHarness, wordWrap, wrapText, wrapVisibleFirst, wrapWithCache, wrapWithTags };