@openpresentation/opf-editor 0.26.5 → 0.26.7

package/dist/source-navigation.js

@@ -0,0 +1,217 @@
+// Go to definition, peek, references and rename (artifacts/source-editor/SPEC.md, section 8.3). Loaded lazily by the code editor on the first use of F12,
+// Alt+F12, Shift+F12, F2 or Cmd/Ctrl+click. Each command is `(view, context) => boolean` (true: the key was taken); `context` is what the code editor
+// knows: `{ format, catalogs, say, api, options, view, platform, readOnly, pointer }` (see json-editor.js `featureContext`). The reading of the text is
+// source-navigation-model.js, the widgets are source-navigation-ui.js; this file joins them and says what happened.
+import { layoutRegionSummary } from "./layout-templates.js";
+import { NOUNS, analyzeInPieces, definitionOf, lineAt, lineByNumber, lineCount, referenceList, renameBlocker, renameEdits, slideNumberAt, symbolAt, symbolKey, validateName } from "./source-navigation-model.js";
+import { cardPanel, closePanel, peekPanel, referencesPanel, renamePanel, showPanel } from "./source-navigation-ui.js";
+
+const SOURCE_LABEL = "Provided by app";
+const PEEK_LINES = 10;
+
+// The part of a line to show: all of it when it is short, else a window around `offset` (a minified deck is one line).
+const EXCERPT = 200;
+function excerpt(line, offset) {
+  if (line.text.length <= EXCERPT) return line.text;
+  const at = Math.max(0, offset - line.from);
+  const start = Math.max(0, Math.min(at - 60, line.text.length - EXCERPT));
+  return `${start > 0 ? "…" : ""}${line.text.slice(start, start + EXCERPT)}${start + EXCERPT < line.text.length ? "…" : ""}`;
+}
+
+const labelOf = (symbol) => `${NOUNS[symbol.kind] ?? symbol.kind} ${symbol.id}`;
+const plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+
+// The text read once: the commands that follow each other on the same text (F12, then Alt+F12, then F2 and its Enter) share one reading, and any edit
+// makes the next one read again. A big text is read in pieces with the main thread given back between them, so a command is asynchronous; when the text
+// changed while it was read, it is read again.
+let kept = null;
+async function read(context) {
+  for (let attempt = 0; ; attempt++) {
+    const source = context.api.getValue();
+    if (kept && kept.source === source && kept.format === context.format && kept.catalogs === context.catalogs) return { analysis: kept.analysis, source };
+    const analysis = await analyzeInPieces(source, context.format, { catalogs: context.catalogs });
+    if (attempt < 2 && context.api.getValue() !== source) continue;
+    kept = { source, format: context.format, catalogs: context.catalogs, analysis };
+    return { analysis, source };
+  }
+}
+
+// The symbol under the caret, read from the text as it is now.
+async function readCaret(context) {
+  const { api } = context;
+  const { analysis, source } = await read(context);
+  const [from, to] = api.getSelection();
+  const symbol = symbolAt(analysis, from) ?? (to !== from ? symbolAt(analysis, to) : null);
+  return { analysis, symbol, source, offset: from };
+}
+
+function wordAt(view, offset) {
+  const word = view.state.wordAt(Math.min(offset, view.state.doc.length));
+  return word ? view.state.sliceDoc(word.from, word.to) : "";
+}
+
+const jump = (context, view, occurrence, message) => {
+  closePanel(view, { focus: false });
+  context.api.setSelection(occurrence.from, occurrence.to);
+  view.focus();
+  context.say(message);
+};
+
+// The lines of a declaration (the key through the end of its value, up to ten lines) with a line of context on each side.
+function peekLines(analysis, definition) {
+  const first = lineAt(analysis, definition.from).number, last = lineAt(analysis, Math.max(definition.from, definition.blockTo ?? definition.to)).number;
+  const targetEnd = Math.min(last, first + PEEK_LINES - 1);
+  const lines = [];
+  for (let number = Math.max(1, first - 1); number <= Math.min(lineCount(analysis), targetEnd + 1); number++) {
+    const line = lineByNumber(analysis, number);
+    lines.push({ number, text: excerpt(line, number === first ? definition.from : line.from), target: number >= first && number <= targetEnd });
+  }
+  return lines;
+}
+
+function recordModel(definition, context) {
+  const record = definition.record ?? {};
+  const noun = NOUNS[definition.kind] ?? definition.kind;
+  const name = typeof record.name === "string" && record.name ? record.name : "";
+  const notes = [];
+  if (definition.kind === "layouts") { const summary = layoutRegionSummary(record); if (summary) notes.push(`Regions: ${summary}`); }
+  if (definition.member) {
+    const member = definition.member;
+    const description = definition.kind === "region" ? (member.accepts?.length ? `Accepts ${member.accepts.join(", ")}.` : "") : member.description ?? "";
+    return { title: definition.id, type: `${noun} of ${definition.reference}`, description: [member.name && definition.kind === "beat" ? member.name : "", description].filter(Boolean).join(". ") || undefined, notes: [SOURCE_LABEL] };
+  }
+  if (name && name !== definition.id) notes.unshift(name);
+  notes.push(SOURCE_LABEL);
+  return { title: definition.id, type: noun, description: typeof record.description === "string" ? record.description : undefined, notes };
+}
+
+function cardFor(view, context, source, symbol, definition, analysis) {
+  const model = recordModel(definition, context);
+  const label = labelOf(symbol);
+  const close = () => closePanel(view);
+  let preview;
+  try { preview = context.options?.resolvePreview?.(definition.kind, definition.id); } catch { preview = undefined; }
+  showPanel(view, cardPanel({ label, title: `${label} · ${SOURCE_LABEL}`, model, preview, onClose: close }), lineAt(analysis, symbol.from).to, source);
+  context.say(`${label} is provided by the app. ${model.description ?? ""}`.trim());
+}
+
+// ---- F12 ----------------------------------------------------------------------------------------------------------------------------
+/** F12, Cmd/Ctrl+click: jump to where the id under the caret is defined (or open the record's card). */
+export function goToDefinition(view, context) {
+  void goTo(view, context);
+  return true;
+}
+async function goTo(view, context) {
+  const { analysis, symbol, source } = await readCaret(context);
+  if (!view.dom.isConnected) return;
+  // A click that finds nothing is a plain click.
+  const quiet = context.pointer === true;
+  if (!symbol) { if (!quiet) context.say(`No definition found${wordAt(view, context.api.getSelection()[0]) ? ` for '${wordAt(view, context.api.getSelection()[0])}'` : ""}`); return; }
+  const definition = definitionOf(analysis, symbol);
+  if (!definition) { if (!quiet) context.say(`No definition found for '${symbol.id}'`); return; }
+  if (definition.where === "built-in") { if (!quiet) context.say(`${symbol.id} is a built-in variable; it has no definition in the document`); return; }
+  if (definition.where === "app") { cardFor(view, context, source, symbol, definition, analysis); return; }
+  const target = definition.occurrence;
+  // On the declaration itself the key lists the uses, as VS Code does.
+  if (target === symbol) { showReferences(view, context, analysis, symbol, source); return; }
+  jump(context, view, target, `Definition of ${labelOf(symbol)}, line ${lineAt(analysis, target.from).number}`);
+}
+
+// ---- Alt+F12 ------------------------------------------------------------------------------------------------------------------------
+/** Alt+F12: show the definition inline. */
+export function peekDefinition(view, context) {
+  void peek(view, context);
+  return true;
+}
+async function peek(view, context) {
+  const { analysis, symbol, source } = await readCaret(context);
+  if (!view.dom.isConnected) return;
+  if (!symbol) { context.say(`No definition found${wordAt(view, context.api.getSelection()[0]) ? ` for '${wordAt(view, context.api.getSelection()[0])}'` : ""}`); return; }
+  const definition = definitionOf(analysis, symbol);
+  if (!definition) { context.say(`No definition found for '${symbol.id}'`); return; }
+  if (definition.where === "built-in") { context.say(`${symbol.id} is a built-in variable; it has no definition in the document`); return; }
+  if (definition.where === "app") { cardFor(view, context, source, symbol, definition, analysis); return; }
+  const target = definition.occurrence;
+  if (target === symbol) { showReferences(view, context, analysis, symbol, source); return; }
+  const label = labelOf(symbol), line = lineAt(analysis, target.from).number;
+  const close = () => closePanel(view);
+  showPanel(view, peekPanel({
+    label, title: label, where: `Line ${line}`, lines: peekLines(analysis, target),
+    onGo: () => jump(context, view, target, `Definition of ${label}, line ${line}`),
+    onClose: close,
+  }), lineAt(analysis, symbol.from).to, source);
+  context.say(`Peek definition of ${label}, line ${line}. Enter goes to it, Escape closes.`);
+}
+
+// ---- Shift+F12 ----------------------------------------------------------------------------------------------------------------------
+function showReferences(view, context, analysis, symbol, source) {
+  const list = referenceList(analysis, symbol);
+  const label = labelOf(symbol);
+  const rows = list.map((occurrence) => {
+    const line = lineAt(analysis, occurrence.from);
+    return { number: line.number, slide: slideNumberAt(analysis, occurrence.from), text: excerpt(line, occurrence.from), declaration: occurrence.role === "def" };
+  });
+  const count = plural(list.length, "reference");
+  const close = () => closePanel(view);
+  showPanel(view, referencesPanel({
+    label, title: `${count} to ${label}`, rows,
+    onPick: (index) => jump(context, view, list[index], `${label}, ${list[index].role === "def" ? "declaration" : "reference"} at line ${rows[index].number}`),
+    onClose: close,
+  }), lineAt(analysis, symbol.from).to, source);
+  context.say(`${count} to ${label}`);
+}
+
+/** Shift+F12: list the places that use the id under the caret. */
+export function findReferences(view, context) {
+  void references(view, context);
+  return true;
+}
+async function references(view, context) {
+  const { analysis, symbol, source } = await readCaret(context);
+  if (!view.dom.isConnected) return;
+  if (!symbol) { context.say("No references found"); return; }
+  showReferences(view, context, analysis, symbol, source);
+}
+
+// ---- F2 -----------------------------------------------------------------------------------------------------------------------------
+/** F2: rename the id under the caret in its definition and every reference, as one undo step. */
+export function renameSymbol(view, context) {
+  void rename(view, context);
+  return true;
+}
+async function rename(view, context) {
+  const { analysis, symbol, source } = await readCaret(context);
+  if (!view.dom.isConnected) return;
+  if (!symbol) { context.say(context.readOnly ? "Cannot rename: the editor is read-only" : "Cannot rename: there is no id at the caret"); return; }
+  const blocker = renameBlocker(analysis, symbol, { readOnly: view.state.readOnly });
+  if (blocker) { context.say(blocker); return; }
+  const label = labelOf(symbol), key = symbolKey(symbol);
+  const close = () => closePanel(view);
+  let applying = false;
+  const apply = async (name) => {
+    if (applying) return;
+    applying = true;
+    // Read the text again: the author may have typed since the input opened.
+    const { analysis: now } = await read(context);
+    applying = false;
+    // The occurrence the caret was on (the nearest one of the symbol, when the text moved).
+    const same = now.occurrences.filter((occurrence) => symbolKey(occurrence) === key);
+    const current = same.reduce((best, occurrence) => (!best || Math.abs(occurrence.from - symbol.from) < Math.abs(best.from - symbol.from) ? occurrence : best), null);
+    if (!current) { close(); context.say(`Rename cancelled: ${label} is no longer in the text`); return; }
+    const problem = validateName(now, current, name);
+    if (problem) { context.say(problem); return; }
+    const result = renameEdits(now, current, name);
+    closePanel(view, { focus: false });
+    if (!result) { view.focus(); context.say(`${label} keeps its name`); return; }
+    // The selection goes to the same occurrence it was on when the input opened.
+    const places = result.edits.length;
+    context.api.applyEdits(result.edits, { select: result.caret, userEvent: "input.rename" });
+    view.focus();
+    context.say(`Renamed ${label} to ${name} in ${plural(places, "place")}`);
+  };
+  showPanel(view, renamePanel({
+    label, current: symbol.id, validate: (name) => validateName(analysis, symbol, name),
+    onSubmit: apply, onClose: close, say: context.say,
+  }), lineAt(analysis, symbol.from).to, source);
+  context.say(`Rename ${label}. Type the new name and press Enter, or Escape to cancel.`);
+}

