@adecore/editor-react 0.22.0 → 0.23.0

package/dist/symbols.js

@@ -19,7 +19,7 @@ const KINDS = {
 };
 function walk(symbols, spans) {
     for (const symbol of symbols) {
-        spans.push({ name: symbol.name, kind: symbol.kind, range: symbol.range });
+        spans.push({ name: symbol.name, kind: symbol.kind, range: symbol.range, nameLine: symbol.selectionRange?.start.line });
         walk(symbol.children ?? [], spans);
     }
 }
@@ -35,16 +35,48 @@ export function symbolSpansOf(result) {
     }
     return result.map((symbol) => ({ name: symbol.name, kind: symbol.kind, range: symbol.location.range }));
 }
-function blockOf({ name, kind, range }) {
+/* A line a declaration can have above it: blank, a comment, or an attribute. A bare `#` is no comment, since it heads a Markdown section. */
+const PRELUDE = /^\s*(?:$|\/\/|\/\*|\*|#\[)/;
+/*
+ * The line a block is pinned by. A range may begin at the doc comment or the attributes of a declaration, so the
+ * line of the name wins, and without it the first line below the comment that holds the name.
+ */
+function headerLineOf({ name, range, nameLine }, lines) {
+    const { start, end } = range;
+    if (nameLine !== undefined && nameLine >= start.line && nameLine <= end.line) {
+        return nameLine;
+    }
+    if (lines === undefined) {
+        return start.line;
+    }
+    const last = Math.min(end.line, lines.length - 1);
+    let first = start.line;
+    while (first < last && PRELUDE.test(lines[first] ?? '')) {
+        first++;
+    }
+    const short = name.slice(name.lastIndexOf('\\') + 1);
+    for (let line = first; line <= last; line++) {
+        if (!PRELUDE.test(lines[line] ?? '') && (lines[line] ?? '').includes(short)) {
+            return line;
+        }
+    }
+    return first;
+}
+function blockOf(span, lines) {
+    const { name, kind, range } = span;
     const label = KINDS[kind];
     // A one-line symbol has no body to pin, and a property or an enum member is part of the block around it.
     return label === undefined || range.end.line <= range.start.line
         ? null
-        : { startLine: range.start.line + 1, endLine: range.end.line + 1, name, kind: label };
+        : { startLine: headerLineOf(span, lines) + 1, endLine: range.end.line + 1, name, kind: label };
 }
-/* The multi-line symbols of a file as blocks, outermost first, in one-based lines. */
-export function blocksOf(result) {
-    const blocks = symbolSpansOf(result).flatMap((span) => blockOf(span) ?? []);
+/*
+ * The multi-line symbols of a file as blocks, outermost first, in one-based lines. The text of the document
+ * lets a block start at its declaration rather than at the comment a server counts into the symbol.
+ */
+export function blocksOf(result, text) {
+    const lines = text?.split('\n');
+    const blocks = symbolSpansOf(result).flatMap((span) => blockOf(span, lines) ?? []);
     return blocks.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
 }
 /*
@@ -62,7 +94,7 @@ export class SymbolsFeature {
             }
             const result = await project.service.documentSymbols(uri, { signal });
             if (!signal.aborted) {
-                editor.setBlocks(result === null ? null : blocksOf(result));
+                editor.setBlocks(result === null ? null : blocksOf(result, editor.getText()));
                 for (const listener of [...this.listeners]) {
                     listener(result);
                 }

package/dist/testing.d.ts

@@ -1,4 +1,4 @@
-import { type LanguageService, type LanguageDocument, type LanguageRequestOptions, type DiagnosticsReport, type ContentChange, type Disposable, type ProviderOptions, type CodeAction, type CodeActionContext, type CodeLens, type Command, type CompletionContext, type CompletionItem, type CompletionResult, type DocumentHighlight, type DocumentSymbolResult, type FoldingRange, type FormattingOptions, type Hover, type InlayHint, type Location, type NavigationResult, type Position, type PrepareRenameResult, type Range, type SelectionRange, type SemanticTokens, type SemanticTokensDelta, type SignatureHelp, type SignatureHelpContext, type TextEdit, type WorkspaceEdit, type WorkspaceSymbolResult } from '@adecore/lsp';
+import { type LanguageService, type LanguageDocument, type LanguageRequestOptions, type DiagnosticsReport, type ContentChange, type Disposable, type ProviderOptions, type CallHierarchyIncomingCall, type CallHierarchyItem, type CallHierarchyOutgoingCall, type CodeAction, type CodeActionContext, type CodeLens, type Command, type CompletionContext, type CompletionItem, type CompletionResult, type DocumentHighlight, type DocumentSymbolResult, type FoldingRange, type FormattingOptions, type Hover, type InlayHint, type Location, type NavigationResult, type Position, type PrepareRenameResult, type Range, type SelectionRange, type SemanticTokens, type SemanticTokensDelta, type SignatureHelp, type SignatureHelpContext, type TextEdit, type WorkspaceEdit, type WorkspaceSymbolResult } from '@adecore/lsp';
 export { ManualTimers } from './timers.ts';
 export interface LanguageCall {
     method: string;
@@ -44,6 +44,7 @@ export declare class FakeLanguageService implements LanguageService {
     executeCommand(uri: string, command: Command, options?: LanguageRequestOptions): Promise<unknown>;
     formatting(uri: string, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
     rangeFormatting(uri: string, range: Range, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    onTypeFormatting(uri: string, position: Position, ch: string, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
     semanticTokens(uri: string, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
     semanticTokensDelta(uri: string, previousResultId: string, options?: LanguageRequestOptions): Promise<SemanticTokens | SemanticTokensDelta | null>;
     semanticTokensRange(uri: string, range: Range, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
@@ -52,6 +53,9 @@ export declare class FakeLanguageService implements LanguageService {
     workspaceSymbols(uri: string, query: string, options?: LanguageRequestOptions): Promise<WorkspaceSymbolResult>;
     foldingRanges(uri: string, options?: LanguageRequestOptions): Promise<FoldingRange[] | null>;
     selectionRanges(uri: string, positions: readonly Position[], options?: LanguageRequestOptions): Promise<SelectionRange[] | null>;
+    prepareCallHierarchy(uri: string, position: Position, options?: LanguageRequestOptions): Promise<CallHierarchyItem[] | null>;
+    incomingCalls(uri: string, item: CallHierarchyItem, options?: LanguageRequestOptions): Promise<CallHierarchyIncomingCall[] | null>;
+    outgoingCalls(uri: string, item: CallHierarchyItem, options?: LanguageRequestOptions): Promise<CallHierarchyOutgoingCall[] | null>;
     codeLenses(uri: string, options?: LanguageRequestOptions): Promise<CodeLens[] | null>;
     resolveCodeLens(uri: string, lens: CodeLens, options?: LanguageRequestOptions): Promise<CodeLens>;
 }

package/dist/testing.js

@@ -123,6 +123,9 @@ export class FakeLanguageService {
     rangeFormatting(uri, range, formatting, options = {}) {
         return this.request('textDocument/rangeFormatting', uri, { range, options: formatting }, options);
     }
+    onTypeFormatting(uri, position, ch, formatting, options = {}) {
+        return this.request('textDocument/onTypeFormatting', uri, { position, ch, options: formatting }, options);
+    }
     semanticTokens(uri, options = {}) {
         return this.request('textDocument/semanticTokens/full', uri, {}, options);
     }
@@ -147,6 +150,15 @@ export class FakeLanguageService {
     selectionRanges(uri, positions, options = {}) {
         return this.request('textDocument/selectionRange', uri, { positions }, options);
     }
+    prepareCallHierarchy(uri, position, options = {}) {
+        return this.request('textDocument/prepareCallHierarchy', uri, { position }, options);
+    }
+    incomingCalls(uri, item, options = {}) {
+        return this.request('callHierarchy/incomingCalls', uri, { item }, options);
+    }
+    outgoingCalls(uri, item, options = {}) {
+        return this.request('callHierarchy/outgoingCalls', uri, { item }, options);
+    }
     codeLenses(uri, options = {}) {
         return this.request('textDocument/codeLens', uri, {}, options);
     }

package/dist/workspace-edit.d.ts

@@ -1,5 +1,5 @@
 import type { Editor } from '@adecore/editor';
-import { type ApplyWorkspaceEditResult, type RenameFile, type TextEdit, type WorkspaceEdit } from '@adecore/lsp';
+import { type ApplyWorkspaceEditResult, type ResourceOperationKind, type RenameFile, type TextEdit, type WorkspaceEdit } from '@adecore/lsp';
 import type { DiskText } from './host-types.ts';
 export interface StagedFile {
     readonly path: string;
@@ -10,13 +10,35 @@ export interface ProjectFiles {
     read(path: string): Promise<DiskText | null>;
     stage(files: readonly StagedFile[]): void;
     save(files: readonly StagedFile[]): Promise<string | null>;
-    rename(from: string, to: string): Promise<string | null>;
-    create?(path: string, text: string): Promise<string | null>;
+    rename(from: string, to: string, options?: {
+        readonly overwrite: boolean;
+    }): Promise<string | null>;
+    create?(path: string, text: string, options?: {
+        readonly overwrite: boolean;
+    }): Promise<string | null>;
+    delete?(path: string, options: {
+        readonly recursive: boolean;
+    }): Promise<string | null>;
+    readonly supportsOverwrite?: boolean;
+    isUnsaved?(path: string): boolean;
+    exists?(path: string): Promise<boolean>;
+    isFolder?(path: string): Promise<boolean>;
 }
 export interface WorkspaceEditHost {
     editorOf(uri: string): Editor | undefined;
     readonly files: ProjectFiles | null;
+    versionOf?(uri: string): number | null;
+    isReadOnly?(uri: string): boolean;
+    openUris?(): readonly string[];
 }
+export interface ResourceOperationView {
+    readonly kind: ResourceOperationKind;
+    readonly uri: string;
+    readonly newUri?: string;
+}
+export declare function textEntriesOf(edit: WorkspaceEdit): Map<string, TextEdit[][]>;
 export declare function entriesOf(edit: WorkspaceEdit): Map<string, TextEdit[][]> | null;
 export declare function renamesOf(edit: WorkspaceEdit): RenameFile[];
+export declare function resourceOperationsOf(edit: WorkspaceEdit): ResourceOperationView[];
+export declare function supportedResourceOperations(files: ProjectFiles | null | undefined): ResourceOperationKind[];
 export declare function applyWorkspaceEdit(edit: WorkspaceEdit, host: WorkspaceEditHost): Promise<ApplyWorkspaceEditResult>;

package/dist/workspace-edit.js

@@ -1,185 +1,324 @@
-import { applyTextEdits, fileUriToPath } from '@adecore/lsp';
+import { fileUriToPath, planWorkspaceOperations } from '@adecore/lsp';
 import { messageOf } from './error-message.js';
 function refused(failureReason) {
     return { applied: false, failureReason };
 }
-/* The steps of an edit; null when it deletes a file, which an edit is not applied with. */
-function stepsOf(edit) {
-    const steps = [];
-    for (const change of edit.documentChanges ?? []) {
-        if ('textDocument' in change) {
-            steps.push({ kind: 'edits', uri: change.textDocument.uri, edits: change.edits });
-        }
-        else if (change.kind === 'create') {
-            steps.push({ kind: 'create', file: change });
-        }
-        else if (change.kind === 'rename') {
-            steps.push({ kind: 'rename', oldUri: change.oldUri, newUri: change.newUri });
-        }
-        else {
-            return null;
-        }
-    }
+/* The text edits of an edit per document, as the entries a document has in it, whatever else the edit does. */
+export function textEntriesOf(edit) {
+    const entries = new Map();
+    const add = (uri, edits) => {
+        entries.set(uri, [...(entries.get(uri) ?? []), edits]);
+    };
     if (edit.documentChanges === undefined) {
         for (const [uri, edits] of Object.entries(edit.changes ?? {})) {
-            steps.push({ kind: 'edits', uri, edits });
+            add(uri, edits);
         }
+        return entries;
     }
-    return steps;
-}
-/* The text edits of an edit per document, as the entries a document has in it; null when it deletes a file. */
-export function entriesOf(edit) {
-    const steps = stepsOf(edit);
-    if (steps === null) {
-        return null;
-    }
-    const entries = new Map();
-    for (const step of steps) {
-        if (step.kind === 'edits') {
-            entries.set(step.uri, [...(entries.get(step.uri) ?? []), step.edits]);
+    for (const change of edit.documentChanges) {
+        if ('textDocument' in change) {
+            add(change.textDocument.uri, change.edits);
         }
     }
     return entries;
 }
+/* The text edits of an edit per document, as the entries a document has in it; null when it deletes a file. */
+export function entriesOf(edit) {
+    return (edit.documentChanges ?? []).some((change) => 'kind' in change && change.kind === 'delete') ? null : textEntriesOf(edit);
+}
 /* The files an edit moves, which a preview of lines cannot show. */
 export function renamesOf(edit) {
     return (edit.documentChanges ?? []).filter((change) => 'kind' in change && change.kind === 'rename');
 }
+/* Every file an edit makes, moves or deletes, in the order it says. */
+export function resourceOperationsOf(edit) {
+    const operations = [];
+    for (const change of edit.documentChanges ?? []) {
+        if ('textDocument' in change) {
+            continue;
+        }
+        operations.push(change.kind === 'rename' ? { kind: 'rename', uri: change.oldUri, newUri: change.newUri } : { kind: change.kind, uri: change.uri });
+    }
+    return operations;
+}
 function contentChangeOf(edit) {
     return { range: edit.range, text: edit.newText };
 }
-/*
- * Applies an LSP workspace edit step by step, after checking it against every text so one that does not fit
- * changes nothing. A file an editor holds takes its edits as one undo step; any other file gets an unsaved
- * draft, since nothing is written to disk on a server's word alone, unless the edit also moves a file: then it
- * is one change, saved and moved through the machine. A file the edit creates is made through the machine.
- */
-export async function applyWorkspaceEdit(edit, host) {
-    const steps = stepsOf(edit);
-    if (steps === null) {
-        return refused('Deleting files is not supported yet');
-    }
-    const planned = await plan(steps, host);
-    if (typeof planned === 'string') {
-        return refused(planned);
-    }
-    const moving = planned.some((item) => item.kind === 'rename');
-    const staged = [];
-    for (const item of planned) {
-        if (item.kind === 'rename' || item.kind === 'create') {
-            const reason = item.kind === 'rename' ? await host.files.rename(item.oldPath, item.newPath) : await host.files.create(item.path, item.text);
-            if (reason !== null) {
-                return refused(reason);
+/* The resource operations a project has a way to carry out; pass it as the session's `resourceOperations` so servers only ask for what can be done. */
+export function supportedResourceOperations(files) {
+    const operations = [];
+    if (files?.create !== undefined) {
+        operations.push('create');
+    }
+    if (files?.rename !== undefined) {
+        operations.push('rename');
+    }
+    if (files?.delete !== undefined) {
+        operations.push('delete');
+    }
+    return operations;
+}
+function within(uri, folder) {
+    return uri.startsWith(`${folder}/`);
+}
+/* Where a deleted URI stood before the renames that ran ahead of it, and what was moved into it: the places unsaved work can be. */
+function placesOf(uri, renames) {
+    const found = new Set([uri]);
+    for (let i = renames.length - 1; i >= 0; i--) {
+        const { oldUri, newUri } = renames[i];
+        for (const place of [...found]) {
+            if (place === newUri || within(place, newUri)) {
+                found.add(oldUri + place.slice(newUri.length));
             }
-            continue;
-        }
-        if (item.after === item.before) {
-            continue;
-        }
-        const editor = host.editorOf(item.uri);
-        if (editor) {
-            // The edits stay apart, so the caret and what is drawn over the text stay where they were between them.
-            if (!editor.applyEdits(item.edits.map(contentChangeOf))) {
-                return refused(`${item.uri} is read only`);
+            else if (within(newUri, place)) {
+                found.add(oldUri);
             }
-            continue;
-        }
-        const path = fileUriToPath(item.uri);
-        if (path === null || item.disk === null) {
-            continue;
-        }
-        const file = { path, disk: item.disk, text: item.after };
-        if (!moving) {
-            staged.push(file);
-            continue;
-        }
-        const reason = await host.files.save([file]);
-        if (reason !== null) {
-            return refused(reason);
         }
     }
-    if (staged.length > 0) {
-        host.files?.stage(staged);
+    return [...found];
+}
+/* Whether deleting or replacing loses work nobody saved at any of the places. Without `isUnsaved` that is an editor on, or under, a place. A `recursive` one may be a folder. */
+function losesWork(recursive, places, host) {
+    const files = host.files;
+    if (files.isUnsaved !== undefined) {
+        return places.some((place) => {
+            const path = fileUriToPath(place);
+            return path !== null && files.isUnsaved(path);
+        });
     }
-    return { applied: true };
+    if (host.openUris === undefined && recursive) {
+        return true;
+    }
+    const open = host.openUris?.() ?? [];
+    return places.some((place) => host.editorOf(place) !== undefined || open.some((uri) => uri === place || within(uri, place)));
 }
-/* Reads every text the edit needs and works out what each step leaves, or says why it does not fit. */
-async function plan(steps, host) {
-    const texts = new Map();
-    // A file that has moved is read where it still stands: nothing moves until the plan is made.
-    const origins = new Map();
-    // A file that is made is written once, with what every step leaves in it.
-    const creates = new Map();
-    const planned = [];
+function readOnlyAt(host, uri, editor) {
+    return host.isReadOnly?.(uri) ?? editor?.isReadOnly?.() ?? false;
+}
+/* Why a create or move over a file that is there is refused; null when the host can replace it without losing work. */
+function overwriteProblem(step, target, places, host, reads) {
+    const path = fileUriToPath(target);
+    if (host.files?.supportsOverwrite !== true) {
+        return `${path} already exists`;
+    }
+    // A target no text was read from may be a folder, with unsaved work anywhere under it.
+    const isText = step.kind === 'create' || reads.open.has(target) || reads.disks.has(target);
+    if (losesWork(!isText, places, host)) {
+        return `${path} has changes that are not saved`;
+    }
+    const editor = host.editorOf(target);
+    return editor !== undefined && step.kind === 'create' && readOnlyAt(host, target, editor) ? `${path} is read only` : null;
+}
+/* Checks a plan against what only the host can see: paths, overwrites, unsaved work and the editors it touches. Null when it fits. */
+function problemWith(steps, host, reads) {
+    const renames = [];
     for (const step of steps) {
-        if (step.kind === 'create') {
-            const made = await planCreate(step.file, host, texts);
-            if (typeof made === 'string') {
-                return made;
-            }
-            if (made !== null) {
-                creates.set(step.file.uri, made);
-                planned.push(made);
+        if (step.kind === 'edits') {
+            if (step.open && readOnlyAt(host, step.readUri, host.editorOf(step.readUri))) {
+                return `${step.uri} is read only`;
             }
             continue;
         }
-        if (step.kind === 'rename') {
-            const oldPath = fileUriToPath(step.oldUri);
-            const newPath = fileUriToPath(step.newUri);
-            if (oldPath === null || newPath === null || host.files === null) {
-                return `${step.oldUri} cannot be moved from here`;
-            }
-            origins.set(step.newUri, origins.get(step.oldUri) ?? step.oldUri);
-            planned.push({ kind: 'rename', oldPath, newPath });
-            continue;
+        const uris = step.kind === 'rename' ? [step.oldUri, step.newUri] : [step.uri];
+        const paths = uris.map((uri) => fileUriToPath(uri));
+        if (paths.includes(null)) {
+            return `${uris[0]} cannot be changed from here`;
         }
-        const source = origins.get(step.uri) ?? step.uri;
-        const created = creates.get(source);
-        if (created !== undefined) {
-            try {
-                created.text = applyTextEdits(created.text, step.edits);
-            }
-            catch (error) {
-                return messageOf(error);
+        if ((step.kind === 'create' || step.kind === 'rename') && step.overwrite) {
+            const target = step.kind === 'create' ? step.uri : step.newUri;
+            const refusal = overwriteProblem(step, target, placesOf(target, renames), host, reads);
+            if (refusal !== null) {
+                return refusal;
             }
-            continue;
         }
-        if (!texts.has(source)) {
-            const editor = host.editorOf(source);
-            if (editor) {
-                texts.set(source, { text: editor.getText(), disk: null });
-            }
-            else {
-                const path = fileUriToPath(source);
-                const disk = path === null || host.files === null ? null : await host.files.read(path);
+        if (step.kind === 'rename') {
+            renames.push({ kind: 'rename', oldUri: step.oldUri, newUri: step.newUri });
+        }
+        if (step.kind === 'delete' && losesWork(step.recursive, placesOf(step.uri, renames), host)) {
+            return `${paths[0]} has changes that are not saved`;
+        }
+    }
+    for (const [uri, planned] of reads.open) {
+        const editor = host.editorOf(uri);
+        if (editor === undefined || editor.getText() !== planned.text) {
+            return `${uri} changed while the edit was being prepared`;
+        }
+        const version = host.versionOf?.(uri) ?? null;
+        if (planned.version !== null && version !== planned.version) {
+            return `${uri} changed while the edit was being prepared`;
+        }
+    }
+    for (const uri of reads.disks.keys()) {
+        if (host.editorOf(uri) !== undefined) {
+            return `${uri} was opened while the edit was being prepared`;
+        }
+    }
+    return null;
+}
+/*
+ * Applies an LSP workspace edit step by step, after planning it against every text (`planWorkspaceOperations`)
+ * so one that does not fit changes nothing. What the host supports follows `host.files`: moves need `rename`,
+ * makes need `create` and deletes need `delete`. Just before the first step runs, every open editor must still
+ * hold the text and version the plan was made from, and a delete must not lose unsaved work. Each text step
+ * and each delete checks that again right before it runs, since the steps before it are awaited.
+ *
+ * A file an editor holds takes its edits as one undo step per step of the edit; any other file gets an unsaved
+ * draft, since nothing is written to disk on a server's word alone, unless the edit also moves files: then it
+ * is one change, saved and moved through the machine. A create or a move over a file that is there is refused,
+ * unless it says `overwrite` and `files.supportsOverwrite` is set. Then it is refused only when the target, or
+ * anything under a folder target, has unsaved work, checked again right before the step runs. `overwrite` wins
+ * over `ignoreIfExists`, as the protocol says. A created file that an editor still holds shows its new text.
+ * The steps run in order and a step that no longer fits stops the edit there, with the steps before it applied
+ * and nothing rolled back. A folder that only exists because an earlier move in the same edit made it is
+ * looked for where it was and refused.
+ */
+export async function applyWorkspaceEdit(edit, host) {
+    const reads = { open: new Map(), disks: new Map() };
+    const files = host.files;
+    let steps;
+    try {
+        ({ steps } = await planWorkspaceOperations(edit, {
+            operations: supportedResourceOperations(files),
+            read: async (uri) => {
+                const editor = host.editorOf(uri);
+                if (editor !== undefined) {
+                    const text = editor.getText();
+                    const version = host.versionOf?.(uri) ?? null;
+                    reads.open.set(uri, { text, version });
+                    return { text, version, open: true };
+                }
+                const path = fileUriToPath(uri);
+                const disk = path === null || files === null ? null : await files.read(path);
                 if (disk === null) {
-                    return `${source} cannot be read as text`;
+                    return null;
                 }
-                texts.set(source, { text: disk.text, disk });
-            }
+                reads.disks.set(uri, disk);
+                return { text: disk.text, version: null, open: false };
+            },
+            ...(files?.exists === undefined
+                ? {}
+                : {
+                    exists: async (uri) => {
+                        const path = fileUriToPath(uri);
+                        return path !== null && (await files.exists(path));
+                    }
+                }),
+            ...(files?.isFolder === undefined
+                ? {}
+                : {
+                    isFolder: async (uri) => {
+                        const path = fileUriToPath(uri);
+                        return path === null || (await files.isFolder(path));
+                    }
+                })
+        }));
+    }
+    catch (error) {
+        return refused(messageOf(error));
+    }
+    const problem = problemWith(steps, host, reads);
+    if (problem !== null) {
+        return refused(problem);
+    }
+    const running = { ahead: [], reads, saving: steps.some((step) => step.kind === 'rename'), staged: [], touched: new Set() };
+    for (const [index, step] of steps.entries()) {
+        running.ahead = steps.slice(index + 1);
+        const reason = await run(step, host, running);
+        if (reason !== null) {
+            return refused(reason);
         }
-        const held = texts.get(source);
-        let after;
-        try {
-            after = applyTextEdits(held.text, step.edits);
+    }
+    if (running.staged.length > 0) {
+        files?.stage(running.staged);
+    }
+    return { applied: true };
+}
+/* Why a text step no longer fits its editor, now that the steps before it ran; null when it does. */
+function driftOf(step, host, uri, editor, touched) {
+    if (editor.getText() !== step.before) {
+        return `${step.uri} changed while the edit was being applied`;
+    }
+    const version = uri === step.readUri && !touched.has(editor) ? host.versionOf?.(uri) : undefined;
+    if (version !== undefined && step.version !== null && version !== step.version) {
+        return `${step.uri} changed while the edit was being applied`;
+    }
+    return readOnlyAt(host, uri, editor) ? `${step.uri} is read only` : null;
+}
+/* Does one step; the reason it could not, or null. */
+async function run(step, host, running) {
+    const files = host.files;
+    if (step.kind === 'create') {
+        return step.overwrite ? overwriteFile(step, host) : files.create(fileUriToPath(step.uri), step.text);
+    }
+    if (step.kind === 'rename') {
+        const [from, to] = [fileUriToPath(step.oldUri), fileUriToPath(step.newUri)];
+        if (!step.overwrite) {
+            return files.rename(from, to);
         }
-        catch (error) {
-            return messageOf(error);
+        // The steps before this one ran, so the unsaved work at the target is looked for once more.
+        return losesWork(!running.reads.disks.has(step.newUri) && !running.reads.open.has(step.newUri), [step.newUri], host)
+            ? `${to} has changes that are not saved`
+            : files.rename(from, to, { overwrite: true });
+    }
+    if (step.kind === 'delete') {
+        const path = fileUriToPath(step.uri);
+        if (losesWork(step.recursive, [step.uri], host)) {
+            return `${path} has changes that are not saved`;
         }
-        planned.push({ kind: 'edits', uri: step.uri, edits: step.edits, before: held.text, after, disk: held.disk });
-        texts.set(source, { text: after, disk: held.disk });
+        return files.delete(path, { recursive: step.recursive });
     }
-    return planned;
+    if (step.after === step.before) {
+        return null;
+    }
+    if (step.open) {
+        const uri = host.editorOf(step.uri) === undefined ? step.readUri : step.uri;
+        return editOpen(step, host, running, uri, host.editorOf(uri));
+    }
+    return runDraft(step, host, running);
+}
+/* Empties a file that is there and gives it its text; the editor that still holds it is set to the same text. */
+async function overwriteFile(step, host) {
+    const path = fileUriToPath(step.uri);
+    if (losesWork(false, [step.uri], host)) {
+        return `${path} has changes that are not saved`;
+    }
+    const reason = await host.files.create(path, step.text, { overwrite: true });
+    if (reason === null) {
+        host.editorOf(step.uri)?.setText(step.text);
+    }
+    return reason;
+}
+function editOpen(step, host, running, uri, editor) {
+    if (editor === undefined) {
+        return `${step.uri} is not open any more`;
+    }
+    const drift = driftOf(step, host, uri, editor, running.touched);
+    if (drift !== null) {
+        return drift;
+    }
+    running.touched.add(editor);
+    // The edits stay apart, so the caret and what is drawn over the text stay where they were between them.
+    return editor.applyEdits(step.edits.map(contentChangeOf)) ? null : `${step.uri} is read only`;
+}
+/* Whether a later step deletes the file or a folder around it, so a draft or a save of it would only bring it back. */
+function deletedAhead(uri, ahead) {
+    return ahead.some((step) => step.kind === 'delete' && (step.uri === uri || within(uri, step.uri.replace(/\/$/, ''))));
 }
-/* A file that is not there yet, or null when it is and the create says to leave it. Making one over a file that is there is not supported. */
-async function planCreate(file, host, texts) {
-    const path = fileUriToPath(file.uri);
-    if (path === null || host.files?.create === undefined) {
-        return `Creating ${file.uri} is not supported here`;
+async function runDraft(step, host, running) {
+    const { reads, saving, staged, ahead } = running;
+    const uri = [step.uri, step.readUri].find((candidate) => host.editorOf(candidate) !== undefined);
+    if (uri !== undefined) {
+        return editOpen(step, host, running, uri, host.editorOf(uri));
     }
-    const there = texts.has(file.uri) || host.editorOf(file.uri) !== undefined || (await host.files.read(path)) !== null;
-    if (!there) {
-        return { kind: 'create', path, text: '' };
+    const path = fileUriToPath(step.uri);
+    const disk = reads.disks.get(step.readUri);
+    if (path === null || disk === undefined || deletedAhead(step.uri, ahead)) {
+        return null;
+    }
+    const file = { path, disk, text: step.after };
+    if (!saving) {
+        staged.push(file);
+        return null;
     }
-    return file.options?.ignoreIfExists === true && file.options.overwrite !== true ? null : `${path} already exists`;
+    return host.files.save([file]);
 }