@code-yeongyu/senpi-tui 2026.9.30 → 2026.10.1-2

package/dist/utils.js

@@ -67,6 +67,10 @@ export function __widthCacheStats() {
     };
 }
 export const cjkBreakRegex = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}]/u;
+// CJK letters remain part of words and paths; only punctuation can separate prose from completions.
+export const cjkPunctuationRegex = new RegExp(`(?:(?=\\p{Punctuation})${cjkBreakRegex.source}|[，．：；！？（）［］｛｝“”‘’…—])`, "u");
+export const autocompleteSeparatorRegex = new RegExp(`(?:\\s|${cjkPunctuationRegex.source})`, "u");
+export const autocompleteBoundaryRegex = new RegExp(`(?:^|${autocompleteSeparatorRegex.source})`, "u");
 function isPrintableAscii(str) {
     for (let i = 0; i < str.length; i++) {
         const code = str.charCodeAt(i);
@@ -166,8 +170,12 @@ function finalizeTruncatedResult(prefix, prefixWidth, ellipsis, ellipsisWidth, m
  * check to avoid running the RGI_Emoji regex unnecessarily.
  */
 function graphemeWidth(segment) {
-    if (segment === "\t") {
-        return 3;
+    if (segment.length === 1) {
+        const code = segment.charCodeAt(0);
+        if (code >= 0x20 && code <= 0x7e)
+            return 1;
+        if (code === 0x09)
+            return 3;
     }
     // Some marks occupy cells even without a base character.
     if (terminalSpacingMarkRegex.test(segment)) {
@@ -229,9 +237,11 @@ export function visibleWidth(str) {
     if (str.length === 0) {
         return 0;
     }
-    // Fast path: pure ASCII printable
-    if (isPrintableAscii(str)) {
-        return str.length;
+    // Fast path: printable ASCII, tabs, and ANSI escape sequences. Styled lines take this path, so
+    // re-rendering after a theme change does not run grapheme segmentation on every line.
+    const asciiWidth = asciiVisibleWidth(str);
+    if (asciiWidth !== -1) {
+        return asciiWidth;
     }
     // Check cache
     const cachedCurrent = widthCacheCurrent.get(str);
@@ -251,22 +261,26 @@ export function visibleWidth(str) {
     if (str.includes("\t")) {
         clean = clean.replace(/\t/g, "   ");
     }
-    if (clean.includes("\x1b")) {
+    let escapeIndex = clean.indexOf("\x1b");
+    if (escapeIndex !== -1) {
         // Strip supported ANSI/OSC/APC escape sequences in one pass.
         // This covers CSI styling/cursor codes, OSC hyperlinks and prompt markers,
         // and APC sequences like CURSOR_MARKER.
         let stripped = "";
-        let i = 0;
-        while (i < clean.length) {
-            const ansi = extractAnsiCode(clean, i);
-            if (ansi) {
-                i += ansi.length;
-                continue;
+        let copyFrom = 0;
+        while (escapeIndex !== -1) {
+            const length = ansiCodeLength(clean, escapeIndex);
+            if (length > 0) {
+                stripped += clean.slice(copyFrom, escapeIndex);
+                escapeIndex += length;
+                copyFrom = escapeIndex;
             }
-            stripped += clean[i];
-            i++;
+            else {
+                escapeIndex++;
+            }
+            escapeIndex = clean.indexOf("\x1b", escapeIndex);
         }
-        clean = stripped;
+        clean = stripped + clean.slice(copyFrom);
     }
     // Calculate width
     let width = 0;
@@ -394,30 +408,52 @@ export function coalesceAdjacentSgr(line) {
  * Extract ANSI escape sequences from a string at the given position.
  */
 export function extractAnsiCode(str, pos) {
-    if (pos >= str.length || str[pos] !== "\x1b")
-        return null;
+    const length = ansiCodeLength(str, pos);
+    return length > 0 ? { code: str.substring(pos, pos + length), length } : null;
+}
+/**
+ * Width of a string made of printable ASCII, tabs, and ANSI escape sequences, or -1 if it contains
+ * anything else. Matches `visibleWidth` for those strings without allocating.
+ */
+function asciiVisibleWidth(str) {
+    let width = 0;
+    let i = 0;
+    while (i < str.length) {
+        const code = str.charCodeAt(i);
+        if (code >= 0x20 && code <= 0x7e) {
+            width++;
+            i++;
+        }
+        else if (code === 0x09) {
+            width += 3;
+            i++;
+        }
+        else if (code === 0x1b) {
+            const length = ansiCodeLength(str, i);
+            if (length === 0)
+                return -1;
+            i += length;
+        }
+        else {
+            return -1;
+        }
+    }
+    return width;
+}
+/** Length of the ANSI/OSC/APC escape sequence starting at `pos`, or 0 if there is none. */
+function ansiCodeLength(str, pos) {
+    if (pos >= str.length || str.charCodeAt(pos) !== 0x1b)
+        return 0;
     const next = str[pos + 1];
     // CSI sequence: ESC [ ... m/G/K/H/J
     if (next === "[") {
-        let j = pos + 2;
-        while (j < str.length && !/[mGKHJ]/.test(str[j]))
-            j++;
-        if (j < str.length)
-            return { code: str.substring(pos, j + 1), length: j + 1 - pos };
-        return null;
-    }
-    // OSC sequence: ESC ] ... BEL or ESC ] ... ST (ESC \)
-    // Used for hyperlinks (OSC 8), window titles, etc.
-    if (next === "]") {
-        let j = pos + 2;
-        while (j < str.length) {
-            if (str[j] === "\x07")
-                return { code: str.substring(pos, j + 1), length: j + 1 - pos };
-            if (str[j] === "\x1b" && str[j + 1] === "\\")
-                return { code: str.substring(pos, j + 2), length: j + 2 - pos };
-            j++;
+        for (let j = pos + 2; j < str.length; j++) {
+            const c = str.charCodeAt(j);
+            // m, G, K, H, J
+            if (c === 0x6d || c === 0x47 || c === 0x4b || c === 0x48 || c === 0x4a)
+                return j + 1 - pos;
         }
-        return null;
+        return 0;
     }
     // DCS sequence: ESC P ... ST (ESC \)
     // Used for tmux passthrough (ESC P tmux; ... ESC \) whose payload doubles
@@ -426,32 +462,33 @@ export function extractAnsiCode(str, pos) {
     if (next === "P") {
         let j = pos + 2;
         while (j < str.length) {
-            if (str[j] === "\x1b") {
+            if (str.charCodeAt(j) === 0x1b) {
                 if (str[j + 1] === "\\")
-                    return { code: str.substring(pos, j + 2), length: j + 2 - pos };
-                if (str[j + 1] === "\x1b") {
+                    return j + 2 - pos;
+                if (str.charCodeAt(j + 1) === 0x1b) {
                     j += 2;
                     continue;
                 }
             }
             j++;
         }
-        return null;
+        return 0;
     }
+    // OSC sequence: ESC ] ... BEL or ESC ] ... ST (ESC \)
+    // Used for hyperlinks (OSC 8), window titles, etc.
     // APC sequence: ESC _ ... BEL or ESC _ ... ST (ESC \)
     // Used for cursor marker and application-specific commands
-    if (next === "_") {
-        let j = pos + 2;
-        while (j < str.length) {
-            if (str[j] === "\x07")
-                return { code: str.substring(pos, j + 1), length: j + 1 - pos };
-            if (str[j] === "\x1b" && str[j + 1] === "\\")
-                return { code: str.substring(pos, j + 2), length: j + 2 - pos };
-            j++;
+    if (next === "]" || next === "_") {
+        for (let j = pos + 2; j < str.length; j++) {
+            const c = str.charCodeAt(j);
+            if (c === 0x07)
+                return j + 1 - pos;
+            if (c === 0x1b && str[j + 1] === "\\")
+                return j + 2 - pos;
         }
-        return null;
+        return 0;
     }
-    return null;
+    return 0;
 }
 function parseOsc8Hyperlink(ansiCode) {
     if (!ansiCode.startsWith("\x1b]8;")) {
@@ -726,16 +763,17 @@ class AnsiCodeTracker {
     }
 }
 function updateTrackerFromText(text, tracker) {
-    let i = 0;
-    while (i < text.length) {
-        const ansiResult = extractAnsiCode(text, i);
-        if (ansiResult) {
-            tracker.process(ansiResult.code);
-            i += ansiResult.length;
+    let i = text.indexOf("\x1b");
+    while (i !== -1) {
+        const length = ansiCodeLength(text, i);
+        if (length > 0) {
+            tracker.process(text.substring(i, i + length));
+            i += length;
         }
         else {
             i++;
         }
+        i = text.indexOf("\x1b", i);
     }
 }
 /** Return only the background color active at the end of an ANSI-styled string. */
@@ -744,6 +782,10 @@ export function getActiveBackgroundAnsi(text) {
     updateTrackerFromText(text, tracker);
     return tracker.getActiveBackgroundCode();
 }
+function* graphemeSegments(text) {
+    for (const { segment } of graphemeSegmenter.segment(text))
+        yield segment;
+}
 /**
  * Split text into words while keeping ANSI codes attached.
  */
@@ -769,13 +811,19 @@ function splitIntoTokensWithAnsi(text) {
             i += ansiResult.length;
             continue;
         }
-        let end = i;
-        while (end < text.length && !extractAnsiCode(text, end)) {
-            end++;
+        // Visible text runs up to the next escape sequence.
+        let end = text.indexOf("\x1b", i + 1);
+        while (end !== -1 && ansiCodeLength(text, end) === 0) {
+            end = text.indexOf("\x1b", end + 1);
         }
-        for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+        if (end === -1)
+            end = text.length;
+        const chunk = text.slice(i, end);
+        // Printable ASCII characters are single graphemes, so skip the segmenter for them.
+        const ascii = isPrintableAscii(chunk);
+        for (const segment of ascii ? chunk : graphemeSegments(chunk)) {
             const segmentIsSpace = segment === " ";
-            if (!segmentIsSpace && cjkBreakRegex.test(segment)) {
+            if (!ascii && !segmentIsSpace && cjkBreakRegex.test(segment)) {
                 flushCurrent();
                 const token = pendingAnsi + segment;
                 pendingAnsi = "";

package/dist/wheel-scroll.d.ts

@@ -0,0 +1,23 @@
+/** Lines moved per mouse-wheel event, or `"auto"` to accelerate fast wheel spins. */
+export type WheelScrollLines = number | "auto";
+/**
+ * Converts wheel events into line counts.
+ *
+ * In `"auto"` mode on terminals that do not accelerate wheel input, the count follows event
+ * velocity: an isolated notch moves one line, while a fast spin moves up to six lines per event.
+ * For example, notches 100 ms apart move 1 line each, 50 ms apart move 2, and 20 ms apart move 5.
+ */
+export declare class WheelScrollAccelerator {
+    private lines;
+    private readonly accelerate;
+    private lastTime;
+    private lastDirection;
+    private averageGap;
+    private carry;
+    constructor(lines?: WheelScrollLines, accelerate?: boolean);
+    setLines(lines: WheelScrollLines): void;
+    /** Return the positive line count for a wheel event in `direction` at time `now` (milliseconds). */
+    next(direction: -1 | 1, now: number): number;
+    private reset;
+}
+//# sourceMappingURL=wheel-scroll.d.ts.map

package/dist/wheel-scroll.js

@@ -0,0 +1,70 @@
+// Several events closer than this belong to one physical notch (Ghostty emits them ~4 ms apart)
+// or come from a high-resolution source. They move one line each and do not accelerate.
+const BURST_GAP_MS = 5;
+// A pause longer than this ends a scroll gesture.
+const GESTURE_GAP_MS = 200;
+// Average event gap that maps to one line per event. Faster events scale up proportionally.
+const REFERENCE_GAP_MS = 100;
+const MAX_AUTO_LINES = 6;
+/**
+ * Local macOS terminals receive wheel and trackpad deltas that the OS has already accelerated,
+ * and they emit one event per line. Other platforms, and SSH sessions where the client platform
+ * is unknown, usually send one event per wheel notch.
+ */
+function terminalAcceleratesWheel() {
+    const env = process.env;
+    return (process.platform === "darwin" &&
+        env.SSH_CONNECTION === undefined &&
+        env.SSH_CLIENT === undefined &&
+        env.SSH_TTY === undefined);
+}
+/**
+ * Converts wheel events into line counts.
+ *
+ * In `"auto"` mode on terminals that do not accelerate wheel input, the count follows event
+ * velocity: an isolated notch moves one line, while a fast spin moves up to six lines per event.
+ * For example, notches 100 ms apart move 1 line each, 50 ms apart move 2, and 20 ms apart move 5.
+ */
+export class WheelScrollAccelerator {
+    constructor(lines = "auto", accelerate = !terminalAcceleratesWheel()) {
+        this.lastTime = Number.NEGATIVE_INFINITY;
+        this.lastDirection = 0;
+        this.carry = 0;
+        this.lines = lines;
+        this.accelerate = accelerate;
+    }
+    setLines(lines) {
+        this.lines = lines;
+        this.reset();
+    }
+    /** Return the positive line count for a wheel event in `direction` at time `now` (milliseconds). */
+    next(direction, now) {
+        if (this.lines !== "auto")
+            return Number.isFinite(this.lines) ? Math.max(1, Math.floor(this.lines)) : 1;
+        if (!this.accelerate)
+            return 1;
+        const gap = now - this.lastTime;
+        const sameGesture = direction === this.lastDirection && gap <= GESTURE_GAP_MS;
+        this.lastTime = now;
+        this.lastDirection = direction;
+        if (!sameGesture) {
+            this.averageGap = undefined;
+            this.carry = 0;
+            return 1;
+        }
+        if (gap < BURST_GAP_MS)
+            return 1;
+        this.averageGap = this.averageGap === undefined ? gap : (this.averageGap + gap) / 2;
+        const lines = Math.min(MAX_AUTO_LINES, Math.max(1, REFERENCE_GAP_MS / this.averageGap)) + this.carry;
+        const whole = Math.floor(lines);
+        this.carry = lines - whole;
+        return whole;
+    }
+    reset() {
+        this.lastTime = Number.NEGATIVE_INFINITY;
+        this.lastDirection = 0;
+        this.averageGap = undefined;
+        this.carry = 0;
+    }
+}
+//# sourceMappingURL=wheel-scroll.js.map

package/native/clipboard.h

@@ -7,8 +7,17 @@
 #include <string.h>
 #endif
 
-typedef enum { CLIPBOARD_TEXT, CLIPBOARD_IMAGE, CLIPBOARD_WRITE } clipboard_operation;
-typedef enum { CLIPBOARD_UNAVAILABLE, CLIPBOARD_EMPTY, CLIPBOARD_UTF8, CLIPBOARD_LATIN1, CLIPBOARD_UTF16, CLIPBOARD_BUFFER } clipboard_format;
+typedef enum { CLIPBOARD_TEXT, CLIPBOARD_IMAGE, CLIPBOARD_WRITE, CLIPBOARD_FILES } clipboard_operation;
+// CLIPBOARD_PATHS stores concatenated, NUL-terminated UTF-8 paths in clipboard_job.data.
+typedef enum {
+    CLIPBOARD_UNAVAILABLE,
+    CLIPBOARD_EMPTY,
+    CLIPBOARD_UTF8,
+    CLIPBOARD_LATIN1,
+    CLIPBOARD_UTF16,
+    CLIPBOARD_BUFFER,
+    CLIPBOARD_PATHS
+} clipboard_format;
 
 typedef struct {
     napi_async_work work;
@@ -63,6 +72,33 @@ static void PI_NAPI_CALL execute_clipboard_work(napi_env env, void* data) {
     clipboard_execute(data);
 }
 
+static int create_clipboard_paths_value(
+    napi_env env,
+    const clipboard_job* job,
+    napi_create_string_utf8_fn create_string,
+    napi_value* result
+) {
+    napi_create_array_fn create_array = (napi_create_array_fn)node_symbol("napi_create_array");
+    napi_set_element_fn set_element = (napi_set_element_fn)node_symbol("napi_set_element");
+    if (!create_array || !set_element || create_array(env, result) != 0) return 1;
+
+    const char* cursor = job->data;
+    const char* end = cursor + job->length;
+    for (uint32_t index = 0; cursor < end; index++) {
+        const char* terminator = cursor;
+        while (terminator < end && *terminator != '\0') terminator++;
+        if (terminator == end) return 1;
+
+        napi_value item = 0;
+        if (create_string(env, cursor, (size_t)(terminator - cursor), &item) != 0 ||
+            set_element(env, *result, index, item) != 0) {
+            return 1;
+        }
+        cursor = terminator + 1;
+    }
+    return 0;
+}
+
 static void PI_NAPI_CALL complete_clipboard_work(napi_env env, int status, void* data) {
     clipboard_job* job = data;
     napi_create_string_utf8_fn create_string = (napi_create_string_utf8_fn)node_symbol("napi_create_string_utf8");
@@ -71,6 +107,8 @@ static void PI_NAPI_CALL complete_clipboard_work(napi_env env, int status, void*
     if (!job->error && job->operation != CLIPBOARD_WRITE) {
         if (job->format == CLIPBOARD_EMPTY) {
             result = null_value(env);
+        } else if (job->format == CLIPBOARD_PATHS) {
+            status = create_clipboard_paths_value(env, job, create_string, &result);
         } else if (job->format == CLIPBOARD_BUFFER) {
             napi_create_buffer_copy_fn create_buffer = (napi_create_buffer_copy_fn)node_symbol("napi_create_buffer_copy");
             status = create_buffer(env, job->length, job->data, 0, &result);

package/native/darwin/README.md

@@ -1,6 +1,6 @@
 # Darwin native prebuilds
 
-Provides modifier-key state and asynchronous text/image clipboard access using AppKit.
+Provides modifier-key state and asynchronous text, image, and file-path clipboard access using AppKit.
 
 ## Building
 

package/native/darwin/src/darwin-platform.m

@@ -66,6 +66,40 @@ static void clipboard_execute(clipboard_job* job) {
             } else {
                 clipboard_copy(job, text.UTF8String, [text lengthOfBytesUsingEncoding:NSUTF8StringEncoding], CLIPBOARD_UTF8);
             }
+        } else if (job->operation == CLIPBOARD_FILES) {
+            NSArray* urls = [pasteboard readObjectsForClasses:@[[NSURL class]]
+                options:@{NSPasteboardURLReadingFileURLsOnlyKey: @YES}];
+            size_t total = 0;
+            for (NSURL* url in urls) {
+                const char* path = url.fileSystemRepresentation;
+                if (!path) continue;
+                size_t length = strlen(path);
+                if (length == SIZE_MAX || total > SIZE_MAX - length - 1) {
+                    job->error = "Clipboard file paths are too large";
+                    return;
+                }
+                total += length + 1;
+            }
+            if (total == 0) {
+                job->format = CLIPBOARD_EMPTY;
+                return;
+            }
+            char* paths = clipboard_alloc(total);
+            if (!paths) {
+                job->error = "Out of memory";
+                return;
+            }
+            char* cursor = paths;
+            for (NSURL* url in urls) {
+                const char* path = url.fileSystemRepresentation;
+                if (!path) continue;
+                size_t length = strlen(path);
+                memcpy(cursor, path, length + 1);
+                cursor += length + 1;
+            }
+            job->data = paths;
+            job->length = total;
+            job->format = CLIPBOARD_PATHS;
         } else {
             if (![pasteboard availableTypeFromArray:@[ NSPasteboardTypePNG, NSPasteboardTypeTIFF ]]) {
                 job->format = CLIPBOARD_EMPTY;
@@ -84,10 +118,15 @@ static void clipboard_execute(clipboard_job* job) {
     }
 }
 
+static napi_value PI_NAPI_CALL get_clipboard_file_paths(napi_env env, napi_callback_info info) {
+    return queue_clipboard(env, info, CLIPBOARD_FILES);
+}
+
 PI_NAPI_EXPORT napi_value napi_register_module_v1(napi_env env, napi_value exports) {
     set_function_export(env, exports, "isModifierPressed", is_modifier_pressed);
     set_function_export(env, exports, "getText", get_clipboard_text);
     set_function_export(env, exports, "setText", set_clipboard_text);
     set_function_export(env, exports, "getImage", get_clipboard_image);
+    set_function_export(env, exports, "getFilePaths", get_clipboard_file_paths);
     return exports;
 }

package/native/napi.h

@@ -26,6 +26,7 @@ typedef void* napi_deferred;
 typedef void (PI_NAPI_CALL *napi_async_execute_callback)(napi_env, void*);
 typedef void (PI_NAPI_CALL *napi_async_complete_callback)(napi_env, int, void*);
 typedef int (PI_NAPI_CALL *napi_create_async_work_fn)(napi_env, napi_value, napi_value, napi_async_execute_callback, napi_async_complete_callback, void*, napi_async_work*);
+typedef int (PI_NAPI_CALL *napi_create_array_fn)(napi_env, napi_value*);
 typedef int (PI_NAPI_CALL *napi_async_work_fn)(napi_env, napi_async_work);
 typedef int (PI_NAPI_CALL *napi_create_promise_fn)(napi_env, napi_deferred*, napi_value*);
 typedef int (PI_NAPI_CALL *napi_settle_deferred_fn)(napi_env, napi_deferred, napi_value);
@@ -41,6 +42,7 @@ typedef int (PI_NAPI_CALL *napi_get_value_fn)(napi_env, napi_value*);
 typedef int (PI_NAPI_CALL *napi_get_value_string_utf8_fn)(napi_env, napi_value, char*, size_t, size_t*);
 typedef int (PI_NAPI_CALL *napi_get_value_string_utf16_fn)(napi_env, napi_value, uint16_t*, size_t, size_t*);
 typedef int (PI_NAPI_CALL *napi_set_named_property_fn)(napi_env, napi_value, const char*, napi_value);
+typedef int (PI_NAPI_CALL *napi_set_element_fn)(napi_env, napi_value, uint32_t, napi_value);
 typedef int (PI_NAPI_CALL *napi_throw_error_fn)(napi_env, const char*, const char*);
 
 static void* node_symbol(const char* name) {

package/package.json

@@ -1,12 +1,12 @@
 {
 	"name": "@code-yeongyu/senpi-tui",
-	"version": "2026.9.30",
+	"version": "2026.10.1-2",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",
 	"scripts": {
 		"clean": "shx rm -rf dist",
-		"build": "tsgo -p tsconfig.build.json",
+		"build": "tsc -p tsconfig.build.json",
 		"build:native:darwin": "native/darwin/build.sh",
 		"build:native:linux": "native/linux/build.sh",
 		"build:native:win32": "node native/win32/build.mjs",