diff --git a/val_highlight/CHANGELOG.md b/val_highlight/CHANGELOG.md
index bb2f4e9..6046b4d 100644
--- a/val_highlight/CHANGELOG.md
+++ b/val_highlight/CHANGELOG.md
@@ -1,3 +1,26 @@
+## Unreleased
+
+### Added
+
+* **`EditingSyntax`** — how a language is edited: its line and block
+  comment markers, bracket pairs and quote characters. Every built-in
+  language declares one; set `Grammar.editing` on your own, or let
+  `EditingSyntax.of` derive it from the grammar's `LineComment`,
+  `BlockComment` and `QuotedString` blocks. `Grammar.extend` takes an
+  `editing` argument.
+* **`HighlightResult.matchingBracket`** — finds the matching bracket by
+  walking tokens, skipping brackets inside strings and comments.
+* **`HighlightResult.isStringOrCommentAt`**, **`isCommentAt`** and
+  **`isInsideStringOrComment`** — tell code apart from strings and
+  comments, at a character or at a caret position. Interpolations inside
+  strings count as code.
+* **`ScopeTable.isStringOrComment`** and **`isComment`** — the same
+  questions for a scope stack, answered from a table built once per stack.
+
+### Changed
+
+* Markdown highlights HTML comments (`<!-- -->`) as comments.
+
 ## 0.1.0
 
 First release.
diff --git a/val_highlight/README.md b/val_highlight/README.md
index b25abda..0e57ed6 100644
--- a/val_highlight/README.md
+++ b/val_highlight/README.md
@@ -162,6 +162,28 @@ final document = IncrementalHighlighter(language: dartLanguage, text: source);
 final updated = document.update(editedSource);
 ```
 
+Results also answer the questions an editor asks, using the tokens, so
+brackets and quotes inside strings and comments are never mistaken for
+code:
+
+```dart
+result.matchingBracket(offset);          // the matching bracket, or -1
+result.isStringOrCommentAt(offset);      // the character at offset
+result.isInsideStringOrComment(caret);   // text typed at a caret position
+```
+
+Each language also describes how it is edited — its comment markers,
+bracket pairs and quote characters — as an `EditingSyntax`:
+
+```dart
+final syntax = EditingSyntax.of(pythonLanguage);
+syntax.lineComment;   // '#'
+syntax.quotes;        // '"\''
+```
+
+Set `editing:` on your own grammar, or leave it out and it is derived from
+the grammar's `LineComment`, `BlockComment` and `QuotedString` blocks.
+
 ## 🔧 Changing a built-in language
 
 ```dart
