@openclaw/diffs 2026.9.4 → 2026.9.6

package/node_modules/@pierre/diffs/dist/editor/editPrediction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editPrediction.d.ts","names":[],"sources":["../../src/editor/editPrediction.ts"],"mappings":";;;UAGiB;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;aAA0B;aAAwB;;;WAElD,aAAa;;aAEX;;aAEA;;;UAII;;WAEN,QAAQ;;UAGF;;WAEN,gBAAgB;;WAEhB,WAAW;;UAGL;;EAEf,UACE,SAAS,oBACT,SAAS,uBACN,QAAQ;;UAGE;WACN;WACA;WACA;WACA;WACA;WACA;WACA,WAAW;;UAGZ;WACC;WACA;WACA;EACT,WAAW,iBAAiB;EAC5B,YAAY,6BAA6B;EACzC,SAAS,UAAU;EACnB,YAAY;EACZ,cAAc;EACd,aAAa,eAAe;EAC5B,OAAO;;UAGC;WACC;WACA;WACA;WACA;WACA;;iBAmTK,qBACd,kBAAkB,+BAClB,cACA,UAAU,wBACV,aAAa,+BACb,+BACA,cACC;iBAwLa,2BACd,cACA,UAAU,wBACV,sBACA,kBAAkB,+BAClB,iBAAiB,2BAChB;iBAmKa,6BACd,cACA,kBAAkB"}

package/node_modules/@pierre/diffs/dist/editor/editPrediction.js

