ink-prompt 0.2.3 → 0.2.4

package/dist/components/MultilineInput/TextBuffer.js

@@ -17,19 +17,15 @@ export function insertText(buffer, cursor, text) {
         return { buffer, cursor };
     const { line, column } = cursor;
     const currentLine = buffer.lines[line];
-    // Insert text and handle newlines
     const beforeCursor = currentLine.slice(0, column);
     const afterCursor = currentLine.slice(column);
     const fullText = beforeCursor + text + afterCursor;
-    // Split into lines
     const newLines = fullText.split('\n');
-    // Calculate new cursor position
     const textLines = text.split('\n');
     const cursorLine = line + (textLines.length - 1);
     const cursorColumn = textLines.length === 1
         ? column + text.length
         : textLines[textLines.length - 1].length;
-    // Rebuild buffer
     const resultLines = [
         ...buffer.lines.slice(0, line),
         ...newLines,
@@ -43,13 +39,11 @@ export function insertText(buffer, cursor, text) {
 /**
  * Delete character before cursor (backspace)
  */
-export function deleteChar(buffer, cursor, placeholders) {
+export function deleteChar(buffer, cursor, entries) {
     const { line, column } = cursor;
-    // At the very start of the buffer - nothing to delete
     if (line === 0 && column === 0) {
         return { buffer, cursor };
     }
-    // At the start of a line - merge with previous line
     if (column === 0) {
         const previousLine = buffer.lines[line - 1];
         const currentLine = buffer.lines[line];
@@ -62,9 +56,8 @@ export function deleteChar(buffer, cursor, placeholders) {
             cursor: { line: line - 1, column: previousLine.length },
         };
     }
-    // Atomic-block deletion (sentinel or placeholder marker) \u2014 remove the whole block
     const currentLine = buffer.lines[line];
-    const block = findAtomicBlockBefore(currentLine, column, placeholders);
+    const block = findAtomicBlockBefore(currentLine, column, entries);
     if (block) {
         const newLine = currentLine.slice(0, block.start) + currentLine.slice(block.end);
         const newLines = [...buffer.lines];
@@ -85,15 +78,13 @@ export function deleteChar(buffer, cursor, placeholders) {
 /**
  * Delete character after cursor (forward delete / Delete key)
  */
-export function deleteCharForward(buffer, cursor, placeholders) {
+export function deleteCharForward(buffer, cursor, entries) {
     const { line, column } = cursor;
     const currentLine = buffer.lines[line];
     const lineCount = buffer.lines.length;
-    // At the very end of the buffer - nothing to delete
     if (line === lineCount - 1 && column >= currentLine.length) {
         return { buffer, cursor };
     }
-    // At the end of a line - merge with next line
     if (column >= currentLine.length) {
         const nextLine = buffer.lines[line + 1];
         const mergedLine = currentLine + nextLine;
@@ -102,11 +93,10 @@ export function deleteCharForward(buffer, cursor, placeholders) {
         newLines.splice(line + 1, 1);
         return {
             buffer: { lines: newLines },
-            cursor, // Cursor stays in place
+            cursor,
         };
     }
-    // Atomic-block deletion forward (sentinel or placeholder marker) \u2014 remove the whole block
-    const block = findAtomicBlockAfter(currentLine, column, placeholders);
+    const block = findAtomicBlockAfter(currentLine, column, entries);
     if (block) {
         const newLine = currentLine.slice(0, block.start) + currentLine.slice(block.end);
         const newLines = [...buffer.lines];
@@ -116,13 +106,12 @@ export function deleteCharForward(buffer, cursor, placeholders) {
             cursor,
         };
     }
-    // Delete character after cursor within the line
     const newLine = currentLine.slice(0, column) + currentLine.slice(column + 1);
     const newLines = [...buffer.lines];
     newLines[line] = newLine;
     return {
         buffer: { lines: newLines },
-        cursor, // Cursor stays in place
+        cursor,
     };
 }
 /**
@@ -144,46 +133,82 @@ export function insertNewLine(buffer, cursor) {
 function getVisualWidth(char) {
     return 1;
 }
-/**
- * Break a line into visual rows using word-aware wrapping.
- * Words are kept intact when possible, breaking at spaces.
- * Long words that exceed width are hard-wrapped.
- * Sentinel blocks are atomic: never split, and occupy visual width
- * equal to their placeholder text length.
- */
-export function getVisualRows(line, width, placeholders) {
+function getVisualRowCount(line, width, entries) {
+    return getVisualRows(line, width, entries).length;
+}
+function visualToBufferColumn(visualRow, visualCol, line, width, entries) {
+    const rows = getVisualRows(line, width, entries);
+    if (visualRow >= rows.length) {
+        return line.length;
+    }
+    const row = rows[visualRow];
+    return Math.min(row.start + visualCol, line.length);
+}
+function getVisualRowLength(line, visualRow, width, entries) {
+    const rows = getVisualRows(line, width, entries);
+    if (visualRow >= rows.length)
+        return 0;
+    return rows[visualRow].length;
+}
+function getVisualPosition(bufferColumn, line, width, entries) {
+    const rows = getVisualRows(line, width, entries);
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const rowEnd = row.start + row.length;
+        if (bufferColumn >= row.start && bufferColumn < rowEnd) {
+            return { visualRow: i, visualCol: bufferColumn - row.start };
+        }
+        if (bufferColumn === rowEnd && i === rows.length - 1) {
+            return { visualRow: i, visualCol: row.length };
+        }
+    }
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        if (bufferColumn === row.start + row.length && i < rows.length - 1) {
+            return { visualRow: i + 1, visualCol: 0 };
+        }
+    }
+    const lastRow = rows[rows.length - 1];
+    return { visualRow: rows.length - 1, visualCol: lastRow.length };
+}
+export function getVisualRows(line, width, entries) {
     const safeWidth = Math.max(1, width);
     const rows = [];
-    if (line.length === 0) {
-        return [{ start: 0, length: 0 }];
+    const blocks = findAtomicBlocks(line, entries);
+    if (blocks.length > 0) {
+        return getVisualRowsWithBlocks(line, safeWidth, rows, blocks);
     }
-    const blocks = findAtomicBlocks(line, placeholders);
-    // Fast path: no atomic blocks
-    if (blocks.length === 0) {
-        let offset = 0;
-        let remaining = line;
-        while (remaining.length > 0) {
-            let chunkLength = safeWidth;
-            if (remaining.length <= safeWidth) {
-                chunkLength = remaining.length;
-            }
-            else {
-                let splitIndex = -1;
-                for (let i = safeWidth - 1; i >= 0; i--) {
-                    if (remaining[i] === ' ') {
-                        splitIndex = i;
-                        break;
-                    }
-                }
-                if (splitIndex !== -1) {
-                    chunkLength = splitIndex + 1;
+    let offset = 0;
+    let remaining = line;
+    while (remaining.length > 0) {
+        let chunkLength = safeWidth;
+        if (remaining.length <= safeWidth) {
+            chunkLength = remaining.length;
+        }
+        else {
+            let splitIndex = -1;
+            for (let i = safeWidth - 1; i >= 0; i--) {
+                if (remaining[i] === ' ') {
+                    splitIndex = i;
+                    break;
                 }
             }
-            rows.push({ start: offset, length: chunkLength });
-            remaining = remaining.slice(chunkLength);
-            offset += chunkLength;
+            if (splitIndex !== -1) {
+                chunkLength = splitIndex + 1;
+            }
         }
-        return rows;
+        rows.push({ start: offset, length: chunkLength });
+        remaining = remaining.slice(chunkLength);
+        offset += chunkLength;
+    }
+    if (rows.length === 0) {
+        return [{ start: 0, length: 0 }];
+    }
+    return rows;
+}
+function getVisualRowsWithBlocks(line, safeWidth, rows, blocks) {
+    if (line.length === 0) {
+        return [{ start: 0, length: 0 }];
     }
     let charPos = 0;
     let rowStart = 0;
@@ -249,83 +274,18 @@ export function getVisualRows(line, width, placeholders) {
     }
     return rows;
 }
-/**
- * Calculate which visual row (within a buffer line) the cursor is on,
- * and the column within that visual row.
- * Uses word-aware wrapping.
- */
-function getVisualPosition(bufferColumn, line, width, placeholders) {
-    const rows = getVisualRows(line, width, placeholders);
-    for (let i = 0; i < rows.length; i++) {
-        const row = rows[i];
-        const rowEnd = row.start + row.length;
-        if (bufferColumn >= row.start && bufferColumn < rowEnd) {
-            return { visualRow: i, visualCol: bufferColumn - row.start };
-        }
-        // Handle cursor at the very end of this row
-        if (bufferColumn === rowEnd && i === rows.length - 1) {
-            return { visualRow: i, visualCol: row.length };
-        }
-    }
-    // Cursor at wrap point - belongs to the next row
-    for (let i = 0; i < rows.length; i++) {
-        const row = rows[i];
-        if (bufferColumn === row.start + row.length && i < rows.length - 1) {
-            return { visualRow: i + 1, visualCol: 0 };
-        }
-    }
-    // Fallback: cursor at end of line
-    const lastRow = rows[rows.length - 1];
-    return { visualRow: rows.length - 1, visualCol: lastRow.length };
-}
-/**
- * Calculate how many visual rows a buffer line takes.
- * Uses word-aware wrapping.
- */
-function getVisualRowCount(line, width, placeholders) {
-    return getVisualRows(line, width, placeholders).length;
-}
-/**
- * Convert visual position back to buffer column.
- * Uses word-aware wrapping.
- */
-function visualToBufferColumn(visualRow, visualCol, line, width, placeholders) {
-    const rows = getVisualRows(line, width, placeholders);
-    if (visualRow >= rows.length) {
-        return line.length;
-    }
-    const row = rows[visualRow];
-    return Math.min(row.start + visualCol, line.length);
-}
-/**
- * Get the length of a specific visual row within a buffer line.
- * Uses word-aware wrapping.
- */
-function getVisualRowLength(line, visualRow, width, placeholders) {
-    const rows = getVisualRows(line, width, placeholders);
-    if (visualRow >= rows.length)
-        return 0;
-    return rows[visualRow].length;
-}
-/**
- * Move cursor in specified direction with bounds checking.
- * When width is provided, up/down movement is based on visual lines (accounting for wrapping).
- * When width is not provided, up/down movement is based on buffer lines.
- */
-export function moveCursor(buffer, cursor, direction, width, placeholders) {
+export function moveCursor(buffer, cursor, direction, width, entries) {
     const { line, column } = cursor;
     const currentLine = buffer.lines[line];
     const lineCount = buffer.lines.length;
     switch (direction) {
         case 'left': {
             if (column > 0) {
-                // If position before cursor is the end of an atomic block, jump to its start
-                const block = findAtomicBlockBefore(currentLine, column, placeholders);
+                const block = findAtomicBlockBefore(currentLine, column, entries);
                 if (block)
                     return { line, column: block.start };
                 return { line, column: column - 1 };
             }
-            // Wrap to end of previous line
             if (line > 0) {
                 return { line: line - 1, column: buffer.lines[line - 1].length };
             }
@@ -333,13 +293,11 @@ export function moveCursor(buffer, cursor, direction, width, placeholders) {
         }
         case 'right': {
             if (column < currentLine.length) {
-                // If cursor is at the start of an atomic block, jump past its end
-                const block = findAtomicBlockAfter(currentLine, column, placeholders);
+                const block = findAtomicBlockAfter(currentLine, column, entries);
                 if (block)
                     return { line, column: block.end };
                 return { line, column: column + 1 };
             }
-            // Wrap to start of next line
             if (line < lineCount - 1) {
                 return { line: line + 1, column: 0 };
             }
@@ -347,20 +305,20 @@ export function moveCursor(buffer, cursor, direction, width, placeholders) {
         }
         case 'up':
             if (width !== undefined) {
-                const { visualRow, visualCol } = getVisualPosition(column, currentLine, width, placeholders);
+                const { visualRow, visualCol } = getVisualPosition(column, currentLine, width, entries);
                 if (visualRow > 0) {
                     const targetVisualRow = visualRow - 1;
-                    const targetVisualRowLength = getVisualRowLength(currentLine, targetVisualRow, width, placeholders);
+                    const targetVisualRowLength = getVisualRowLength(currentLine, targetVisualRow, width, entries);
                     const targetVisualCol = Math.min(visualCol, targetVisualRowLength);
-                    return { line, column: visualToBufferColumn(targetVisualRow, targetVisualCol, currentLine, width, placeholders) };
+                    return { line, column: visualToBufferColumn(targetVisualRow, targetVisualCol, currentLine, width, entries) };
                 }
                 if (line > 0) {
                     const prevLine = buffer.lines[line - 1];
-                    const prevLineVisualRows = getVisualRowCount(prevLine, width, placeholders);
+                    const prevLineVisualRows = getVisualRowCount(prevLine, width, entries);
                     const targetVisualRow = prevLineVisualRows - 1;
-                    const targetVisualRowLength = getVisualRowLength(prevLine, targetVisualRow, width, placeholders);
+                    const targetVisualRowLength = getVisualRowLength(prevLine, targetVisualRow, width, entries);
                     const targetVisualCol = Math.min(visualCol, targetVisualRowLength);
-                    return { line: line - 1, column: visualToBufferColumn(targetVisualRow, targetVisualCol, prevLine, width, placeholders) };
+                    return { line: line - 1, column: visualToBufferColumn(targetVisualRow, targetVisualCol, prevLine, width, entries) };
                 }
                 return cursor;
             }
@@ -371,23 +329,22 @@ export function moveCursor(buffer, cursor, direction, width, placeholders) {
             return cursor;
         case 'down':
             if (width !== undefined) {
-                const { visualRow, visualCol } = getVisualPosition(column, currentLine, width, placeholders);
-                const currentLineVisualRows = getVisualRowCount(currentLine, width, placeholders);
+                const { visualRow, visualCol } = getVisualPosition(column, currentLine, width, entries);
+                const currentLineVisualRows = getVisualRowCount(currentLine, width, entries);
                 if (visualRow < currentLineVisualRows - 1) {
                     const targetVisualRow = visualRow + 1;
-                    const targetVisualRowLength = getVisualRowLength(currentLine, targetVisualRow, width, placeholders);
+                    const targetVisualRowLength = getVisualRowLength(currentLine, targetVisualRow, width, entries);
                     const targetVisualCol = Math.min(visualCol, targetVisualRowLength);
-                    return { line, column: visualToBufferColumn(targetVisualRow, targetVisualCol, currentLine, width, placeholders) };
+                    return { line, column: visualToBufferColumn(targetVisualRow, targetVisualCol, currentLine, width, entries) };
                 }
                 if (line < lineCount - 1) {
                     const nextLine = buffer.lines[line + 1];
-                    const targetVisualRowLength = getVisualRowLength(nextLine, 0, width, placeholders);
+                    const targetVisualRowLength = getVisualRowLength(nextLine, 0, width, entries);
                     const targetVisualCol = Math.min(visualCol, targetVisualRowLength);
                     return { line: line + 1, column: Math.min(targetVisualCol, nextLine.length) };
                 }
                 return cursor;
             }
-            // Buffer-line movement (no width provided)
             if (line < lineCount - 1) {
                 const targetLine = buffer.lines[line + 1];
                 return { line: line + 1, column: Math.min(column, targetLine.length) };
@@ -401,62 +358,35 @@ export function moveCursor(buffer, cursor, direction, width, placeholders) {
             return cursor;
     }
 }
-/**
- * Get the full text content from buffer (lines joined with newlines)
- */
 export function getTextContent(buffer) {
-    // Single empty line is considered empty buffer
     if (buffer.lines.length === 1 && buffer.lines[0] === '') {
         return '';
     }
     return buffer.lines.join('\n');
 }
-/**
- * Get the flat offset (index) from a cursor position.
- */
 export function getOffset(buffer, cursor) {
     let offset = 0;
     for (let i = 0; i < cursor.line; i++) {
-        offset += buffer.lines[i].length + 1; // +1 for the newline
+        offset += buffer.lines[i].length + 1;
     }
     offset += cursor.column;
     return offset;
 }
-/**
- * Get the cursor position from a flat offset.
- */
 export function getCursor(buffer, offset) {
     let currentOffset = 0;
     for (let i = 0; i < buffer.lines.length; i++) {
         const lineLength = buffer.lines[i].length;
-        // Check if the offset falls within this line (including the newline character unless it's the last line)
-        // We treat the position *after* the newline as the start of the next line.
-        // Position *at* the end of line (before newline) is valid cursor column.
-        // If we are on the last line, we accept up to lineLength
         if (i === buffer.lines.length - 1) {
             if (offset <= currentOffset + lineLength) {
                 return { line: i, column: Math.max(0, offset - currentOffset) };
             }
-            // If offset is beyond the content, clamp to end
             return { line: i, column: lineLength };
         }
-        // For non-last lines, we account for newline character (+1)
         if (offset <= currentOffset + lineLength) {
             return { line: i, column: Math.max(0, offset - currentOffset) };
         }
-        // If offset is exactly at the newline character, it depends on interpretation.
-        // Usually, cursor at the newline means it's at the end of the line.
-        // But if we are "past" the newline, we are on the start of next line.
-        // Logic:
-        // Line 0: "abc" (len 3). Newline at index 3.
-        // Index 0='a', 1='b', 2='c', 3='\n'.
-        // If target offset is 3: That's end of line 0.
-        // If target offset is 4: That's start of line 1.
-        // currentOffset + lineLength is index of newline.
-        // If offset == currentOffset + lineLength + 1, we move to next loop
         currentOffset += lineLength + 1;
     }
-    // Fallback (should have returned in loop)
     const lastLineIdx = buffer.lines.length - 1;
     return { line: lastLineIdx, column: buffer.lines[lastLineIdx].length };
 }

package/dist/components/MultilineInput/TextRenderer.d.ts

@@ -1,14 +1,13 @@
 import React from 'react';
-import type { Buffer, Cursor, WrapResult, PlaceholderState } from './types.js';
-import type { ImageRef } from './ImageTypes.js';
+import type { Buffer, Cursor, WrapResult } from './types.js';
+import type { BlockState } from './BlockTypes.js';
 export interface TextRendererProps {
     buffer: Buffer;
     cursor: Cursor;
     width?: number;
     showCursor?: boolean;
-    /** Placeholder state for expanding paste markers into display text */
-    placeholderState?: PlaceholderState;
-    images?: Record<string, ImageRef>;
+    /** Block state for expanding markers into display text */
+    blockState?: BlockState;
 }
 interface VisualSegment {
     text: string;
@@ -19,8 +18,8 @@ interface VisualRow {
     /** Total visual length (sum of segment text lengths). */
     visualLength: number;
 }
-export declare function wrapLines(buffer: Buffer, cursor: Cursor, width: number, placeholders?: PlaceholderState['placeholders']): WrapResult & {
+export declare function wrapLines(buffer: Buffer, cursor: Cursor, width: number, entries?: Map<string, import('./BlockTypes.js').BlockEntry>): WrapResult & {
     rows: VisualRow[];
 };
-export declare function TextRenderer({ buffer, cursor, width: propWidth, showCursor, placeholderState, }: TextRendererProps): React.ReactElement;
+export declare function TextRenderer({ buffer, cursor, width: propWidth, showCursor, blockState, }: TextRendererProps): React.ReactElement;
 export {};

package/dist/components/MultilineInput/TextRenderer.js

@@ -14,7 +14,7 @@ function expandRange(line, start, end, blocks) {
             if (raw > plainStart) {
                 segments.push({ text: line.slice(plainStart, raw), dim: false });
             }
-            segments.push({ text: block.displayText, dim: block.kind === 'sentinel' });
+            segments.push({ text: block.displayText, dim: block.dim });
             raw = block.end;
             plainStart = raw;
         }
@@ -46,7 +46,7 @@ function visualColumnForRawColumn(line, rowStart, column, blocks) {
     }
     return visualCol;
 }
-export function wrapLines(buffer, cursor, width, placeholders) {
+export function wrapLines(buffer, cursor, width, entries) {
     const visualLines = [];
     const rowsOut = [];
     let cursorVisualRow = 0;
@@ -56,8 +56,8 @@ export function wrapLines(buffer, cursor, width, placeholders) {
     for (let lineIndex = 0; lineIndex < buffer.lines.length; lineIndex++) {
         const rawLine = buffer.lines[lineIndex];
         const isCursorLine = lineIndex === cursor.line;
-        const blocks = findAtomicBlocks(rawLine, placeholders);
-        const rows = getVisualRows(rawLine, safeWidth, placeholders);
+        const blocks = findAtomicBlocks(rawLine, entries);
+        const rows = getVisualRows(rawLine, safeWidth, entries);
         if (rawLine.length === 0) {
             visualLines.push('');
             rowsOut.push({ segments: [], visualLength: 0 });
@@ -140,10 +140,10 @@ function renderVisualRow(row, isCursorRow, cursorCol, showCursor) {
         : [];
     return (_jsxs(_Fragment, { children: [renderSegments(before, 'b'), _jsx(Text, { inverse: true, dimColor: under.dim, children: under.ch }), renderSegments(after, 'a')] }));
 }
-export function TextRenderer({ buffer, cursor, width: propWidth, showCursor = true, placeholderState, }) {
+export function TextRenderer({ buffer, cursor, width: propWidth, showCursor = true, blockState, }) {
     const width = useTerminalWidth(propWidth);
-    const placeholders = placeholderState?.placeholders;
-    const { rows, cursorVisualRow, cursorVisualCol } = wrapLines(buffer, cursor, width, placeholders);
+    const entries = blockState?.entries;
+    const { rows, cursorVisualRow, cursorVisualCol } = wrapLines(buffer, cursor, width, entries);
     return (_jsx(Box, { flexDirection: "column", children: rows.map((row, index) => {
             const isCursorRow = index === cursorVisualRow;
             return (_jsx(Box, { children: renderVisualRow(row, isCursorRow, cursorVisualCol, showCursor) }, index));

package/dist/components/MultilineInput/__tests__/BlockMarker.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest';
+import { BLOCK_OPEN, BLOCK_CLOSE, createBlockMarker, parseBlockMarkers, findBlockMarkerAt, findBlockMarkerBefore, findBlockMarkerAfter, removeBlockMarker, blockMarkerVisualWidth, getBlockPlaceholderText, generateBlockId, } from '../BlockMarker.js';
+describe('generateBlockId', () => {
+    it('generates a non-empty string', () => {
+        const id = generateBlockId();
+        expect(id.length).toBeGreaterThan(0);
+    });
+    it('generates unique IDs', () => {
+        const ids = new Set(Array.from({ length: 100 }, () => generateBlockId()));
+        expect(ids.size).toBe(100);
+    });
+});
+describe('createBlockMarker', () => {
+    it('creates a paste marker', () => {
+        const marker = createBlockMarker('p', 'abc123', 1);
+        expect(marker).toBe(`${BLOCK_OPEN}p:abc123:1${BLOCK_CLOSE}`);
+    });
+    it('creates an image marker', () => {
+        const marker = createBlockMarker('i', 'xyz789', 2);
+        expect(marker).toBe(`${BLOCK_OPEN}i:xyz789:2${BLOCK_CLOSE}`);
+    });
+});
+describe('parseBlockMarkers', () => {
+    it('finds a single paste marker', () => {
+        const text = `hello ${BLOCK_OPEN}p:abc123:1${BLOCK_CLOSE} world`;
+        const markers = parseBlockMarkers(text);
+        expect(markers).toHaveLength(1);
+        expect(markers[0]).toMatchObject({ kind: 'p', id: 'abc123', displayNumber: 1, start: 6, end: 18 });
+    });
+    it('finds a single image marker', () => {
+        const text = `${BLOCK_OPEN}i:xyz789:2${BLOCK_CLOSE}`;
+        const markers = parseBlockMarkers(text);
+        expect(markers).toHaveLength(1);
+        expect(markers[0]).toMatchObject({ kind: 'i', id: 'xyz789', displayNumber: 2, start: 0, end: 12 });
+    });
+    it('finds multiple markers', () => {
+        const text = `${BLOCK_OPEN}p:id1:1${BLOCK_CLOSE}ab${BLOCK_OPEN}i:id2:2${BLOCK_CLOSE}`;
+        const markers = parseBlockMarkers(text);
+        expect(markers).toHaveLength(2);
+        expect(markers[0]).toMatchObject({ kind: 'p', id: 'id1', displayNumber: 1, start: 0 });
+        expect(markers[1]).toMatchObject({ kind: 'i', id: 'id2', displayNumber: 2 });
+    });
+    it('returns empty array for text without markers', () => {
+        expect(parseBlockMarkers('plain text')).toEqual([]);
+    });
+    it('returns empty array for empty text', () => {
+        expect(parseBlockMarkers('')).toEqual([]);
+    });
+    it('skips malformed markers', () => {
+        const text = `${BLOCK_OPEN}bad${BLOCK_CLOSE}`;
+        expect(parseBlockMarkers(text)).toEqual([]);
+    });
+    it('skips markers with unknown kind', () => {
+        const text = `${BLOCK_OPEN}x:abc:1${BLOCK_CLOSE}`;
+        expect(parseBlockMarkers(text)).toEqual([]);
+    });
+});
+describe('findBlockMarkerAt', () => {
+    it('finds marker containing the offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        const result = findBlockMarkerAt(text, 2);
+        expect(result).toMatchObject({ kind: 'p', id: 'id', displayNumber: 1 });
+    });
+    it('returns null for offset at marker start', () => {
+        const text = `${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}`;
+        expect(findBlockMarkerAt(text, 0)).toBeNull();
+    });
+    it('returns null for offset at marker end', () => {
+        const text = `${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}`;
+        const end = text.length;
+        expect(findBlockMarkerAt(text, end)).toBeNull();
+    });
+    it('returns null outside markers', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        expect(findBlockMarkerAt(text, 0)).toBeNull();
+        expect(findBlockMarkerAt(text, text.length - 1)).toBeNull();
+    });
+});
+describe('findBlockMarkerBefore', () => {
+    it('finds marker ending at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        const end = text.indexOf(BLOCK_CLOSE) + 1;
+        const result = findBlockMarkerBefore(text, end);
+        expect(result).toMatchObject({ kind: 'p', id: 'id' });
+    });
+    it('returns null when no marker ends at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        expect(findBlockMarkerBefore(text, 1)).toBeNull();
+    });
+});
+describe('findBlockMarkerAfter', () => {
+    it('finds marker starting at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        const start = text.indexOf(BLOCK_OPEN);
+        const result = findBlockMarkerAfter(text, start);
+        expect(result).toMatchObject({ kind: 'p', id: 'id' });
+    });
+    it('returns null when no marker starts at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        expect(findBlockMarkerAfter(text, 0)).toBeNull();
+        expect(findBlockMarkerAfter(text, 2)).toBeNull();
+    });
+});
+describe('removeBlockMarker', () => {
+    it('removes marker at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        const result = removeBlockMarker(text, 2);
+        expect(result).toBe('ab');
+    });
+    it('returns original text if no marker at offset', () => {
+        const text = 'abc';
+        expect(removeBlockMarker(text, 1)).toBe('abc');
+    });
+});
+describe('getBlockPlaceholderText', () => {
+    it('formats image display text', () => {
+        expect(getBlockPlaceholderText('i', 1)).toBe('[Pasted Image #1]');
+        expect(getBlockPlaceholderText('i', 42)).toBe('[Pasted Image #42]');
+    });
+    it('formats paste display text', () => {
+        expect(getBlockPlaceholderText('p', 1)).toBe('[Paste text #1]');
+        expect(getBlockPlaceholderText('p', 5)).toBe('[Paste text #5]');
+    });
+});
+describe('blockMarkerVisualWidth', () => {
+    it('returns correct width', () => {
+        expect(blockMarkerVisualWidth(1)).toBe('[Pasted Image #1]'.length);
+        expect(blockMarkerVisualWidth(100)).toBe('[Pasted Image #100]'.length);
+    });
+});