@adecore/editor 0.17.0-beta.1 → 0.17.0-beta.2

package/LICENSE

@@ -6,7 +6,7 @@ FSL-1.1-MIT
 
 ## Notice
 
-Copyright 2026 Bas Milius
+Copyright 2026 - present Bas Milius
 
 ## Terms and Conditions
 

package/README.md

@@ -1,82 +1,57 @@
 # @adecore/editor
 
-Read the [browser editor handbook](https://adecore.dev/editor/handbook/) for the complete setup, concepts, host integration and testing guides.
+[![npm](https://img.shields.io/npm/v/@adecore/editor)](https://www.npmjs.com/package/@adecore/editor)
+[![Docs](https://img.shields.io/badge/docs-adecore.dev-blue)](https://adecore.dev/editor/)
 
-The DOM view of the smart editor. It draws a `DocumentModel` from `@adecore/editor-core` with its own layout and implements the `EditorEngine` contract. Language features live in `@adecore/editor-react`; the engine itself needs no language service.
+A code editor for the DOM. It draws a [`DocumentModel`](https://adecore.dev/editor-core/) with a layout of its own, renders only the rows in view, and takes the decorations, rows and marks a host hands it: problems, inlay hints, semantic colors, change marks, widgets between lines, code vision, agent attribution and ghost text. It knows no language server; [`@adecore/editor-react`](https://adecore.dev/editor-react/) adds one.
 
-```ts
-const engine = createSmartEditorEngine({
-    tokenizer: shikiTokenizers(() => highlighter),
-    handBack: shellShortcuts,
-    apple
-});
-const editor = engine.mount(element, { text, language: 'typescript', theme: 'github-dark' });
-```
-
-Import `@adecore/ui/theme.css`, then `@adecore/editor/editor.css`. The element needs a positioned box sized by its parent. Editor, find, change and attribution colors have defaults on Adecore theme tokens. The code face uses `--font-mono`, `--code-font-size` and `--code-line-height`; the latter two default to `--text-code` and `--text-code--line-height`. Override them after the editor CSS, and call `refreshFont()` when they change.
-
-## How it is put together
-
-- `layout.ts`: the rows of the document, free of the DOM. A row is a line, a widget or a fold's first line. It owns wrapping into visual lines, tab stops, inlays, folded lines, caret and selection boxes, hit testing and moving by visual line. Only the rows on screen are measured; the others stand on an estimate that the first draw corrects.
-- `view.ts`: the DOM, the scroll (native: the gutter and the pinned headers stick to the corner of the one scroll container, and the scroll event draws the rows, a viewport of them on each side, in the frame it shows in), the folds and what is drawn behind and above the text. `paint.ts` holds the drawing of rows, the gutter, the selection and the carets. Rows are absolutely placed runs of text, so the layout decides where each character is. A draw reads the viewport's scroll position and size once at its start, since a read after the first write of a frame makes the browser lay the page out again, and a host setter whose value did not change draws nothing. The horizontal scroll extent is the widest line measured since the text last changed, inlays included, plus three columns as on the platform; a host row follows the scroll and clips what it draws past its width, since an overflow there would grow the extent with every scroll and carry the sticky gutter out of view.
-- `controller.ts`: what a person does. Keys come from one table (`keymap-table.ts`, which the client prints in its menus as well) and are mapped in `keymap.ts` to the model's commands, typing goes through `DocumentModel.typeText`, a paste through `DocumentModel.paste`, the mouse through `pointer.ts`. A copy or cut of a bare caret remembers its text for every editor of the page, and pasting that same text again, in any of them, lands as whole lines. Adding a caret above or below is the double tap of a modifier and an arrow (`modifier-gesture.ts`). The smart keys (`EditorSmartKeys`: pairing, surrounding, tabbing out, smart Enter, indent on paste, the smart semicolon and the camel humps) are options of the editor, set at mounting and changed with `setSmartKeys`; all are on except the camel humps. The textarea (`native-input.ts`) is only the sink for the platform's typing, composition and paste, and carries the text around the caret for assistive technology.
-- `tokens.ts` and `shiki.ts`: coloring. A grammar needs the state the previous line ended in, so lines are colored from a frontier down, a slice at a time, on the screen plus a margin. An edit moves the frontier to the changed line and stops as soon as a line ends in the state it had before. The tokenizer is injected (`TokenizerSource`); `shikiTokenizers` adapts the viewer's Shiki highlighter. It loads the languages a grammar embeds only on demand (a style block's `lang="scss"`, a Markdown fence) when the document names them, since Shiki rebuilds the host grammar when one loads later, and a tokenizer says so with `stale` so the colors start over from the top. A language added to a document after it opened (a new fence) is colored once the file opens again. `php-html.ts` is the grammar for a PHP file as a document (HTML with PHP between its tags), which Shiki does not bundle; PHP inside an HTML attribute is not colored.
-- `outline.ts`: the blocks of the document with a header line, read from braces and indentation until the host hands over better ones with `setBlocks` (a language server's symbols). Sticky scroll pins the headers of the blocks scrolled out of sight, and `onScope` reports the named blocks around the caret for a breadcrumb.
-- `overview.ts`: the ticks in the scroll track for the host's change marks (`setChangeMarks`, also drawn in the gutter) and the find matches.
-- `find.ts`: the matches of the host's find bar. They are marked in the editor and never touch the selection until `endFind`.
-- `semantic.ts` and `theme-scopes.ts`: what a language server classified, drawn over the grammar's colors. The host hands scopes (`setSemanticTokens`), and the theme's own rules decide the color (`scopeColors`, `shikiScopeColors`), so a class is the theme's class color. A scope the theme says nothing about keeps what the grammar made.
-- `scroll.ts` and `scroll-animation.ts`: where a scroll goes (the platform's scrolling model: margins, and a jump a third from the top) and how it gets there, over up to a tenth of a second and never for a line or less.
-- `keymap-table.ts`: the keys of every editor and language command for macOS and the other platforms, which the client prints in its menus too (`@adecore/editor/keymap`).
-- `engine.ts`: the `Editor` contract over a model and a view.
-
-## What a language feature gets
-
-The editor knows no language server. It reports every change of the text as LSP content changes (`onTextChange`, with its source), says where the caret is (`getCaret`, `onCaret`) and where a character is on the screen (`rectAt`, in the page's pixels so a popup is right at any canvas zoom), and takes what a host draws or does: `setMarkers` (squiggles, faded and struck text, a lane in the scroll track), `setInlayHints`, `setSemanticTokens`, `setHighlights`, `setBlocks`, `setWidgets` (rows of the host's own DOM next to lines, drawn in the layout's block rows; `placement: 'above'` puts one over its line, and each owner has its own set, see below), `setCodeVision` (a quiet row above a declaration, see below), `setGhostText` (a suggestion after the caret, see below), `setGutterAction` (one button in the gutter, such as a lightbulb, which `onGutterAction` reports), `setGutterMarkers` (small buttons in the gutter per owner, such as the mark of a saved inline edit, which `onGutterMarker` reports by id; a marker stays on its line until its owner sets them again), `setLink` (a name underlined as a link while a modifier is held) `trackRange` (a range that follows the text through edits and reads null once an edit touched it, inside or across an end; text inserted exactly at an end does not count, so a range that was a selection still holds the same text) and `applyEdits`. A marker's `message` is what the tick of the problem says in the scroll track, where a press on the tick goes to the problem. `getSelection`, `getSelections`, `setSelections` (the last range is the primary one), `getVisibleRange` and `getIndentation` say what a feature asks about, and `setSelection` selects a range, such as the stop of a snippet. `onHover` reports the character under the pointer, `onClick` offers a press on a character first (Mod+click follows a name) and `onContextMenu` asks the host for its menu, which the editor does not draw, `onKeyDown` lets a host take a key before the editor does, and `onViewChange` says when the screen position of a character moved.
-
-`setText` applies the difference as a line diff in one batch (`changedSpans`), one undo step reported as an external change, so a reload from disk or a sync between two editors on a file keeps the scroll, carets, folds, markers, inlays and code vision rows wherever the text around them stayed. A language server hears it as the one stretch from the first change to the last.
-
-`runCommand` runs an editing command by name, which is how a menu or the palette reaches the editor; the folding commands (collapse and expand a region, all, recursively, a selection, documentation comments and "expand all to level 1 through 5") and column mode are the view's own.
-
-A collapsed fold is one row for the line commands, as the platform has it: delete, duplicate, comment, move and a copy or cut with no selection take the whole fold (a moved fold stays collapsed on its new lines), a word move steps over it and add caret above and below skips it. The view hands the commands its rows through `lineSpan`.
+**[Documentation with live demos](https://adecore.dev/editor/)**
 
-Folds are kept by line (`getFolds`, and `folds` on mounting), the way scroll and caret are. A fold has a role (the file header, imports, documentation comments, regions, the body of a function, a method or a class, object and array literals, tags, attributes and so on, `FoldRole` of the core), and `foldDefaults` on mounting lists the roles that fold by themselves in a file that has no folds of its own. `setFoldHints` hands over a language server's symbols and folding ranges, which name the bodies and tags the text cannot, and the defaults fold what they name once: not a fold somebody opened or closed, not one that holds the caret, and nothing after the first edit. `foldOutline` (`off`, `hover` or `always`) says when the arrow shows in the gutter. Indent guides, whitespace and a right margin are options and setters (`guides`, `whitespace`, `rightMargin`). The find takes `inSelection`, `selectFindMatches` puts a caret on every match, `setReplacePreview` draws what a regular expression writes under the current match, and `findFromCursor` steps without a find bar.
+## Install
 
-`handBack` shortcuts are not handled by the editor and not prevented, so the page's own listeners get them. Mod+S is `onSave`.
-
-## Agent marks
-
-`setAttributionMarks` draws a three pixel bar in the gutter, where the change marks are, for each run of lines (`id`, one-based `startLine` and `endLine`, `color`). The color is a custom property of the page (`--agent-1` to `--agent-6`, `AGENT_COLORS`, defined in `editor.css` for both themes, with `--agent-ink` for text on them) or any CSS color. On a line that has both, the bar stands in the place of the git change mark, which the scroll track still shows; a removal triangle between lines stays. A run follows its text through edits until the host sets the marks again, and an edit costs one mapping of two offsets per run, so thousands of runs stay smooth. `onAttributionHover` reports the id and the bar's box on the line under the pointer (a few pixels either side of the bar count), and null when it leaves.
-
-`setRemoteCursors` draws the caret of an agent (`id`, `position`, `name`, `color`, the same colors) over the text, two pixels wide with its name in a label above it, the label's lower left corner square. Where there is no room above the caret (the first line, or under the pinned headers) the name goes under it. It follows its text through edits until set again, is not interactive, and is left out on a line a fold hides. The editor's own caret and selection never move for it.
-
-## Review and conflict rows
-
-`setLineHighlights` tints lines behind the text (`startLine` and `endLine` one-based, a `color`, an optional `sign` such as `+` in the gutter beside the number, an optional `fill` that paints the rows as it stands instead of the 14% tint of the color), one box per row so a widget row between two tinted lines stays clear. It follows its text through edits like the marks do. `renderCode(container, text, options)` fills a widget row's element with lines that are not in the document, such as the lines an agent removed or the other side of a conflict, in the editor's face and token colors, with a gutter column as wide as the editor's, so the text lines up with the document's (`firstLine` for numbers, `sign`, `color` for the tint and the bar, `emphasis` for character ranges per line drawn in a stronger tint, such as the words a change replaced, and `faded` for text that is gone). Both take the same colors as the attribution marks. A widget has `placement: 'above'` for a row over its line. `setLineActions(actions, owner?)` puts the host's own DOM after the last character of a line (`id`, zero-based `line`, `render(container)` once per action), such as the buttons of a change under review. It is no row: it takes no height, follows its line through edits, is hidden where a fold hides the line, and a press on it never moves the caret. A long line with no wrap pushes it past the edge of the view.
-
-## Widgets per owner
+```sh
+bun add @adecore/editor
+```
 
-`setWidgets(widgets, owner?)` replaces the rows of one owner, `default` without one, and leaves every other owner's alone, so a peek, the review rows of an agent's change and a conflict stand together. Rows next to the same line are ordered by their owners' names and then in the order each owner gave them, not by who set them last, so they never swap places. An empty list takes the owner's rows away.
+## Set up
 
-## Code vision rows
+```css
+@import '@adecore/ui/theme.css';
+@import '@adecore/editor/editor.css';
+```
 
-`setCodeVision` takes a row per declaration: the line, and the entries of the row (`id`, `text`, an optional `user` or `users` icon, and `activate`, which gets the box of the pressed entry in the page's pixels). The row is a block row above the line (`lens` on a `BlockWidget`, `lens.ts` for its buttons), one code line high whatever its entries are, placed at the indentation of the declaration and never measured, so it holds its height with no entries and the text does not move when they arrive. It follows its declaration through edits like every block does, is kept apart from `setWidgets` (a peek under a name never takes a row away), and is drawn again only when the words of its entries change. An entry stands a text size from the next one, is muted, and lights up as a link with an underline under the pointer; a press on it never moves the caret or takes the focus.
+```ts
+import { createSmartEditorEngine, shikiTokenizers } from '@adecore/editor';
 
-## Ghost text
+const engine = createSmartEditorEngine({ tokenizer: shikiTokenizers(getHighlighter) });
+const editor = engine.mount(element, { text, language: 'typescript', theme: 'github-light' });
+```
 
-`setGhostText({ position, text, accessory? })` draws a suggestion after the caret that is not in the document, such as a continuation from a model, and `null` takes it away. The first line of `text` sits in the line in the code face and the editor's faint color, italic, and the caret stays in front of it. Further lines are a row under the line, in the same color and with the gutter column of the document, so the lines below move down while it is shown. `accessory` fills an element drawn after the end of the line, such as the keys that take the suggestion. The editor never accepts it: the host binds the keys (Tab, `acceptGhostWord`) and inserts the text with `applyEdits`, which is one undo step. Any change of the text takes the suggestion away, so the host sets it again for the text it was made for; moving the caret does not, and the host decides what that means.
+The element needs a position and a size from its parent.
 
-## Limits
+## Entry points
 
-- No rendered documentation blocks.
-- Wrapped lines break at spaces and inside a word that does not fit, and continue at the line's indentation plus two characters. A click past the end of a visual line draws the caret at its end until the caret moves; an arrow key onto that offset draws it at the start of the next line.
-- A line over 20,000 characters is not colored.
-- Every edit rebuilds the row list, which is linear in the number of lines.
-- No bidirectional text, and no screen reader testing beyond the textarea's own context.
+| Import | What it holds |
+|---|---|
+| `@adecore/editor` | `createSmartEditorEngine`, the `Editor` contract and its types, the Shiki adapters |
+| `@adecore/editor/editor.css` | The styles |
+| `@adecore/editor/shiki` | The Shiki adapters and grammar loading |
+| `@adecore/editor/keymap` | The key table, `resolveKeymap`, `chordOf` and `parseChord` |
+| `@adecore/editor/fake` | `FakeEditorEngine`, for tests of host code |
+| `@adecore/editor/testing` | `mountEditor` on a LinkeDOM page |
 
-## Keymaps and package exports
+## Documentation
 
-`@adecore/editor/keymap` exports `KEYMAP`, `resolveKeymap`, `chordOf` and `parseChord`. Pass the same resolved keymap and `apple` flag to the engine and to `ProjectLanguage` so editor keys, language commands and menu hints agree. Application collisions belong in host overrides. AI commands have no universal bindings. `handBack` remains the host's global shortcut list.
+| Page | What it covers |
+|---|---|
+| [Getting started](https://adecore.dev/editor/getting-started) | Install, styles, mounting and the engine options |
+| [Options and keymaps](https://adecore.dev/editor/options) | Every option and setter, smart keys and the key table |
+| [Text and events](https://adecore.dev/editor/editing) | Positions, edits, selections, events and tracked ranges |
+| [Decorations](https://adecore.dev/editor/decorations), [Rows and widgets](https://adecore.dev/editor/rows), [Agents](https://adecore.dev/editor/agents) | What a host draws into the editor |
+| [Find and folding](https://adecore.dev/editor/find-folding) | The find matcher, folds and sticky scroll |
+| [Theme and syntax](https://adecore.dev/editor/theme) | CSS tokens, Shiki and a tokenizer of your own |
+| [Testing](https://adecore.dev/editor/testing) | `mountEditor` and `FakeEditorEngine` |
 
-The root exports the engine and its types. `/shiki` supplies the Shiki adapter, `/fake` supplies the DOM-free `FakeEditorEngine`, and `/testing` supplies DOM fixtures backed by LinkeDOM. `/editor.css` supplies the required editor chrome.
+## License
 
-This unpublished package is private at version `0.0.0` and retains FSL-1.1-MIT. Source consumers enable the `source` condition in the bundler, TypeScript and Bun. Default exports use compiled JavaScript and declarations. Run `bun run build`, `bun run typecheck` and `bun run test` from this package after workspace installation. See the editor migration guide for consumer adapters and the transferred revision.
+FSL-1.1-MIT

package/dist/engine.js

@@ -5,6 +5,7 @@ import { emit, subscribe } from './listeners.js';
 import { fillLens, lensSignature } from './lens.js';
 import { EditorView } from './view.js';
 const DEFAULT_TAB_SIZE = 4;
+const DEFAULT_LABEL = 'Code editor';
 const DEFAULT_WIDGET_OWNER = 'default';
 class SmartEditor {
     model;
@@ -41,6 +42,7 @@ class SmartEditor {
             wrap: options.wrap ?? false,
             smartKeys: resolveSmartKeys(options.smartKeys),
             messages: options.messages ?? {},
+            label: options.label ?? DEFAULT_LABEL,
             guides: options.guides !== false,
             whitespace: options.whitespace === true,
             rightMargin: options.rightMargin ?? null,
@@ -522,6 +524,10 @@ class SmartEditor {
         this.settings.foldOutline = outline;
         this.view.applySettings();
     }
+    setLabel(label) {
+        this.settings.label = label;
+        this.view.applySettings();
+    }
     setFoldHints(hints) {
         this.view.setFoldHints(hints === null
             ? null

package/dist/fake.d.ts

@@ -111,6 +111,8 @@ export declare class FakeEditor implements Editor {
     foldOutline: EditorFoldOutline;
     foldHints: EditorFoldHints | null;
     setFoldOutline(outline: EditorFoldOutline): void;
+    label: string;
+    setLabel(label: string): void;
     setFoldHints(hints: EditorFoldHints | null): void;
     setSmartKeys(keys: Partial<EditorSmartKeys>): void;
     setIndentation(indentation: EditorIndentation): void;

package/dist/fake.js

@@ -43,6 +43,7 @@ export class FakeEditor {
         this.theme = options.theme;
         this.readOnly = options.readOnly ?? false;
         this.readOnlyReason = options.readOnlyReason;
+        this.label = options.label ?? 'Code editor';
         this.revealedLine = options.line ?? null;
         this.column = options.column ?? null;
         this.scrollTop = options.scrollTop ?? null;
@@ -372,6 +373,10 @@ export class FakeEditor {
     setFoldOutline(outline) {
         this.foldOutline = outline;
     }
+    label;
+    setLabel(label) {
+        this.label = label;
+    }
     setFoldHints(hints) {
         this.foldHints = hints;
     }

package/dist/types.d.ts

@@ -28,6 +28,7 @@ export interface EditorOptions {
     readonly rightMargin?: number | null;
     readonly foldOutline?: EditorFoldOutline;
     readonly messages?: Partial<EditorMessages>;
+    readonly label?: string;
     readonly folds?: EditorFolds;
     readonly foldDefaults?: readonly FoldRole[];
     readonly line?: number;
@@ -258,6 +259,7 @@ export interface Editor {
     setWhitespace(whitespace: boolean): void;
     setRightMargin(column: number | null): void;
     setFoldOutline(outline: EditorFoldOutline): void;
+    setLabel(label: string): void;
     setFoldHints(hints: EditorFoldHints | null): void;
     setChangeMarks(marks: readonly EditorChangeMark[]): void;
     setBlocks(blocks: readonly EditorBlock[] | null): void;

package/dist/view.d.ts

@@ -13,6 +13,7 @@ export interface ViewSettings {
     wrap: boolean;
     smartKeys: EditorSmartKeys;
     messages: Partial<EditorMessages>;
+    label: string;
     guides: boolean;
     whitespace: boolean;
     rightMargin: number | null;

package/dist/view.js

@@ -208,7 +208,6 @@ export class EditorView {
             this.input.setAttribute(name, 'off');
         }
         this.input.setAttribute('aria-multiline', 'true');
-        this.input.setAttribute('aria-label', 'Code editor');
         this.sticky.setAttribute('aria-hidden', 'true');
         this.sticky.hidden = true;
         this.overview = make('div', 'se-overview');
@@ -252,6 +251,7 @@ export class EditorView {
     /* Settings that are read off the page or off `settings` are applied again: after a change to either. */
     applySettings() {
         this.input.readOnly = this.settings.readOnly;
+        this.input.setAttribute('aria-label', this.settings.label);
         this.root.dataset.readonly = String(this.settings.readOnly);
         this.root.dataset.wrap = String(this.settings.wrap);
         this.root.dataset.foldOutline = this.settings.foldOutline;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor",
-  "version": "0.17.0-beta.1",
+  "version": "0.17.0-beta.2",
   "type": "module",
   "exports": {
     ".": {
@@ -39,7 +39,7 @@
     "test": "bun test --conditions=source"
   },
   "dependencies": {
-    "@adecore/editor-core": "0.17.0-beta.1",
+    "@adecore/editor-core": "0.17.0-beta.2",
     "shiki": "^4.4.3",
     "linkedom": "^0.18.13"
   },

package/src/engine.ts

@@ -51,6 +51,7 @@ import { fillLens, lensSignature } from './lens.ts';
 import { EditorView, type ViewSettings } from './view.ts';
 
 const DEFAULT_TAB_SIZE = 4;
+const DEFAULT_LABEL = 'Code editor';
 const DEFAULT_WIDGET_OWNER = 'default';
 
 class SmartEditor implements Editor {
@@ -90,6 +91,7 @@ class SmartEditor implements Editor {
             wrap: options.wrap ?? false,
             smartKeys: resolveSmartKeys(options.smartKeys),
             messages: options.messages ?? {},
+            label: options.label ?? DEFAULT_LABEL,
             guides: options.guides !== false,
             whitespace: options.whitespace === true,
             rightMargin: options.rightMargin ?? null,
@@ -659,6 +661,11 @@ class SmartEditor implements Editor {
         this.view.applySettings();
     }
 
+    setLabel(label: string): void {
+        this.settings.label = label;
+        this.view.applySettings();
+    }
+
     setFoldHints(hints: EditorFoldHints | null): void {
         this.view.setFoldHints(
             hints === null

package/src/fake.ts

@@ -91,6 +91,7 @@ export class FakeEditor implements Editor {
         this.theme = options.theme;
         this.readOnly = options.readOnly ?? false;
         this.readOnlyReason = options.readOnlyReason;
+        this.label = options.label ?? 'Code editor';
         this.revealedLine = options.line ?? null;
         this.column = options.column ?? null;
         this.scrollTop = options.scrollTop ?? null;
@@ -487,6 +488,12 @@ export class FakeEditor implements Editor {
         this.foldOutline = outline;
     }
 
+    label: string;
+
+    setLabel(label: string): void {
+        this.label = label;
+    }
+
     setFoldHints(hints: EditorFoldHints | null): void {
         this.foldHints = hints;
     }

package/src/types.ts

@@ -68,6 +68,8 @@ export interface EditorOptions {
     readonly foldOutline?: EditorFoldOutline;
     /* What the editor says to a person itself, in the host's words. */
     readonly messages?: Partial<EditorMessages>;
+    /* The accessible name of the editor, such as "Commit message", in the host's language; `Code editor` without one. */
+    readonly label?: string;
     /* The folds a host kept when the file was last open. */
     readonly folds?: EditorFolds;
     /* Without remembered folds, the folds of these roles fold, as they do the first time a file opens, and again as a language server names more of them. */
@@ -491,6 +493,7 @@ export interface Editor {
     /* The column to draw a line at; null takes it away. */
     setRightMargin(column: number | null): void;
     setFoldOutline(outline: EditorFoldOutline): void;
+    setLabel(label: string): void;
     /* What a language server knows about the folds: the bodies of symbols and the ranges it folds. They follow their text through edits until set again; null forgets them. */
     setFoldHints(hints: EditorFoldHints | null): void;
     /* Marks that follow their lines through edits until the host sets them again. */

package/src/view.ts

@@ -67,6 +67,7 @@ export interface ViewSettings {
     wrap: boolean;
     smartKeys: EditorSmartKeys;
     messages: Partial<EditorMessages>;
+    label: string;
     /* A line at each indentation level, and the one of the scope around the caret stronger. */
     guides: boolean;
     /* Spaces drawn as dots and tabs as arrows. */
@@ -299,7 +300,6 @@ export class EditorView {
             this.input.setAttribute(name, 'off');
         }
         this.input.setAttribute('aria-multiline', 'true');
-        this.input.setAttribute('aria-label', 'Code editor');
         this.sticky.setAttribute('aria-hidden', 'true');
         this.sticky.hidden = true;
         this.overview = make('div', 'se-overview');
@@ -345,6 +345,7 @@ export class EditorView {
     /* Settings that are read off the page or off `settings` are applied again: after a change to either. */
     applySettings(): void {
         this.input.readOnly = this.settings.readOnly;
+        this.input.setAttribute('aria-label', this.settings.label);
         this.root.dataset.readonly = String(this.settings.readOnly);
         this.root.dataset.wrap = String(this.settings.wrap);
         this.root.dataset.foldOutline = this.settings.foldOutline;