@@ -178,6 +200,11 @@ final withTodos = dartLanguage.extend(
 
 // Replace a named part of a grammar. `grammar.repository.keys` lists them.
 final quiet = dartLanguage.extend(repository: {'numbers': []});
+
+// Change how it is edited: comment markers, brackets and quotes.
+final backticks = dartLanguage.extend(
+  editing: EditingSyntax.cStyle.copyWith(quotes: '"\'`'),
+);
 ```
 
 A new scope such as `todo` only needs a theme entry:
diff --git a/val_highlight/lib/languages/bash.dart b/val_highlight/lib/languages/bash.dart
index d8b20bc..910b413 100644
--- a/val_highlight/lib/languages/bash.dart
+++ b/val_highlight/lib/languages/bash.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Bash and POSIX shell scripts.
 const bashLanguage = Grammar(
   name: 'bash',
+  editing: EditingSyntax(lineComment: '#', quotes: '"\'`'),
   aliases: ['sh', 'shell', 'zsh', 'console'],
   fileExtensions: ['sh', 'bash', 'zsh'],
   shebangs: ['bash', 'sh', 'zsh', 'dash', 'ksh'],
diff --git a/val_highlight/lib/languages/batch.dart b/val_highlight/lib/languages/batch.dart
index 2b40aa8..59f4f06 100644
--- a/val_highlight/lib/languages/batch.dart
+++ b/val_highlight/lib/languages/batch.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Windows batch files (`.bat`, `.cmd`).
 const batchLanguage = Grammar(
   name: 'batch',
+  editing: EditingSyntax(lineComment: 'REM', quotes: '"'),
   aliases: ['bat', 'cmd', 'dos'],
   fileExtensions: ['bat', 'cmd'],
   caseInsensitive: true,
diff --git a/val_highlight/lib/languages/c.dart b/val_highlight/lib/languages/c.dart
index 5846c8c..12e6df6 100644
--- a/val_highlight/lib/languages/c.dart
+++ b/val_highlight/lib/languages/c.dart
@@ -38,6 +38,7 @@ const cCommonRules = <Rule>[
 /// C.
 const cLanguage = Grammar(
   name: 'c',
+  editing: EditingSyntax.cStyle,
   aliases: ['h'],
   fileExtensions: ['c', 'h'],
   signatures: [
diff --git a/val_highlight/lib/languages/clojure.dart b/val_highlight/lib/languages/clojure.dart
index c103444..37d76c1 100644
--- a/val_highlight/lib/languages/clojure.dart
+++ b/val_highlight/lib/languages/clojure.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Clojure, ClojureScript and EDN.
 const clojureLanguage = Grammar(
   name: 'clojure',
+  editing: EditingSyntax(lineComment: ';', quotes: '"'),
   aliases: ['clj', 'cljs', 'cljc', 'edn'],
   fileExtensions: ['clj', 'cljs', 'cljc', 'edn'],
   signatures: [
diff --git a/val_highlight/lib/languages/cmake.dart b/val_highlight/lib/languages/cmake.dart
index 265ca8e..6ce318a 100644
--- a/val_highlight/lib/languages/cmake.dart
+++ b/val_highlight/lib/languages/cmake.dart
@@ -10,6 +10,7 @@ const _controlCommands = [
 /// CMake.
 const cmakeLanguage = Grammar(
   name: 'cmake',
+  editing: EditingSyntax(lineComment: '#', quotes: '"'),
   aliases: ['cmakelists'],
   fileExtensions: ['cmake'],
   fileNames: ['CMakeLists.txt'],
diff --git a/val_highlight/lib/languages/cpp.dart b/val_highlight/lib/languages/cpp.dart
index ba455bc..65a12fa 100644
--- a/val_highlight/lib/languages/cpp.dart
+++ b/val_highlight/lib/languages/cpp.dart
@@ -4,6 +4,7 @@ import 'c.dart';
 /// C++ (C++23).
 const cppLanguage = Grammar(
   name: 'cpp',
+  editing: EditingSyntax.cStyle,
   aliases: ['c++', 'cxx', 'hpp', 'cc', 'hh'],
   fileExtensions: ['cpp', 'cc', 'cxx', 'hpp', 'hh', 'hxx', 'ipp', 'ixx'],
   signatures: [
diff --git a/val_highlight/lib/languages/csharp.dart b/val_highlight/lib/languages/csharp.dart
index 0dd7ba0..5cc2154 100644
--- a/val_highlight/lib/languages/csharp.dart
+++ b/val_highlight/lib/languages/csharp.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// C# (12+).
 const csharpLanguage = Grammar(
   name: 'csharp',
+  editing: EditingSyntax.cStyle,
   aliases: ['cs', 'c#'],
   fileExtensions: ['cs', 'csx'],
   signatures: [
diff --git a/val_highlight/lib/languages/css.dart b/val_highlight/lib/languages/css.dart
index cf1a655..b999055 100644
--- a/val_highlight/lib/languages/css.dart
+++ b/val_highlight/lib/languages/css.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// CSS, including nesting and custom properties.
 const cssLanguage = Grammar(
   name: 'css',
+  editing: EditingSyntax(blockComment: ('/*', '*/')),
   fileExtensions: ['css'],
   caseInsensitive: true,
   signatures: [
diff --git a/val_highlight/lib/languages/dart.dart b/val_highlight/lib/languages/dart.dart
index e963da5..f7f0e2c 100644
--- a/val_highlight/lib/languages/dart.dart
+++ b/val_highlight/lib/languages/dart.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Dart.
 const dartLanguage = Grammar(
   name: 'dart',
+  editing: EditingSyntax.cStyle,
   fileExtensions: ['dart'],
   rules: [
     IncludeRule('comments'),
diff --git a/val_highlight/lib/languages/diff.dart b/val_highlight/lib/languages/diff.dart
index 5265860..872a2ca 100644
--- a/val_highlight/lib/languages/diff.dart
+++ b/val_highlight/lib/languages/diff.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Unified and git diffs.
 const diffLanguage = Grammar(
   name: 'diff',
+  editing: EditingSyntax.none,
   aliases: ['patch'],
   fileExtensions: ['diff', 'patch'],
   signatures: [r'^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@', r'^diff --git '],
diff --git a/val_highlight/lib/languages/dockerfile.dart b/val_highlight/lib/languages/dockerfile.dart
index 301a267..8b0c4ce 100644
--- a/val_highlight/lib/languages/dockerfile.dart
+++ b/val_highlight/lib/languages/dockerfile.dart
@@ -6,6 +6,7 @@ import '../advanced.dart';
 /// following `\` continuations. Heredocs (`RUN <<EOF … EOF`) are strings.
 const dockerfileLanguage = Grammar(
   name: 'dockerfile',
+  editing: EditingSyntax.hashStyle,
   aliases: ['docker', 'containerfile'],
   fileExtensions: ['dockerfile'],
   fileNames: ['Dockerfile', 'Containerfile'],
diff --git a/val_highlight/lib/languages/elixir.dart b/val_highlight/lib/languages/elixir.dart
index 53956c2..11fa3d2 100644
--- a/val_highlight/lib/languages/elixir.dart
+++ b/val_highlight/lib/languages/elixir.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Elixir.
 const elixirLanguage = Grammar(
   name: 'elixir',
+  editing: EditingSyntax.hashStyle,
   aliases: ['ex', 'exs'],
   fileExtensions: ['ex', 'exs', 'heex'],
   fileNames: ['mix.lock'],
diff --git a/val_highlight/lib/languages/erlang.dart b/val_highlight/lib/languages/erlang.dart
index 9978c8c..854a291 100644
--- a/val_highlight/lib/languages/erlang.dart
+++ b/val_highlight/lib/languages/erlang.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Erlang.
 const erlangLanguage = Grammar(
   name: 'erlang',
+  editing: EditingSyntax(lineComment: '%'),
   aliases: ['erl'],
   fileExtensions: ['erl', 'hrl', 'escript'],
   fileNames: ['rebar.config'],
diff --git a/val_highlight/lib/languages/fsharp.dart b/val_highlight/lib/languages/fsharp.dart
index da5bbf6..cc04432 100644
--- a/val_highlight/lib/languages/fsharp.dart
+++ b/val_highlight/lib/languages/fsharp.dart
@@ -3,6 +3,11 @@ import '../advanced.dart';
 /// F#.
 const fsharpLanguage = Grammar(
   name: 'fsharp',
+  editing: EditingSyntax(
+    lineComment: '//',
+    blockComment: ('(*', '*)'),
+    quotes: '"',
+  ),
   aliases: ['fs', 'f#'],
   fileExtensions: ['fs', 'fsi', 'fsx'],
   signatures: [
diff --git a/val_highlight/lib/languages/generic.dart b/val_highlight/lib/languages/generic.dart
index ba5650f..ee40881 100644
--- a/val_highlight/lib/languages/generic.dart
+++ b/val_highlight/lib/languages/generic.dart
@@ -9,6 +9,7 @@ import '../advanced.dart';
 /// `allLanguagesRegistry()` and of `CodeView` when no language is given.
 const genericLanguage = Grammar(
   name: 'generic',
+  editing: EditingSyntax.cStyle,
   detectable: false,
   rules: [
     TokenRule(r'^#!.*$', scope: Scopes.meta),
diff --git a/val_highlight/lib/languages/go.dart b/val_highlight/lib/languages/go.dart
index 1b1dd44..e94c799 100644
--- a/val_highlight/lib/languages/go.dart
+++ b/val_highlight/lib/languages/go.dart
@@ -3,6 +3,11 @@ import '../advanced.dart';
 /// Go.
 const goLanguage = Grammar(
   name: 'go',
+  editing: EditingSyntax(
+    lineComment: '//',
+    blockComment: ('/*', '*/'),
+    quotes: '"\'`',
+  ),
   aliases: ['golang'],
   fileExtensions: ['go'],
   signatures: [
diff --git a/val_highlight/lib/languages/graphql.dart b/val_highlight/lib/languages/graphql.dart
index a73e1ca..09fd8c1 100644
--- a/val_highlight/lib/languages/graphql.dart
+++ b/val_highlight/lib/languages/graphql.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// GraphQL queries and schema definitions.
 const graphqlLanguage = Grammar(
   name: 'graphql',
+  editing: EditingSyntax(lineComment: '#', quotes: '"'),
   aliases: ['gql'],
   fileExtensions: ['graphql', 'gql', 'graphqls'],
   signatures: [
diff --git a/val_highlight/lib/languages/groovy.dart b/val_highlight/lib/languages/groovy.dart
index b1fac8f..449cc5a 100644
--- a/val_highlight/lib/languages/groovy.dart
+++ b/val_highlight/lib/languages/groovy.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Groovy, including Gradle build scripts (`build.gradle`).
 const groovyLanguage = Grammar(
   name: 'groovy',
+  editing: EditingSyntax.cStyle,
   aliases: ['gradle'],
   fileExtensions: ['groovy', 'gradle', 'gvy', 'gy', 'gsh'],
   fileNames: ['Jenkinsfile'],
diff --git a/val_highlight/lib/languages/haskell.dart b/val_highlight/lib/languages/haskell.dart
index b9655f8..b7440a6 100644
--- a/val_highlight/lib/languages/haskell.dart
+++ b/val_highlight/lib/languages/haskell.dart
@@ -3,6 +3,11 @@ import '../advanced.dart';
 /// Haskell.
 const haskellLanguage = Grammar(
   name: 'haskell',
+  editing: EditingSyntax(
+    lineComment: '--',
+    blockComment: ('{-', '-}'),
+    quotes: '"',
+  ),
   aliases: ['hs'],
   fileExtensions: ['hs', 'lhs'],
   signatures: [
diff --git a/val_highlight/lib/languages/hcl.dart b/val_highlight/lib/languages/hcl.dart
index 08cc858..c89af60 100644
--- a/val_highlight/lib/languages/hcl.dart
+++ b/val_highlight/lib/languages/hcl.dart
@@ -3,6 +3,11 @@ import '../advanced.dart';
 /// HCL, including Terraform and OpenTofu configuration.
 const hclLanguage = Grammar(
   name: 'hcl',
+  editing: EditingSyntax(
+    lineComment: '#',
+    blockComment: ('/*', '*/'),
+    quotes: '"',
+  ),
   aliases: ['terraform', 'tf', 'opentofu'],
   fileExtensions: ['tf', 'tfvars', 'hcl'],
   signatures: [
diff --git a/val_highlight/lib/languages/html.dart b/val_highlight/lib/languages/html.dart
index 78e17f5..e825042 100644
--- a/val_highlight/lib/languages/html.dart
+++ b/val_highlight/lib/languages/html.dart
@@ -6,6 +6,7 @@ import 'javascript.dart';
 /// HTML, with embedded CSS in `<style>` and JavaScript in `<script>`.
 const htmlLanguage = Grammar(
   name: 'html',
+  editing: EditingSyntax.markupStyle,
   // Vue and Svelte single-file components are HTML with embedded script and
   // style elements.
   aliases: ['htm', 'xhtml', 'vue', 'svelte'],
diff --git a/val_highlight/lib/languages/ini.dart b/val_highlight/lib/languages/ini.dart
index 5a6f171..4820ab8 100644
--- a/val_highlight/lib/languages/ini.dart
+++ b/val_highlight/lib/languages/ini.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// INI files and Java `.properties` files.
 const iniLanguage = Grammar(
   name: 'ini',
+  editing: EditingSyntax(lineComment: ';'),
   aliases: ['properties', 'conf', 'cfg', 'editorconfig', 'gitconfig'],
   fileExtensions: ['ini', 'cfg', 'conf', 'properties', 'editorconfig'],
   fileNames: ['.editorconfig', '.gitconfig', 'gradle.properties'],
diff --git a/val_highlight/lib/languages/java.dart b/val_highlight/lib/languages/java.dart
index 6100251..1e15a73 100644
--- a/val_highlight/lib/languages/java.dart
+++ b/val_highlight/lib/languages/java.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Java (21+), including records, sealed types and text blocks.
 const javaLanguage = Grammar(
   name: 'java',
+  editing: EditingSyntax.cStyle,
   aliases: ['jsp'],
   fileExtensions: ['java'],
   signatures: [
diff --git a/val_highlight/lib/languages/javascript.dart b/val_highlight/lib/languages/javascript.dart
index 59859fa..a582699 100644
--- a/val_highlight/lib/languages/javascript.dart
+++ b/val_highlight/lib/languages/javascript.dart
@@ -4,6 +4,11 @@ import '../src/languages/ecmascript.dart';
 /// JavaScript, including JSX-free modern syntax.
 const javascriptLanguage = Grammar(
   name: 'javascript',
+  editing: EditingSyntax(
+    lineComment: '//',
+    blockComment: ('/*', '*/'),
+    quotes: '"\'`',
+  ),
   aliases: ['js', 'mjs', 'cjs'],
   fileExtensions: ['js', 'mjs', 'cjs'],
   shebangs: ['node', 'deno', 'bun'],
diff --git a/val_highlight/lib/languages/json.dart b/val_highlight/lib/languages/json.dart
index 9ab0887..524112f 100644
--- a/val_highlight/lib/languages/json.dart
+++ b/val_highlight/lib/languages/json.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// JSON, including the comments allowed by JSONC.
 const jsonLanguage = Grammar(
   name: 'json',
+  editing: EditingSyntax(quotes: '"'),
   aliases: ['jsonc'],
   fileExtensions: ['json', 'jsonc'],
   signatures: [
diff --git a/val_highlight/lib/languages/jsx.dart b/val_highlight/lib/languages/jsx.dart
index d695394..df81816 100644
--- a/val_highlight/lib/languages/jsx.dart
+++ b/val_highlight/lib/languages/jsx.dart
@@ -4,6 +4,11 @@ import '../src/languages/ecmascript.dart';
 /// JavaScript with JSX elements, as used by React.
 const jsxLanguage = Grammar(
   name: 'jsx',
+  editing: EditingSyntax(
+    lineComment: '//',
+    blockComment: ('/*', '*/'),
+    quotes: '"\'`',
+  ),
   aliases: ['react'],
   fileExtensions: ['jsx'],
   signatures: [
diff --git a/val_highlight/lib/languages/julia.dart b/val_highlight/lib/languages/julia.dart
index 22ed4f6..2749a65 100644
--- a/val_highlight/lib/languages/julia.dart
+++ b/val_highlight/lib/languages/julia.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Julia.
 const juliaLanguage = Grammar(
   name: 'julia',
+  editing: EditingSyntax(lineComment: '#', blockComment: ('#=', '=#')),
   aliases: ['jl'],
   fileExtensions: ['jl'],
   shebangs: ['julia'],
diff --git a/val_highlight/lib/languages/kotlin.dart b/val_highlight/lib/languages/kotlin.dart
index 05c80e1..cd4a572 100644
--- a/val_highlight/lib/languages/kotlin.dart
+++ b/val_highlight/lib/languages/kotlin.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Kotlin, including Kotlin script (`.kts`, such as `build.gradle.kts`).
 const kotlinLanguage = Grammar(
   name: 'kotlin',
+  editing: EditingSyntax.cStyle,
   aliases: ['kt', 'kts'],
   fileExtensions: ['kt', 'kts'],
   shebangs: ['kotlin'],
diff --git a/val_highlight/lib/languages/latex.dart b/val_highlight/lib/languages/latex.dart
index 9a6db06..6b5a4d1 100644
--- a/val_highlight/lib/languages/latex.dart
+++ b/val_highlight/lib/languages/latex.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// LaTeX and TeX.
 const latexLanguage = Grammar(
   name: 'latex',
+  editing: EditingSyntax(lineComment: '%', quotes: ''),
   aliases: ['tex'],
   fileExtensions: ['tex', 'sty', 'cls', 'ltx', 'bib'],
   // Inline math can wrap across lines, but never across a blank line.
diff --git a/val_highlight/lib/languages/less.dart b/val_highlight/lib/languages/less.dart
index 1291573..1c2bbe1 100644
--- a/val_highlight/lib/languages/less.dart
+++ b/val_highlight/lib/languages/less.dart
@@ -9,6 +9,7 @@ const _atRules =
 /// Less.
 const lessLanguage = Grammar(
   name: 'less',
+  editing: EditingSyntax.cStyle,
   fileExtensions: ['less'],
   caseInsensitive: true,
   signatures: [
diff --git a/val_highlight/lib/languages/lua.dart b/val_highlight/lib/languages/lua.dart
index bee7a7f..44987c7 100644
--- a/val_highlight/lib/languages/lua.dart
+++ b/val_highlight/lib/languages/lua.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Lua 5.4, including Luau-style usage in game and editor scripts.
 const luaLanguage = Grammar(
   name: 'lua',
+  editing: EditingSyntax(lineComment: '--', blockComment: ('--[[', ']]')),
   aliases: ['luau'],
   fileExtensions: ['lua', 'luau', 'rockspec'],
   shebangs: ['lua', 'luajit'],
diff --git a/val_highlight/lib/languages/makefile.dart b/val_highlight/lib/languages/makefile.dart
index 6049af3..1e8c937 100644
--- a/val_highlight/lib/languages/makefile.dart
+++ b/val_highlight/lib/languages/makefile.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Make (GNU make syntax).
 const makefileLanguage = Grammar(
   name: 'makefile',
+  editing: EditingSyntax.hashStyle,
   aliases: ['make', 'mk', 'mak'],
   fileExtensions: ['mk', 'mak'],
   fileNames: ['Makefile', 'GNUmakefile', 'makefile'],
diff --git a/val_highlight/lib/languages/markdown.dart b/val_highlight/lib/languages/markdown.dart
index 59513ff..c57ef59 100644
--- a/val_highlight/lib/languages/markdown.dart
+++ b/val_highlight/lib/languages/markdown.dart
@@ -7,6 +7,7 @@ import '../advanced.dart';
 /// registry; otherwise their content is scoped as [Scopes.code].
 const markdownLanguage = Grammar(
   name: 'markdown',
+  editing: EditingSyntax(blockComment: ('<!--', '-->'), quotes: '`'),
   aliases: ['md', 'mkdown', 'mkd'],
   fileExtensions: ['md', 'markdown', 'mkd'],
   // Inline code can wrap across lines, but never across a blank line.
@@ -39,6 +40,7 @@ const markdownLanguage = Grammar(
       endReferencesBegin: true,
       rules: [TokenRule(r'[^\n]+', scope: Scopes.code)],
     ),
+    BlockComment('<!--', '-->'),
     TokenRule(r'^#{1,6}(?=[ \t]|$).*$', scope: Scopes.heading),
     TokenRule(r'^.+\n(?:=+|-+)[ \t]*$', scope: Scopes.heading),
     TokenRule(r'^[ \t]*(?:[-*_][ \t]*){3,}$', scope: Scopes.meta),
diff --git a/val_highlight/lib/languages/nasm.dart b/val_highlight/lib/languages/nasm.dart
index 46ed24f..a88ad96 100644
--- a/val_highlight/lib/languages/nasm.dart
+++ b/val_highlight/lib/languages/nasm.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// x86 assembly in NASM/YASM syntax.
 const nasmLanguage = Grammar(
   name: 'nasm',
+  editing: EditingSyntax(lineComment: ';', quotes: '"\'`'),
   aliases: ['asm', 'x86asm', 'assembly'],
   fileExtensions: ['asm', 'nasm', 's'],
   caseInsensitive: true,
diff --git a/val_highlight/lib/languages/nginx.dart b/val_highlight/lib/languages/nginx.dart
index 6a19cf5..d34f5bd 100644
--- a/val_highlight/lib/languages/nginx.dart
+++ b/val_highlight/lib/languages/nginx.dart
@@ -8,6 +8,7 @@ const _blocks =
 /// nginx configuration.
 const nginxLanguage = Grammar(
   name: 'nginx',
+  editing: EditingSyntax.hashStyle,
   aliases: ['nginxconf'],
   fileNames: ['nginx.conf'],
   signatures: [
diff --git a/val_highlight/lib/languages/objectivec.dart b/val_highlight/lib/languages/objectivec.dart
index f1cb737..c8c43df 100644
--- a/val_highlight/lib/languages/objectivec.dart
+++ b/val_highlight/lib/languages/objectivec.dart
@@ -4,6 +4,7 @@ import 'c.dart';
 /// Objective-C and Objective-C++.
 const objectiveCLanguage = Grammar(
   name: 'objectivec',
+  editing: EditingSyntax.cStyle,
   aliases: ['objc', 'objective-c', 'obj-c', 'objectivecpp', 'objc++'],
   fileExtensions: ['m', 'mm'],
   signatures: [
diff --git a/val_highlight/lib/languages/ocaml.dart b/val_highlight/lib/languages/ocaml.dart
index af24c12..1a5e178 100644
--- a/val_highlight/lib/languages/ocaml.dart
+++ b/val_highlight/lib/languages/ocaml.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// OCaml.
 const ocamlLanguage = Grammar(
   name: 'ocaml',
+  editing: EditingSyntax(blockComment: ('(*', '*)'), quotes: '"'),
   aliases: ['ml'],
   fileExtensions: ['ml', 'mli'],
   signatures: [
diff --git a/val_highlight/lib/languages/perl.dart b/val_highlight/lib/languages/perl.dart
index 65161a6..7cda29c 100644
--- a/val_highlight/lib/languages/perl.dart
+++ b/val_highlight/lib/languages/perl.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Perl 5.
 const perlLanguage = Grammar(
   name: 'perl',
+  editing: EditingSyntax(lineComment: '#', quotes: '"\'`'),
   aliases: ['pl', 'pm'],
   fileExtensions: ['pl', 'pm', 't', 'psgi'],
   shebangs: ['perl'],
diff --git a/val_highlight/lib/languages/php.dart b/val_highlight/lib/languages/php.dart
index 3b15e08..5804bd7 100644
--- a/val_highlight/lib/languages/php.dart
+++ b/val_highlight/lib/languages/php.dart
@@ -8,6 +8,7 @@ import 'html.dart';
 /// starts with markup is HTML until its first PHP tag.
 const phpLanguage = Grammar(
   name: 'php',
+  editing: EditingSyntax.cStyle,
   aliases: ['php8', 'phtml'],
   fileExtensions: ['php', 'phtml', 'php8', 'php7'],
   shebangs: ['php'],
diff --git a/val_highlight/lib/languages/plaintext.dart b/val_highlight/lib/languages/plaintext.dart
index 6b610eb..a80b5ff 100644
--- a/val_highlight/lib/languages/plaintext.dart
+++ b/val_highlight/lib/languages/plaintext.dart
@@ -4,6 +4,7 @@ import '../val_highlight.dart';
 /// is used for placeholders and for code in an unknown language.
 const plainTextLanguage = Grammar(
   name: 'plaintext',
+  editing: EditingSyntax.none,
   detectable: false,
   aliases: ['text', 'txt', 'plain'],
   fileExtensions: ['txt'],
diff --git a/val_highlight/lib/languages/powershell.dart b/val_highlight/lib/languages/powershell.dart
index 5aeb8c0..830db17 100644
--- a/val_highlight/lib/languages/powershell.dart
+++ b/val_highlight/lib/languages/powershell.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// PowerShell. Keywords and operators are case-insensitive.
 const powershellLanguage = Grammar(
   name: 'powershell',
+  editing: EditingSyntax(lineComment: '#', blockComment: ('<#', '#>')),
   aliases: ['ps1', 'pwsh', 'ps', 'posh'],
   fileExtensions: ['ps1', 'psm1', 'psd1'],
   shebangs: ['pwsh', 'powershell'],
diff --git a/val_highlight/lib/languages/protobuf.dart b/val_highlight/lib/languages/protobuf.dart
index 347c455..9255bbb 100644
--- a/val_highlight/lib/languages/protobuf.dart
+++ b/val_highlight/lib/languages/protobuf.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Protocol Buffers (proto2, proto3 and editions).
 const protobufLanguage = Grammar(
   name: 'protobuf',
+  editing: EditingSyntax.cStyle,
   aliases: ['proto'],
   fileExtensions: ['proto'],
   signatures: [
diff --git a/val_highlight/lib/languages/python.dart b/val_highlight/lib/languages/python.dart
index e1ddda7..cff2c3d 100644
--- a/val_highlight/lib/languages/python.dart
+++ b/val_highlight/lib/languages/python.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Python 3.
 const pythonLanguage = Grammar(
   name: 'python',
+  editing: EditingSyntax.hashStyle,
   aliases: ['py', 'py3', 'gyp'],
   fileExtensions: ['py', 'pyw', 'pyi'],
   shebangs: ['python', 'python3'],
diff --git a/val_highlight/lib/languages/r.dart b/val_highlight/lib/languages/r.dart
index e987814..0950f03 100644
--- a/val_highlight/lib/languages/r.dart
+++ b/val_highlight/lib/languages/r.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// R.
 const rLanguage = Grammar(
   name: 'r',
+  editing: EditingSyntax(lineComment: '#', quotes: '"\'`'),
   aliases: ['rscript', 'splus'],
   fileExtensions: ['r', 'rprofile'],
   fileNames: ['.Rprofile'],
diff --git a/val_highlight/lib/languages/ruby.dart b/val_highlight/lib/languages/ruby.dart
index 0b312ba..4af6f43 100644
--- a/val_highlight/lib/languages/ruby.dart
+++ b/val_highlight/lib/languages/ruby.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Ruby, including Gemfiles, Podfiles, Rakefiles and Fastlane files.
 const rubyLanguage = Grammar(
   name: 'ruby',
+  editing: EditingSyntax(lineComment: '#', quotes: '"\'`'),
   aliases: ['rb', 'jruby', 'podfile', 'gemfile'],
   fileExtensions: ['rb', 'rake', 'gemspec', 'podspec', 'ru', 'rbw', 'thor'],
   fileNames: [
diff --git a/val_highlight/lib/languages/rust.dart b/val_highlight/lib/languages/rust.dart
index 357ad70..979042f 100644
--- a/val_highlight/lib/languages/rust.dart
+++ b/val_highlight/lib/languages/rust.dart
@@ -3,6 +3,11 @@ import '../advanced.dart';
 /// Rust.
 const rustLanguage = Grammar(
   name: 'rust',
+  editing: EditingSyntax(
+    lineComment: '//',
+    blockComment: ('/*', '*/'),
+    quotes: '"',
+  ),
   aliases: ['rs'],
   fileExtensions: ['rs'],
   signatures: [
diff --git a/val_highlight/lib/languages/scala.dart b/val_highlight/lib/languages/scala.dart
index ace51ce..985f9e3 100644
--- a/val_highlight/lib/languages/scala.dart
+++ b/val_highlight/lib/languages/scala.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Scala 2 and 3.
 const scalaLanguage = Grammar(
   name: 'scala',
+  editing: EditingSyntax.cStyle,
   aliases: ['sc'],
   fileExtensions: ['scala', 'sc', 'sbt'],
   signatures: [
diff --git a/val_highlight/lib/languages/scss.dart b/val_highlight/lib/languages/scss.dart
index 472a645..419033a 100644
--- a/val_highlight/lib/languages/scss.dart
+++ b/val_highlight/lib/languages/scss.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Sass in SCSS syntax.
 const scssLanguage = Grammar(
   name: 'scss',
+  editing: EditingSyntax.cStyle,
   aliases: ['sass'],
   fileExtensions: ['scss'],
   caseInsensitive: true,
diff --git a/val_highlight/lib/languages/solidity.dart b/val_highlight/lib/languages/solidity.dart
index 073d262..3cc5a00 100644
--- a/val_highlight/lib/languages/solidity.dart
+++ b/val_highlight/lib/languages/solidity.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Solidity.
 const solidityLanguage = Grammar(
   name: 'solidity',
+  editing: EditingSyntax.cStyle,
   aliases: ['sol'],
   fileExtensions: ['sol'],
   signatures: [
diff --git a/val_highlight/lib/languages/sql.dart b/val_highlight/lib/languages/sql.dart
index b644186..7eea888 100644
--- a/val_highlight/lib/languages/sql.dart
+++ b/val_highlight/lib/languages/sql.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// SQL, covering the common ANSI syntax plus popular dialect keywords.
 const sqlLanguage = Grammar(
   name: 'sql',
+  editing: EditingSyntax(lineComment: '--', blockComment: ('/*', '*/')),
   aliases: ['postgresql', 'postgres', 'mysql', 'sqlite', 'plsql', 'tsql'],
   fileExtensions: ['sql'],
   caseInsensitive: true,
diff --git a/val_highlight/lib/languages/swift.dart b/val_highlight/lib/languages/swift.dart
index ea650f5..c1847ea 100644
--- a/val_highlight/lib/languages/swift.dart
+++ b/val_highlight/lib/languages/swift.dart
@@ -3,6 +3,11 @@ import '../advanced.dart';
 /// Swift (6), including raw strings, macros and result builders.
 const swiftLanguage = Grammar(
   name: 'swift',
+  editing: EditingSyntax(
+    lineComment: '//',
+    blockComment: ('/*', '*/'),
+    quotes: '"',
+  ),
   fileExtensions: ['swift'],
   shebangs: ['swift'],
   signatures: [
diff --git a/val_highlight/lib/languages/toml.dart b/val_highlight/lib/languages/toml.dart
index 3cb1aba..d36a3e6 100644
--- a/val_highlight/lib/languages/toml.dart
+++ b/val_highlight/lib/languages/toml.dart
@@ -9,6 +9,7 @@ const _dottedKey = '$_key(?:[ \\t]*\\.[ \\t]*$_key)*';
 /// TOML.
 const tomlLanguage = Grammar(
   name: 'toml',
+  editing: EditingSyntax.hashStyle,
   fileExtensions: ['toml'],
   fileNames: ['Cargo.lock', 'Pipfile', 'poetry.lock'],
   signatures: [
diff --git a/val_highlight/lib/languages/tsx.dart b/val_highlight/lib/languages/tsx.dart
index fe2e12f..67d1462 100644
--- a/val_highlight/lib/languages/tsx.dart
+++ b/val_highlight/lib/languages/tsx.dart
@@ -4,6 +4,11 @@ import '../src/languages/ecmascript.dart';
 /// TypeScript with JSX elements, as used by React.
 const tsxLanguage = Grammar(
   name: 'tsx',
+  editing: EditingSyntax(
+    lineComment: '//',
+    blockComment: ('/*', '*/'),
+    quotes: '"\'`',
+  ),
   fileExtensions: ['tsx'],
   signatures: [
     r'\breturn\s*\(?\s*<[A-Za-z>]',
diff --git a/val_highlight/lib/languages/typescript.dart b/val_highlight/lib/languages/typescript.dart
index 36579d4..0212e64 100644
--- a/val_highlight/lib/languages/typescript.dart
+++ b/val_highlight/lib/languages/typescript.dart
@@ -4,6 +4,11 @@ import '../src/languages/ecmascript.dart';
 /// TypeScript.
 const typescriptLanguage = Grammar(
   name: 'typescript',
+  editing: EditingSyntax(
+    lineComment: '//',
+    blockComment: ('/*', '*/'),
+    quotes: '"\'`',
+  ),
   aliases: ['ts', 'mts', 'cts'],
   fileExtensions: ['ts', 'mts', 'cts'],
   shebangs: ['ts-node', 'tsx'],
diff --git a/val_highlight/lib/languages/xml.dart b/val_highlight/lib/languages/xml.dart
index 0c36394..04867f2 100644
--- a/val_highlight/lib/languages/xml.dart
+++ b/val_highlight/lib/languages/xml.dart
@@ -4,6 +4,7 @@ import '../src/languages/markup.dart';
 /// XML, including SVG, plist and similar formats.
 const xmlLanguage = Grammar(
   name: 'xml',
+  editing: EditingSyntax.markupStyle,
   aliases: ['svg', 'plist', 'xsd', 'xsl', 'rss', 'atom'],
   fileExtensions: ['xml', 'svg', 'plist', 'xsd', 'xsl', 'xslt', 'rss'],
   signatures: [r'^\s*<\?xml\b', r'\bxmlns(?::\w+)?='],
diff --git a/val_highlight/lib/languages/yaml.dart b/val_highlight/lib/languages/yaml.dart
index 7bc771a..4ee6214 100644
--- a/val_highlight/lib/languages/yaml.dart
+++ b/val_highlight/lib/languages/yaml.dart
@@ -23,6 +23,7 @@ const _blockEnd = r'^(?![ \t]*$)(?!\1[ \t])|(?![\s\S])';
 /// YAML.
 const yamlLanguage = Grammar(
   name: 'yaml',
+  editing: EditingSyntax.hashStyle,
   aliases: ['yml'],
   fileExtensions: ['yaml', 'yml'],
   signatures: [
diff --git a/val_highlight/lib/languages/zig.dart b/val_highlight/lib/languages/zig.dart
index d84917a..1c52511 100644
--- a/val_highlight/lib/languages/zig.dart
+++ b/val_highlight/lib/languages/zig.dart
@@ -3,6 +3,7 @@ import '../advanced.dart';
 /// Zig.
 const zigLanguage = Grammar(
   name: 'zig',
+  editing: EditingSyntax(lineComment: '//'),
   fileExtensions: ['zig', 'zon'],
   signatures: [
     r'@import\("std"\)',
diff --git a/val_highlight/lib/src/engine/scope_table.dart b/val_highlight/lib/src/engine/scope_table.dart
index f1f8a20..1e1b336 100644
--- a/val_highlight/lib/src/engine/scope_table.dart
+++ b/val_highlight/lib/src/engine/scope_table.dart
@@ -1,3 +1,5 @@
+import 'dart:typed_data';
+
 /// Interned scope names and scope stacks for one highlight result.
 ///
 /// Every token records a single stack id. A stack is a chain of scopes from
@@ -18,6 +20,11 @@ final class ScopeTable {
   final Map<int, int> _stackIds = {};
   List<List<int>?>? _paths;
 
+  // Per stack: bit 0 = inside a string, comment or regexp; bit 1 = inside a
+  // comment. Grown lazily, since stacks are only ever appended.
+  Uint8List _kinds = Uint8List(0);
+  int _kindCount = 0;
+
   /// Number of stacks, including the root.
   int get stackCount => _parents.length;
 
@@ -73,4 +80,38 @@ final class ScopeTable {
     paths[stack] = path;
     return path;
   }
+
+  /// Whether [stack] is inside a string, comment or regular expression.
+  ///
+  /// An interpolation inside a string, such as `${x}`, is code again: its
+  /// stacks are not.
+  bool isStringOrComment(int stack) => _kind(stack) & 1 != 0;
+
+  /// Whether [stack] is inside a comment.
+  bool isComment(int stack) => _kind(stack) & 2 != 0;
+
+  int _kind(int stack) {
+    if (stack >= _kindCount) _classify();
+    return _kinds[stack];
+  }
+
+  void _classify() {
+    final count = stackCount;
+    if (_kinds.length < count) {
+      _kinds = Uint8List(count < 64 ? 64 : count * 2)
+        ..setRange(0, _kindCount, _kinds);
+    }
+    for (var id = _kindCount == 0 ? 1 : _kindCount; id < count; id++) {
+      final name = _names[_scopes[id]];
+      final dot = name.indexOf('.');
+      final head = dot < 0 ? name : name.substring(0, dot);
+      _kinds[id] = switch (head) {
+        'comment' => 3,
+        'string' || 'regexp' => _kinds[_parents[id]] | 1,
+        'interpolation' => 0,
+        _ => _kinds[_parents[id]],
+      };
+    }
+    _kindCount = count;
+  }
 }
diff --git a/val_highlight/lib/src/grammar/editing.dart b/val_highlight/lib/src/grammar/editing.dart
new file mode 100644
index 0000000..5fc9ab7
--- /dev/null
+++ b/val_highlight/lib/src/grammar/editing.dart
@@ -0,0 +1,147 @@
+part of 'grammar.dart';
+
+/// How code in a language is edited: its comment markers, brackets and
+/// quotes.
+///
+/// Editors use this to toggle comments, auto-close brackets and quotes and
+/// match brackets. Set it on a grammar with [Grammar.editing]; read it with
+/// [EditingSyntax.of], which derives one from the grammar's [LineComment],
+/// [BlockComment] and [QuotedString] blocks when none is set.
+///
+/// ```dart
+/// const myLanguage = Grammar(
+///   name: 'mine',
+///   rules: [...],
+///   editing: EditingSyntax(lineComment: '--', quotes: '"'),
+/// );
+/// ```
+final class EditingSyntax {
+  /// Creates editing conventions for a language.
+  const EditingSyntax({
+    this.lineComment,
+    this.blockComment,
+    this.brackets = '()[]{}',
+    this.quotes = '"\'',
+  });
+
+  /// `//` line comments, `/* */` block comments, and `"` `'` quotes: C, Java,
+  /// Kotlin, Swift and most of their relatives.
+  static const cStyle = EditingSyntax(
+    lineComment: '//',
+    blockComment: ('/*', '*/'),
+  );
+
+  /// `#` line comments: shells, Python, Ruby, YAML and many config formats.
+  static const hashStyle = EditingSyntax(lineComment: '#');
+
+  /// `<!-- -->` block comments: HTML, XML and Markdown.
+  static const markupStyle = EditingSyntax(blockComment: ('<!--', '-->'));
+
+  /// No comments, brackets or quotes: plain text.
+  static const none = EditingSyntax(brackets: '', quotes: '');
+
+  /// Text that starts a line comment, such as `//` or `#`, or `null` if the
+  /// language has none.
+  final String? lineComment;
+
+  /// The opening and closing text of a block comment, such as `('/*',
+  /// '*/')`, or `null` if the language has none.
+  final (String, String)? blockComment;
+
+  /// Bracket pairs, as consecutive opening and closing characters: `'()[]{}'`
+  /// stands for `()`, `[]` and `{}`. Used for matching and auto-closing.
+  final String brackets;
+
+  /// Characters that open and close a string, such as `"` and `'`.
+  /// Auto-closed like brackets, except after a letter or digit, so `don't`
+  /// is left alone. Leave out characters with another meaning, such as `'`
+  /// in Rust lifetimes or Lisp quoting.
+  final String quotes;
+
+  /// Returns a copy with the given fields replaced.
+  EditingSyntax copyWith({
+    String? lineComment,
+    (String, String)? blockComment,
+    String? brackets,
+    String? quotes,
+  }) {
+    return EditingSyntax(
+      lineComment: lineComment ?? this.lineComment,
+      blockComment: blockComment ?? this.blockComment,
+      brackets: brackets ?? this.brackets,
+      quotes: quotes ?? this.quotes,
+    );
+  }
+
+  /// The closing character for [open], or `null` if [open] opens nothing.
+  ///
+  /// Brackets close with their pair and quotes with themselves.
+  String? closerOf(String open) {
+    for (var i = 0; i + 1 < brackets.length; i += 2) {
+      if (brackets[i] == open) return brackets[i + 1];
+    }
+    return quotes.contains(open) ? open : null;
+  }
+
+  static final Expando<EditingSyntax> _derived = Expando('EditingSyntax');
+
+  /// The editing conventions of [grammar]: its [Grammar.editing], or, when
+  /// that is unset, conventions derived from its comment and string blocks.
+  ///
+  /// Derivation looks at the top-level rules and the repository. The
+  /// shortest [LineComment] and [BlockComment] markers win, so `//` beats
+  /// `///`. Quotes come from single-character [QuotedString]s, and default
+  /// to `"` and `'` when there are none. The result is cached per grammar.
+  static EditingSyntax of(Grammar grammar) =>
+      grammar.editing ?? (_derived[grammar] ??= _derive(grammar));
+
+  static EditingSyntax _derive(Grammar grammar) {
+    String? line;
+    (String, String)? block;
+    final quotes = StringBuffer();
+    void visit(Rule rule) {
+      switch (rule) {
+        case LineComment(:final start, :final scope)
+            when scope == Scopes.comment &&
+                (line == null || start.length < line!.length):
+          line = start;
+        case BlockComment(:final open, :final close, :final scope)
+            when scope == Scopes.comment &&
+                (block == null || open.length < block!.$1.length):
+          block = (open, close);
+        case QuotedString(:final quote, :final end)
+            when quote.length == 1 &&
+                (end == null || end == quote) &&
+                !quotes.toString().contains(quote):
+          quotes.write(quote);
+        default:
+      }
+    }
+
+    grammar.rules.forEach(visit);
+    for (final list in grammar.repository.values) {
+      list.forEach(visit);
+    }
+    return EditingSyntax(
+      lineComment: line,
+      blockComment: block,
+      quotes: quotes.isEmpty ? '"\'' : quotes.toString(),
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      other is EditingSyntax &&
+      other.lineComment == lineComment &&
+      other.blockComment == blockComment &&
+      other.brackets == brackets &&
+      other.quotes == quotes;
+
+  @override
+  int get hashCode => Object.hash(lineComment, blockComment, brackets, quotes);
+
+  @override
+  String toString() =>
+      'EditingSyntax(lineComment: $lineComment, blockComment: $blockComment, '
+      'brackets: $brackets, quotes: $quotes)';
+}
diff --git a/val_highlight/lib/src/grammar/grammar.dart b/val_highlight/lib/src/grammar/grammar.dart
index 50f43c5..3e8e162 100644
--- a/val_highlight/lib/src/grammar/grammar.dart
+++ b/val_highlight/lib/src/grammar/grammar.dart
@@ -2,6 +2,7 @@ import '../engine/compiler.dart';
 import 'scopes.dart';
 
 part 'blocks.dart';
+part 'editing.dart';
 
 /// A language grammar: an ordered list of [Rule]s plus a named repository of
 /// reusable rule lists.
@@ -27,6 +28,7 @@ final class Grammar {
     this.signatures = const [],
     this.restartLine,
     this.detectable = true,
+    this.editing,
   });
 
   /// Canonical, lower-case language name, such as `dart`.
@@ -75,6 +77,11 @@ final class Grammar {
   /// grammars such as plain text and the generic fallback.
   final bool detectable;
 
+  /// How code in this language is edited: comment markers, brackets and
+  /// quotes. When `null`, [EditingSyntax.of] derives them from the
+  /// grammar's comment and string blocks.
+  final EditingSyntax? editing;
+
   /// Returns a new grammar based on this one.
   ///
   /// [rules] are placed *before* the existing top-level rules, so they take
@@ -88,6 +95,7 @@ final class Grammar {
     List<String>? aliases,
     List<String>? fileExtensions,
     List<String>? fileNames,
+    EditingSyntax? editing,
   }) {
     return Grammar(
       name: name ?? this.name,
@@ -102,6 +110,7 @@ final class Grammar {
       signatures: signatures,
       restartLine: restartLine,
       detectable: detectable,
+      editing: editing ?? this.editing,
     );
   }
 
@@ -179,6 +188,7 @@ final class Grammar {
       signatures: signatures,
       restartLine: restartLine,
       detectable: detectable,
+      editing: editing,
     );
   }
 
diff --git a/val_highlight/lib/src/result.dart b/val_highlight/lib/src/result.dart
index d090c0f..b604250 100644
--- a/val_highlight/lib/src/result.dart
+++ b/val_highlight/lib/src/result.dart
@@ -122,6 +122,129 @@ final class HighlightResult {
     }
   }
 
+  /// Whether the character at [offset] is inside a string, comment or
+  /// regular expression. Interpolations inside strings count as code.
+  bool isStringOrCommentAt(int offset) {
+    if (offset < 0 || offset >= code.length) return false;
+    return scopes.isStringOrComment(_stacks[tokenAt(offset)]);
+  }
+
+  /// Whether the character at [offset] is inside a comment.
+  bool isCommentAt(int offset) {
+    if (offset < 0 || offset >= code.length) return false;
+    return scopes.isComment(_stacks[tokenAt(offset)]);
+  }
+
+  /// Whether text typed at caret position [offset], between
+  /// `code[offset - 1]` and `code[offset]`, would land inside a string or
+  /// comment.
+  ///
+  /// Unlike [isStringOrCommentAt], this answers for a position between
+  /// characters: right after a closing quote is outside the string, while
+  /// the end of a line comment or of an unterminated string is inside.
+  /// [syntax] supplies the block comment marker; it defaults to
+  /// [EditingSyntax.of] the [language].
+  bool isInsideStringOrComment(int offset, [EditingSyntax? syntax]) {
+    if (offset <= 0 || offset > code.length) return false;
+    final before = tokenAt(offset - 1);
+    final stack = _stacks[before];
+    if (!scopes.isStringOrComment(stack)) return false;
+    if (_ends[before] > offset) return true;
+    if (offset < code.length) {
+      if (scopes.isStringOrComment(_stacks[before + 1])) return true;
+      final next = code.codeUnitAt(offset);
+      if (next != 0x0A && next != 0x0D) return false;
+    }
+    // At the end of a line, right after a string or comment: still inside
+    // unless it was closed there.
+    if (scopes.isComment(stack)) {
+      final close = (syntax ?? EditingSyntax.of(language)).blockComment?.$2;
+      return close == null ||
+          offset - close.length <= tokenStart(before) ||
+          !code.startsWith(close, offset - close.length);
+    }
+    final last = code.codeUnitAt(offset - 1);
+    final quote = last == 0x22 || last == 0x27 || last == 0x60;
+    final opened =
+        tokenStart(before) < offset - 1 ||
+        (before > 0 && scopes.isStringOrComment(_stacks[before - 1]));
+    return !(quote && opened);
+  }
+
+  /// Offset of the bracket matching the one at [offset], or `-1` if the
+  /// character at [offset] is not a bracket in code, or has no match within
+  /// [limit] characters.
+  ///
+  /// [brackets] lists pairs as consecutive opening and closing characters,
+  /// as in [EditingSyntax.brackets]. Brackets inside strings and comments
+  /// are skipped, so `f(")")` matches correctly. The search walks tokens,
+  /// jumping over a whole string or comment at once.
+  int matchingBracket(
+    int offset, {
+    String brackets = '()[]{}',
+    int limit = 1 << 20,
+  }) {
+    if (offset < 0 || offset >= code.length) return -1;
+    final unit = code.codeUnitAt(offset);
+    var pair = -1;
+    for (var i = 0; i + 1 < brackets.length; i += 2) {
+      if (brackets.codeUnitAt(i) == unit) {
+        pair = i;
+        break;
+      }
+      if (brackets.codeUnitAt(i + 1) == unit) {
+        pair = i + 1;
+        break;
+      }
+    }
+    if (pair < 0) return -1;
+    final open = brackets.codeUnitAt(pair & ~1);
+    final close = brackets.codeUnitAt(pair | 1);
+    if (open == close) return -1;
+    var token = tokenAt(offset);
+    if (scopes.isStringOrComment(_stacks[token])) return -1;
+    var depth = 0;
+    var i = offset;
+    if (pair.isEven) {
+      final stop = code.length - offset > limit ? offset + limit : code.length;
+      while (i < stop) {
+        final end = _ends[token];
+        if (!scopes.isStringOrComment(_stacks[token])) {
+          final until = end < stop ? end : stop;
+          for (; i < until; i++) {
+            final c = code.codeUnitAt(i);
+            if (c == open) {
+              depth++;
+            } else if (c == close && --depth == 0) {
+              return i;
+            }
+          }
+        }
+        i = end;
+        token++;
+      }
+    } else {
+      final stop = offset > limit ? offset - limit : 0;
+      while (i >= stop) {
+        final start = tokenStart(token);
+        if (!scopes.isStringOrComment(_stacks[token])) {
+          final until = start > stop ? start : stop;
+          for (; i >= until; i--) {
+            final c = code.codeUnitAt(i);
+            if (c == close) {
+              depth++;
+            } else if (c == open && --depth == 0) {
+              return i;
+            }
+          }
+        }
+        i = start - 1;
+        token--;
+      }
+    }
+    return -1;
+  }
+
   /// Renders the result as HTML. See [HtmlRenderer] for options.
   String toHtml([HtmlRenderer renderer = const HtmlRenderer()]) =>
       renderer.render(this);
diff --git a/val_highlight/lib/val_highlight.dart b/val_highlight/lib/val_highlight.dart
index 9e1b707..2fdd074 100644
--- a/val_highlight/lib/val_highlight.dart
+++ b/val_highlight/lib/val_highlight.dart
@@ -15,7 +15,7 @@ library;
 
 export 'src/detect.dart' show Detection, LanguageDetector;
 export 'src/engine/scope_table.dart' show ScopeTable;
-export 'src/grammar/grammar.dart' show Grammar, GrammarException;
+export 'src/grammar/grammar.dart' show EditingSyntax, Grammar, GrammarException;
 export 'src/grammar/scopes.dart' show Scopes;
 export 'src/highlighter.dart' show Highlighter;
 export 'src/incremental.dart' show IncrementalHighlighter;
diff --git a/val_highlight/test/editing_test.dart b/val_highlight/test/editing_test.dart
new file mode 100644
index 0000000..e6c8b95
--- /dev/null
+++ b/val_highlight/test/editing_test.dart
@@ -0,0 +1,195 @@
+import 'package:test/test.dart';
+import 'package:val_highlight/advanced.dart';
+import 'package:val_highlight/languages/all.dart';
+
+HighlightResult _dart(String code) =>
+    const Highlighter().highlight(code, language: dartLanguage);
+
+void main() {
+  group('EditingSyntax', () {
+    test('every built-in language declares its syntax', () {
+      for (final language in allLanguages) {
+        expect(language.editing, isNotNull, reason: language.name);
+      }
+    });
+
+    test('declared comment markers highlight as comments', () {
+      for (final language in allLanguages) {
+        final syntax = EditingSyntax.of(language);
+        final line = syntax.lineComment;
+        if (line != null) {
+          final result = const Highlighter().highlight(
+            '$line note\n',
+            language: language,
+          );
+          expect(result.isCommentAt(0), isTrue, reason: language.name);
+        }
+        final block = syntax.blockComment;
+        if (block != null) {
+          final code = '${block.$1} note ${block.$2}\n';
+          final result = const Highlighter().highlight(
+            code,
+            language: language,
+          );
+          expect(result.isCommentAt(0), isTrue, reason: language.name);
+          expect(
+            result.isCommentAt(code.length - 2),
+            isTrue,
+            reason: language.name,
+          );
+        }
+      }
+    });
+
+    test('is derived from comment and string blocks', () {
+      const grammar = Grammar(
+        name: 'custom',
+        rules: [
+          LineComment('///', scope: Scopes.commentDoc),
+          LineComment('--'),
+          BlockComment('{-', '-}'),
+          QuotedString('"'),
+          QuotedString('"""'),
+        ],
+      );
+      final syntax = EditingSyntax.of(grammar);
+      expect(syntax.lineComment, '--');
+      expect(syntax.blockComment, ('{-', '-}'));
+      expect(syntax.quotes, '"');
+      expect(syntax.brackets, '()[]{}');
+      expect(identical(EditingSyntax.of(grammar), syntax), isTrue);
+    });
+
+    test('defaults to common quotes when a grammar declares none', () {
+      const grammar = Grammar(name: 'bare', rules: []);
+      final syntax = EditingSyntax.of(grammar);
+      expect(syntax.lineComment, isNull);
+      expect(syntax.blockComment, isNull);
+      expect(syntax.quotes, '"\'');
+    });
+
+    test('extend keeps or replaces the syntax', () {
+      expect(dartLanguage.extend().editing, EditingSyntax.cStyle);
+      expect(
+        dartLanguage.withKeywords(remove: ['var']).editing,
+        EditingSyntax.cStyle,
+      );
+      const hash = EditingSyntax(lineComment: '#');
+      expect(dartLanguage.extend(editing: hash).editing, hash);
+    });
+
+    test('closerOf pairs brackets and quotes', () {
+      const syntax = EditingSyntax(quotes: '"`');
+      expect(syntax.closerOf('('), ')');
+      expect(syntax.closerOf('{'), '}');
+      expect(syntax.closerOf('"'), '"');
+      expect(syntax.closerOf('`'), '`');
+      expect(syntax.closerOf("'"), isNull);
+      expect(syntax.closerOf(')'), isNull);
+    });
+  });
+
+  group('string and comment context', () {
+    test('characters in strings and comments', () {
+      const code = 'f("a(") // b(';
+      final result = _dart(code);
+      expect(result.isStringOrCommentAt(0), isFalse);
+      expect(result.isStringOrCommentAt(code.indexOf('a')), isTrue);
+      expect(result.isCommentAt(code.indexOf('a')), isFalse);
+      expect(result.isCommentAt(code.indexOf('b')), isTrue);
+      expect(result.isStringOrCommentAt(-1), isFalse);
+      expect(result.isStringOrCommentAt(code.length), isFalse);
+    });
+
+    test('interpolations are code again', () {
+      const code = r'"x ${f(1)} y"';
+      final result = _dart(code);
+      expect(result.isStringOrCommentAt(code.indexOf('x')), isTrue);
+      expect(result.isStringOrCommentAt(code.indexOf('(')), isFalse);
+      expect(result.isStringOrCommentAt(code.indexOf('y')), isTrue);
+    });
+
+    test('caret positions between characters', () {
+      const code = 'a = "bc" + d; // e\nx = "open\n/* c */\n';
+      final result = _dart(code);
+      bool inside(String marker, [int shift = 0]) =>
+          result.isInsideStringOrComment(code.indexOf(marker) + shift);
+
+      expect(inside('a'), isFalse);
+      expect(inside('bc'), isTrue); // just after the opening quote
+      expect(inside('c"'), isTrue);
+      expect(inside('" +'), isTrue); // before the closing quote
+      expect(inside(' + d'), isFalse); // just after the closing quote
+      expect(inside('e\n', 1), isTrue); // end of a line comment
+      expect(inside('open\n', 4), isTrue); // end of an unterminated string
+      expect(inside('*/\n', 2), isFalse); // after a closed block comment
+      expect(result.isInsideStringOrComment(0), isFalse);
+    });
+
+    test('a block comment still open at the end of a line', () {
+      const code = 'a /* b\nc */';
+      final result = _dart(code);
+      expect(result.isInsideStringOrComment(code.indexOf('\n')), isTrue);
+    });
+
+    test('a string closed at the end of a line', () {
+      final result = const Highlighter().highlight(
+        "x = 'a'\n",
+        language: pythonLanguage,
+      );
+      expect(result.isInsideStringOrComment(7), isFalse);
+      expect(result.isInsideStringOrComment(6), isTrue);
+    });
+  });
+
+  group('matchingBracket', () {
+    test('matches forwards and backwards', () {
+      const code = 'f(a[1], {b: (c)})';
+      final result = _dart(code);
+      expect(result.matchingBracket(1), code.length - 1);
+      expect(result.matchingBracket(code.length - 1), 1);
+      expect(result.matchingBracket(3), code.indexOf(']'));
+      expect(result.matchingBracket(code.indexOf(']')), 3);
+      expect(result.matchingBracket(code.indexOf('{')), code.indexOf('}'));
+      expect(result.matchingBracket(code.indexOf('(c')), code.indexOf(')}'));
+    });
+
+    test('skips brackets in strings and comments', () {
+      const code = 'f(")", // )\n  x)';
+      final result = _dart(code);
+      expect(result.matchingBracket(1), code.length - 1);
+      expect(result.matchingBracket(code.length - 1), 1);
+    });
+
+    test('brackets in strings and comments match nothing', () {
+      const code = 'f(")")';
+      final result = _dart(code);
+      expect(result.matchingBracket(3), -1);
+    });
+
+    test('unbalanced, non-bracket and out-of-range offsets', () {
+      final result = _dart('f((x)');
+      expect(result.matchingBracket(1), -1);
+      expect(result.matchingBracket(0), -1);
+      expect(result.matchingBracket(-1), -1);
+      expect(result.matchingBracket(99), -1);
+    });
+
+    test('custom pairs and a search limit', () {
+      final result = _dart('<a<b>>');
+      expect(result.matchingBracket(0), -1);
+      expect(result.matchingBracket(0, brackets: '<>'), 5);
+      expect(result.matchingBracket(5, brackets: '<>'), 0);
+      expect(result.matchingBracket(0, brackets: '<>', limit: 3), -1);
+      expect(result.matchingBracket(5, brackets: '<>', limit: 3), -1);
+    });
+
+    test('works across lines in a large document', () {
+      final body = List.filled(5000, '  x = "}";').join('\n');
+      final code = 'f() {\n$body\n}';
+      final result = _dart(code);
+      expect(result.matchingBracket(4), code.length - 1);
+      expect(result.matchingBracket(code.length - 1), 4);
+    });
+  });
+}
diff --git a/val_highlight_flutter/CHANGELOG.md b/val_highlight_flutter/CHANGELOG.md
index 46e791b..3afc64c 100644
--- a/val_highlight_flutter/CHANGELOG.md
+++ b/val_highlight_flutter/CHANGELOG.md
@@ -1,3 +1,53 @@
+## Unreleased
+
+### Added
+
+* **Editing essentials in `CodeField`**, configured with `CodeEditing`:
+  * brackets and quotes close themselves, a typed closer steps over an
+    automatic one, and Backspace deletes an empty automatic pair. Quotes
+    stay single after a letter or digit and inside strings and comments;
+  * typing a bracket or quote over a selection wraps it;
+  * Enter between brackets, as in `{|}`, moves the closer onto its own
+    line;
+  * Ctrl+/ (Cmd+/ on Apple platforms) comments and uncomments lines, with
+    the language's markers, or wraps a block comment where a language has
+    no line comments. Doc comments (`///`, `//!`) and shebangs are
+    commented out like code rather than stripped;
+  * the bracket at the caret and its match are outlined.
+
+  Brackets, quotes and comment markers come from the language's
+  `EditingSyntax`. Typing is handled as text changes, so it works on
+  on-screen keyboards and voice input as well as hardware keyboards, and
+  text an input method is composing is never changed.
+* **Line numbers in `CodeField`** — `lineNumbers`, `firstLineNumber` and
+  `gutterStyle`, plus `highlightedLines`, `highlightCurrentLine` and their
+  colors. They are painted from the text's own layout, so wrapped lines
+  line up, only visible lines are painted, and they follow the text when
+  a font finishes loading late.
+* **Shortcuts as intents** — `IndentCodeIntent`, `OutdentCodeIntent` and
+  `ToggleCommentIntent`. Rebind keys with `CodeField.shortcuts` (defaults in
+  `CodeField.defaultShortcuts`), or override an intent with an `Actions`
+  widget above the field.
+* **`CodeEditingFormatter`** — the same typing behaviour for a plain
+  `TextField` driven by a `HighlightTextController`.
+* **`toggleComment`** — the comment toggle as a function on a
+  `TextEditingValue`.
+* **`CodeField.inputFormatters`** — more formatters, applied after the
+  editing behaviour.
+* **`CodeField.undoController`** — the field's undo history. Each edit the
+  field makes itself is one undo step.
+
+### Changed
+
+* Typing in `CodeField` now auto-closes brackets and quotes, and Enter
+  between brackets splits them across lines. Pass
+  `editing: CodeEditing.none` for 0.1.0's behaviour, or turn off single
+  behaviours with `CodeEditing`.
+* Enter keeps the indentation on on-screen keyboards too, not only on
+  hardware keyboards.
+* Requires the unreleased `val_highlight` changes above (`EditingSyntax`
+  and the bracket and context queries on `HighlightResult`).
+
 ## 0.1.0
 
 First release.
diff --git a/val_highlight_flutter/README.md b/val_highlight_flutter/README.md
index 8c4ec62..a283566 100644
--- a/val_highlight_flutter/README.md
+++ b/val_highlight_flutter/README.md
@@ -27,8 +27,9 @@
   to show code, `CodeField(controller: …)` to edit it.
 - **Smooth on large files** — a 20,000-line file scrolls with no dropped
   frames, and typing in a 2,000-line editor takes about 14 ms per keystroke.
-- **Real editing** — Tab and Shift+Tab indent and outdent, Enter keeps the
-  indentation, and every edit re-highlights only what it can affect.
+- **Real editing** — auto-closing brackets and quotes, comment toggling,
+  bracket matching, smart indentation and line numbers, on every keyboard;
+  every edit re-highlights only what it can affect.
 - **Native rendering** — plain Flutter text, no WebView and no platform
   code. Works on Android, iOS, macOS, Windows, Linux and the web.
 - **Follows your app** — light and dark themes switch with the app, and
@@ -98,11 +99,55 @@ CodeField(controller: controller, expands: true)
 `CodeField` is a `TextField` for code:
 
 - monospace, no autocorrect or smart quotes;
-- Tab and Shift+Tab indent and outdent (`indent` sets the unit);
+- brackets and quotes close themselves, typing a closer steps over it, and
+  Backspace deletes an empty pair;
+- typing a bracket or quote over a selection wraps it;
 - Enter keeps the current indentation, adding a level after `{`, `[`, `(`
-  or `:`;
+  or `:`, and moves the closer of `{|}` onto its own line;
+- Tab and Shift+Tab indent and outdent (`indent` sets the unit);
+- Ctrl+/ (Cmd+/ on Apple platforms) comments and uncomments lines;
+- the bracket at the caret and its match are outlined;
 - each edit re-scans only the lines it can affect.
 
+Brackets, quotes and comment markers come from the language
+(`EditingSyntax`), so Rust lifetimes or Python `#` comments behave. Typing
+is handled as text changes rather than key presses, so it works the same
+on hardware keyboards, on-screen keyboards and voice input, and never
+touches text an input method is still composing.
+
+```dart
+CodeField(
+  controller: controller,
+  lineNumbers: true,
+  highlightCurrentLine: true,
+  highlightedLines: {3, 4},
+  editing: const CodeEditing(autoClose: false), // or CodeEditing.none
+)
+```
+
+Line numbers and line bands are painted from the text's own layout, so
+wrapped lines line up, and only visible lines are painted.
+
+Each shortcut sends an intent: `IndentCodeIntent`, `OutdentCodeIntent` or
+`ToggleCommentIntent`. Rebind keys with `shortcuts` (`const {}` gives Tab
+back to focus traversal), or change what an intent does with an `Actions`
+widget above the field:
+
+```dart
+Actions(
+  actions: {
+    ToggleCommentIntent: CallbackAction<ToggleCommentIntent>(
+      onInvoke: (_) => myToggle(),
+    ),
+  },
+  child: CodeField(controller: controller),
+)
+```
+
+For a plain `TextField`, add
+`CodeEditingFormatter(controller: controller)` to its `inputFormatters` to
+get the same typing behaviour.
+
 Flutter lays out a text field's whole text on every change, and styled runs
 make that slower. So for documents over 300 lines, `CodeField` colours only
 the visible lines plus a margin, and the coloured window follows scrolling.
diff --git a/val_highlight_flutter/example/lib/main.dart b/val_highlight_flutter/example/lib/main.dart
index db1ffd4..3689317 100644
--- a/val_highlight_flutter/example/lib/main.dart
+++ b/val_highlight_flutter/example/lib/main.dart
@@ -259,6 +259,8 @@ class _EditorPageState extends State<EditorPage> {
             child: CodeField(
               controller: _controller,
               expands: true,
+              lineNumbers: true,
+              highlightCurrentLine: true,
               textAlignVertical: TextAlignVertical.top,
               decoration: const InputDecoration(
                 border: InputBorder.none,
diff --git a/val_highlight_flutter/lib/src/code_editing.dart b/val_highlight_flutter/lib/src/code_editing.dart
new file mode 100644
index 0000000..d41785f
--- /dev/null
+++ b/val_highlight_flutter/lib/src/code_editing.dart
@@ -0,0 +1,779 @@
+import 'package:flutter/services.dart';
+import 'package:flutter/widgets.dart';
+import 'package:val_highlight/val_highlight.dart';
+
+import 'highlight_text_controller.dart';
+
+/// Editing behaviour for `CodeField`: what typing, Enter and Backspace do
+/// beyond inserting text.
+///
+/// Brackets, quotes and comment markers come from the language's
+/// [EditingSyntax], unless [syntax] overrides them.
+///
+/// ```dart
+/// CodeField(
+///   controller: controller,
+///   editing: const CodeEditing(autoClose: false),
+/// )
+/// ```
+///
+/// Use [CodeEditing.none] to turn every behaviour off.
+@immutable
+class CodeEditing {
+  /// Creates editing behaviour. Everything is on by default.
+  const CodeEditing({
+    this.autoIndent = true,
+    this.autoClose = true,
+    this.wrapSelection = true,
+    this.matchBrackets = true,
+    this.syntax,
+  });
+
+  /// Plain text editing: no auto-indent, auto-closing, wrapping or bracket
+  /// matching.
+  static const none = CodeEditing(
+    autoIndent: false,
+    autoClose: false,
+    wrapSelection: false,
+    matchBrackets: false,
+  );
+
+  /// Whether Enter keeps the current line's indentation, adds a level after
+  /// an opening bracket or `:`, and moves a closing bracket right after the
+  /// caret onto its own line.
+  final bool autoIndent;
+
+  /// Whether typing an opening bracket or quote also inserts its closing
+  /// one.
+  ///
+  /// Brackets close when the caret is followed by whitespace, the end of
+  /// the text or a closing character such as `)` or `;`. Quotes also stay
+  /// single after a letter or digit and inside strings and comments.
+  /// Typing a closer that was inserted automatically steps over it, and
+  /// Backspace between an empty automatic pair deletes both.
+  final bool autoClose;
+
+  /// Whether typing an opening bracket or quote over a selection wraps the
+  /// selection instead of replacing it.
+  final bool wrapSelection;
+
+  /// Whether the bracket at the caret and its match are outlined.
+  final bool matchBrackets;
+
+  /// Comment markers, brackets and quotes to use instead of the language's.
+  final EditingSyntax? syntax;
+
+  /// The syntax used for [language]: [syntax], or the language's own.
+  EditingSyntax syntaxFor(Grammar language) =>
+      syntax ?? EditingSyntax.of(language);
+
+  /// Returns a copy with the given fields replaced.
+  CodeEditing copyWith({
+    bool? autoIndent,
+    bool? autoClose,
+    bool? wrapSelection,
+    bool? matchBrackets,
+    EditingSyntax? syntax,
+  }) {
+    return CodeEditing(
+      autoIndent: autoIndent ?? this.autoIndent,
+      autoClose: autoClose ?? this.autoClose,
+      wrapSelection: wrapSelection ?? this.wrapSelection,
+      matchBrackets: matchBrackets ?? this.matchBrackets,
+      syntax: syntax ?? this.syntax,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      other is CodeEditing &&
+      other.autoIndent == autoIndent &&
+      other.autoClose == autoClose &&
+      other.wrapSelection == wrapSelection &&
+      other.matchBrackets == matchBrackets &&
+      other.syntax == syntax;
+
+  @override
+  int get hashCode =>
+      Object.hash(autoIndent, autoClose, wrapSelection, matchBrackets, syntax);
+}
+
+/// Indents the selected lines, or inserts an indent at the caret. Bound to
+/// Tab in `CodeField`.
+class IndentCodeIntent extends Intent {
+  /// Creates an indent intent.
+  const IndentCodeIntent();
+}
+
+/// Removes one indent from the selected lines. Bound to Shift+Tab in
+/// `CodeField`.
+class OutdentCodeIntent extends Intent {
+  /// Creates an outdent intent.
+  const OutdentCodeIntent();
+}
+
+/// Comments or uncomments the selected lines. Bound to Ctrl+/ (Cmd+/ on
+/// Apple platforms) in `CodeField`.
+class ToggleCommentIntent extends Intent {
+  /// Creates a toggle-comment intent.
+  const ToggleCommentIntent();
+}
+
+/// Applies [CodeEditing] to text typed into a field driven by a
+/// [HighlightTextController].
+///
+/// `CodeField` installs one automatically. Add one to a plain [TextField]'s
+/// `inputFormatters` to get the same behaviour there:
+///
+/// ```dart
+/// TextField(
+///   controller: controller,
+///   maxLines: null,
+///   inputFormatters: [CodeEditingFormatter(controller: controller)],
+/// )
+/// ```
+///
+/// It reacts to text changes rather than key presses, so it works the same
+/// with hardware keyboards, on-screen keyboards and voice input. Text being
+/// composed by an input method is never changed. Each change it makes is a
+/// single edit, so one undo reverts it.
+class CodeEditingFormatter extends TextInputFormatter {
+  /// Creates a formatter for [controller].
+  CodeEditingFormatter({
+    required this.controller,
+    this.editing = const CodeEditing(),
+    this.indent = '  ',
+  });
+
+  /// The controller whose highlighting tells strings and comments apart.
+  final HighlightTextController controller;
+
+  /// The behaviour to apply.
+  CodeEditing editing;
+
+  /// One level of indentation, for Enter.
+  String indent;
+
+  // Offsets of closers inserted automatically, in increasing order. Only
+  // these are stepped over or deleted with their opener.
+  final List<int> _closers = [];
+  String? _text;
+
+  @override
+  TextEditingValue formatEditUpdate(
+    TextEditingValue oldValue,
+    TextEditingValue newValue,
+  ) {
+    final value = _format(oldValue, newValue);
+    _text = value.text;
+    return value;
+  }
+
+  TextEditingValue _format(TextEditingValue oldValue, TextEditingValue value) {
+    // Something other than this formatter changed the text: the recorded
+    // closers may no longer be where they were.
+    if (!identical(oldValue.text, _text)) _closers.clear();
+    final edit = _Edit.between(oldValue, value);
+    if (edit == null) {
+      _closers.clear();
+      return value;
+    }
+    _forgetDistantClosers(oldValue.text, edit.start);
+    // Never change text an input method is still composing.
+    if (value.composing.isValid) return _shifted(value, edit);
+
+    final text = oldValue.text;
+    final inserted = edit.inserted;
+    if (inserted.length == 1) {
+      if (inserted == '\n') {
+        if (!editing.autoIndent) return _shifted(value, edit);
+        _closers.clear();
+        return newlineKeepingIndent(
+          oldValue,
+          indent,
+          brackets: _syntax.brackets,
+        ).copyWith(composing: TextRange.empty);
+      }
+      final closer = editing.autoClose || editing.wrapSelection
+          ? _syntax.closerOf(inserted)
+          : null;
+      if (edit.start < edit.end) {
+        if (closer != null && editing.wrapSelection) {
+          _closers.clear();
+          return _wrap(oldValue, edit, inserted, closer);
+        }
+        return _shifted(value, edit);
+      }
+      if (editing.autoClose) {
+        final at = edit.start;
+        // Step over a closer this formatter inserted.
+        if (at < text.length && text[at] == inserted && _closers.contains(at)) {
+          _closers.remove(at);
+          return oldValue.copyWith(
+            selection: TextSelection.collapsed(offset: at + 1),
+            composing: TextRange.empty,
+          );
+        }
+        if (closer != null && _shouldClose(text, at, inserted, closer)) {
+          _shift(at, at, 2);
+          _closers
+            ..add(at + 1)
+            ..sort();
+          return TextEditingValue(
+            text: value.text.replaceRange(at + 1, at + 1, closer),
+            selection: TextSelection.collapsed(offset: at + 1),
+          );
+        }
+      }
+      return _shifted(value, edit);
+    }
+
+    // Backspace between an automatic pair deletes both halves.
+    if (inserted.isEmpty &&
+        editing.autoClose &&
+        edit.end - edit.start == 1 &&
+        oldValue.selection.isCollapsed &&
+        oldValue.selection.baseOffset == edit.end &&
+        _closers.contains(edit.end) &&
+        edit.end < text.length &&
+        _syntax.closerOf(text[edit.start]) == text[edit.end]) {
+      _closers.remove(edit.end);
+      _shift(edit.start, edit.end + 1, 0);
+      return TextEditingValue(
+        text: text.replaceRange(edit.start, edit.end + 1, ''),
+        selection: TextSelection.collapsed(offset: edit.start),
+      );
+    }
+    return _shifted(value, edit);
+  }
+
+  EditingSyntax get _syntax => editing.syntaxFor(controller.language);
+
+  bool _shouldClose(String text, int at, String open, String close) {
+    if (at < text.length && !_closesBefore(text.codeUnitAt(at))) return false;
+    final quote = open == close;
+    if (!quote) return true;
+    if (at > 0 && _isWord(text.codeUnitAt(at - 1))) return false;
+    final result = controller.result;
+    if (!identical(result.code, text) && result.code != text) return true;
+    return !result.isInsideStringOrComment(at, _syntax);
+  }
+
+  TextEditingValue _wrap(
+    TextEditingValue value,
+    _Edit edit,
+    String open,
+    String close,
+  ) {
+    final text = value.text;
+    final selection = value.selection;
+    return TextEditingValue(
+      text:
+          '${text.substring(0, edit.start)}$open'
+          '${text.substring(edit.start, edit.end)}$close'
+          '${text.substring(edit.end)}',
+      selection: TextSelection(
+        baseOffset: selection.baseOffset + 1,
+        extentOffset: selection.extentOffset + 1,
+      ),
+    );
+  }
+
+  TextEditingValue _shifted(TextEditingValue value, _Edit edit) {
+    _shift(edit.start, edit.end, edit.inserted.length);
+    return value;
+  }
+
+  /// Moves recorded closers for [start, end) being replaced by [length]
+  /// characters. Closers inside the replaced range are forgotten.
+  void _shift(int start, int end, int length) {
+    if (_closers.isEmpty) return;
+    final delta = length - (end - start);
+    var write = 0;
+    for (final offset in _closers) {
+      if (offset < start) {
+        _closers[write++] = offset;
+      } else if (offset >= end) {
+        _closers[write++] = offset + delta;
+      }
+    }
+    _closers.length = write;
+  }
+
+  /// Forgets closers behind the caret or on another line: once the caret
+  /// leaves an auto-closed pair, its closer is ordinary text.
+  void _forgetDistantClosers(String text, int caret) {
+    if (_closers.isEmpty) return;
+    _closers.removeWhere((offset) {
+      if (offset < caret || offset >= text.length || offset - caret > 512) {
+        return true;
+      }
+      for (var i = caret; i < offset; i++) {
+        if (text.codeUnitAt(i) == 0x0A) return true;
+      }
+      return false;
+    });
+  }
+
+  static bool _closesBefore(int unit) =>
+      unit == 0x20 || // space
+      unit == 0x09 || // tab
+      unit == 0x0A || // \n
+      unit == 0x0D || // \r
+      unit == 0x29 || // )
+      unit == 0x5D || // ]
+      unit == 0x7D || // }
+      unit == 0x3E || // >
+      unit == 0x3B || // ;
+      unit == 0x3A || // :
+      unit == 0x2C || // ,
+      unit == 0x2E || // .
+      unit == 0x3D; // =
+
+  static bool _isWord(int unit) =>
+      (unit >= 0x30 && unit <= 0x39) ||
+      (unit >= 0x41 && unit <= 0x5A) ||
+      (unit >= 0x61 && unit <= 0x7A) ||
+      unit == 0x5F ||
+      unit > 0x7F;
+}
+
+/// A single replacement of `[start, end)` in the old text by [inserted].
+final class _Edit {
+  const _Edit(this.start, this.end, this.inserted);
+
+  final int start;
+  final int end;
+  final String inserted;
+
+  /// The edit that turns [old] into [value], when it is a typed insertion,
+  /// a replaced selection, Backspace or Delete. `null` for anything else,
+  /// such as an input method rewriting a word.
+  ///
+  /// Checks run in constant time: lengths, selections and the text around
+  /// the edit.
+  static _Edit? between(TextEditingValue old, TextEditingValue value) {
+    final selection = old.selection;
+    final after = value.selection;
+    if (!selection.isValid || !after.isValid || !after.isCollapsed) {
+      return null;
+    }
+    final oldText = old.text;
+    final text = value.text;
+    final start = selection.start;
+    final end = selection.end;
+    final inserted = text.length - oldText.length + (end - start);
+    if (inserted >= 0 && after.baseOffset == start + inserted) {
+      if (_same(oldText, text, start, end, start + inserted)) {
+        return _Edit(start, end, text.substring(start, start + inserted));
+      }
+    }
+    if (selection.isCollapsed && text.length == oldText.length - 1) {
+      if (start > 0 && after.baseOffset == start - 1) {
+        if (_same(oldText, text, start - 1, start, start - 1)) {
+          return _Edit(start - 1, start, '');
+        }
+      } else if (start < oldText.length && after.baseOffset == start) {
+        if (_same(oldText, text, start, start + 1, start)) {
+          return _Edit(start, start + 1, '');
+        }
+      }
+    }
+    return null;
+  }
+
+  /// Whether [oldText] and [text] agree just before [start] and just after
+  /// the edit, which ends at [oldEnd] in the old text and [newEnd] in the
+  /// new one.
+  static bool _same(
+    String oldText,
+    String text,
+    int start,
+    int oldEnd,
+    int newEnd,
+  ) {
+    const window = 16;
+    for (var i = start - 1; i >= 0 && i >= start - window; i--) {
+      if (oldText.codeUnitAt(i) != text.codeUnitAt(i)) return false;
+    }
+    for (var i = 0; i < window && oldEnd + i < oldText.length; i++) {
+      if (newEnd + i >= text.length ||
+          oldText.codeUnitAt(oldEnd + i) != text.codeUnitAt(newEnd + i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+/// Tab: inserts [indent] at the caret, or indents every selected line.
+TextEditingValue indentText(TextEditingValue value, String indent) {
+  final text = value.text;
+  final selection = value.selection;
+  if (selection.isCollapsed ||
+      !text.substring(selection.start, selection.end).contains('\n')) {
+    return value
+        .replaced(selection, indent)
+        .copyWith(
+          selection: TextSelection.collapsed(
+            offset: selection.start + indent.length,
+          ),
+        );
+  }
+  final first = _lineStart(text, selection.start);
+  final buffer = StringBuffer(text.substring(0, first));
+  var added = 0;
+  var addedBeforeStart = 0;
+  var position = first;
+  for (final line in text.substring(first, selection.end).split('\n')) {
+    if (position > first) buffer.write('\n');
+    if (line.isNotEmpty) {
+      buffer.write(indent);
+      added += indent.length;
+      if (position <= selection.start) addedBeforeStart += indent.length;
+    }
+    buffer.write(line);
+    position += line.length + 1;
+  }
+  buffer.write(text.substring(selection.end));
+  return TextEditingValue(
+    text: buffer.toString(),
+    selection: TextSelection(
+      baseOffset: selection.start + addedBeforeStart,
+      extentOffset: selection.end + added,
+    ),
+  );
+}
+
+/// Shift+Tab: removes one level of indentation from every selected line (or
+/// the caret's line).
+TextEditingValue outdentLines(TextEditingValue value, String indent) {
+  final text = value.text;
+  final selection = value.selection;
+  final first = _lineStart(text, selection.start);
+  final end = selection.end;
+  final buffer = StringBuffer(text.substring(0, first));
+  var removed = 0;
+  var removedBeforeStart = 0;
+  var position = first;
+  final lines = text.substring(first, end).split('\n');
+  for (var i = 0; i < lines.length; i++) {
+    final line = lines[i];
+    if (i > 0) buffer.write('\n');
+    var cut = 0;
+    if (line.startsWith(indent)) {
+      cut = indent.length;
+    } else {
+      while (cut < indent.length && cut < line.length && line[cut] == ' ') {
+        cut++;
+      }
+      if (cut == 0 && line.startsWith('\t')) cut = 1;
+    }
+    buffer.write(line.substring(cut));
+    removed += cut;
+    if (position < selection.start) {
+      removedBeforeStart += cut.clamp(0, selection.start - position);
+    }
+    position += line.length + 1;
+  }
+  buffer.write(text.substring(end));
+  return TextEditingValue(
+    text: buffer.toString(),
+    selection: TextSelection(
+      baseOffset: selection.start - removedBeforeStart,
+      extentOffset: selection.end - removed,
+    ),
+  );
+}
+
+/// Enter: a line break followed by the current line's indentation, plus one
+/// [indent] level after an opening bracket or colon.
+///
+/// When the caret sits between a pair from [brackets], as in `{|}`, the
+/// closing bracket moves to its own line below the caret.
+TextEditingValue newlineKeepingIndent(
+  TextEditingValue value,
+  String indent, {
+  String brackets = '',
+}) {
+  final text = value.text;
+  final selection = value.selection;
+  final lineStart = _lineStart(text, selection.start);
+  var leading = lineStart;
+  while (leading < selection.start &&
+      (text.codeUnitAt(leading) == 0x20 || text.codeUnitAt(leading) == 0x09)) {
+    leading++;
+  }
+  final current = text.substring(lineStart, leading);
+  var insert = '\n$current';
+  final before = text.substring(lineStart, selection.start).trimRight();
+  final opened =
+      before.endsWith('{') ||
+      before.endsWith('[') ||
+      before.endsWith('(') ||
+      before.endsWith(':');
+  if (opened) insert += indent;
+  final caret = selection.start + insert.length;
+  if (selection.start > 0 && selection.end < text.length) {
+    final open = text[selection.start - 1];
+    final close = text[selection.end];
+    for (var i = 0; i + 1 < brackets.length; i += 2) {
+      if (brackets[i] == open && brackets[i + 1] == close) {
+        if (!opened) insert += indent;
+        return value
+            .replaced(selection, '$insert\n$current')
+            .copyWith(
+              selection: TextSelection.collapsed(
+                offset: selection.start + insert.length,
+              ),
+            );
+      }
+    }
+  }
+  return value
+      .replaced(selection, insert)
+      .copyWith(selection: TextSelection.collapsed(offset: caret));
+}
+
+/// Comments or uncomments the lines touched by the selection, using
+/// [syntax]'s markers. Returns `null` when the language has no comments.
+///
+/// With a line comment marker, the lines are uncommented when every
+/// non-blank one already starts with the marker, and commented otherwise.
+/// Markers are aligned at the smallest indentation, and blank lines are
+/// left alone. [result], when it highlights [value]'s text, makes sure a
+/// marker inside a string is not taken for a comment.
+///
+/// With only a block comment, as in CSS or HTML, the selection (or the
+/// caret's line) is wrapped in the markers, or unwrapped if it already is.
+TextEditingValue? toggleComment(
+  TextEditingValue value,
+  EditingSyntax syntax, {
+  HighlightResult? result,
+}) {
+  final text = value.text;
+  final selection = value.selection;
+  if (!selection.isValid || selection.end > text.length) return null;
+  final checked = result != null && result.code == text ? result : null;
+  final line = syntax.lineComment;
+  if (line != null && line.isNotEmpty) {
+    return _toggleLineComments(value, line, checked);
+  }
+  final block = syntax.blockComment;
+  if (block != null) return _toggleBlockComment(value, block, checked);
+  return null;
+}
+
+TextEditingValue _toggleLineComments(
+  TextEditingValue value,
+  String marker,
+  HighlightResult? result,
+) {
+  final text = value.text;
+  final selection = value.selection;
+  var end = selection.end;
+  // A selection ending at the start of a line does not include that line.
+  if (end > selection.start && text.codeUnitAt(end - 1) == 0x0A) end--;
+
+  final starts = <int>[];
+  final indents = <int>[];
+  var blankOnly = true;
+  var allCommented = true;
+  var minIndent = -1;
+  var start = _lineStart(text, selection.start);
+  while (true) {
+    var lineEnd = text.indexOf('\n', start);
+    if (lineEnd < 0) lineEnd = text.length;
+    var indent = start;
+    while (indent < lineEnd &&
+        (text.codeUnitAt(indent) == 0x20 || text.codeUnitAt(indent) == 0x09)) {
+      indent++;
+    }
+    final blank =
+        indent == lineEnd ||
+        (indent + 1 == lineEnd && text.codeUnitAt(indent) == 0x0D);
+    starts.add(start);
+    indents.add(blank ? -1 : indent);
+    if (!blank) {
+      blankOnly = false;
+      if (minIndent < 0 || indent - start < minIndent) {
+        minIndent = indent - start;
+      }
+      if (!_commentedBy(text, indent, marker, result)) allCommented = false;
+    }
+    if (lineEnd >= end || lineEnd >= text.length) break;
+    start = lineEnd + 1;
+  }
+
+  final edits = <_Change>[];
+  if (blankOnly) {
+    // Only blank lines: comment them at their own indentation.
+    for (final start in starts) {
+      var indent = start;
+      while (indent < text.length &&
+          (text.codeUnitAt(indent) == 0x20 ||
+              text.codeUnitAt(indent) == 0x09)) {
+        indent++;
+      }
+      edits.add(_Change(indent, indent, '$marker '));
+    }
+  } else if (allCommented) {
+    for (final indent in indents) {
+      if (indent < 0) continue;
+      var cut = indent + marker.length;
+      if (cut < text.length && text.codeUnitAt(cut) == 0x20) cut++;
+      edits.add(_Change(indent, cut, ''));
+    }
+  } else {
+    for (var i = 0; i < starts.length; i++) {
+      if (indents[i] < 0) continue;
+      final at = starts[i] + minIndent;
+      edits.add(_Change(at, at, '$marker '));
+    }
+  }
+  return _applyChanges(value, edits);
+}
+
+/// Whether the line whose text starts at [indent] was commented out with
+/// [marker].
+///
+/// Doc comments (`///`, `//!`, R's `#'`) and shebangs (`#!`) start with the
+/// marker too, but they are content: toggling comments them out like any
+/// other line instead of breaking them.
+bool _commentedBy(
+  String text,
+  int indent,
+  String marker,
+  HighlightResult? result,
+) {
+  if (!text.startsWith(marker, indent)) return false;
+  final after = indent + marker.length;
+  if (after < text.length && text.codeUnitAt(after) == 0x21) return false;
+  if (result == null) {
+    // Without highlighting, `///` is told apart from `//` by its repeated
+    // last character.
+    return after >= text.length ||
+        text.codeUnitAt(after) != marker.codeUnitAt(marker.length - 1);
+  }
+  final stack = result.tokenStack(result.tokenAt(indent));
+  if (!result.scopes.isComment(stack)) return false;
+  for (final scope in result.scopes.scopesOf(stack)) {
+    if (scope == Scopes.commentDoc ||
+        scope.startsWith('${Scopes.commentDoc}.')) {
+      return false;
+    }
+  }
+  return true;
+}
+
+TextEditingValue _toggleBlockComment(
+  TextEditingValue value,
+  (String, String) block,
+  HighlightResult? result,
+) {
+  final (open, close) = block;
+  final text = value.text;
+  final selection = value.selection;
+  var start = selection.start;
+  var end = selection.end;
+  if (selection.isCollapsed) {
+    start = _lineStart(text, start);
+    end = text.indexOf('\n', start);
+    if (end < 0) end = text.length;
+  }
+  // Ignore surrounding whitespace.
+  while (start < end && _isSpace(text.codeUnitAt(start))) {
+    start++;
+  }
+  while (end > start && _isSpace(text.codeUnitAt(end - 1))) {
+    end--;
+  }
+  final wrapped =
+      end - start >= open.length + close.length &&
+      text.startsWith(open, start) &&
+      text.startsWith(close, end - close.length) &&
+      (result == null || result.isCommentAt(start));
+  if (wrapped) {
+    var openEnd = start + open.length;
+    var closeStart = end - close.length;
+    if (openEnd < closeStart && text.codeUnitAt(openEnd) == 0x20) openEnd++;
+    if (closeStart > openEnd && text.codeUnitAt(closeStart - 1) == 0x20) {
+      closeStart--;
+    }
+    return _applyChanges(value, [
+      _Change(start, openEnd, ''),
+      _Change(closeStart, end, ''),
+    ]);
+  }
+  return _applyChanges(value, [
+    _Change(start, start, '$open '),
+    _Change(end, end, ' $close'),
+  ], inner: true);
+}
+
+/// Replaces `[start, end)` with [text].
+final class _Change {
+  const _Change(this.start, this.end, this.text);
+
+  final int start;
+  final int end;
+  final String text;
+}
+
+/// Applies [changes], in increasing order and not overlapping, as one edit,
+/// carrying the selection along.
+///
+/// A selection grows to take in text inserted at its edges, unless [inner],
+/// when it keeps to the text it had.
+TextEditingValue _applyChanges(
+  TextEditingValue value,
+  List<_Change> changes, {
+  bool inner = false,
+}) {
+  final text = value.text;
+  final out = StringBuffer();
+  var position = 0;
+  for (final change in changes) {
+    out
+      ..write(text.substring(position, change.start))
+      ..write(change.text);
+    position = change.end;
+  }
+  out.write(text.substring(position));
+
+  // Maps an old offset to the new text. Text inserted exactly at the
+  // offset lands after it when [after], before it otherwise.
+  int map(int offset, bool after) {
+    var delta = 0;
+    for (final change in changes) {
+      if (offset < change.start || (offset == change.start && !after)) break;
+      if (offset < change.end) {
+        return change.start + delta + (after ? change.text.length : 0);
+      }
+      delta += change.text.length - (change.end - change.start);
+    }
+    return offset + delta;
+  }
+
+  final selection = value.selection;
+  final TextSelection mapped;
+  if (selection.isCollapsed) {
+    mapped = TextSelection.collapsed(offset: map(selection.baseOffset, true));
+  } else {
+    final forward = selection.baseOffset <= selection.extentOffset;
+    final start = map(selection.start, inner);
+    final end = map(selection.end, !inner);
+    mapped = TextSelection(
+      baseOffset: forward ? start : end,
+      extentOffset: forward ? end : start,
+    );
+  }
+  return TextEditingValue(text: out.toString(), selection: mapped);
+}
+
+bool _isSpace(int unit) =>
+    unit == 0x20 || unit == 0x09 || unit == 0x0A || unit == 0x0D;
+
+/// Offset where the line containing [offset] starts.
+int _lineStart(String text, int offset) =>
+    offset == 0 ? 0 : text.lastIndexOf('\n', offset - 1) + 1;
diff --git a/val_highlight_flutter/lib/src/code_field.dart b/val_highlight_flutter/lib/src/code_field.dart
index 8dbfb6b..fe6f33b 100644
--- a/val_highlight_flutter/lib/src/code_field.dart
+++ b/val_highlight_flutter/lib/src/code_field.dart
@@ -1,12 +1,17 @@
 import 'dart:math' as math;
 
+import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/rendering.dart';
 import 'package:flutter/services.dart';
 
+import 'code_editing.dart';
 import 'code_theme.dart';
+import 'editor_decorations.dart';
 import 'highlight_text_controller.dart';
 
+export 'code_editing.dart' show indentText, newlineKeepingIndent, outdentLines;
+
 /// A code editor: a multi-line [TextField] driven by a
 /// [HighlightTextController], which stays fast on large documents.
 ///
@@ -14,6 +19,17 @@ import 'highlight_text_controller.dart';
 /// CodeField(controller: HighlightTextController(language: dartLanguage))
 /// ```
 ///
+/// Typing follows [editing]: Enter keeps the indentation, brackets and
+/// quotes close themselves, and the bracket at the caret is matched. Keys
+/// follow [shortcuts]: Tab and Shift+Tab indent and outdent, and Ctrl+/
+/// (Cmd+/ on Apple platforms) toggles comments. Each key sends an [Intent]
+/// ([IndentCodeIntent], [OutdentCodeIntent], [ToggleCommentIntent]); an
+/// [Actions] widget above the field can override what they do.
+///
+/// Set [lineNumbers] for a gutter, [highlightedLines] to mark lines, and
+/// [highlightCurrentLine] to mark the caret's line. These are painted from
+/// the text's own layout, so wrapped lines line up.
+///
 /// Laying out a text field is proportional to its styled runs, so for
 /// documents longer than [styleAllBelow] lines only the visible lines, plus
 /// [margin] lines on each side, are coloured. The window follows scrolling
@@ -41,6 +57,18 @@ class CodeField extends StatefulWidget {
     this.styleAllBelow = 300,
     this.margin = 150,
     this.indent = '  ',
+    this.editing = const CodeEditing(),
+    this.shortcuts,
+    this.inputFormatters,
+    this.undoController,
+    this.lineNumbers = false,
+    this.firstLineNumber = 1,
+    this.gutterStyle,
+    this.highlightedLines = const {},
+    this.highlightColor,
+    this.highlightCurrentLine = false,
+    this.currentLineColor,
+    this.bracketColor,
   });
 
   /// The text and its highlighting.
@@ -90,6 +118,64 @@ class CodeField extends StatefulWidget {
   /// after an opening `{`, `[`, `(` or `:`.
   final String indent;
 
+  /// What typing, Enter and Backspace do beyond inserting text. Use
+  /// [CodeEditing.none] for a plain text field.
+  final CodeEditing editing;
+
+  /// Keys and the intents they send. Defaults to [defaultShortcuts]; pass
+  /// `const {}` for none, so Tab moves focus as in other fields.
+  final Map<ShortcutActivator, Intent>? shortcuts;
+
+  /// Formatters applied after the editing behaviour, such as a length
+  /// limit.
+  final List<TextInputFormatter>? inputFormatters;
+
+  /// Controls the field's undo history, as in [TextField.undoController].
+  /// Every edit the field makes itself — an auto-closed pair, a toggled
+  /// comment, an indent — is a single undo step.
+  final UndoHistoryController? undoController;
+
+  /// Whether to show line numbers in a gutter.
+  final bool lineNumbers;
+
+  /// Number shown for the first line.
+  final int firstLineNumber;
+
+  /// Style of the line numbers. Defaults to the code style in a faded
+  /// text color.
+  final TextStyle? gutterStyle;
+
+  /// Line numbers, as shown in the gutter, to highlight.
+  final Set<int> highlightedLines;
+
+  /// Background of [highlightedLines].
+  final Color? highlightColor;
+
+  /// Whether to highlight the line with the caret.
+  final bool highlightCurrentLine;
+
+  /// Background of the caret's line when [highlightCurrentLine] is set.
+  final Color? currentLineColor;
+
+  /// Background of a matched bracket pair, when [CodeEditing.matchBrackets]
+  /// is on.
+  final Color? bracketColor;
+
+  /// The default [shortcuts]: Tab, Shift+Tab, and Ctrl+/ (Cmd+/ on macOS
+  /// and iOS).
+  static Map<ShortcutActivator, Intent> get defaultShortcuts {
+    final apple =
+        defaultTargetPlatform == TargetPlatform.macOS ||
+        defaultTargetPlatform == TargetPlatform.iOS;
+    return {
+      const SingleActivator(LogicalKeyboardKey.tab): const IndentCodeIntent(),
+      const SingleActivator(LogicalKeyboardKey.tab, shift: true):
+          const OutdentCodeIntent(),
+      SingleActivator(LogicalKeyboardKey.slash, meta: apple, control: !apple):
+          const ToggleCommentIntent(),
+    };
+  }
+
   @override
   State<CodeField> createState() => _CodeFieldState();
 }
@@ -98,22 +184,85 @@ class _CodeFieldState extends State<CodeField> {
   ScrollController? _ownScroll;
   ScrollPosition? _outer;
   bool _scheduled = false;
+  late CodeEditingFormatter _formatter = _newFormatter();
+  final _outerMoved = _Notifier();
+  GutterDigits? _digits;
+  GutterDigits? _currentDigits;
+  int _digitCount = 0;
+
+  late final Map<Type, Action<Intent>> _actions = {
+    IndentCodeIntent: Action<IndentCodeIntent>.overridable(
+      defaultAction: _EditAction<IndentCodeIntent>(
+        this,
+        (value) => indentText(value, widget.indent),
+      ),
+      context: context,
+    ),
+    OutdentCodeIntent: Action<OutdentCodeIntent>.overridable(
+      defaultAction: _EditAction<OutdentCodeIntent>(
+        this,
+        (value) => outdentLines(value, widget.indent),
+      ),
+      context: context,
+    ),
+    ToggleCommentIntent: Action<ToggleCommentIntent>.overridable(
+      defaultAction: _EditAction<ToggleCommentIntent>(
+        this,
+        (value) => toggleComment(
+          value,
+          widget.editing.syntaxFor(widget.controller.language),
+          result: widget.controller.result,
+        ),
+      ),
+      context: context,
+    ),
+  };
+
+  Listenable? _repaintListenable;
+  Object? _repaintController;
+  Object? _repaintScroll;
+
+  /// Everything that moves the decorations, merged once per controller
+  /// and scroll controller.
+  Listenable _repaint() {
+    final controller = widget.controller;
+    final scroll = _scroll;
+    if (!identical(controller, _repaintController) ||
+        !identical(scroll, _repaintScroll)) {
+      _repaintController = controller;
+      _repaintScroll = scroll;
+      _repaintListenable = Listenable.merge([controller, scroll, _outerMoved]);
+    }
+    return _repaintListenable!;
+  }
 
   ScrollController get _scroll =>
       widget.scrollController ?? (_ownScroll ??= ScrollController());
 
+  CodeEditingFormatter _newFormatter() => CodeEditingFormatter(
+    controller: widget.controller,
+    editing: widget.editing,
+    indent: widget.indent,
+  );
+
   @override
   void initState() {
     super.initState();
-    widget.controller.addListener(_schedule);
+    widget.controller.addListener(_onChanged);
+    PaintingBinding.instance.systemFonts.addListener(_onFontsChanged);
   }
 
   @override
   void didUpdateWidget(CodeField old) {
     super.didUpdateWidget(old);
     if (!identical(old.controller, widget.controller)) {
-      old.controller.removeListener(_schedule);
-      widget.controller.addListener(_schedule);
+      old.controller.removeListener(_onChanged);
+      widget.controller.addListener(_onChanged);
+      _formatter = _newFormatter();
+    } else {
+      _formatter
+        ..editing = widget.editing
+        ..indent = widget.indent;
     }
   }
 
@@ -122,19 +271,49 @@ class _CodeFieldState extends State<CodeField> {
     super.didChangeDependencies();
     final outer = Scrollable.maybeOf(context)?.position;
     if (!identical(outer, _outer)) {
-      _outer?.removeListener(_schedule);
-      _outer = outer?..addListener(_schedule);
+      _outer?.removeListener(_onOuterScroll);
+      _outer = outer?..addListener(_onOuterScroll);
     }
   }
 
   @override
   void dispose() {
-    widget.controller.removeListener(_schedule);
-    _outer?.removeListener(_schedule);
+    widget.controller.removeListener(_onChanged);
+    PaintingBinding.instance.systemFonts.removeListener(_onFontsChanged);
+    _outer?.removeListener(_onOuterScroll);
     _ownScroll?.dispose();
+    _outerMoved.dispose();
+    _digits?.dispose();
+    _currentDigits?.dispose();
     super.dispose();
   }
 
+  void _onChanged() {
+    _schedule();
+    // The gutter widens when the line count gains a digit.
+    if (widget.lineNumbers && _digitsFor() != _digitCount) setState(() {});
+  }
+
+  /// A font finished loading, so the text was laid out again: lay out the
+  /// digits again too, and repaint the gutter where the lines now are.
+  void _onFontsChanged() {
+    _digits?.dispose();
+    _currentDigits?.dispose();
+    _digits = null;
+    _currentDigits = null;
+    if (mounted) setState(() {});
+  }
+
+  void _onOuterScroll() {
+    _schedule();
+    _outerMoved.notify();
+  }
+
+  int _digitsFor() {
+    final last = widget.firstLineNumber + widget.controller.result.lineCount;
+    return math.max(2, '${math.max(last - 1, 0)}'.length);
+  }
+
   /// Updates the styled window after the next layout. [requestFrame] asks
   /// for a frame; not needed when called during a build.
   void _schedule({bool requestFrame = true}) {
@@ -158,18 +337,14 @@ class _CodeFieldState extends State<CodeField> {
       controller.window = null;
       return;
     }
-    final editable = _findEditable(context.findRenderObject());
+    final editable = _editable();
     if (editable == null || !editable.attached || !editable.hasSize) return;
 
     // The visible part of the text: the editable box, clipped by any
     // enclosing scroll view.
     var visible = editable.localToGlobal(Offset.zero) & editable.size;
-    final outerBox = _outer?.context.notificationContext?.findRenderObject();
-    if (outerBox is RenderBox && outerBox.hasSize) {
-      visible = visible.intersect(
-        outerBox.localToGlobal(Offset.zero) & outerBox.size,
-      );
-    }
+    final viewport = _viewport();
+    if (viewport != null) visible = visible.intersect(viewport);
     if (visible.isEmpty) return;
     final top = editable
         .getPositionForPoint(visible.topLeft + const Offset(1, 1))
@@ -196,6 +371,15 @@ class _CodeFieldState extends State<CodeField> {
     );
   }
 
+  RenderEditable? _editable() => _findEditable(context.findRenderObject());
+
+  /// The global rectangle of the enclosing scroll view, if any.
+  Rect? _viewport() {
+    final box = _outer?.context.notificationContext?.findRenderObject();
+    if (box is! RenderBox || !box.attached || !box.hasSize) return null;
+    return box.localToGlobal(Offset.zero) & box.size;
+  }
+
   static int _lineOf(int Function(int) lineStart, int lines, int offset) {
     var low = 0;
     var high = lines - 1;
@@ -218,43 +402,150 @@ class _CodeFieldState extends State<CodeField> {
     return found;
   }
 
-  /// Tab and Shift+Tab indent and outdent; Enter keeps the indentation.
+  /// Whether a shortcut may edit the text now.
+  bool get _canEdit {
+    final value = widget.controller.value;
+    return !widget.readOnly &&
+        value.selection.isValid &&
+        !value.isComposingRangeValid;
+  }
+
+  /// Applies an edit made by a shortcut, as the user's own.
+  void _apply(TextEditingValue? edited) {
+    if (edited == null) return;
+    final changed = edited.text != widget.controller.text;
+    widget.controller.value = edited;
+    if (changed) widget.onChanged?.call(edited.text);
+  }
+
+  /// Enter keeps the indentation. Typed line breaks reach the formatter
+  /// instead on keyboards that do not send key events.
   KeyEventResult _onKey(FocusNode node, KeyEvent event) {
-    if (event is KeyUpEvent || widget.readOnly) return KeyEventResult.ignored;
-    final keys = HardwareKeyboard.instance;
-    if (keys.isControlPressed || keys.isMetaPressed || keys.isAltPressed) {
+    if (event is KeyUpEvent || !widget.editing.autoIndent) {
       return KeyEventResult.ignored;
     }
     final key = event.logicalKey;
-    final value = widget.controller.value;
-    if (!value.selection.isValid || value.isComposingRangeValid) {
+    if (key != LogicalKeyboardKey.enter &&
+        key != LogicalKeyboardKey.numpadEnter) {
       return KeyEventResult.ignored;
     }
-    TextEditingValue? edited;
-    if (key == LogicalKeyboardKey.tab) {
-      edited = keys.isShiftPressed
-          ? outdentLines(value, widget.indent)
-          : indentText(value, widget.indent);
-    } else if (key == LogicalKeyboardKey.enter ||
-        key == LogicalKeyboardKey.numpadEnter) {
-      if (keys.isShiftPressed) return KeyEventResult.ignored;
-      edited = newlineKeepingIndent(value, widget.indent);
+    final keys = HardwareKeyboard.instance;
+    if (keys.isShiftPressed ||
+        keys.isControlPressed ||
+        keys.isMetaPressed ||
+        keys.isAltPressed ||
+        !_canEdit) {
+      return KeyEventResult.ignored;
     }
-    if (edited == null) return KeyEventResult.ignored;
-    widget.controller.value = edited;
-    widget.onChanged?.call(edited.text);
+    _apply(
+      newlineKeepingIndent(
+        widget.controller.value,
+        widget.indent,
+        brackets: widget.editing.syntaxFor(widget.controller.language).brackets,
+      ),
+    );
     return KeyEventResult.handled;
   }
 
   @override
   Widget build(BuildContext context) {
     _schedule(requestFrame: false);
-    return Focus(
+    Widget field = Focus(
       canRequestFocus: false,
       skipTraversal: true,
       onKeyEvent: _onKey,
       child: _field(context),
     );
+    field = Actions(actions: _actions, child: field);
+    field = Shortcuts(
+      shortcuts: widget.shortcuts ?? CodeField.defaultShortcuts,
+      child: field,
+    );
+    final decorated =
+        widget.lineNumbers ||
+        widget.highlightCurrentLine ||
+        widget.highlightedLines.isNotEmpty ||
+        widget.editing.matchBrackets;
+    if (!decorated) return field;
+    return _decorate(context, field);
+  }
+
+  Widget _decorate(BuildContext context, Widget field) {
+    final theme = CodeTheme.resolve(context, widget.controller.theme);
+    final base = CodeTheme.textStyleOf(context, widget.style);
+    final foreground = theme.root.color == null
+        ? base.color ?? (theme.dark ? Colors.white : Colors.black)
+        : Color(theme.root.color!);
+
+    var gutterWidth = 0.0;
+    const gap = 16.0;
+    const leading = 8.0;
+    GutterDigits? digits;
+    GutterDigits? current;
+    if (widget.lineNumbers) {
+      final scaler = MediaQuery.textScalerOf(context);
+      final style = base
+          .copyWith(color: foreground.withValues(alpha: 0.45))
+          .merge(widget.gutterStyle);
+      if (_digits?.style != style ||
+          _digits?.textScaler != scaler ||
+          widget.highlightCurrentLine != (_currentDigits != null)) {
+        _digits?.dispose();
+        _currentDigits?.dispose();
+        _digits = GutterDigits(style, scaler);
+        _currentDigits = widget.highlightCurrentLine
+            ? GutterDigits(
+                style.copyWith(color: style.color?.withValues(alpha: 0.9)),
+                scaler,
+              )
+            : null;
+      }
+      digits = _digits;
+      current = _currentDigits;
+      _digitCount = _digitsFor();
+      gutterWidth = leading + digits!.maxWidth * _digitCount + gap;
+    }
+
+    return Stack(
+      fit: StackFit.passthrough,
+      children: [
+        Positioned.fill(
+          child: IgnorePointer(
+            child: EditorDecorations(
+              controller: widget.controller,
+              repaint: _repaint(),
+              editable: _editable,
+              viewport: _viewport,
+              digits: digits,
+              gutterWidth: gutterWidth,
+              gutterGap: gap,
+              firstLineNumber: widget.firstLineNumber,
+              highlightedLines: widget.highlightedLines,
+              highlightColor:
+                  widget.highlightColor ??
+                  (theme.dark
+                      ? const Color(0x22FFFFFF)
+                      : const Color(0x14000000)),
+              currentLineColor: widget.highlightCurrentLine
+                  ? widget.currentLineColor ??
+                        (theme.dark
+                            ? const Color(0x12FFFFFF)
+                            : const Color(0x0A000000))
+                  : null,
+              currentNumberDigits: current,
+              bracketColor: widget.editing.matchBrackets
+                  ? widget.bracketColor ?? foreground.withValues(alpha: 0.18)
+                  : null,
+              editing: widget.editing,
+            ),
+          ),
+        ),
+        Padding(
+          padding: EdgeInsets.only(left: gutterWidth),
+          child: field,
+        ),
+      ],
+    );
   }
 
   Widget _field(BuildContext context) {
@@ -283,119 +574,30 @@ class _CodeFieldState extends State<CodeField> {
         enableSuggestions: false,
         smartDashesType: SmartDashesType.disabled,
         smartQuotesType: SmartQuotesType.disabled,
+        inputFormatters: [_formatter, ...?widget.inputFormatters],
+        undoController: widget.undoController,
       ),
     );
   }
 }
 
-/// Tab: inserts [indent] at the caret, or indents every selected line.
-TextEditingValue indentText(TextEditingValue value, String indent) {
-  final text = value.text;
-  final selection = value.selection;
-  if (selection.isCollapsed ||
-      !text.substring(selection.start, selection.end).contains('\n')) {
-    return value
-        .replaced(selection, indent)
-        .copyWith(
-          selection: TextSelection.collapsed(
-            offset: selection.start + indent.length,
-          ),
-        );
-  }
-  final first = _lineStart(text, selection.start);
-  final buffer = StringBuffer(text.substring(0, first));
-  var added = 0;
-  var addedBeforeStart = 0;
-  var position = first;
-  for (final line in text.substring(first, selection.end).split('\n')) {
-    if (position > first) buffer.write('\n');
-    if (line.isNotEmpty) {
-      buffer.write(indent);
-      added += indent.length;
-      if (position <= selection.start) addedBeforeStart += indent.length;
-    }
-    buffer.write(line);
-    position += line.length + 1;
-  }
-  buffer.write(text.substring(selection.end));
-  return TextEditingValue(
-    text: buffer.toString(),
-    selection: TextSelection(
-      baseOffset: selection.start + addedBeforeStart,
-      extentOffset: selection.end + added,
-    ),
-  );
-}
+/// An edit triggered by a shortcut, enabled while the field is editable.
+class _EditAction<T extends Intent> extends Action<T> {
+  _EditAction(this._state, this._edit);
 
-/// Shift+Tab: removes one level of indentation from every selected line (or
-/// the caret's line).
-TextEditingValue outdentLines(TextEditingValue value, String indent) {
-  final text = value.text;
-  final selection = value.selection;
-  final first = _lineStart(text, selection.start);
-  final end = selection.end;
-  final buffer = StringBuffer(text.substring(0, first));
-  var removed = 0;
-  var removedBeforeStart = 0;
-  var position = first;
-  final lines = text.substring(first, end).split('\n');
-  for (var i = 0; i < lines.length; i++) {
-    final line = lines[i];
-    if (i > 0) buffer.write('\n');
-    var cut = 0;
-    if (line.startsWith(indent)) {
-      cut = indent.length;
-    } else {
-      while (cut < indent.length && cut < line.length && line[cut] == ' ') {
-        cut++;
-      }
-      if (cut == 0 && line.startsWith('\t')) cut = 1;
-    }
-    buffer.write(line.substring(cut));
-    removed += cut;
-    if (position < selection.start) {
-      removedBeforeStart += cut.clamp(0, selection.start - position);
-    }
-    position += line.length + 1;
-  }
-  buffer.write(text.substring(end));
-  return TextEditingValue(
-    text: buffer.toString(),
-    selection: TextSelection(
-      baseOffset: selection.start - removedBeforeStart,
-      extentOffset: selection.end - removed,
-    ),
-  );
-}
+  final _CodeFieldState _state;
+  final TextEditingValue? Function(TextEditingValue value) _edit;
 
-/// Enter: a line break followed by the current line's indentation, plus one
-/// [indent] level after an opening bracket or colon.
-TextEditingValue newlineKeepingIndent(TextEditingValue value, String indent) {
-  final text = value.text;
-  final selection = value.selection;
-  final lineStart = _lineStart(text, selection.start);
-  var leading = lineStart;
-  while (leading < selection.start &&
-      (text.codeUnitAt(leading) == 0x20 || text.codeUnitAt(leading) == 0x09)) {
-    leading++;
-  }
-  var insert = '\n${text.substring(lineStart, leading)}';
-  final before = text.substring(lineStart, selection.start).trimRight();
-  if (before.endsWith('{') ||
-      before.endsWith('[') ||
-      before.endsWith('(') ||
-      before.endsWith(':')) {
-    insert += indent;
+  @override
+  bool isEnabled(T intent) => _state.mounted && _state._canEdit;
+
+  @override
+  Object? invoke(T intent) {
+    _state._apply(_edit(_state.widget.controller.value));
+    return null;
   }
-  return value
-      .replaced(selection, insert)
-      .copyWith(
-        selection: TextSelection.collapsed(
-          offset: selection.start + insert.length,
-        ),
-      );
 }
 
-/// Offset where the line containing [offset] starts.
-int _lineStart(String text, int offset) =>
-    offset == 0 ? 0 : text.lastIndexOf('\n', offset - 1) + 1;
+class _Notifier extends ChangeNotifier {
+  void notify() => notifyListeners();
+}
diff --git a/val_highlight_flutter/lib/src/editor_decorations.dart b/val_highlight_flutter/lib/src/editor_decorations.dart
new file mode 100644
index 0000000..bdd57fb
--- /dev/null
+++ b/val_highlight_flutter/lib/src/editor_decorations.dart
@@ -0,0 +1,352 @@
+import 'package:flutter/rendering.dart';
+import 'package:flutter/widgets.dart';
+import 'package:val_highlight/val_highlight.dart';
+
+import 'code_editing.dart';
+import 'highlight_text_controller.dart';
+
+/// Pre-laid-out digits `0`–`9` in one style, so painting line numbers never
+/// lays out text: a number is drawn digit by digit, right-aligned.
+final class GutterDigits {
+  /// Lays out the ten digits in [style].
+  GutterDigits(this.style, this.textScaler)
+    : _painters = List.generate(
+        10,
+        (digit) => TextPainter(
+          text: TextSpan(text: '$digit', style: style),
+          textDirection: TextDirection.ltr,
+          textScaler: textScaler,
+        )..layout(),
+      ) {
+    for (final painter in _painters) {
+      if (painter.width > maxWidth) maxWidth = painter.width;
+    }
+  }
+
+  /// The style the digits were laid out in.
+  final TextStyle style;
+
+  /// The text scaler the digits were laid out with.
+  final TextScaler textScaler;
+
+  final List<TextPainter> _painters;
+
+  /// Width of the widest digit.
+  double maxWidth = 0;
+
+  /// Width of [number] when painted.
+  double widthOf(int number) {
+    var width = 0.0;
+    do {
+      width += _painters[number % 10].width;
+      number ~/= 10;
+    } while (number > 0);
+    return width;
+  }
+
+  /// Paints [number] with its right edge at [right] and its top at [top].
+  void paint(Canvas canvas, int number, double right, double top) {
+    var x = right;
+    do {
+      final painter = _painters[number % 10];
+      x -= painter.width;
+      painter.paint(canvas, Offset(x, top));
+      number ~/= 10;
+    } while (number > 0);
+  }
+
+  /// Releases the laid-out digits.
+  void dispose() {
+    for (final painter in _painters) {
+      painter.dispose();
+    }
+  }
+}
+
+/// Paints behind a `CodeField`'s text: highlighted and current line bands,
+/// line numbers in the gutter, and the matched bracket pair.
+///
+/// Everything is positioned from the editable text's own layout, so wrapped
+/// lines, scrolling and any decoration padding line up exactly. Only lines
+/// inside the visible area are visited, so the cost per frame depends on
+/// the screen, not the document.
+class EditorDecorations extends LeafRenderObjectWidget {
+  /// Creates the decorations.
+  const EditorDecorations({
+    super.key,
+    required this.controller,
+    required this.repaint,
+    required this.editable,
+    required this.viewport,
+    required this.digits,
+    required this.gutterWidth,
+    required this.gutterGap,
+    required this.firstLineNumber,
+    required this.highlightedLines,
+    required this.highlightColor,
+    required this.currentLineColor,
+    required this.currentNumberDigits,
+    required this.bracketColor,
+    required this.editing,
+  });
+
+  /// The text being decorated.
+  final HighlightTextController controller;
+
+  /// Fires whenever the decorations may have moved.
+  final Listenable repaint;
+
+  /// The render object of the editable text, once laid out.
+  final RenderEditable? Function() editable;
+
+  /// The global rectangle of an enclosing scroll view, if any.
+  final Rect? Function() viewport;
+
+  /// Digits for line numbers, or `null` for no gutter.
+  final GutterDigits? digits;
+
+  /// Width of the gutter, including [gutterGap].
+  final double gutterWidth;
+
+  /// Space between the numbers and the text.
+  final double gutterGap;
+
+  /// Number shown for the first line.
+  final int firstLineNumber;
+
+  /// Line numbers, as shown, to paint with [highlightColor].
+  final Set<int> highlightedLines;
+
+  /// Band color for [highlightedLines].
+  final Color highlightColor;
+
+  /// Band color for the caret's line, or `null` for none.
+  final Color? currentLineColor;
+
+  /// Digits for the caret line's number, or `null` to use [digits].
+  final GutterDigits? currentNumberDigits;
+
+  /// Fill for the matched bracket pair, or `null` for no matching.
+  final Color? bracketColor;
+
+  /// Editing behaviour, whose syntax gives the bracket pairs to match.
+  final CodeEditing editing;
+
+  @override
+  RenderEditorDecorations createRenderObject(BuildContext context) =>
+      RenderEditorDecorations(this);
+
+  @override
+  void updateRenderObject(
+    BuildContext context,
+    RenderEditorDecorations renderObject,
+  ) {
+    renderObject.config = this;
+  }
+}
+
+/// The render object of [EditorDecorations].
+class RenderEditorDecorations extends RenderBox {
+  /// Creates the render object.
+  RenderEditorDecorations(this._config);
+
+  EditorDecorations _config;
+
+  /// The current configuration.
+  set config(EditorDecorations value) {
+    final old = _config;
+    _config = value;
+    if (attached && !identical(old.repaint, value.repaint)) {
+      old.repaint.removeListener(markNeedsPaint);
+      value.repaint.addListener(markNeedsPaint);
+    }
+    markNeedsPaint();
+  }
+
+  // The last bracket match, reused while the text and caret stay put.
+  HighlightResult? _matchResult;
+  int _matchCaret = -1;
+  String _matchBrackets = '';
+  (int, int)? _match;
+
+  @override
+  void attach(PipelineOwner owner) {
+    super.attach(owner);
+    _config.repaint.addListener(markNeedsPaint);
+  }
+
+  @override
+  void detach() {
+    _config.repaint.removeListener(markNeedsPaint);
+    super.detach();
+  }
+
+  @override
+  bool get sizedByParent => true;
+
+  @override
+  Size computeDryLayout(BoxConstraints constraints) => constraints.biggest;
+
+  @override
+  bool get isRepaintBoundary => true;
+
+  @override
+  void paint(PaintingContext context, Offset offset) {
+    final editable = _config.editable();
+    if (editable == null ||
+        !editable.attached ||
+        !editable.hasSize ||
+        editable.maxLines == 1) {
+      return;
+    }
+    final result = _config.controller.result;
+    final lineCount = result.lineCount;
+    final origin = MatrixUtils.transformPoint(
+      editable.getTransformTo(this),
+      Offset.zero,
+    );
+
+    // The visible part: the editable's viewport, clipped by our bounds and
+    // by an enclosing scroll view.
+    var visible = Rect.fromLTRB(
+      0,
+      origin.dy < 0 ? 0 : origin.dy,
+      size.width,
+      origin.dy + editable.size.height > size.height
+          ? size.height
+          : origin.dy + editable.size.height,
+    );
+    final viewport = _config.viewport();
+    if (viewport != null) {
+      final topLeft = globalToLocal(viewport.topLeft);
+      visible = visible.intersect(topLeft & viewport.size);
+    }
+    if (visible.isEmpty || visible.height <= 0) return;
+
+    // Caret rectangles carry a constant, platform-specific offset from the
+    // top of their line. Measure it on the first line, whose top is known.
+    final scroll = editable.offset.pixels;
+    final skew =
+        editable.getLocalRectForCaret(const TextPosition(offset: 0)).top +
+        scroll;
+    double lineTop(int line) =>
+        editable
+            .getLocalRectForCaret(TextPosition(offset: result.lineStart(line)))
+            .top -
+        skew +
+        origin.dy;
+
+    final selection = _config.controller.selection;
+    final caretLine = selection.isValid
+        ? _lineOf(result, selection.extentOffset)
+        : -1;
+    final firstVisible = _lineOf(
+      result,
+      editable
+          .getPositionForPoint(
+            localToGlobal(Offset(visible.left + 1, visible.top + 1)),
+          )
+          .offset,
+    );
+
+    final canvas = context.canvas;
+    canvas
+      ..save()
+      ..clipRect(visible.shift(offset));
+    final digits = _config.digits;
+    final numberRight = _config.gutterWidth - _config.gutterGap;
+    final paint = Paint();
+    var line = firstVisible > 0 ? firstVisible - 1 : 0;
+    var top = lineTop(line);
+    while (line < lineCount && top < visible.bottom) {
+      final bottom = line + 1 < lineCount
+          ? lineTop(line + 1)
+          : top + editable.preferredLineHeight;
+      if (bottom > visible.top) {
+        final number = _config.firstLineNumber + line;
+        Color? band;
+        if (_config.highlightedLines.contains(number)) {
+          band = _config.highlightColor;
+        } else if (line == caretLine) {
+          band = _config.currentLineColor;
+        }
+        if (band != null) {
+          canvas.drawRect(
+            Rect.fromLTRB(0, top, size.width, bottom).shift(offset),
+            paint..color = band,
+          );
+        }
+        if (digits != null && number >= 0) {
+          final style = line == caretLine
+              ? _config.currentNumberDigits ?? digits
+              : digits;
+          style.paint(canvas, number, offset.dx + numberRight, offset.dy + top);
+        }
+      }
+      line++;
+      top = bottom;
+    }
+
+    final bracketColor = _config.bracketColor;
+    if (bracketColor != null && selection.isValid && selection.isCollapsed) {
+      final match = _bracketMatch(result, selection.baseOffset);
+      if (match != null) {
+        paint.color = bracketColor;
+        for (final at in [match.$1, match.$2]) {
+          for (final box in editable.getBoxesForSelection(
+            TextSelection(baseOffset: at, extentOffset: at + 1),
+          )) {
+            final rect = box.toRect().shift(origin + offset);
+            canvas.drawRRect(
+              RRect.fromRectAndRadius(
+                rect.inflate(1),
+                const Radius.circular(2),
+              ),
+              paint,
+            );
+          }
+        }
+      }
+    }
+    canvas.restore();
+  }
+
+  /// The bracket next to [caret] and its match: the one before the caret
+  /// first, as most editors do.
+  (int, int)? _bracketMatch(HighlightResult result, int caret) {
+    final brackets = _config.editing
+        .syntaxFor(_config.controller.language)
+        .brackets;
+    if (identical(result, _matchResult) &&
+        caret == _matchCaret &&
+        brackets == _matchBrackets) {
+      return _match;
+    }
+    _matchResult = result;
+    _matchCaret = caret;
+    _matchBrackets = brackets;
+    _match = null;
+    for (final at in [caret - 1, caret]) {
+      final other = result.matchingBracket(at, brackets: brackets);
+      if (other >= 0) {
+        _match = at < other ? (at, other) : (other, at);
+        break;
+      }
+    }
+    return _match;
+  }
+
+  static int _lineOf(HighlightResult result, int offset) {
+    var low = 0;
+    var high = result.lineCount - 1;
+    while (low < high) {
+      final mid = (low + high + 1) >> 1;
+      if (result.lineStart(mid) <= offset) {
+        low = mid;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return low;
+  }
+}
diff --git a/val_highlight_flutter/lib/val_highlight_flutter.dart b/val_highlight_flutter/lib/val_highlight_flutter.dart
index e64c8fd..f3ab08c 100644
--- a/val_highlight_flutter/lib/val_highlight_flutter.dart
+++ b/val_highlight_flutter/lib/val_highlight_flutter.dart
@@ -14,6 +14,14 @@ library;
 
 export 'package:val_highlight/val_highlight.dart';
 
+export 'src/code_editing.dart'
+    show
+        CodeEditing,
+        CodeEditingFormatter,
+        IndentCodeIntent,
+        OutdentCodeIntent,
+        ToggleCommentIntent,
+        toggleComment;
 export 'src/code_field.dart' show CodeField;
 export 'src/code_highlighter.dart' show CodeHighlighter;
 export 'src/code_styles.dart' show CodeStyles, textStyleFromStyle;
diff --git a/val_highlight_flutter/test/code_editing_test.dart b/val_highlight_flutter/test/code_editing_test.dart
new file mode 100644
index 0000000..6230ccf
--- /dev/null
+++ b/val_highlight_flutter/test/code_editing_test.dart
@@ -0,0 +1,384 @@
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:val_highlight/languages/css.dart';
+import 'package:val_highlight/languages/dart.dart';
+import 'package:val_highlight/languages/plaintext.dart';
+import 'package:val_highlight/languages/python.dart';
+import 'package:val_highlight/languages/rust.dart';
+import 'package:val_highlight_flutter/val_highlight_flutter.dart';
+
+/// A document being typed into through a [CodeEditingFormatter], the way
+/// a text field applies it.
+class _Doc {
+  _Doc(
+    String text, {
+    int? caret,
+    Grammar language = dartLanguage,
+    CodeEditing editing = const CodeEditing(),
+  }) : controller = HighlightTextController(text: text, language: language) {
+    controller.selection = TextSelection.collapsed(
+      offset: caret ?? text.length,
+    );
+    formatter = CodeEditingFormatter(controller: controller, editing: editing);
+  }
+
+  final HighlightTextController controller;
+  late final CodeEditingFormatter formatter;
+
+  String get text => controller.text;
+  TextSelection get selection => controller.selection;
+
+  /// [text] with `|` at the caret, or `[` `]` around the selection.
+  String get shown {
+    final s = selection;
+    if (s.isCollapsed) return text.replaceRange(s.start, s.start, '|');
+    return '${text.substring(0, s.start)}[${text.substring(s.start, s.end)}]'
+        '${text.substring(s.end)}';
+  }
+
+  void _apply(TextEditingValue value) {
+    controller.value = formatter.formatEditUpdate(controller.value, value);
+  }
+
+  /// Types [chars] one at a time, replacing the selection.
+  void type(String chars) {
+    for (final char in chars.split('')) {
+      final value = controller.value;
+      final s = value.selection;
+      _apply(
+        TextEditingValue(
+          text: value.text.replaceRange(s.start, s.end, char),
+          selection: TextSelection.collapsed(offset: s.start + 1),
+        ),
+      );
+    }
+  }
+
+  void backspace() {
+    final value = controller.value;
+    final s = value.selection;
+    final start = s.isCollapsed ? s.start - 1 : s.start;
+    _apply(
+      TextEditingValue(
+        text: value.text.replaceRange(start, s.end, ''),
+        selection: TextSelection.collapsed(offset: start),
+      ),
+    );
+  }
+
+  void select(int start, [int? end]) {
+    controller.selection = TextSelection(
+      baseOffset: start,
+      extentOffset: end ?? start,
+    );
+  }
+}
+
+void main() {
+  group('auto-closing', () {
+    test('brackets close and the closer is stepped over', () {
+      final doc = _Doc('f');
+      doc.type('(');
+      expect(doc.shown, 'f(|)');
+      doc.type('x');
+      expect(doc.shown, 'f(x|)');
+      doc.type(')');
+      expect(doc.shown, 'f(x)|');
+      doc.type(';');
+      expect(doc.shown, 'f(x);|');
+    });
+
+    test('nested brackets step over in order', () {
+      final doc = _Doc('');
+      doc.type('{[(');
+      expect(doc.shown, '{[(|)]}');
+      doc.type(')]}');
+      expect(doc.shown, '{[()]}|');
+    });
+
+    test('brackets stay single before a word', () {
+      final doc = _Doc('value', caret: 0);
+      doc.type('(');
+      expect(doc.shown, '(|value');
+    });
+
+    test('a typed closer is not swallowed unless it was automatic', () {
+      final doc = _Doc('f()', caret: 2);
+      doc.type(')');
+      expect(doc.shown, 'f()|)');
+    });
+
+    test('Backspace deletes an automatic empty pair', () {
+      final doc = _Doc('f');
+      doc.type('(');
+      doc.backspace();
+      expect(doc.shown, 'f|');
+    });
+
+    test('Backspace leaves a typed pair alone', () {
+      final doc = _Doc('f()', caret: 2);
+      doc.backspace();
+      expect(doc.shown, 'f|)');
+    });
+
+    test('quotes close, but not after a word or inside a string', () {
+      final doc = _Doc('x = ');
+      doc.type('"');
+      expect(doc.shown, 'x = "|"');
+      doc.type('hi"');
+      expect(doc.shown, 'x = "hi"|');
+
+      final word = _Doc('don');
+      word.type("'");
+      expect(word.shown, "don'|");
+
+      final inString = _Doc('x = "a  b"', caret: 7);
+      inString.type("'");
+      expect(inString.shown, 'x = "a \'| b"');
+    });
+
+    test('quotes do not close in comments', () {
+      final doc = _Doc('// say ');
+      doc.type('"');
+      expect(doc.shown, '// say "|');
+    });
+
+    test('language quotes: Rust lifetimes stay single', () {
+      final doc = _Doc('fn f<', language: rustLanguage);
+      doc.type("'");
+      expect(doc.shown, "fn f<'|");
+    });
+
+    test('plain text closes nothing', () {
+      final doc = _Doc('', language: plainTextLanguage);
+      doc.type('("');
+      expect(doc.shown, '("|');
+    });
+
+    test('a closer is forgotten once the caret leaves its line', () {
+      final doc = _Doc('a\nb');
+      doc.select(1);
+      doc.type('(');
+      expect(doc.shown, 'a(|)\nb');
+      doc.select(5);
+      doc.select(2);
+      doc.type('x');
+      doc.select(doc.text.length);
+      doc.select(3);
+      expect(doc.shown, 'a(x|)\nb');
+      // Still on the line: steps over.
+      doc.type(')');
+      expect(doc.shown, 'a(x)|\nb');
+    });
+
+    test('closers survive edits made elsewhere on the line', () {
+      final doc = _Doc('');
+      doc.type('f(');
+      doc.type('a, b');
+      expect(doc.shown, 'f(a, b|)');
+      doc.backspace();
+      doc.type('c)');
+      expect(doc.shown, 'f(a, c)|');
+    });
+
+    test('an outside change forgets the closers', () {
+      final doc = _Doc('');
+      doc.type('(');
+      // A closer would now sit where the automatic one was.
+      doc.controller.value = const TextEditingValue(
+        text: '))',
+        selection: TextSelection.collapsed(offset: 1),
+      );
+      doc.type(')');
+      expect(doc.shown, '))|)');
+    });
+
+    test('text being composed is never changed', () {
+      final doc = _Doc('f');
+      final value = doc.formatter.formatEditUpdate(
+        doc.controller.value,
+        const TextEditingValue(
+          text: 'f(',
+          selection: TextSelection.collapsed(offset: 2),
+          composing: TextRange(start: 1, end: 2),
+        ),
+      );
+      expect(value.text, 'f(');
+    });
+
+    test('can be turned off', () {
+      final doc = _Doc('f', editing: const CodeEditing(autoClose: false));
+      doc.type('("');
+      expect(doc.shown, 'f("|');
+    });
+  });
+
+  group('wrapping a selection', () {
+    test('brackets and quotes wrap the selection', () {
+      final doc = _Doc('a value b');
+      doc.select(2, 7);
+      doc.type('(');
+      expect(doc.shown, 'a ([value]) b');
+      doc.type('"');
+      expect(doc.shown, 'a ("[value]") b');
+    });
+
+    test('other characters replace it', () {
+      final doc = _Doc('a value b');
+      doc.select(2, 7);
+      doc.type('x');
+      expect(doc.shown, 'a x| b');
+    });
+
+    test('can be turned off', () {
+      final doc = _Doc(
+        'a value b',
+        editing: const CodeEditing(wrapSelection: false),
+      );
+      doc.select(2, 7);
+      doc.type('(');
+      expect(doc.shown, 'a (| b');
+    });
+  });
+
+  group('Enter', () {
+    test('keeps the indentation and indents after an opener', () {
+      final doc = _Doc('  if (x) {');
+      doc.type('\n');
+      expect(doc.shown, '  if (x) {\n    |');
+    });
+
+    test('splits a bracket pair onto three lines', () {
+      final doc = _Doc('  f() {}', caret: 7);
+      doc.type('\n');
+      expect(doc.shown, '  f() {\n    |\n  }');
+    });
+
+    test('after an automatic pair', () {
+      final doc = _Doc('');
+      doc.type('[\n');
+      expect(doc.shown, '[\n  |\n]');
+    });
+
+    test('can be turned off', () {
+      final doc = _Doc('  x', editing: const CodeEditing(autoIndent: false));
+      doc.type('\n');
+      expect(doc.shown, '  x\n|');
+    });
+  });
+
+  group('toggleComment', () {
+    TextEditingValue? toggle(
+      String text,
+      int start, [
+      int? end,
+      Grammar language = dartLanguage,
+    ]) {
+      final value = TextEditingValue(
+        text: text,
+        selection: TextSelection(baseOffset: start, extentOffset: end ?? start),
+      );
+      return toggleComment(
+        value,
+        EditingSyntax.of(language),
+        result: const Highlighter().highlight(text, language: language),
+      );
+    }
+
+    test('comments the caret line and back', () {
+      final on = toggle('  a();\nb();', 3)!;
+      expect(on.text, '  // a();\nb();');
+      expect(on.selection.baseOffset, 6);
+      final off = toggle(on.text, on.selection.baseOffset)!;
+      expect(off.text, '  a();\nb();');
+      expect(off.selection.baseOffset, 3);
+    });
+
+    test('aligns markers at the smallest indentation and skips blanks', () {
+      const text = '  if (a) {\n    b();\n\n  }';
+      final on = toggle(text, 0, text.length)!;
+      expect(on.text, '  // if (a) {\n  //   b();\n\n  // }');
+      expect(on.selection.start, 0);
+      expect(on.selection.end, on.text.length);
+      expect(toggle(on.text, 0, on.text.length)!.text, text);
+    });
+
+    test('comments every line when only some are commented', () {
+      final on = toggle('// a\nb', 0, 6)!;
+      expect(on.text, '// // a\n// b');
+    });
+
+    test('a selection ending at a line start leaves that line alone', () {
+      final on = toggle('a\nb\n', 0, 2)!;
+      expect(on.text, '// a\nb\n');
+    });
+
+    test('a marker inside a string is not a comment', () {
+      const text = 'x = """\n// not a comment\n""";';
+      final on = toggle(text, 9)!;
+      expect(on.text, 'x = """\n// // not a comment\n""";');
+    });
+
+    test('doc comments are content, not comment markers', () {
+      final on = toggle('/// Docs.\nvoid f() {}', 0, 21)!;
+      expect(on.text, '// /// Docs.\n// void f() {}');
+      expect(
+        toggle(on.text, 0, on.text.length)!.text,
+        '/// Docs.\nvoid f() {}',
+      );
+
+      expect(toggle('  /// Docs.', 5)!.text, '  // /// Docs.');
+      expect(toggle('  // /// Docs.', 5)!.text, '  /// Docs.');
+    });
+
+    test('Rust inner doc comments and shebangs are content', () {
+      expect(
+        toggle('//! Crate.', 0, null, rustLanguage)!.text,
+        '// //! Crate.',
+      );
+      expect(
+        toggle('#!/usr/bin/env python', 0, null, pythonLanguage)!.text,
+        '# #!/usr/bin/env python',
+      );
+    });
+
+    test(
+      'without highlighting, a repeated marker character is a doc comment',
+      () {
+        final value = toggleComment(
+          const TextEditingValue(
+            text: '/// Docs.',
+            selection: TextSelection.collapsed(offset: 0),
+          ),
+          EditingSyntax.cStyle,
+        )!;
+        expect(value.text, '// /// Docs.');
+      },
+    );
+
+    test('uses the language marker', () {
+      expect(toggle('x = 1', 0, null, pythonLanguage)!.text, '# x = 1');
+    });
+
+    test('block comments wrap the line or selection', () {
+      final line = toggle('  a { b: c; }', 4, null, cssLanguage)!;
+      expect(line.text, '  /* a { b: c; } */');
+      expect(toggle(line.text, 6, null, cssLanguage)!.text, '  a { b: c; }');
+
+      final part = toggle('a { b: c; }', 4, 9, cssLanguage)!;
+      expect(part.text, 'a { /* b: c; */ }');
+      expect(
+        part.text.substring(part.selection.start, part.selection.end),
+        'b: c;',
+      );
+    });
+
+    test('languages without comments do nothing', () {
+      expect(toggle('text', 0, null, plainTextLanguage), isNull);
+    });
+
+    test('a selection past the end does nothing', () {
+      expect(toggle('a', 0, 5), isNull);
+    });
+  });
+}
diff --git a/val_highlight_flutter/test/code_field_test.dart b/val_highlight_flutter/test/code_field_test.dart
index bc6c14e..f5939c0 100644
--- a/val_highlight_flutter/test/code_field_test.dart
+++ b/val_highlight_flutter/test/code_field_test.dart
@@ -1,8 +1,10 @@
 import 'package:flutter/material.dart';
+import 'package:flutter/rendering.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:val_highlight/languages/dart.dart';
 import 'package:val_highlight_flutter/src/code_field.dart';
+import 'package:val_highlight_flutter/src/editor_decorations.dart';
 import 'package:val_highlight_flutter/val_highlight_flutter.dart';
 
 String _lines(int n) =>
@@ -171,4 +173,465 @@ void main() {
       isTrue,
     );
   });
+
+  Future<HighlightTextController> pumpField(
+    WidgetTester tester,
+    String text, {
+    int? caret,
+    Widget Function(Widget field)? wrap,
+    CodeField Function(HighlightTextController controller)? build,
+  }) async {
+    final controller = HighlightTextController(
+      text: text,
+      language: dartLanguage,
+    );
+    addTearDown(controller.dispose);
+    final field =
+        build?.call(controller) ??
+        CodeField(controller: controller, expands: true);
+    await tester.pumpWidget(
+      MaterialApp(home: Scaffold(body: wrap?.call(field) ?? field)),
+    );
+    await tester.showKeyboard(find.byType(CodeField));
+    controller.selection = TextSelection.collapsed(
+      offset: caret ?? text.length,
+    );
+    await tester.pump();
+    return controller;
+  }
+
+  Future<void> pressCombo(WidgetTester tester, LogicalKeyboardKey key) async {
+    await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
+    await tester.sendKeyEvent(key);
+    await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
+    await tester.pump();
+  }
+
+  group('typing', () {
+    testWidgets('text from an input method auto-closes brackets', (
+      tester,
+    ) async {
+      final controller = await pumpField(tester, 'f');
+      tester.testTextInput.updateEditingValue(
+        const TextEditingValue(
+          text: 'f(',
+          selection: TextSelection.collapsed(offset: 2),
+        ),
+      );
+      await tester.pump();
+      expect(controller.text, 'f()');
+      expect(controller.selection.baseOffset, 2);
+    });
+
+    testWidgets('a line break from an input method keeps the indentation', (
+      tester,
+    ) async {
+      final controller = await pumpField(tester, '  f() {}', caret: 7);
+      tester.testTextInput.updateEditingValue(
+        const TextEditingValue(
+          text: '  f() {\n}',
+          selection: TextSelection.collapsed(offset: 8),
+        ),
+      );
+      await tester.pump();
+      expect(controller.text, '  f() {\n    \n  }');
+      expect(controller.selection.baseOffset, 12);
+    });
+
+    testWidgets('CodeEditing.none types plainly', (tester) async {
+      final controller = await pumpField(
+        tester,
+        'f',
+        build: (controller) => CodeField(
+          controller: controller,
+          expands: true,
+          editing: CodeEditing.none,
+        ),
+      );
+      tester.testTextInput.updateEditingValue(
+        const TextEditingValue(
+          text: 'f(',
+          selection: TextSelection.collapsed(offset: 2),
+        ),
+      );
+      await tester.pump();
+      expect(controller.text, 'f(');
+    });
+
+    testWidgets('extra input formatters run after the editing behaviour', (
+      tester,
+    ) async {
+      final controller = await pumpField(
+        tester,
+        'f',
+        build: (controller) => CodeField(
+          controller: controller,
+          expands: true,
+          inputFormatters: [LengthLimitingTextInputFormatter(2)],
+        ),
+      );
+      tester.testTextInput.updateEditingValue(
+        const TextEditingValue(
+          text: 'f(',
+          selection: TextSelection.collapsed(offset: 2),
+        ),
+      );
+      await tester.pump();
+      expect(controller.text, 'f(');
+    });
+  });
+
+  group('shortcuts', () {
+    testWidgets('Ctrl+/ toggles a comment', (tester) async {
+      final controller = await pumpField(tester, 'a();\nb();', caret: 2);
+      await pressCombo(tester, LogicalKeyboardKey.slash);
+      expect(controller.text, '// a();\nb();');
+      await pressCombo(tester, LogicalKeyboardKey.slash);
+      expect(controller.text, 'a();\nb();');
+    });
+
+    testWidgets('Shift+Tab outdents', (tester) async {
+      final controller = await pumpField(tester, '    a', caret: 5);
+      await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
+      await tester.sendKeyEvent(LogicalKeyboardKey.tab);
+      await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
+      await tester.pump();
+      expect(controller.text, '  a');
+    });
+
+    testWidgets('an Actions widget above can override an intent', (
+      tester,
+    ) async {
+      var calls = 0;
+      final controller = await pumpField(
+        tester,
+        'a();',
+        wrap: (field) => Actions(
+          actions: {
+            ToggleCommentIntent: CallbackAction<ToggleCommentIntent>(
+              onInvoke: (_) => calls++,
+            ),
+          },
+          child: field,
+        ),
+      );
+      await pressCombo(tester, LogicalKeyboardKey.slash);
+      expect(calls, 1);
+      expect(controller.text, 'a();');
+    });
+
+    testWidgets('custom shortcuts replace the defaults', (tester) async {
+      final controller = await pumpField(
+        tester,
+        'a',
+        build: (controller) => CodeField(
+          controller: controller,
+          expands: true,
+          shortcuts: const {
+            SingleActivator(LogicalKeyboardKey.keyK, control: true):
+                ToggleCommentIntent(),
+          },
+        ),
+      );
+      await tester.sendKeyEvent(LogicalKeyboardKey.tab);
+      await tester.pump();
+      expect(controller.text, 'a');
+      await pressCombo(tester, LogicalKeyboardKey.keyK);
+      expect(controller.text, '// a');
+    });
+
+    testWidgets('read-only fields do not edit', (tester) async {
+      final controller = await pumpField(
+        tester,
+        'a',
+        build: (controller) =>
+            CodeField(controller: controller, expands: true, readOnly: true),
+      );
+      await tester.sendKeyEvent(LogicalKeyboardKey.tab);
+      await pressCombo(tester, LogicalKeyboardKey.slash);
+      expect(controller.text, 'a');
+    });
+  });
+
+  group('decorations', () {
+    double textLeft(WidgetTester tester) =>
+        tester.getTopLeft(find.byType(EditableText)).dx;
+
+    testWidgets('line numbers paint in a gutter beside the text', (
+      tester,
+    ) async {
+      await pumpField(
+        tester,
+        'a\nb\nc',
+        build: (controller) =>
+            CodeField(controller: controller, expands: true, lineNumbers: true),
+      );
+      expect(textLeft(tester), greaterThan(16));
+      expect(
+        find.byType(EditorDecorations),
+        paints
+          ..paragraph()
+          ..paragraph()
+          ..paragraph(),
+      );
+    });
+
+    testWidgets('no gutter by default', (tester) async {
+      await pumpField(tester, 'a\nb');
+      expect(textLeft(tester), 0);
+      expect(find.byType(EditorDecorations), isNot(paints..paragraph()));
+    });
+
+    testWidgets('numbers follow wrapped lines', (tester) async {
+      final long = List.filled(60, 'word').join(' ');
+      await pumpField(
+        tester,
+        '$long\nshort',
+        wrap: (field) => SizedBox(width: 300, child: field),
+        build: (controller) =>
+            CodeField(controller: controller, expands: true, lineNumbers: true),
+      );
+      final editable = tester.allRenderObjects
+          .whereType<RenderEditable>()
+          .first;
+      final lineHeight = editable.preferredLineHeight;
+      final secondTop = editable
+          .getLocalRectForCaret(TextPosition(offset: long.length + 1))
+          .top;
+      expect(secondTop, greaterThan(lineHeight * 2));
+      // The second number sits beside the second line, below the wrapped
+      // rows of the first.
+      expect(
+        find.byType(EditorDecorations),
+        paints
+          ..paragraph(
+            offset: isA<Offset>().having((o) => o.dy, 'dy', lessThan(1)),
+          )
+          ..paragraph(
+            offset: isA<Offset>().having(
+              (o) => o.dy,
+              'dy',
+              greaterThan(lineHeight * 2),
+            ),
+          ),
+      );
+    });
+
+    testWidgets('a font that finishes loading relays out the gutter', (
+      tester,
+    ) async {
+      await pumpField(
+        tester,
+        'a\nb',
+        build: (controller) =>
+            CodeField(controller: controller, expands: true, lineNumbers: true),
+      );
+      GutterDigits? digits() => tester
+          .widget<EditorDecorations>(find.byType(EditorDecorations))
+          .digits;
+      final before = digits();
+      await tester.binding.handleSystemMessage(<String, Object?>{
+        'type': 'fontsChange',
+      });
+      await tester.pump();
+      expect(digits(), isNot(same(before)));
+      expect(
+        find.byType(EditorDecorations),
+        paints
+          ..paragraph()
+          ..paragraph(),
+      );
+    });
+
+    testWidgets('the gutter widens as the line count gains a digit', (
+      tester,
+    ) async {
+      final controller = await pumpField(
+        tester,
+        List.filled(99, 'x').join('\n'),
+        build: (controller) =>
+            CodeField(controller: controller, expands: true, lineNumbers: true),
+      );
+      final before = textLeft(tester);
+      controller.text = '${controller.text}\ny';
+      await tester.pump();
+      expect(textLeft(tester), greaterThan(before));
+    });
+
+    testWidgets('the caret line and highlighted lines get bands', (
+      tester,
+    ) async {
+      await pumpField(
+        tester,
+        'a\nb\nc',
+        caret: 0,
+        build: (controller) => CodeField(
+          controller: controller,
+          expands: true,
+          highlightCurrentLine: true,
+          currentLineColor: const Color(0xFF00FF00),
+          highlightedLines: const {3},
+          highlightColor: const Color(0xFFFF0000),
+        ),
+      );
+      expect(
+        find.byType(EditorDecorations),
+        paints
+          ..rect(color: const Color(0xFF00FF00))
+          ..rect(color: const Color(0xFFFF0000)),
+      );
+    });
+
+    testWidgets('a bracket next to the caret is matched', (tester) async {
+      await pumpField(
+        tester,
+        'f(a, b)',
+        caret: 2,
+        build: (controller) => CodeField(
+          controller: controller,
+          expands: true,
+          bracketColor: const Color(0xFF0000FF),
+        ),
+      );
+      expect(
+        find.byType(EditorDecorations),
+        paints
+          ..rrect(color: const Color(0xFF0000FF))
+          ..rrect(color: const Color(0xFF0000FF)),
+      );
+    });
+
+    testWidgets('brackets in strings are not matched', (tester) async {
+      await pumpField(tester, 'f("(")', caret: 4);
+      expect(find.byType(EditorDecorations), isNot(paints..rrect()));
+    });
+  });
+
+  group('undo', () {
+    late UndoHistoryController undo;
+
+    Future<HighlightTextController> pumpUndoable(
+      WidgetTester tester,
+      String text, {
+      int? caret,
+    }) {
+      undo = UndoHistoryController();
+      addTearDown(undo.dispose);
+      return pumpField(
+        tester,
+        text,
+        caret: caret,
+        build: (controller) => CodeField(
+          controller: controller,
+          expands: true,
+          undoController: undo,
+        ),
+      );
+    }
+
+    /// Lets the undo history record the current value; it throttles pushes.
+    Future<void> settle(WidgetTester tester) =>
+        tester.pump(const Duration(seconds: 1));
+
+    Future<void> typeText(WidgetTester tester, String text, int caret) async {
+      tester.testTextInput.updateEditingValue(
+        TextEditingValue(
+          text: text,
+          selection: TextSelection.collapsed(offset: caret),
+        ),
+      );
+      await settle(tester);
+    }
+
+    testWidgets('an auto-closed pair is undone in one step', (tester) async {
+      final controller = await pumpUndoable(tester, 'f');
+      await settle(tester);
+      await typeText(tester, 'f(', 2);
+      expect(controller.text, 'f()');
+      undo.undo();
+      await tester.pump();
+      expect(controller.text, 'f');
+      expect(controller.selection, const TextSelection.collapsed(offset: 1));
+      undo.redo();
+      await tester.pump();
+      expect(controller.text, 'f()');
+    });
+
+    testWidgets('a split bracket pair is undone in one step', (tester) async {
+      final controller = await pumpUndoable(tester, 'f() {}', caret: 5);
+      await settle(tester);
+      await typeText(tester, 'f() {\n}', 6);
+      expect(controller.text, 'f() {\n  \n}');
+      undo.undo();
+      await tester.pump();
+      expect(controller.text, 'f() {}');
+    });
+
+    testWidgets('a wrapped selection is undone in one step', (tester) async {
+      final controller = await pumpUndoable(tester, 'a b c');
+      controller.selection = const TextSelection(
+        baseOffset: 2,
+        extentOffset: 3,
+      );
+      await settle(tester);
+      tester.testTextInput.updateEditingValue(
+        const TextEditingValue(
+          text: 'a ( c',
+          selection: TextSelection.collapsed(offset: 3),
+        ),
+      );
+      await settle(tester);
+      expect(controller.text, 'a (b) c');
+      undo.undo();
+      await tester.pump();
+      expect(controller.text, 'a b c');
+    });
+
+    testWidgets('a toggled comment is undone in one step', (tester) async {
+      final controller = await pumpUndoable(tester, 'a();\nb();');
+      controller.selection = const TextSelection(
+        baseOffset: 0,
+        extentOffset: 9,
+      );
+      await settle(tester);
+      await pressCombo(tester, LogicalKeyboardKey.slash);
+      await settle(tester);
+      expect(controller.text, '// a();\n// b();');
+      undo.undo();
+      await tester.pump();
+      expect(controller.text, 'a();\nb();');
+    });
+
+    testWidgets('an indent is undone in one step', (tester) async {
+      final controller = await pumpUndoable(tester, 'a\nb');
+      controller.selection = const TextSelection(
+        baseOffset: 0,
+        extentOffset: 3,
+      );
+      await settle(tester);
+      await tester.sendKeyEvent(LogicalKeyboardKey.tab);
+      await settle(tester);
+      expect(controller.text, '  a\n  b');
+      undo.undo();
+      await tester.pump();
+      expect(controller.text, 'a\nb');
+    });
+
+    testWidgets('stepping over a closer adds no undo step', (tester) async {
+      final controller = await pumpUndoable(tester, 'f');
+      await settle(tester);
+      await typeText(tester, 'f(', 2);
+      await typeText(tester, 'f(x)', 3);
+      expect(controller.text, 'f(x)');
+      await typeText(tester, 'f(x))', 4);
+      expect(controller.text, 'f(x)');
+      expect(controller.selection.baseOffset, 4);
+      undo.undo();
+      await tester.pump();
+      expect(controller.text, 'f()');
+      undo.undo();
+      await tester.pump();
+      expect(controller.text, 'f');
+    });
+  });
 }