weml-monaco 0.5.2 → 0.6.0

package/CHANGELOG.md

@@ -8,6 +8,16 @@ This package mirrors the language logic of the VS Code extension; entries below
 track the port catching up with the VS Code provider changes (see the root
 `CHANGELOG.md` for the extension).
 
+## [0.6.0] — 2026-10-06
+
+### Added
+- `registerWemlWorker` (`weml-monaco/worker`) and the worker module
+  (`weml-monaco/weml.worker`): the same language with completion, hover, outline
+  and diagnostics computed in a Web Worker, so typing in a large document no
+  longer waits for a full parse per keystroke. The worker mirrors models from
+  their edits and answers only the current version of a model. `registerWeml`
+  and the global build are unchanged.
+
 ## [0.5.2] — 2026-09-26
 
 ### Added

package/README.md

@@ -99,6 +99,48 @@ formatter directly, call `formatWemlText(source)`.
 Structural validation failures are also available through
 `isWemlStructureValidationFailure(error)` and include a code, line and column.
 
+## Analysis in a Web Worker
+
+`registerWeml` runs completion, hover, outline and diagnostics on the main
+thread, and each of them parses the whole document for every new model version.
+On a large file — a whole book, a megabyte and more — that is tens of
+milliseconds per keystroke on the thread that handles the keystrokes, and typing
+falls behind. `registerWemlWorker` registers the same language with that work in
+a Web Worker:
+
+```ts
+import * as monaco from 'monaco-editor/editor/editor.api.js';
+import { registerWemlWorker } from 'weml-monaco/worker';
+import WemlWorker from 'weml-monaco/weml.worker?worker'; // Vite
+
+const disposable = registerWemlWorker(monaco, { worker: () => new WemlWorker() });
+// Without Vite's `?worker`:
+// registerWemlWorker(monaco, {
+//     worker: () => new Worker(new URL('weml-monaco/weml.worker', import.meta.url), { type: 'module' }),
+// });
+```
+
+It is an addition, not a replacement: `registerWeml` is unchanged, and an
+application chooses one of the two (registering both doubles every provider).
+The worker runs the very providers `registerWeml` registers, so suggestions,
+hovers, outline and markers are the same; only where they are computed changes.
+
+- The worker mirrors each `weml` model's text and keeps it current from the
+  edits Monaco reports — the main thread never sends the whole text again.
+- A request is answered only for the model's current version: one overtaken by
+  further typing is answered empty without parsing, so holding a key down does
+  not build up a queue of parses.
+- Markers computed for a version the model has since left are dropped.
+- The tokenizer, language configuration and formatting stay on the main thread,
+  as with `registerWeml` — they are cheap or run on demand.
+- `weml-monaco/weml.worker` imports nothing of Monaco at runtime; it needs a
+  bundler (or a module worker) to load, and is ESM only.
+
+`registerWemlWorker(monaco, options)` takes the options of `registerWeml` plus
+`worker`, a function that starts the worker (called once; the worker is
+terminated on `dispose()`). The global `<script>` build (`index.global.js`) has
+no worker variant.
+
 ## Toolbar & editor commands
 
 Monaco has no webview panels, so the VS Code toolbar is ported as a **DOM top

package/dist/weml.worker.d.mts

@@ -0,0 +1,2 @@
+
+export {  }