@toddzheng024/dscode-bundle 0.7.12 → 0.7.14

package/vendor/tui/lib/render/editor.mjs

@@ -0,0 +1,437 @@
+/**
+ * Pure composer editor model with Codex textarea semantics: a grapheme
+ * cursor over a column-safe multiline layout, word/piece motion, single-entry
+ * kill + yank, and the shell-recall boundary gate that keeps Up/Down usable
+ * inside a multiline draft.
+ *
+ * The model is intentionally string-offset based (UTF-16 indices clamped to
+ * grapheme boundaries) so the React state stays two primitives
+ * (value, cursor) and every operation here stays pure and testable.
+ *
+ * Word motion follows Codex's piece semantics: whitespace separates runs,
+ * punctuation runs stay atomic, and each Han grapheme is its own boundary.
+ *
+ * @module @deepseek-ai/dsh-code/render/editor
+ */
+import { visibleColumns } from './markdown.mjs';
+const segmenter = typeof Intl !== 'undefined' && 'Segmenter' in Intl
+    ? new Intl.Segmenter('en', { granularity: 'grapheme' })
+    : undefined;
+/**
+ * Split text into grapheme clusters. Falls back to code points when
+ * Intl.Segmenter is unavailable; the fallback still keeps surrogate pairs
+ * (emoji) atomic so the cursor can never split one.
+ */
+export function splitGraphemes(text) {
+    if (text === '')
+        return [];
+    const spans = [];
+    if (segmenter !== undefined) {
+        for (const piece of segmenter.segment(text)) {
+            spans.push({
+                text: piece.segment,
+                start: piece.index,
+                end: piece.index + piece.segment.length,
+                width: visibleColumns(piece.segment),
+            });
+        }
+        return spans;
+    }
+    let start = 0;
+    for (const char of text) {
+        spans.push({ text: char, start, end: start + char.length, width: visibleColumns(char) });
+        start += char.length;
+    }
+    return spans;
+}
+/** Round one UTF-16 offset down to the grapheme boundary at or before it. */
+function floorBoundary(spans, offset) {
+    for (let index = spans.length - 1; index >= 0; index -= 1) {
+        const span = spans[index];
+        if (span.end <= offset)
+            return span.end;
+        if (span.start < offset)
+            return span.start;
+    }
+    return 0;
+}
+/** Clamp a cursor offset to the nearest grapheme boundary (surrogates, ZWJ, marks stay whole). */
+export function clampCursor(value, offset) {
+    if (value === '')
+        return 0;
+    const target = Math.max(0, Math.min(value.length, Math.floor(offset)));
+    if (target === 0 || target === value.length)
+        return target;
+    const spans = splitGraphemes(value);
+    const down = floorBoundary(spans, target);
+    if (down === target)
+        return target;
+    const up = spans.find(span => span.start >= target)?.start ?? value.length;
+    return up - target < target - down ? up : down;
+}
+/**
+ * Delete the final grapheme cluster (append-only drafts without a cursor).
+ * Surrogate pairs and multi-codepoint emoji stay whole instead of leaving a
+ * lone trailing code unit behind.
+ */
+export function deleteLastGrapheme(text) {
+    if (text === '')
+        return '';
+    const spans = splitGraphemes(text);
+    return text.slice(0, spans[spans.length - 1].start);
+}
+/**
+ * Step the cursor by whole graphemes (negative steps left). The cursor is
+ * assumed to sit on a boundary; any drift is clamped first.
+ */
+export function moveCursorBy(value, offset, delta) {
+    if (delta === 0 || value === '')
+        return clampCursor(value, offset);
+    const spans = splitGraphemes(value);
+    const boundaries = [0];
+    for (const span of spans)
+        boundaries.push(span.end);
+    const current = boundaries.indexOf(clampCursor(value, offset));
+    if (current === -1)
+        return clampCursor(value, offset);
+    const next = Math.max(0, Math.min(boundaries.length - 1, current + delta));
+    return boundaries[next];
+}
+/**
+ * Normalize text entering the draft: CRLF/CR become LF, tabs become two
+ * spaces (terminal tab stops are contextual and cannot join a deterministic
+ * row budget), and every other C0 control byte plus DEL is REMOVED — the
+ * draft is data, so a stray ESC (Windows Terminal file drops) disappears
+ * instead of rendering as literal backslash-x-1-b text. Newlines survive.
+ */
+export function sanitizeDraftText(text) {
+    return text
+        .replaceAll('\r\n', '\n')
+        .replaceAll('\r', '\n')
+        // The draft is DATA, not display: strip C0 control bytes (the stray ESC
+        // that rides Windows Terminal file drops) and DEL instead of escaping
+        // them into visible "\x1b" text. Newlines survive; tabs widen.
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu, '')
+        .replaceAll('\t', '  ');
+}
+/**
+ * Hard-wrap the draft into column-safe physical rows. Wide graphemes never
+ * split across rows (a grapheme that does not fit flushes the row first) and
+ * explicit newlines end their row without occupying a cell.
+ */
+export function editorModel(value, columns) {
+    const width = Math.max(1, Math.floor(columns));
+    const spans = splitGraphemes(value);
+    const rows = [];
+    let text = '';
+    let start = 0;
+    let used = 0;
+    const offsets = [0];
+    const rowColumns = [0];
+    const rowCuts = [0];
+    const flush = (end) => {
+        rows.push({ text, start, end, offsets: [...offsets], columns: [...rowColumns], cuts: [...rowCuts] });
+        text = '';
+        used = 0;
+        offsets.length = 0;
+        rowColumns.length = 0;
+        rowCuts.length = 0;
+    };
+    for (const span of spans) {
+        if (span.text === '\n') {
+            flush(span.start);
+            start = span.end;
+            offsets.push(span.end);
+            rowColumns.push(0);
+            rowCuts.push(0);
+            continue;
+        }
+        if (used > 0 && used + span.width > width) {
+            flush(span.start);
+            start = span.start;
+            offsets.push(span.start);
+            rowColumns.push(0);
+            rowCuts.push(0);
+        }
+        text += span.text;
+        used += span.width;
+        offsets.push(span.end);
+        rowColumns.push(used);
+        rowCuts.push(text.length);
+    }
+    if (text !== '' || rows.length === 0)
+        flush(value.length);
+    else if (offsets.length > 0) {
+        // Trailing newline leaves one pending empty boundary row.
+        rows.push({ text: '', start, end: value.length, offsets: [...offsets], columns: [...rowColumns], cuts: [...rowCuts] });
+    }
+    return { rows, length: value.length };
+}
+/** Split one row around the authoritative caret; every other row stays whole. */
+export function editorRowParts(row, rowIndex, caretRow, cursor, caretEnabled = true) {
+    if (!caretEnabled || rowIndex !== caretRow)
+        return { before: '', caret: '', after: row.text, hasCaret: false };
+    const at = row.offsets.indexOf(cursor);
+    if (at < 0)
+        return { before: '', caret: '', after: row.text, hasCaret: false };
+    const before = at > 0 ? row.text.slice(0, row.cuts[at]) : '';
+    const caret = at < row.cuts.length - 1 ? row.text.slice(row.cuts[at], row.cuts[at + 1]) : ' ';
+    const after = at < row.cuts.length - 1 ? row.text.slice(row.cuts[at + 1]) : '';
+    return { before, caret, after, hasCaret: true };
+}
+/** Map a cursor offset to its caret site on the wrapped rows. */
+export function caretSite(model, offset) {
+    const target = Math.max(0, Math.min(model.length, offset));
+    for (let index = model.rows.length - 1; index >= 0; index -= 1) {
+        const row = model.rows[index];
+        const at = row.offsets.indexOf(target);
+        if (at >= 0)
+            return { row: index, column: row.columns[at] };
+    }
+    const last = model.rows[model.rows.length - 1];
+    return { row: model.rows.length - 1, column: last === undefined ? 0 : last.columns[last.columns.length - 1] };
+}
+/**
+ * Move the caret across physical rows keeping a preferred display column
+ * (Codex `preferred_col`): horizontal moves reset the preference, vertical
+ * moves reuse it, clamped to each row's width.
+ */
+export function moveCursorVertically(model, offset, preferredColumn, delta) {
+    const site = caretSite(model, offset);
+    const target = site.row + delta;
+    if (delta === 0)
+        return offset;
+    if (target < 0)
+        return 0;
+    if (target >= model.rows.length)
+        return model.length;
+    const row = model.rows[target];
+    const wanted = Math.max(0, Math.min(preferredColumn, row.columns[row.columns.length - 1]));
+    let best = 0;
+    for (let index = 1; index < row.columns.length; index += 1) {
+        if (row.columns[index] <= wanted)
+            best = index;
+        else
+            break;
+    }
+    return row.offsets[best];
+}
+/** The start/end offsets of the logical line containing the cursor. */
+export function lineBounds(value, offset) {
+    const target = Math.max(0, Math.min(value.length, offset));
+    const start = value.lastIndexOf('\n', Math.max(0, target - 1)) + 1;
+    const end = value.indexOf('\n', target);
+    return { start, end: end === -1 ? value.length : end };
+}
+/** Codex WORD_SEPARATORS: punctuation runs are their own word pieces. */
+const WORD_SEPARATORS = new Set('`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?');
+const HAN_GRAPHEME = /^\p{Script=Han}(?:\p{Mark}|\uFE0F)*$/u;
+const UNICODE_PUNCTUATION = /^\p{P}+$/u;
+function classifyGrapheme(text) {
+    if (/^\s$/u.test(text))
+        return 'space';
+    return WORD_SEPARATORS.has(text) || UNICODE_PUNCTUATION.test(text) ? 'punct' : 'word';
+}
+/** Maximal same-class runs; Han graphemes deliberately stay one run each. */
+function pieceRuns(value) {
+    const runs = [];
+    let current;
+    for (const span of splitGraphemes(value)) {
+        const klass = span.text === '\n' ? 'space' : classifyGrapheme(span.text);
+        const atomic = klass === 'word' && HAN_GRAPHEME.test(span.text);
+        if (current !== undefined && current.class === klass && !current.atomic && !atomic) {
+            current.end = span.end;
+            continue;
+        }
+        current = { start: span.start, end: span.end, class: klass, atomic };
+        runs.push(current);
+    }
+    return runs;
+}
+/**
+ * Codex `beginning_of_previous_word`: skip whitespace left, then land on the
+ * START of the trailing non-space piece (extending over separator pieces).
+ */
+export function moveWordLeft(value, offset) {
+    const cursor = clampCursor(value, offset);
+    const runs = pieceRuns(value);
+    // The last run with content before the cursor includes the current word's
+    // left-hand fragment, instead of skipping the whole containing run.
+    let index = runs.findLastIndex(run => run.start < cursor);
+    if (index < 0)
+        return 0;
+    if (runs[index].class === 'space') {
+        index -= 1;
+        if (index < 0)
+            return 0;
+    }
+    let target = index;
+    while (target > 0 && runs[target].class === 'punct' && runs[target - 1].class === 'punct')
+        target -= 1;
+    return runs[target].start;
+}
+/**
+ * Codex `end_of_next_word`: skip whitespace right, then land on the END of
+ * the leading non-space piece (extending over separator pieces).
+ */
+export function moveWordRight(value, offset) {
+    const cursor = clampCursor(value, offset);
+    const runs = pieceRuns(value);
+    // The first run with content after the cursor includes the current word's
+    // right-hand fragment, instead of jumping straight to the following word.
+    let index = runs.findIndex(run => run.end > cursor);
+    if (index >= runs.length)
+        return value.length;
+    if (runs[index].class === 'space') {
+        index += 1;
+        if (index >= runs.length)
+            return value.length;
+    }
+    let target = index;
+    while (target < runs.length - 1 && runs[target].class === 'punct' && runs[target + 1].class === 'punct')
+        target += 1;
+    return runs[target].end;
+}
+function replaceRange(value, cursor, start, end, killed) {
+    const from = Math.min(start, end);
+    const to = Math.max(start, end);
+    if (from >= to)
+        return { value, cursor, killed: undefined };
+    const text = value.slice(from, to);
+    return {
+        value: value.slice(0, from) + value.slice(to),
+        cursor: Math.max(0, cursor - Math.max(0, Math.min(cursor, to) - from)),
+        killed: killed ? text : undefined,
+    };
+}
+/** Delete the grapheme cluster before the cursor. */
+export function deleteBackward(value, cursor) {
+    if (cursor === 0)
+        return { value, cursor, killed: undefined };
+    const spans = splitGraphemes(value.slice(0, cursor));
+    const start = spans.length === 0 ? 0 : spans[spans.length - 1].start;
+    return replaceRange(value, cursor, start, cursor, false);
+}
+/** Delete the grapheme cluster at the cursor. */
+export function deleteForward(value, cursor) {
+    if (cursor >= value.length)
+        return { value, cursor, killed: undefined };
+    const span = splitGraphemes(value).find(candidate => candidate.start >= cursor);
+    return replaceRange(value, cursor, cursor, span === undefined ? value.length : span.end, false);
+}
+/** Delete back to the start of the previous word (fills the kill buffer). */
+export function deleteWordBackward(value, cursor) {
+    const start = moveWordLeft(value, cursor);
+    return replaceRange(value, cursor, start, cursor, true);
+}
+/** Delete forward to the end of the next word (fills the kill buffer). */
+export function deleteWordForward(value, cursor) {
+    const end = moveWordRight(value, cursor);
+    return replaceRange(value, cursor, cursor, end, true);
+}
+/** Ctrl+U: kill from the line start to the cursor; at BOL, kill the newline. */
+export function killToLineStart(value, cursor) {
+    const bounds = lineBounds(value, cursor);
+    if (cursor > bounds.start)
+        return replaceRange(value, cursor, bounds.start, cursor, true);
+    if (bounds.start > 0)
+        return replaceRange(value, cursor, bounds.start - 1, bounds.start, true);
+    return { value, cursor, killed: undefined };
+}
+/** Ctrl+K: kill from the cursor to the line end; at EOL, kill the newline. */
+export function killToLineEnd(value, cursor) {
+    const bounds = lineBounds(value, cursor);
+    if (cursor < bounds.end)
+        return replaceRange(value, cursor, cursor, bounds.end, true);
+    if (bounds.end < value.length)
+        return replaceRange(value, cursor, bounds.end, bounds.end + 1, true);
+    return { value, cursor, killed: undefined };
+}
+/** Insert sanitized text at the cursor. */
+export function insertText(value, cursor, text) {
+    const safe = sanitizeDraftText(text);
+    if (safe === '')
+        return { value, cursor, killed: undefined };
+    return { value: value.slice(0, cursor) + safe + value.slice(cursor), cursor: cursor + safe.length, killed: undefined };
+}
+/** Ctrl+A: current logical line start, then the previous line start on repeat. */
+export function moveToLineStart(value, cursor, crossOnRepeat) {
+    const site = clampCursor(value, cursor);
+    const bounds = lineBounds(value, site);
+    if (!crossOnRepeat || site !== bounds.start || bounds.start === 0)
+        return bounds.start;
+    return lineBounds(value, bounds.start - 1).start;
+}
+/** Ctrl+E: current logical line end, then the next line end on repeat. */
+export function moveToLineEnd(value, cursor, crossOnRepeat) {
+    const site = clampCursor(value, cursor);
+    const bounds = lineBounds(value, site);
+    if (!crossOnRepeat || site !== bounds.end || bounds.end >= value.length)
+        return bounds.end;
+    return lineBounds(value, bounds.end + 1).end;
+}
+/**
+ * Remap a captured range when all intervening edits are wholly before or
+ * wholly after it. An edit overlapping either boundary invalidates the
+ * anchor instead of guessing and inserting content at a surprising place.
+ */
+export function remapStableRange(original, current, range) {
+    const start = Math.max(0, Math.min(original.length, range.start));
+    const end = Math.max(start, Math.min(original.length, range.end));
+    if (original === current)
+        return { start, end };
+    let prefix = 0;
+    const shared = Math.min(original.length, current.length);
+    while (prefix < shared && original[prefix] === current[prefix])
+        prefix += 1;
+    let suffix = 0;
+    while (suffix < original.length - prefix
+        && suffix < current.length - prefix
+        && original[original.length - 1 - suffix] === current[current.length - 1 - suffix])
+        suffix += 1;
+    const oldChangedEnd = original.length - suffix;
+    if (prefix >= end)
+        return { start, end };
+    if (oldChangedEnd <= start) {
+        const delta = current.length - original.length;
+        return { start: start + delta, end: end + delta };
+    }
+    return undefined;
+}
+/** Replace a current range while preserving a cursor moved after capture. */
+export function replaceRangePreservingCursor(value, cursor, range, replacement) {
+    const start = Math.max(0, Math.min(value.length, range.start));
+    const end = Math.max(start, Math.min(value.length, range.end));
+    const site = clampCursor(value, cursor);
+    const nextCursor = site <= start
+        ? site
+        : site >= end
+            ? site + replacement.length - (end - start)
+            : start + replacement.length;
+    return {
+        value: value.slice(0, start) + replacement + value.slice(end),
+        cursor: nextCursor,
+        killed: undefined,
+    };
+}
+/**
+ * Composer editor row budget: the editor itself never grows past this many
+ * physical rows; deeper drafts scroll internally to keep the caret visible.
+ * Short terminals collapse toward one row so the live transcript keeps room.
+ */
+export function composerMaxRows(terminalRows) {
+    return Math.max(1, Math.min(6, Math.floor((Math.max(1, terminalRows) - 10) / 3)));
+}
+/**
+ * History navigation starts with Up on an empty draft, or continues from an
+ * unchanged recalled entry whenever the caret sits on either text edge
+ * (start or end) - moving the caret into the interior returns the keys to
+ * ordinary editing until an edge is reached again.
+ */
+export function shouldRecallNavigate(value, cursor, lastRecalled, direction) {
+    if (value === '')
+        return direction < 0;
+    if (lastRecalled !== value)
+        return false;
+    return cursor === 0 || cursor === value.length;
+}

