@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/workflows/src/tui/inputs-picker-render.ts

@@ -1,312 +0,0 @@
-import type { WorkflowInputEntry } from "../extension/render-result.js";
-import { paint } from "./color-utils.js";
-import type { GraphTheme } from "./graph-theme.js";
-import { renderCompactBandHeader } from "./header.js";
-import { clampGraphemeOffset, headToWidth, layoutEditableText, tailToWidth } from "./inputs-picker-editing.js";
-import type { InputsPickerRenderOpts, InputsPickerState } from "./inputs-picker-types.js";
-import { computeInvalid, invalidForField } from "./inputs-picker-types.js";
-import { renderAskChoiceRows, renderSubmitControls } from "./submit-pane.js";
-import { graphemes, truncateToWidth, visibleWidth, wrapPlainText } from "./text-helpers.js";
-
-function renderInlineText(
-	value: string,
-	focused: boolean,
-	cursorOn: boolean,
-	usable: number,
-	theme: GraphTheme,
-	placeholder: string | undefined,
-	isEmpty: boolean,
-	caret?: number,
-): string {
-	const showCursor = focused && cursorOn;
-	if (isEmpty) {
-		const ph = placeholder ?? "";
-		if (ph === "") {
-			return padLine(showCursor ? paint("▋", theme.accent) : " ", usable);
-		}
-		const [first = "", ...rest] = graphemes(ph);
-		const head = showCursor ? paint(first, theme.bg, { bg: theme.accent }) : paint(first, theme.dim);
-		return padLine(head + paint(rest.join(""), theme.dim), usable);
-	}
-	const safe = clampGraphemeOffset(value, caret ?? value.length);
-	const beforeFull = value.slice(0, safe);
-	const afterFull = value.slice(safe);
-	const [at = ""] = graphemes(afterFull);
-	const afterRest = at === "" ? "" : afterFull.slice(at.length);
-	const cursorPlain = showCursor ? (at !== "" ? at : "▋") : at;
-	const cursorWidth = Math.max(1, visibleWidth(cursorPlain));
-	const totalWidth =
-		visibleWidth(beforeFull) + cursorWidth + visibleWidth(showCursor ? afterRest : afterFull.slice(at.length));
-	let before = beforeFull;
-	let after = showCursor ? afterRest : afterFull.slice(at.length);
-	if (totalWidth > usable) {
-		before = tailToWidth(beforeFull, Math.max(0, usable - cursorWidth));
-		after = headToWidth(
-			showCursor ? afterRest : afterFull.slice(at.length),
-			Math.max(0, usable - visibleWidth(before) - cursorWidth),
-		);
-	}
-	const cursorCell = showCursor
-		? at !== ""
-			? paint(at, theme.bg, { bg: theme.accent })
-			: paint("▋", theme.accent)
-		: paint(at, theme.text);
-	return padLine(paint(before, theme.text) + cursorCell + paint(after, theme.text), usable);
-}
-
-function padLine(s: string, usable: number): string {
-	// The caller appends `│` immediately after this string, so the row must
-	// fill exactly `usable` cells of visible width — otherwise the right
-	// border slides leftward and the field card looks broken-narrow under a
-	// full-width top/bottom border. Pad short content; clip overflow with `…`.
-	// visibleWidth/truncateToWidth are width-correct for CJK/emoji glyphs.
-	const len = visibleWidth(s);
-	if (len === usable) return s;
-	if (len < usable) return s + " ".repeat(usable - len);
-	return truncateToWidth(s, usable, "…", true);
-}
-
-function fitLine(line: string, width: number): string {
-	return truncateToWidth(line, Math.max(0, width), "…", true);
-}
-
-function renderWorkflowHeader(
-	workflowName: string,
-	fieldCount: number,
-	focusedIdx: number,
-	theme: GraphTheme,
-	width: number,
-): string[] {
-	const current = Math.min(fieldCount, Math.max(1, focusedIdx + 1));
-	return renderCompactBandHeader({
-		label: "WORKFLOW",
-		subtitle: workflowName,
-		badges: fieldCount > 0 ? [{ text: `${current} / ${fieldCount}`, fg: theme.dim }] : [],
-		width,
-		theme,
-	});
-}
-
-function renderInputField(
-	field: WorkflowInputEntry,
-	raw: string,
-	caret: number,
-	cursorOn: boolean,
-	invalid: string | null,
-	focused: boolean,
-	theme: GraphTheme,
-	width: number,
-): string[] {
-	const boxWidth = Math.max(4, width);
-	const contentWidth = Math.max(1, boxWidth - 2);
-	const borderColor = focused ? theme.accent : theme.borderDim;
-	const rows = renderAskStyleInputBody(
-		field,
-		raw,
-		focused ? caret : raw.length,
-		cursorOn,
-		focused,
-		theme,
-		contentWidth,
-	);
-	const lines = [
-		renderFieldTop(field.name, boxWidth, borderColor, focused, theme),
-		...rows.map((row) => renderFieldRow(row, contentWidth, borderColor, theme)),
-		renderFieldBottom(boxWidth, borderColor),
-		...renderFieldMeta(field, invalid, theme, width),
-	];
-	return lines;
-}
-
-function renderAskStyleInputBody(
-	field: WorkflowInputEntry,
-	raw: string,
-	caret: number,
-	cursorOn: boolean,
-	focused: boolean,
-	theme: GraphTheme,
-	width: number,
-): string[] {
-	if (field.type === "select" && field.choices && field.choices.length > 0) {
-		const selected = Math.max(0, field.choices.indexOf(raw));
-		return field.choices.flatMap((choice, i) =>
-			renderAskChoiceRows(
-				i + 1,
-				focused || i !== selected ? choice : `✓ ${choice}`,
-				focused && i === selected,
-				theme,
-				width,
-			),
-		);
-	}
-
-	if (field.type === "boolean") {
-		const normalized = raw.trim().toLowerCase();
-		const hasValue = normalized.length > 0;
-		const on = normalized === "true" || normalized === "1";
-		return [
-			...renderAskChoiceRows(
-				1,
-				focused || !hasValue || !on ? "on" : "✓ on",
-				focused && hasValue && on,
-				theme,
-				width,
-			),
-			...renderAskChoiceRows(
-				2,
-				focused || !hasValue || on ? "off" : "✓ off",
-				focused && hasValue && !on,
-				theme,
-				width,
-			),
-		];
-	}
-
-	return renderAskInputRows(field, raw, caret, cursorOn, focused, theme, width);
-}
-
-function renderAskInputRows(
-	field: WorkflowInputEntry,
-	raw: string,
-	caret: number,
-	cursorOn: boolean,
-	focused: boolean,
-	theme: GraphTheme,
-	width: number,
-): string[] {
-	const usable = Math.max(1, width);
-
-	if (field.type !== "text") {
-		return [renderInlineText(raw, focused, cursorOn, usable, theme, field.placeholder, raw === "", caret)];
-	}
-
-	const ROWS = 3;
-	if (raw === "") {
-		return [
-			renderInlineText("", focused, cursorOn, usable, theme, field.placeholder, true),
-			...Array.from({ length: ROWS - 1 }, () => padLine("", usable)),
-		];
-	}
-
-	const layout = layoutEditableText(raw, usable);
-	const safeCaret = clampGraphemeOffset(raw, caret);
-	let cursorRow = layout.length - 1;
-	for (let i = 0; i < layout.length; i++) {
-		const line = layout[i]!;
-		const next = layout[i + 1];
-		if (safeCaret >= line.start && safeCaret < line.end) {
-			cursorRow = i;
-			break;
-		}
-		if (safeCaret === line.end) {
-			cursorRow = next?.start === safeCaret ? i + 1 : i;
-		}
-	}
-	cursorRow = Math.max(0, Math.min(cursorRow, layout.length - 1));
-	const start = Math.max(0, Math.min(cursorRow - ROWS + 1, layout.length - ROWS));
-	const rows: string[] = [];
-	for (let i = 0; i < ROWS; i++) {
-		const rowIdx = start + i;
-		const line = layout[rowIdx];
-		if (!line) {
-			rows.push(padLine("", usable));
-			continue;
-		}
-		const lineCaret = safeCaret >= line.start && safeCaret <= line.end ? safeCaret - line.start : line.text.length;
-		rows.push(
-			renderInlineText(
-				line.text,
-				focused && rowIdx === cursorRow,
-				cursorOn,
-				usable,
-				theme,
-				field.placeholder,
-				false,
-				lineCaret,
-			),
-		);
-	}
-	return rows;
-}
-
-export function renderInputsPicker(opts: InputsPickerRenderOpts): string[] {
-	const { theme, workflowName, fields, state, width, cursorOn } = opts;
-	const lines: string[] = [];
-
-	lines.push(...renderWorkflowHeader(workflowName, fields.length, state.focusedIdx, theme, width));
-	lines.push("");
-
-	for (let i = 0; i < fields.length; i += 1) {
-		const field = fields[i]!;
-		const raw = state.rawText[field.name] ?? "";
-		const invalid = state.invalidIndices.includes(i) ? invalidForField(field, raw, i) : null;
-		lines.push(...renderInputField(field, raw, state.caret, cursorOn, invalid, state.focusedIdx === i, theme, width));
-		lines.push("");
-	}
-
-	lines.push(...renderPickerSubmitControls(fields, state, theme, width));
-
-	return lines.map((line) => fitLine(line, width));
-}
-
-function renderFieldTop(
-	title: string,
-	width: number,
-	borderColor: string,
-	focused: boolean,
-	theme: GraphTheme,
-): string {
-	const label = ` ${title} `;
-	const labelText = paint(label, focused ? theme.accent : theme.textMuted, { bold: focused });
-	const fill = Math.max(0, width - visibleWidth(label) - 2);
-	return paint("╭", borderColor) + labelText + paint(`${"─".repeat(fill)}╮`, borderColor);
-}
-
-function renderFieldRow(row: string, contentWidth: number, borderColor: string, _theme: GraphTheme): string {
-	const clipped = truncateToWidth(row, contentWidth, "", true);
-	const padded = clipped + " ".repeat(Math.max(0, contentWidth - visibleWidth(clipped)));
-	return paint("│", borderColor) + padded + paint("│", borderColor);
-}
-
-function renderFieldBottom(width: number, borderColor: string): string {
-	return paint(`╰${"─".repeat(Math.max(0, width - 2))}╯`, borderColor);
-}
-
-function renderFieldMeta(
-	field: WorkflowInputEntry,
-	invalid: string | null,
-	theme: GraphTheme,
-	width: number,
-): string[] {
-	const required = field.required ? "required" : "optional";
-	const text =
-		field.description && field.description.length > 0
-			? `${field.type} · ${required} · ${field.description}`
-			: `${field.type} · ${required}`;
-	const lines = wrapPlainText(text, width).map((line) => paintRequiredMetaLine(line, field.required === true, theme));
-	if (invalid) lines.push(...wrapPlainText(invalid, width).map((line) => paint(line, theme.error)));
-	return lines;
-}
-
-function paintRequiredMetaLine(line: string, required: boolean, theme: GraphTheme): string {
-	if (!required) return paint(line, theme.textMuted);
-	return line
-		.split(/(\brequired\b)/g)
-		.map((part) => (part === "required" ? paint(part, theme.warning) : paint(part, theme.textMuted)))
-		.join("");
-}
-
-function renderPickerSubmitControls(
-	fields: readonly WorkflowInputEntry[],
-	state: InputsPickerState,
-	theme: GraphTheme,
-	width: number,
-): string[] {
-	const invalid = computeInvalid(fields, state.rawText);
-	return renderSubmitControls({
-		invalidFieldNames: invalid.map((i) => fields[i]!.name),
-		submitFocused: state.focusedIdx === fields.length,
-		theme,
-		width,
-	});
-}

