@vscode/chat-lib 0.0.1

package/src/_internal/platform/inlineEdits/common/dataTypes/permutation.ts

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { illegalArgument } from '../../../../util/vs/base/common/errors';
+
+/**
+ * Represents a re-arrangement of items in an array.
+ */
+export class Permutation {
+
+	/**
+	 * The index map describes the index in the original array.
+	 *
+	 * @example
+	 * ```typescript
+	 * const arr = [20, 10, 30];
+	 *
+	 * const arrSortedPermutation = new Permutation([1, 0, 2]);
+	 * // though consider using `Permutation.createSortPermutation(arr, (a, b) => a - b)` for sorting permutations
+	 * ```
+	 */
+	constructor(private readonly _indexMap: readonly number[]) { }
+
+	get arrayLength() {
+		return this._indexMap.length;
+	}
+
+	/**
+	 * Returns a permutation that sorts the given array according to the given compare function.
+	 */
+	public static createSortPermutation<T>(arr: readonly T[], compareFn: (a: T, b: T) => number): Permutation {
+		const sortIndices = Array.from(arr.keys()).sort((index1, index2) => compareFn(arr[index1], arr[index2]));
+		return new Permutation(sortIndices);
+	}
+
+	/**
+	 * Returns a new array with the elements of the given array re-arranged according to this permutation.
+	 */
+	apply<T>(arr: readonly T[]): T[] {
+		if (arr.length !== this.arrayLength) {
+			throw illegalArgument(`Permutation must be applied on an array of same length. Received length: ${arr.length}. Expected length: ${this.arrayLength}`);
+		}
+		return arr.map((_, index) => arr[this._indexMap[index]]);
+	}
+
+	/**
+	 * Given an index after permutation is, returns the index in the original array.
+	 */
+	mapIndexBack(indexAfterShuffling: number): number {
+		const originalArrIdx = this._indexMap.at(indexAfterShuffling);
+		if (originalArrIdx === undefined) {
+			throw illegalArgument(`Given index must be within original array length. Received: ${indexAfterShuffling}. Expected: 0 <= x < ${this.arrayLength}`);
+		}
+		return originalArrIdx;
+	}
+
+	/**
+	 * Returns a new permutation that undoes the re-arrangement of this permutation.
+	*/
+	inverse(): Permutation {
+		const inverseIndexMap = this._indexMap.slice();
+		for (let i = 0; i < this._indexMap.length; i++) {
+			inverseIndexMap[this._indexMap[i]] = i;
+		}
+		return new Permutation(inverseIndexMap);
+	}
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/rootedLineEdit.ts

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { LineEdit, LineReplacement } from '../../../../util/vs/editor/common/core/edits/lineEdit';
+import { BaseStringEdit, StringEdit } from '../../../../util/vs/editor/common/core/edits/stringEdit';
+import { StringText } from '../../../../util/vs/editor/common/core/text/abstractText';
+import { ensureDependenciesAreSet } from '../../../../util/vs/editor/common/core/text/positionToOffset';
+import { RootedEdit } from './edit';
+
+ensureDependenciesAreSet();
+
+export class RootedLineEdit {
+	public static fromEdit<TEdit extends BaseStringEdit>(edit: RootedEdit<TEdit>): RootedLineEdit {
+		const lineEdit = LineEdit.fromEdit(edit.edit as BaseStringEdit as StringEdit, edit.base);
+		return new RootedLineEdit(edit.base, lineEdit);
+	}
+
+	constructor(
+		public readonly base: StringText,
+		public readonly edit: LineEdit,
+	) { }
+
+
+	public toString(): string {
+		return this.edit.humanReadablePatch(this.base.getLines());
+	}
+
+	public toEdit(): StringEdit {
+		return this.edit.toEdit(this.base);
+	}
+
+	public toRootedEdit(): RootedEdit {
+		return new RootedEdit(this.base, this.toEdit());
+	}
+
+	public getEditedState(): string[] {
+		const lines = this.base.getLines();
+		const newLines = this.edit.apply(lines);
+		return newLines;
+	}
+
+	public removeCommonSuffixPrefixLines(): RootedLineEdit {
+		const isNotEmptyEdit = (edit: LineReplacement) => !edit.lineRange.isEmpty || edit.newLines.length > 0;
+		const newEdit = this.edit.replacements.map(e => e.removeCommonSuffixPrefixLines(this.base)).filter(e => isNotEmptyEdit(e));
+		return new RootedLineEdit(this.base, new LineEdit(newEdit));
+	}
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/textEditLength.ts

@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { TextEdit } from '../../../../util/vs/editor/common/core/edits/textEdit';
+import { Range } from '../../../../util/vs/editor/common/core/range';
+import { TextLength } from '../../../../util/vs/editor/common/core/text/textLength';
+import { combineTextEditInfos } from './textEditLengthHelper/combineTextEditInfos';
+import { lengthsToRange, lengthToObj, toLength } from './textEditLengthHelper/length';
+import { TextEditInfo } from './textEditLengthHelper/textEditInfo';
+
+export class TextLengthEdit {
+	public static readonly empty = new TextLengthEdit([]);
+
+	public static fromTextEdit(textEdit: TextEdit): TextLengthEdit {
+		const edits = textEdit.replacements.map(e => new SingleTextEditLength(e.range, TextLength.ofText(e.text)));
+		return new TextLengthEdit(edits);
+	}
+
+	private static _fromTextEditInfo(info: TextEditInfo[]): TextLengthEdit {
+		const edits = info.map(e => {
+			const newLen = lengthToObj(e.newLength);
+			return new SingleTextEditLength(
+				lengthsToRange(e.startOffset, e.endOffset),
+				new TextLength(newLen.lineCount, newLen.columnCount),
+			);
+		});
+		return new TextLengthEdit(edits);
+	}
+
+	constructor(
+		public readonly edits: readonly SingleTextEditLength[],
+	) { }
+
+	private _toTextEditInfo(): TextEditInfo[] {
+		return this.edits.map(e => new TextEditInfo(
+			toLength(e.range.startLineNumber - 1, e.range.startColumn - 1),
+			toLength(e.range.endLineNumber - 1, e.range.endColumn - 1),
+			toLength(e.newLength.lineCount, e.newLength.columnCount),
+		));
+	}
+
+	public compose(other: TextLengthEdit): TextLengthEdit {
+		const self = this._toTextEditInfo();
+		const o = other._toTextEditInfo();
+
+		const result = combineTextEditInfos(self, o);
+		return TextLengthEdit._fromTextEditInfo(result);
+	}
+
+	/**
+	 * Returns the range of the edit, or undefined if the edit is empty.
+	 */
+	public getRange(): Range | undefined {
+		if (this.edits.length === 0) { return undefined; }
+		return Range.fromPositions(this.edits[0].range.getStartPosition(), this.edits.at(-1)!.range.getEndPosition());
+	}
+
+	public toString() {
+		return `[${this.edits.join(', ')}]`;
+	}
+}
+
+export class SingleTextEditLength {
+	constructor(
+		public readonly range: Range,
+		public readonly newLength: TextLength,
+	) { }
+
+	toString() {
+		return `{ range: ${this.range}, newLength: ${this.newLength} }`;
+	}
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/textEditLengthHelper/combineTextEditInfos.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ArrayQueue } from '../../../../../util/vs/base/common/arrays.js';
+import { Length, lengthAdd, lengthDiffNonNegative, lengthEquals, lengthIsZero, lengthToObj, lengthZero, sumLengths } from './length.js';
+import { TextEditInfo } from './textEditInfo.js';
+
+export function combineTextEditInfos(textEditInfoFirst: TextEditInfo[], textEditInfoSecond: TextEditInfo[]): TextEditInfo[] {
+	if (textEditInfoFirst.length === 0) {
+		return textEditInfoSecond;
+	}
+	if (textEditInfoSecond.length === 0) {
+		return textEditInfoFirst;
+	}
+
+	// s0: State before any edits
+	const s0ToS1Map = new ArrayQueue(toLengthMapping(textEditInfoFirst));
+	// s1: State after first edit, but before second edit
+	const s1ToS2Map = toLengthMapping(textEditInfoSecond) as (LengthMapping | { lengthBefore: undefined; lengthAfter: undefined; modified: false })[];
+	s1ToS2Map.push({ modified: false, lengthBefore: undefined, lengthAfter: undefined }); // Copy everything from old to new
+	// s2: State after both edits
+
+	let curItem: LengthMapping | undefined = s0ToS1Map.dequeue();
+
+	/**
+	 * @param s1Length Use undefined for length "infinity"
+	 */
+	function nextS0ToS1MapWithS1LengthOf(s1Length: Length | undefined): LengthMapping[] {
+		if (s1Length === undefined) {
+			const arr = s0ToS1Map.takeWhile(v => true) || [];
+			if (curItem) {
+				arr.unshift(curItem);
+			}
+			return arr;
+		}
+
+		const result: LengthMapping[] = [];
+		while (curItem && !lengthIsZero(s1Length)) {
+			const [item, remainingItem] = curItem.splitAt(s1Length);
+			result.push(item);
+			s1Length = lengthDiffNonNegative(item.lengthAfter, s1Length);
+			curItem = remainingItem ?? s0ToS1Map.dequeue();
+		}
+		if (!lengthIsZero(s1Length)) {
+			result.push(new LengthMapping(false, s1Length, s1Length));
+		}
+		return result;
+	}
+
+	const result: TextEditInfo[] = [];
+
+	function pushEdit(startOffset: Length, endOffset: Length, newLength: Length): void {
+		if (result.length > 0 && lengthEquals(result[result.length - 1].endOffset, startOffset)) {
+			const lastResult = result[result.length - 1];
+			result[result.length - 1] = new TextEditInfo(lastResult.startOffset, endOffset, lengthAdd(lastResult.newLength, newLength));
+		} else {
+			result.push({ startOffset, endOffset, newLength });
+		}
+	}
+
+	let s0offset = lengthZero;
+	for (const s1ToS2 of s1ToS2Map) {
+		const s0ToS1Map = nextS0ToS1MapWithS1LengthOf(s1ToS2.lengthBefore);
+		if (s1ToS2.modified) {
+			const s0Length = sumLengths(s0ToS1Map, s => s.lengthBefore);
+			const s0EndOffset = lengthAdd(s0offset, s0Length);
+			pushEdit(s0offset, s0EndOffset, s1ToS2.lengthAfter);
+			s0offset = s0EndOffset;
+		} else {
+			for (const s1 of s0ToS1Map) {
+				const s0startOffset = s0offset;
+				s0offset = lengthAdd(s0offset, s1.lengthBefore);
+				if (s1.modified) {
+					pushEdit(s0startOffset, s0offset, s1.lengthAfter);
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+class LengthMapping {
+	constructor(
+		/**
+		 * If false, length before and length after equal.
+		 */
+		public readonly modified: boolean,
+		public readonly lengthBefore: Length,
+		public readonly lengthAfter: Length,
+	) {
+	}
+
+	splitAt(lengthAfter: Length): [LengthMapping, LengthMapping | undefined] {
+		const remainingLengthAfter = lengthDiffNonNegative(lengthAfter, this.lengthAfter);
+		if (lengthEquals(remainingLengthAfter, lengthZero)) {
+			return [this, undefined];
+		} else if (this.modified) {
+			return [
+				new LengthMapping(this.modified, this.lengthBefore, lengthAfter),
+				new LengthMapping(this.modified, lengthZero, remainingLengthAfter)
+			];
+		} else {
+			return [
+				new LengthMapping(this.modified, lengthAfter, lengthAfter),
+				new LengthMapping(this.modified, remainingLengthAfter, remainingLengthAfter)
+			];
+		}
+	}
+
+	toString(): string {
+		return `${this.modified ? 'M' : 'U'}:${lengthToObj(this.lengthBefore)} -> ${lengthToObj(this.lengthAfter)}`;
+	}
+}
+
+function toLengthMapping(textEditInfos: TextEditInfo[]): LengthMapping[] {
+	const result: LengthMapping[] = [];
+	let lastOffset = lengthZero;
+	for (const textEditInfo of textEditInfos) {
+		const spaceLength = lengthDiffNonNegative(lastOffset, textEditInfo.startOffset);
+		if (!lengthIsZero(spaceLength)) {
+			result.push(new LengthMapping(false, spaceLength, spaceLength));
+		}
+
+		const lengthBefore = lengthDiffNonNegative(textEditInfo.startOffset, textEditInfo.endOffset);
+		result.push(new LengthMapping(true, lengthBefore, textEditInfo.newLength));
+		lastOffset = textEditInfo.endOffset;
+	}
+	return result;
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/textEditLengthHelper/length.ts

@@ -0,0 +1,184 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { splitLines } from '../../../../../util/vs/base/common/strings';
+import { Position } from '../../../../../util/vs/editor/common/core/position';
+import { Range } from '../../../../../util/vs/editor/common/core/range';
+import { TextLength } from '../../../../../util/vs/editor/common/core/text/textLength';
+
+/**
+ * The end must be greater than or equal to the start.
+*/
+export function lengthDiff(startLineCount: number, startColumnCount: number, endLineCount: number, endColumnCount: number): Length {
+	return (startLineCount !== endLineCount)
+		? toLength(endLineCount - startLineCount, endColumnCount)
+		: toLength(0, endColumnCount - startColumnCount);
+}
+
+/**
+ * Represents a non-negative length in terms of line and column count.
+ * Does not allocate.
+*/
+export type Length = { _brand: 'Length' };
+
+export const lengthZero = 0 as any as Length;
+
+export function lengthIsZero(length: Length): boolean {
+	return length as any as number === 0;
+}
+
+/*
+ * We have 52 bits available in a JS number.
+ * We use the upper 26 bits to store the line and the lower 26 bits to store the column.
+ */
+///*
+const factor = 2 ** 26;
+/*/
+const factor = 1000000;
+// */
+
+export function toLength(lineCount: number, columnCount: number): Length {
+	// llllllllllllllllllllllllllcccccccccccccccccccccccccc (52 bits)
+	//       line count (26 bits)    column count (26 bits)
+
+	// If there is no overflow (all values/sums below 2^26 = 67108864),
+	// we have `toLength(lns1, cols1) + toLength(lns2, cols2) = toLength(lns1 + lns2, cols1 + cols2)`.
+
+	return (lineCount * factor + columnCount) as any as Length;
+}
+
+export function lengthToObj(length: Length): TextLength {
+	const l = length as any as number;
+	const lineCount = Math.floor(l / factor);
+	const columnCount = l - lineCount * factor;
+	return new TextLength(lineCount, columnCount);
+}
+
+export function lengthGetLineCount(length: Length): number {
+	return Math.floor(length as any as number / factor);
+}
+
+/**
+ * Returns the amount of columns of the given length, assuming that it does not span any line.
+*/
+export function lengthGetColumnCountIfZeroLineCount(length: Length): number {
+	return length as any as number;
+}
+
+
+// [10 lines, 5 cols] + [ 0 lines, 3 cols] = [10 lines, 8 cols]
+// [10 lines, 5 cols] + [20 lines, 3 cols] = [30 lines, 3 cols]
+export function lengthAdd(length1: Length, length2: Length): Length;
+export function lengthAdd(l1: any, l2: any): Length {
+	let r = l1 + l2;
+	if (l2 >= factor) { r = r - (l1 % factor); }
+	return r;
+}
+
+export function sumLengths<T>(items: readonly T[], lengthFn: (item: T) => Length): Length {
+	return items.reduce((a, b) => lengthAdd(a, lengthFn(b)), lengthZero);
+}
+
+export function lengthEquals(length1: Length, length2: Length): boolean {
+	return length1 === length2;
+}
+
+/**
+ * Returns a non negative length `result` such that `lengthAdd(length1, result) = length2`, or zero if such length does not exist.
+ */
+export function lengthDiffNonNegative(length1: Length, length2: Length): Length {
+	const l1 = length1 as any as number;
+	const l2 = length2 as any as number;
+
+	const diff = l2 - l1;
+	if (diff <= 0) {
+		// line-count of length1 is higher than line-count of length2
+		// or they are equal and column-count of length1 is higher than column-count of length2
+		return lengthZero;
+	}
+
+	const lineCount1 = Math.floor(l1 / factor);
+	const lineCount2 = Math.floor(l2 / factor);
+
+	const colCount2 = l2 - lineCount2 * factor;
+
+	if (lineCount1 === lineCount2) {
+		const colCount1 = l1 - lineCount1 * factor;
+		return toLength(0, colCount2 - colCount1);
+	} else {
+		return toLength(lineCount2 - lineCount1, colCount2);
+	}
+}
+
+export function lengthLessThan(length1: Length, length2: Length): boolean {
+	// First, compare line counts, then column counts.
+	return (length1 as any as number) < (length2 as any as number);
+}
+
+export function lengthLessThanEqual(length1: Length, length2: Length): boolean {
+	return (length1 as any as number) <= (length2 as any as number);
+}
+
+export function lengthGreaterThanEqual(length1: Length, length2: Length): boolean {
+	return (length1 as any as number) >= (length2 as any as number);
+}
+
+export function lengthToPosition(length: Length): Position {
+	const l = length as any as number;
+	const lineCount = Math.floor(l / factor);
+	const colCount = l - lineCount * factor;
+	return new Position(lineCount + 1, colCount + 1);
+}
+
+export function positionToLength(position: Position): Length {
+	return toLength(position.lineNumber - 1, position.column - 1);
+}
+
+export function lengthsToRange(lengthStart: Length, lengthEnd: Length): Range {
+	const l = lengthStart as any as number;
+	const lineCount = Math.floor(l / factor);
+	const colCount = l - lineCount * factor;
+
+	const l2 = lengthEnd as any as number;
+	const lineCount2 = Math.floor(l2 / factor);
+	const colCount2 = l2 - lineCount2 * factor;
+
+	return new Range(lineCount + 1, colCount + 1, lineCount2 + 1, colCount2 + 1);
+}
+
+export function lengthOfRange(range: Range): TextLength {
+	if (range.startLineNumber === range.endLineNumber) {
+		return new TextLength(0, range.endColumn - range.startColumn);
+	} else {
+		return new TextLength(range.endLineNumber - range.startLineNumber, range.endColumn - 1);
+	}
+}
+
+export function lengthCompare(length1: Length, length2: Length): number {
+	const l1 = length1 as any as number;
+	const l2 = length2 as any as number;
+	return l1 - l2;
+}
+
+export function lengthOfString(str: string): Length {
+	const lines = splitLines(str);
+	return toLength(lines.length - 1, lines[lines.length - 1].length);
+}
+
+export function lengthOfStringObj(str: string): TextLength {
+	const lines = splitLines(str);
+	return new TextLength(lines.length - 1, lines[lines.length - 1].length);
+}
+
+/**
+ * Computes a numeric hash of the given length.
+*/
+export function lengthHash(length: Length): number {
+	return length as any;
+}
+
+export function lengthMax(length1: Length, length2: Length): Length {
+	return length1 > length2 ? length1 : length2;
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/textEditLengthHelper/textEditInfo.ts

@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Length, lengthToObj } from './length';
+
+export class TextEditInfo {
+	/*public static fromModelContentChanges(changes: IModelContentChange[]): TextEditInfo[] {
+		// Must be sorted in ascending order
+		const edits = changes.map(c => {
+			const range = Range.lift(c.range);
+			return new TextEditInfo(
+				positionToLength(range.getStartPosition()),
+				positionToLength(range.getEndPosition()),
+				lengthOfString(c.text)
+			);
+		}).reverse();
+		return edits;
+	}*/
+
+	constructor(
+		public readonly startOffset: Length,
+		public readonly endOffset: Length,
+		public readonly newLength: Length
+	) {
+	}
+
+	toString(): string {
+		return `[${lengthToObj(this.startOffset)}...${lengthToObj(this.endOffset)}) -> ${lengthToObj(this.newLength)}`;
+	}
+}

package/src/_internal/platform/inlineEdits/common/dataTypes/xtabPromptOptions.ts

@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export type RecentlyViewedDocumentsOptions = {
+	readonly nDocuments: number;
+	readonly maxTokens: number;
+	readonly includeViewedFiles: boolean;
+}
+
+export type LanguageContextLanguages = { [languageId: string]: boolean };
+
+export type LanguageContextOptions = {
+	readonly enabled: boolean;
+	readonly maxTokens: number;
+}
+
+export type DiffHistoryOptions = {
+	readonly nEntries: number;
+	readonly maxTokens: number;
+	readonly onlyForDocsInPrompt: boolean;
+	readonly useRelativePaths: boolean;
+}
+
+export type PagedClipping = { pageSize: number };
+
+export type CurrentFileOptions = {
+	readonly maxTokens: number;
+	readonly includeTags: boolean;
+	readonly prioritizeAboveCursor: boolean;
+}
+
+export type PromptOptions = {
+	readonly promptingStrategy: PromptingStrategy | undefined /* default */;
+	readonly currentFile: CurrentFileOptions;
+	readonly pagedClipping: PagedClipping;
+	readonly recentlyViewedDocuments: RecentlyViewedDocumentsOptions;
+	readonly languageContext: LanguageContextOptions;
+	readonly diffHistory: DiffHistoryOptions;
+}
+
+/**
+ * Prompt strategies that tweak prompt in a way that's different from current prod prompting strategy.
+ */
+export enum PromptingStrategy {
+	/**
+	 * Original Xtab unified model prompting strategy.
+	 */
+	UnifiedModel = 'xtabUnifiedModel',
+	Codexv21NesUnified = 'codexv21nesUnified',
+	Nes41Miniv3 = 'nes41miniv3',
+	SimplifiedSystemPrompt = 'simplifiedSystemPrompt',
+	Xtab275 = 'xtab275',
+}
+
+export const DEFAULT_OPTIONS: PromptOptions = {
+	promptingStrategy: undefined,
+	currentFile: {
+		maxTokens: 2000,
+		includeTags: true,
+		prioritizeAboveCursor: false,
+	},
+	pagedClipping: {
+		pageSize: 10,
+	},
+	recentlyViewedDocuments: {
+		nDocuments: 5,
+		maxTokens: 2000,
+		includeViewedFiles: false,
+	},
+	languageContext: {
+		enabled: false,
+		maxTokens: 2000,
+	},
+	diffHistory: {
+		nEntries: 25,
+		maxTokens: 1000,
+		onlyForDocsInPrompt: false,
+		useRelativePaths: false,
+	},
+};
+
+// TODO: consider a better per language setting/experiment approach
+export const LANGUAGE_CONTEXT_ENABLED_LANGUAGES: LanguageContextLanguages = {
+	'prompt': true,
+	'instructions': true,
+	'chatmode': true,
+};

package/src/_internal/platform/inlineEdits/common/debugRecorderBookmark.ts

@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export class DebugRecorderBookmark {
+	constructor(
+		public readonly timeMs: number,
+	) { }
+}