package/vendor/tui/lib/render/export.mjs

@@ -0,0 +1,119 @@
+/**
+ * Markdown export of one transcript view: the /export command's pure
+ * formatter. Deterministic and side-effect free — the runner owns the file
+ * write, so tests drive the builder with folded views directly.
+ *
+ * @module @deepseek-ai/dsh-code/render/export
+ */
+import { assertNever } from '@deepseek-ai/dsh-util-values';
+import { fileLabels, imageLabels } from './projection.mjs';
+import { t } from '../i18n.mjs';
+/**
+ * Render the transcript as a standalone markdown document.
+ * @param view - the folded transcript view to export.
+ * @param sessionId - the full session identity for the header.
+ * @returns the complete markdown text.
+ */
+/** Both user and queued rows export the same attachment label block. */
+const attachmentLabels = (entry) => [imageLabels(entry.images), fileLabels(entry.files)].filter(label => label !== '').join('\n');
+export function buildExportMarkdown(view, sessionId) {
+    const out = [
+        view.title === ''
+            ? `# dsh session ${sessionId}`
+            : `# ${view.title}`,
+        `> session ${sessionId}`,
+        '',
+    ];
+    // The effective system prompt (v3 surface nodes) heads the export in a
+    // collapsed block: visible when audited, out of the way when scrolled.
+    if (view.systemPrompt !== '') {
+        out.push('<details><summary>system prompt</summary>', '', view.systemPrompt, '', '</details>', '');
+    }
+    for (const entry of view.entries) {
+        switch (entry.kind) {
+            case 'user':
+                if (entry.notice) {
+                    out.push(`> ⤷ context: ${entry.text}`, '');
+                }
+                else {
+                    const attachments = attachmentLabels(entry);
+                    // How the prompt was delivered is part of the record: a queued or
+                    // steered message reads differently from one typed into an idle
+                    // composer. Ordinary prompts keep the bare heading.
+                    const marker = entry.delivery === undefined ? '' : ` (${t(entry.delivery === 'queued' ? 'entry.delivery.queued' : 'entry.delivery.steered')})`;
+                    out.push(`## user${marker}`, '', entry.text, ...(attachments === '' ? [] : [attachments]), '');
+                }
+                break;
+            case 'assistant':
+                if (entry.reasoning !== '') {
+                    out.push('<details><summary>thinking</summary>', '', entry.reasoning, '', '</details>', '');
+                }
+                out.push('## assistant', '', entry.text, '');
+                break;
+            case 'tool':
+                out.push(`### tool \`${entry.name}\``, '');
+                if (entry.preview !== '')
+                    out.push(`- args: ${entry.preview}`);
+                if (entry.subs.length > 0) {
+                    for (const sub of entry.subs) {
+                        const label = sub.preview === '' ? sub.name : `${sub.name} ${sub.preview}`;
+                        out.push(`- dispatch: ${sub.state === 'error' ? 'error' : sub.state === 'running' ? 'running' : 'ok'} · ${label}${sub.summary === '' ? '' : ` · ${sub.summary}`}`);
+                    }
+                    if (entry.subsDropped > 0)
+                        out.push(`- dispatch: … ${entry.subsDropped} earlier dispatch${entry.subsDropped === 1 ? '' : 'es'}`);
+                }
+                if (entry.summary !== '')
+                    out.push(`- ${entry.state === 'error' ? 'error' : 'result'}: ${entry.summary}`);
+                out.push('');
+                break;
+            case 'command':
+                out.push(`### /${entry.name}${entry.args === '' ? '' : ` ${entry.args}`}`, '');
+                if (entry.summary !== '')
+                    out.push(`- ${entry.state === 'error' ? 'error' : 'result'}: ${entry.summary}`);
+                out.push('');
+                break;
+            case 'error':
+                out.push(`> ⨯ ${entry.text}`, '');
+                break;
+            case 'turn-marker':
+                out.push(`> ${entry.text}`, '');
+                break;
+            case 'compaction':
+                out.push(entry.ok
+                    ? `> compacted ~${entry.tokens} tokens`
+                    : `> compaction failed: ${entry.error}`, '');
+                break;
+            case 'retry':
+                out.push(`> retry ${entry.attempt}/${entry.max} (${entry.code})`, '');
+                break;
+            case 'files':
+                out.push(`> files changed: ${entry.paths.join(', ')}`, '');
+                break;
+            case 'workflow':
+                out.push(`### workflow \`${entry.name}\` (${entry.state})`, '');
+                for (const member of entry.members) {
+                    const phase = member.phase === '' ? '' : ` [${member.phase}]`;
+                    out.push(`- ${member.outcome}: ${member.label}${phase}`);
+                }
+                if (entry.membersDropped > 0)
+                    out.push(`- … ${entry.membersDropped} earlier member${entry.membersDropped === 1 ? '' : 's'}`);
+                out.push('');
+                break;
+            case 'pending':
+                // Codex PendingSteer: queued prompts export like ordinary user rows.
+                out.push('## user', '', entry.text, ...(attachmentLabels(entry) === '' ? [] : [attachmentLabels(entry)]), '');
+                break;
+            default:
+                assertNever(entry, 'transcript entry kind');
+        }
+    }
+    if (view.streaming !== '')
+        out.push('## assistant (streaming)', '', view.streaming, '');
+    const { stats } = view;
+    out.push('---', '');
+    out.push(`- model: ${view.model === '' ? '(none yet)' : view.model}`);
+    out.push(`- turns: ${stats.turns} · steps: ${stats.steps}`);
+    out.push(`- tokens: ↑${stats.usage.uncachedInputTokens} ↓${stats.usage.outputTokens} · cache read ${stats.usage.cacheReadTokens} · cache write ${stats.usage.cacheWriteTokens}`);
+    out.push(`- todos: ${view.todos.length}`);
+    return out.join('\n');
+}