@@ -0,0 +1,365 @@
+//#region src/editor/editPrediction.ts
+const EDITABLE_TOKENS = 350;
+const CONTEXT_TOKENS = 150;
+const MAX_EDITABLE_TOKENS = 512;
+const MAX_CONTEXT_TOKENS = 662;
+const MAX_REQUEST_BYTES = 131072;
+const MAX_CAPTURE_BYTES = 6144;
+const COALESCE_MS = 1e3;
+const COALESCE_LINES = 8;
+const DIFF_CONTEXT_LINES = 3;
+const CAPTURE_CONTEXT_OPTIONS = [11, DIFF_CONTEXT_LINES];
+const textEncoder = new TextEncoder();
+function lineStarts(text) {
+	const starts = [0];
+	for (let index = 0; index < text.length; index++) {
+		if (text.charCodeAt(index) === 13 && text.charCodeAt(index + 1) === 10) index++;
+		if (text.charCodeAt(index) === 10 || text.charCodeAt(index) === 13) starts.push(index + 1);
+	}
+	return starts;
+}
+function diffLineCount(text, starts) {
+	if (text.length === 0) return 0;
+	return starts.at(-1) === text.length ? starts.length - 1 : starts.length;
+}
+function lineEnd(text, starts, line) {
+	const next = starts[line + 1];
+	return next === void 0 ? text.length : next - (text.charCodeAt(next - 1) === 10 && text.charCodeAt(next - 2) === 13 ? 2 : 1);
+}
+function linesEqual(left, leftStarts, leftLine, right, rightStarts, rightLine) {
+	const leftStart = leftStarts[leftLine];
+	const rightStart = rightStarts[rightLine];
+	const length = lineEnd(left, leftStarts, leftLine) - leftStart;
+	if (length !== lineEnd(right, rightStarts, rightLine) - rightStart) return false;
+	for (let index = 0; index < length; index++) if (left.charCodeAt(leftStart + index) !== right.charCodeAt(rightStart + index)) return false;
+	return true;
+}
+function lineDiffBounds(oldText, oldStarts, newText, newStarts) {
+	const oldLineCount = diffLineCount(oldText, oldStarts);
+	const newLineCount = diffLineCount(newText, newStarts);
+	let prefixLines = 0;
+	while (prefixLines < oldLineCount && prefixLines < newLineCount) {
+		if (!linesEqual(oldText, oldStarts, prefixLines, newText, newStarts, prefixLines)) break;
+		prefixLines++;
+	}
+	let suffixLines = 0;
+	while (suffixLines < oldLineCount - prefixLines && suffixLines < newLineCount - prefixLines) {
+		if (!linesEqual(oldText, oldStarts, oldLineCount - 1 - suffixLines, newText, newStarts, newLineCount - 1 - suffixLines)) break;
+		suffixLines++;
+	}
+	return {
+		oldLineCount,
+		newLineCount,
+		prefixLines,
+		suffixLines
+	};
+}
+function formatEditHunk(path, oldText, newText, lineOffset = 0) {
+	if (oldText === newText) return;
+	const oldStarts = lineStarts(oldText);
+	const newStarts = lineStarts(newText);
+	const bounds = lineDiffBounds(oldText, oldStarts, newText, newStarts);
+	if (bounds.prefixLines === bounds.oldLineCount && bounds.prefixLines === bounds.newLineCount) return;
+	const oldChangedEnd = bounds.oldLineCount - bounds.suffixLines;
+	const newChangedEnd = bounds.newLineCount - bounds.suffixLines;
+	const oldChanged = oldText.slice(oldStarts[bounds.prefixLines] ?? oldText.length, oldStarts[oldChangedEnd] ?? oldText.length);
+	const newChanged = newText.slice(newStarts[bounds.prefixLines] ?? newText.length, newStarts[newChangedEnd] ?? newText.length);
+	if (textEncoder.encode(oldChanged).byteLength > MAX_CAPTURE_BYTES || textEncoder.encode(newChanged).byteLength > MAX_CAPTURE_BYTES) return;
+	const start = Math.max(0, bounds.prefixLines - DIFF_CONTEXT_LINES);
+	const oldEnd = Math.min(bounds.oldLineCount, oldChangedEnd + DIFF_CONTEXT_LINES);
+	const newEnd = Math.min(bounds.newLineCount, newChangedEnd + DIFF_CONTEXT_LINES);
+	const oldCount = oldEnd - start;
+	const newCount = newEnd - start;
+	const line = start + lineOffset;
+	const output = [
+		`--- a/${path}`,
+		`+++ b/${path}`,
+		`@@ -${oldCount === 0 ? line : line + 1},${oldCount} +${newCount === 0 ? line : line + 1},${newCount} @@`
+	];
+	for (let line = start; line < bounds.prefixLines; line++) output.push(` ${oldText.slice(oldStarts[line], lineEnd(oldText, oldStarts, line))}`);
+	for (let line = bounds.prefixLines; line < oldChangedEnd; line++) output.push(`-${oldText.slice(oldStarts[line], lineEnd(oldText, oldStarts, line))}`);
+	for (let line = bounds.prefixLines; line < newChangedEnd; line++) output.push(`+${newText.slice(newStarts[line], lineEnd(newText, newStarts, line))}`);
+	for (let line = oldChangedEnd; line < oldEnd; line++) output.push(` ${oldText.slice(oldStarts[line], lineEnd(oldText, oldStarts, line))}`);
+	const hunk = output.join("\n");
+	return textEncoder.encode(hunk).byteLength <= MAX_CAPTURE_BYTES ? {
+		hunk,
+		bounds
+	} : void 0;
+}
+function applyEditsToSlice(text, sliceStart, edits) {
+	const chunks = [];
+	let offset = 0;
+	for (const edit of edits) {
+		const start = edit.start - sliceStart;
+		const end = edit.end - sliceStart;
+		if (start < offset || end < start || end > text.length) return;
+		chunks.push(text.slice(offset, start), edit.text);
+		offset = end;
+	}
+	chunks.push(text.slice(offset));
+	return chunks.join("");
+}
+function captureEditPredictionTransaction(document, transaction) {
+	const inverseEdits = transaction.inverseEdits;
+	if (inverseEdits.length === 0) return;
+	let changedStart = inverseEdits[0].start;
+	let changedEnd = inverseEdits[0].end;
+	for (let index = 1; index < inverseEdits.length; index++) {
+		changedStart = Math.min(changedStart, inverseEdits[index].start);
+		changedEnd = Math.max(changedEnd, inverseEdits[index].end);
+	}
+	const [startPosition, endPosition] = document.positionsAt([changedStart, changedEnd]);
+	for (const contextLines of CAPTURE_CONTEXT_OPTIONS) {
+		const startLine = Math.max(0, startPosition.line - contextLines);
+		const endLine = Math.min(document.lineCount - 1, endPosition.line + contextLines);
+		const afterStart = document.offsetAt({
+			line: startLine,
+			character: 0
+		});
+		const afterEnd = endLine + 1 < document.lineCount ? document.offsetAt({
+			line: endLine + 1,
+			character: 0
+		}) : document.offsetAt({
+			line: endLine,
+			character: document.getLineLength(endLine)
+		});
+		if (afterEnd - afterStart > MAX_CAPTURE_BYTES) continue;
+		const afterText = document.getTextSlice(afterStart, afterEnd);
+		if (textEncoder.encode(afterText).byteLength > MAX_CAPTURE_BYTES) continue;
+		const beforeText = applyEditsToSlice(afterText, afterStart, inverseEdits);
+		if (beforeText === void 0 || beforeText.length > MAX_CAPTURE_BYTES || textEncoder.encode(beforeText).byteLength > MAX_CAPTURE_BYTES) continue;
+		return {
+			beforeText,
+			afterText,
+			startOffset: afterStart,
+			startLine,
+			bounds: lineDiffBounds(beforeText, lineStarts(beforeText), afterText, lineStarts(afterText))
+		};
+	}
+}
+function recordEditPrediction(history, path, document, transaction, source, at = Date.now()) {
+	const kept = history.slice(-10);
+	const fragment = captureEditPredictionTransaction(document, transaction);
+	if (fragment === void 0) {
+		const previous = kept.at(-1);
+		if (previous?.fragment !== void 0) kept[kept.length - 1] = {
+			...previous,
+			fragment: void 0
+		};
+		return kept;
+	}
+	if (fragment.beforeText === fragment.afterText) return kept;
+	const changedStartLine = fragment.startLine + fragment.bounds.prefixLines;
+	const beforeChangedEndLine = fragment.startLine + fragment.bounds.oldLineCount - fragment.bounds.suffixLines;
+	const last = kept.at(-1);
+	const gap = last !== void 0 && changedStartLine > last.end ? changedStartLine - last.end : last !== void 0 && last.start > beforeChangedEndLine ? last.start - beforeChangedEndLine : 0;
+	if (last !== void 0 && last.fragment !== void 0 && last.path === path && last.source === source && at - last.at < COALESCE_MS && gap <= COALESCE_LINES) {
+		const previous = last.fragment;
+		const beforeEnd = fragment.startOffset + fragment.beforeText.length;
+		const overlapStart = Math.max(previous.currentStart, fragment.startOffset);
+		const overlapEnd = Math.min(previous.currentEnd, beforeEnd);
+		if (overlapStart <= overlapEnd && previous.currentText.slice(overlapStart - previous.currentStart, overlapEnd - previous.currentStart) === fragment.beforeText.slice(overlapStart - fragment.startOffset, overlapEnd - fragment.startOffset)) {
+			const unionStart = Math.min(previous.currentStart, fragment.startOffset);
+			const currentText = previous.currentStart <= fragment.startOffset ? previous.currentText + fragment.beforeText.slice(Math.max(0, previous.currentEnd - fragment.startOffset)) : fragment.beforeText + previous.currentText.slice(Math.max(0, beforeEnd - previous.currentStart));
+			const prefix = currentText.slice(0, previous.currentStart - unionStart);
+			const suffix = currentText.slice(previous.currentEnd - unionStart);
+			const baseText = prefix + previous.baseText + suffix;
+			const nextText = applyEditsToSlice(currentText, unionStart, transaction.appliedEdits);
+			const startLine = previous.currentStart <= fragment.startOffset ? previous.startLine : fragment.startLine;
+			if (nextText !== void 0 && baseText.length <= MAX_CAPTURE_BYTES && nextText.length <= MAX_CAPTURE_BYTES && textEncoder.encode(baseText).byteLength <= MAX_CAPTURE_BYTES && textEncoder.encode(nextText).byteLength <= MAX_CAPTURE_BYTES) {
+				if (baseText === nextText) {
+					kept.pop();
+					return kept;
+				}
+				const formatted = formatEditHunk(path, baseText, nextText, startLine);
+				if (formatted !== void 0) {
+					kept[kept.length - 1] = {
+						path,
+						hunk: formatted.hunk,
+						start: startLine + formatted.bounds.prefixLines,
+						end: startLine + formatted.bounds.newLineCount - formatted.bounds.suffixLines,
+						at,
+						source,
+						fragment: {
+							baseText,
+							currentText: nextText,
+							currentStart: unionStart,
+							currentEnd: unionStart + nextText.length,
+							startLine
+						}
+					};
+					return kept;
+				}
+			}
+		}
+	}
+	const previous = kept.at(-1);
+	if (previous?.fragment !== void 0) kept[kept.length - 1] = {
+		...previous,
+		fragment: void 0
+	};
+	const formatted = formatEditHunk(path, fragment.beforeText, fragment.afterText, fragment.startLine);
+	if (formatted === void 0) return kept;
+	kept.push({
+		path,
+		hunk: formatted.hunk,
+		start: changedStartLine,
+		end: fragment.startLine + fragment.bounds.newLineCount - fragment.bounds.suffixLines,
+		at,
+		source,
+		fragment: {
+			baseText: fragment.beforeText,
+			currentText: fragment.afterText,
+			currentStart: fragment.startOffset,
+			currentEnd: fragment.startOffset + fragment.afterText.length,
+			startLine: fragment.startLine
+		}
+	});
+	return kept.slice(-10);
+}
+function expandLinewise(lineCount, costForLine, canExpandTo, first, last, remaining) {
+	while (remaining > 0 && (first > 0 || last < lineCount - 1)) {
+		let expanded = false;
+		if (first > 0 && canExpandTo(first - 1)) {
+			const cost = costForLine(first - 1);
+			if (cost <= remaining) {
+				first--;
+				remaining -= cost;
+				expanded = true;
+			}
+		}
+		if (last < lineCount - 1 && canExpandTo(last + 1)) {
+			const cost = costForLine(last + 1);
+			if (cost <= remaining) {
+				last++;
+				remaining -= cost;
+				expanded = true;
+			}
+		}
+		if (!expanded) break;
+	}
+	return {
+		first,
+		last
+	};
+}
+function buildEditPredictionRequest(path, document, cursorOffset, history, isLineEditable) {
+	if (document.lineCount <= 0) return;
+	const lastLine = document.lineCount - 1;
+	const documentLength = document.offsetAt({
+		line: lastLine,
+		character: document.getLineLength(lastLine)
+	});
+	let cursor = Math.max(0, Math.min(Number.isFinite(cursorOffset) ? Math.trunc(cursorOffset) : 0, documentLength));
+	const previous = document.charAt(cursor - 1).charCodeAt(0);
+	const next = document.charAt(cursor).charCodeAt(0);
+	if (cursor > 0 && cursor < documentLength && (previous === 13 && next === 10 || previous >= 55296 && previous <= 56319 && next >= 56320 && next <= 57343)) cursor--;
+	const cursorLine = document.positionAt(cursor).line;
+	const editableLines = /* @__PURE__ */ new Map();
+	const canEdit = (line) => {
+		if (line < 0 || line >= document.lineCount) return false;
+		let editable = editableLines.get(line);
+		if (editable == null) {
+			editable = isLineEditable(line);
+			editableLines.set(line, editable);
+		}
+		return editable;
+	};
+	if (!canEdit(cursorLine)) return;
+	const tokenCosts = /* @__PURE__ */ new Map();
+	const costForLine = (line) => {
+		const cached = tokenCosts.get(line);
+		if (cached !== void 0) return cached;
+		const lineLength = document.getLineLength(line);
+		if (Math.floor(lineLength / 3) > MAX_CONTEXT_TOKENS) {
+			const cost = 663;
+			tokenCosts.set(line, cost);
+			return cost;
+		}
+		const cost = Math.max(1, Math.floor(textEncoder.encode(document.getLineText(line)).byteLength / 3));
+		tokenCosts.set(line, cost);
+		return cost;
+	};
+	let editableFirst = cursorLine;
+	let editableLast = cursorLine;
+	let remaining = Math.max(0, Math.floor(EDITABLE_TOKENS * 3 / 4) - costForLine(cursorLine));
+	while (remaining > 0 && (canEdit(editableFirst - 1) || canEdit(editableLast + 1))) {
+		if (canEdit(editableLast + 1)) {
+			const cost = costForLine(editableLast + 1);
+			if (cost > remaining) break;
+			editableLast++;
+			remaining -= cost;
+		}
+		if (canEdit(editableFirst - 1) && remaining > 0) {
+			const cost = costForLine(editableFirst - 1);
+			if (cost > remaining) break;
+			editableFirst--;
+			remaining -= cost;
+		}
+	}
+	remaining += 88;
+	({first: editableFirst, last: editableLast} = expandLinewise(document.lineCount, costForLine, canEdit, editableFirst, editableLast, remaining));
+	let contextFirst = editableFirst;
+	let contextLast = editableLast;
+	({first: contextFirst, last: contextLast} = expandLinewise(document.lineCount, costForLine, () => true, contextFirst, contextLast, CONTEXT_TOKENS));
+	let editableTokens = 0;
+	for (let line = editableFirst; line <= editableLast; line++) editableTokens += costForLine(line);
+	let contextTokens = 0;
+	for (let line = contextFirst; line <= contextLast; line++) contextTokens += costForLine(line);
+	if (editableTokens > MAX_EDITABLE_TOKENS || contextTokens > MAX_CONTEXT_TOKENS) return;
+	const contextStart = document.offsetAt({
+		line: contextFirst,
+		character: 0
+	});
+	const contextEnd = document.offsetAt({
+		line: contextLast,
+		character: document.getLineLength(contextLast)
+	});
+	const excerptText = document.getTextSlice(contextStart, contextEnd);
+	const request = {
+		path,
+		version: document.version,
+		eol: document.eol,
+		excerptText,
+		excerptStartLine: contextFirst,
+		cursorOffsetInExcerpt: cursor - contextStart,
+		editableRange: {
+			start: document.offsetAt({
+				line: editableFirst,
+				character: 0
+			}) - contextStart,
+			end: document.offsetAt({
+				line: editableLast,
+				character: document.getLineLength(editableLast)
+			}) - contextStart
+		},
+		editHistory: history.slice(-10).map(({ hunk, source }) => ({
+			diff: hunk,
+			source
+		}))
+	};
+	return textEncoder.encode(JSON.stringify(request)).byteLength <= MAX_REQUEST_BYTES ? request : void 0;
+}
+function matchesEditPredictionPattern(path, pattern) {
+	if (typeof pattern !== "string") return new RegExp(pattern.source, pattern.flags).test(path);
+	pattern = pattern.replaceAll("\\", "/");
+	let source = "^";
+	for (let index = 0; index < pattern.length; index++) {
+		const character = pattern[index];
+		if (character === "*") {
+			if (pattern[index + 1] === "*") {
+				index++;
+				if (pattern[index + 1] === "/") {
+					index++;
+					source += "(?:.*/)?";
+				} else source += ".*";
+			} else source += "[^/]*";
+		} else if (character === "?") source += "[^/]";
+		else source += /[\\^$.*+?()[\]{}|]/.test(character) ? `\\${character}` : character;
+	}
+	return new RegExp(`${source}$`).test(path);
+}
+//#endregion
+export { buildEditPredictionRequest, matchesEditPredictionPattern, recordEditPrediction };
+
+//# sourceMappingURL=editPrediction.js.map