package/dist/builtin/workflows/src/tui/inputs-picker-types.ts

@@ -1,161 +0,0 @@
-import type { WorkflowInputEntry } from "../extension/render-result.js";
-import type { WorkflowInputValues, WorkflowSerializableValue } from "../shared/types.js";
-import type { GraphTheme } from "./graph-theme.js";
-
-export interface InputsPickerState {
-	/** Index of the currently-focused field. */
-	focusedIdx: number;
-	/**
-	 * Raw string the user has typed/selected for each field, keyed by name.
-	 * Booleans store `"true"` / `"false"`; numbers store their text form;
-	 * selects store the chosen choice; text/string store the literal value.
-	 * `coerceValues()` converts these into typed objects at submit time.
-	 */
-	rawText: Record<string, string>;
-	/** Reserved for older form snapshots; Submit is now a single final action. */
-	submitChoiceIdx: number;
-	/**
-	 * Set of field indices that failed validation on the most recent submit
-	 * attempt. Used to dim the run hint and to highlight a field if the user
-	 * retries with required fields still empty.
-	 */
-	invalidIndices: readonly number[];
-	/** Cursor offset within the focused single-line text field. */
-	caret: number;
-}
-
-/** Discriminated action returned by the key handler. */
-export type InputsPickerAction = { kind: "noop" } | { kind: "cancel" } | { kind: "run"; values: WorkflowInputValues };
-
-export interface InputsPickerRenderOpts {
-	width: number;
-	theme: GraphTheme;
-	workflowName: string;
-	fields: readonly WorkflowInputEntry[];
-	state: InputsPickerState;
-	/** True when the blinking cursor is in its visible half-period. */
-	cursorOn: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// State construction + value coercion
-// ---------------------------------------------------------------------------
-
-/**
- * Seed `rawText` from declared defaults plus any values the user already
- * passed as key=value tokens. Enums/selects fall back to their first choice
- * (matching atomic's seeding rule), booleans default to `false`, and
- * numbers/text default to empty unless the schema declared a default.
- */
-export function createInputsPickerState(
-	fields: readonly WorkflowInputEntry[],
-	prefilled: WorkflowInputValues = {},
-): InputsPickerState {
-	const rawText: Record<string, string> = {};
-	for (const f of fields) {
-		if (prefilled[f.name] !== undefined) {
-			rawText[f.name] = String(prefilled[f.name]);
-			continue;
-		}
-		if (f.default !== undefined) {
-			rawText[f.name] = String(f.default);
-			continue;
-		}
-		if (f.type === "select" && f.choices && f.choices.length > 0) {
-			rawText[f.name] = f.choices[0]!;
-			continue;
-		}
-		if (f.type === "boolean") {
-			rawText[f.name] = "false";
-			continue;
-		}
-		rawText[f.name] = "";
-	}
-	// Focus the first invalid field if any; otherwise field 0. This keeps the
-	// cursor on the first thing the user actually needs to fill in.
-	const firstInvalid = fields.findIndex((f, i) => invalidForField(f, rawText[f.name] ?? "", i) !== null);
-	const focusedIdx = firstInvalid >= 0 ? firstInvalid : 0;
-	return {
-		focusedIdx,
-		rawText,
-		submitChoiceIdx: 0,
-		invalidIndices: [],
-		caret: (rawText[fields[focusedIdx]?.name ?? ""] ?? "").length,
-	};
-}
-
-/**
- * Coerce the rawText map into typed values matching the declared schema.
- * Mirrors the `parseWorkflowArgs` JSON-tolerant logic for text/string
- * fields (so users can paste `["a","b"]` into a text box and have it land
- * as an array), and enforces numeric / boolean parsing for typed fields.
- *
- * Throws on hard parse failure for required fields; lenient on optional.
- * The picker only calls `coerceValues` after `validate` succeeds, so the
- * thrown branch is a defensive guard, not an expected path.
- */
-export function coerceValues(fields: readonly WorkflowInputEntry[], raw: Record<string, string>): WorkflowInputValues {
-	const out: Record<string, WorkflowSerializableValue> = {};
-	for (const f of fields) {
-		const v = raw[f.name] ?? "";
-		if (v === "" && !f.required) continue; // skip empty optionals
-		switch (f.type) {
-			case "number":
-			case "integer": {
-				const n = Number(v);
-				if (Number.isFinite(n)) out[f.name] = n;
-				break;
-			}
-			case "boolean": {
-				out[f.name] = v === "true" || v === "1";
-				break;
-			}
-			case "select":
-				out[f.name] = v;
-				break;
-			default: {
-				// Try JSON for power users pasting structured data; otherwise treat
-				// as a literal string. Mirrors parseWorkflowArgs.
-				if ((v.startsWith("{") && v.endsWith("}")) || (v.startsWith("[") && v.endsWith("]"))) {
-					try {
-						out[f.name] = JSON.parse(v) as WorkflowSerializableValue;
-						break;
-					} catch {
-						// fall through
-					}
-				}
-				out[f.name] = v;
-			}
-		}
-	}
-	return out;
-}
-
-// ---------------------------------------------------------------------------
-// Validation
-// ---------------------------------------------------------------------------
-
-/**
- * Return the reason why `field` is invalid for `value`, or `null` if valid.
- * Used both to flag fields on submit and to drive the dim state of the run
- * key hint.
- */
-export function invalidForField(field: WorkflowInputEntry, value: string, _idx: number): string | null {
-	if (field.required && value.trim() === "") return "required";
-	if (field.type === "select" && field.choices && value !== "" && !field.choices.includes(value)) {
-		return "not in choices";
-	}
-	if ((field.type === "number" || field.type === "integer") && value !== "" && !Number.isFinite(Number(value))) {
-		return "must be a number";
-	}
-	return null;
-}
-
-export function computeInvalid(fields: readonly WorkflowInputEntry[], raw: Record<string, string>): number[] {
-	const out: number[] = [];
-	for (let i = 0; i < fields.length; i++) {
-		const f = fields[i]!;
-		if (invalidForField(f, raw[f.name] ?? "", i) !== null) out.push(i);
-	}
-	return out;
-}

package/dist/builtin/workflows/src/tui/inputs-picker.ts

@@ -1,20 +0,0 @@
-/**
- * Interactive argument picker for /workflow invocations.
- *
- * Public facade kept for existing imports; implementation lives in sibling
- * modules so each source file stays focused.
- */
-
-export { handleInputsPickerInput } from "./inputs-picker-input.js";
-export { renderInputsPicker } from "./inputs-picker-render.js";
-export type {
-	InputsPickerAction,
-	InputsPickerRenderOpts,
-	InputsPickerState,
-} from "./inputs-picker-types.js";
-export {
-	coerceValues,
-	computeInvalid,
-	createInputsPickerState,
-	invalidForField,
-} from "./inputs-picker-types.js";

package/dist/builtin/workflows/src/tui/keybindings-adapter.ts

@@ -1,167 +0,0 @@
-/**
- * Structural adapter for Pi's injected `KeybindingsManager` plus the
- * string-buffer helpers that the workflow form's editing actions need.
- *
- * Workflow input surfaces (the inline form editor and the fallback overlay
- * picker) receive Pi's keybindings manager as the third argument of their
- * factory. They use it to translate raw terminal byte sequences into named
- * Pi actions (`tui.editor.deleteWordBackward`, etc.) so user-configured
- * keybindings — Ctrl/Cmd+Backspace, Ctrl+W, Ctrl+U, Ctrl+K, Alt+Arrow,
- * Home/End, etc. — work consistently with the rest of the agent's TUI.
- *
- * We intentionally avoid a direct `KeybindingsManager` import from
- * `@earendil-works/pi-tui` here:
- *   - The manager is a runtime singleton owned by the host; constructing
- *     a second one in the extension graph would duplicate state and
- *     fight the host for action resolution.
- *   - The structural `{ matches(data, action): boolean }` shape is all
- *     this code needs and keeps the per-call surface tiny.
- *
- * Rendering primitives are different — `Box`, `Text`, `Spacer`,
- * `Markdown`, etc. from `@earendil-works/pi-tui` are stateless and SHOULD be
- * imported directly in extension code (per pi.dev/docs/latest/tui).
- *
- * cross-ref:
- *   - node_modules/@earendil-works/pi-tui/src/keybindings.ts → KeybindingsManager
- *   - node_modules/@earendil-works/pi-tui/src/components/editor.ts routes through
- *     the same action ids (`tui.editor.cursorWordLeft`, etc.).
- */
-
-/**
- * Minimal shape this codebase needs from Pi's `KeybindingsManager`.
- *
- * `matches(data, action)` returns true when raw terminal bytes in `data`
- * map to the named action under the user's resolved keybindings. Real
- * pi-tui `KeybindingsManager.matches` is fully covariant with this type.
- */
-export interface KeybindingsLike {
-	matches(data: string, action: string): boolean;
-	/** Optional host display lookup; structural test doubles may omit it. */
-	getKeys?(action: string): readonly string[];
-}
-
-export const APP_ACTION = {
-	toolsExpand: "app.tools.expand",
-	thinkingToggle: "app.thinking.toggle",
-} as const;
-
-export const TUI_ACTION = {
-	altScreenBottom: "tui.altScreen.bottom",
-	editorCursorUp: "tui.editor.cursorUp",
-	editorCursorDown: "tui.editor.cursorDown",
-	editorCursorLeft: "tui.editor.cursorLeft",
-	editorCursorRight: "tui.editor.cursorRight",
-	inputSubmit: "tui.input.submit",
-	selectUp: "tui.select.up",
-	selectDown: "tui.select.down",
-	selectPageUp: "tui.select.pageUp",
-	selectPageDown: "tui.select.pageDown",
-	selectConfirm: "tui.select.confirm",
-} as const;
-
-/** Runtime guard for hosts that wire the keybindings manager. */
-export function isKeybindingsLike(kb: unknown): kb is KeybindingsLike {
-	return typeof kb === "object" && kb !== null && typeof (kb as { matches?: unknown }).matches === "function";
-}
-
-/**
- * Ask Pi whether `data` maps to the named action. Returns `false` when
- * no keybindings manager is wired or the action does not match — there
- * is intentionally no parallel raw-byte fallback table. Hosts are
- * expected to provide a `KeybindingsManager` and tests pass a real or
- * structural fake one.
- */
-export function matchesAction(kb: KeybindingsLike | undefined, data: string, action: string): boolean {
-	if (!kb) return false;
-	return kb.matches(data, action);
-}
-
-// ── Word boundary helpers ────────────────────────────────────────────────
-//
-// Emacs/bash-readline semantics: a "word" is a maximal run of non-
-// whitespace characters. Word-left/word-right skip the leading
-// whitespace gap, then skip the word run. This intentionally diverges
-// from pi-tui's Unicode-aware grapheme segmenter (which requires the
-// pi-natives addon) — workflow inputs are short prompts where simple
-// whitespace-based word boundaries match user intuition and keep the
-// helper free of native-module deps so tests run on any host.
-
-function isWordBoundary(ch: string): boolean {
-	return /\s/.test(ch);
-}
-
-/**
- * Return the offset to the left of `caret` that lands on the previous
- * word boundary. Mirrors readline's `backward-word`: skip whitespace
- * (and newlines) leftward, then skip non-whitespace leftward. Clamps to
- * the start of the string.
- */
-export function wordLeft(text: string, caret: number): number {
-	let i = Math.max(0, Math.min(caret, text.length));
-	// Skip trailing whitespace (including newlines).
-	while (i > 0 && isWordBoundary(text[i - 1]!)) i -= 1;
-	// Skip word body.
-	while (i > 0 && !isWordBoundary(text[i - 1]!)) i -= 1;
-	return i;
-}
-
-/**
- * Return the offset to the right of `caret` that lands on the next
- * word boundary. Mirrors readline's `forward-word`: skip whitespace
- * rightward, then skip non-whitespace rightward. Clamps to the end of
- * the string.
- */
-export function wordRight(text: string, caret: number): number {
-	const len = text.length;
-	let i = Math.max(0, Math.min(caret, len));
-	while (i < len && isWordBoundary(text[i]!)) i += 1;
-	while (i < len && !isWordBoundary(text[i]!)) i += 1;
-	return i;
-}
-
-// ── Logical-line helpers ─────────────────────────────────────────────────
-//
-// The form caret is a single integer offset into `rawText[fieldName]`;
-// logical lines are split by `\n`. Line-start / line-end resolve to the
-// boundaries of the line containing the caret. Line-start is the offset
-// of the character AFTER the previous `\n` (or 0). Line-end is the
-// offset of the next `\n` (or `text.length`).
-
-export function lineStart(text: string, caret: number): number {
-	const c = Math.max(0, Math.min(caret, text.length));
-	return text.lastIndexOf("\n", c - 1) + 1;
-}
-
-export function lineEnd(text: string, caret: number): number {
-	const c = Math.max(0, Math.min(caret, text.length));
-	const nl = text.indexOf("\n", c);
-	return nl === -1 ? text.length : nl;
-}
-
-/**
- * Splice `[start, end)` out of `text` and return the new value plus the
- * caret position after the deletion. Both bounds are clamped to the
- * valid range; an empty or inverted range is a no-op (returns original
- * text and `caret`).
- */
-export interface DeleteRangeResult {
-	text: string;
-	caret: number;
-}
-
-export function deleteRange(text: string, start: number, end: number, caret: number): DeleteRangeResult {
-	const len = text.length;
-	const s = Math.max(0, Math.min(start, len));
-	const e = Math.max(s, Math.min(end, len));
-	if (s === e) return { text, caret };
-	const next = text.slice(0, s) + text.slice(e);
-	// The caret tracks the user's logical position. Cases:
-	//   - caret < s              → unaffected, stays in place
-	//   - s <= caret <= e        → collapses to s
-	//   - caret > e              → shifts left by the deleted run's length
-	let nextCaret: number;
-	if (caret <= s) nextCaret = caret;
-	else if (caret <= e) nextCaret = s;
-	else nextCaret = caret - (e - s);
-	return { text: next, caret: nextCaret };
-}