feat(core): INCLUDE, error overhaul, sf64 lane, WORDS ALL, .RS

WS-012 -- INCLUDE/INCLUDED: - Injected source loader (core stays IO-free: CLI installs a filesystem reader, web leaves it unset -> defined error). Recursive include_file feeds files line-by-line through evaluate, so compile state and SEE capture span lines for free. Cycle detection, depth cap 16, paths relative to the including file, SOURCE-ID per nesting level, parent input restored on success/error/BYE. - CLI file mode now runs through the include machinery: `wafer x.fth` gets file:line error context and a base dir for nested INCLUDEs. - Unlocks the REMEMBER+INCLUDE reload loop. WS-008 -- error reporting remainder: - Errors inside included files carry `file.fth:12:` context (anyhow context chain; CLI prints {e:#}). - describe_uncaught now returns typed WaferError::UncaughtThrow { code, message } -- display text unchanged, THROW code reachable via downcast for CLI/web consumers. - compile_word emits a WASM name section; wasmtime trap backtraces name the faulting word and runtime_native prefixes "in <WORD>:". Batch/consolidated modules stay unnamed (no name plumbing there; boot primitives rarely trap). WS-003 -- SwiftForth correctness lane: - compare_all_programs_sf64 runs the program corpus with sf64 as oracle; whitespace-token comparison (sf64 prints numbers space-prefixed and echoes piped lines). 34/35 parity; dot-quote skipped (interpret-mode ." is a SwiftForth no-op). #[ignore]d like the gforth lane; `just compare-correctness` runs both. WS-011 leftovers: - WORDS ALL: grouped full view -- one section per wordlist (search order first), then internal words, each with counts. Backed by Dictionary::visible_entries (name, wid, internal); visible_words now derives from it. - .RS / RDEPTH: return-stack introspection in boot.fth over a new RP@ primitive (IrOp::RpFetch); BEGIN/WHILE walk so the walk never touches the stack it prints. SPACES clamped per 6.1.2230. 549 unit + 11 compliance + 9(+2) comparison + 5 crypto + 1 bench green; fmt/clippy clean; --no-default-features and wasm32 web checks pass.
feat(core): SEE, SEE-IR, HELP introspection trio (WS-010)
2026-08-06 12:03:29 +02:00 · 2026-08-06 11:18:03 +02:00
17 changed files with 1070 additions and 1214 deletions
@@ -3,6 +3,3 @@
 *.swp
 .DS_Store
 *.bk
 # Local planning notes — never tracked
 /plans/
@@ -1,199 +0,0 @@
 # Changelog
 All notable changes to WAFER are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [0.2.5] - 2026-08-06
 ### Added
 - **`QUIT`** ( -- ) ( R: i\*x -- ), the CORE word that was missing: empty
  the return stack, enter interpretation state, hand the input source
  back to the user input device and return to the interpreter without a
  message. The data stack is deliberately left alone — that is the whole
  difference to `ABORT`, which the standard defines as "empty the data
  stack, then `QUIT`". It unwinds through nested `EVALUATE` and
  `INCLUDE`, abandoning them, and `SOURCE-ID` is restored to 0.
  `CATCH` does **not** report it: `QUIT` rides throw code -56, which the
  interpreter treats as a return to the prompt rather than an exception.
  Both behaviours were checked against gforth 0.7.3 and SwiftForth
  `sf64`, which agree — `1 2 ' QUIT CATCH .` prints nothing and leaves
  `1 2` on the stack in all three engines.
  The gap had gone unnoticed because the Forth 2012 test suite skips it
  by its own admission ("I HAVEN'T FIGURED OUT HOW TO TEST KEY, QUIT,
  ABORT, OR ABORT\""), and because `HELP`'s coverage lint compares the
  dictionary against the docs — a word absent from both looks complete.
  `docs/wafer-anki.txt` had been documenting `QUIT` as if it existed.
  Note that `ABORT` was already correct: executing it while a definition
  is open does clear both stacks and return to interpretation state.
  Typing `ABORT` (or `QUIT`) into an unfinished definition compiles it
  rather than running it, exactly as in every other Forth; `[` is the
  word that gets you out.
 ## [0.2.4] - 2026-08-06
 ### Fixed
 - **Errors from host words in the browser build read like Forth errors
  again.** A host word signals failure by throwing across the JS
  boundary, and the browser runtime reported the exception with its
  `Debug` form, so an empty-stack `RESIZE` came back as
  `call_func(134) failed: JsValue(Error: Stack underflow ...)` trailed by
  an engine stack trace. The thrown message is the Forth message, so it
  is now surfaced verbatim — `Stack underflow`, exactly what the native
  CLI prints. Exceptions that carry no message keep the call context,
  since those are genuine runtime faults rather than Forth throws.
  `CATCH` was never affected: it reads the throw code from its own
  channel, not from the message.
 ## [0.2.3] - 2026-08-06
 ### Fixed
 - **Release builds of `wafer-web` no longer fail on proc-macro loading.**
  Cargo strips debuginfo from release artifacts by default, and on macOS
  that also strips the metadata proc-macro dylibs need to be loadable, so
  `wasm-pack build --release` died with `can't find crate` for
  `rustversion`, `thiserror_impl` and every other proc-macro. Build
  scripts and proc-macros gain nothing from stripping, so
  `[profile.release.build-override]` now exempts them; release binaries
  stay stripped. Debug builds were never affected, which is why the test
  suite stayed green while the browser REPL could not be built for
  production.
 - `wafer-web` and `wafer-cli` requested `wafer-core` version `0.2.1`
  while the workspace had moved to `0.2.2`. The caret requirement still
  resolved, so nothing broke, but the pin is now kept in step.
 ## [0.2.2] - 2026-08-06
 ### Added
 - **SwiftForth-style input number conversion.** Punctuation (`,` `.` `+`
  `/` `:` and an embedded `-`) anywhere after the leftmost digit now forces
  double-cell conversion, so `12.34`, `1,234`, `12:30:45` and `2026-08-06`
  all convert as doubles without a custom parser. Previously only a
  trailing `.` worked and `1.5` was an "unknown word" error. The
  punctuation is a double-cell marker, not a fractional point: every
  spelling of `1234` (`1234.`, `123.4`, `.1234`) yields the same value.
 - **`DPL`** ( -- addr ): digits to the right of the rightmost punctuation
  character in the last converted number, negative when the token carried
  none. Seeded at -1024 and bumped once per digit, matching `sf64`.
  Together with `<# #>` this is how fixed-point input is scaled.
 - **`NH`** ( -- addr ): the high-order cell dropped by a single-cell
  conversion, so a token that overflows a cell can be recovered as a
  double (`4000000000 NH @ D.`).
 Verified token-for-token against SwiftForth `sf64`: DPL values, double
 promotion and sign handling agree on every probed form. One deliberate
 divergence — WAFER also accepts a sign before a base prefix (`-$FF`), which
 `sf64` rejects; the Forth 2012 spelling `$-FF` works in both. A leading `+`
 is punctuation rather than a sign in both engines, so `+7` is the double 7
 with `DPL` = 1.
 ## [0.2.1] - 2026-08-06
 ### Fixed
 - **The search order is now authoritative** (Forth 2012 §16.3.3): a word
  whose wordlist is not in the search order is no longer findable.
  Previously lookup fell back to the newest entry across all wordlists,
  making word hiding impossible. Verified against gforth and SwiftForth,
  and guarded by a cross-engine corpus program.
 - **Host words validate their stack arguments.** Around 40 host-implemented
  words (`RND-SEED`, `ACCEPT`, `RESIZE`, `ALLOCATE`, `FREE`, `SEARCH`,
  `SUBSTITUTE`, `ROLL`, `M*`, `UM/MOD`, `SF@ SF! DF@ DF!`, `F. FE. FS. F~`,
  `2R@`, and friends) performed raw stack-pointer arithmetic with no
  underflow check — calling them on an empty stack silently corrupted the
  stack pointer (the compiled-code guards from 0.2.0 do not cover host
  words). All argument-taking host words now fail with a clean, CATCHable
  underflow error, enforced by a class-wide regression test.
 ## [0.2.0] - 2026-08-06
 The usability release: introspection, source files, honest errors, and a
 safety net under every compiled word.
 ### Added
 - **Stack guards in compiled code**: under/overflow checks at the
  stack-pointer choke points of generated WASM. Faults THROW standard codes
  (`-3`..`-6`, `-44`, `-45`), are CATCHable, and print standard messages
  instead of silently corrupting memory. Default on; `wafer build` output
  stays unguarded; `WAFER_STACK_GUARDS=0|1` overrides.
 - **`SEE`**: source-level decompiler. Colon words (including everything in
  `boot.fth`) show their captured verbatim source; data words show
  synthesized definitions with current values (`9 VALUE X`,
  `DEFER D ( IS DUP )`); primitives fall back to a readable IR dump —
  `SEE` never dead-ends on a defined word.
 - **`SEE-IR`**: post-optimization IR view with resolved callee names and
  indented control flow — shows what the optimizer actually did.
 - **`HELP`**: stack effect + one-line description for **every** word in a
  fresh VM (dictionary words and outer-interpreter tokens alike); coverage
  is enforced by a unit test, so an undocumented new word fails the build.
  User words echo their leading `( n -- n )` comment.
 - **`INCLUDE` / `INCLUDED`**: nestable source-file loading with cycle
  detection, depth bound, paths relative to the including file, and
  per-level `SOURCE-ID`. The loader is injected (CLI: filesystem; web:
  defined error), so the core stays IO-free. `wafer prog.fth` now runs
  through the same machinery.
 - **`MARKER` extensions**: `REMEMBER` (re-runnable marker), `EMPTY` and
  `GILD` (boot-state rollback and re-baselining). Marker rollback now also
  restores search order, wordlists, `REPLACES` substitutions, `ABORT"`
  texts, and captured word sources — enabling the `REMEMBER` + `INCLUDE`
  edit-reload loop.
 - **`WORDS`**: optional substring filter (`WORDS FLOAT`), word count, and
  `WORDS ALL` — a grouped full view by wordlist plus internal words.
 - **Return-stack introspection**: `.RS`, `RDEPTH`, `RP@`.
 - **Tools**: `.S` honors `BASE`, `F.S`, `?`, bounds-checked `DUMP`, real
  `BYE`, named `ORDER` output.
 - **CLI REPL**: persistent history (XDG state dir, `0600`), dictionary-backed
  tab completion, prefix history search on Up/Down, Ctrl-C clears the line.
 - **Web REPL**: history persisted to localStorage, User Words palette,
  `BASE` indicator in the stack bar.
 - **Error reporting**: uncaught `THROW` codes map to standard messages;
  `ABORT"` text prints only when uncaught; errors inside included files
  carry `file.fth:line:` context; uncaught throws are typed
  (`WaferError::UncaughtThrow`) for embedding consumers; compiled words
  carry WASM name sections, so genuine traps name the faulting word
  (`in CRASHER: wasm trap: out of bounds memory access`).
 - **SwiftForth correctness lane**: the cross-engine program corpus can run
  against sf64 as an oracle (`just compare-correctness`), alongside the
  existing gforth lane and the sf64 performance lane.
 ### Fixed
 - Multi-line command output in the CLI REPL starts on its own line
  (inline `ok` echo only for single-line output).
 - `.S` printed in decimal regardless of `BASE`.
 - A bare interpreted `R>` underflowed silently (exposed by the new stack
  guards; compliance baseline updated).
 - `SPACES` with a negative count now outputs nothing, per Forth 2012
  6.1.2230.
 ### Changed
 - `wafer prog.fth` reports errors with `file:line` context and resolves
  nested `INCLUDE`s relative to the file.
 - Internal words (`_`-prefixed) are flagged in the dictionary and hidden
  from `WORDS` and completion (`WORDS ALL` shows them).
 - Dependencies upgraded across the board: wasmtime 43 → 47,
  wasm-encoder/wasmparser 0.246 → 0.255, plus all semver-compatible
  updates.
 ## [0.1.0] - 2026-08-04
 Initial development line (untagged): Forth 2012 core with IR optimizer and
 WASM codegen via wasm-encoder/wasmtime, ~300 words across Core, Double,
 Float, String, Search-Order, Exception, and Tools word sets, Forth 2012
 compliance suite, `CONSOLIDATE` whole-program recompilation, `wafer build`
 AOT export (WASM / native / JS loader), browser REPL, SHA-1/256/512 words,
 and cross-engine benchmark lanes against gforth and SwiftForth.
 [0.2.1]: https://github.com/ok2/wafer/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/ok2/wafer/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/ok2/wafer/releases/tag/v0.1.0
@@ -79,7 +79,7 @@ Handle in `interpret_token_immediate()` or `compile_token()` as a special case.
 ## Testing
- Run `cargo test --workspace` before committing (currently 562 unit + 1 benchmark + 11 compliance + 9 comparison + 5 crypto)
+- Run `cargo test --workspace` before committing (currently 542 unit + 1 benchmark + 11 compliance + 9 comparison + 5 crypto)
 - Forth 2012 compliance: `cargo test -p wafer-core --test compliance`
 - Cross-engine comparison (vs gforth): `cargo test -p wafer-core --test comparison`
 - Performance benchmarks (release mode): `cargo test -p wafer-core --test comparison -- --nocapture --ignored`
@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 [workspace.package]
-version = "0.2.5"
+version = "0.1.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/ok2/wafer"
@@ -41,21 +41,13 @@ needless_collect = "warn"
 or_fun_call = "warn"
 [workspace.dependencies]
-wasm-encoder = "0.255"
+wasm-encoder = "0.246"
-wasmparser = "0.255"
+wasmparser = "0.246"
-wasmtime = "47"
+wasmtime = "43"
 anyhow = "1"
 thiserror = "2"
 proptest = "1"
 insta = "1"
-sha1 = "0.10"
+sha1 = "0.11"
-sha2 = "0.10"
+sha2 = "0.11"
 send_wrapper = "0.6"
 # Cargo strips debuginfo from release artifacts by default, and on macOS that
 # also strips the metadata proc-macro dylibs need to be loadable — release
 # builds then fail with "can't find crate" for every proc-macro (rustversion,
 # thiserror_impl, ...). Build scripts and proc-macros gain nothing from
 # stripping, so exempt them; the release binaries stay stripped.
 [profile.release.build-override]
 strip = false
@@ -66,13 +66,6 @@ ci: fmt clippy deny test
 check:
    cargo check --workspace
 # Install the wafer CLI (release build) and bat syntax highlighting.
 # STRIP=none: Cargo's release default (strip = "debuginfo") emits dylibs that
 # macOS 27's dyld rejects ("mis-aligned LINKEDIT string pool"), so proc macros
 # fail to load during the build itself.
 install: install-syntax
    CARGO_PROFILE_RELEASE_STRIP=none cargo install --path crates/cli --locked
 # Install bat syntax highlighting for WAFER / Forth
 install-syntax:
    mkdir -p ~/.config/bat/syntaxes
@@ -9,7 +9,7 @@ license.workspace = true
 workspace = true
 [dependencies]
-wafer-core = { path = "../core", version = "0.2.5" }
+wafer-core = { path = "../core", version = "0.1.0" }
 wasmtime = { workspace = true }
 anyhow = { workspace = true }
 clap = { version = "4", features = ["derive"] }
@@ -192,9 +192,10 @@ impl Dictionary {
                    }
                }
            }