package/node_modules/@pierre/diffs/dist/editor/editPrediction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editPrediction.js","names":[],"sources":["../../src/editor/editPrediction.ts"],"sourcesContent":["import type { TextDocumentChangeTransaction } from './textDocumentChangeTransaction';\nimport type { Position, ResolvedTextEdit, TextEdit } from './types';\n\nexport interface EditPredictRequest {\n  /** Current file name/path as supplied to the File or FileDiff component. */\n  readonly path: string;\n  /** Document version. */\n  readonly version: number;\n  /** Document end-of-line sequence. */\n  readonly eol: '\\n' | '\\r\\n' | '\\r';\n  /** Bounded slice of the file around the cursor (not the whole file). */\n  readonly excerptText: string;\n  /** Zero-based document line where the excerpt starts. */\n  readonly excerptStartLine: number;\n  /** UTF-16 cursor offset relative to `excerptText`. */\n  readonly cursorOffsetInExcerpt: number;\n  /** Half-open UTF-16 range within `excerptText` that may be edited. */\n  readonly editableRange: { readonly start: number; readonly end: number };\n  /** Chronological, bounded edit history for this document. */\n  readonly editHistory: ReadonlyArray<{\n    /** Edit in unified-diff format. */\n    readonly diff: string;\n    /** Edit source. */\n    readonly source: 'user' | 'prediction';\n  }>;\n}\n\nexport interface EditPredictContext {\n  /** Aborted when the document or cursor changes. */\n  readonly signal: AbortSignal;\n}\n\nexport interface EditPredictResponse {\n  /** Non-overlapping edits using absolute document positions. */\n  readonly edits: readonly TextEdit[];\n  /** Absolute post-edit cursor position. */\n  readonly newCursor: Position;\n}\n\nexport interface EditPredictProvider {\n  /** Predicts the next edit for the given request. */\n  predict: (\n    request: EditPredictRequest,\n    context: EditPredictContext\n  ) => Promise<EditPredictResponse>;\n}\n\nexport interface EditPredictionHistoryRecord {\n  readonly path: string;\n  readonly hunk: string;\n  readonly start: number;\n  readonly end: number;\n  readonly at: number;\n  readonly source: 'user' | 'prediction';\n  readonly fragment?: EditPredictionHistoryFragment;\n}\n\ninterface EditPredictionDocument {\n  readonly version: number;\n  readonly eol: '\\n' | '\\r\\n' | '\\r';\n  readonly lineCount: number;\n  positionAt(offset: number): Position;\n  positionsAt(offsets: readonly number[]): Position[];\n  offsetAt(position: Position): number;\n  getLineText(line: number): string;\n  getLineLength(line: number): number;\n  getTextSlice(start: number, end: number): string;\n  charAt(offset: number): string;\n}\n\ninterface EditPredictionHistoryFragment {\n  readonly baseText: string;\n  readonly currentText: string;\n  readonly currentStart: number;\n  readonly currentEnd: number;\n  readonly startLine: number;\n}\n\ninterface EditPredictionTransactionFragment {\n  readonly beforeText: string;\n  readonly afterText: string;\n  readonly startOffset: number;\n  readonly startLine: number;\n  readonly bounds: LineDiffBounds;\n}\n\ninterface LineDiffBounds {\n  readonly oldLineCount: number;\n  readonly newLineCount: number;\n  readonly prefixLines: number;\n  readonly suffixLines: number;\n}\n\nconst EDITABLE_TOKENS = 350;\nconst CONTEXT_TOKENS = 150;\nconst MAX_EDITABLE_TOKENS = 512;\nconst MAX_CONTEXT_TOKENS = 662;\nconst MAX_REQUEST_BYTES = 128 * 1024;\nconst MAX_HISTORY_ENTRIES = 10;\nconst MAX_CAPTURE_BYTES = 6144;\nconst COALESCE_MS = 1000;\nconst COALESCE_LINES = 8;\nconst DIFF_CONTEXT_LINES = 3;\nconst CAPTURE_CONTEXT_LINES = DIFF_CONTEXT_LINES + COALESCE_LINES;\nconst CAPTURE_CONTEXT_OPTIONS = [\n  CAPTURE_CONTEXT_LINES,\n  DIFF_CONTEXT_LINES,\n] as const;\nconst textEncoder = new TextEncoder();\n\nfunction lineStarts(text: string): number[] {\n  const starts = [0];\n  for (let index = 0; index < text.length; index++) {\n    if (text.charCodeAt(index) === 13 && text.charCodeAt(index + 1) === 10) {\n      index++;\n    }\n    if (text.charCodeAt(index) === 10 || text.charCodeAt(index) === 13) {\n      starts.push(index + 1);\n    }\n  }\n  return starts;\n}\n\n// A line start at text.length is the boundary after a trailing terminator,\n// not an additional document line for unified-diff counts.\nfunction diffLineCount(text: string, starts: readonly number[]): number {\n  if (text.length === 0) {\n    return 0;\n  }\n  return starts.at(-1) === text.length ? starts.length - 1 : starts.length;\n}\n\nfunction lineEnd(\n  text: string,\n  starts: readonly number[],\n  line: number\n): number {\n  const next = starts[line + 1];\n  return next === undefined\n    ? text.length\n    : next -\n        (text.charCodeAt(next - 1) === 10 && text.charCodeAt(next - 2) === 13\n          ? 2\n          : 1);\n}\n\nfunction linesEqual(\n  left: string,\n  leftStarts: readonly number[],\n  leftLine: number,\n  right: string,\n  rightStarts: readonly number[],\n  rightLine: number\n): boolean {\n  const leftStart = leftStarts[leftLine];\n  const rightStart = rightStarts[rightLine];\n  const length = lineEnd(left, leftStarts, leftLine) - leftStart;\n  if (length !== lineEnd(right, rightStarts, rightLine) - rightStart) {\n    return false;\n  }\n  for (let index = 0; index < length; index++) {\n    if (\n      left.charCodeAt(leftStart + index) !==\n      right.charCodeAt(rightStart + index)\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction lineDiffBounds(\n  oldText: string,\n  oldStarts: readonly number[],\n  newText: string,\n  newStarts: readonly number[]\n): LineDiffBounds {\n  const oldLineCount = diffLineCount(oldText, oldStarts);\n  const newLineCount = diffLineCount(newText, newStarts);\n  let prefixLines = 0;\n  while (prefixLines < oldLineCount && prefixLines < newLineCount) {\n    if (\n      !linesEqual(\n        oldText,\n        oldStarts,\n        prefixLines,\n        newText,\n        newStarts,\n        prefixLines\n      )\n    ) {\n      break;\n    }\n    prefixLines++;\n  }\n\n  let suffixLines = 0;\n  while (\n    suffixLines < oldLineCount - prefixLines &&\n    suffixLines < newLineCount - prefixLines\n  ) {\n    const oldLine = oldLineCount - 1 - suffixLines;\n    const newLine = newLineCount - 1 - suffixLines;\n    if (!linesEqual(oldText, oldStarts, oldLine, newText, newStarts, newLine)) {\n      break;\n    }\n    suffixLines++;\n  }\n  return { oldLineCount, newLineCount, prefixLines, suffixLines };\n}\n\nfunction formatEditHunk(\n  path: string,\n  oldText: string,\n  newText: string,\n  lineOffset = 0\n): { readonly hunk: string; readonly bounds: LineDiffBounds } | undefined {\n  if (oldText === newText) {\n    return;\n  }\n  const oldStarts = lineStarts(oldText);\n  const newStarts = lineStarts(newText);\n  const bounds = lineDiffBounds(oldText, oldStarts, newText, newStarts);\n  if (\n    bounds.prefixLines === bounds.oldLineCount &&\n    bounds.prefixLines === bounds.newLineCount\n  ) {\n    return;\n  }\n  const oldChangedEnd = bounds.oldLineCount - bounds.suffixLines;\n  const newChangedEnd = bounds.newLineCount - bounds.suffixLines;\n  const oldChanged = oldText.slice(\n    oldStarts[bounds.prefixLines] ?? oldText.length,\n    oldStarts[oldChangedEnd] ?? oldText.length\n  );\n  const newChanged = newText.slice(\n    newStarts[bounds.prefixLines] ?? newText.length,\n    newStarts[newChangedEnd] ?? newText.length\n  );\n  if (\n    textEncoder.encode(oldChanged).byteLength > MAX_CAPTURE_BYTES ||\n    textEncoder.encode(newChanged).byteLength > MAX_CAPTURE_BYTES\n  ) {\n    return;\n  }\n\n  const start = Math.max(0, bounds.prefixLines - DIFF_CONTEXT_LINES);\n  const oldEnd = Math.min(\n    bounds.oldLineCount,\n    oldChangedEnd + DIFF_CONTEXT_LINES\n  );\n  const newEnd = Math.min(\n    bounds.newLineCount,\n    newChangedEnd + DIFF_CONTEXT_LINES\n  );\n  const oldCount = oldEnd - start;\n  const newCount = newEnd - start;\n  const line = start + lineOffset;\n  const output = [\n    `--- a/${path}`,\n    `+++ b/${path}`,\n    `@@ -${oldCount === 0 ? line : line + 1},${oldCount} +${\n      newCount === 0 ? line : line + 1\n    },${newCount} @@`,\n  ];\n  for (let line = start; line < bounds.prefixLines; line++) {\n    output.push(\n      ` ${oldText.slice(oldStarts[line], lineEnd(oldText, oldStarts, line))}`\n    );\n  }\n  for (let line = bounds.prefixLines; line < oldChangedEnd; line++) {\n    output.push(\n      `-${oldText.slice(oldStarts[line], lineEnd(oldText, oldStarts, line))}`\n    );\n  }\n  for (let line = bounds.prefixLines; line < newChangedEnd; line++) {\n    output.push(\n      `+${newText.slice(newStarts[line], lineEnd(newText, newStarts, line))}`\n    );\n  }\n  for (let line = oldChangedEnd; line < oldEnd; line++) {\n    output.push(\n      ` ${oldText.slice(oldStarts[line], lineEnd(oldText, oldStarts, line))}`\n    );\n  }\n  const hunk = output.join('\\n');\n  return textEncoder.encode(hunk).byteLength <= MAX_CAPTURE_BYTES\n    ? { hunk, bounds }\n    : undefined;\n}\n\n// Applies offset edits to a bounded document slice without materializing the\n// surrounding file. Returns undefined if the slice does not contain the edits.\nfunction applyEditsToSlice(\n  text: string,\n  sliceStart: number,\n  edits: readonly ResolvedTextEdit[]\n): string | undefined {\n  const chunks: string[] = [];\n  let offset = 0;\n  for (const edit of edits) {\n    const start = edit.start - sliceStart;\n    const end = edit.end - sliceStart;\n    if (start < offset || end < start || end > text.length) {\n      return;\n    }\n    chunks.push(text.slice(offset, start), edit.text);\n    offset = end;\n  }\n  chunks.push(text.slice(offset));\n  return chunks.join('');\n}\n\n// Captures a small post-edit window and reconstructs its pre-edit contents\n// from the inverse edits already stored by the undo transaction.\nfunction captureEditPredictionTransaction(\n  document: EditPredictionDocument,\n  transaction: TextDocumentChangeTransaction\n): EditPredictionTransactionFragment | undefined {\n  const inverseEdits = transaction.inverseEdits;\n  if (inverseEdits.length === 0) {\n    return;\n  }\n  let changedStart = inverseEdits[0].start;\n  let changedEnd = inverseEdits[0].end;\n  for (let index = 1; index < inverseEdits.length; index++) {\n    changedStart = Math.min(changedStart, inverseEdits[index].start);\n    changedEnd = Math.max(changedEnd, inverseEdits[index].end);\n  }\n  const [startPosition, endPosition] = document.positionsAt([\n    changedStart,\n    changedEnd,\n  ]);\n  for (const contextLines of CAPTURE_CONTEXT_OPTIONS) {\n    const startLine = Math.max(0, startPosition.line - contextLines);\n    const endLine = Math.min(\n      document.lineCount - 1,\n      endPosition.line + contextLines\n    );\n    const afterStart = document.offsetAt({\n      line: startLine,\n      character: 0,\n    });\n    const afterEnd =\n      endLine + 1 < document.lineCount\n        ? document.offsetAt({ line: endLine + 1, character: 0 })\n        : document.offsetAt({\n            line: endLine,\n            character: document.getLineLength(endLine),\n          });\n    if (afterEnd - afterStart > MAX_CAPTURE_BYTES) {\n      continue;\n    }\n    const afterText = document.getTextSlice(afterStart, afterEnd);\n    if (textEncoder.encode(afterText).byteLength > MAX_CAPTURE_BYTES) {\n      continue;\n    }\n    const beforeText = applyEditsToSlice(afterText, afterStart, inverseEdits);\n    if (\n      beforeText === undefined ||\n      beforeText.length > MAX_CAPTURE_BYTES ||\n      textEncoder.encode(beforeText).byteLength > MAX_CAPTURE_BYTES\n    ) {\n      continue;\n    }\n    const bounds = lineDiffBounds(\n      beforeText,\n      lineStarts(beforeText),\n      afterText,\n      lineStarts(afterText)\n    );\n    return {\n      beforeText,\n      afterText,\n      startOffset: afterStart,\n      startLine,\n      bounds,\n    };\n  }\n  return undefined;\n}\n\nexport function recordEditPrediction(\n  history: readonly EditPredictionHistoryRecord[],\n  path: string,\n  document: EditPredictionDocument,\n  transaction: TextDocumentChangeTransaction,\n  source: 'user' | 'prediction',\n  at: number = Date.now()\n): EditPredictionHistoryRecord[] {\n  const kept = history.slice(-MAX_HISTORY_ENTRIES);\n  const fragment = captureEditPredictionTransaction(document, transaction);\n  if (fragment === undefined) {\n    const previous = kept.at(-1);\n    if (previous?.fragment !== undefined) {\n      kept[kept.length - 1] = { ...previous, fragment: undefined };\n    }\n    return kept;\n  }\n  if (fragment.beforeText === fragment.afterText) {\n    return kept;\n  }\n  const changedStartLine = fragment.startLine + fragment.bounds.prefixLines;\n  const beforeChangedEndLine =\n    fragment.startLine +\n    fragment.bounds.oldLineCount -\n    fragment.bounds.suffixLines;\n  const last = kept.at(-1);\n  const gap =\n    last !== undefined && changedStartLine > last.end\n      ? changedStartLine - last.end\n      : last !== undefined && last.start > beforeChangedEndLine\n        ? last.start - beforeChangedEndLine\n        : 0;\n  const canMerge =\n    last !== undefined &&\n    last.fragment !== undefined &&\n    last.path === path &&\n    last.source === source &&\n    at - last.at < COALESCE_MS &&\n    gap <= COALESCE_LINES;\n\n  if (canMerge) {\n    const previous = last.fragment;\n    const beforeEnd = fragment.startOffset + fragment.beforeText.length;\n    const overlapStart = Math.max(previous.currentStart, fragment.startOffset);\n    const overlapEnd = Math.min(previous.currentEnd, beforeEnd);\n    if (\n      overlapStart <= overlapEnd &&\n      previous.currentText.slice(\n        overlapStart - previous.currentStart,\n        overlapEnd - previous.currentStart\n      ) ===\n        fragment.beforeText.slice(\n          overlapStart - fragment.startOffset,\n          overlapEnd - fragment.startOffset\n        )\n    ) {\n      const unionStart = Math.min(previous.currentStart, fragment.startOffset);\n      const currentText =\n        previous.currentStart <= fragment.startOffset\n          ? previous.currentText +\n            fragment.beforeText.slice(\n              Math.max(0, previous.currentEnd - fragment.startOffset)\n            )\n          : fragment.beforeText +\n            previous.currentText.slice(\n              Math.max(0, beforeEnd - previous.currentStart)\n            );\n      const prefix = currentText.slice(0, previous.currentStart - unionStart);\n      const suffix = currentText.slice(previous.currentEnd - unionStart);\n      const baseText = prefix + previous.baseText + suffix;\n      const nextText = applyEditsToSlice(\n        currentText,\n        unionStart,\n        transaction.appliedEdits\n      );\n      const startLine =\n        previous.currentStart <= fragment.startOffset\n          ? previous.startLine\n          : fragment.startLine;\n      if (\n        nextText !== undefined &&\n        baseText.length <= MAX_CAPTURE_BYTES &&\n        nextText.length <= MAX_CAPTURE_BYTES &&\n        textEncoder.encode(baseText).byteLength <= MAX_CAPTURE_BYTES &&\n        textEncoder.encode(nextText).byteLength <= MAX_CAPTURE_BYTES\n      ) {\n        if (baseText === nextText) {\n          kept.pop();\n          return kept;\n        }\n        const formatted = formatEditHunk(path, baseText, nextText, startLine);\n        if (formatted !== undefined) {\n          kept[kept.length - 1] = {\n            path,\n            hunk: formatted.hunk,\n            start: startLine + formatted.bounds.prefixLines,\n            end:\n              startLine +\n              formatted.bounds.newLineCount -\n              formatted.bounds.suffixLines,\n            at,\n            source,\n            fragment: {\n              baseText,\n              currentText: nextText,\n              currentStart: unionStart,\n              currentEnd: unionStart + nextText.length,\n              startLine,\n            },\n          };\n          return kept;\n        }\n      }\n    }\n  }\n  const previous = kept.at(-1);\n  if (previous?.fragment !== undefined) {\n    kept[kept.length - 1] = { ...previous, fragment: undefined };\n  }\n  const formatted = formatEditHunk(\n    path,\n    fragment.beforeText,\n    fragment.afterText,\n    fragment.startLine\n  );\n  if (formatted === undefined) {\n    return kept;\n  }\n  kept.push({\n    path,\n    hunk: formatted.hunk,\n    start: changedStartLine,\n    end:\n      fragment.startLine +\n      fragment.bounds.newLineCount -\n      fragment.bounds.suffixLines,\n    at,\n    source,\n    fragment: {\n      baseText: fragment.beforeText,\n      currentText: fragment.afterText,\n      currentStart: fragment.startOffset,\n      currentEnd: fragment.startOffset + fragment.afterText.length,\n      startLine: fragment.startLine,\n    },\n  });\n  return kept.slice(-MAX_HISTORY_ENTRIES);\n}\n\n// Grows [first, last] one line at a time in both directions while the token\n// budget allows and `canExpandTo` accepts the next line on that side.\nfunction expandLinewise(\n  lineCount: number,\n  costForLine: (line: number) => number,\n  canExpandTo: (line: number) => boolean,\n  first: number,\n  last: number,\n  remaining: number\n): { first: number; last: number } {\n  while (remaining > 0 && (first > 0 || last < lineCount - 1)) {\n    let expanded = false;\n    if (first > 0 && canExpandTo(first - 1)) {\n      const cost = costForLine(first - 1);\n      if (cost <= remaining) {\n        first--;\n        remaining -= cost;\n        expanded = true;\n      }\n    }\n    if (last < lineCount - 1 && canExpandTo(last + 1)) {\n      const cost = costForLine(last + 1);\n      if (cost <= remaining) {\n        last++;\n        remaining -= cost;\n        expanded = true;\n      }\n    }\n    if (!expanded) {\n      break;\n    }\n  }\n  return { first, last };\n}\n\n// Builds the request sent to the prediction provider. It carries a bounded\n// excerpt of the document around the cursor and marks the part of it the\n// provider may edit. The editable part grows outward from the cursor line and\n// stops at the first line `isLineEditable` rejects, so the provider never sees\n// an editable line the editor could not show a preview for. The rest of the\n// excerpt is read-only context and is not filtered. Returns undefined when the\n// cursor line itself is rejected.\nexport function buildEditPredictionRequest(\n  path: string,\n  document: EditPredictionDocument,\n  cursorOffset: number,\n  history: readonly EditPredictionHistoryRecord[],\n  isLineEditable: (line: number) => boolean\n): EditPredictRequest | undefined {\n  if (document.lineCount <= 0) {\n    return;\n  }\n  const lastLine = document.lineCount - 1;\n  const documentLength = document.offsetAt({\n    line: lastLine,\n    character: document.getLineLength(lastLine),\n  });\n  const normalizedCursor = Number.isFinite(cursorOffset)\n    ? Math.trunc(cursorOffset)\n    : 0;\n  let cursor = Math.max(0, Math.min(normalizedCursor, documentLength));\n  const previous = document.charAt(cursor - 1).charCodeAt(0);\n  const next = document.charAt(cursor).charCodeAt(0);\n  if (\n    cursor > 0 &&\n    cursor < documentLength &&\n    ((previous === 13 && next === 10) ||\n      (previous >= 0xd800 &&\n        previous <= 0xdbff &&\n        next >= 0xdc00 &&\n        next <= 0xdfff))\n  ) {\n    cursor--;\n  }\n  const cursorLine = document.positionAt(cursor).line;\n  // Cache whether each line may be edited. `isLineEditable` can be costly (a\n  // diff has to walk its hunks to answer), and the loops below ask about the\n  // same boundary lines over and over.\n  const editableLines = new Map<number, boolean>();\n  const canEdit = (line: number): boolean => {\n    if (line < 0 || line >= document.lineCount) {\n      return false;\n    }\n    let editable = editableLines.get(line);\n    if (editable == null) {\n      editable = isLineEditable(line);\n      editableLines.set(line, editable);\n    }\n    return editable;\n  };\n  if (!canEdit(cursorLine)) {\n    return;\n  }\n  const tokenCosts = new Map<number, number>();\n  const costForLine = (line: number): number => {\n    const cached = tokenCosts.get(line);\n    if (cached !== undefined) {\n      return cached;\n    }\n    const lineLength = document.getLineLength(line);\n    if (Math.floor(lineLength / 3) > MAX_CONTEXT_TOKENS) {\n      const cost = MAX_CONTEXT_TOKENS + 1;\n      tokenCosts.set(line, cost);\n      return cost;\n    }\n    const cost = Math.max(\n      1,\n      Math.floor(textEncoder.encode(document.getLineText(line)).byteLength / 3)\n    );\n    tokenCosts.set(line, cost);\n    return cost;\n  };\n\n  let editableFirst = cursorLine;\n  let editableLast = cursorLine;\n  const initialBudget = Math.floor((EDITABLE_TOKENS * 3) / 4);\n  let remaining = Math.max(0, initialBudget - costForLine(cursorLine));\n  while (\n    remaining > 0 &&\n    (canEdit(editableFirst - 1) || canEdit(editableLast + 1))\n  ) {\n    if (canEdit(editableLast + 1)) {\n      const cost = costForLine(editableLast + 1);\n      if (cost > remaining) {\n        break;\n      }\n      editableLast++;\n      remaining -= cost;\n    }\n    if (canEdit(editableFirst - 1) && remaining > 0) {\n      const cost = costForLine(editableFirst - 1);\n      if (cost > remaining) {\n        break;\n      }\n      editableFirst--;\n      remaining -= cost;\n    }\n  }\n  remaining += EDITABLE_TOKENS - initialBudget;\n  ({ first: editableFirst, last: editableLast } = expandLinewise(\n    document.lineCount,\n    costForLine,\n    canEdit,\n    editableFirst,\n    editableLast,\n    remaining\n  ));\n\n  let contextFirst = editableFirst;\n  let contextLast = editableLast;\n  ({ first: contextFirst, last: contextLast } = expandLinewise(\n    document.lineCount,\n    costForLine,\n    () => true,\n    contextFirst,\n    contextLast,\n    CONTEXT_TOKENS\n  ));\n  let editableTokens = 0;\n  for (let line = editableFirst; line <= editableLast; line++) {\n    editableTokens += costForLine(line);\n  }\n  let contextTokens = 0;\n  for (let line = contextFirst; line <= contextLast; line++) {\n    contextTokens += costForLine(line);\n  }\n  if (\n    editableTokens > MAX_EDITABLE_TOKENS ||\n    contextTokens > MAX_CONTEXT_TOKENS\n  ) {\n    return;\n  }\n\n  const contextStart = document.offsetAt({\n    line: contextFirst,\n    character: 0,\n  });\n  const contextEnd = document.offsetAt({\n    line: contextLast,\n    character: document.getLineLength(contextLast),\n  });\n  const excerptText = document.getTextSlice(contextStart, contextEnd);\n  const request: EditPredictRequest = {\n    path,\n    version: document.version,\n    eol: document.eol,\n    excerptText,\n    excerptStartLine: contextFirst,\n    cursorOffsetInExcerpt: cursor - contextStart,\n    editableRange: {\n      start:\n        document.offsetAt({ line: editableFirst, character: 0 }) - contextStart,\n      end:\n        document.offsetAt({\n          line: editableLast,\n          character: document.getLineLength(editableLast),\n        }) - contextStart,\n    },\n    editHistory: history\n      .slice(-MAX_HISTORY_ENTRIES)\n      .map(({ hunk, source }) => ({\n        diff: hunk,\n        source,\n      })),\n  };\n  return textEncoder.encode(JSON.stringify(request)).byteLength <=\n    MAX_REQUEST_BYTES\n    ? request\n    : undefined;\n}\n\nexport function matchesEditPredictionPattern(\n  path: string,\n  pattern: string | RegExp\n): boolean {\n  if (typeof pattern !== 'string') {\n    return new RegExp(pattern.source, pattern.flags).test(path);\n  }\n\n  pattern = pattern.replaceAll('\\\\', '/');\n  let source = '^';\n  for (let index = 0; index < pattern.length; index++) {\n    const character = pattern[index];\n    if (character === '*') {\n      if (pattern[index + 1] === '*') {\n        index++;\n        if (pattern[index + 1] === '/') {\n          index++;\n          source += '(?:.*/)?';\n        } else {\n          source += '.*';\n        }\n      } else {\n        source += '[^/]*';\n      }\n    } else if (character === '?') {\n      source += '[^/]';\n    } else {\n      source += /[\\\\^$.*+?()[\\]{}|]/.test(character)\n        ? `\\\\${character}`\n        : character;\n    }\n  }\n  return new RegExp(`${source}$`).test(path);\n}\n"],"mappings":"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"}