package/dist/source-outline.js

@@ -0,0 +1,112 @@
+// The symbol picker (artifacts/source-editor/SPEC.md, section 8.4): Cmd/Ctrl+Shift+O lists the slides ("3. Highlights") and the other symbols of the
+// document (source-symbols.js) in a box at the top of the editor, filtered as you type. The arrows move, Enter jumps to the symbol and selects its range,
+// Escape closes and returns to where you were. Loaded lazily by the code editor.
+import { EditorView } from "@codemirror/view";
+import { documentSymbols, filterSymbols, symbolAt } from "./source-symbols.js";
+
+let counter = 0;
+const open = new WeakMap();
+const MAX_SHOWN = 200;
+
+const element = (doc, tag, className, attributes = {}) => {
+  const node = doc.createElement(tag);
+  if (className) node.className = className;
+  for (const [key, value] of Object.entries(attributes)) node.setAttribute(key, value);
+  return node;
+};
+const KIND_WORDS = { slide: "slide", section: "section", asset: "asset", dataset: "dataset", variable: "variable", reference: "reference", record: "catalog record" };
+
+/** Go to a symbol: select its range, scroll it into view and say where we are. */
+export function goToSymbol(view, context, symbol) {
+  context.api.setSelection(symbol.from, symbol.to);
+  context.api.focus();
+  context.say(`${symbol.label}, ${KIND_WORDS[symbol.kind] ?? symbol.kind}, line ${symbol.line}`);
+}
+
+/** Open the picker for `view` (Cmd/Ctrl+Shift+O); a second press closes it. Returns true: the key was taken. */
+export function showSymbolPicker(view, context) {
+  const existing = open.get(view);
+  if (existing) { existing.close(); return true; }
+  const text = context.api.getValue();
+  const symbols = documentSymbols(context.format, text);
+  const doc = view.dom.ownerDocument;
+  const id = `opf-quickpick-${++counter}`;
+  const root = element(doc, "div", "opf-quickpick");
+  const input = element(doc, "input", "opf-quickpick-input", { type: "text", role: "combobox", "aria-label": "Go to symbol", "aria-expanded": "true", "aria-controls": `${id}-list`, "aria-autocomplete": "list", placeholder: "Go to symbol: type to filter", autocomplete: "off", spellcheck: "false" });
+  const list = element(doc, "ul", "opf-quickpick-list", { id: `${id}-list`, role: "listbox", "aria-label": "Symbols" });
+  const status = element(doc, "div", "opf-quickpick-status", { role: "status", "aria-live": "polite" });
+  root.append(input, list, status);
+  view.dom.append(root);
+  const [caret] = context.api.getSelection();
+  const here = symbolAt(symbols.filter((symbol) => symbol.kind === "slide" || symbol.depth >= 0), caret);
+  const scroll = view.scrollDOM.scrollTop;
+  let shown = symbols, selected = 0, closed = false, timer = null;
+
+  function optionId(index) { return `${id}-option-${index}`; }
+  function select(index, { preview = true } = {}) {
+    if (!shown.length) { selected = 0; input.removeAttribute("aria-activedescendant"); return; }
+    selected = (index + shown.length) % shown.length;
+    [...list.children].forEach((node, at) => { const on = at === selected; node.setAttribute("aria-selected", String(on)); node.classList.toggle("is-selected", on); if (on) node.scrollIntoView?.({ block: "nearest" }); });
+    input.setAttribute("aria-activedescendant", optionId(selected));
+    // The editor follows the selection without moving the caret (VS Code shows the symbol as you arrow through the list).
+    if (preview) view.dispatch({ effects: EditorView.scrollIntoView(shown[selected].from, { y: "center" }) });
+    clearTimeout(timer);
+    timer = setTimeout(() => { const symbol = shown[selected]; if (symbol && !closed) context.say(`${symbol.label}, ${KIND_WORDS[symbol.kind] ?? symbol.kind}. ${selected + 1} of ${shown.length}`); }, 100);
+  }
+  function render(initial) {
+    shown = filterSymbols(symbols, input.value);
+    list.replaceChildren();
+    shown.slice(0, MAX_SHOWN).forEach((symbol, index) => {
+      const item = element(doc, "li", `opf-quickpick-item is-${symbol.kind}`, { id: optionId(index), role: "option", "aria-selected": "false", "data-kind": symbol.kind });
+      item.style.paddingLeft = `${10 + symbol.depth * 14}px`;
+      item.append(Object.assign(element(doc, "span", "opf-quickpick-label"), { textContent: symbol.label }));
+      if (symbol.detail) item.append(Object.assign(element(doc, "span", "opf-quickpick-detail"), { textContent: symbol.detail }));
+      item.append(Object.assign(element(doc, "span", "opf-quickpick-kind"), { textContent: KIND_WORDS[symbol.kind] ?? symbol.kind }));
+      item.addEventListener("pointerdown", (event) => event.preventDefault());
+      item.addEventListener("click", () => pick(index));
+      list.append(item);
+    });
+    if (shown.length > MAX_SHOWN) list.append(Object.assign(element(doc, "li", "opf-quickpick-more", { role: "presentation" }), { textContent: `${shown.length - MAX_SHOWN} more: keep typing to narrow the list.` }));
+    status.textContent = shown.length ? `${shown.length} ${shown.length === 1 ? "symbol" : "symbols"}` : "No symbols match";
+    const start = initial && here ? Math.max(0, shown.findIndex((symbol) => symbol.id === here.id)) : 0;
+    select(start, { preview: !initial });
+    if (!initial) context.say(status.textContent);
+  }
+  function pick(index) {
+    const symbol = shown[index];
+    if (!symbol) return;
+    close({ restore: false });
+    goToSymbol(view, context, symbol);
+  }
+  function close({ restore = true } = {}) {
+    if (closed) return;
+    closed = true;
+    clearTimeout(timer);
+    open.delete(view);
+    doc.removeEventListener("pointerdown", outside, true);
+    root.remove();
+    if (restore) view.scrollDOM.scrollTop = scroll;
+    if (view.dom.isConnected) view.focus();
+  }
+  function outside(event) { if (!root.contains(event.target)) close(); }
+  open.set(view, { close });
+  input.addEventListener("input", () => render(false));
+  input.addEventListener("keydown", (event) => {
+    const page = Math.max(1, Math.floor(list.clientHeight / 28) - 1);
+    if (event.key === "ArrowDown") { event.preventDefault(); select(selected + 1); }
+    else if (event.key === "ArrowUp") { event.preventDefault(); select(selected - 1); }
+    else if (event.key === "PageDown") { event.preventDefault(); select(Math.min(shown.length - 1, selected + page)); }
+    else if (event.key === "PageUp") { event.preventDefault(); select(Math.max(0, selected - page)); }
+    else if (event.key === "Enter") { event.preventDefault(); pick(selected); }
+    else if (event.key === "Escape") { event.preventDefault(); event.stopPropagation(); close(); }
+    else if (event.key === "Tab") { event.preventDefault(); close(); }
+    // The key that opened the picker closes it, also from the input.
+    else if ((context.platform === "mac" ? event.metaKey : event.ctrlKey) && event.shiftKey && !event.altKey && (event.key.toLowerCase() === "o" || event.code === "KeyO")) { event.preventDefault(); event.stopPropagation(); close(); }
+  });
+  input.addEventListener("blur", () => { setTimeout(() => { if (!closed && !root.contains(doc.activeElement)) close({ restore: false }); }, 0); });
+  doc.addEventListener("pointerdown", outside, true);
+  render(true);
+  input.focus();
+  context.say(`Go to symbol, ${symbols.length} ${symbols.length === 1 ? "symbol" : "symbols"}. Type to filter, Enter to go, Escape to close.`);
+  return true;
+}

