@citisen/litearea 0.1.0 → 0.2.1

package/dist/types/core/types.d.ts

@@ -36,9 +36,9 @@ export interface Token extends Range {
  * tokens and they are deliberately not tokens here.
  *
  * The distinction earns its keep. A token is what the *characters* are; a
- * decoration is what they *mean*, and the two change on different schedules. The
- * font-query grammar paints `Geist Mono` as a family from the characters alone,
- * but which family is *in effect* depends on the installed catalogue — the same
+ * decoration is what they *mean*, and the two change on different schedules. A
+ * grammar can paint `Geist Mono` as a family from the characters alone, but which
+ * family is *in effect* depends on a catalogue the HOST supplied — the same
  * characters mean something else on another machine. Painting that as a token
  * would mean re-lexing the document whenever the catalogue changed; painting it
  * as a decoration means recomputing one range list, which is what it is.
@@ -431,8 +431,8 @@ export interface CompletionContext<State = unknown> {
      * `runn|` is no longer "at the start of the line" in the strict sense, but it is
      * unmistakably completing the first word. A source that asked `firstOnLine` would
      * switch itself off after the very first keystroke — which is exactly the bug this
-     * field was added to fix, and exactly the kind of thing a reference grammar is
-     * for finding.
+     * field was added to fix, and exactly the kind of thing a grammar written against
+     * a real document is for finding.
      */
     firstWord: boolean;
     /** The first non-whitespace token on the caret's line, when there is one. */

package/dist/types/dom/editor.d.ts

@@ -31,9 +31,14 @@ export interface LiteAreaCompletion {
     /**
      * Characters that open the list in addition to word characters.
      *
-     * Default `' '`, and that default is doing real work: both reference languages
-     * put a value after a name, so a space is exactly where the next word becomes
-     * guessable.
+     * Empty by default, because a separator is the wrong moment to interrupt: it is
+     * where the next token starts, which is the argument FOR opening there, and it
+     * loses to the habit every reader already has — the editor this is modelled on
+     * offers nothing on a space and waits for a letter or for `Ctrl+Space`. Nothing
+     * is stranded by that. The list stays open once it is open, so a value typed
+     * after a name is still filtered in place, and `Ctrl+Space` opens it on demand.
+     * Set it to `' '` or `','` for a language where a separator really is where the
+     * next token becomes guessable.
      */
     triggerCharacters?: string;
     /** The most rows to offer. Default 100. */

package/dist/types/dom/editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../../src/dom/editor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../../src/dom/editor.ts"],"names":[],"mappings":"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"}

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAeA,YAAY,EACV,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,eAAe,EACf,UAAU,EACV,OAAO,EACP,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,SAAS,EACT,KAAK,EACL,UAAU,EACV,kBAAkB,EAClB,IAAI,EACJ,WAAW,EACX,SAAS,EACT,KAAK,EACL,SAAS,EACT,QAAQ,EACR,cAAc,EACd,KAAK,EACL,iBAAiB,EACjB,eAAe,EACf,QAAQ,EACR,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAA;AAExB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEpE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAEpE,OAAO,EACL,KAAK,EACL,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,MAAM,EACN,WAAW,EACX,UAAU,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,WAAW,EACX,YAAY,EACZ,UAAU,GACX,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,KAAK,cAAc,GACpB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,IAAI,EACJ,KAAK,eAAe,EACpB,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAElF,OAAO,EACL,aAAa,EACb,cAAc,GACf,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,MAAM,EACX,KAAK,WAAW,GACjB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,eAAe,EACf,QAAQ,EACR,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,GACvB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE/D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEnE,OAAO,EACL,eAAe,EACf,eAAe,EACf,YAAY,EACZ,UAAU,EACV,aAAa,GACd,MAAM,aAAa,CAAA;AAEpB,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAgBA,YAAY,EACV,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,eAAe,EACf,UAAU,EACV,OAAO,EACP,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,SAAS,EACT,KAAK,EACL,UAAU,EACV,kBAAkB,EAClB,IAAI,EACJ,WAAW,EACX,SAAS,EACT,KAAK,EACL,SAAS,EACT,QAAQ,EACR,cAAc,EACd,KAAK,EACL,iBAAiB,EACjB,eAAe,EACf,QAAQ,EACR,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAA;AAExB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEpE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAEpE,OAAO,EACL,KAAK,EACL,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,MAAM,EACN,WAAW,EACX,UAAU,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,WAAW,EACX,YAAY,EACZ,UAAU,GACX,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,KAAK,cAAc,GACpB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,IAAI,EACJ,KAAK,eAAe,EACpB,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAElF,OAAO,EACL,aAAa,EACb,cAAc,GACf,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,MAAM,EACX,KAAK,WAAW,GACjB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,eAAe,EACf,QAAQ,EACR,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,GACvB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE/D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEnE,OAAO,EACL,eAAe,EACf,eAAe,EACf,YAAY,EACZ,UAAU,EACV,aAAa,GACd,MAAM,aAAa,CAAA;AAEpB,cAAc,gBAAgB,CAAA"}

package/docs/architecture.md

@@ -265,11 +265,15 @@ of them are exactly why `scripts/browser-check.mjs` exists: a textarea's undo
 stack has no API to read and no way to fake, so the only honest test is to make an
 edit and undo it in a browser that has a real one.
 
-The harness bundles the **shipped** `dist/` files rather than `src/` — so what it
-drives is the artifact a host installs — inlines them as an IIFE (Chromium refuses
-to fetch an ES module from a `file://` URL), and drives the public API and the
-public DOM only: it mounts editors, types through `execCommand('insertText')`,
-presses keys, dispatches a `mousedown` on a row, and hovers a squiggle. The page
+The harness bundles the **shipped** `dist/index.js` — the package's one JavaScript
+entry point — rather than `src/`, so what it drives is the artifact a host
+installs, and it inlines it as an IIFE (Chromium refuses to fetch an ES module
+from a `file://` URL). The language the checks run against is defined inside the
+checklist itself, because the package ships none: proving that a particular
+product DSL works in a browser belongs beside the plugin that owns it, while the
+questions here are all about the engine. It drives the public API and the public
+DOM only: it mounts editors, types through `execCommand('insertText')`, presses
+keys, dispatches a `mousedown` on a row, and hovers a squiggle. The page
 reports through `document.title`, with `error` and `unhandledrejection` listeners
 that write to the same channel, because a page whose only output channel is its
 title has to report its own failures through that channel — otherwise a syntax
@@ -311,6 +315,6 @@ again", which is all most hosts need.
 | `contenteditable` | It makes the document a DOM tree that the browser edits in ways you do not control — nested elements, `<br>` for a blank line, pasted HTML — so the value would have to be re-serialised on every keystroke, which is the same re-render problem with more failure modes and no native undo semantics worth having |
 | A second highlighting layer per range list (one for scopes, one for decorations, one for squiggles) | Each layer would have to position its own spans, so each would need its own idea of where a range starts, and a span positioned by measuring drifts as soon as the font, the wrapping, or the padding is even slightly different from what was measured. One merged stream cannot drift because nothing is positioned |
 | Measuring the live field (`scrollHeight` after collapsing it) | It reflows the page and flickers on every keystroke — the measurement that is supposed to decide the height is what makes the height unstable. The offscreen mirror pays one extra layout and keeps the field's geometry out of the question |
-| A bundled grammar (a default language, or a language registry) | The claim of the library is that the core knows no syntax. A default grammar would make that claim false, and it would be the thing every host inherited. The two reference grammars are importable and deliberately outside `src/core/` |
+| A bundled grammar (a default language, or a language registry) | The claim of the library is that the core knows no syntax. A default grammar would make that claim false, and it would be the thing every host inherited. The package therefore ships no grammar at all: a DSL lives beside the plugin that owns it and is handed to the editor as a value |
 | Synthetic `beforeinput`/`InputEvent` edits | Untrusted, so the browser will not run them through the editing pipeline: the text changes and the history does not, which is worse than a documented `'direct'` fallback because it fails silently |
 | Tracking the caret as a character index in one module and a screen position in another | Every position that crosses a module boundary is a character offset; pixels enter only in `src/dom/`, only to place a floating element, and never travel back inward. Two coordinate systems for one caret is what produced the range that "had already moved" |

package/docs/completion.md

@@ -34,7 +34,7 @@ two bugs that make a completer feel broken have somewhere to live:
 | Event | What happens |
 | --- | --- |
 | A word character is typed | The list opens, in `'auto'` mode. The predicate is the grammar's `wordChars` |
-| A character typed through `triggerCharacters` | The list opens, in `'auto'` mode. Default `' '`, and that default is doing real work: a value usually follows a name, so a space is exactly where the next word becomes guessable |
+| A character typed through `triggerCharacters` | Also opens it, in `'auto'` mode. **Empty by default**, so a separator does not open the list — see below |
 | More characters are typed while the list is open | Re-resolved: the same source answers again if it is still eligible, the range is recomputed from the caret, and the rows are re-filtered |
 | A character is deleted while the list is open | Re-filtered. A backspace with no list open opens nothing, because a deletion is not a request for suggestions |
 | `Ctrl+Space` / `Cmd+Space` | Opens with no needle (`'explicit'`), or closes the list when it is already open |
@@ -45,6 +45,14 @@ two bugs that make a completer feel broken have somewhere to live:
 | The editor itself is writing | Nothing re-opens: the editor knows its own edit from the user's |
 | Any `input` event while `readOnly` | Nothing |
 
+`triggerCharacters` is empty by default, so a separator does not open the list. A
+space is where the next token starts, which is the argument for opening there,
+and it loses to the habit a reader already has: the editor this is modelled on
+offers nothing on a space and waits for a letter or for `Ctrl+Space`. Nothing is
+stranded by it — the list stays open while the next token is typed, so a value
+after a name is still suggested in place — and a language whose separator really
+is the moment the next token becomes guessable names it explicitly.
+
 `auto: false` (or `completion: false` on the editor) switches off every row above
 except `Ctrl+Space`, `Escape`, and the arrows; `showCompletions()` and
 `hideCompletions()` drive the same open and close by hand, and `currentCompletion`
@@ -163,9 +171,9 @@ eligible while that head is being spelled out. `runn\|` is no longer "at the sta
 of the line" in the strict sense — the line already has content — but it is
 unmistakably completing the first word. A source that asked `firstOnLine` would
 switch itself off after the very first keystroke, which is the bug the second field
-exists to prevent. `dshSentryStyleGrammar` asks `firstWord` for exactly this
-reason, and it is the difference between a list that helps and a list that keeps
-disappearing.
+exists to prevent. A line-oriented grammar's first-word completion asks
+`firstWord` for exactly this reason, and it is the difference between a list that
+helps and a list that keeps disappearing.
 
 ## Ranking
 
@@ -276,7 +284,7 @@ default would be guessing about every other language.
 
 | VSCode | litearea |
 | --- | --- |
-| Typing triggers suggestions | A word character or one of `triggerCharacters` (default `' '`) opens the list; `auto: false` turns it off |
+| Typing triggers suggestions | A word character or one of `triggerCharacters` (empty by default) opens the list; `auto: false` turns it off |
 | `Ctrl+Space` | `Ctrl+Space`/`Cmd+Space` opens on demand, and closes when the list is already open |
 | Typing filters the list | The needle is the text between the source's current range start and the caret, matched fuzzily |
 | `Enter` accepts | `Enter` accepts the active row |

package/docs/grammar.md

@@ -76,9 +76,9 @@ A function is handed everything a lexical decision could need:
 | `state` | Whatever `analyze` returned |
 
 The `state` field is the one that earns the function form: it is how a scope can
-depend on something the characters do not say. `dshFontQueryGrammar` uses it to
-paint a weight word as `weight` or `weight.missing`, which depends on the
-machine's installed faces, not on the word.
+depend on something the characters do not say. A grammar for a host's installed
+fonts uses it to paint a weight word as `weight` or `weight.missing`, which
+depends on the faces the host reported, not on the word.
 
 ### `match`: a regular expression
 
@@ -116,7 +116,7 @@ states the host actually has — costs one call, not one per token.
 
 | Field | Default | Notes |
 | --- | --- | --- |
-| `max` | 4 | The most words one entry may span. A span longer than `max` is never attempted, and four covers every family in the shipped catalogue (`Source Han Serif SC` is four) |
+| `max` | 4 | The most words one entry may span. A span longer than `max` is never attempted, and four covers a name like `Source Han Serif SC`, which is four words |
 
 The engine tries the longest span first and keeps the longest member it finds, so
 a catalogue holding both `IBM Plex` and `IBM Plex Mono` resolves the longer name.
@@ -346,10 +346,10 @@ decides three things at once:
 3. **Where a double click puts the selection**, because that is the platform's
    own word test and the browser uses the same notion of a word the field does.
 
-A language whose names contain a dot or a hyphen must say so. `dshFontQueryGrammar`
-uses `/[\p{L}\p{N}_-]/u` so `-apple-system` is one word; `dshSentryStyleGrammar`
-deliberately does *not* include `.`, so a stray `circle.` is not read as one
-unknown word and reported as a name the user never typed.
+A language whose names contain a dot or a hyphen must say so. A font query uses
+`/[\p{L}\p{N}_-]/u` so `-apple-system` is one word; a grammar whose names never
+contain a dot leaves it out, so a stray `circle.` is not read as one unknown word
+and reported as a name the user never typed.
 
 The flags are normalised: `g` and `y` are stripped from the predicate, because
 `RegExp.prototype.test` advances `lastIndex` on a global pattern and a predicate
@@ -442,7 +442,8 @@ diagnostic's `source` is always the grammar's `id`.
 
 `report` is also the place a structural walk that ran in `analyze` publishes what
 it found — record the ranges while the structure is known, and report them here.
-Both reference grammars do exactly that.
+That is the usual arrangement: `analyze` decides what is wrong and `validate`
+hands the ranges over.
 
 ### Codes and severities
 
@@ -476,12 +477,12 @@ detail and the body. Decorations are clamped into the document, dropped when the
 come out empty, and sorted — a grammar computing them from a stale parse cannot
 paint a span nobody can see.
 
-The font grammar's "in effect" pill is the worked case. `Geist Mono` is painted as
-a family from the characters alone — that is a token. Which family is *in effect*
-depends on the machine's installed catalogue, so the same characters mean
-something else on another computer. Painting that as a token would mean re-lexing
-the document whenever the catalogue changed; as a decoration it is one recomputed
-range list, which is what it actually is.
+A host's "in effect" mark is the worked case. `Geist Mono` is painted as a family
+from the characters alone — that is a token. Which family is *in effect* depends
+on the host's installed catalogue, so the same characters mean something else on
+another computer. Painting that as a token would mean re-lexing the document
+whenever the catalogue changed; as a decoration it is one recomputed range list,
+which is what it actually is.
 
 Reach for `decorate` when the mark depends on something outside the document. If
 nothing in your language does, do not add one — a decoration that could have been

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@citisen/litearea",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "A lightweight textarea-based code editor: native undo/redo, fully custom syntax highlighting, VSCode-style completion, diagnostics, and hover tooltips. No CodeMirror, no Monaco.",
   "type": "module",
   "license": "MIT",
@@ -27,11 +27,6 @@
       "import": "./dist/react.js",
       "require": "./dist/react.cjs"
     },
-    "./grammars": {
-      "types": "./dist/types/grammars/index.d.ts",
-      "import": "./dist/grammars.js",
-      "require": "./dist/grammars.cjs"
-    },
     "./styles.css": "./dist/styles.css",
     "./package.json": "./package.json"
   },

package/scripts/browser-check.mjs

@@ -20,6 +20,12 @@
  * 4. **Auto-sizing.** Whether a box has a scrollbar is `scrollHeight` against
  *    `clientHeight`, measured after a real layout.
  *
+ * The checks are about the ENGINE, so the language they run against is a FIXTURE
+ * defined inside the checklist itself. The package ships no syntax and no grammar
+ * to import: a harness that borrowed a real DSL would be checking that DSL rather
+ * than the artifact this exists to check, and proving a particular product DSL
+ * belongs beside the plugin that owns it.
+ *
  * Usage:
  *   node scripts/browser-check.mjs [path/to/chrome]
  *
@@ -88,20 +94,20 @@ if (browser === undefined) {
  * The page is opened over `file://`, and Chromium refuses to fetch an ES module from
  * a file URL — so the library is bundled to an IIFE and inlined. The entry is built
  * from the SHIPPED files rather than from `src/`, so what this check drives is the
- * artifact a host would actually install.
+ * artifact a host would actually install — and it is the root entry ALONE, because
+ * that is all the package publishes.
  * @returns the script source.
  */
 async function bundle() {
   const index = join(root, 'dist', 'index.js')
-  const grammars = join(root, 'dist', 'grammars.js')
-  if (!existsSync(index) || !existsSync(grammars)) {
+  if (!existsSync(index)) {
     console.error('browser-check: dist/ is missing; run `npm run build` first')
     process.exit(1)
   }
   const { build } = await import('esbuild')
   const result = await build({
     stdin: {
-      contents: `export * from ${JSON.stringify(index)}\nexport * from ${JSON.stringify(grammars)}\n`,
+      contents: `export * from ${JSON.stringify(index)}\n`,
       resolveDir: root,
       sourcefile: 'litearea-browser-entry.js',
       loader: 'js',
@@ -156,12 +162,57 @@ const CHECKLIST = String.raw`
         field.dispatchEvent(new KeyboardEvent('keydown', { key: key, bubbles: true, cancelable: true }))
       }
 
-      const sentry = api.dshSentryStyleGrammar()
-      const font = api.dshFontQueryGrammar({
-        catalogue: ['Inter', 'IBM Plex Mono', 'Geist Mono', 'Fira Code'],
-        enumerated: true,
-        styles: { 'Geist Mono': ['Regular', 'Medium', 'Bold'] },
-        shippedWeight: 400,
+      // ── the fixture grammar ─────────────────────────────────────────────
+      // The package ships no syntax, so the checklist defines the language it
+      // drives. This is a FIXTURE and not a product DSL: one closed vocabulary,
+      // three rules, one completion source, and it is published nowhere. The two
+      // checks that need a differently-shaped grammar — the naive one in section
+      // 10 and the bulky one in section 8 — define their own, for the same reason.
+      const SHAPES = api.defineVocabulary({
+        id: 'shape',
+        words: ['circle', 'square', 'rounded'],
+        scope: 'shape',
+        unknownMessage: '"{word}" is not a shape — expected {allowed}.',
+        docs: {
+          circle: { detail: 'a disc', body: 'Fixture documentation for circle.' },
+          square: { detail: 'four corners', body: 'Fixture documentation for square.' },
+          rounded: { detail: 'a rounded box', body: 'Fixture documentation for rounded.' },
+        },
+      })
+
+      const fixture = api.defineGrammar({
+        id: 'browser-fixture',
+        name: 'browser fixture',
+        rules: [
+          // The number rule sits ABOVE the vocabulary: digits are word characters,
+          // so a words rule placed first would swallow and reject them.
+          { kind: 'match', scope: 'keyword', pattern: /draw|fill/ },
+          { kind: 'match', scope: 'number', pattern: /\d+(?:\.\d+)?/ },
+          { kind: 'words', words: SHAPES, unknown: {} },
+        ],
+        compose: [
+          {
+            id: 'shape',
+            range: (context) => context.word,
+            items: (context) => {
+              const written = context.text.slice(0, context.caret)
+              return ['circle', 'square', 'rounded'].map((shape) => {
+                // A shape the document already uses leads the list, which is what
+                // sortText is for: the ranking must put that group first without
+                // pretending its label starts with a zero.
+                const used = written.indexOf(shape) >= 0
+                return {
+                  label: shape,
+                  append: ' ',
+                  kind: 'shape',
+                  detail: SHAPES.entryFor(shape)?.detail,
+                  documentation: SHAPES.entryFor(shape)?.body,
+                  sortText: used ? '0' : '1',
+                }
+              })
+            },
+          },
+        ],
       })
 
       ;(async () => {
@@ -169,7 +220,7 @@ const CHECKLIST = String.raw`
         check(typeof api.createEditor === 'function', 'the bundle did not expose createEditor')
 
         // ── 1. the layer reproduces the document, and lines up with it ──────
-        const one = mount(sentry, 'running  circle  blue  turn   3')
+        const one = mount(fixture, 'draw  circle  fill  rounded  10')
         const paint = paintOf(one)
         check(
           paint.textContent === one.input.value,
@@ -190,7 +241,7 @@ const CHECKLIST = String.raw`
         // screen: a stylesheet rule of higher specificity once set text-decoration on every
         // painted span, which quietly switched off every squiggle in the library. Nothing in
         // the DOM reveals that, so the only honest check is the browser's own computed style.
-        const marked = mount(sentry, 'running  bogus  blue')
+        const marked = mount(fixture, 'draw bogus 10')
         const markedSpans = [...marked.element.querySelectorAll('.litearea-paint > span')]
         const flaggedSpan = markedSpans.find((span) => span.className.indexOf('litearea-diag-error') >= 0)
         check(flaggedSpan !== undefined, 'a rejected word must carry a severity class')
@@ -220,14 +271,14 @@ const CHECKLIST = String.raw`
         // is the first thing a host asks about, so it is measured rather than asserted in prose.
         // Georgia is chosen precisely because it is unlike the default in every metric.
         const themed = mount(
-          sentry,
-          'running  circle  blue  turn   3\nwaiting rounded amber blink 1.1',
+          fixture,
+          'draw circle 10\nfill square 20',
           {
             variables: {
               font: 'Georgia, Times New Roman, serif',
               'font-size': '15px',
               'line-height': '26px',
-              'scope-state': '#b91c1c',
+              'scope-keyword': '#b91c1c',
               accent: '#c2410c',
             },
           },
@@ -253,8 +304,8 @@ const CHECKLIST = String.raw`
           'a themed layer must still reproduce the document',
         )
         const themedState = [...themed.element.querySelectorAll('.litearea-paint > span')]
-          .find((span) => span.className.indexOf('litearea-scope-state') >= 0)
-        check(themedState !== undefined, 'the themed document must have a state token')
+          .find((span) => span.className.indexOf('litearea-scope-keyword') >= 0)
+        check(themedState !== undefined, 'the themed document must have a keyword token')
         if (themedState !== undefined) {
           check(
             getComputedStyle(themedState).color === 'rgb(185, 28, 28)',
@@ -280,10 +331,10 @@ const CHECKLIST = String.raw`
             ' > ' + one.input.clientHeight + ')',
         )
         const oneLine = one.input.offsetHeight
-        one.setValue('running circle blue turn 3\nwaiting rounded amber blink 1.1\ndone circle green flush 1.6', true)
+        one.setValue('draw circle 10\nfill square 20\ndraw rounded 30', true)
         const threeLines = one.input.offsetHeight
         check(threeLines > oneLine, 'more lines must grow the box (was ' + oneLine + ', now ' + threeLines + ')')
-        one.setValue('running circle blue turn 3', true)
+        one.setValue('draw circle 10', true)
         const backToOne = one.input.offsetHeight
         check(
           Math.abs(backToOne - oneLine) <= 1,
@@ -292,8 +343,8 @@ const CHECKLIST = String.raw`
 
         // ── 3. a maximum height clamps the box and introduces a scrollbar ───
         const clamped = mount(
-          sentry,
-          'running circle blue turn 3\nwaiting rounded amber blink 1.1\ndone circle green flush 1.6\napproval rounded amber blink 1.9',
+          fixture,
+          'draw circle 1\nfill square 2\ndraw rounded 3\nfill circle 4',
           { sizing: { maxRows: 2 } },
         )
         check(
@@ -333,22 +384,22 @@ const CHECKLIST = String.raw`
         notes.push('control: a direct value assignment is not undoable, as expected')
 
         // ── 5. undo and redo survive a completion ──────────────────────────
-        const undoable = mount(sentry, '')
+        const undoable = mount(fixture, '')
         undoable.focus()
-        document.execCommand('insertText', false, 'runn')
+        document.execCommand('insertText', false, 'rou')
         check(
-          undoable.value === 'runn',
+          undoable.value === 'rou',
           'typing through the editing pipeline must land (value is ' + JSON.stringify(undoable.value) + ')',
         )
         check(
           undoable.currentCompletion !== undefined,
-          'typing a state prefix must open the completion list',
+          'typing a shape prefix must open the completion list',
         )
         check(rowsOf(undoable).length > 0, 'the completion list must render rows')
         const beforeCompletion = undoable.value
         press(undoable.input, 'Enter')
         check(
-          undoable.value.indexOf('running') === 0,
+          undoable.value.indexOf('rounded') === 0,
           'Enter must accept the highlighted completion (value is ' + JSON.stringify(undoable.value) + ')',
         )
         check(
@@ -381,7 +432,7 @@ const CHECKLIST = String.raw`
         // letter — so accepting the suggestion produced the completion followed by the
         // leftover character. Every character must be typed SEPARATELY here, so that the list
         // is filtered once per keystroke exactly as a person would drive it.
-        const grown = mount(sentry, '')
+        const grown = mount(fixture, '')
         grown.focus()
         document.execCommand('insertText', false, 'r')
         check(grown.currentCompletion !== undefined, 'the first letter must open the list')
@@ -394,26 +445,28 @@ const CHECKLIST = String.raw`
         )
         press(grown.input, 'Enter')
         check(
-          grown.value === 'running ',
+          grown.value === 'rounded ',
           'accepting after two letters must replace BOTH of them (got ' + JSON.stringify(grown.value) + ')',
         )
 
         // The same thing with a longer word and a middle-of-document caret, because the
-        // off-by-one is easiest to miss when the range is not anchored at zero.
-        const midword = mount(sentry, 'running circle blue turn 3\nwaiting rounded amber blink 1.1')
+        // off-by-one is easiest to miss when the range is not anchored at zero. The
+        // inserted letters are a subsequence of the word rather than its next letters, so
+        // the row is still offered and the replacement has to cover everything typed.
+        const midword = mount(fixture, 'draw circle 1\nrounded square 2')
         midword.focus()
-        const lineStart = midword.input.value.indexOf('waiting')
+        const lineStart = midword.input.value.indexOf('rounded')
         midword.setSelection(lineStart + 1)
-        document.execCommand('insertText', false, 'ai')
+        document.execCommand('insertText', false, 'ou')
         press(midword.input, 'Enter')
         check(
-          midword.input.value.split('\n')[1] === 'waiting rounded amber blink 1.1',
+          midword.input.value.split('\n')[1] === 'rounded square 2',
           'completing a word in the middle of a document must leave no debris (line is ' +
             JSON.stringify(midword.input.value.split('\n')[1]) + ')',
         )
 
         // ── 7. a repaint does not move the caret ───────────────────────────
-        const careful = mount(sentry, 'running  circle  blue  turn  3\nwaiting rounded amber blink 1.1')
+        const careful = mount(fixture, 'draw  circle  fill  rounded  10\nfill square 20')
         careful.focus()
         const at = careful.input.value.indexOf('rounded')
         careful.setSelection(at)
@@ -435,7 +488,7 @@ const CHECKLIST = String.raw`
         )
 
         // ── 7. the list opens, navigates, and dismisses ─────────────────────
-        const listed = mount(sentry, 'running ')
+        const listed = mount(fixture, 'draw ')
         listed.focus()
         listed.setSelection(listed.input.value.length)
         listed.showCompletions()
@@ -470,7 +523,7 @@ const CHECKLIST = String.raw`
         // row rather than the scrollbar, so a keyboard user never saw it, and a mouse user had
         // to scroll down to read it and back up to reach the next row. The fix is positional, so
         // this asks the layout rather than the DOM.
-        const bulky = litearea.defineGrammar({
+        const bulky = api.defineGrammar({
           id: 'bulky',
           rules: [{ kind: 'match', scope: 'word', pattern: /[a-z]+/ }],
           wordChars: /[\p{L}]/u,
@@ -540,10 +593,10 @@ const CHECKLIST = String.raw`
         }
 
         // ── 9. the tooltip explains a problem ───────────────────────────────
-        const hovered = mount(sentry, 'running  bogus  blue', { hover: { enabled: true, delay: 0 } })
+        const hovered = mount(fixture, 'draw bogus 10', { hover: { enabled: true, delay: 0 } })
         const flagged = [...hovered.element.querySelectorAll('.litearea-paint > span')]
           .find((span) => span.className.indexOf('litearea-diag-') >= 0)
-        check(flagged !== undefined, 'an unknown state must be underlined')
+        check(flagged !== undefined, 'an unknown shape must be underlined')
         if (flagged !== undefined) {
           const box = flagged.getBoundingClientRect()
           hovered.input.dispatchEvent(new MouseEvent('mousemove', {
@@ -567,19 +620,42 @@ const CHECKLIST = String.raw`
           check(tip.dataset.open === 'false', 'leaving the field must close the tooltip')
         }
 
-        // ── 9. the font grammar works in a browser too ─────────────────────
-        const fonts = mount(font, 'Geist Mono m')
-        fonts.focus()
-        fonts.setSelection(fonts.input.value.length)
-        fonts.showCompletions()
-        const fontRows = [...rowsOf(fonts)].map((row) => row.textContent)
-        check(
-          fontRows.some((label) => label.indexOf('medium') >= 0),
-          'the font grammar must offer Geist Mono weights (got ' + JSON.stringify(fontRows.slice(0, 6)) + ')',
-        )
+        // ── 9b. the fixture's own completion offers its own vocabulary ─────
+        // This replaced a check that drove the dsh-font DSL in a browser. Proving
+        // that a particular product DSL works is the plugin's job and not the
+        // library's: a DSL belongs beside the plugin that owns it. What is left is
+        // the engine claim the old check was reaching for — rows carry an append
+        // and a sortText, and the list honours both.
+        const offered = mount(fixture, 'draw circle 1\nfill ')
+        offered.focus()
+        offered.setSelection(offered.input.value.length)
+        offered.showCompletions()
+        check(
+          rowsOf(offered).length === 3,
+          'the fixture completion must offer its whole vocabulary (got ' + rowsOf(offered).length + ')',
+        )
+        const offeredState = offered.currentCompletion
+        check(offeredState !== undefined, 'showCompletions must open the list over an empty word')
+        if (offeredState !== undefined) {
+          const firstRow = offeredState.rows[0]
+          check(
+            firstRow !== undefined && firstRow.item.sortText === '0',
+            'A ROW THAT LEADS BY sortText MUST LEAD THE LIST (got ' +
+              JSON.stringify(firstRow === undefined ? null : firstRow.item.label) + ')',
+          )
+          check(
+            firstRow !== undefined && firstRow.item.label === 'circle',
+            'the shape the document already uses must be offered first (got ' +
+              JSON.stringify(firstRow === undefined ? null : firstRow.item.label) + ')',
+          )
+          check(
+            offeredState.rows.some((row) => row.item.append === ' '),
+            'a row must carry the append a host would type next',
+          )
+        }
         check(
-          paintOf(fonts).textContent === 'Geist Mono m',
-          'the font layer must reproduce the query',
+          paintOf(offered).textContent === offered.input.value,
+          'the fixture layer must reproduce the document it is showing a list over',
         )
 
         // ── 10. resting on blank space must explain nothing ────────────────
@@ -589,10 +665,10 @@ const CHECKLIST = String.raw`
         // an implementation detail and not an explanation of anything.
         //
         // The grammar here is naive ON PURPOSE: it describes every token it is handed, including
-        // whitespace. Testing this against one of the reference grammars would prove nothing,
-        // because both of them happen to stay quiet about a scope they have no documentation
-        // for — the check has to exercise the ENGINE's refusal to ask, not a grammar's manners.
-        const naive = litearea.defineGrammar({
+        // whitespace. Testing this against a grammar that happens to stay quiet about a scope it
+        // has no documentation for would prove nothing — the check has to exercise the ENGINE's
+        // refusal to ask, not a grammar's manners.
+        const naive = api.defineGrammar({
           id: 'naive',
           rules: [{ kind: 'match', scope: 'word', pattern: /[a-z]+/ }],
           describe: (context) =>
@@ -665,6 +741,9 @@ const CHECKLIST = String.raw`
             document.querySelectorAll('style[data-litearea-styles]').length + ')',
         )
 
+        // A host's own write at the very end: it must be accepted without throwing,
+        // and it is deliberately not a check, because a direct assignment is exactly
+        // what the control above proved the pipeline does not record.
         const edits = one.input.value
         one.input.value = edits