package/node_modules/@pierre/diffs/dist/editor/editStack.d.ts

@@ -1,76 +1,54 @@
-import { DiffLineAnnotation, EditorSelection, ResolvedTextEdit } from "../types.js";
+import { EditHistoryEntry, EditHistoryState, EditorLineAnnotation, EditorSelection, EditorType, ResolvedTextEdit } from "./types.js";
 import { TextDocument } from "./textDocument.js";
-
 //#region src/editor/editStack.d.ts
-type EditStackCoalescingMode = 1 | 2 | 3;
-/** An entry in the edit stack. */
-interface EditStackEntry<LAnnotation> {
-  /** Forward offset edits from the entry's base text to its final text. */
-  forwardEdits: ResolvedTextEdit[];
-  /** Inverse offset edits from the entry's final text back to its base text. */
-  inverseEdits: ResolvedTextEdit[];
-  /** Document version before the entry is applied. */
-  versionBefore: number;
-  /** Document version after the entry is applied. */
-  versionAfter: number;
-  /** Selection before the transaction. */
-  selectionsBefore?: EditorSelection[];
-  /** Selection after the transaction. */
-  selectionsAfter?: EditorSelection[];
-  /** Line annotations before the transaction. */
-  lineAnnotationsBefore?: DiffLineAnnotation<LAnnotation>[];
-  /** Line annotations after the transaction. */
-  lineAnnotationsAfter?: DiffLineAnnotation<LAnnotation>[];
-  /** Input mode inferred from the edit or retained by a coalesced run. */
-  coalescingMode?: EditStackCoalescingMode;
-  /**
-   * When `true`, this entry is its own undo step and never merges with the
-   * entry before or after it. Set for paste and cut, which otherwise look like
-   * typing and would merge into the previous keystroke.
-   */
-  undoBoundary?: boolean;
-}
+type EditStackEntry<EType extends EditorType, LAnnotation = unknown> = EditHistoryEntry<EType, LAnnotation>;
 /** Options for the edit stack. */
 interface EditStackOptions {
   /** The maximum number of entries to keep in the undo stack. */
   maxEntries?: number;
 }
 /** A stack of edit entries. */