package/vendor/tui/lib/render/fuzzy.mjs

@@ -0,0 +1,79 @@
+/**
+ * Shared fuzzy ranking for `/` and `@` menu candidates: the query must be a
+ * case-insensitive ordered subsequence of the candidate name. Prefix hits
+ * rank first, then the strongest alignment score, then the source order of
+ * the input. Ported from the upstream web client's ui-primitives
+ * (rank-by-name.ts) so the terminal matches the web menu's discovery feel;
+ * the algorithm is unchanged, only the module's home moved.
+ *
+ * @module @deepseek-ai/dsh-code/render/fuzzy
+ */
+/** Extra weight for name starts and separator boundaries. */
+function boundaryBonus(name, index) {
+    return index === 0 || name.charAt(index - 1) === '-' || name.charAt(index - 1) === '_' ? 8 : 0;
+}
+/**
+ * Score the strongest ordered-subsequence alignment in O(name × query).
+ * Boundary and adjacent matches earn weight; skipped and leading characters
+ * cost weight. Undefined when the query is not a subsequence of the name.
+ */
+function alignmentScore(name, query) {
+    if (query.length > name.length)
+        return undefined;
+    const noMatch = Number.NEGATIVE_INFINITY;
+    let previous = Array(name.length).fill(noMatch);
+    for (let index = 0; index < name.length; index++) {
+        if (name.charAt(index) === query.charAt(0))
+            previous[index] = 1 + boundaryBonus(name, index) - index;
+    }
+    for (let queryIndex = 1; queryIndex < query.length; queryIndex++) {
+        const current = Array(name.length).fill(noMatch);
+        // Sweep the previous row once: `left` is its score one character back
+        // (the adjacent continuation), `leftLeft` two back (the earliest gapped one).
+        let left = noMatch;
+        let leftLeft = noMatch;
+        let bestGapped = noMatch;
+        for (const [index, prior] of previous.entries()) {
+            if (leftLeft !== noMatch)
+                bestGapped = Math.max(bestGapped, leftLeft + index - 2);
+            if (name.charAt(index) === query.charAt(queryIndex)) {
+                const bonus = 1 + boundaryBonus(name, index);
+                let score = noMatch;
+                if (left !== noMatch)
+                    score = left + bonus + 4;
+                if (bestGapped !== noMatch)
+                    score = Math.max(score, bestGapped + bonus + 1 - index);
+                current[index] = score;
+            }
+            leftLeft = left;
+            left = prior;
+        }
+        previous = current;
+    }
+    let best = noMatch;
+    for (const score of previous)
+        best = Math.max(best, score);
+    return best === noMatch ? undefined : best;
+}
+/**
+ * Rank named items by a menu query.
+ * @param items - candidates in source order (the caller's composition order
+ * is the final tie-breaker, e.g. local commands before registry entries).
+ * @param rawQuery - the text typed after the trigger, matched case-insensitively.
+ * @returns the matching items: prefix hits first, then by alignment score,
+ * then in source order. The input list itself for an empty query.
+ */
+export function rankByName(items, rawQuery) {
+    const query = rawQuery.toLowerCase();
+    if (query === '')
+        return items;
+    const ranked = [];
+    items.forEach((item, index) => {
+        const name = item.name.toLowerCase();
+        const score = alignmentScore(name, query);
+        if (score !== undefined)
+            ranked.push({ item, index, prefix: name.startsWith(query), score });
+    });
+    ranked.sort((left, right) => Number(right.prefix) - Number(left.prefix) || right.score - left.score || left.index - right.index);
+    return ranked.map(match => match.item);
+}