package/dist/source-pane.d.ts

@@ -43,7 +43,42 @@ export interface SourceFile {
   mime: string;
 }
 
+export type ShortcutPlatform = "mac" | "win" | "linux";
+/** One row of the keyboard shortcuts list. */
+export interface Shortcut {
+  id: string;
+  title: string;
+  group: string;
+  /** The keys as words: `Cmd+Shift+O` on macOS, `Ctrl+Shift+O` elsewhere; a chord is two strokes separated by a space (`Cmd+K Cmd+0`). */
+  keys: string[];
+  /** The same keys with the macOS symbols (`⌘⇧O`) on macOS, else the words. */
+  symbols: string[];
+  /** The keys in CodeMirror's notation (`Mod-Shift-o`). */
+  strokes: string[];
+  /** What has to be true for the keys to apply (`the list is open`). */
+  when?: string;
+}
+
+/** One entry of the outline of a document (the symbol picker and the outline panel). Offsets are source offsets. */
+export interface OutlineSymbol {
+  id: string;
+  kind: "slide" | "section" | "asset" | "dataset" | "variable" | "reference" | "record";
+  /** `3. Highlights` for a slide, the id for an asset, `layout hero` for an embedded catalog record. */
+  label: string;
+  /** `layout cover` for a slide with a layout, the title of a dataset, the catalog group of a record. */
+  detail: string;
+  /** 1 for the entries under a section (assets, datasets, variables, references). */
+  depth: number;
+  from: number;
+  to: number;
+  line: number;
+}
+
 export interface SourcePaneOptions {
+  /** Add an Outline button to the bar and a panel listing the slides and other symbols of the document (`"open"` shows the panel at the start). The symbol picker (Cmd/Ctrl+Shift+O) is always there. */
+  outline?: boolean | "open";
+  /** Called with `getShortcuts()` when the shortcuts dialog is about to open; returning `true` means the host shows its own and the editor's dialog stays closed. */
+  onShowShortcuts?(shortcuts: Shortcut[]): boolean | void;
   /** The editor session. Every edit in any format reaches it as a patch (`applyPatch`), so it is validated and undoable. */
   editor: EditorSession;
   /** File name without extension (default `deck`). Spaces and slashes become `-`. */
@@ -75,6 +110,17 @@ export interface SourcePaneOptions {
   completions?: boolean;
   /** Enter continues a list: a new string item after a string in a JSON list, the next `- ` in YAML, the next marker (or `> `) in Markdown; an empty one ends it. Default true. */
   smartListEnter?: boolean;
+  /**
+   * Run the pane's text checks (reading YAML or Markdown, the syntax pass of JSON and the document validation) in a Web Worker, so typing in a deck
+   * of a thousand slides never blocks the main thread. A function returns the Worker (`() => new Worker(new URL("@openpresentation/opf-editor/source-worker", import.meta.url), { type: "module" })`
+   * with a bundler that supports that form); a Worker is used as given; `true` starts `source-worker.js` beside the package's own module, which works
+   * when a bundler follows `new URL(..., import.meta.url)`. Only the typing delay uses the worker: every explicit action (`getText`, switching the format,
+   * `replaceDocument`, Format, Undo) is applied on the main thread at once. When the worker cannot start, fails or stops answering, the pane checks on the
+   * main thread from then on and `onError` is called once; no edit is lost. Default `false` (everything on the main thread).
+   */
+  worker?: boolean | Worker | (() => Worker);
+  /** A preview for the card F12 and Alt+F12 open on a catalog record only the app provides (see `JsonCodeEditorOptions.resolvePreview`). */
+  resolvePreview?: (kind: string, id: string) => HTMLElement | string | undefined | Promise<HTMLElement | string | undefined>;
   onError?(error: unknown): void;
 }
 
@@ -136,8 +182,25 @@ export interface SourcePane {
   showProblem(index: number): boolean;
   /** Open the suggestion list at the caret, as Ctrl+Space does. */
   triggerCompletion(): boolean;
+  /**
+   * Every key binding the editor installed, for `platform` (default: the page's), grouped and titled as the shortcuts dialog shows them. The list is produced from the
+   * table that installs the keymap, so it cannot drift from the keys.
+   */
+  getShortcuts(platform?: ShortcutPlatform): Shortcut[];
+  /** Open the keyboard shortcuts dialog (the `?` button, F1, Cmd/Ctrl+K then Cmd/Ctrl+S). `onShowShortcuts` returning true replaces it with the host's own. */
+  showShortcuts(): boolean;
+  /** Open the symbol picker (Cmd/Ctrl+Shift+O). */
+  showSymbols(): boolean;
+  /** The outline of the text as it is now, in document order. Works on text that does not parse. */
+  getOutline(): OutlineSymbol[];
+  /** Show or hide the outline panel (needs the `outline` option); without an argument it toggles. Returns whether the panel is open. */
+  toggleOutline(open?: boolean): boolean;
   /** The underlying code editor (`mountJsonCodeEditor`). */
   readonly editor: JsonCodeEditor;
+  /** Resolves when no typed edit waits for its apply delay and no check (a worker's included) is running: the text on screen has been read and applied. */
+  whenIdle(): Promise<void>;
+  /** How the applied edits were checked: how many by the worker and how many on the main thread, and whether the worker can still be used. */
+  checkerStats(): { worker: number; inline: number; available: boolean };
   destroy(): void;
 }