-declare class EditStack<LAnnotation> {
+declare class EditStack<EType extends EditorType, LAnnotation = unknown> {
   #private;
   constructor(options?: EditStackOptions);
   get canUndo(): boolean;
   get canRedo(): boolean;
+  /** Return an independent, developer-editable history snapshot. */
+  getState(): EditHistoryState<EType, LAnnotation>;
+  /** Return a live view over this stack without copying its entries. */
+  getLiveState(): EditHistoryState<EType, LAnnotation>;
+  /** Transfer developer-owned history into an edit stack. */
+  static fromState<EType extends EditorType, LAnnotation>(state: EditHistoryState<EType, LAnnotation>): EditStack<EType, LAnnotation>;
   /** Clears both the undo and redo stacks. */
   clear(): void;
   /** Clears the redo stack. */
   clearRedo(): void;
   /** Pushes a new entry onto the undo stack. */
-  push(entry: EditStackEntry<LAnnotation>): void;
+  push(entry: EditStackEntry<EType, LAnnotation>): void;
   /** Sets the selections after the last undo entry. */
   setLastUndoSelectionsAfter(selections: EditorSelection[]): void;
   /** Sets the line annotations after the last undo entry. */
-  setLastUndoLineAnnotations(lineAnnotationsBefore: DiffLineAnnotation<LAnnotation>[], lineAnnotationsAfter: DiffLineAnnotation<LAnnotation>[]): void;
+  setLastUndoLineAnnotations(lineAnnotationsBefore: EditorLineAnnotation<EType, LAnnotation>[], lineAnnotationsAfter: EditorLineAnnotation<EType, LAnnotation>[]): void;
   /** Returns the last undo entry, or `undefined` if empty. */
-  peekUndo(): EditStackEntry<LAnnotation> | undefined;
+  peekUndo(): EditStackEntry<EType, LAnnotation> | undefined;
   /** Returns the last undo entry only while its coalescing group is open. */
-  peekUndoForCoalescing(): EditStackEntry<LAnnotation> | undefined;
+  peekUndoForCoalescing(): EditStackEntry<EType, LAnnotation> | undefined;
   /** Replaces the last undo entry with the given entry. */
-  replaceLastUndo(entry: EditStackEntry<LAnnotation>): void;
+  replaceLastUndo(entry: EditStackEntry<EType, LAnnotation>): void;
   /** Moves the latest undo entry to the redo stack and returns it, or `undefined` if empty. */
-  popUndoToRedo(): EditStackEntry<LAnnotation> | void;
+  popUndoToRedo(): EditStackEntry<EType, LAnnotation> | void;
   /** Moves the latest redo entry back to the undo stack and returns it, or `undefined` if empty. */
-  popRedoToUndo(): EditStackEntry<LAnnotation> | void;
+  popRedoToUndo(): EditStackEntry<EType, LAnnotation> | void;
 }
-declare function createEditStackEntry<LAnnotation>(textDocument: TextDocument<LAnnotation>, resolvedEdits: ResolvedTextEdit[], versionBefore: number, versionAfter: number, selectionsBefore?: EditorSelection[], selectionsAfter?: EditorSelection[], lineAnnotationsBefore?: DiffLineAnnotation<LAnnotation>[], lineAnnotationsAfter?: DiffLineAnnotation<LAnnotation>[]): EditStackEntry<LAnnotation>;
+declare function createEditStackEntry<EType extends EditorType, LAnnotation>(textDocument: TextDocument<EType, LAnnotation>, resolvedEdits: ResolvedTextEdit[], versionBefore: number, versionAfter: number, selectionsBefore?: EditorSelection[], selectionsAfter?: EditorSelection[], lineAnnotationsBefore?: EditorLineAnnotation<EType, LAnnotation>[], lineAnnotationsAfter?: EditorLineAnnotation<EType, LAnnotation>[]): EditStackEntry<EType, LAnnotation>;
 /** Determines if the change matches following modes:
  * - 'insert': simple typing
  * - 'backspace': backward delete
  * - 'delete': forward delete
  */
-declare function shouldCoalesceEditStackEntry<LAnnotation>(previousEntry: EditStackEntry<LAnnotation> | undefined, nextEntry: EditStackEntry<LAnnotation>): boolean;
+declare function shouldCoalesceEditStackEntry<EType extends EditorType, LAnnotation>(previousEntry: EditStackEntry<EType, LAnnotation> | undefined, nextEntry: EditStackEntry<EType, LAnnotation>): boolean;
 /** Coalesce edit stack entries for simple typing and single-character deletes. */
-declare function coalesceEditStackEntries<LAnnotation>(previousEntry: EditStackEntry<LAnnotation>, nextEntry: EditStackEntry<LAnnotation>): EditStackEntry<LAnnotation>;
+declare function coalesceEditStackEntries<EType extends EditorType, LAnnotation>(previousEntry: EditStackEntry<EType, LAnnotation>, nextEntry: EditStackEntry<EType, LAnnotation>): EditStackEntry<EType, LAnnotation>;
 //#endregion
 export { EditStack, EditStackEntry, EditStackOptions, coalesceEditStackEntries, createEditStackEntry, shouldCoalesceEditStackEntry };
 //# sourceMappingURL=editStack.d.ts.map

package/node_modules/@pierre/diffs/dist/editor/editStack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editStack.d.ts","names":[],"sources":["../../src/editor/editStack.ts"],"mappings":";;;;KAaK,uBAAA;;UAGY,cAAA;EAHW;EAK1B,YAAA,EAAc,gBAAA;EALY;EAO1B,YAAA,EAAc,gBAAA;EAJC;EAMf,aAAA;EAN6B;EAQ7B,YAAA;EAJc;EAMd,gBAAA,GAAmB,eAAA;EAED;EAAlB,eAAA,GAAkB,eAAA;EAEM;EAAxB,qBAAA,GAAwB,kBAAA,CAAmB,WAAA;EAEpB;EAAvB,oBAAA,GAAuB,kBAAA,CAAmB,WAAA;EAEF;EAAxC,cAAA,GAAiB,uBAAA;EAlBa;;;;;EAwB9B,YAAA;AAAA;;UAIe,gBAAA;EAhBf;EAkBA,UAAU;AAAA;;cAIC,SAAA;EAAA;EAMX,WAAA,CAAY,OAAA,GAAU,gBAAA;EAAA,IAOlB,OAAA;EAAA,IAIA,OAAA;EAjCa;EAsCjB,KAAA;EAhCY;EAuCZ,SAAA;EAnCe;EAwCf,IAAA,CAAK,KAAA,EAAO,cAAA,CAAe,WAAA;;EAU3B,0BAAA,CAA2B,UAAA,EAAY,eAAA;EAhD7B;EA0DV,0BAAA,CACE,qBAAA,EAAuB,kBAAA,CAAmB,WAAA,KAC1C,oBAAA,EAAsB,kBAAA,CAAmB,WAAA;EAxDvB;EAkEpB,QAAA,IAAY,cAAA,CAAe,WAAA;EA5DL;EAiEtB,qBAAA,IAAyB,cAAA,CAAe,WAAA;EArC5B;EA0CZ,eAAA,CAAgB,KAAA,EAAO,cAAA,CAAe,WAAA;EArBM;EAgC5C,aAAA,IAAiB,cAAA,CAAe,WAAA;EA/BW;EAyC3C,aAAA,IAAiB,cAAA,CAAe,WAAA;AAAA;AAAA,iBAUlB,oBAAA,cACd,YAAA,EAAc,YAAA,CAAa,WAAA,GAC3B,aAAA,EAAe,gBAAA,IACf,aAAA,UACA,YAAA,UACA,gBAAA,GAAmB,eAAA,IACnB,eAAA,GAAkB,eAAA,IAClB,qBAAA,GAAwB,kBAAA,CAAmB,WAAA,KAC3C,oBAAA,GAAuB,kBAAA,CAAmB,WAAA,MACzC,cAAA,CAAe,WAAA;;;;;;iBAmEF,4BAAA,cACd,aAAA,EAAe,cAAA,CAAe,WAAA,eAC9B,SAAA,EAAW,cAAA,CAAe,WAAA;;iBA8FZ,wBAAA,cACd,aAAA,EAAe,cAAA,CAAe,WAAA,GAC9B,SAAA,EAAW,cAAA,CAAe,WAAA,IACzB,cAAA,CAAe,WAAA"}
+{"version":3,"file":"editStack.d.ts","names":[],"sources":["../../src/editor/editStack.ts"],"mappings":";;;KAkBY,eACV,cAAc,YACd,yBACE,iBAAiB,OAAO;;UAIX;;EAEf;;;cAIW,UAAU,cAAc,YAAY;;EAM/C,YAAY,UAAU;MAOlB;MAIA;;EAKJ,YAAY,iBAAiB,OAAO;;EAUpC,gBAAgB,iBAAiB,OAAO;;SAyBjC,UAAU,cAAc,YAAY,aACzC,OAAO,iBAAiB,OAAO,eAC9B,UAAU,OAAO;;EAWpB;;EAOA;;EAKA,KAAK,OAAO,eAAe,OAAO;;EAUlC,2BAA2B,YAAY;;EAUvC,2BACE,uBAAuB,qBAAqB,OAAO,gBACnD,sBAAsB,qBAAqB,OAAO;;EAUpD,YAAY,eAAe,OAAO;;EAKlC,yBAAyB,eAAe,OAAO;;EAK/C,gBAAgB,OAAO,eAAe,OAAO;;EAW7C,iBAAiB,eAAe,OAAO;;EAUvC,iBAAiB,eAAe,OAAO;;iBA8CzB,qBAAqB,cAAc,YAAY,aAC7D,cAAc,aAAa,OAAO,cAClC,eAAe,oBACf,uBACA,sBACA,mBAAmB,mBACnB,kBAAkB,mBAClB,wBAAwB,qBAAqB,OAAO,gBACpD,uBAAuB,qBAAqB,OAAO,iBAClD,eAAe,OAAO;;;;;;iBAmET,6BACd,cAAc,YACd,aAEA,eAAe,eAAe,OAAO,0BACrC,WAAW,eAAe,OAAO;;iBA8FnB,yBAAyB,cAAc,YAAY,aACjE,eAAe,eAAe,OAAO,cACrC,WAAW,eAAe,OAAO,eAChC,eAAe,OAAO"}

package/node_modules/@pierre/diffs/dist/editor/editStack.js

@@ -1,11 +1,11 @@
 //#region src/editor/editStack.ts
 /** Largest number of undo or redo entries kept; oldest entries drop first once exceeded. */
 const DEFAULT_EDIT_STACK_MAX_ENTRIES = 100;
-const COALESCING_MODE_INSERT = 1;
-const COALESCING_MODE_BACKSPACE = 2;
-const COALESCING_MODE_DELETE = 3;
+const COALESCING_MODE_INSERT = "insert";
+const COALESCING_MODE_BACKSPACE = "backspace";
+const COALESCING_MODE_DELETE = "delete";
 /** A stack of edit entries. */
-var EditStack = class {
+var EditStack = class EditStack {
 	#undoStack = [];
 	#redoStack = [];
 	#maxEntries;
@@ -19,6 +19,44 @@ var EditStack = class {
 	get canRedo() {
 		return this.#redoStack.length > 0;
 	}
+	/** Return an independent, developer-editable history snapshot. */
+	getState() {
+		return {
+			undoStack: this.#undoStack.map(cloneEditStackEntryForState),
+			redoStack: this.#redoStack.map(cloneEditStackEntryForState),
+			maxEntries: this.#maxEntries,
+			canCoalesce: this.#canCoalesce
+		};
+	}
+	/** Return a live view over this stack without copying its entries. */
+	getLiveState() {
+		return Object.defineProperties({}, {
+			undoStack: {
+				enumerable: true,
+				get: () => this.#undoStack
+			},
+			redoStack: {
+				enumerable: true,
+				get: () => this.#redoStack
+			},
+			maxEntries: {
+				enumerable: true,
+				get: () => this.#maxEntries
+			},
+			canCoalesce: {
+				enumerable: true,
+				get: () => this.#canCoalesce
+			}
+		});
+	}
+	/** Transfer developer-owned history into an edit stack. */
+	static fromState(state) {
+		const stack = new EditStack({ maxEntries: state.maxEntries });
+		stack.#undoStack = state.undoStack;
+		stack.#redoStack = state.redoStack;
+		stack.#canCoalesce = state.canCoalesce;
+		return stack;
+	}
 	/** Clears both the undo and redo stacks. */
 	clear() {
 		this.#undoStack.length = 0;
@@ -86,6 +124,31 @@ var EditStack = class {
 		}
 	}
 };
+function cloneEditStackEntry(entry) {
+	return {
+		...entry,
+		forwardEdits: entry.forwardEdits.map((edit) => ({ ...edit })),
+		inverseEdits: entry.inverseEdits.map((edit) => ({ ...edit })),
+		selectionsBefore: entry.selectionsBefore?.map(cloneSelection),
+		selectionsAfter: entry.selectionsAfter?.map(cloneSelection),
+		lineAnnotationsBefore: entry.lineAnnotationsBefore?.slice(),
+		lineAnnotationsAfter: entry.lineAnnotationsAfter?.slice()
+	};
+}
+function cloneEditStackEntryForState(entry) {
+	return {
+		...cloneEditStackEntry(entry),
+		lineAnnotationsBefore: entry.lineAnnotationsBefore?.map((annotation) => ({ ...annotation })),
+		lineAnnotationsAfter: entry.lineAnnotationsAfter?.map((annotation) => ({ ...annotation }))
+	};
+}
+function cloneSelection(selection) {
+	return {
+		...selection,
+		start: { ...selection.start },
+		end: { ...selection.end }
+	};
+}
 function createEditStackEntry(textDocument, resolvedEdits, versionBefore, versionAfter, selectionsBefore, selectionsAfter, lineAnnotationsBefore, lineAnnotationsAfter) {
 	const forwardEdits = [...resolvedEdits].sort((a, b) => a.start - b.start);
 	const inverseEdits = [];