-            // In no wordlist of the search order: not findable
+            // Fallback: return newest entry across all wordlists
-            // (Forth 2012 §16.3.3 — the order is authoritative).
+            if let Some(&(_wid, word_addr, fn_index, is_immediate)) = entries.last() {
-            return None;
+                return Some((word_addr, WordId(fn_index), is_immediate));
            }
        }
        // Fallback: linked-list walk (for words not yet in the index)
@@ -108,23 +108,6 @@ pub const SYSVAR_HLD: u32 = SYSVAR_BASE + 28;
 pub const SYSVAR_LEAVE_FLAG: u32 = SYSVAR_BASE + 32;
 /// Throw code left by a compiled stack-guard fault for `_STACK_FAULT_`.
 pub const SYSVAR_FAULT_CODE: u32 = SYSVAR_BASE + 36;
 /// DPL: digits right of the rightmost punctuation in the last converted
 /// number; negative when the token carried no punctuation.
 pub const SYSVAR_DPL: u32 = SYSVAR_BASE + 40;
 /// NH: high-order cell of the last single-cell conversion, so an
 /// out-of-range token can be recovered as a double.
 pub const SYSVAR_NH: u32 = SYSVAR_BASE + 44;
 /// Seed for [`SYSVAR_DPL`] before conversion starts.
 ///
 /// `SwiftForth` seeds DPL with a negative value and bumps it once per digit,
 /// so an unpunctuated token still ends up negative. Punctuation resets the
 /// counter to zero, which makes the final value the digit count right of the
 /// rightmost punctuation character.
 ///
 /// The exact seed is observable: `sf64` reports DPL as -1020 after `1234`
 /// and -1023 after `-1`, both of which pin it to -1024.
 pub const DPL_INIT: i32 = -1024;
 #[cfg(test)]
 mod tests {
@@ -166,9 +149,6 @@ mod tests {
            SYSVAR_NUM_TIB,
            SYSVAR_HLD,
            SYSVAR_LEAVE_FLAG,
            SYSVAR_FAULT_CODE,
            SYSVAR_DPL,
            SYSVAR_NH,
        ];
        for offset in all_offsets {
            assert!(offset + CELL_SIZE <= SYSVAR_BASE + SYSVAR_SIZE);
@@ -350,16 +350,6 @@ pub const WORD_DOCS: &[(&str, &str, &str)] = &[
        "Convert digits, accumulating into ud.",
    ),
    ("BASE", "( -- addr )", "Variable holding the number base."),
    (
        "DPL",
        "( -- addr )",
        "Variable: digits right of the last punctuation; negative if none.",
    ),
    (
        "NH",
        "( -- addr )",
        "Variable: high cell dropped by the last single-cell conversion.",
    ),
    ("HEX", "( -- )", "Set BASE to sixteen."),
    ("DECIMAL", "( -- )", "Set BASE to ten."),
    // -- Core: strings --
@@ -716,11 +706,6 @@ pub const WORD_DOCS: &[(&str, &str, &str)] = &[
        "Read a line of input (unsupported here).",
    ),
    ("ABORT", "( i*x -- )", "Empty the stacks and abort."),
    (
        "QUIT",
        "( -- ) ( R: i*x -- )",
        "Empty the return stack, return to the interpreter; data stack kept.",
    ),
    (
        "ABORT\"",
        "( flag -- )",
@@ -453,26 +453,6 @@ fn programs() -> Vec<Program> {
            expected: "99 \n",
            category: Category::Definitions,
        },
        Program {
            name: "search-order-hides",
            code: "WORDLIST CONSTANT MY-WL\n\
                   MY-WL SET-CURRENT\n\
                   : SECRET 42 ;\n\
                   FORTH-WORDLIST SET-CURRENT\n\
                   [UNDEFINED] SECRET . CR\n\
                   GET-ORDER MY-WL SWAP 1+ SET-ORDER\n\
                   [DEFINED] SECRET . CR\n\
                   SECRET . CR\n\
                   -1 SET-ORDER\n\
                   [UNDEFINED] SECRET . CR",
            expected: "-1 \n-1 \n42 \n-1 \n",
            category: Category::Definitions,
        },
        // QUIT is deliberately absent from this corpus: what it abandons is
        // "the input source", and each engine here is fed differently (wafer
        // line by line, gforth from a file, sf64 from a prompting stdin), so
        // a comparison would measure the harness. Its semantics are pinned by
        // the QUIT tests in outer.rs, checked by hand against both engines.
        // -- Strings --
        Program {
            name: "s-quote-type",
@@ -12,7 +12,7 @@ workspace = true
 crate-type = ["cdylib", "rlib"]
 [dependencies]
-wafer-core = { path = "../core", version = "0.2.5", default-features = false, features = ["crypto"] }
+wafer-core = { path = "../core", version = "0.1.0", default-features = false, features = ["crypto"] }
 wasm-bindgen = "0.2"
 js-sys = "0.3"
 send_wrapper = { workspace = true }
@@ -38,23 +38,6 @@ impl WebHostAccess {
    }
 }
 /// An exception on its way back out of compiled code. Host words rethrow the
 /// Forth message (`Stack underflow`, an `ABORT"` text, a `THROW` description),
 /// so surface exactly that and nothing else — the JS `Error` carries the whole
 /// engine stack in its message, which is noise to a Forth programmer. Anything
 /// without a message is a genuine runtime fault and keeps the call context.
 fn call_error(fn_index: u32, e: &JsValue) -> anyhow::Error {
    match Reflect::get(e, &"message".into())
        .ok()
        .and_then(|m| m.as_string())
        .and_then(|m| m.lines().next().map(str::trim).map(str::to_string))
        .filter(|m| !m.is_empty())
    {
        Some(msg) => anyhow::anyhow!("{msg}"),
        None => anyhow::anyhow!("call_func({fn_index}) failed: {e:?}"),
    }
 }
 impl HostAccess for WebHostAccess {
    fn mem_read_i32(&mut self, addr: u32) -> i32 {
        let view = js_sys::Int32Array::new(&self.buffer());
@@ -151,7 +134,7 @@ impl HostAccess for WebHostAccess {
            .dyn_into()
            .map_err(|_| anyhow::anyhow!("table entry {fn_index} is not a function"))?;
        func.call0(&JsValue::NULL)
-            .map_err(|e| call_error(fn_index, &e))?;
+            .map_err(|e| anyhow::anyhow!("call_func({fn_index}) failed: {e:?}"))?;
        Ok(())
    }
 }
@@ -423,7 +406,7 @@ impl Runtime for WebRuntime {
            .dyn_into()
            .map_err(|_| anyhow::anyhow!("table entry {fn_index} is not callable"))?;
        func.call0(&JsValue::NULL)
-            .map_err(|e| call_error(fn_index, &e))?;
+            .map_err(|e| anyhow::anyhow!("call_func({fn_index}) failed: {e:?}"))?;
        Ok(())
    }
@@ -18,11 +18,11 @@ confidence-threshold = 0.8
 [bans]
 multiple-versions = "deny"
 wildcards = "deny"
-# Transitive duplicates from wasmtime v47 dependencies
+# Transitive duplicates from wasmtime v31 -- will resolve when upgrading
 skip = [
    "getrandom",
    "syn",
    "hashbrown",
    "r-efi",
    "thiserror",
    "thiserror-impl",
    "wasm-encoder",
@@ -0,0 +1,230 @@
 # Plan: SEE / SEE-IR / HELP — Introspection Trio
 Status: implemented 2026-08-05 (all phases; HELP covers every word in a fresh VM, enforced by test)
 Scope: `SEE` (source-level decompile), `SEE-IR` (optimized-IR dump), `HELP` (per-word docs), shared lookup infrastructure.
 Each phase is self-contained and executable in a fresh context. Execute in order; every phase leaves the tree green (`cargo test --workspace` passes).
 ---
 ## Phase 0 — Consolidated Findings (read this first, do not re-derive)
 All references verified at commit `e31407a` (branch `usability`).
 ### The template to copy: WORDS
 `WORDS` is a **host primitive whose body runs Rust-side via the `pending_define` mechanism**. This is the exact pattern for SEE/SEE-IR/HELP because it gives a real dictionary entry (→ findable by `'`, listed by `WORDS`, tab-completable in the CLI via `crates/cli/src/main.rs:452-455`, exposed to web palette via `crates/web/src/lib.rs:61`) while the implementation can still call `next_token()` and write `self.output`.
 - Registration: `register_words()` at `crates/core/src/outer.rs:6301-6310` — host fn pushes code `40` into `pending_define`, called from `register_primitives()` at `outer.rs:2991` under the `// -- Programming-Tools word set --` header.
 - Dispatch: `handle_pending_define()` arm at `outer.rs:5328`: `40 => self.do_words(),`.
 - Body: `do_words()` at `outer.rs:6045-6074`. Note `outer.rs:6050-6052`: it reads an optional same-line argument with `self.next_token()` **gated on `self.state == 0`** — SEE must copy this gate.
 - **Used `pending_define` codes: 1–12, 20, 21, 25, 33, 40.** Free: **41 (SEE), 42 (SEE-IR), 43 (HELP)**. Legend comment at `outer.rs:232-233` must be extended.
 ### Allowed APIs (verified signatures)
 | API | Location | Notes |
 |---|---|---|
 | `Dictionary::find(&self, name: &str) -> Option<(u32, WordId, bool)>` | `dictionary.rs:182` | `(word_addr, WordId, is_immediate)`, case-insensitive |
 | `Dictionary::word_name(word_addr)` / `code_field(word_addr)` / `read_link` / `latest()` | `dictionary.rs:375/392/287/282` | manual entry walk |
 | `flags::IMMEDIATE = 0x80`, `HIDDEN = 0x40`, `INTERNAL = 0x20` | `dictionary.rs:16-27` | raw flags byte = `dict.memory()[(word_addr+4) as usize]` — no getter exists |
 | `ir_bodies: HashMap<WordId, Vec<IrOp>>` | `outer.rs:256` | **post-optimization** IR; populated for colon words AND all defining-word products AND IR primitives (see kind table below) |
 | `host_word_names: HashMap<WordId, String>` | `outer.rs:214` | only populated by `register_host_primitive` (`outer.rs:2702-2703`) |
 | `does_definitions: HashMap<WordId, DoesDefinition>` | `outer.rs:223` | DOES>-words |
 | `output: Arc<Mutex<String>>` | `outer.rs:208` | ALL text output goes here; `HostAccess` has **no** emit method (`runtime.rs:17-60`) |
 | `next_token()` | `outer.rs:690-704` | whitespace-delimited, advances `input_pos` |
 | `register_host_primitive(name, immediate, func) -> anyhow::Result<WordId>` | `outer.rs:2686-2691` | public |
 | `IrOp` enum, `#[derive(Debug, Clone, PartialEq)]` | `ir.rs:9-218` | **no `Display` impl exists anywhere in core** — formatter is net-new |
 | `eval_output(input) -> String` test helper | `outer.rs:7566` | fresh VM per call; multi-eval tests build VM inline like `outer.rs:9077-9080` |
 ### Word-kind classification (SEE must distinguish these)
 | Kind | Detectable via | SEE output strategy |
 |---|---|---|
 | Colon word / `:NONAME` | in `ir_bodies`, has captured source (Phase 3) | source (Phase 3) or IR (Phase 2) |
 | IR primitive (`DUP`…) | in `ir_bodies`, no source | IR body + "primitive" tag |
 | Host primitive (`.S`, `WORDS`…) | in `host_word_names` | `<built-in host word>` stub |
 | CONSTANT / VARIABLE / VALUE / CREATE / DEFER / SYNONYM / BUFFER: / 2\*/F\* | in `ir_bodies` with recognizable shape (e.g. CONSTANT = `[PushI32(v)]`, insert sites: `outer.rs:3194/3226/3263/3309/3351/3388/3440/6517/6547/6590/7344`) | synthesized definition, e.g. `42 CONSTANT ANSWER` (Phase 3) |
 | DOES>-defined word | key in `does_definitions` | show CREATE part + DOES> body IR |
 | Interpreter special token (`:`, `;`, `VARIABLE`, `'`, `CHAR`…) | hardcoded matches `outer.rs:755-820`, `927-992`; several have **no dictionary entry at all** | `<compiler word, handled by the outer interpreter>` stub |
 ### Hard constraints
 1. **Feature-free.** `outer.rs`, `ir.rs`, `dictionary.rs` compile without the `native` feature (`lib.rs:17-42`); web consumes core with `default-features = false` (`crates/web/Cargo.toml:15`). No `#[cfg(feature = "native")]` in any SEE code. Unit tests live in the existing `#[cfg(all(test, feature = "native"))]` module (`outer.rs:7553`) — that is fine and matches practice.
 2. **`ir_bodies` stores post-optimization IR** (`finish_colon_def`: optimize at `outer.rs:2297`, insert at `outer.rs:2298`; inlining threshold 8 at `optimizer.rs:56`). `: FOO SQ SQ ;` shows `SQ`'s body inlined. This is a *feature* for SEE-IR (shows what the optimizer did) and the *reason* SEE needs separate source capture (Phase 3).
 3. **Multi-line definitions**: compile state persists across `evaluate()` calls (`outer.rs:512-514` resets only `input_buffer`/`input_pos`); the driver (CLI `main.rs:411-416`) feeds lines. Source capture must accumulate across calls. On error, `evaluate()` wipes compile state (`outer.rs:523-535`) — capture state must be wiped there too.
 4. **Error house style** (`outer.rs:1294/3400/4057` precedents): `anyhow::bail!("SEE: unknown word: {name}")`, `anyhow::bail!("SEE: expected word name")`.
 5. **Compliance suite gives SEE zero coverage** — `toolstest.fth:38-39` explicitly excludes it. All coverage is hand-written unit tests. Adding SEE cannot break `compliance_tools`.
 6. **MARKER correctness**: any new per-word map (source text, docs) must be snapshotted/restored in `MarkerState` (`outer.rs:166-176`, snapshot `outer.rs:3462-3480`, restore `outer.rs:3484-3506`), mirroring how `ir_bodies` is handled there.
 ### Anti-patterns (verified NOT to exist — do not invent)
 - `HostAccess::emit(...)` / any output method on `HostAccess` — does not exist; capture `Arc::clone(&self.output)` instead.
 - `Display for IrOp` — does not exist; write the formatter.
 - A dictionary "entry struct" or kind tag — does not exist; classify via the VM-side maps above.
 - `Dictionary::flags(addr)` getter — does not exist; read the raw byte.
 - Refill-on-demand for a missing SEE argument — `REFILL`/`ACCEPT` are hardcoded to fail (`outer.rs:5824-5852`); `SEE` at end of line is an error, same as `'` (`outer.rs:4051-4053`).
 ---
 ## Phase 1 — IR pretty-printer (pure function, no VM changes)
 **Goal:** a feature-free formatter turning `&[IrOp]` into readable, indented text. Foundation for SEE-IR and the SEE fallback path.
 **What to implement:**
 1. New module `crates/core/src/see.rs`, registered unconditionally in `lib.rs` next to `pub mod outer;` (`lib.rs:30`). Public API:
   ```rust
   /// Format an IR body as indented, one-op-per-line text.
   pub fn format_ir(ops: &[IrOp]) -> String
   ```
 2. Exhaustive `match` over every `IrOp` variant (full list at `ir.rs:10-218`) — **no wildcard arm**, so adding a variant later forces a formatter update at compile time.
 3. Simple ops print as their Forth-ish name plus payload: `PushI32(7)` → `push 7`, `Call(WordId(12))` → `call #12`, `TailCall` → `tail-call #12`. Resolve `#12` to a word name at a higher level (Phase 2) — `format_ir` itself stays name-agnostic, but takes an optional resolver to keep it pure:
   ```rust
   pub fn format_ir_with(ops: &[IrOp], resolve: &dyn Fn(WordId) -> Option<String>) -> String
   ```
   (`format_ir` delegates with a `|_| None` resolver.)
 4. The six nested variants (`If`, `DoLoop`, `BeginUntil`, `BeginAgain`, `BeginWhileRepeat` at `ir.rs:78-99`, `BeginDoubleWhileRepeat` at `ir.rs:105-111`) print as Forth control words with 2-space indented bodies:
   ```
   if
     dup
     mul
   else
     drop
   then
   ```
 5. Flat branch ops (`Block`/`BranchIfFalse`/`EndBlock`, `ir.rs:118-124`) print literally (`block L3` etc.) — they have no clean Forth surface syntax; do not attempt reconstruction.
 **Verification checklist:**
 - [ ] Unit tests in `see.rs` (plain `#[cfg(test)]`, NOT feature-gated — the module has no runtime dependency): nested `If` inside `DoLoop` indents correctly; every-variant smoke test via a `Vec` containing one of each simple op.
 - [ ] `cargo check -p wafer-core --no-default-features` passes (proves feature-freedom).
 - [ ] `cargo test --workspace` green; `cargo fmt --all` + `cargo clippy --workspace` clean.
 **Anti-pattern guards:** no `impl Display for IrOp` (keep the formatter in `see.rs`, IrOp is data); no wildcard match arm; no `#[cfg(feature = "native")]`.
 ---## Phase 2 — SEE-IR word
 **Goal:** `SEE-IR name` prints the stored post-optimization IR for any word — the optimizer-debugging view. Ship this before source-SEE: it is nearly free and immediately useful.
 **What to implement:**
 1. Copy the WORDS registration pattern verbatim (`outer.rs:6301-6310`): `register_see_ir()` pushes pending code **42**; register in `register_primitives()` next to `self.register_words()?` (`outer.rs:2991`). Extend the legend comment at `outer.rs:232-233`.
 2. Dispatch arm in `handle_pending_define()` next to `outer.rs:5328`: `42 => self.do_see_ir(),`.
 3. `do_see_ir()` (place near `do_words()`, `outer.rs:6045`):
   - Parse name: `let Some(name) = self.next_token() else { bail!("SEE-IR: expected word name") }` — **no** interpret-mode gate here (unlike WORDS' optional filter, the argument is mandatory; compile-mode `SEE-IR` may simply also parse — matches `'`).
   - Lookup: `self.dictionary.find(&name)` → else `bail!("SEE-IR: unknown word: {name}")`.
   - Classify per the Phase 0 kind table, in this order: `ir_bodies` hit → header line + `see::format_ir_with(...)` with a resolver that maps `WordId` → name (build once from a dictionary walk: `latest()`/`read_link`/`word_name`/`code_field`, `dictionary.rs:282/287/375/392`); `host_word_names` hit → `SEE-IR: <name> is a built-in host word`; neither → `SEE-IR: <name> has no IR body`.
   - Header line format: `\ <NAME> — <n> ops (optimized IR)`, plus ` immediate` when the find() flag is set, plus `does>` info when `does_definitions` has the id.
   - Write everything into `self.output.lock().unwrap()`; end with `\n` (multi-line output convention from commit `2910884`).
 4. Special-token names (`:`, `VARIABLE`, `'`, …): after dictionary miss, check a small const list of known interpreter tokens (source: match arms at `outer.rs:755-820`, `927-992`) and print `SEE-IR: <name> is handled directly by the outer interpreter` instead of erroring.
 **Documentation references:** WORDS pattern `outer.rs:6301-6310`, `5328`, `6045-6074`; error style `outer.rs:4057`; output convention `outer.rs:6056-6073`.
 **Verification checklist:**
 - [ ] Tests (in `outer.rs` test module, `eval_output` style, cf. `outer.rs:9035-9041`):
  - `: SQ DUP * ; SEE-IR SQ` output contains `dup` and `mul`;
  - `: FOO SQ SQ ; SEE-IR FOO` shows the **inlined** body (contains two `mul`, no `call`) — locks in the "optimized view" semantics;
  - `SEE-IR DUP` works (IR primitive); `SEE-IR WORDS` prints host-word stub; `SEE-IR NOSUCHWORD` errors with `SEE-IR: unknown word: NOSUCHWORD`; bare `SEE-IR` errors with `expected word name`;
  - `SEE-IR :` prints the interpreter-token message.
 - [ ] `IF`/`ELSE`/`THEN` and `DO LOOP` bodies render indented (one structured-word test).
 - [ ] `cargo test --workspace` green; fmt + clippy clean; `cargo check -p wafer-core --no-default-features` passes.
 **Anti-pattern guards:** do not print via a nonexistent `HostAccess` emit; do not gate name parsing on `state == 0` (mandatory arg, not optional filter); do not `THROW -13` (plain `bail!` matches TO/SYNONYM precedent).
 ---
 ## Phase 3 — Source capture + SEE
 **Goal:** `SEE name` prints the original source text `: name … ;` for colon words, synthesized definitions for data words, graceful stubs otherwise. This is the user-facing SEE.
 **What to implement:**
 1. **Capture fields** on `ForthVM` (near `compiling_ir`, `outer.rs:204`):
   ```rust
   compiling_source: String,      // accumulated raw text of the definition in progress
   source_capture_from: Option<usize>,  // input_pos where capture started in the CURRENT buffer
   word_sources: HashMap<WordId, String>,
   ```
 2. **Capture protocol** (verbatim source, including comments and string literals — token-level reassembly would lose them):
   - `start_colon_def()` (`outer.rs:2097`): set `source_capture_from` to the position where `:` began. `interpret_token()` receives the token already consumed, so record the position **before** dispatch: in the `evaluate()` loop (`outer.rs:518-521`), remember `pos_before = self.input_pos` minus token — simplest correct form: capture `token_start` inside `next_token()` (`outer.rs:690-704`) into a new field `last_token_start: usize` as it skips whitespace; `start_colon_def` then does `self.source_capture_from = Some(self.last_token_start)`.
   - End of `evaluate()` (after the loop, `outer.rs:~536`): if still compiling and capture active, flush `input_buffer[from..]` + `'\n'` into `compiling_source`, reset `source_capture_from = Some(0)` so the next buffer continues capture from its start.
   - `finish_colon_def()` (`outer.rs:2266`): flush `input_buffer[from..=pos of ';']`, store `word_sources.insert(word_id, normalized)`, clear capture state. Normalize only trailing whitespace; keep interior verbatim.
   - Error path `outer.rs:523-535`: clear both capture fields alongside the existing compile-state wipe.
   - `:NONAME` and quotations (`outer.rs:759-761, 773-778`): skip capture (no name to SEE) — guard on `compiling_name.is_some()`.
 3. **MARKER integration**: add `word_sources` to `MarkerState` (`outer.rs:166-176`), snapshot (`outer.rs:3462-3480`) and restore (`outer.rs:3484-3506`) exactly as `ir_bodies` is handled there.
 4. **SEE word**: pending code **41**, same registration/dispatch shape as Phase 2. `do_see()` resolution order:
   1. `word_sources` hit → print stored source verbatim, append ` immediate` on its own line if flagged (cf. `set_immediate`, `dictionary.rs:404`).
   2. Recognizable data-word IR shape (Phase 0 kind table) → synthesized one-liner. CONSTANT `[PushI32(v)]` → `<v> CONSTANT <NAME>`; VARIABLE → `VARIABLE <NAME>  ( addr=<v> )`; VALUE `[PushI32(a), Fetch]` → `<cur> VALUE <NAME>` reading current value via `self.rt` memory read if cheap, else `VALUE <NAME>`; SYNONYM `[Call(id)]` → `SYNONYM <NAME> <OLD>`; DEFER → `DEFER <NAME>` plus current target name via `does`/pfa lookup when resolvable.
   3. `ir_bodies` hit (primitive or pre-capture colon word) → `\ <NAME> is a primitive; IR:` + `format_ir_with` output (reuse Phase 1/2 machinery — SEE never dead-ends).
   4. `host_word_names` hit → `<NAME> is a built-in host word`.
   5. Interpreter-token list → `<NAME> is handled by the outer interpreter (compiler word)`.
   6. Else → `bail!("SEE: unknown word: {name}")`.
 5. **Boot words get sources for free**: `boot.fth` definitions flow through the same `evaluate()`/`finish_colon_def` path, so `SEE NIP` etc. shows real boot source. Verify, don't assume — one test below.
 **Documentation references:** compile-state lifecycle `outer.rs:512-535`, `2097-2121`, `2266-2329`; multi-line REPL driver `main.rs:411-416`; MarkerState `outer.rs:166-176, 3462-3506`.
 **Verification checklist:**
 - [ ] `: SQ DUP * ; SEE SQ` prints `: SQ DUP * ;` (verbatim, one line).
 - [ ] Multi-line: inline-VM test (pattern `outer.rs:9077-9080`): `evaluate(": TRI\")` then `evaluate(\"  DUP DUP ;")`, then `SEE TRI` shows both lines.
 - [ ] Comment survives: `: C ( n -- n ) 1+ ; SEE C` output contains `( n -- n )`.
 - [ ] `42 CONSTANT A SEE A` → `42 CONSTANT A`; `VARIABLE V SEE V` → contains `VARIABLE V`.
 - [ ] `SEE NIP` (boot word) prints a colon definition, not an IR dump.
 - [ ] `SEE DUP` prints the primitive-IR fallback; `SEE WORDS` prints host stub; `SEE '` prints interpreter-token message; unknown word errors in house style.
 - [ ] MARKER round-trip: define word, set marker, redefine, execute marker, `SEE` shows the original — plus existing marker tests still green.
 - [ ] Immediate flag: `: I2 ; IMMEDIATE SEE I2` output contains `immediate`.
 - [ ] Error path: force `unknown word` mid-definition, then define a fresh word — its captured source must not contain debris from the aborted definition.
 - [ ] Full suite + fmt + clippy + `--no-default-features` check.
 **Anti-pattern guards:** do not reconstruct source from tokens (loses comments/strings/spacing); do not capture into `word_sources` for `:NONAME`; do not forget the error-path wipe (`outer.rs:523-535`) — stale capture corrupts the next definition's source; `evaluate()` resets `input_pos` per call (`outer.rs:512-514`) so `source_capture_from` is per-buffer, never carried across calls uncleared.
 ---
 ## Phase 4 — HELP word + doc table
 **Goal:** `HELP name` prints stack effect + one-line description; `HELP` alone prints usage. Shares lookup/classification with SEE.
 **What to implement:**
 1. New feature-free module `crates/core/src/wordhelp.rs`: a static table
   ```rust
   /// (NAME, stack effect, one-line description)
   pub const WORD_DOCS: &[(&str, &str, &str)] = &[
       ("DUP", "( x -- x x )", "Duplicate the top of the data stack."),
       ...
   ];
   pub fn lookup(name: &str) -> Option<(&'static str, &'static str)>  // case-insensitive
   ```
   Seed from the Forth 2012 glossary (stack effects are standardized). Cover, in priority order: core + core-ext words WAFER implements, then tools/double/float sets. Incomplete coverage is acceptable and expected — `HELP` says `no help for <name> (word exists)` when the word is defined but undocumented, which doubles as the TODO list.
 2. `HELP` word: pending code **43**, same registration/dispatch shape as Phase 2. Resolution: parse optional name (bare `HELP` → usage line `HELP <word>  — also try: WORDS, SEE <word>, SEE-IR <word>`); table hit → print `NAME  ( stack effect )  description`; miss but dictionary hit → `no help for <name>` + hint `try SEE <name>`; miss both → house-style unknown-word error.
 3. Cross-wiring (the "as useful as possible" part):
   - `SEE`/`SEE-IR` prepend the HELP line as a `\ ...` comment when the table has one.
   - `HELP` appends ` immediate` / `built-in` / `defined in boot.fth or user code` classification reusing the Phase 2/3 classifier — factor that classifier into a shared `fn classify_word(&self, name) -> WordClass` when Phase 4 lands (do NOT pre-build it in Phase 2; extract once there are two users, per smallest-change rule).
 4. User-defined words: optional docstring convention — if the captured source's first parenthesized comment looks like a stack effect (`( ... -- ... )`), `HELP` echoes it for user words. No new syntax, zero cost, rewards idiomatic Forth style.
 **Verification checklist:**
 - [ ] `HELP DUP` prints stack effect + description; `HELP dup` (lowercase) same.
 - [ ] `HELP` alone prints usage; `HELP NOSUCH` errors house-style; `HELP MYWORD` for undocumented-but-defined word prints the `no help` + `SEE` hint.
 - [ ] `: SQ ( n -- n^2 ) DUP * ; HELP SQ` echoes `( n -- n^2 )`.
 - [ ] Table lint test: iterate `WORD_DOCS`, assert every documented name resolves in a booted VM's dictionary (catches typos/renames mechanically).
 - [ ] Full suite + fmt + clippy + `--no-default-features`.
 **Anti-pattern guards:** no doc strings threaded through `register_primitive` call sites (200+ call-site churn, bloats outer.rs — the side table is deliberate); no partial-coverage panic — missing docs degrade gracefully.
 ---
 ## Phase 5 — Final verification + docs
 1. **Full gate:** `cargo fmt --all` && `cargo clippy --workspace` (zero warnings) && `cargo test --workspace` (expect baseline 431 unit + new SEE/SEE-IR/HELP tests, 1 benchmark, 11 compliance, 9 comparison — all green).
 2. **Feature-freedom proof:** `cargo check -p wafer-core --no-default-features` and web build `cd crates/web && wasm-pack build --target web --dev --out-dir www/pkg`.
 3. **Manual REPL pass** (CLI): `SEE SQ`, `SEE-IR FOO` with inlining, `HELP DUP`, multi-line definition then SEE, tab-complete `SE<tab>` — confirm multi-line output renders per commit `2910884` conventions (block output, ` ok` on own line).
 4. **Web REPL smoke:** serve `crates/web/www`, run the same commands — output flows through `take_output()` (`web/src/lib.rs:38-43`), no web-side changes expected.
 5. **Anti-pattern grep:** `grep -n "cfg(feature" crates/core/src/see.rs crates/core/src/wordhelp.rs` → empty; `grep -n "impl Display for IrOp" -r crates/core` → empty; `grep -rn "emit" crates/core/src/see.rs` → empty.
 6. **Docs:** `docs/FORTH.md:95` already lists SEE under Programming-Tools — verify claim now true; add SEE/SEE-IR/HELP to README feature list if words are enumerated there; extend CLAUDE.md test-count line.
 7. **Compliance untouched:** `cargo test -p wafer-core --test compliance` — must stay 11/11 (suite excludes SEE by design, `toolstest.fth:38-39`).
 ---
 ## Deliberate scope cuts (revisit later, not now)
 - **`SEE-WASM`** (disassemble compiled module via `wasmprinter`): compiled bytes are likely dropped after instantiation; `codegen.rs` unexamined. Separate plan if wanted.
 - **IR→Forth source reconstruction** for optimized bodies: lossy and misleading post-inlining; the source-capture path makes it unnecessary.
 - **`LOCATE` / editor integration**: needs file/line provenance in the dictionary; out of scope.
 - **Forth-side doc syntax (`:doc`)**: revisit after self-hosting work starts; the `( n -- n^2 )` echo in Phase 4 covers the 80% case with zero syntax.
@@ -33,10 +33,7 @@ contexts:
    - include: compare
    - include: memory
    - include: io
    - include: pictured
    - include: string_ops
    - include: float
    - include: tools
    - include: dictionary
    - include: exception
    - include: parsing
@@ -98,31 +95,27 @@ contexts:
    # Quotations (Core-Ext 6.2.0455): [: ... ;] compiles an anonymous word.
    - match: '(?i)(?:^|(?<=\s))(\[:|;\]){{ident_break}}'
      scope: keyword.other.definition.forth
-    - match: '(?i)(?:^|(?<=\s))(VARIABLE|2VARIABLE|CONSTANT|2CONSTANT|VALUE|CREATE|DEFER|MARKER|REMEMBER|BUFFER:|FCONSTANT|FVARIABLE)(\s+)(\S+)?'
+    - match: '(?i)(?:^|(?<=\s))(VARIABLE|2VARIABLE|CONSTANT|2CONSTANT|VALUE|CREATE|DEFER|MARKER|BUFFER:|FCONSTANT|FVARIABLE)(\s+)(\S+)?'
      captures:
        1: keyword.other.defining.forth
        3: entity.name.constant.forth
-    - match: '(?i)(?:^|(?<=\s))(DOES>|IMMEDIATE|RECURSE|POSTPONE|COMPILE,|LITERAL|2LITERAL|FLITERAL|SLITERAL|DEFER!|DEFER@){{ident_break}}'
+    - match: '(?i)(?:^|(?<=\s))(DOES>|IMMEDIATE|RECURSE|POSTPONE|COMPILE,|LITERAL|2LITERAL|FLITERAL|SLITERAL){{ident_break}}'
      scope: keyword.other.defining.forth
  control:
    - match: '(?i)(?:^|(?<=\s))(IF|THEN|ELSE|BEGIN|UNTIL|WHILE|REPEAT|AGAIN|DO|\?DO|LOOP|\+LOOP|LEAVE|UNLOOP|EXIT|CASE|OF|ENDOF|ENDCASE|QUIT){{ident_break}}'
      scope: keyword.control.forth
    # Conditional compilation (Tools-ext 15.6.2).
    - match: '(?i)(?:^|(?<=\s))(\[IF\]|\[ELSE\]|\[THEN\]|\[DEFINED\]|\[UNDEFINED\]){{ident_break}}'
      scope: keyword.control.conditional-compilation.forth
  stack_ops:
    - match: '(?i)(?:^|(?<=\s))(DUP|\?DUP|DROP|SWAP|OVER|ROT|-ROT|NIP|TUCK|PICK|ROLL|2DUP|2DROP|2SWAP|2OVER|2ROT|DEPTH|SP@){{ident_break}}'
      scope: support.function.stack.forth
  return_stack:
-    # RP@ / RDEPTH are WAFER extensions (gforth-style return-stack access).
+    - match: '(?i)(?:^|(?<=\s))(>R|R>|R@|2>R|2R>|2R@|N>R|NR>|I|J|CS-PICK|CS-ROLL){{ident_break}}'
    - match: '(?i)(?:^|(?<=\s))(>R|R>|R@|2>R|2R>|2R@|N>R|NR>|I|J|CS-PICK|CS-ROLL|RP@|RDEPTH){{ident_break}}'
      scope: support.function.return-stack.forth
  arithmetic:
-    - match: '(?i)(?:^|(?<=\s))(\+|-|\*|/|MOD|/MOD|\*/|\*/MOD|NEGATE|ABS|MIN|MAX|1\+|1-|2\*|2/|M\*|M\+|M\*/|UM\*|UM/MOD|FM/MOD|SM/REM|S>D|D>S|D\+|D-|DNEGATE|DABS|DMAX|DMIN|D2\*|D2/){{ident_break}}'
+    - match: '(?i)(?:^|(?<=\s))(\+|-|\*|/|MOD|/MOD|\*/|\*/MOD|NEGATE|ABS|MIN|MAX|1\+|1-|2\*|2/|M\*|M\+|M\*/|UM\*|UM/MOD|FM/MOD|SM/REM|S>D|D>S){{ident_break}}'
      scope: keyword.operator.arithmetic.forth
  logic:
@@ -130,36 +123,21 @@ contexts:
      scope: keyword.operator.logical.forth
  compare:
-    - match: '(?i)(?:^|(?<=\s))(=|<>|<|>|<=|>=|U<|U>|0=|0<>|0<|0>|D<|D=|D0<|D0=|DU<|WITHIN){{ident_break}}'
+    - match: '(?i)(?:^|(?<=\s))(=|<>|<|>|<=|>=|U<|U>|0=|0<>|0<|0>){{ident_break}}'
      scope: keyword.operator.comparison.forth
  memory:
-    - match: '(?i)(?:^|(?<=\s))(@|!|C@|C!|\+!|2@|2!|C,|ALLOT|HERE|ALIGN|ALIGNED|CELL\+|CELLS|CHAR\+|CHARS|UNUSED|MOVE|CMOVE|CMOVE>|FILL|ERASE|BLANK|ALLOCATE|FREE|RESIZE|PAD){{ident_break}}'
+    - match: '(?i)(?:^|(?<=\s))(@|!|C@|C!|\+!|2@|2!|ALLOT|HERE|ALIGN|ALIGNED|CELL\+|CELLS|CHAR\+|CHARS|UNUSED|MOVE|CMOVE|CMOVE>|FILL|ERASE|BLANK|ALLOCATE|FREE|RESIZE|PAD){{ident_break}}'
      scope: support.function.memory.forth
  io:
-    - match: '(?i)(?:^|(?<=\s))(EMIT|CR|SPACE|SPACES|TYPE|\.|U\.|\.R|U\.R|D\.|D\.R|\?|KEY|KEY\?|PAGE|AT-XY|ACCEPT|EXPECT|\.S|F\.S|\.RS){{ident_break}}'
+    - match: '(?i)(?:^|(?<=\s))(EMIT|CR|SPACE|SPACES|TYPE|\.|U\.|\.R|U\.R|D\.|D\.R|\?|KEY|KEY\?|PAGE|AT-XY|ACCEPT|EXPECT|\.S){{ident_break}}'
      scope: support.function.io.forth
  # Pictured numeric output (6.1: <# # #S #> HOLD SIGN; HOLDS is Core-Ext).
  pictured:
    - match: '(?i)(?:^|(?<=\s))(<#|#>|#S|#|HOLD|HOLDS|SIGN){{ident_break}}'
      scope: support.function.pictured.forth
  # String word set (17.6).
  string_ops:
    - match: '(?i)(?:^|(?<=\s))(COUNT|COMPARE|-TRAILING|/STRING){{ident_break}}'
      scope: support.function.string.forth
  float:
-    - match: '(?i)(?:^|(?<=\s))(F\+|F-|F\*\*|F\*|F/|FNEGATE|FABS|FMAX|FMIN|FSQRT|FFLOOR|FROUND|FLOOR|FSINCOS|FSINH|FSIN|FCOSH|FCOS|FTANH|FTAN|FASINH|FASIN|FACOSH|FACOS|FATANH|FATAN2|FATAN|FEXPM1|FEXP|FLNP1|FLN|FLOG|FALOG|F=|F<|F0=|F0<|F~|FDUP|FDROP|FSWAP|FOVER|FROT|FNIP|FTUCK|FDEPTH|F@|F!|FE\.|FS\.|F\.|F>D|D>F|F>S|S>F|>FLOAT|REPRESENT|PRECISION|SET-PRECISION|FALIGN|FALIGNED|DFALIGN|DFALIGNED|SFALIGN|SFALIGNED|FLOAT\+|FLOATS|DFLOAT\+|DFLOATS|SFLOAT\+|SFLOATS|DF@|DF!|SF@|SF!){{ident_break}}'
+    - match: '(?i)(?:^|(?<=\s))(F\+|F-|F\*|F/|FNEGATE|FABS|FMAX|FMIN|FSQRT|FFLOOR|FROUND|FSINCOS|F=|F<|F0=|F0<|F~|FDUP|FDROP|FSWAP|FOVER|FROT|FNIP|FTUCK|FDEPTH|F@|F!|FE\.|FS\.|F\.|F>D|D>F|F>S|S>F|>FLOAT|REPRESENT|PRECISION|SET-PRECISION|FALIGNED|DFALIGNED|SFALIGNED|DF@|DF!|SF@|SF!){{ident_break}}'
      scope: support.function.float.forth
  # Interactive/debug tools (Tools word set + WAFER REPL additions).
  tools:
    - match: '(?i)(?:^|(?<=\s))(SEE-IR|SEE|DUMP|BYE|HELP){{ident_break}}'
      scope: support.function.tools.forth
  dictionary:
    - match: "(?i)(?:^|(?<=\\s))('|\\[']|,|>BODY|FIND|WORDS|ONLY|ALSO|PREVIOUS|DEFINITIONS|FORTH|GET-ORDER|SET-ORDER|GET-CURRENT|SET-CURRENT|WORDLIST|SEARCH-WORDLIST|FORTH-WORDLIST|ENVIRONMENT\\?|EXECUTE){{ident_break}}"
      scope: support.function.dictionary.forth
@@ -169,7 +147,7 @@ contexts:
      scope: keyword.control.exception.forth
  parsing:
-    - match: '(?i)(?:^|(?<=\s))(PARSE|PARSE-NAME|WORD|REFILL|EVALUATE|INCLUDE|INCLUDED|SOURCE|SOURCE-ID|>IN|BASE|DECIMAL|HEX|STATE|>NUMBER|SEARCH|SUBSTITUTE|UNESCAPE|REPLACES|S){{ident_break}}'
+    - match: '(?i)(?:^|(?<=\s))(PARSE|PARSE-NAME|WORD|REFILL|EVALUATE|SOURCE|SOURCE-ID|>IN|BASE|STATE|>NUMBER|SEARCH|SUBSTITUTE|UNESCAPE|REPLACES|S){{ident_break}}'
      scope: support.function.parsing.forth
  literals:
@@ -207,5 +185,5 @@ contexts:
  wafer_extras:
    # WAFER-specific extensions beyond the Forth 2012 standard.
    # When the language grows new user-facing non-standard words, add them here.
-    - match: '(?i)(?:^|(?<=\s))(CONSOLIDATE|RANDOM|RND-SEED|UTIME|READ-PASSWORD|EMPTY|GILD){{ident_break}}'
+    - match: '(?i)(?:^|(?<=\s))(CONSOLIDATE|RANDOM|RND-SEED|UTIME|READ-PASSWORD){{ident_break}}'
      scope: support.function.wafer-extra.forth