@dxos/ui-editor 0.14.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/ui-editor",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "Text editor components.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -61,40 +61,40 @@
     "diff": "^8.0.3",
     "lodash.defaultsdeep": "^4.6.1",
     "lodash.sortby": "^4.7.0",
-    "@dxos/app-graph": "0.14.0",
-    "@dxos/async": "0.14.0",
-    "@dxos/client": "0.14.0",
-    "@dxos/context": "0.14.0",
-    "@dxos/display-name": "0.14.0",
-    "@dxos/echo": "0.14.0",
-    "@dxos/echo-client": "0.14.0",
-    "@dxos/echo-doc": "0.14.0",
-    "@dxos/invariant": "0.14.0",
-    "@dxos/keys": "0.14.0",
-    "@dxos/log": "0.14.0",
-    "@dxos/nlp": "0.14.0",
-    "@dxos/protocols": "0.14.0",
-    "@dxos/ui": "0.14.0",
-    "@dxos/ui-theme": "0.14.0",
-    "@dxos/ui-types": "0.14.0",
-    "@dxos/util": "0.14.0"
+    "@dxos/app-graph": "0.16.0",
+    "@dxos/async": "0.16.0",
+    "@dxos/client": "0.16.0",
+    "@dxos/context": "0.16.0",
+    "@dxos/display-name": "0.16.0",
+    "@dxos/echo": "0.16.0",
+    "@dxos/echo-client": "0.16.0",
+    "@dxos/echo-doc": "0.16.0",
+    "@dxos/invariant": "0.16.0",
+    "@dxos/keys": "0.16.0",
+    "@dxos/log": "0.16.0",
+    "@dxos/nlp": "0.16.0",
+    "@dxos/protocols": "0.16.0",
+    "@dxos/ui": "0.16.0",
+    "@dxos/ui-theme": "0.16.0",
+    "@dxos/ui-types": "0.16.0",
+    "@dxos/util": "0.16.0"
   },
   "devDependencies": {
     "@automerge/automerge": "3.5.0",
     "@types/lodash.defaultsdeep": "^4.6.6",
     "@types/lodash.sortby": "^4.7.7",
-    "effect": "4.0.0",
+    "effect": "4.0.4",
     "happy-dom": "^20.0.0",
     "jsdom": "^29.1.1",
-    "vite": "^8.2.2",
+    "vite": "^8.3.4",
     "vite-plugin-top-level-await": "^1.6.0",
     "vite-plugin-wasm": "^3.6.0",
-    "@dxos/echo": "0.14.0",
-    "@dxos/ui-theme": "0.14.0"
+    "@dxos/echo": "0.16.0",
+    "@dxos/ui-theme": "0.16.0"
   },
   "peerDependencies": {
-    "effect": "4.0.0",
-    "@dxos/ui-theme": "^0.14.0"
+    "effect": "4.0.4",
+    "@dxos/ui-theme": "^0.16.0"
   },
   "publishConfig": {
     "access": "public"

package/src/extensions/language/index.ts

@@ -6,4 +6,5 @@ export * from './datalog/index.ts';
 export * from './json/index.ts';
 export * from './markdown/index.ts';
 export * from './mermaid/index.ts';
+export * from './turtle/index.ts';
 export * from './xml/index.ts';

package/src/extensions/language/markdown/styles.ts

@@ -85,6 +85,8 @@ export const formattingStyles = EditorView.theme({
   // so constrain them to the target 24px height.
   '& .cm-code-inline': {
     fontFamily: fontMono,
+    // A step below the body text: a monospace face runs wider and taller than the prose at the same size.
+    fontSize: '0.9em',
     height: '24px',
     alignItems: 'center',
     overflow: 'hidden',

package/src/extensions/language/turtle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './turtle.ts';

package/src/extensions/language/turtle/turtle.test.ts

@@ -0,0 +1,106 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { highlightTree, tagHighlighter, tags } from '@lezer/highlight';
+import { describe, test } from 'vitest';
+
+import { highlightTurtle, turtleLanguage } from './turtle.ts';
+
+/** Class names per standard tag, so a token's colour is asserted by the tag the editor's theme would style. */
+const highlighter = tagHighlighter([
+  { tag: tags.lineComment, class: 'comment' },
+  { tag: tags.keyword, class: 'keyword' },
+  { tag: tags.url, class: 'iri' },
+  { tag: tags.namespace, class: 'prefix' },
+  { tag: tags.propertyName, class: 'name' },
+  { tag: tags.special(tags.variableName), class: 'blank' },
+  { tag: tags.string, class: 'string' },
+  { tag: tags.annotation, class: 'language' },
+  { tag: tags.typeOperator, class: 'datatype' },
+  { tag: tags.number, class: 'number' },
+  { tag: tags.bool, class: 'bool' },
+  { tag: tags.punctuation, class: 'terminator' },
+  { tag: tags.separator, class: 'separator' },
+  { tag: tags.squareBracket, class: 'bracket' },
+  { tag: tags.brace, class: 'brace' },
+  { tag: tags.invalid, class: 'invalid' },
+]);
+
+/** `[text, class]` for every highlighted span of `source`. */
+const tokenize = (source: string): [string, string][] => {
+  const spans: [string, string][] = [];
+  highlightTree(turtleLanguage.parser.parse(source), highlighter, (from, to, classes) => {
+    spans.push([source.slice(from, to), classes]);
+  });
+  return spans;
+};
+
+describe('turtle language', () => {
+  test('prefix declaration: keyword, prefix and IRI', ({ expect }) => {
+    expect(tokenize('@prefix sx: <https://dxos.org/semantic#> .')).toEqual([
+      ['@prefix', 'keyword'],
+      ['sx:', 'prefix'],
+      ['<https://dxos.org/semantic#>', 'iri'],
+      ['.', 'terminator'],
+    ]);
+  });
+
+  test('statement: prefixed names (a digit-led local name included), `a`, literals and separators', ({ expect }) => {
+    expect(tokenize('fact:3f2a a sx:Fact ; sx:quote "I own it"@en , 42 ; sx:ok true .')).toEqual([
+      ['fact:', 'prefix'],
+      ['3f2a', 'name'],
+      ['a', 'keyword'],
+      ['sx:', 'prefix'],
+      ['Fact', 'name'],
+      [';', 'separator'],
+      ['sx:', 'prefix'],
+      ['quote', 'name'],
+      ['"I own it"', 'string'],
+      ['@en', 'language'],
+      [',', 'separator'],
+      ['42', 'number'],
+      [';', 'separator'],
+      ['sx:', 'prefix'],
+      ['ok', 'name'],
+      ['true', 'bool'],
+      ['.', 'terminator'],
+    ]);
+  });
+
+  test('TriG graph block, typed literal, blank node and comment', ({ expect }) => {
+    expect(tokenize('g1:graph { _:b1 prov:at "2026"^^xsd:dateTime . } # done')).toEqual([
+      ['g1:', 'prefix'],
+      ['graph', 'name'],
+      ['{', 'brace'],
+      ['_:b1', 'blank'],
+      ['prov:', 'prefix'],
+      ['at', 'name'],
+      ['"2026"', 'string'],
+      ['^^', 'datatype'],
+      ['xsd:', 'prefix'],
+      ['dateTime', 'name'],
+      ['.', 'terminator'],
+      ['}', 'brace'],
+      ['# done', 'comment'],
+    ]);
+  });
+
+  test('a long string spans lines', ({ expect }) => {
+    expect(tokenize('sx:q """one\ntwo""" .')).toEqual([
+      ['sx:', 'prefix'],
+      ['q', 'name'],
+      ['"""one', 'string'],
+      ['two"""', 'string'],
+      ['.', 'terminator'],
+    ]);
+  });
+
+  test('highlightTurtle splits spans by line and keeps every character', ({ expect }) => {
+    const source = 'fact:f1 {\n  entity:a dx:b "c" .\n}';
+    const lines = highlightTurtle(source, highlighter);
+    expect(lines).toHaveLength(3);
+    expect(lines.map((spans) => spans.map((span) => span.text).join('')).join('\n')).toBe(source);
+    expect(lines[1]).toContainEqual({ text: '"c"', classes: 'string' });
+  });
+});

package/src/extensions/language/turtle/turtle.ts

@@ -0,0 +1,183 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { LanguageSupport, StreamLanguage, type StringStream } from '@codemirror/language';
+import { type Highlighter, type Tag, highlightCode, tags } from '@lezer/highlight';
+
+/** Token names emitted by the tokenizer, mapped to standard tags so the editor's highlight style colours them. */
+const tokenTable = {
+  comment: tags.lineComment,
+  // `@prefix`, `@base`, `PREFIX`, `BASE`, `GRAPH` and `a` (`rdf:type`).
+  keyword: tags.keyword,
+  iri: tags.url,
+  // The `sx` of `sx:quote`; the local name after the colon is the `name`.
+  prefix: tags.namespace,
+  name: tags.propertyName,
+  blank: tags.special(tags.variableName),
+  string: tags.string,
+  language: tags.annotation,
+  datatype: tags.typeOperator,
+  number: tags.number,
+  bool: tags.bool,
+  terminator: tags.punctuation,
+  separator: tags.separator,
+  bracket: tags.squareBracket,
+  paren: tags.paren,
+  // TriG's graph blocks.
+  brace: tags.brace,
+  invalid: tags.invalid,
+} satisfies Record<string, Tag>;
+
+export type TurtleToken = keyof typeof tokenTable;
+
+type TurtleState = {
+  /** The delimiter of a long string (`"""` or `'''`) that spans lines. */
+  long?: string;
+  /** The last token was a prefix, so a local name follows directly, even one a number would otherwise claim. */
+  local: boolean;
+};
+
+const PUNCTUATION: Record<string, TurtleToken | undefined> = {
+  '.': 'terminator',
+  ';': 'separator',
+  ',': 'separator',
+  '[': 'bracket',
+  ']': 'bracket',
+  '(': 'paren',
+  ')': 'paren',
+  '{': 'brace',
+  '}': 'brace',
+};
+
+const KEYWORDS = /^(?:PREFIX|BASE|GRAPH)\b/i;
+// PN_PREFIX ':' PN_LOCAL, loosely: a local name may hold dots and dashes but does not end in a dot.
+const PREFIXED_NAME = /^([A-Za-z][\w.-]*)?:/;
+const LOCAL_NAME = /^(?:[\w\-%]|\.(?=[\w\-%]))+/;
+
+const skipLongString = (stream: StringStream, state: TurtleState): TurtleToken => {
+  const delimiter = state.long ?? '"""';
+  if (stream.skipTo(delimiter)) {
+    stream.pos += delimiter.length;
+    state.long = undefined;
+  } else {
+    stream.skipToEnd();
+  }
+  return 'string';
+};
+
+const token = (stream: StringStream, state: TurtleState): TurtleToken | null => {
+  if (state.long) {
+    return skipLongString(stream, state);
+  }
+  if (state.local) {
+    state.local = false;
+    if (stream.match(LOCAL_NAME)) {
+      return 'name';
+    }
+  }
+  if (stream.eatSpace()) {
+    return null;
+  }
+  if (stream.match('#')) {
+    stream.skipToEnd();
+    return 'comment';
+  }
+
+  const long = stream.match('"""') ? '"""' : stream.match("'''") ? "'''" : undefined;
+  if (long) {
+    state.long = long;
+    return skipLongString(stream, state);
+  }
+  const quote = stream.peek();
+  if (quote === '"' || quote === "'") {
+    stream.next();
+    let escaped = false;
+    let char: string | void;
+    while ((char = stream.next()) != null) {
+      if (char === quote && !escaped) {
+        return 'string';
+      }
+      escaped = !escaped && char === '\\';
+    }
+    return 'invalid';
+  }
+
+  if (stream.match(/^<[^<>"{}|^`\\\s]*>/)) {
+    return 'iri';
+  }
+  if (stream.match(/^@(?:prefix|base)\b/)) {
+    return 'keyword';
+  }
+  // A language tag follows its string directly (`"Founder"@en`).
+  if (stream.match(/^@[A-Za-z]+(?:-[A-Za-z0-9]+)*/)) {
+    return 'language';
+  }
+  if (stream.match('^^')) {
+    return 'datatype';
+  }
+  if (stream.match(/^_:[\w.-]*\w/)) {
+    return 'blank';
+  }
+  if (stream.match(/^[+-]?(?:\d+\.?\d*(?:[eE][+-]?\d+)?|\.\d+(?:[eE][+-]?\d+)?)/)) {
+    return 'number';
+  }
+  if (stream.match(/^(?:true|false)\b/)) {
+    return 'bool';
+  }
+  if (stream.match(KEYWORDS)) {
+    return 'keyword';
+  }
+  if (stream.match(/^a(?=[\s<[(_"'])/)) {
+    return 'keyword';
+  }
+  if (stream.match(PREFIXED_NAME)) {
+    // The prefix and its colon; the local name, if any, is the next token.
+    state.local = true;
+    return 'prefix';
+  }
+  if (stream.match(LOCAL_NAME)) {
+    return 'name';
+  }
+
+  const char = stream.next();
+  return (char ? PUNCTUATION[char] : undefined) ?? 'invalid';
+};
+
+/** RDF 1.1 Turtle, and TriG's `{ … }` graph blocks, which Turtle's tokens cover otherwise. */
+export const turtleLanguage = StreamLanguage.define<TurtleState>({
+  name: 'turtle',
+  startState: () => ({ local: false }),
+  copyState: (state) => ({ ...state }),
+  token,
+  tokenTable,
+  languageData: {
+    commentTokens: { line: '#' },
+    closeBrackets: { brackets: ['(', '[', '{', '"', "'", '<'] },
+  },
+});
+
+/** Turtle (and TriG) language support; pair with the theme's syntax highlighting to colour it. */
+export const turtle = (): LanguageSupport => new LanguageSupport(turtleLanguage);
+
+/** A run of source text and the classes the highlighter gave it (empty when unstyled). */
+export type HighlightedSpan = { text: string; classes: string };
+
+/**
+ * Highlights Turtle or TriG without an editor, one array of spans per line, for read-only snippets where mounting
+ * a CodeMirror view per snippet would cost too much.
+ */
+export const highlightTurtle = (
+  source: string,
+  highlighter: Highlighter | readonly Highlighter[],
+): HighlightedSpan[][] => {
+  const lines: HighlightedSpan[][] = [[]];
+  highlightCode(
+    source,
+    turtleLanguage.parser.parse(source),
+    highlighter,
+    (text, classes) => lines[lines.length - 1].push({ text, classes }),
+    () => lines.push([]),
+  );
+  return lines;
+};

package/src/extensions/state/selection.test.ts

@@ -2,10 +2,78 @@
 // Copyright 2026 DXOS.org
 //
 
+import { EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
 import * as Schema from 'effect/Schema';
-import { describe, test } from 'vitest';
+import { describe, onTestFinished, test } from 'vitest';
 
-import { EditorSelectionStateSchema } from './selection.ts';
+import {
+  type EditorSelectionState,
+  EditorSelectionStateSchema,
+  documentId,
+  restoreEditorState,
+  selectionState,
+} from './selection.ts';
+
+const DOC_ID = 'doc';
+
+/** Mounts a view whose recorder writes into `store`. */
+const createRecordingView = (store: Map<string, EditorSelectionState>) => {
+  const parent = document.createElement('div');
+  document.body.append(parent);
+  const view = new EditorView({
+    parent,
+    state: EditorState.create({
+      doc: 'line one\nline two\nline three\n',
+      extensions: [
+        documentId.of(DOC_ID),
+        selectionState({ getState: (id) => store.get(id), setState: (id, state) => store.set(id, state) }),
+      ],
+    }),
+  });
+  // happy-dom has no layout, so pin the top-of-viewport position the recorder measures.
+  view.posAtCoords = () => 0;
+  onTestFinished(() => {
+    view.destroy();
+    parent.remove();
+  });
+  return view;
+};
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+describe('selectionState', () => {
+  const restored: EditorSelectionState = { scrollTo: 12, scrollOffset: 3, selection: { anchor: 15, head: 15 } };
+
+  test('records the caret after a change', async ({ expect }) => {
+    const store = new Map<string, EditorSelectionState>();
+    const view = createRecordingView(store);
+    view.dispatch({ selection: { anchor: 4 } });
+    await sleep(1_200);
+    expect(store.get(DOC_ID)?.selection).toEqual({ anchor: 4, head: 4 });
+  });
+
+  // The content fill at mount records the top of the document; that write must not land over the
+  // state the restore just applied, or the next visit opens at the top.
+  test('a restore cancels a write queued before it', async ({ expect }) => {
+    const store = new Map<string, EditorSelectionState>([[DOC_ID, restored]]);
+    const view = createRecordingView(store);
+    view.dispatch({ selection: { anchor: 2 } });
+    await sleep(50);
+    restoreEditorState(view, restored);
+    await sleep(1_200);
+    expect(store.get(DOC_ID)).toEqual(restored);
+  });
+
+  test('a measurement requested before a restore is not written after it', async ({ expect }) => {
+    const store = new Map<string, EditorSelectionState>([[DOC_ID, restored]]);
+    const view = createRecordingView(store);
+    view.dispatch({ selection: { anchor: 2 } });
+    restoreEditorState(view, restored);
+    await sleep(1_200);
+    expect(store.get(DOC_ID)).toEqual(restored);
+  });
+});
 
 describe('EditorSelectionStateSchema', () => {
   test('encode/decode preserves the legacy serialized shape', ({ expect }) => {

package/src/extensions/state/selection.ts

@@ -7,7 +7,6 @@ import { EditorView, keymap } from '@codemirror/view';
 import * as Schema from 'effect/Schema';
 import * as Struct from 'effect/Struct';
 
-import { debounce } from '@dxos/async';
 import { isTruthy } from '@dxos/util';
 
 import { singleValueFacet } from '../../util/index.ts';
@@ -50,6 +49,9 @@ const stateRestoreAnnotation = 'org.dxos.cm.state-restore';
 /** Window after a restore during which scroll events are not recorded. */
 const RESTORE_SUPPRESS_MS = 500;
 
+/** Delay before a recorded state is written to the store. */
+const RECORD_DELAY_MS = 1_000;
+
 /** Dedupes the recorder's measure requests: CodeMirror keeps one request per key until its measure phase runs. */
 const recordKey = {};
 
@@ -105,7 +107,13 @@ export const restoreEditorState = (view: EditorView, state: EditorSelectionState
  * Track scrolling and selection state to be restored when switching to document.
  */
 export const selectionState = ({ getState, setState }: Partial<EditorStateStore> = {}): Extension => {
-  const setStateDebounced = debounce(setState!, 1_000);
+  // Debounced by hand so a restore can cancel a write queued before it: the binding's content fill at
+  // mount records the top-of-document position, which would otherwise overwrite the stored state.
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const cancelPending = () => {
+    clearTimeout(timer);
+    timer = undefined;
+  };
 
   // A restore dispatches its own scroll, which would immediately record a position measured
   // before the document has finished laying out; ignore scroll events for a beat afterwards.
@@ -132,9 +140,15 @@ export const selectionState = ({ getState, setState }: Partial<EditorStateStore>
       return { scrollTo: pos, scrollOffset, selection: { anchor, head } };
     },
     write: (state: EditorSelectionState | undefined, view: EditorView) => {
+      // CodeMirror reads measure requests before applying a pending scroll target, so a request queued
+      // before a restore measures the pre-restore viewport.
+      if (performance.now() < suppressUntil) {
+        return;
+      }
       const id = view.state.facet(documentId);
-      if (state && id) {
-        setStateDebounced(id, state);
+      if (state && id && setState) {
+        cancelPending();
+        timer = setTimeout(() => setState(id, state), RECORD_DELAY_MS);
       }
     },
   };
@@ -156,6 +170,7 @@ export const selectionState = ({ getState, setState }: Partial<EditorStateStore>
     EditorView.updateListener.of(({ view, transactions }) => {
       if (transactions.some((tr) => tr.isUserEvent(stateRestoreAnnotation))) {
         suppressUntil = performance.now() + RESTORE_SUPPRESS_MS;
+        cancelPending();
         return;
       }
 

package/src/extensions/widgets/object-links.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2026 DXOS.org
 //
 
-import { forceParsing } from '@codemirror/language';
+import { forceParsing, syntaxTree } from '@codemirror/language';
 import { EditorState } from '@codemirror/state';
 import { EditorView, WidgetType } from '@codemirror/view';
 import { describe, test } from 'vitest';
@@ -134,6 +134,22 @@ describe('objectLinks', () => {
     view.destroy();
   });
 
+  // Background parsing extends the tree in steps with no document change, and a parse that runs out
+  // of time fills skipped ranges in as they scroll into view; each step must decorate what it parsed.
+  test('widgets follow a parse that advances without a document change', async ({ expect }) => {
+    const doc = Array.from({ length: 4_000 }, (_, i) => `See [x](eid:${i}) ${'and more text '.repeat(15)}\n\n`).join(
+      '',
+    );
+    const view = createView(doc, { link: recording });
+    const initial = decorations(view).length;
+    const parsed = syntaxTree(view.state).length;
+    await expect.poll(() => syntaxTree(view.state).length, { timeout: 10_000 }).toBeGreaterThan(parsed);
+    await flush();
+    expect(syntaxTree(view.state).length).toBeLessThan(doc.length);
+    expect(decorations(view).length).toBeGreaterThan(initial);
+    view.destroy();
+  });
+
   // The Component (StubWidget) branch the app uses — asserts the portal host mounts too.
   test('component-backed block widget builds and mounts on first render', async ({ expect }) => {
     let widgets: WidgetState[] = [];

package/src/extensions/widgets/widgets.ts

@@ -8,7 +8,7 @@
 // host renders portals from, widget state and context effects, and bookmark navigation. What is
 // matched is a matcher's business: `xmlTags` claims XML elements, `objectLinks` object links.
 
-import { ensureSyntaxTree, syntaxTree, syntaxTreeAvailable } from '@codemirror/language';
+import { ensureSyntaxTree, syntaxTree } from '@codemirror/language';
 import {
   type EditorState,
   type Extension,
@@ -435,7 +435,7 @@ type WidgetDecorationSet = {
   notifier: WidgetNotifier;
 };
 
-/** Ceiling on parsing ahead of the background parser; past it `parseCompletionPlugin` rebuilds. */
+/** Ceiling on parsing ahead of the background parser; past it `parseProgressPlugin` rebuilds. */
 const PARSE_BUDGET = 50;
 
 /**
@@ -637,25 +637,26 @@ const scrollJumpMonitor = (() => {
 })();
 
 /**
- * Re-decorate once the whole document has parsed. `StateField.create` (and incremental rebuilds) only
- * see the syntax tree parsed so far, so a block past CodeMirror's initial background-parse window is
- * not decorated until some later transaction — previously it appeared only after the first edit. This
- * dispatches a one-shot rebuild when the full tree becomes available (re-armed on each edit).
+ * Re-decorate whenever the syntax tree changes. `StateField.create` (and incremental rebuilds) see
+ * only the tree parsed so far: background parsing extends it later, and a parse that runs out of time
+ * skips ranges outside the viewport and parses them as they scroll in, neither with a document change.
+ * Edits rebuild too: the incremental merge duplicates a widget appended after the last one (see the
+ * `xml-tags` invariant tests), and this rebuild settles it. Rebuilds within one task coalesce.
  */
-const parseCompletionPlugin = ViewPlugin.fromClass(
+const parseProgressPlugin = ViewPlugin.fromClass(
   class {
-    #rebuiltForLength = -1;
+    #pending = false;
 
     update(update: ViewUpdate) {
-      if (update.docChanged) {
-        this.#rebuiltForLength = -1;
-      }
-      const length = update.state.doc.length;
-      if (this.#rebuiltForLength !== length && syntaxTreeAvailable(update.state, length)) {
-        this.#rebuiltForLength = length;
-        // Defer: cannot dispatch during an update.
-        queueMicrotask(() => update.view.dispatch({ effects: widgetRebuildEffect.of(null) }));
+      if (this.#pending || syntaxTree(update.startState) === syntaxTree(update.state)) {
+        return;
       }
+      this.#pending = true;
+      // Defer: cannot dispatch during an update.
+      queueMicrotask(() => {
+        this.#pending = false;
+        update.view.dispatch({ effects: widgetRebuildEffect.of(null) });
+      });
     }
   },
 );
@@ -798,7 +799,7 @@ export const widgetsCore: Extension = [
   widgetStateMapStateField,
   widgetDecorationsField,
   widgetUpdatePlugin,
-  parseCompletionPlugin,
+  parseProgressPlugin,
   navigationEffectPlugin,
   keyHandlers,
   scrollJumpMonitor,