diff --git a/AGENT.md b/AGENT.md
deleted file mode 100644
index 92dc9d71e1..0000000000
--- a/AGENT.md
+++ /dev/null
@@ -1,395 +0,0 @@
-# AGENT.md — Semantic Web Language Server (swls)
-
-> Quick reference for AI coding agents working in this repository.
-
----
-
-## What Is This Project?
-
-**swls** is a Language Server Protocol (LSP) server for Semantic Web languages, providing IDE-like features (completion, hover, diagnostics, formatting, rename, etc.) for **Turtle** and **SPARQL** in any LSP-compatible editor (VS Code, NeoVim, JetBrains).
-
-The server binary communicates over stdio using the LSP protocol (via `tower-lsp`). It also compiles to WASM for browser/VS Code extension use.
-
-- **Published crate / binary**: `swls`
-- **Repository**: https://github.com/semanticweblanguageserver/swls
-- **Paper citation**: ESWC 2025 – "The Semantic Web Language Server"
-
----
-
-## Workspace Layout
-
-```
-swls/                        ← workspace root
-├── core/                    ← swls-core: ECS framework, all shared types, backend, features
-├── swls/                    ← swls: native binary (main.rs) and TowerClient
-├── lang-turtle/             ← swls-lang-turtle: Turtle (.ttl) language support
-├── lang-sparql/             ← swls-lang-sparql: SPARQL (.sq/.rq/.sparql) language support
-├── lov/                     ← swls-lov: bundled prefix/ontology metadata (LocalPrefix)
-├── test-utils/              ← shared test harness (TestClient, TestFs, setup_world, create_file)
-├── conformance/             ← W3C conformance tests for Turtle parser (generated via build.rs)
-├── turtle/                  ← A* error-recovering parser (excluded from workspace, path dep)
-├── prefixes/                ← (submodule/data) prefix data for lov
-├── jetbrains/               ← JetBrains IDE plugin (separate Kotlin/Gradle project)
-└── examples/                ← usage examples
-```
-
-All Rust crates share `[workspace.dependencies]` from the root `Cargo.toml`.
-
-> **Note:** The `turtle/` directory is **excluded** from the workspace (`exclude = ["turtle"]` in root `Cargo.toml`) because it has the same package name as the upstream crate. It is consumed as a path dependency by `lang-turtle`, `lang-sparql`, and `core`. Do not add it to the workspace members list.
-
----
-
-## The `turtle/` A* Parser Crate
-
-The `turtle/` directory is a local copy of an A* error-recovering parser for Turtle and SPARQL. It is the **primary parsing engine** for both `lang-turtle` and `lang-sparql`.
-
-### Key APIs
-
-```rust
-// Parse a Turtle document incrementally
-let (parse, new_prev) = turtle::parse_incremental(
-    Rule::new(SyntaxKind::Turtle),   // or SyntaxKind::QueryUnit for SPARQL
-    source,
-    prev,                            // Option<&PrevParseInfo> — None for fresh parse
-    IncrementalBias::default(),
-);
-
-// Get the rowan CST
-let syntax: SyntaxNode<Lang> = parse.syntax::<Lang>();
-
-// Convert to model
-let turtle_model: turtle::model::Turtle = turtle::convert(&syntax);        // Turtle
-let turtle_model: turtle::model::Turtle = turtle::sparql::convert::convert(&syntax);  // SPARQL
-```
-
-### Model Types (`turtle::model::*`)
-
-- `Turtle { base, set_base, prefixes, triples }` — document root
-- `Triple { subject, predicate_objects }` — one subject with all its PO pairs
-- `Term` — `NamedNode | BlankNode | Literal | Variable | Collection | ...`
-- `TurtlePrefix { name, value }` — prefix declaration
-- `Spanned<T>` — `(value: T, range: Range<usize>)` with `Deref<Target=T>` and utility methods
-
-### Error Recovery
-
-The A* parser always produces a complete CST even for invalid input. Errors are represented as:
-- `SyntaxNode` with `kind == SyntaxKind::Error` (structural error recovery)
-- `SyntaxToken` with `kind == SyntaxKind::Error` (lexer-level invalid token)
-
-**Always use `children_with_tokens()` + `NodeOrToken` matching** when walking the CST to detect errors — `.children()` alone misses token-level errors.
-
-### Stack Overflow Prevention
-
-`turtle::List<T>` is a recursive cons-list. The default recursive `Drop` causes stack overflows on large files. Fixed by `turtle::list::drop_list<T>` (iterative walk via `Rc::try_unwrap`), called in `Parse::from_steps`.
-
----
-
-
-## Architecture: ECS-Driven LSP
-
-The core design is **Entity Component System (ECS)** using **Bevy ECS** (`bevy_ecs`). Each open document is an ECS **Entity**. Derived data (tokens, triples, prefixes, completions, hover info, diagnostics) are **Components** attached to that entity. LSP requests are modelled as **Schedules** that run ECS systems.
-
-### Request Lifecycle
-
-1. An LSP request arrives at `Backend` (in `core/src/backend.rs`), which implements `tower_lsp::LanguageServer`.
-2. `Backend` sends a `CommandQueue` to a tokio channel that feeds the single-threaded `World`.
-3. The command inserts request-specific components (e.g., `CompletionRequest`) on the entity, then runs the relevant **Schedule** (e.g., `CompletionLabel`).
-4. Systems in that schedule read existing components and populate the request component.
-5. The result is returned to the LSP client.
-
-### Schedule Labels (features)
-
-All defined in `core/src/feature/`:
-
-| Label | LSP Feature |
-|---|---|
-| `ParseLabel` | Tokenize + parse document |
-| `CompletionLabel` | Code completion |
-| `HoverLabel` | Hover info |
-| `DiagnosticsLabel` | Publish diagnostics |
-| `FormatLabel` | Document formatting |
-| `RenameLabel` / `PrepareRenameLabel` | Rename symbol |
-| `ReferencesLabel` | Find references |
-| `GotoDefinitionLabel` | Go to definition |
-| `GotoTypeLabel` | Go to type definition |
-| `CodeActionLabel` | Code actions |
-| `SemanticLabel` | Semantic token highlighting |
-| `InlayLabel` | Inlay hints |
-| `SaveLabel` | On-save actions |
-| `Tasks` | Async background tasks |
-| `Startup` | One-time world initialization |
-
-### Key Components (in `core/src/components/`)
-
-- `Source(String)` — raw document text
-- `RopeC(Rope)` — efficient rope representation for edits
-- `Label(Url)` — document URL, used as entity identity key
-- `Element<L>` — parsed semantic element (language-specific AST root)
-- `CstTokens(Vec<Spanned<rowan::SyntaxKind>>)` — CST leaf tokens extracted from the A* parse tree
-- `Comments(Vec<Spanned<String>>)` — comments extracted from CST (used by formatter)
-- `Triples` — parsed RDF triples (sophia_api quads)
-- `Prefixes` — prefix/namespace map for the document
-- `Open` — marker: document is currently open in the editor
-- `Dirty` — marker: document has unparsed changes
-- `DocumentLinks` — referenced documents (via `owl:imports` or prefix imports)
-- `PositionComponent` — cursor position injected during a request
-- `DynLang(Box<dyn LangHelper>)` — language-specific helper (keywords, text extraction)
-- `DefinedClass`, `DefinedClasses`, `DefinedProperty`, `DefinedProperties` — derived ontology info
-- `CompletionRequest`, `HoverRequest`, `FormatRequest`, etc. — per-request response accumulators
-- `TokenComponent` — cursor-specific token context (`text`, `range`, `source_span`, `is_error`); no longer wraps a typed `Token`
-- `TripleComponent` — cursor-specific triple context; provides `term()` returning `MyTerm` with fully-expanded IRI
-
-### Key Resources
-
-- `SemanticTokensDict` — maps `SemanticTokenType` → index
-- `Ontologies` — known ontology data loaded at startup
-- `OntologyExtractor` — async ontology fetching with LOV API caching
-- `TypeHierarchy` — RDF class hierarchy (subclass relationships)
-- `DiagnosticPublisher` — sends diagnostics back to client via channel
-- `CommandSender` / `CommandReceiver` — channel for sending `CommandQueue` to the world
-- `Fs(Arc<dyn FsTrait>)` — file system abstraction (native vs. WASM)
-- `ServerConfig` — top-level config (enabled languages, workspaces); contains `LocalConfig` and `CompletionConfig`
-
----
-
-## Language Trait System
-
-Each language implements two traits (in `core/src/lang.rs`):
-
-### `Lang` trait
-
-Implemented by `TurtleLang`, `Sparql`:
-
-```rust
-pub trait Lang: 'static {
-    type Element: Send + Sync;        // parsed AST root (turtle::model::Turtle for both Turtle and SPARQL)
-    type ElementError: Into<SimpleDiagnostic> + ...;
-
-    const CODE_ACTION: bool;
-    const HOVER: bool;
-    const LANG: &'static str;        // e.g. "turtle", "sparql"
-    const TRIGGERS: &'static [&'static str];  // completion trigger chars
-    const LEGEND_TYPES: &'static [SemanticTokenType];
-    const PATTERN: Option<&'static str>;
-
-    fn semantic_token_type(kind: rowan::SyntaxKind) -> Option<SemanticTokenType> { None }
-}
-```
-
-> **Note:** `type Token` and `type TokenError` have been removed. There is no longer a typed token layer — the A* CST (`CstTokens`) is used directly. Semantic systems (hover, rename, references) work via `TripleComponent`.
-
-### `LangHelper` trait
-
-Provides runtime language-specific behavior: keywords list and text extraction from tokens (e.g., JSON-LD strips quotes from string tokens).
-
-### Adding a New Language
-
-1. Create a new crate `lang-xxx/`.
-2. Define a marker component (`struct MyLang`) and implement `Lang` and `LangHelper`.
-3. Register a `CreateEvent` observer that matches by `language_id` or file extension.
-4. Implement `setup_world(world: &mut World)` and call it from `swls/src/main.rs`.
-5. Use the `turtle/` A* parser (Turtle or SPARQL grammar) — no separate tokenizer is needed.
-
----
-
-## Crate Details
-
-### `core` (`swls-core`)
-
-The backbone. Contains:
-- `backend.rs` — `Backend` struct, implements `tower_lsp::LanguageServer`, dispatches all requests.
-- `components/` — all ECS components and resources.
-- `feature/` — one module per LSP feature; each has a `setup_schedule()` fn and a `Label` schedule.
-- `systems/` — generic systems: `spawn_or_insert`, `handle_tasks`, `derive_classes`, `derive_ontologies`, `complete_properties`, `complete_class`, `fetch_lov_properties`, `open_imports`, etc.
-  - `shapes/` — **SHACL shape validation** (feature-gated with `shapes` feature flag); uses `shacl_validation`, `shacl_ir`, `shacl_ast` crates; supports multi-file shape compilation and global shapes
-- `store.rs` — Oxigraph RDF 1.2 store wrapper (used for SPARQL queries and SHACL validation)
-- `lang.rs` — `Lang` and `LangHelper` traits. Typed token layer removed (`TokenTrait` gone).
-- `client.rs` — `Client` (async) and `ClientSync` traits; platform abstraction.
-- `util/` — range conversions, `Spanned<T>`, triple utilities. `get_current_cst_token` replaces old `get_current_token`; `CstTokens`/`Comments` components defined here.
-- `store.rs` — document store utilities.
-- `prelude.rs` — everything commonly needed; use `swls_core::prelude::*`.
-
-### `swls` (binary crate)
-
-- `main.rs` — entry point; builds tokio runtime, sets up `World` with all language plugins, launches `tower_lsp::Server` over stdio.
-- `client.rs` — `TowerClient` (wraps `tower_lsp::Client`), `BinFs` (native filesystem).
-- `timings.rs` — tracing layer for request timing.
-- Logs go to `$TMPDIR/turtle-lsp.txt` (falls back to stderr).
-
-### `lang-turtle` (`swls-lang-turtle`)
-
-Uses the **A\* error-recovering parser** from the `turtle/` crate. No separate tokenizer.
-
-- `lang/parser.rs` — wraps `turtle::parse_incremental` (Turtle grammar); defines `TurtleParseError`, `PrevParseInfo`; `parse_new(source, base_url, prev) -> (Turtle, Vec<TurtleParseError>, PrevParseInfo, SyntaxNode)`. `collect_errors` walks the CST via `children_with_tokens()` to catch both Error nodes and Error tokens.
-- `lang/model.rs` — extension-trait layer over `turtle::model::*`: `TurtleExt` (get_simple_triples, get_prefixes, get_base), `TriplesBuilder` (subject/predicate/object expansion), `NamedNodeExt`, `TurtlePrefixExt`, `Based`. `get_simple_triples()` is the main entry point → `Vec<MyQuad>`.
-- `lang/formatter.rs` — document formatter; receives `Comments` from the ECS.
-- `lang/mod.rs` — exports all submodules; provides `parse_source` compatibility shim for conformance tests.
-- `ecs/parse.rs` — `parse_turtle_system`: calls `parse_new`, extracts `CstTokens` + `Comments` from the CST; open docs skip incremental state (`prev=None`) to avoid A* bias; `derive_triples` calls `TurtleExt::get_simple_triples()`.
-- `ecs/format.rs` — `format_turtle_system`: reads `Comments` component and passes to `format_turtle`.
-- `ecs/` — completion, formatting, code actions, hover, semantic tokens systems.
-- `config.rs`, `prefix.rs` — prefix/config helpers.
-- Supports: diagnostics, completion (prefixes, properties, classes), formatting, code actions, hover, semantic tokens.
-
-**Key type aliases used throughout:**
-- `turtle::model::Turtle` — parsed document model (`triples`, `prefixes`, `base`, `set_base`)
-- `turtle::Spanned<T>` — re-exported as `swls_core::prelude::Spanned<T>`; wraps a value with a byte range
-- `MyQuad` — `sophia_api`-compatible quad extracted from triples
-- `TurtleParseError { range: Range<usize>, msg: String }` — parser error
-
-**Incremental parse note:** For open (user-edited) documents, always pass `prev=None` to `parse_new` to avoid A* error-recovery bias from stale state. LOV (read-only) documents may reuse `PrevParseInfo`.
-
-**Placeholder triple:** When a predicate has no object (e.g., `foaf:` with cursor after colon), `TriplesBuilder::handle_po` pushes a `MyQuad` with `MyTerm::invalid` as object. This ensures `get_current_triple` can detect predicate position for autocompletion.
-
-### `lang-sparql` (`swls-lang-sparql`)
-
-Uses the **A\* SPARQL parser** from `turtle::sparql` and models SPARQL as `turtle::model::Turtle` (triples + prefixes). No rich SPARQL AST — sufficient for all current LSP features. No separate tokenizer.
-
-- `ecs/mod.rs` — `parse_sparql_system`: calls `turtle::parse_incremental` with `SyntaxKind::QueryUnit`, then `turtle::sparql::convert::convert()` to get a `Turtle` model; extracts `CstTokens` from CST. `collect_errors` walks CST via `children_with_tokens()`. `derive_triples` calls `TurtleExt::get_simple_triples()`. `variable_completion` uses `Triples` component.
-- `lang/mod.rs` — minimal; SPARQL keywords defined as `SPARQL_KEYWORDS` static slice.
-- `type Element = turtle::model::Turtle`, `type ElementError = TurtleParseError`
-- Note: `CODE_ACTION = false`, no formatting. Recognized by `language_id == "sparql"` or `.sq`/`.rq` extension.
-
-### `lov` (`swls-lov`)
-
-Bundled prefix/ontology metadata. Provides `LocalPrefix` component with fields: `location`, `namespace`, `content`, `name`, `title`, `rank`. The `LOCAL_PREFIXES` static slice is generated from `min_prefixes` submodule.
-
-### `test-utils`
-
-Shared test harness:
-- `TestClient` — implements `Client` + `ClientSync`; collects logs and diagnostics; runs futures via `async-executor`.
-- `TestFs` — implements `FsTrait`; uses a temp directory.
-- `setup_world(client, f)` — creates a `World`, runs `Startup`, returns `(World, DiagnosticReceiver)`.
-- `create_file(world, content, url, lang, bundle)` — inserts a document entity and triggers parse.
-- `debug_world(world)` — prints all entities and their components.
-
-### `conformance`
-
-W3C Turtle conformance test suite runner. `build.rs` generates test functions from the `w3c/` directory. `test_syntax(location, is_positive)` parses a `.ttl` file and checks whether parsing succeeds/fails as expected.
-
----
-
-## Key Dependencies
-
-| Crate | Role |
-|---|---|
-| `bevy_ecs` | ECS world, components, systems, schedules |
-| `bevy_tasks` | Task spawning |
-| `tower-lsp` | LSP protocol server implementation |
-| `turtle` (path dep) | A* error-recovering parser for Turtle + SPARQL; provides `turtle::model::*`, `parse_incremental`, `Spanned<T>` |
-| `rowan` | CST (concrete syntax tree) underlying the A* parser output |
-| `ropey` | Rope data structure for efficient text edits |
-| `sophia_api` / `sophia_iri` / `sophia_turtle` | RDF data model and quad iterators |
-| `oxigraph` (0.5.3) | RDF 1.2 store with embedded SPARQL engine (used for SHACL/store) |
-| `shacl_validation` / `shacl_ir` / `shacl_ast` | SHACL shape validation (feature-gated) |
-| `reqwest` | HTTP fetching for ontologies/LOV |
-| `serde` / `serde_json` | JSON serialization |
-| `tracing` | Structured logging and timing |
-| `similar` | Text diffing (for formatting edits) |
-| `futures` | Async utilities, channels |
-| `tokio` | Async runtime (native binary) |
-
----
-
-## Build & Dev
-
-### Common Commands
-
-```sh
-# Build the full workspace
-cargo build --workspace
-
-# Build and install the native binary (debug)
-cargo install --path swls
-
-# Run all tests (including conformance)
-cargo test --workspace
-
-# Build docs for all crates
-cargo doc --workspace --lib
-
-# Run a specific crate's tests
-cargo test -p swls-core
-cargo test -p swls-lang-turtle
-cargo test -p conformance
-```
-
-### `Makefile.toml` (cargo-make tasks)
-
-Run with `cargo make <task>`:
-
-| Task | Description |
-|---|---|
-| `deps` | Install `wasm-bindgen-cli` |
-| `install-bin` | `cargo install --path ./lsp-bin/ --debug` |
-| `build-server` | Build WASM target for browser/VS Code |
-| `run-app` | Run the Monaco demo app locally |
-| `run-web` | Run VS Code web extension locally |
-| `build-prod` | Production build of web app |
-| `build-docs` | Build all Rust docs |
-
-### Nix
-
-`flake.nix` provides a dev shell. Use `nix develop` to get a shell with all tools.
-
-### CI (`.github/workflows/ci.yml`)
-
-- **build-native**: `cargo build --all-targets --workspace` + `cargo test --workspace` on `ubuntu-latest`
-- **doc**: Builds and deploys docs to GitHub Pages (runs after `build-native`)
-- Triggers: push/PR to `main`
-
----
-
-## Testing Patterns
-
-Tests live alongside the code or in `conformance/`. Use `test-utils` for integration-style tests:
-
-```rust
-use test_utils::{TestClient, setup_world, create_file};
-use swls_lang_turtle::setup_world as turtle_setup;
-
-let client = TestClient::new();
-let (mut world, _diag_rx) = setup_world(client, |world| {
-    turtle_setup::<TestClient>(world);
-});
-let entity = create_file(&mut world, "@prefix ex: <http://example.org/> .\n", 
-    "file:///test.ttl", "turtle", ());
-world.run_schedule(CompletionLabel);
-// inspect world components on entity
-```
-
-`TestClient::await_futures(|| world.run_schedule(Tasks))` drains async tasks (e.g., LOV fetches).
-
----
-
-## LSP Configuration (Client Side)
-
-The server accepts `initializationOptions`:
-
-```json
-{
-  "turtle": true,
-  "sparql": false
-}
-```
-
-Each key enables/disables the corresponding language plugin.
-
-NeoVim file type detection:
-- `*.ttl` → `turtle`
-- `*.sq`, `*.rq`, `*.sparql` → `sparql`
-
----
-
-## Important Conventions
-
-- **`prelude::*`** — almost all code does `use swls_core::prelude::*`; check `core/src/prelude.rs` to see what's exported.
-- **Feature schedules** — to add a new system to a feature, use `world.schedule_scope(FeatureLabel, |_, schedule| { schedule.add_systems(...) })`.
-- **Entity = document** — never think of entities as anything else in this codebase.
-- **`Changed<T>` queries** — systems typically use `Changed<Triples>` or `Changed<CstTokens>` to avoid redundant recomputation.
-- **`Without<Dirty>`** — always guard derived-data systems with `Without<Dirty>` to skip documents that haven't finished parsing.
-- **`shapes` feature flag** — SHACL validation in `swls-core` is gated behind `features = ["shapes"]`; not enabled by default.
-- **Error handling** — errors are `SimpleDiagnostic` converted from parser errors via `Into<SimpleDiagnostic>`.
-- **Logging** — use `tracing::{debug!, info!, error!}`. Logs go to `$TMPDIR/turtle-lsp.txt` (falls back to stderr).
-- **Temp files** — `BinFs` stores virtual files in `/tmp/swls/<N>/` (auto-incrementing N).
-- **Formatting** — `rustfmt.toml` at workspace root; run `cargo fmt`.
-- **No `prefixes/` Rust crate** — the `prefixes/` dir appears to be a data submodule, not a compiled crate.
diff --git a/Cargo.lock b/Cargo.lock
index db557ca7e8..0d453b361b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -170,22 +170,6 @@ dependencies = [
  "pin-project-lite",
 ]
 
-[[package]]
-name = "async-codec-lite"
-version = "0.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2527c30e3972d8ff366b353125dae828c4252a154dbe6063684f6c5e014760a3"
-dependencies = [
- "anyhow",
- "bytes",
- "futures-core",
- "futures-io",
- "futures-sink",
- "log",
- "pin-project-lite",
- "thiserror 1.0.69",
-]
-
 [[package]]
 name = "async-executor"
 version = "1.14.0"
@@ -346,7 +330,7 @@ dependencies = [
  "serde",
  "slotmap",
  "smallvec",
- "thiserror 2.0.18",
+ "thiserror",
  "variadics_please",
 ]
 
@@ -420,7 +404,7 @@ dependencies = [
  "serde",
  "smallvec",
  "smol_str",
- "thiserror 2.0.18",
+ "thiserror",
  "uuid",
  "variadics_please",
  "wgpu-types",
@@ -743,7 +727,7 @@ dependencies = [
  "semver",
  "serde",
  "serde_json",
- "thiserror 2.0.18",
+ "thiserror",
  "tokio",
  "tracing",
  "tracing-subscriber",
@@ -1636,7 +1620,7 @@ dependencies = [
  "proptest",
  "reqwest",
  "serde",
- "thiserror 2.0.18",
+ "thiserror",
  "url",
 ]
 
@@ -1673,7 +1657,7 @@ dependencies = [
  "jni-sys",
  "log",
  "simd_cesu8",
- "thiserror 2.0.18",
+ "thiserror",
  "walkdir",
  "windows-link",
 ]
@@ -1895,7 +1879,7 @@ dependencies = [
  "iri_s",
  "serde",
  "serde_json",
- "thiserror 2.0.18",
+ "thiserror",
  "tracing",
  "yaml-rust2",
 ]
@@ -2040,7 +2024,7 @@ dependencies = [
  "sparesults",
  "spareval",
  "spargebra",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -2068,7 +2052,7 @@ dependencies = [
  "oxiri",
  "oxrdf",
  "ryu-js",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -2083,7 +2067,7 @@ dependencies = [
  "oxsdatatypes",
  "rand 0.9.4",
  "sha2",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -2096,7 +2080,7 @@ dependencies = [
  "oxrdf",
  "oxrdfxml",
  "oxttl",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -2109,7 +2093,7 @@ dependencies = [
  "oxiri",
  "oxrdf",
  "quick-xml",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -2119,7 +2103,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06fa874d87eae638daae9b4e3198864fe2cce68589f227c0b2cf5b62b1530516"
 dependencies = [
  "js-sys",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -2132,7 +2116,7 @@ dependencies = [
  "oxilangtag",
  "oxiri",
  "oxrdf",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -2335,7 +2319,7 @@ dependencies = [
  "iri_s",
  "proptest",
  "serde",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -2466,7 +2450,7 @@ dependencies = [
  "rustc-hash 2.1.2",
  "rustls",
  "socket2",
- "thiserror 2.0.18",
+ "thiserror",
  "tokio",
  "tracing",
  "web-time",
@@ -2487,7 +2471,7 @@ dependencies = [
  "rustls",
  "rustls-pki-types",
  "slab",
- "thiserror 2.0.18",
+ "thiserror",
  "tinyvec",
  "tracing",
  "web-time",
@@ -2604,9 +2588,9 @@ dependencies = [
 
 [[package]]
 name = "rdf-parsers"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a78a9e22c77a5c933bea42ebb1c6891164ee40700a883c986c987959a084a86"
+checksum = "dfe6d27af89d2b3c55604bed8e52e220b56e664aacf5df48b45da1451833cf21"
 dependencies = [
  "async-trait",
  "logos",
@@ -2632,7 +2616,7 @@ checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
 dependencies = [
  "getrandom 0.2.17",
  "libredox",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -2835,7 +2819,7 @@ dependencies = [
  "spargebra",
  "tabled",
  "tempfile",
- "thiserror 2.0.18",
+ "thiserror",
  "tokio",
  "toml",
  "url",
@@ -3163,7 +3147,7 @@ dependencies = [
  "itertools",
  "prefixmap",
  "rudof_rdf",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -3182,7 +3166,7 @@ dependencies = [
  "rudof_rdf",
  "shacl_ast",
  "shacl_rdf",
- "thiserror 2.0.18",
+ "thiserror",
  "tracing",
 ]
 
@@ -3200,7 +3184,7 @@ dependencies = [
  "regex",
  "rudof_rdf",
  "shacl_ast",
- "thiserror 2.0.18",
+ "thiserror",
  "tracing",
 ]
 
@@ -3224,7 +3208,7 @@ dependencies = [
  "shacl_rdf",
  "sparql_service",
  "tabled",
- "thiserror 2.0.18",
+ "thiserror",
  "toml",
  "tracing",
  "tracing-subscriber",
@@ -3335,7 +3319,7 @@ dependencies = [
  "resiter",
  "serde",
  "sophia_iri",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -3345,7 +3329,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebacba4fa7baed53f89844a5c9e5962d6232a449d5b450b9de72bb67f0203332"
 dependencies = [
  "sophia_api",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -3358,7 +3342,7 @@ dependencies = [
  "oxiri",
  "regex",
  "serde",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -3397,7 +3381,7 @@ dependencies = [
  "memchr",
  "oxrdf",
  "quick-xml",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -3420,7 +3404,7 @@ dependencies = [
  "sparesults",
  "spargebra",
  "sparopt",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -3434,7 +3418,7 @@ dependencies = [
  "oxrdf",
  "peg",
  "rand 0.9.4",
- "thiserror 2.0.18",
+ "thiserror",
 ]
 
 [[package]]
@@ -3469,7 +3453,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sparesults",
- "thiserror 2.0.18",
+ "thiserror",
  "toml",
  "tracing",
 ]
@@ -3522,7 +3506,7 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "swls"
-version = "0.2.2"
+version = "0.3.0"
 dependencies = [
  "async-trait",
  "bevy_ecs",
@@ -3552,6 +3536,7 @@ dependencies = [
 name = "swls-conformance"
 version = "0.1.0"
 dependencies = [
+ "rdf-parsers",
  "sophia_api",
  "sophia_inmem",
  "sophia_iri",
@@ -3562,8 +3547,9 @@ dependencies = [
 
 [[package]]
 name = "swls-core"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
+ "async-trait",
  "bevy_ecs",
  "chrono",
  "chumsky",
@@ -3572,6 +3558,7 @@ dependencies = [
  "futures",
  "iri_s",
  "lazy_static",
+ "lsp-types",
  "mie",
  "oxigraph",
  "oxrdf",
@@ -3589,13 +3576,29 @@ dependencies = [
  "sophia_api",
  "sparql_service",
  "swls-lov",
- "tower-lsp",
+ "tracing",
+]
+
+[[package]]
+name = "swls-e2e-tests"
+version = "0.1.0"
+dependencies = [
+ "bevy_ecs",
+ "futures",
+ "ropey",
+ "swls-core",
+ "swls-lang-jsonld",
+ "swls-lang-sparql",
+ "swls-lang-trig",
+ "swls-lang-turtle",
+ "swls-test-utils",
+ "test-log",
  "tracing",
 ]
 
 [[package]]
 name = "swls-lang-jsonld"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "async-trait",
  "bevy_ecs",
@@ -3617,7 +3620,7 @@ dependencies = [
 
 [[package]]
 name = "swls-lang-rdf-base"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "bevy_ecs",
  "rdf-parsers",
@@ -3627,7 +3630,7 @@ dependencies = [
 
 [[package]]
 name = "swls-lang-sparql"
-version = "0.1.4"
+version = "0.1.5"
 dependencies = [
  "async-trait",
  "bevy_ecs",
@@ -3650,7 +3653,7 @@ dependencies = [
 
 [[package]]
 name = "swls-lang-trig"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "async-trait",
  "bevy_ecs",
@@ -3670,7 +3673,7 @@ dependencies = [
 
 [[package]]
 name = "swls-lang-turtle"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "async-trait",
  "bevy_ecs",
@@ -3703,6 +3706,7 @@ version = "0.1.0"
 dependencies = [
  "async-executor",
  "async-std",
+ "async-trait",
  "bevy_ecs",
  "chumsky",
  "futures",
@@ -3711,7 +3715,6 @@ dependencies = [
  "serde_json",
  "sophia_api",
  "swls-core",
- "tower-lsp",
  "tracing",
 ]
 
@@ -3850,33 +3853,13 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f18aa187839b2bdb1ad2fa35ead8c4c2976b64e4363c386d45ac0f7ee85c9233"
 
-[[package]]
-name = "thiserror"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
-dependencies = [
- "thiserror-impl 1.0.69",
-]
-
 [[package]]
 name = "thiserror"
 version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
 dependencies = [
- "thiserror-impl 2.0.18",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
+ "thiserror-impl",
 ]
 
 [[package]]
@@ -4139,7 +4122,6 @@ version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b38fb0e6ce037835174256518aace3ca621c4f96383c56bb846cfc11b341910"
 dependencies = [
- "async-codec-lite",
  "async-trait",
  "auto_impl",
  "bytes",
@@ -4591,7 +4573,7 @@ dependencies = [
  "js-sys",
  "log",
  "serde",
- "thiserror 2.0.18",
+ "thiserror",
  "web-sys",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 0c614f1be9..97140235fa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,6 +8,7 @@ homepage = "https://github.com/semanticweblanguageserver/swls"
 
 [workspace.dependencies]
 async-trait = "0.1.89"
+lsp-types = "=0.94.1"
 bevy_ecs = { version = "0.18", default-features = true, features = [
   "multi_threaded"
 ] }
@@ -19,7 +20,7 @@ logos = "0.15.1"
 reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }
 ropey = "1.6.1"
 # rdf-parsers = "0.1.8"
-rdf-parsers = { version = "0.1.13" }
+rdf-parsers = { version = "0.1.14" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.145"
 similar = "2.7"
@@ -63,6 +64,7 @@ members = [
   "swls",
   "test-utils",
   "conformance",
+  "e2e",
 ]
 resolver = "2"
 exclude = ["turtle"]
diff --git a/README.md b/README.md
index da2ea827d3..43ae60955f 100644
--- a/README.md
+++ b/README.md
@@ -5,76 +5,90 @@
 ![LICENSE](https://img.shields.io/badge/License-MIT-8A2BE2)
 [![Visual Studio Marketplace Last Updated](https://img.shields.io/visual-studio-marketplace/last-updated/ajuvercr.semantic-web-lsp?label=VSCode%20Extension)](https://marketplace.visualstudio.com/items?itemName=ajuvercr.semantic-web-lsp)
 
-This repo includes the source code for the semantic web language server.
-The language server provides IDE like functionality for semantic web languages, including Turtle, TriG, JSON-LD and SPARQL.
+**SWLS** is a Language Server Protocol (LSP) server that brings IDE-like tooling — diagnostics,
+completion, hover, navigation, refactoring, formatting and highlighting — to Semantic Web
+languages: **Turtle**, **TriG**, **JSON-LD** and **SPARQL**.
 
-A live demo can be found [online](https://semanticweblanguageserver.github.io/swls/), built with monaco editors.
+Try it instantly, no install required: **[live demo](https://semanticweblanguageserver.github.io/swls/)** (Monaco editor in the browser).
 
-## Documentation
+## Install
 
-- [lsp-core](https://semanticweblanguageserver.github.io/swls/docs/lsp_core/index.html)
-- [lang-turtle](https://semanticweblanguageserver.github.io/swls/docs/lang_turtle/index.html)
-- [lang-jsonld](https://semanticweblanguageserver.github.io/swls/docs/lang_jsonld/index.html)
-- [lang-sparql](https://semanticweblanguageserver.github.io/swls/docs/lang_sparql/index.html)
-- [lsp-bin](https://semanticweblanguageserver.github.io/swls/docs/swls/index.html)
+| Editor | How |
+|---|---|
+| **VS Code** | Install from the [Marketplace](https://marketplace.visualstudio.com/items?itemName=ajuvercr.semantic-web-lsp) ([source](https://github.com/SemanticWebLanguageServer/swls-vscode)) |
+| **NeoVim** | Use the [swls.nvim](https://github.com/SemanticWebLanguageServer/swls.nvim) plugin |
+| **JetBrains** | Install from the JetBrains Marketplace ([source](https://github.com/SemanticWebLanguageServer/swls-jetbrains)) |
+| **Anything else** | Any LSP-capable editor can run the `swls` binary directly — see [Other editors](#other-editors) |
 
+Details and caveats for each editor are in [Installation](#installation) below.
 
 ## Features
 
-### Diagnostics
-
-- Syntax diagnostics
-- Undefined prefix diagnostics
-- SHACL shape diagnostics
-
-### Completion
-
-- Prefix completion (just start writing the prefix, `foa` completes to `foaf:` and adding the prefix statement)
-- Property completion (ordered according to domain)
-- Class completion (when writing the object where the prediate is `a`)
-
-### Hover
-
-- Shows additional information about the entities like class
-
-### Rename
+| Category | What you get |
+|---|---|
+| **Diagnostics** | Syntax errors · undefined-prefix errors · unused-prefix warnings · unknown-property-in-closed-namespace warnings · SHACL shape violations |
+| **Completion** | Keywords (`@prefix`, `@context`, ...) · prefix names (from bundled LOV/prefix.cc data) · classes · domain-aware properties · cross-document subjects (Turtle) · Components.js parameters (JSON-LD) |
+| **Hover** | Inferred RDF type · class & property documentation from the ontology · explanation when a property is only accepted via your allow-list |
+| **Navigation** | Go to definition (RDF terms and, for JSON-LD, Components.js modules/parameters) · go to type definition · find references · rename |
+| **Code actions** | Add missing prefix declaration · allow-list an unknown property · organize/sort `@prefix` imports (Turtle) · extract/inline a blank node |
+| **Formatting** | Document formatting for Turtle and JSON-LD · auto-insert the prefix declaration while typing |
+| **Highlighting** | Semantic syntax highlighting |
+| **Inlay hints** | Inferred type shown inline next to subjects missing an explicit `rdf:type` |
 
-- Rename terms local to the current file 
+Every diagnostic and almost every feature above can be **individually enabled or disabled** —
+see [Configuration](#configuration).
 
-### Formatting
+## Installation
 
-- Format Turtle and JSON-LD
+Currently a fluent install is possible for NeoVim and VS Code. Since SWLS speaks the standard
+Language Server Protocol, it can be wired into any editor with an LSP client — see
+[Other editors](#other-editors) if yours isn't listed below.
 
-### Highlighting
+### VS Code
 
-- Enables semantic highlighting
+There is a VS Code extension available in the [Marketplace](https://marketplace.visualstudio.com/items?itemName=ajuvercr.semantic-web-lsp).
+Source: [SemanticWebLanguageServer/swls-vscode](https://github.com/SemanticWebLanguageServer/swls-vscode).
 
+### JetBrains
 
-## Use the LSP
+There is a JetBrains plugin available in the [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/27501-swls--turtle-trig-sparql--json-ld-language-server).
+Source: [SemanticWebLanguageServer/swls-jetbrains](https://github.com/SemanticWebLanguageServer/swls-jetbrains).
 
-Currently a fluent install is possible for NeoVim and VSCode.
-However the language server protocol enables swift integration into other editors.
+### NeoVim
 
-### VS Code
+A NeoVim plugin is available at [SemanticWebLanguageServer/swls.nvim](https://github.com/SemanticWebLanguageServer/swls.nvim).
 
-Install the semantic web lsp extension ([vscode](https://marketplace.visualstudio.com/items?itemName=ajuvercr.semantic-web-lsp) or [open-vscode](https://open-vsx.org/extension/ajuvercr/semantic-web-lsp)).
-The extension starts the lsp from WASM and starts the vscode LSP client.
+### Other editors
 
-You can configure the LSP to disable certain languages, this is useful as SPARQL is not fully supported yet, but comes bundled in the LSP.
+SWLS is a standard LSP server (stdio transport), so any editor with a generic LSP client
+(Sublime Text, Helix, Emacs `lsp-mode`/`eglot`, Kate, ...) can run it directly. Grab the `swls`
+binary from the [latest release](https://github.com/semanticweblanguageserver/swls/releases) and
+point your editor's LSP client at it for `.ttl`, `.trig`, `.jsonld` and `.sparql`/`.rq` files.
 
-### Jetbrains
+## Configuration
 
-A zip of the Jetbrains plugin is available with the latest releases.
-To install the plugin you should download the zip (swls-1.1-SNAPSHOT.zip) and go to Settings (ctrl + alt + s) > Plugins > Gear > Install Plugin from Disk and select the file.
-Currently the plugin checks the Github releases on each startup to check if the latest binary is installed, and installs the latest binary.
-This is not very user friendly, certainly on low quality internet connections.
+SWLS reads configuration from the client's `initializationOptions`, plus optional
+`.swls/config.json` (workspace) and `~/.config/swls/config.json` (global) files.
 
-PRs are much appreciated on the Jetbrains plugin.
+```json
+{
+  "turtle": true,
+  "sparql": false,
+  "disabled": ["unused_prefix", "hover_excluded_property"]
+}
+```
 
-### NeoVim
+- `turtle` / `trig` / `jsonld` / `sparql` (default `true`) — enable/disable a language plugin entirely.
+- `disabled` — a list of individual diagnostics or LSP (sub-)features to turn off, e.g. just the
+  "unused prefix" warning, or just hover-on-class without touching the rest of hover.
 
-A NeoVim plugin is available at [SemanticWebLanguageServer/swls.nvim](https://github.com/SemanticWebLanguageServer/swls.nvim).
+## Documentation
 
+- [lsp-core](https://semanticweblanguageserver.github.io/swls/docs/lsp_core/index.html)
+- [lang-turtle](https://semanticweblanguageserver.github.io/swls/docs/lang_turtle/index.html)
+- [lang-jsonld](https://semanticweblanguageserver.github.io/swls/docs/lang_jsonld/index.html)
+- [lang-sparql](https://semanticweblanguageserver.github.io/swls/docs/lang_sparql/index.html)
+- [lsp-bin](https://semanticweblanguageserver.github.io/swls/docs/swls/index.html)
 
 ## Screenshots
 
@@ -90,7 +104,7 @@ A NeoVim plugin is available at [SemanticWebLanguageServer/swls.nvim](https://gi
 
 When using the Semantic Web Language Server, please use the following citation:
 
-> A. Vercruysse, J. A. Rojas Melendez, and P. Colpaert, “The semantic web language server : enhancing the developer experience for semantic web practitioners,” in The Semantic Web : 22nd European Semantic Web Conference, ESWC 2025, Proceedings, Part II, Portoroz, Slovenia, 2025, vol. 15719, pp. 210–225.
+> A. Vercruysse, J. A. Rojas Melendez, and P. Colpaert, “The semantic web language server : enhancing the developer experience for semantic web practitioners,” in The Semantic Web : 22nd European Semantic Web Conference, ESWC 2025, Proceedings, Part II, Portoroz, Slovenia, 2025, vol. 15719, pp. 210–225.
 
 Bibtex:
 ```bibtex
diff --git a/conformance/Cargo.toml b/conformance/Cargo.toml
index e3ab667dc1..628c79f77d 100644
--- a/conformance/Cargo.toml
+++ b/conformance/Cargo.toml
@@ -15,6 +15,7 @@ homepage.workspace = true
 sophia_api.workspace   = true
 sophia_iri.workspace   = true
 sophia_turtle = "0.9.0"
+rdf-parsers.workspace  = true
 
 swls-lang-turtle = { path = "../lang-turtle/" }
 swls-core        = { path = "../core/" }
diff --git a/conformance/src/lib.rs b/conformance/src/lib.rs
index b0f53ad3df..b6469ac787 100644
--- a/conformance/src/lib.rs
+++ b/conformance/src/lib.rs
@@ -1,11 +1,8 @@
 #![allow(non_snake_case)]
 use std::{collections::HashSet, str::FromStr as _};
 
-use swls_lang_turtle::lang::{
-    model::{Term, Triple, Turtle},
-    parse_source,
-    // parser2::parse_source as parse_source2,
-};
+use rdf_parsers::model::{BlankNode, NamedNode, Term, Triple, Turtle};
+use swls_lang_turtle::lang::parse_source;
 
 fn check_turtle_defined_prefixes(turtle: Option<&Turtle>) -> bool {
     // check defined prefixes
@@ -15,7 +12,10 @@ fn check_turtle_defined_prefixes(turtle: Option<&Turtle>) -> bool {
             prefixes.insert(pref.value().prefix.value().to_string());
         }
 
-        turtle.triples.iter().all(|t| check_triple(&t, &prefixes))
+        turtle
+            .triples
+            .iter()
+            .all(|t| check_triple(t.value(), &prefixes))
     } else {
         true
     }
@@ -66,16 +66,17 @@ pub fn test_syntax(location: &str, is_positive: bool) {
 }
 
 fn check_triple(triple: &Triple, defined: &HashSet<String>) -> bool {
-    if !check_term(&triple.subject, &defined) {
+    if !check_term(triple.subject.value(), defined) {
         return false;
     }
 
     for po in &triple.po {
-        if !check_term(&po.predicate, defined) {
+        let po = po.value();
+        if !check_term(po.predicate.value(), defined) {
             return false;
         }
 
-        if !po.object.iter().all(|t| check_term(t, defined)) {
+        if !po.object.iter().all(|t| check_term(t.value(), defined)) {
             return false;
         }
     }
@@ -85,22 +86,21 @@ fn check_triple(triple: &Triple, defined: &HashSet<String>) -> bool {
 
 fn check_term(term: &Term, defined: &HashSet<String>) -> bool {
     match term {
-        Term::BlankNode(swls_lang_turtle::lang::model::BlankNode::Unnamed(pos, _, _)) => {
+        Term::BlankNode(BlankNode::Unnamed(pos, _, _)) => {
             for po in pos {
-                if !check_term(&po.predicate, defined) {
+                let po = po.value();
+                if !check_term(po.predicate.value(), defined) {
                     return false;
                 }
 
-                if !po.object.iter().all(|t| check_term(t, defined)) {
+                if !po.object.iter().all(|t| check_term(t.value(), defined)) {
                     return false;
                 }
             }
             true
         }
-        Term::NamedNode(swls_lang_turtle::lang::model::NamedNode::Prefixed { prefix, .. }) => {
-            defined.contains(prefix)
-        }
-        Term::Collection(spanneds) => spanneds.iter().all(|t| check_term(t, defined)),
+        Term::NamedNode(NamedNode::Prefixed { prefix, .. }) => defined.contains(prefix),
+        Term::Collection(spanneds) => spanneds.iter().all(|t| check_term(t.value(), defined)),
         _ => true,
     }
 }
diff --git a/core/CHANGELOG.md b/core/CHANGELOG.md
index 331dd8a4e2..4a46064d6e 100644
--- a/core/CHANGELOG.md
+++ b/core/CHANGELOG.md
@@ -5,6 +5,56 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v0.1.4 (2026-06-22)
+
+### New Features
+
+ - <csr-id-bb4f08bed28af56f776d32f787a459c7325ec47e/> gate features with configuration
+ - <csr-id-4bad0c7033f9029315e831d5801922f959a64165/> add automatic insert of prefix statements when writing colon
+ - <csr-id-ece087810771449d6e3e9badcc21b123af613879/> inline and extract blank nodes
+ - <csr-id-5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1/> add undefined iri's warnings
+ - <csr-id-b55d2807364d9521378e9d5433ee53d3d6bc8109/> prefix diagnostics
+ - <csr-id-91c1ad0150e44713d3589bb264d704a4656e4a8a/> move tower_lsp to swls binary
+ - <csr-id-251a00396498ebe11c4c9632afb72b6dd91dafda/> start rename
+
+### Bug Fixes
+
+ - <csr-id-e93ae6e2e86c1cdb634820f09c120663cf898fee/> incorrect json-ld alias marked as unused + fix spans on diagnostics
+ - <csr-id-3604321f63b609c0095e507c094925d0d49894e5/> improve rename robustness
+ - <csr-id-91a3739936dfb66c688d161c5264c997020abc86/> remove unused systems
+ - <csr-id-aeb99acaba4869abdf8c7b8608b48c6ff91e0149/> better timing on the validation to reduce race conditions
+ - <csr-id-e52d0f65cef812ffeab54b7d110045ce4c74f741/> diagnostics after on change things works way better
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 12 commits contributed to the release over the course of 20 calendar days.
+ - 32 days passed between releases.
+ - 12 commits were understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - Gate features with configuration ([`bb4f08b`](https://github.com/SemanticWebLanguageServer/swls/commit/bb4f08bed28af56f776d32f787a459c7325ec47e))
+    - Incorrect json-ld alias marked as unused + fix spans on diagnostics ([`e93ae6e`](https://github.com/SemanticWebLanguageServer/swls/commit/e93ae6e2e86c1cdb634820f09c120663cf898fee))
+    - Add automatic insert of prefix statements when writing colon ([`4bad0c7`](https://github.com/SemanticWebLanguageServer/swls/commit/4bad0c7033f9029315e831d5801922f959a64165))
+    - Improve rename robustness ([`3604321`](https://github.com/SemanticWebLanguageServer/swls/commit/3604321f63b609c0095e507c094925d0d49894e5))
+    - Remove unused systems ([`91a3739`](https://github.com/SemanticWebLanguageServer/swls/commit/91a3739936dfb66c688d161c5264c997020abc86))
+    - Inline and extract blank nodes ([`ece0878`](https://github.com/SemanticWebLanguageServer/swls/commit/ece087810771449d6e3e9badcc21b123af613879))
+    - Add undefined iri's warnings ([`5daeb7f`](https://github.com/SemanticWebLanguageServer/swls/commit/5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1))
+    - Better timing on the validation to reduce race conditions ([`aeb99ac`](https://github.com/SemanticWebLanguageServer/swls/commit/aeb99acaba4869abdf8c7b8608b48c6ff91e0149))
+    - Diagnostics after on change things works way better ([`e52d0f6`](https://github.com/SemanticWebLanguageServer/swls/commit/e52d0f65cef812ffeab54b7d110045ce4c74f741))
+    - Prefix diagnostics ([`b55d280`](https://github.com/SemanticWebLanguageServer/swls/commit/b55d2807364d9521378e9d5433ee53d3d6bc8109))
+    - Move tower_lsp to swls binary ([`91c1ad0`](https://github.com/SemanticWebLanguageServer/swls/commit/91c1ad0150e44713d3589bb264d704a4656e4a8a))
+    - Start rename ([`251a003`](https://github.com/SemanticWebLanguageServer/swls/commit/251a00396498ebe11c4c9632afb72b6dd91dafda))
+</details>
+
 ## v0.1.3 (2026-05-20)
 
 ### New Features
@@ -16,7 +66,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <csr-read-only-do-not-edit/>
 
- - 3 commits contributed to the release.
+ - 4 commits contributed to the release.
  - 19 days passed between releases.
  - 2 commits were understood as [conventional](https://www.conventionalcommits.org).
  - 0 issues like '(#ID)' were seen in commit messages
@@ -28,6 +78,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>
 
  * **Uncategorized**
+    - Release swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`0d1c8c5`](https://github.com/SemanticWebLanguageServer/swls/commit/0d1c8c52d0b7741321109ad22f1f16d53e4f8dc6))
     - Adjusting changelogs prior to release of swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`4f3e731`](https://github.com/SemanticWebLanguageServer/swls/commit/4f3e731b0301e0b689bfe15e790ad4706a3c84e1))
     - Use lov-mirror on github for better response times ([`eb41444`](https://github.com/SemanticWebLanguageServer/swls/commit/eb4144409025da4fba32892e10c207441c882de0))
     - Better highlighting ([`9b17ed3`](https://github.com/SemanticWebLanguageServer/swls/commit/9b17ed366f37598da0a9747dc51d552bee891ded))
diff --git a/core/Cargo.toml b/core/Cargo.toml
index 0877f31f10..f700d6e5c8 100644
--- a/core/Cargo.toml
+++ b/core/Cargo.toml
@@ -5,7 +5,7 @@ name = "swls-core"
 description = "Core LSP infrastructure for the Semantic Web Language Server"
 keywords = ["lsp", "semantic-web", "rdf", "shacl", "sparql"]
 categories = ["development-tools"]
-version = "0.1.3"
+version = "0.1.4"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
@@ -15,8 +15,8 @@ homepage.workspace = true
 [features]
 default = ["shapes", "tokio"]
 shapes = []
-tokio = ["tower-lsp/runtime-tokio", "sparql_service", "mie"]
-agnostic = ["tower-lsp/runtime-agnostic"]
+tokio = ["sparql_service", "mie"]
+agnostic = []
 
 
 [dependencies]
@@ -29,7 +29,8 @@ serde.workspace        = true
 serde_json.workspace   = true
 sophia_api.workspace   = true
 tracing.workspace      = true
-tower-lsp.workspace = true
+async-trait.workspace  = true
+lsp-types.workspace    = true
 
 dirs = "6"
 chrono = { version = "0.4.42", default-features = false, features = ["serde"] }
diff --git a/core/src/backend.rs b/core/src/backend.rs
index b782e4ea0d..96eee714ac 100644
--- a/core/src/backend.rs
+++ b/core/src/backend.rs
@@ -13,10 +13,10 @@ use goto_type::GotoTypeRequest;
 use references::ReferencesRequest;
 use request::{GotoTypeDefinitionParams, GotoTypeDefinitionResponse};
 use ropey::Rope;
-use tower_lsp::{jsonrpc::Result, LanguageServer};
 use tracing::{debug, error, info, instrument};
 
 use crate::{
+    client::Client,
     feature::{
         code_action::{CodeActionRequest, Label as CodeActionLabel},
         goto_definition::GotoDefinitionRequest,
@@ -26,21 +26,40 @@ use crate::{
     Started, Startup,
 };
 
+/// Error returned by [`Backend`] request handlers.
+///
+/// No handler currently fails at the protocol level, so this type is uninhabited.
+/// It exists so handlers can return a transport-agnostic [`Result`] that front-ends
+/// map onto their own error type (e.g. `tower_lsp::jsonrpc::Error`) without `swls-core`
+/// depending on any transport crate.
 #[derive(Debug)]
-pub struct Backend {
+pub enum ServerError {}
+
+/// Transport-agnostic result type for [`Backend`] request handlers.
+pub type Result<T> = std::result::Result<T, ServerError>;
+
+/// Transport-agnostic LSP request handler.
+///
+/// `Backend` exposes inherent `async` methods mirroring the LSP requests. Front-ends
+/// (the `swls` binary's `tower_lsp` adapter, or a future wasm dispatcher) call these
+/// directly. It is generic over the [`Client`] used to send server-to-client messages.
+pub struct Backend<C> {
     entities: Arc<Mutex<HashMap<String, Entity>>>,
     sender: CommandSender,
-    #[allow(unused)]
-    client: tower_lsp::Client,
+    client: C,
     semantic_tokens: Vec<SemanticTokenType>,
 }
 
-impl Backend {
-    pub fn new(
-        sender: CommandSender,
-        client: tower_lsp::Client,
-        tokens: Vec<SemanticTokenType>,
-    ) -> Self {
+impl<C> std::fmt::Debug for Backend<C> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Backend")
+            .field("semantic_tokens", &self.semantic_tokens)
+            .finish_non_exhaustive()
+    }
+}
+
+impl<C: Client> Backend<C> {
+    pub fn new(sender: CommandSender, client: C, tokens: Vec<SemanticTokenType>) -> Self {
         Self {
             entities: Default::default(),
             sender,
@@ -100,15 +119,27 @@ impl Backend {
         map.get(uri).copied()
     }
 
+    /// Whether the given LSP feature has been disabled via [`ServerConfig`].
+    async fn is_disabled(&self, feature: Disabled) -> bool {
+        self.run(move |world| {
+            world
+                .resource::<ServerConfig>()
+                .config
+                .local
+                .is_disabled(feature)
+        })
+        .await
+        .unwrap_or(false)
+    }
+
     fn adjust_position(pos: &mut Position) {
         pos.character = pos.character.saturating_sub(1);
     }
 }
 
-#[tower_lsp::async_trait]
-impl LanguageServer for Backend {
+impl<C: Client> Backend<C> {
     #[instrument(skip(self, init))]
-    async fn initialize(&self, init: InitializeParams) -> Result<InitializeResult> {
+    pub async fn initialize(&self, init: InitializeParams) -> Result<InitializeResult> {
         info!("Initialize");
 
         let workspaces = init.workspace_folders.clone().unwrap_or_default();
@@ -145,6 +176,9 @@ impl LanguageServer for Backend {
         })
         .collect();
 
+        let disabled = server_config.config.local.disabled.clone();
+        let is_enabled = |d: Disabled| !disabled.contains(&d);
+
         self.run(|world| {
             world.insert_resource(server_config);
             world.run_schedule(Startup);
@@ -155,12 +189,14 @@ impl LanguageServer for Backend {
         Ok(InitializeResult {
             server_info: None,
             capabilities: ServerCapabilities {
-                inlay_hint_provider: Some(OneOf::Left(true)),
+                inlay_hint_provider: is_enabled(Disabled::InlayHint)
+                    .then_some(OneOf::Left(true)),
                 text_document_sync: Some(TextDocumentSyncCapability::Kind(
                     TextDocumentSyncKind::FULL,
                 )),
-                code_action_provider: Some(CodeActionProviderCapability::Simple(true)),
-                completion_provider: Some(CompletionOptions {
+                code_action_provider: is_enabled(Disabled::CodeAction)
+                    .then_some(CodeActionProviderCapability::Simple(true)),
+                completion_provider: is_enabled(Disabled::Completion).then_some(CompletionOptions {
                     resolve_provider: Some(false),
                     trigger_characters: Some(vec![String::from(":")]),
                     work_done_progress_options: Default::default(),
@@ -168,12 +204,21 @@ impl LanguageServer for Backend {
                     completion_item: None,
                 }),
                 // implementation_provider: Some(ImplementationProviderCapability::Simple(true)),
-                type_definition_provider: Some(TypeDefinitionProviderCapability::Simple(true)),
-                references_provider: Some(OneOf::Left(true)),
-                hover_provider: Some(HoverProviderCapability::Simple(true)),
-                definition_provider: Some(OneOf::Left(true)),
-                document_formatting_provider: Some(OneOf::Left(true)),
-                semantic_tokens_provider: Some(
+                type_definition_provider: is_enabled(Disabled::GotoTypeDefinition)
+                    .then_some(TypeDefinitionProviderCapability::Simple(true)),
+                references_provider: is_enabled(Disabled::References).then_some(OneOf::Left(true)),
+                hover_provider: is_enabled(Disabled::Hover)
+                    .then_some(HoverProviderCapability::Simple(true)),
+                definition_provider: is_enabled(Disabled::GotoDefinition)
+                    .then_some(OneOf::Left(true)),
+                document_formatting_provider: is_enabled(Disabled::Format)
+                    .then_some(OneOf::Left(true)),
+                document_on_type_formatting_provider: is_enabled(Disabled::PrefixAutoInsert)
+                    .then_some(DocumentOnTypeFormattingOptions {
+                        first_trigger_character: ":".to_string(),
+                        more_trigger_character: None,
+                    }),
+                semantic_tokens_provider: is_enabled(Disabled::SemanticTokens).then_some(
                     SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(
                         SemanticTokensRegistrationOptions {
                             text_document_registration_options: {
@@ -194,16 +239,22 @@ impl LanguageServer for Backend {
                         },
                     ),
                 ),
-                rename_provider: Some(OneOf::Right(RenameOptions {
-                    prepare_provider: Some(true),
+                rename_provider: is_enabled(Disabled::Rename).then_some(OneOf::Right(
+                    RenameOptions {
+                        prepare_provider: Some(true),
+                        work_done_progress_options: Default::default(),
+                    },
+                )),
+                execute_command_provider: Some(ExecuteCommandOptions {
+                    commands: vec![crate::systems::ALLOW_PROPERTY_COMMAND.to_string()],
                     work_done_progress_options: Default::default(),
-                })),
+                }),
                 ..ServerCapabilities::default()
             },
         })
     }
 
-    async fn initialized(&self, _params: InitializedParams) {
+    pub async fn initialized(&self, _params: InitializedParams) {
         self.run(|world| {
             tracing::info!("initialized");
             world.run_schedule(Started);
@@ -211,7 +262,7 @@ impl LanguageServer for Backend {
         .await;
     }
 
-    async fn did_change_workspace_folders(&self, params: DidChangeWorkspaceFoldersParams) -> () {
+    pub async fn did_change_workspace_folders(&self, params: DidChangeWorkspaceFoldersParams) -> () {
         self.run(move |world| {
             let mut config = world.resource_mut::<ServerConfig>();
             let WorkspaceFoldersChangeEvent { added, removed } = params.event;
@@ -230,11 +281,14 @@ impl LanguageServer for Backend {
     }
 
     #[instrument(skip(self, params), fields(uri = %params.text_document.uri.as_str()))]
-    async fn semantic_tokens_full(
+    pub async fn semantic_tokens_full(
         &self,
         params: SemanticTokensParams,
     ) -> Result<Option<SemanticTokensResult>> {
         debug!("semantic tokens full");
+        if self.is_disabled(Disabled::SemanticTokens).await {
+            return Ok(None);
+        }
         let uri = params.text_document.uri.as_str();
         let Some(entity) = self.get_entity(uri).await else {
             debug!("Didn't find entity {} stopping", uri);
@@ -258,14 +312,17 @@ impl LanguageServer for Backend {
     }
 
     #[instrument(skip(self))]
-    async fn shutdown(&self) -> Result<()> {
+    pub async fn shutdown(&self) -> Result<()> {
         info!("Shutting down!");
 
         Ok(())
     }
 
     #[instrument(skip(self, params), fields(uri = %params.text_document_position.text_document.uri.as_str()))]
-    async fn references(&self, params: ReferenceParams) -> Result<Option<Vec<Location>>> {
+    pub async fn references(&self, params: ReferenceParams) -> Result<Option<Vec<Location>>> {
+        if self.is_disabled(Disabled::References).await {
+            return Ok(None);
+        }
         let Some(entity) = self
             .get_entity(params.text_document_position.text_document.uri.as_str())
             .await
@@ -289,10 +346,13 @@ impl LanguageServer for Backend {
     }
 
     #[instrument(skip(self, params), fields(uri = %params.text_document.uri.as_str()))]
-    async fn prepare_rename(
+    pub async fn prepare_rename(
         &self,
         params: TextDocumentPositionParams,
     ) -> Result<Option<PrepareRenameResponse>> {
+        if self.is_disabled(Disabled::Rename).await {
+            return Ok(None);
+        }
         let Some(entity) = self.get_entity(params.text_document.uri.as_str()).await else {
             return Ok(None);
         };
@@ -316,7 +376,10 @@ impl LanguageServer for Backend {
     }
 
     #[instrument(skip(self, params), fields(uri = %params.text_document_position.text_document.uri.as_str()))]
-    async fn rename(&self, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
+    pub async fn rename(&self, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
+        if self.is_disabled(Disabled::Rename).await {
+            return Ok(Some(WorkspaceEdit::new(HashMap::new())));
+        }
         let Some(entity) = self
             .get_entity(params.text_document_position.text_document.uri.as_str())
             .await
@@ -347,7 +410,10 @@ impl LanguageServer for Backend {
         Ok(Some(WorkspaceEdit::new(change_map)))
     }
 
-    async fn hover(&self, params: HoverParams) -> Result<Option<crate::lsp_types::Hover>> {
+    pub async fn hover(&self, params: HoverParams) -> Result<Option<crate::lsp_types::Hover>> {
+        if self.is_disabled(Disabled::Hover).await {
+            return Ok(None);
+        }
         let request: HoverRequest = HoverRequest::default();
 
         let Some(entity) = self
@@ -385,8 +451,11 @@ impl LanguageServer for Backend {
         Ok(None)
     }
 
-    async fn inlay_hint(&self, params: InlayHintParams) -> Result<Option<Vec<InlayHint>>> {
+    pub async fn inlay_hint(&self, params: InlayHintParams) -> Result<Option<Vec<InlayHint>>> {
         debug!("Inlay hints called");
+        if self.is_disabled(Disabled::InlayHint).await {
+            return Ok(None);
+        }
         let uri = params.text_document.uri.as_str();
         let Some(entity) = self.get_entity(uri).await else {
             debug!("Didn't find entity {}", uri);
@@ -406,7 +475,10 @@ impl LanguageServer for Backend {
     }
 
     #[instrument(skip(self))]
-    async fn formatting(&self, params: DocumentFormattingParams) -> Result<Option<Vec<TextEdit>>> {
+    pub async fn formatting(&self, params: DocumentFormattingParams) -> Result<Option<Vec<TextEdit>>> {
+        if self.is_disabled(Disabled::Format).await {
+            return Ok(None);
+        }
         let uri = params.text_document.uri.as_str();
         let Some(entity) = self.get_entity(uri).await else {
             debug!("Didn't find entity {}", uri);
@@ -419,8 +491,37 @@ impl LanguageServer for Backend {
         Ok(request.and_then(|x| x.0))
     }
 
+    #[instrument(skip(self, params), fields(uri = %params.text_document_position.text_document.uri.as_str()))]
+    pub async fn on_type_formatting(
+        &self,
+        params: DocumentOnTypeFormattingParams,
+    ) -> Result<Option<Vec<TextEdit>>> {
+        if self.is_disabled(Disabled::PrefixAutoInsert).await {
+            return Ok(None);
+        }
+        let uri = params.text_document_position.text_document.uri.as_str();
+        let Some(entity) = self.get_entity(uri).await else {
+            return Ok(None);
+        };
+
+        // Use the exact position after the typed character — do NOT apply
+        // `adjust_position` here, the scan expects the cursor right after `:`.
+        let pos = params.text_document_position.position;
+        let request = self
+            .run_schedule::<on_type_format::OnTypeFormatRequest>(
+                entity,
+                OnTypeFormatLabel,
+                (
+                    PositionComponent(pos),
+                    on_type_format::OnTypeFormatRequest(None),
+                ),
+            )
+            .await;
+        Ok(request.and_then(|x| x.0))
+    }
+
     #[instrument(skip(self, params), fields(uri = %params.text_document.uri.as_str()))]
-    async fn did_open(&self, params: DidOpenTextDocumentParams) {
+    pub async fn did_open(&self, params: DidOpenTextDocumentParams) {
         let item = params.text_document;
         let url = item.uri.as_str().to_string();
 
@@ -445,7 +546,6 @@ impl LanguageServer for Backend {
                 let id = spawn(world);
                 world.run_schedule(ParseLabel);
                 world.flush();
-                world.run_schedule(DiagnosticsLabel);
                 id
             })
             .await;
@@ -460,7 +560,7 @@ impl LanguageServer for Backend {
     }
 
     #[instrument(skip(self, params), fields(uri = %params.text_document.uri.as_str()))]
-    async fn did_change(&self, params: DidChangeTextDocumentParams) {
+    pub async fn did_change(&self, params: DidChangeTextDocumentParams) {
         let Some(entity) = self.get_entity(params.text_document.uri.as_str()).await else {
             debug!("Didn't find entity {}", params.text_document.uri.as_str());
             return;
@@ -481,13 +581,12 @@ impl LanguageServer for Backend {
                 .insert((Source(change.text), rope_c));
             world.run_schedule(ParseLabel);
             world.flush();
-            world.run_schedule(DiagnosticsLabel);
         })
         .await;
     }
 
     #[instrument(skip(self, params), fields(uri = %params.text_document.uri.as_str()))]
-    async fn did_save(&self, params: DidSaveTextDocumentParams) {
+    pub async fn did_save(&self, params: DidSaveTextDocumentParams) {
         let _ = params;
 
         self.run(move |world| {
@@ -499,10 +598,13 @@ impl LanguageServer for Backend {
     }
 
     #[instrument(skip(self, params), fields(uri = %params.text_document_position_params.text_document.uri.as_str()))]
-    async fn goto_definition(
+    pub async fn goto_definition(
         &self,
         params: GotoDefinitionParams,
     ) -> Result<Option<GotoDefinitionResponse>> {
+        if self.is_disabled(Disabled::GotoDefinition).await {
+            return Ok(None);
+        }
         let Some(entity) = self
             .get_entity(
                 params
@@ -535,10 +637,13 @@ impl LanguageServer for Backend {
     }
 
     #[instrument(skip(self, params), fields(uri = %params.text_document_position_params.text_document.uri.as_str()))]
-    async fn goto_type_definition(
+    pub async fn goto_type_definition(
         &self,
         params: GotoTypeDefinitionParams,
     ) -> Result<Option<GotoTypeDefinitionResponse>> {
+        if self.is_disabled(Disabled::GotoTypeDefinition).await {
+            return Ok(None);
+        }
         let Some(entity) = self
             .get_entity(
                 params
@@ -568,17 +673,21 @@ impl LanguageServer for Backend {
     }
 
     #[instrument(skip(self, params), fields(uri = %params.text_document.uri.as_str()))]
-    async fn code_action(&self, params: CodeActionParams) -> Result<Option<CodeActionResponse>> {
+    pub async fn code_action(&self, params: CodeActionParams) -> Result<Option<CodeActionResponse>> {
+        if self.is_disabled(Disabled::CodeAction).await {
+            return Ok(None);
+        }
         let uri = params.text_document.uri.as_str();
         let Some(entity) = self.get_entity(uri).await else {
             return Ok(None);
         };
 
+        let pos = params.range.start;
         let request = self
             .run_schedule::<CodeActionRequest>(
                 entity,
                 CodeActionLabel,
-                CodeActionRequest::default(),
+                (CodeActionRequest::default(), PositionComponent(pos)),
             )
             .await;
 
@@ -589,8 +698,61 @@ impl LanguageServer for Backend {
         }))
     }
 
+    /// Handle `workspace/executeCommand`.
+    ///
+    /// Currently only `swls.allowProperty`: adds the given property IRI to the
+    /// user's `allowed_properties`, both at runtime (clearing the warning) and on
+    /// disk (so the choice survives restarts), then refreshes diagnostics.
+    #[instrument(skip(self, params), fields(command = %params.command))]
+    pub async fn execute_command(
+        &self,
+        params: ExecuteCommandParams,
+    ) -> Result<Option<serde_json::Value>> {
+        if params.command == crate::systems::ALLOW_PROPERTY_COMMAND {
+            let Some(iri) = params
+                .arguments
+                .first()
+                .and_then(|v| v.as_str())
+                .map(String::from)
+            else {
+                return Ok(None);
+            };
+
+            // 1. Update the in-memory config so the warning clears immediately.
+            self.run({
+                let iri = iri.clone();
+                move |world| {
+                    world
+                        .resource_mut::<ServerConfig>()
+                        .config
+                        .local
+                        .allowed_properties
+                        .insert(iri);
+                }
+            })
+            .await;
+
+            // 2. Persist to the global config file.
+            if let Some(fs) = self.run(|w| w.resource::<Fs>().clone()).await {
+                LocalConfig::persist_allowed_property(&fs, &iri).await;
+            }
+
+            // 3. Re-run diagnostics for all open documents.
+            self.run(|world| {
+                world.run_schedule(ParseLabel);
+                world.flush();
+            })
+            .await;
+        }
+
+        Ok(None)
+    }
+
     #[instrument(skip(self, params), fields(uri = %params.text_document_position.text_document.uri.as_str()))]
-    async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
+    pub async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
+        if self.is_disabled(Disabled::Completion).await {
+            return Ok(None);
+        }
         let Some(entity) = self
             .get_entity(params.text_document_position.text_document.uri.as_str())
             .await
diff --git a/core/src/client.rs b/core/src/client.rs
index a2f5d99acd..af0b130abc 100644
--- a/core/src/client.rs
+++ b/core/src/client.rs
@@ -10,7 +10,7 @@ pub struct Resp {
     pub status: u16,
 }
 
-#[tower_lsp::async_trait]
+#[async_trait::async_trait]
 pub trait Client: Clone + ClientSync {
     async fn log_message<M: Display + Sync + Send + 'static>(&self, ty: MessageType, msg: M) -> ();
     async fn publish_diagnostics(
diff --git a/core/src/components/config.rs b/core/src/components/config.rs
index 3ff7c263aa..137e64d43f 100644
--- a/core/src/components/config.rs
+++ b/core/src/components/config.rs
@@ -1,17 +1,145 @@
 use std::{collections::HashSet, path::PathBuf};
 
 use bevy_ecs::prelude::*;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 use crate::{
     lsp_types::{Url, WorkspaceFolder},
     util::fs::Fs,
 };
 
-#[derive(Debug, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Disabled {
     #[serde(alias = "SHAPES", alias = "shapes")]
     Shapes,
+
+    // --- diagnostics ---
+    /// Diagnostic for predicate/object IRIs that use an undeclared prefix.
+    #[serde(alias = "UNDEFINED_PREFIX", alias = "undefined_prefix")]
+    UndefinedPrefix,
+    /// Diagnostic for prefixes that are declared but never used.
+    #[serde(alias = "UNUSED_PREFIX", alias = "unused_prefix")]
+    UnusedPrefix,
+    /// Diagnostic for properties under a `closed_namespaces` namespace that are
+    /// not known to the ontology and not in `allowed_properties`.
+    #[serde(alias = "NAMESPACE_PROPERTIES", alias = "namespace_properties")]
+    NamespaceProperties,
+    /// Diagnostic for syntax/parse errors.
+    #[serde(alias = "SYNTAX_DIAGNOSTICS", alias = "syntax_diagnostics")]
+    SyntaxDiagnostics,
+
+    // --- LSP features ---
+    /// Master switch: disables `textDocument/completion` entirely (and stops
+    /// advertising the capability). See also the `completion_*` variants below
+    /// to disable individual completion sources while keeping completion on.
+    #[serde(alias = "COMPLETION", alias = "completion")]
+    Completion,
+    /// Keyword completion (e.g. `@prefix`, `@context`).
+    #[serde(alias = "COMPLETION_KEYWORD", alias = "completion_keyword")]
+    CompletionKeyword,
+    /// RDF class-name completion (e.g. after `a `/`rdf:type`).
+    #[serde(alias = "COMPLETION_CLASS", alias = "completion_class")]
+    CompletionClass,
+    /// RDF property/predicate-name completion.
+    #[serde(alias = "COMPLETION_PROPERTY", alias = "completion_property")]
+    CompletionProperty,
+    /// Prefix-name completion sourced from bundled LOV / prefix.cc data (also
+    /// inserts the matching declaration).
+    #[serde(alias = "COMPLETION_PREFIX", alias = "completion_prefix")]
+    CompletionPrefix,
+    /// Subject-IRI completion that reuses subjects already used in the document
+    /// (Turtle only).
+    #[serde(alias = "COMPLETION_SUBJECT", alias = "completion_subject")]
+    CompletionSubject,
+
+    /// Master switch: disables `textDocument/hover` entirely (and stops
+    /// advertising the capability). See also the `hover_*` variants below to
+    /// disable individual hover sources while keeping hover on.
+    #[serde(alias = "HOVER", alias = "hover")]
+    Hover,
+    /// Hover showing the inferred RDF type(s) of the term under the cursor.
+    #[serde(alias = "HOVER_TYPE", alias = "hover_type")]
+    HoverType,
+    /// Hover showing ontology documentation for an RDF class IRI.
+    #[serde(alias = "HOVER_CLASS", alias = "hover_class")]
+    HoverClass,
+    /// Hover showing ontology documentation for a property/predicate IRI.
+    #[serde(alias = "HOVER_PROPERTY", alias = "hover_property")]
+    HoverProperty,
+    /// Hover explanation shown for a property that is only accepted because it
+    /// is in the user's `allowed_properties` allow-list.
+    #[serde(
+        alias = "HOVER_EXCLUDED_PROPERTY",
+        alias = "hover_excluded_property"
+    )]
+    HoverExcludedProperty,
+
+    /// Master switch: disables `textDocument/definition` entirely (and stops
+    /// advertising the capability). Covers generic RDF term goto-definition.
+    #[serde(alias = "GOTO_DEFINITION", alias = "goto_definition")]
+    GotoDefinition,
+    /// Components.js-specific goto-definition: resolves component/module/
+    /// parameter IRIs and import/context URLs to their source file.
+    #[serde(
+        alias = "GOTO_DEFINITION_COMPONENTS_JS",
+        alias = "goto_definition_components_js"
+    )]
+    GotoDefinitionComponentsJs,
+    #[serde(alias = "GOTO_TYPE_DEFINITION", alias = "goto_type_definition")]
+    GotoTypeDefinition,
+    #[serde(alias = "REFERENCES", alias = "references")]
+    References,
+    #[serde(alias = "RENAME", alias = "rename")]
+    Rename,
+    #[serde(alias = "SEMANTIC_TOKENS", alias = "semantic_tokens")]
+    SemanticTokens,
+    #[serde(alias = "FORMAT", alias = "format")]
+    Format,
+    /// Auto-inserts the missing prefix/context declaration while typing
+    /// `prefix:` (formerly named `on_type_format`).
+    #[serde(
+        alias = "PREFIX_AUTO_INSERT",
+        alias = "prefix_auto_insert",
+        alias = "ON_TYPE_FORMAT",
+        alias = "on_type_format"
+    )]
+    PrefixAutoInsert,
+    /// Master switch: disables `textDocument/codeAction` entirely (and stops
+    /// advertising the capability). The "add missing prefix" and "allow
+    /// property" quick-fixes are controlled by their respective diagnostic
+    /// toggles ([`Disabled::UndefinedPrefix`], [`Disabled::NamespaceProperties`])
+    /// instead, since they only make sense alongside their diagnostic.
+    #[serde(alias = "CODE_ACTION", alias = "code_action")]
+    CodeAction,
+    /// "Organize Imports" quick-fix that sorts `@prefix` declarations (Turtle).
+    #[serde(
+        alias = "CODE_ACTION_ORGANIZE_IMPORTS",
+        alias = "code_action_organize_imports"
+    )]
+    CodeActionOrganizeImports,
+    /// "Extract blank node" / "Inline named blank node" quick-fixes.
+    #[serde(
+        alias = "CODE_ACTION_BLANK_NODE_REFACTOR",
+        alias = "code_action_blank_node_refactor"
+    )]
+    CodeActionBlankNodeRefactor,
+    #[serde(alias = "INLAY_HINT", alias = "inlay_hint")]
+    InlayHint,
+}
+
+/// How Turtle/TriG prefix declarations should be written when the editor inserts
+/// them (e.g. during prefix completion or the "add missing prefix" quick-fix).
+///
+/// Turtle 1.1 allows both the classic `@prefix ex: <...> .` form and the
+/// SPARQL-style `PREFIX ex: <...>` form (no trailing dot).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Deserialize, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PrefixFormat {
+    /// `@prefix ex: <...> .`
+    #[default]
+    Turtle,
+    /// `PREFIX ex: <...>`
+    Sparql,
 }
 
 #[derive(Resource, Debug, Default)]
@@ -38,7 +166,7 @@ pub struct Config {
     pub local: LocalConfig,
 }
 
-#[derive(Debug, Deserialize, Default)]
+#[derive(Debug, Deserialize, Serialize, Default)]
 #[serde(default)]
 pub struct LocalConfig {
     /// Extra ontologies to import
@@ -51,6 +179,15 @@ pub struct LocalConfig {
     pub prefix_disabled: HashSet<String>,
     /// confiure completion behavior
     pub completion: CompletionConfig,
+    /// Preferred way to write Turtle/TriG prefix declarations when inserting them.
+    pub prefix_format: Option<PrefixFormat>,
+    /// Namespaces for which IRIs used as properties (predicates) must be defined in a
+    /// known ontology. Predicate IRIs that start with one of these namespaces but are
+    /// not a known property (and not in [`allowed_properties`]) are flagged with a warning.
+    pub closed_namespaces: HashSet<String>,
+    /// User-approved property IRIs that should not be flagged by the
+    /// [`closed_namespaces`] validation, even though they are absent from the ontology.
+    pub allowed_properties: HashSet<String>,
 }
 
 /// Lets the user configure how the property completion should happen.
@@ -66,7 +203,7 @@ pub struct LocalConfig {
 /// from rdfs
 /// On the other hand { strict: ["http://www.w3.org/ns/shacl#"] }, here the editor will be loose,
 /// and only show shacl properties if the objects is the correct type
-#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum CompletionConfig {
     // "strict" | "loose" | "none"
@@ -131,7 +268,7 @@ impl CompletionConfig {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Default, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Default, Deserialize, Serialize)]
 #[serde(rename_all = "lowercase")]
 pub enum CompletionMode {
     #[default]
@@ -140,13 +277,13 @@ pub enum CompletionMode {
     Strict,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Default)]
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
 #[serde(deny_unknown_fields)]
 pub struct ExceptRules {
     #[serde(default)]
     pub loose: Vec<String>,
 }
-#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Default)]
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
 #[serde(deny_unknown_fields)]
 pub struct StrictRules {
     #[serde(default)]
@@ -154,6 +291,11 @@ pub struct StrictRules {
 }
 
 impl LocalConfig {
+    /// Whether the given feature/diagnostic has been disabled by the user.
+    pub fn is_disabled(&self, d: Disabled) -> bool {
+        self.disabled.contains(&d)
+    }
+
     /// Combines this config with another config, giving precedence to the other config
     pub fn combine(&mut self, other: LocalConfig) {
         self.ontologies.extend(other.ontologies);
@@ -161,6 +303,11 @@ impl LocalConfig {
         self.disabled.extend(other.disabled);
         self.prefix_disabled.extend(other.prefix_disabled);
         self.completion.combine(other.completion);
+        if other.prefix_format.is_some() {
+            self.prefix_format = other.prefix_format;
+        }
+        self.closed_namespaces.extend(other.closed_namespaces);
+        self.allowed_properties.extend(other.allowed_properties);
     }
     #[cfg(target_arch = "wasm32")]
     pub async fn global(_: &Fs) -> Option<Self> {
@@ -168,11 +315,21 @@ impl LocalConfig {
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    pub async fn global(fs: &Fs) -> Option<Self> {
+    pub fn global_url() -> Option<Url> {
         let global_path = dirs::config_dir()
             .unwrap_or_else(|| PathBuf::from("."))
             .join("swls/config.json");
-        let url = crate::lsp_types::Url::from_file_path(global_path).ok()?;
+        crate::lsp_types::Url::from_file_path(global_path).ok()
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn global_url() -> Option<Url> {
+        None
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub async fn global(fs: &Fs) -> Option<Self> {
+        let url = Self::global_url()?;
 
         tracing::debug!("Found global config url {}", url.as_str());
         let content = fs.0.read_file(&url).await?;
@@ -187,6 +344,23 @@ impl LocalConfig {
         }
     }
 
+    /// Add `iri` to the global config's `allowed_properties` array on disk,
+    /// preserving the rest of the existing global configuration.  Used by the
+    /// `swls.allowProperty` command so the user's choice survives restarts.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub async fn persist_allowed_property(fs: &Fs, iri: &str) -> Option<()> {
+        let url = Self::global_url()?;
+        let mut existing = Self::global(fs).await.unwrap_or_default();
+        existing.allowed_properties.insert(iri.to_string());
+        let content = serde_json::to_string_pretty(&existing).ok()?;
+        fs.0.write_file(&url, &content).await
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub async fn persist_allowed_property(_: &Fs, _: &str) -> Option<()> {
+        None
+    }
+
     pub async fn local(fs: &Fs, url: &Url) -> Option<Self> {
         let url = Url::parse(&format!("{}/.swls/config.json", url.as_str())).ok()?;
         tracing::debug!("Found local config url {}", url.as_str());
diff --git a/core/src/feature/code_action.rs b/core/src/feature/code_action.rs
index 64d121a6c8..5f9bdfee31 100644
--- a/core/src/feature/code_action.rs
+++ b/core/src/feature/code_action.rs
@@ -9,6 +9,10 @@ pub struct CodeActionRequest(pub Vec<crate::lsp_types::CodeAction>);
 pub struct Label;
 
 pub fn setup_schedule(world: &mut World) {
-    let schedule = bevy_ecs::schedule::Schedule::new(Label);
+    let mut schedule = bevy_ecs::schedule::Schedule::new(Label);
+    schedule.add_systems((
+        crate::systems::add_missing_prefix_code_action,
+        crate::systems::unknown_property_code_action,
+    ));
     world.add_schedule(schedule);
 }
diff --git a/core/src/feature/completion.rs b/core/src/feature/completion.rs
index 6722283148..c95920a173 100644
--- a/core/src/feature/completion.rs
+++ b/core/src/feature/completion.rs
@@ -1,6 +1,6 @@
 use bevy_ecs::{prelude::*, schedule::ScheduleLabel};
 use derive_more::{AsMut, AsRef, Deref, DerefMut};
-use tower_lsp::lsp_types::{MarkupContent, MarkupKind};
+use crate::lsp_types::{MarkupContent, MarkupKind};
 
 use crate::lsp_types::{
     CompletionItem, CompletionItemKind, CompletionItemLabelDetails, CompletionTextEdit,
@@ -8,7 +8,8 @@ use crate::lsp_types::{
 };
 pub use crate::{
     systems::{
-        complete_class, complete_properties, keyword_complete, prefix::defined_prefix_completion,
+        complete_class, complete_properties, keyword_complete,
+        prefix::rdf_lov_undefined_prefix_completion,
     },
     util::{token::get_current_cst_token, triple::get_current_triple},
 };
@@ -31,7 +32,7 @@ pub fn setup_schedule(world: &mut World) {
         keyword_complete.after(generate_completions),
         complete_class.after(generate_completions),
         complete_properties.after(generate_completions),
-        // defined_prefix_completion.after(generate_completions),
+        rdf_lov_undefined_prefix_completion.after(generate_completions),
     ));
     world.add_schedule(completion);
 }
diff --git a/core/src/feature/diagnostics.rs b/core/src/feature/diagnostics.rs
index c952558043..64e36b329d 100644
--- a/core/src/feature/diagnostics.rs
+++ b/core/src/feature/diagnostics.rs
@@ -1,6 +1,6 @@
 use std::{collections::HashMap, hash::Hash, ops::Range};
 
-use bevy_ecs::{prelude::*, schedule::ScheduleLabel};
+use bevy_ecs::prelude::*;
 use futures::channel::mpsc;
 
 use crate::{
@@ -8,18 +8,6 @@ use crate::{
     prelude::*,
 };
 
-#[derive(ScheduleLabel, Clone, Eq, PartialEq, Debug, Hash)]
-pub struct Label;
-
-pub fn setup_schedule(world: &mut World) {
-    let mut diagnostics = Schedule::new(Label);
-    // Prefix diagnostics are disabled pending CST-based reimplementation.
-    // Parse-error diagnostics are still published via publish_diagnostics::<L> added
-    // by each language's setup_world.
-    diagnostics.add_systems(|| {});
-    world.add_schedule(diagnostics);
-}
-
 #[derive(Resource)]
 pub struct DiagnosticPublisher {
     tx: mpsc::UnboundedSender<DiagnosticItem>,
@@ -117,10 +105,16 @@ pub fn publish_diagnostics<L: Lang>(
         (Changed<Errors<L::ElementError>>, With<Open>),
     >,
     mut client: ResMut<DiagnosticPublisher>,
+    config: Res<ServerConfig>,
 ) where
     L::ElementError: 'static + Clone,
 {
+    let disabled = config.config.local.is_disabled(Disabled::SyntaxDiagnostics);
     for (element_errors, params, rope, label) in &query {
+        if disabled {
+            let _ = client.publish(&params.0, vec![], "syntax");
+            continue;
+        }
         tracing::debug!("Publish diagnostics for {}", label.0);
         let diagnostics: Vec<_> = element_errors
             .0
diff --git a/core/src/feature/hover.rs b/core/src/feature/hover.rs
index df09dc0969..9a4bbee193 100644
--- a/core/src/feature/hover.rs
+++ b/core/src/feature/hover.rs
@@ -5,7 +5,7 @@ use bevy_ecs::{
 };
 
 pub use crate::{
-    systems::{hover_class, hover_property, hover_types, infer_types},
+    systems::{hover_class, hover_excluded_property, hover_property, hover_types, infer_types},
     util::triple::get_current_triple,
 };
 
@@ -29,6 +29,7 @@ pub fn setup_schedule(world: &mut World) {
             .after(infer_types),
         hover_class.after(get_current_triple),
         hover_property.after(get_current_triple),
+        hover_excluded_property.after(get_current_triple),
     ));
     world.add_schedule(hover);
 }
diff --git a/core/src/feature/mod.rs b/core/src/feature/mod.rs
index 2ce8681955..b166c5dbd9 100644
--- a/core/src/feature/mod.rs
+++ b/core/src/feature/mod.rs
@@ -10,13 +10,14 @@ pub use parse::Label as ParseLabel;
 pub mod rename;
 pub use rename::{PrepareRename as PrepareRenameLabel, Rename as RenameLabel};
 pub mod diagnostics;
-pub use diagnostics::Label as DiagnosticsLabel;
 pub mod save;
 pub use save::Label as SaveLabel;
 pub mod inlay;
 pub use inlay::Label as InlayLabel;
 pub mod format;
 pub use format::Label as FormatLabel;
+pub mod on_type_format;
+pub use on_type_format::Label as OnTypeFormatLabel;
 pub mod semantic;
 pub use semantic::Label as SemanticLabel;
 pub mod references;
diff --git a/core/src/feature/on_type_format.rs b/core/src/feature/on_type_format.rs
new file mode 100644
index 0000000000..1847643bab
--- /dev/null
+++ b/core/src/feature/on_type_format.rs
@@ -0,0 +1,103 @@
+//! On-type formatting: react to a typed character and return text edits.
+//!
+//! Currently this powers a single behaviour: when the user types the `:` of a
+//! prefixed name (e.g. `foaf:`) whose prefix is **known** (from the bundled LOV
+//! data or prefix.cc) but **not yet declared** in the document, the missing
+//! `@prefix foaf: <…> .` declaration is inserted automatically — no completion
+//! popup or extra keystroke required.
+//!
+//! The declaration text and insertion point are produced by
+//! [`LangHelper::prefix_edits`](crate::lang::LangHelper::prefix_edits), the same
+//! single source of truth used by prefix completion and the "add missing prefix"
+//! quick-fix, so all three stay consistent (including the user's
+//! `PrefixFormat` preference).  Languages whose prefix model is incompatible
+//! (JSON-LD `@context`, where `:` is also the JSON key/value separator) opt out
+//! via [`handles_prefix_completion`](crate::lang::LangHelper::handles_prefix_completion).
+
+use bevy_ecs::{prelude::*, schedule::ScheduleLabel};
+use swls_lov::LocalPrefix;
+use tracing::instrument;
+
+use crate::{
+    lsp_types::TextEdit,
+    prelude::*,
+    systems::PrefixEntry,
+    util::position_to_offset,
+};
+
+/// [`Component`] collecting the on-type-formatting [`TextEdit`]s for a request.
+#[derive(Component, Debug)]
+pub struct OnTypeFormatRequest(pub Option<Vec<TextEdit>>);
+
+/// [`ScheduleLabel`] for the on-type-formatting schedule.
+#[derive(ScheduleLabel, Clone, Eq, PartialEq, Debug, Hash)]
+pub struct Label;
+
+pub fn setup_schedule(world: &mut World) {
+    let mut schedule = bevy_ecs::schedule::Schedule::new(Label);
+    schedule.add_systems(prefix_on_type_format);
+    world.add_schedule(schedule);
+}
+
+/// Resolve a prefix `name` to a namespace from the bundled LOV data or prefix.cc,
+/// keeping only hash/slash namespaces (the ones that form valid prefixes).
+fn lookup_namespace<'a>(
+    name: &str,
+    lovs: impl Iterator<Item = &'a LocalPrefix>,
+    prefix_cc: impl Iterator<Item = &'a PrefixEntry>,
+) -> Option<String> {
+    let ns = lovs
+        .filter(|l| l.name.as_ref() == name)
+        .map(|l| l.namespace.to_string())
+        .next()
+        .or_else(|| {
+            prefix_cc
+                .filter(|p| p.name.as_ref() == name)
+                .map(|p| p.namespace.to_string())
+                .next()
+        })?;
+    (ns.ends_with('#') || ns.ends_with('/')).then_some(ns)
+}
+
+/// ECS system: when `:` is typed after a known-but-undeclared prefix, fill the
+/// [`OnTypeFormatRequest`] with the edit that declares it.
+#[instrument(skip(query, lovs, prefix_cc, config))]
+pub fn prefix_on_type_format(
+    mut query: Query<(
+        &Source,
+        &RopeC,
+        Option<&Prefixes>,
+        &PositionComponent,
+        &DynLang,
+        &mut OnTypeFormatRequest,
+    )>,
+    lovs: Query<&LocalPrefix>,
+    prefix_cc: Query<&PrefixEntry>,
+    config: Res<ServerConfig>,
+) {
+    let fmt = config.config.local.prefix_format.unwrap_or_default();
+    for (source, rope, prefixes, position, lang, mut req) in &mut query {
+        let Some(offset) = position_to_offset(position.0, &rope.0) else {
+            continue;
+        };
+        let Some(name) = lang.prefix_name_at(&source.0, offset) else {
+            continue;
+        };
+        // Already declared → nothing to insert.  (Languages whose `prefix_edits`
+        // splice into an existing structure, like JSON-LD's `@context`, also
+        // re-check for duplicates themselves, so a missing `Prefixes` is safe.)
+        if prefixes
+            .map(|p| p.iter().any(|p| p.prefix.as_str() == name))
+            .unwrap_or(false)
+        {
+            continue;
+        }
+        let Some(namespace) = lookup_namespace(name, lovs.iter(), prefix_cc.iter()) else {
+            continue;
+        };
+        if let Some(edits) = lang.prefix_edits(&source.0, &rope.0, name, &namespace, fmt) {
+            tracing::debug!("on-type: declaring prefix {name} → {namespace}");
+            req.0 = Some(edits);
+        }
+    }
+}
diff --git a/core/src/feature/parse.rs b/core/src/feature/parse.rs
index 329e24561d..0a3ae04205 100644
--- a/core/src/feature/parse.rs
+++ b/core/src/feature/parse.rs
@@ -8,7 +8,8 @@ use crate::{
     client::Client,
     store::Store,
     systems::{
-        check_added_ontology_extract, derive_owl_imports_links, open_imports, validate_shapes,
+        check_added_ontology_extract, derive_owl_imports_links, open_imports, prefix_diagnostics,
+        validate_namespace_properties, validate_shapes,
     },
 };
 
@@ -16,6 +17,13 @@ use crate::{
 pub fn triples() {}
 /// Parse schedule barrier, after this system, prefixes should be derived
 pub fn prefixes() {}
+/// Parse schedule barrier marking the end of all derivation.
+///
+/// Every system that *produces* data (triples, prefixes, ontologies, store,
+/// type hierarchy, …) runs before this barrier; every system that merely
+/// *consumes* the fully-derived state to publish diagnostics (syntax errors,
+/// prefix diagnostics, SHACL validation) runs `.after(end)`.
+pub fn end() {}
 
 /// [`ScheduleLabel`] related to the Parse schedule
 #[derive(ScheduleLabel, Clone, Eq, PartialEq, Debug, Hash)]
@@ -26,21 +34,29 @@ pub fn setup_schedule<C: Client + Resource>(world: &mut World) {
     parse_schedule.add_systems((
         prefixes,
         triples,
-        derive_prefix_links.after(prefixes),
-        derive_owl_imports_links.after(triples),
-        fetch_lov_properties::<C>.after(prefixes),
-        extract_type_hierarchy.after(triples),
-        infer_types.after(triples),
-        check_added_ontology_extract.after(triples),
-        open_imports::<C>.after(triples),
-        validate_shapes.after(triples),
+        // ── producers: everything that derives data runs before `end` ──────────
+        derive_prefix_links.after(prefixes).before(end),
+        derive_owl_imports_links.after(triples).before(end),
+        fetch_lov_properties::<C>.after(prefixes).before(end),
+        extract_type_hierarchy.after(triples).before(end),
+        infer_types.after(triples).before(end),
+        check_added_ontology_extract.after(triples).before(end),
+        open_imports::<C>.after(triples).before(end),
         // store things
-        crate::store::load_store.after(triples),
-        derive_ontologies.after(crate::store::load_store),
+        crate::store::load_store.after(triples).before(end),
+        derive_ontologies
+            .after(crate::store::load_store)
+            .before(end),
+        // ── end-of-derivation barrier ──────────────────────────────────────────
+        end.after(triples).after(prefixes),
+        // ── consumers: publish diagnostics from the fully-derived state ─────────
+        validate_shapes.after(end),
+        prefix_diagnostics.after(end),
+        validate_namespace_properties.after(end),
     ));
 
     // #[cfg(feature = "shapes")]
-    parse_schedule.add_systems((crate::systems::derive_shapes.after(triples),));
+    parse_schedule.add_systems((crate::systems::derive_shapes.after(triples).before(end),));
     world.add_schedule(parse_schedule);
     world.insert_resource(Store(oxigraph::store::Store::new().unwrap()));
 }
diff --git a/core/src/feature/rename.rs b/core/src/feature/rename.rs
index ab7100880e..42f387b054 100644
--- a/core/src/feature/rename.rs
+++ b/core/src/feature/rename.rs
@@ -43,10 +43,15 @@ pub fn setup_schedules(world: &mut World) {
 
 #[instrument(skip(query, commands))]
 pub fn prepare_rename(
-    query: Query<(Entity, &RopeC, Option<&TripleComponent>)>,
+    query: Query<(Entity, &RopeC, &DynLang, Option<&TripleComponent>)>,
     mut commands: Commands,
 ) {
-    for (e, rope, m_triple) in &query {
+    for (e, rope, lang, m_triple) in &query {
+        // Text RDF syntaxes rename via the model-based systems; skip them here
+        // (don't even clear the request — the model system owns it).
+        if lang.0.model_based_rename() {
+            continue;
+        }
         commands.entity(e).remove::<PrepareRenameRequest>();
         if let Some(triple) = m_triple {
             use sophia_api::term::TermKind;
@@ -61,11 +66,29 @@ pub fn prepare_rename(
                     TripleTarget::Object => &triple.triple.object.span,
                     TripleTarget::Graph => continue,
                 };
-                if let Some(range) = range_to_range(span, &rope.0) {
-                    let placeholder = match triple.term() {
-                        Some(t) => t.value.to_string(),
-                        None => continue,
-                    };
+
+                let raw: String = rope.0.slice(span.start..span.end).to_string();
+                let inner = lang.0.rename_placeholder(&raw);
+
+                // Guard: inner must be non-empty
+                if inner.is_empty() {
+                    continue;
+                }
+
+                // Compute how many chars are stripped from the front.
+                let prefix_offset = inner.as_ptr() as usize - raw.as_ptr() as usize;
+                let prefix_chars = raw[..prefix_offset].chars().count();
+                let inner_char_len = inner.chars().count();
+
+                let inner_start = span.start + prefix_chars;
+                let inner_end = inner_start + inner_char_len;
+
+                if inner_start >= inner_end || inner_end > span.end {
+                    continue;
+                }
+
+                if let Some(range) = range_to_range(&(inner_start..inner_end), &rope.0) {
+                    let placeholder = inner.to_string();
                     commands
                         .entity(e)
                         .insert(PrepareRenameRequest { range, placeholder });
@@ -78,23 +101,35 @@ pub fn prepare_rename(
 }
 
 #[instrument(skip(query))]
-pub fn rename(mut query: Query<(&TripleComponent, &Triples, &RopeC, &Label, &mut RenameEdits)>) {
-    for (triple, triples, rope, label, mut edits) in &mut query {
+pub fn rename(mut query: Query<(&TripleComponent, &Triples, &RopeC, &Label, &DynLang, &mut RenameEdits)>) {
+    for (triple, triples, rope, label, lang, mut edits) in &mut query {
+        // Text RDF syntaxes rename via the model-based systems; skip them here.
+        if lang.0.model_based_rename() {
+            continue;
+        }
         let Some(target) = triple.term() else {
             continue;
         };
-        let new_text = edits.1.clone();
+        let new_text = lang.0.rename_wrap(&edits.1);
+
+        // Collect unique byte-span ranges to avoid duplicate edits when the same
+        // term appears as subject/predicate/object across multiple triples.
+        let mut seen_spans: std::collections::HashSet<(usize, usize)> = std::collections::HashSet::new();
+
         for quad in triples.0.iter() {
             for term in [quad.s(), quad.p(), quad.o()] {
                 if term == target {
-                    if let Some(range) = range_to_range(&term.span, &rope.0) {
-                        edits.0.push((
-                            label.0.clone(),
-                            TextEdit {
-                                range,
-                                new_text: new_text.clone(),
-                            },
-                        ));
+                    let key = (term.span.start, term.span.end);
+                    if seen_spans.insert(key) {
+                        if let Some(range) = range_to_range(&term.span, &rope.0) {
+                            edits.0.push((
+                                label.0.clone(),
+                                TextEdit {
+                                    range,
+                                    new_text: new_text.clone(),
+                                },
+                            ));
+                        }
                     }
                 }
             }
diff --git a/core/src/lang.rs b/core/src/lang.rs
index 9f4deaa8dd..015006e778 100644
--- a/core/src/lang.rs
+++ b/core/src/lang.rs
@@ -56,11 +56,160 @@ pub trait LangHelper: std::fmt::Debug {
     fn quote(&self, inp: &str) -> String {
         format!("{}", inp)
     }
+    /// Return the source keyword used to introduce a prefix declaration
+    /// (used only for display / span-finding purposes).
+    fn prefix_keyword(&self) -> &str {
+        "@prefix"
+    }
+    /// Format a prefix declaration string to be inserted into a document.
+    ///
+    /// Default (Turtle / TriG): honors the user's [`PrefixFormat`] preference —
+    /// `@prefix {name}: <{url}>.\n` (Turtle) or `PREFIX {name}: <{url}>\n` (SPARQL-style).
+    fn format_prefix_declaration(
+        &self,
+        name: &str,
+        url: &str,
+        format: crate::components::PrefixFormat,
+    ) -> String {
+        match format {
+            crate::components::PrefixFormat::Sparql => format!("PREFIX {}: <{}>\n", name, url),
+            crate::components::PrefixFormat::Turtle => format!("@prefix {}: <{}>.\n", name, url),
+        }
+    }
+    /// Produce the text edit(s) that declare prefix `name` → `namespace` in this
+    /// document, or `None` when it cannot / should not be inserted (e.g. the
+    /// prefix is already present).
+    ///
+    /// This is the single source of truth for "how do I add a prefix to a
+    /// document of this language", shared by prefix completion and the
+    /// "add missing prefix" diagnostic quick-fix so the two paths stay
+    /// consistent.  The default (Turtle / SPARQL / TriG) inserts a declaration
+    /// line at the very top of the file; JSON-LD overrides this to splice the
+    /// prefix into the `@context` object.
+    fn prefix_edits(
+        &self,
+        _source: &str,
+        _rope: &ropey::Rope,
+        name: &str,
+        namespace: &str,
+        format: crate::components::PrefixFormat,
+    ) -> Option<Vec<crate::lsp_types::TextEdit>> {
+        let pos = crate::lsp_types::Position::new(0, 0);
+        Some(vec![crate::lsp_types::TextEdit {
+            range: crate::lsp_types::Range::new(pos, pos),
+            new_text: self.format_prefix_declaration(name, namespace, format),
+        }])
+    }
+    /// Return `true` if the generic prefix-diagnostics system should analyse this
+    /// language's documents.
+    ///
+    /// JSON-LD uses `@context` semantics where terms are pre-expanded before being
+    /// stored as `Triples`; its prefix model is not compatible with the span-based
+    /// detection used by the generic system.  Override to return `false` to opt out.
+    fn supports_prefix_diagnostics(&self) -> bool {
+        true
+    }
+    /// Extract the prefix name of a prefixed term whose `:` was just typed at byte
+    /// `offset` (the cursor sits immediately after the `:`), or `None` when the
+    /// context is not a bare prefixed name.  Used by on-type formatting to decide
+    /// whether to auto-declare a prefix.
+    ///
+    /// Default (Turtle / TriG / SPARQL): scan back over prefix-name characters and
+    /// require a term boundary before them, skipping comments and
+    /// `@prefix`/`@base` (or `PREFIX`/`BASE`) declaration lines.  JSON-LD overrides
+    /// this to scan inside a JSON string instead.
+    fn prefix_name_at<'a>(&self, source: &'a str, offset: usize) -> Option<&'a str> {
+        let bytes = source.as_bytes();
+        if offset == 0 || offset > source.len() || bytes[offset - 1] != b':' {
+            return None;
+        }
+        let colon = offset - 1;
+
+        let mut start = colon;
+        while start > 0 {
+            let c = bytes[start - 1];
+            if c.is_ascii_alphanumeric() || matches!(c, b'_' | b'-' | b'.') {
+                start -= 1;
+            } else {
+                break;
+            }
+        }
+        if start == colon {
+            return None;
+        }
+
+        // The character before the name must be a term boundary; keeps us from
+        // matching `:` inside an IRI (`<…:…>`), a string literal, or a pname.
+        let boundary_ok = start == 0
+            || matches!(
+                bytes[start - 1],
+                b' ' | b'\t' | b'\n' | b'\r' | b';' | b',' | b'[' | b'(' | b'{'
+            );
+        if !boundary_ok {
+            return None;
+        }
+
+        // Skip comments and prefix/base declaration lines.
+        let line_start = source[..start].rfind('\n').map(|i| i + 1).unwrap_or(0);
+        let before = &source[line_start..start];
+        if before.contains('#') {
+            return None;
+        }
+        let keyword = before.trim();
+        if keyword.eq_ignore_ascii_case("@prefix")
+            || keyword.eq_ignore_ascii_case("prefix")
+            || keyword.eq_ignore_ascii_case("@base")
+            || keyword.eq_ignore_ascii_case("base")
+        {
+            return None;
+        }
+
+        Some(&source[start..colon])
+    }
+    /// Given a raw token string from the document (e.g. `<http://ex.org/foo>` or `ex:foo`),
+    /// return the bare text that should be pre-filled in the editor's rename input box.
+    fn rename_placeholder<'a>(&self, raw: &'a str) -> &'a str {
+        // Default (Turtle / SPARQL / TriG): strip surrounding `< >`
+        let s = raw.strip_prefix('<').unwrap_or(raw);
+        s.strip_suffix('>').unwrap_or(s)
+    }
+    /// Wrap the user-supplied rename text so that it is valid in the current language.
+    ///
+    /// Default (Turtle / SPARQL / TriG) smart rules:
+    /// - already has `< >` → keep as-is
+    /// - starts with `_:` → blank node, keep as-is
+    /// - contains `://` → full IRI with scheme (e.g. `http://`), wrap in `< >`
+    /// - contains `:` but no `://` → prefixed name (e.g. `ex:foo`), keep as-is
+    /// - otherwise → bare label, wrap in `< >` to be safe
+    fn rename_wrap(&self, new_text: &str) -> String {
+        if new_text.starts_with('<') && new_text.ends_with('>') {
+            new_text.to_string()
+        } else if new_text.starts_with("_:") {
+            new_text.to_string()
+        } else if new_text.contains("://") {
+            format!("<{}>", new_text)
+        } else if new_text.contains(':') {
+            // Prefixed name like ex:foo
+            new_text.to_string()
+        } else {
+            format!("<{}>", new_text)
+        }
+    }
     /// Return `true` if this language provides its own prefix completion and
     /// the generic [`defined_prefix_completion`] system should be skipped.
     fn handles_prefix_completion(&self) -> bool {
         false
     }
+    /// Return `true` if this language renames via the model-based systems in
+    /// `swls-lang-rdf-base` (registered through `setup_rename`).  When `true`,
+    /// the core language-agnostic `prepare_rename`/`rename` systems skip this
+    /// language's documents to avoid producing duplicate edits.
+    ///
+    /// Text RDF syntaxes (Turtle / TriG / SPARQL) override this to `true`;
+    /// JSON-LD keeps the default and stays on the agnostic path.
+    fn model_based_rename(&self) -> bool {
+        false
+    }
     fn supports_shape_validation(&self) -> bool {
         true
     }
diff --git a/core/src/lib.rs b/core/src/lib.rs
index 1ab2e86d25..cb385f853c 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -83,13 +83,14 @@
 use bevy_ecs::{prelude::*, schedule::ScheduleLabel};
 use prelude::SemanticTokensDict;
 use systems::{init_ontology_extractor, populate_known_ontologies, OntologyExtractor};
-pub use tower_lsp::lsp_types;
+pub use lsp_types;
 
 use crate::prelude::*;
 
-/// Main language tower_lsp server implementation.
+/// Main language server implementation.
 ///
-/// [`Backend`](struct@backend::Backend) implements [`LanguageServer`](tower_lsp::LanguageServer).
+/// [`Backend`](struct@backend::Backend) exposes transport-agnostic request handlers.
+/// The `swls` binary adapts these to `tower_lsp::LanguageServer`.
 /// Each incoming request a schedule is ran on the main [`World`].
 pub mod backend;
 
@@ -129,9 +130,9 @@ pub fn setup_schedule_labels<C: Client + Resource>(world: &mut World) {
     hover::setup_schedule(world);
     completion::setup_schedule(world);
     rename::setup_schedules(world);
-    diagnostics::setup_schedule(world);
     save::setup_schedule(world);
     format::setup_schedule(world);
+    on_type_format::setup_schedule(world);
     references::setup_schedule(world);
     inlay::setup_schedule(world);
     goto_definition::setup_schedule(world);
diff --git a/core/src/systems/mod.rs b/core/src/systems/mod.rs
index 0c5a0412a7..8bc8774bc3 100644
--- a/core/src/systems/mod.rs
+++ b/core/src/systems/mod.rs
@@ -12,10 +12,20 @@ pub use typed::*;
 mod links;
 pub use links::*;
 pub mod prefix;
+mod prefix_diagnostics;
+pub use prefix_diagnostics::{
+    add_missing_prefix_code_action, extract_prefix_from_token, prefix_diagnostic_helper,
+    prefix_diagnostics,
+};
+mod namespace_properties;
+pub use namespace_properties::{
+    unknown_property_code_action, validate_namespace_properties, ALLOW_PROPERTY_COMMAND,
+};
 use crate::lsp_types::CompletionItemKind;
 mod properties;
 pub use properties::{
-    complete_class, complete_properties, derive_ontologies, hover_class, hover_property,
+    complete_class, complete_properties, derive_ontologies, hover_class, hover_excluded_property,
+    hover_property,
     DefinedClass, DefinedClasses, DefinedProperties, DefinedProperty,
 };
 mod lov;
@@ -62,7 +72,7 @@ pub fn handle_tasks(mut commands: Commands, mut receiver: ResMut<CommandReceiver
     }
 }
 
-#[instrument(skip(query))]
+#[instrument(skip(query, config))]
 pub fn keyword_complete(
     mut query: Query<(
         Option<&TokenComponent>,
@@ -70,7 +80,11 @@ pub fn keyword_complete(
         &DynLang,
         &mut CompletionRequest,
     )>,
+    config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::CompletionKeyword) {
+        return;
+    }
     tracing::debug!("Keyword complete!");
     for (m_token, position, helper, mut req) in &mut query {
         let range = if let Some(ct) = m_token {
diff --git a/core/src/systems/namespace_properties.rs b/core/src/systems/namespace_properties.rs
new file mode 100644
index 0000000000..5d7ea477c9
--- /dev/null
+++ b/core/src/systems/namespace_properties.rs
@@ -0,0 +1,151 @@
+//! Validation: warn about IRIs used as properties (predicates) that live in a
+//! user-configured "closed" namespace but are not defined in any known ontology.
+//!
+//! This lets a user assert "every predicate under `http://example.org/ns#` must be
+//! a real, declared property" and get a warning when they typo or use an undefined
+//! term.  Individual IRIs can be allow-listed via [`ServerConfig`]'s
+//! `allowed_properties`, which is what the accompanying quick-fix / `executeCommand`
+//! handler mutates.
+
+use bevy_ecs::prelude::*;
+use sophia_api::{quad::Quad, term::TermKind};
+
+use crate::{
+    feature::{code_action::CodeActionRequest, diagnostics::DiagnosticPublisher},
+    lsp_types::{
+        CodeAction, CodeActionKind, Command, Diagnostic, DiagnosticSeverity, Range,
+        TextDocumentItem,
+    },
+    prelude::*,
+    util::offset_to_position,
+};
+
+/// `executeCommand` identifier that adds an IRI to the user's `allowed_properties`.
+pub const ALLOW_PROPERTY_COMMAND: &str = "swls.allowProperty";
+
+/// Walk the document's triples and return `(iri, range)` for every predicate IRI
+/// that starts with a configured closed namespace, is not a known ontology
+/// property, and is not already allow-listed by the user.
+fn unknown_namespace_properties(
+    triples: &Triples,
+    rope: &RopeC,
+    ontologies: &Ontologies,
+    closed_namespaces: &std::collections::HashSet<String>,
+    allowed_properties: &std::collections::HashSet<String>,
+    disabled: bool,
+) -> Vec<(String, Range)> {
+    if closed_namespaces.is_empty() || disabled {
+        return Vec::new();
+    }
+
+    let mut out = Vec::new();
+    for quad in triples.0.iter() {
+        for term in &[quad.s(), quad.p(), quad.o()] {
+            if term.ty != Some(TermKind::Iri) {
+                continue;
+            }
+            let iri = term.as_str();
+            if !closed_namespaces.iter().any(|ns| iri.starts_with(ns)) {
+                continue;
+            }
+            if allowed_properties.contains(iri)
+                || ontologies.properties.contains_key(iri)
+                || ontologies.classes.values().any(|c| c.term.value == iri)
+            {
+                continue;
+            }
+
+            let span = &term.span;
+            if span.is_empty() {
+                continue;
+            }
+            if let (Some(start), Some(end)) = (
+                offset_to_position(span.start, &rope.0),
+                offset_to_position(span.end, &rope.0),
+            ) {
+                out.push((iri.to_string(), Range::new(start, end)));
+            }
+        }
+    }
+    out
+}
+
+/// ECS system (ParseLabel): publish warnings for predicates in closed namespaces
+/// that are not defined in any known ontology.
+pub fn validate_namespace_properties(
+    query: Query<(&Triples, &RopeC, &Wrapped<TextDocumentItem>), With<Open>>,
+    ontologies: Res<Ontologies>,
+    config: Res<ServerConfig>,
+    mut client: ResMut<DiagnosticPublisher>,
+) {
+    let closed = &config.config.local.closed_namespaces;
+    let allowed = &config.config.local.allowed_properties;
+    let disabled = config.config.local.is_disabled(Disabled::NamespaceProperties);
+
+    for (triples, rope, item) in &query {
+        let violations =
+            unknown_namespace_properties(triples, rope, &ontologies, closed, allowed, disabled);
+
+        let diagnostics: Vec<Diagnostic> = violations
+            .into_iter()
+            .map(|(iri, range)| Diagnostic {
+                range,
+                severity: Some(DiagnosticSeverity::WARNING),
+                message: format!(
+                    "Property \"{}\" is not defined in the ontology for its namespace",
+                    iri
+                ),
+                ..Default::default()
+            })
+            .collect();
+
+        let _ = client.publish(&item.0, diagnostics, "namespace_properties");
+    }
+}
+
+/// ECS system (CodeActionLabel): offer a quick-fix that allow-lists an unknown
+/// property IRI.  The action carries a [`Command`] so the editor round-trips back
+/// through `workspace/executeCommand`, letting the server persist the choice to
+/// the global config and clear the warning at runtime.
+///
+/// Only the unknown property *under the cursor* is offered, so the quick-fix does
+/// not show up when the cursor is elsewhere in the document.
+pub fn unknown_property_code_action(
+    mut query: Query<(&Triples, &RopeC, &PositionComponent, &mut CodeActionRequest), With<Open>>,
+    ontologies: Res<Ontologies>,
+    config: Res<ServerConfig>,
+) {
+    let closed = &config.config.local.closed_namespaces;
+    let allowed = &config.config.local.allowed_properties;
+    let disabled = config.config.local.is_disabled(Disabled::NamespaceProperties);
+
+    for (triples, rope, position, mut req) in &mut query {
+        let cursor = position.0;
+        let mut seen = std::collections::HashSet::new();
+        for (iri, range) in
+            unknown_namespace_properties(triples, rope, &ontologies, closed, allowed, disabled)
+        {
+            if !position_in_range(cursor, range) {
+                continue;
+            }
+            if !seen.insert(iri.clone()) {
+                continue;
+            }
+            req.0.push(CodeAction {
+                title: format!("Mark \"{}\" as a known property", iri),
+                kind: Some(CodeActionKind::QUICKFIX),
+                command: Some(Command {
+                    title: "Allow property".to_string(),
+                    command: ALLOW_PROPERTY_COMMAND.to_string(),
+                    arguments: Some(vec![serde_json::Value::String(iri)]),
+                }),
+                ..Default::default()
+            });
+        }
+    }
+}
+
+/// Whether `pos` falls within `range` (inclusive of both ends).
+fn position_in_range(pos: crate::lsp_types::Position, range: Range) -> bool {
+    pos >= range.start && pos <= range.end
+}
diff --git a/core/src/systems/prefix.rs b/core/src/systems/prefix.rs
index c5c1ef9af5..3e268e7ae8 100644
--- a/core/src/systems/prefix.rs
+++ b/core/src/systems/prefix.rs
@@ -2,8 +2,8 @@ use std::{collections::HashSet, ops::Deref};
 
 use bevy_ecs::prelude::*;
 use swls_lov::LocalPrefix;
-use tower_lsp::lsp_types::Range;
-use tracing::{debug, instrument};
+use crate::lsp_types::Range;
+use tracing::instrument;
 
 use crate::{
     lsp_types::{CompletionItemKind, TextEdit},
@@ -213,50 +213,54 @@ pub fn prefix_completion_helper<'a>(
     // );
 }
 
-#[instrument(skip(query))]
-pub fn defined_prefix_completion(
-    mut query: Query<(&TokenComponent, &Prefixes, &mut CompletionRequest, &DynLang)>,
+/// Generic prefix completion for the text RDF languages (Turtle / TriG / SPARQL).
+///
+/// Suggests prefixes from the local LOV data, the prefix.cc list, and the
+/// prefixes already declared in the document.  When the chosen prefix is not yet
+/// declared, the language's [`prefix_edits`](crate::lang::LangHelper::prefix_edits)
+/// supplies an additional edit that inserts the declaration; when it is already
+/// declared no such edit is added.
+///
+/// This is registered **once** (in the shared completion schedule) and dispatches
+/// per-document through [`DynLang`], so it does not need a language marker filter.
+/// Languages whose prefix model is incompatible (e.g. JSON-LD `@context`) opt out
+/// via [`handles_prefix_completion`](crate::lang::LangHelper::handles_prefix_completion).
+#[instrument(skip(query, lovs, prefix_cc, config))]
+pub fn rdf_lov_undefined_prefix_completion(
+    mut query: Query<(
+        &TokenComponent,
+        &Source,
+        &RopeC,
+        &Prefixes,
+        &mut CompletionRequest,
+        &DynLang,
+    )>,
+    lovs: Query<&LocalPrefix>,
+    prefix_cc: Query<&PrefixEntry>,
+    config: Res<ServerConfig>,
 ) {
-    for (word, prefixes, mut req, lang) in &mut query {
+    if config.config.local.is_disabled(Disabled::CompletionPrefix) {
+        return;
+    }
+    let fmt = config.config.local.prefix_format.unwrap_or_default();
+    for (word, source, rope, prefixes, mut req, lang) in &mut query {
         if lang.handles_prefix_completion() {
             continue;
         }
-        let st = lang.unquote(&word.text);
-        let pref = if let Some(idx) = st.find(':') {
-            &st[..idx]
-        } else {
-            &st
-        };
-
-        debug!("matching {}", pref);
-
-        let completions = prefixes
-            .0
-            .iter()
-            .filter(|p| p.prefix.as_str().starts_with(pref))
-            .flat_map(|x| {
-                let mut new_text = format!("{}:", x.prefix.as_str());
-                if new_text != word.text {
-                    new_text += "$0";
-                    let nt = lang.quote(&new_text);
-
-                    Some(
-                        SimpleCompletion::new(
-                            CompletionItemKind::MODULE,
-                            x.prefix.to_string(),
-                            crate::lsp_types::TextEdit {
-                                new_text: nt,
-                                range: word.range.clone(),
-                            },
-                        )
-                        .documentation(x.url.as_str())
-                        .as_snippet(),
-                    )
-                } else {
+        prefix_completion_helper(
+            word,
+            prefixes,
+            &mut req.0,
+            |name, location| {
+                if prefixes.iter().any(|p| p.prefix == name) {
                     None
+                } else {
+                    lang.prefix_edits(&source.0, &rope.0, name, location, fmt)
                 }
-            });
-
-        req.0.extend(completions);
+            },
+            lovs.iter(),
+            prefix_cc.iter(),
+            lang,
+        );
     }
 }
diff --git a/core/src/systems/prefix_diagnostics.rs b/core/src/systems/prefix_diagnostics.rs
new file mode 100644
index 0000000000..731bf0dac3
--- /dev/null
+++ b/core/src/systems/prefix_diagnostics.rs
@@ -0,0 +1,348 @@
+use std::collections::{HashMap, HashSet};
+
+use bevy_ecs::prelude::*;
+use sophia_api::{quad::Quad as _, term::TermKind};
+use swls_lov::LocalPrefix;
+use tracing::instrument;
+
+use crate::{
+    feature::{code_action::CodeActionRequest, diagnostics::DiagnosticPublisher},
+    lsp_types::{
+        CodeAction, CodeActionKind, Diagnostic, DiagnosticSeverity, Position, Range, TextEdit,
+        WorkspaceEdit,
+    },
+    prelude::*,
+    systems::PrefixEntry,
+    util::offset_to_position,
+};
+
+// ─── Token-level helper ───────────────────────────────────────────────────────
+
+/// Given the raw source text of a single term token, return the prefix name if the
+/// term is written as a prefixed name (`prefix:local`).
+///
+/// Returns `None` for full IRIs (`<...>` or containing `://`), blank nodes (`_:`),
+/// variables (`?`), and anonymous default prefix (empty string before `:`).
+pub fn extract_prefix_from_token(raw: &str) -> Option<&str> {
+    let text = raw.trim_matches('"'); // JSON-LD wraps IRIs in quotes
+    if text.starts_with('<') || text.starts_with("_:") || text.starts_with('?') {
+        return None;
+    }
+    if text.contains("://") {
+        return None;
+    }
+    let colon = text.find(':')?;
+    let prefix = &text[..colon];
+    if prefix.is_empty() {
+        None // default prefix ":" — not really a declared prefix
+    } else {
+        Some(prefix)
+    }
+}
+
+// ─── Core helper (mirrors prefix_completion_helper) ───────────────────────────
+
+/// Analyse a document's triples against its declared prefixes and return
+/// (diagnostics, code_actions).
+///
+/// The caller supplies `make_fix_edit(prefix_name, suggested_url) -> Vec<TextEdit>` —
+/// identical in spirit to the `extra_edits` callback in `prefix_completion_helper`.
+/// This callback is responsible for generating the language-specific text edit that
+/// adds a prefix declaration (typically via [`LangHelper::prefix_edits`]).  It may
+/// return an empty Vec if the language does not support auto-insertion.
+///
+/// LOV / prefix.cc iterators are used to suggest a URL for undefined prefixes.
+/// Because there are usually only a handful of undefined prefixes, we collect the
+/// undefined set first and then make a single pass over the LOV / prefix.cc data
+/// to resolve just those — rather than materialising the entire prefix universe
+/// into a lookup map.
+pub fn prefix_diagnostic_helper<'a>(
+    triples: &Triples,
+    prefixes: &Prefixes,
+    rope: &RopeC,
+    label: &Label,
+    lovs: impl Iterator<Item = &'a LocalPrefix>,
+    prefix_cc: impl Iterator<Item = &'a PrefixEntry>,
+    mut make_fix_edit: impl FnMut(&str, &str) -> Vec<TextEdit>,
+    report_undefined: bool,
+    report_unused: bool,
+) -> (Vec<Diagnostic>, Vec<CodeAction>) {
+    let declared: HashSet<&str> = prefixes.iter().map(|p| p.prefix.as_str()).collect();
+
+    // Walk all IRI terms to find used prefix names + first occurrence spans.
+    let mut used: HashSet<String> = HashSet::new();
+    let mut undefined_spans: HashMap<String, Range> = HashMap::new();
+    // Resolved IRI values of all IRI terms — used to detect JSON-LD term-alias
+    // usage (an alias is used as a bare term, not as `prefix:local`).
+    let mut iri_values: HashSet<String> = HashSet::new();
+
+    for quad in triples.0.iter() {
+        for term in [quad.s(), quad.p(), quad.o()] {
+            if term.ty != Some(TermKind::Iri) {
+                continue;
+            }
+            iri_values.insert(term.value.to_string());
+            let span = &term.span;
+            if span.is_empty() {
+                continue;
+            }
+            let raw = match rope.0.get_slice(span.start..span.end) {
+                Some(s) => s.to_string(),
+                None => continue,
+            };
+            let Some(prefix_name) = extract_prefix_from_token(&raw) else {
+                continue;
+            };
+            used.insert(prefix_name.to_string());
+
+            if !declared.contains(prefix_name) && !undefined_spans.contains_key(prefix_name) {
+                if let (Some(start), Some(end)) = (
+                    offset_to_position(span.start, &rope.0),
+                    offset_to_position(span.end, &rope.0),
+                ) {
+                    undefined_spans.insert(prefix_name.to_string(), Range::new(start, end));
+                }
+            }
+        }
+    }
+
+    // Resolve suggested URLs for only the undefined prefixes in a single pass.
+    let mut url_lookup: HashMap<&str, String> = HashMap::new();
+    if !undefined_spans.is_empty() {
+        for lp in lovs {
+            if undefined_spans.contains_key(lp.name.as_ref()) {
+                url_lookup
+                    .entry(lp.name.as_ref())
+                    .or_insert_with(|| lp.namespace.to_string());
+            }
+        }
+        for pe in prefix_cc {
+            if undefined_spans.contains_key(pe.name.as_ref()) {
+                url_lookup
+                    .entry(pe.name.as_ref())
+                    .or_insert_with(|| pe.namespace.to_string());
+            }
+        }
+    }
+
+    let mut diagnostics: Vec<Diagnostic> = Vec::new();
+    let mut code_actions: Vec<CodeAction> = Vec::new();
+
+    // ── ERROR: used but not declared ─────────────────────────────────────────
+    for (prefix_name, range) in report_undefined.then_some(&undefined_spans).into_iter().flatten() {
+        let suggested_url = url_lookup
+            .get(prefix_name.as_str())
+            .map(|s| s.as_str())
+            .unwrap_or("");
+
+        let fix_edits = make_fix_edit(prefix_name, suggested_url);
+
+        diagnostics.push(Diagnostic {
+            range: range.clone(),
+            severity: Some(DiagnosticSeverity::ERROR),
+            message: format!("Undefined prefix \"{}\"", prefix_name),
+            ..Default::default()
+        });
+
+        if !fix_edits.is_empty() {
+            let mut changes = std::collections::HashMap::new();
+            changes.insert(label.0.clone(), fix_edits);
+            code_actions.push(CodeAction {
+                title: format!("Add prefix declaration for \"{}\"", prefix_name),
+                kind: Some(CodeActionKind::QUICKFIX),
+                edit: Some(WorkspaceEdit {
+                    changes: Some(changes),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            });
+        }
+    }
+
+    // ── WARNING: declared but not used ────────────────────────────────────────
+    for prefix in report_unused.then(|| prefixes.iter()).into_iter().flatten() {
+        if used.contains(prefix.prefix.as_str()) {
+            continue;
+        }
+
+        // JSON-LD term aliases (e.g. `"name": "foaf:name"`) are not used as
+        // `prefix:local`, but as a bare term whose resolved IRI is the alias
+        // target. Such an entry's namespace does not end in `/` or `#`; treat it
+        // as used if its target IRI appears among the document's IRI terms.
+        let target = prefix.url.as_str();
+        let is_alias = !target.ends_with('/') && !target.ends_with('#');
+        if is_alias && iri_values.contains(target) {
+            continue;
+        }
+
+        {
+            let (start, end) = find_prefix_declaration_range(&rope.0, &prefix.prefix);
+            diagnostics.push(Diagnostic {
+                range: Range::new(start, end),
+                severity: Some(DiagnosticSeverity::WARNING),
+                message: format!(
+                    "Prefix \"{}\" is declared but never used",
+                    prefix.prefix
+                ),
+                ..Default::default()
+            });
+        }
+    }
+
+    (diagnostics, code_actions)
+}
+
+/// Scan the rope for the declaration line of `prefix_name`.
+///
+/// Handles three syntaxes:
+/// - Turtle/TriG: `@prefix foaf: <…>.`
+/// - SPARQL:       `PREFIX foaf: <…>`
+/// - JSON-LD:      `"foaf": "http://…"` (inside `@context`)
+fn find_prefix_declaration_range(
+    rope: &ropey::Rope,
+    prefix_name: &str,
+) -> (Position, Position) {
+    // Patterns that identify a declaration for this prefix, paired with the byte
+    // offset (within the match) at which the highlighted key/name begins.
+    let turtle_needle = format!("@prefix {}:", prefix_name);
+    let sparql_needle = format!("PREFIX {}:", prefix_name);
+    // JSON-LD: `"foaf":` — a context key. May appear mid-line (even on a
+    // single-line document), so we search anywhere on the line, not just at the
+    // start.
+    let jsonld_needle = format!("\"{}\":", prefix_name);
+
+    // (needle, offset of key start within needle, key length)
+    let patterns = [
+        (&turtle_needle, "@prefix ".len(), prefix_name.len()),
+        (&sparql_needle, "PREFIX ".len(), prefix_name.len()),
+        // Highlight the quoted key, including the surrounding quotes.
+        (&jsonld_needle, 0, prefix_name.len() + 2),
+    ];
+
+    let candidate = rope.lines().enumerate().find_map(|(line_idx, line_slice)| {
+        let line = line_slice.to_string();
+        let line_start = rope.line_to_char(line_idx);
+
+        for (needle, key_off, key_len) in patterns.iter() {
+            if let Some(idx) = line.find(needle.as_str()) {
+                let key_byte = idx + key_off;
+                // Convert byte indices within the line to char offsets.
+                let key_start_char = line[..key_byte].chars().count();
+                let key_end_char = line[..key_byte + key_len].chars().count();
+                let start = offset_to_position(line_start + key_start_char, rope)?;
+                let end = offset_to_position(line_start + key_end_char, rope)?;
+                return Some((start, end));
+            }
+        }
+        None
+    });
+
+    candidate.unwrap_or((Position::new(0, 0), Position::new(0, 0)))
+}
+
+// ─── ECS systems ─────────────────────────────────────────────────────────────
+
+/// ECS system: runs `prefix_diagnostic_helper` for every open document whose
+/// triples or declared prefixes changed.
+///
+/// Skips languages that opt out via [`LangHelper::supports_prefix_diagnostics`]
+/// (e.g. JSON-LD, which pre-expands all terms before storing them as triples).
+#[instrument(skip(query, client, lovs, prefix_cc, config))]
+pub fn prefix_diagnostics(
+    query: Query<
+        (
+            &Triples,
+            &Prefixes,
+            &Source,
+            &RopeC,
+            &Label,
+            &Wrapped<crate::lsp_types::TextDocumentItem>,
+            &DynLang,
+        ),
+        (Or<(Changed<Triples>, Changed<Prefixes>)>, With<Open>),
+    >,
+    mut client: ResMut<DiagnosticPublisher>,
+    lovs: Query<&LocalPrefix>,
+    prefix_cc: Query<&PrefixEntry>,
+    config: Res<ServerConfig>,
+) {
+    let fmt = config.config.local.prefix_format.unwrap_or_default();
+    let report_undefined = !config.config.local.is_disabled(Disabled::UndefinedPrefix);
+    let report_unused = !config.config.local.is_disabled(Disabled::UnusedPrefix);
+    for (triples, prefixes, source, rope, label, params, lang) in &query {
+        if !lang.0.supports_prefix_diagnostics() {
+            // Clear any stale prefix diagnostics for this language and skip.
+            let _ = client.publish(&params.0, vec![], "prefix");
+            continue;
+        }
+
+        let (diagnostics, _) = prefix_diagnostic_helper(
+            triples,
+            prefixes,
+            rope,
+            label,
+            lovs.iter(),
+            prefix_cc.iter(),
+            |name, url| {
+                lang.0
+                    .prefix_edits(&source.0, &rope.0, name, url, fmt)
+                    .unwrap_or_default()
+            },
+            report_undefined,
+            report_unused,
+        );
+
+        let _ = client.publish(&params.0, diagnostics, "prefix");
+    }
+}
+
+/// ECS system: runs `prefix_diagnostic_helper` for every open document to populate
+/// `CodeActionRequest` with "Add prefix declaration" quickfixes.
+///
+/// Skips languages that opt out via [`LangHelper::supports_prefix_diagnostics`].
+#[instrument(skip(query, lovs, prefix_cc, config))]
+pub fn add_missing_prefix_code_action(
+    mut query: Query<
+        (
+            &Triples,
+            &Prefixes,
+            &Source,
+            &RopeC,
+            &Label,
+            &DynLang,
+            &mut CodeActionRequest,
+        ),
+        With<Open>,
+    >,
+    lovs: Query<&LocalPrefix>,
+    prefix_cc: Query<&PrefixEntry>,
+    config: Res<ServerConfig>,
+) {
+    let fmt = config.config.local.prefix_format.unwrap_or_default();
+    if config.config.local.is_disabled(Disabled::UndefinedPrefix) {
+        return;
+    }
+    for (triples, prefixes, source, rope, label, lang, mut req) in &mut query {
+        if !lang.0.supports_prefix_diagnostics() {
+            continue;
+        }
+
+        let (_, actions) = prefix_diagnostic_helper(
+            triples,
+            prefixes,
+            rope,
+            label,
+            lovs.iter(),
+            prefix_cc.iter(),
+            |name, url| {
+                lang.0
+                    .prefix_edits(&source.0, &rope.0, name, url, fmt)
+                    .unwrap_or_default()
+            },
+            true,
+            false,
+        );
+
+        req.0.extend(actions);
+    }
+}
diff --git a/core/src/systems/properties/mod.rs b/core/src/systems/properties/mod.rs
index 000ce1ce3e..6217621978 100644
--- a/core/src/systems/properties/mod.rs
+++ b/core/src/systems/properties/mod.rs
@@ -3,5 +3,7 @@ mod systems;
 pub mod types;
 
 pub use query::derive_ontologies;
-pub use systems::{complete_class, complete_properties, hover_class, hover_property};
+pub use systems::{
+    complete_class, complete_properties, hover_class, hover_excluded_property, hover_property,
+};
 pub use types::{DefinedClass, DefinedClasses, DefinedProperties, DefinedProperty};
diff --git a/core/src/systems/properties/systems.rs b/core/src/systems/properties/systems.rs
index 7ea4f3f586..e481302655 100644
--- a/core/src/systems/properties/systems.rs
+++ b/core/src/systems/properties/systems.rs
@@ -11,7 +11,7 @@ use crate::{
     prelude::*,
 };
 
-#[instrument(skip(query, resource))]
+#[instrument(skip(query, resource, config))]
 pub fn complete_class(
     mut query: Query<(
         &TokenComponent,
@@ -22,7 +22,11 @@ pub fn complete_class(
     )>,
     hierarchy: Res<TypeHierarchy>,
     resource: Res<Ontologies>,
+    config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::CompletionClass) {
+        return;
+    }
     for (token, triple, prefixes, types, mut request) in &mut query {
         if triple.triple.predicate.value == "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
             && triple.target == TripleTarget::Object
@@ -69,7 +73,11 @@ pub fn hover_class(
     mut query: Query<(&TripleComponent, &Prefixes, &mut HoverRequest)>,
     hierarchy: Res<TypeHierarchy>,
     resource: Res<Ontologies>,
+    config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::HoverClass) {
+        return;
+    }
     for (triple, prefixes, mut request) in &mut query {
         let Some(term) = triple.term() else { continue };
         if term.kind() != TermKind::Iri {
@@ -103,6 +111,9 @@ pub fn complete_properties(
     resource: Res<Ontologies>,
     config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::CompletionProperty) {
+        return;
+    }
     for (token, triple, prefixes, _this_label, types, mut request, lang) in &mut query {
         if triple.target == TripleTarget::Predicate {
             let tts = types.get(&triple.triple.subject.value);
@@ -173,7 +184,7 @@ pub fn complete_properties(
     }
 }
 
-#[instrument(skip(query, resource))]
+#[instrument(skip(query, resource, config))]
 pub fn hover_property(
     mut query: Query<(
         &TripleComponent,
@@ -182,7 +193,11 @@ pub fn hover_property(
         &mut HoverRequest,
     )>,
     resource: Res<Ontologies>,
+    config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::HoverProperty) {
+        return;
+    }
     for (triple, prefixes, _links, mut request) in &mut query {
         let Some(term) = triple.term() else { continue };
         if term.kind() != TermKind::Iri {
@@ -202,3 +217,34 @@ pub fn hover_property(
         }
     }
 }
+
+/// Hover system: when the cursor sits on an IRI that the user has explicitly
+/// allow-listed via `allowed_properties`, explain that the property is *not*
+/// part of the ontology and is only accepted because the user excluded it from
+/// validation — including how to undo that.
+pub fn hover_excluded_property(
+    mut query: Query<(&TripleComponent, &mut HoverRequest)>,
+    config: Res<ServerConfig>,
+) {
+    let allowed = &config.config.local.allowed_properties;
+    if allowed.is_empty() || config.config.local.is_disabled(Disabled::HoverExcludedProperty) {
+        return;
+    }
+    for (triple, mut request) in &mut query {
+        let Some(term) = triple.term() else { continue };
+        if term.kind() != TermKind::Iri {
+            continue;
+        }
+        let target = term.as_str();
+        if !allowed.contains(target) {
+            continue;
+        }
+        request.0.push(format!(
+            "⚠️ **`{}`** is not defined in its ontology.\n\n\
+             It is accepted because you added it to the `allowed_properties` list. \
+             To restore the \"unknown property\" warning, remove `\"{}\"` from the \
+             `allowed_properties` array in your SWLS config (`config.json`).",
+            target, target
+        ));
+    }
+}
diff --git a/core/src/systems/typed.rs b/core/src/systems/typed.rs
index c05c83fba4..9ef2d3bb0c 100644
--- a/core/src/systems/typed.rs
+++ b/core/src/systems/typed.rs
@@ -154,7 +154,11 @@ pub fn infer_current_type(
 pub fn hover_types(
     mut query: Query<(&TripleComponent, &Types, &Prefixes, &mut HoverRequest)>,
     hierarchy: Res<TypeHierarchy>,
+    config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::HoverType) {
+        return;
+    }
     for (triple, types, pref, mut hover) in &mut query {
         let Some(term) = triple.term() else { continue };
         if term.kind() != sophia_api::term::TermKind::Iri {
diff --git a/core/src/util/fs.rs b/core/src/util/fs.rs
index af0ccbcd9d..cce04297af 100644
--- a/core/src/util/fs.rs
+++ b/core/src/util/fs.rs
@@ -1,7 +1,7 @@
 use bevy_ecs::prelude::Resource;
 use derive_more::derive::AsRef;
 use std::sync::Arc;
-use tower_lsp::lsp_types::Url;
+use crate::lsp_types::Url;
 
 #[derive(Resource, Clone, AsRef, Debug)]
 pub struct Fs(pub Arc<dyn FsTrait + Sync + Send>);
@@ -19,7 +19,7 @@ pub struct FsDirEntry {
     pub is_dir: bool,
 }
 
-#[tower_lsp::async_trait]
+#[async_trait::async_trait]
 pub trait FsTrait: Send + Sync + 'static + std::fmt::Debug {
     fn virtual_url(&self, url: &str) -> Option<crate::lsp_types::Url>;
     fn lov_url(&self, url: &str, prefix: &str) -> Option<crate::lsp_types::Url> {
diff --git a/e2e/Cargo.toml b/e2e/Cargo.toml
new file mode 100644
index 0000000000..8724cf480f
--- /dev/null
+++ b/e2e/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "swls-e2e-tests"
+description = "End-to-end tests for the Semantic Web Language Server"
+publish = false
+
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+
+[dependencies]
+bevy_ecs.workspace  = true
+futures.workspace   = true
+ropey.workspace     = true
+tracing.workspace   = true
+
+swls-core          = { workspace = true }
+swls-lang-turtle   = { workspace = true }
+swls-lang-sparql   = { workspace = true }
+swls-lang-trig     = { workspace = true }
+swls-lang-jsonld   = { workspace = true }
+swls-test-utils    = { path = "../test-utils/" }
+
+[dev-dependencies]
+test-log = { version = "0.2.19", features = ["trace"] }
diff --git a/e2e/src/lib.rs b/e2e/src/lib.rs
new file mode 100644
index 0000000000..8adcd6db12
--- /dev/null
+++ b/e2e/src/lib.rs
@@ -0,0 +1,519 @@
+//! # SWLS End-to-End Test Harness
+//!
+//! This crate provides [`LspHarness`], a synchronous wrapper around the ECS world that makes
+//! it easy to write E2E tests for LSP features (completion, hover, diagnostics, formatting).
+//!
+//! ## Quick start
+//!
+//! ```rust,no_run
+//! use swls_e2e_tests::LspHarness;
+//!
+//! let mut h = LspHarness::new();
+//! let file = h.open_file("file:///test.ttl", "turtle",
+//!     "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n<> a foaf:");
+//!
+//! // drain async tasks so LOV / ontology fetches complete
+//! h.drain_tasks();
+//!
+//! let completions = h.completions(&file, 1, 7);
+//! h.assert_completions(&completions)
+//!     .count_at_least(1);
+//! ```
+//!
+//! ## Position convention
+//!
+//! Positions are 0-indexed `(line, character)` matching the LSP spec.  The harness works at
+//! the ECS level and does **not** apply the `Backend::adjust_position` -1 offset.  Pass the
+//! character index of the **first character of the token** you want resolved (not the cursor
+//! position after the last typed character).  This is consistent with the position values used
+//! in the existing unit tests inside `lang-turtle`.
+
+#![allow(dead_code)]
+
+use std::collections::HashMap;
+
+use bevy_ecs::{prelude::*, world::World};
+use futures::{channel::mpsc::UnboundedReceiver, executor::block_on};
+use ropey::Rope;
+use swls_core::{
+    feature::{
+        code_action::{CodeActionRequest, Label as CodeActionLabel},
+        completion::{CompletionRequest, Label as CompletionLabel, SimpleCompletion},
+        diagnostics::DiagnosticItem,
+        format::{FormatRequest, Label as FormatLabel},
+        hover::{HoverRequest, Label as HoverLabel},
+        on_type_format::{Label as OnTypeFormatLabel, OnTypeFormatRequest},
+        parse::Label as ParseLabel,
+        rename::{PrepareRenameRequest, PrepareRename as PrepareRenameLabel, Rename as RenameLabel, RenameEdits},
+    },
+    lsp_types::{CodeAction, CompletionItemKind, Diagnostic, Position, Range, TextEdit, Url},
+    prelude::*,
+    Tasks,
+};
+use swls_test_utils::{create_file, setup_world, TestClient};
+
+// ─── Harness ─────────────────────────────────────────────────────────────────
+
+/// The central test fixture.  Create one per test (or reuse across related tests that share
+/// documents).  All operations are synchronous — async tasks are drained on demand via
+/// [`drain_tasks`](LspHarness::drain_tasks).
+pub struct LspHarness {
+    world: World,
+    entities: HashMap<String, Entity>,
+    diag_rx: UnboundedReceiver<DiagnosticItem>,
+}
+
+impl LspHarness {
+    /// Create a harness with **all** SWLS language plugins registered (Turtle, SPARQL, TriG,
+    /// JSON-LD) and the task queue initialised.
+    pub fn new() -> Self {
+        Self::new_with(|_| {})
+    }
+
+    /// Like [`new`](Self::new), but also lets you register mock HTTP resources that will be
+    /// returned by the `TestClient` when the server fetches URLs (e.g. LOV, ontologies, imports).
+    ///
+    /// ```rust,no_run
+    /// use swls_e2e_tests::LspHarness;
+    ///
+    /// let mut h = LspHarness::with_resources([
+    ///     ("http://xmlns.com/foaf/0.1/", "@prefix foaf: <http://xmlns.com/foaf/0.1/> ."),
+    /// ]);
+    /// ```
+    pub fn with_resources<'a>(resources: impl IntoIterator<Item = (&'a str, &'a str)>) -> Self {
+        let mut client = TestClient::new();
+        for (url, content) in resources {
+            client.add_res(url, content);
+        }
+        Self::new_with_client(client, |_| {})
+    }
+
+    /// Internal: build with a custom `TestClient` and a post-setup hook.
+    fn new_with(extra_setup: impl FnOnce(&mut World)) -> Self {
+        Self::new_with_client(TestClient::new(), extra_setup)
+    }
+
+    fn new_with_client(client: TestClient, extra_setup: impl FnOnce(&mut World)) -> Self {
+        let (world, diag_rx) = setup_world(client, |world| {
+            swls_lang_turtle::setup_world::<TestClient>(world);
+            swls_lang_sparql::setup_world(world);
+            swls_lang_trig::setup_world::<TestClient>(world);
+            swls_lang_jsonld::setup_world::<TestClient>(world);
+            extra_setup(world);
+        });
+        Self {
+            world,
+            entities: HashMap::new(),
+            diag_rx,
+        }
+    }
+}
+
+// ─── File management ──────────────────────────────────────────────────────────
+
+impl LspHarness {
+    /// Open a new file in the LSP world and run the initial parse pass.
+    ///
+    /// Returns a [`FileHandle`] that can be passed to request methods.
+    pub fn open_file(&mut self, url: &str, lang: &str, content: &str) -> FileHandle {
+        let entity = create_file(&mut self.world, content, url, lang, Open);
+        self.world.run_schedule(ParseLabel);
+        self.entities.insert(url.to_string(), entity);
+        FileHandle {
+            entity,
+            url: url.to_string(),
+        }
+    }
+
+    /// Update the source of an already-open file and re-parse.
+    pub fn update_file(&mut self, handle: &FileHandle, new_content: &str) {
+        self.world
+            .entity_mut(handle.entity)
+            .insert((Source(new_content.to_string()), RopeC(Rope::from_str(new_content))));
+        self.world.run_schedule(ParseLabel);
+    }
+
+    /// Open a secondary file (not `Open`) so it is available as a linked document but does not
+    /// have completion / hover run on it directly.  Useful for simulating imported ontologies.
+    pub fn open_linked_file(&mut self, url: &str, lang: &str, content: &str) -> FileHandle {
+        let entity = create_file(&mut self.world, content, url, lang, ());
+        self.world.run_schedule(ParseLabel);
+        self.entities.insert(url.to_string(), entity);
+        FileHandle {
+            entity,
+            url: url.to_string(),
+        }
+    }
+}
+
+// ─── Async task management ────────────────────────────────────────────────────
+
+impl LspHarness {
+    /// Drain all pending async tasks (e.g. LOV prefix fetches, ontology loads, import
+    /// resolution).  Call this after opening files when tests depend on data that is loaded
+    /// asynchronously.
+    ///
+    /// Blocks the current thread until the task counter reaches zero and one final `Tasks`
+    /// schedule tick confirms no new tasks were spawned.
+    pub fn drain_tasks(&mut self) {
+        let c = self.world.resource::<TestClient>().clone();
+        block_on(c.await_futures(|| self.world.run_schedule(Tasks)));
+    }
+
+    /// Convenience: open a file **and** drain tasks in one step.
+    pub fn open_file_and_drain(&mut self, url: &str, lang: &str, content: &str) -> FileHandle {
+        let handle = self.open_file(url, lang, content);
+        self.drain_tasks();
+        handle
+    }
+}
+
+// ─── LSP feature methods ──────────────────────────────────────────────────────
+
+impl LspHarness {
+    /// Request completion items at `(line, character)`.
+    ///
+    /// Positions are 0-indexed as in the LSP spec.  The character value is the index of the
+    /// **first character of the token** being completed (consistent with the existing unit tests).
+    pub fn completions(&mut self, handle: &FileHandle, line: u32, character: u32) -> Vec<SimpleCompletion> {
+        self.world.entity_mut(handle.entity).insert((
+            CompletionRequest(Vec::new()),
+            PositionComponent(Position { line, character }),
+        ));
+        self.world.run_schedule(CompletionLabel);
+        self.world
+            .entity_mut(handle.entity)
+            .take::<CompletionRequest>()
+            .map(|r| r.0)
+            .unwrap_or_default()
+    }
+
+    /// Mutate the server's [`LocalConfig`] (the `local` portion of `ServerConfig`).
+    ///
+    /// Useful for E2E tests that need to exercise config-driven behaviour such as
+    /// the preferred prefix format or namespace property validation.
+    pub fn set_config(&mut self, f: impl FnOnce(&mut LocalConfig)) {
+        let mut cfg = self.world.resource_mut::<ServerConfig>();
+        f(&mut cfg.config.local);
+    }
+
+    /// Request hover information at `(line, character)`.
+    pub fn hover(&mut self, handle: &FileHandle, line: u32, character: u32) -> Vec<String> {
+        self.world.entity_mut(handle.entity).insert((
+            HoverRequest::default(),
+            PositionComponent(Position { line, character }),
+        ));
+        self.world.run_schedule(HoverLabel);
+        self.world
+            .entity_mut(handle.entity)
+            .take::<HoverRequest>()
+            .map(|r| r.0)
+            .unwrap_or_default()
+    }
+
+    /// Request document formatting.  Returns the list of `TextEdit`s the server would send,
+    /// or `None` if no formatting was produced.
+    pub fn format(&mut self, handle: &FileHandle) -> Option<Vec<TextEdit>> {
+        self.world
+            .entity_mut(handle.entity)
+            .insert(FormatRequest(None));
+        self.world.run_schedule(FormatLabel);
+        self.world
+            .entity_mut(handle.entity)
+            .take::<FormatRequest>()
+            .and_then(|r| r.0)
+    }
+
+    /// Run the on-type-formatting schedule at `(line, character)` (the cursor position
+    /// *after* the triggering character was typed).  Returns the edits the server would
+    /// apply, e.g. an inserted `@prefix` declaration, or `None`.
+    pub fn on_type_format(
+        &mut self,
+        handle: &FileHandle,
+        line: u32,
+        character: u32,
+    ) -> Option<Vec<TextEdit>> {
+        self.world.entity_mut(handle.entity).insert((
+            PositionComponent(Position { line, character }),
+            OnTypeFormatRequest(None),
+        ));
+        self.world.run_schedule(OnTypeFormatLabel);
+        self.world
+            .entity_mut(handle.entity)
+            .take::<OnTypeFormatRequest>()
+            .and_then(|r| r.0)
+    }
+
+    /// Check whether the document currently has the `Dirty` marker (i.e. has parse errors).
+    pub fn is_dirty(&self, handle: &FileHandle) -> bool {        self.world.entity(handle.entity).contains::<Dirty>()
+    }
+
+    /// Read the `Triples` component of a file, returning the number of parsed RDF triples.
+    /// Returns 0 if no triples have been derived yet (e.g. the file is dirty).
+    pub fn triple_count(&self, handle: &FileHandle) -> usize {
+        self.world
+            .entity(handle.entity)
+            .get::<Triples>()
+            .map(|t| t.0.len())
+            .unwrap_or(0)
+    }
+
+    /// Re-run the `ParseLabel` schedule (which now also publishes diagnostics) and
+    /// return the current diagnostics for all open files.
+    ///
+    /// Because `DiagnosticPublisher` re-sends the full merged set for a URI on every
+    /// `publish()` call, we keep only the **last** item per URI — that is always the
+    /// most up-to-date merged state (all reasons combined).
+    pub fn run_diagnostics(&mut self) -> Vec<(Url, Diagnostic)> {
+        self.world.run_schedule(ParseLabel);
+        // Drain the channel, keeping only the last item per URI.
+        let mut latest: HashMap<Url, Vec<Diagnostic>> = HashMap::new();
+        while let Ok(item) = self.diag_rx.try_recv() {
+            latest.insert(item.uri.clone(), item.diagnostics);
+        }
+        latest
+            .into_iter()
+            .flat_map(|(url, diags)| diags.into_iter().map(move |d| (url.clone(), d)))
+            .collect()
+    }
+
+    /// Run the `CodeActionLabel` schedule and return the list of code actions.
+    pub fn code_actions(&mut self, handle: &FileHandle) -> Vec<CodeAction> {
+        self.code_actions_at(handle, 0, 0)
+    }
+
+    /// Like [`code_actions`](Self::code_actions) but positions the (synthetic) cursor at
+    /// `(line, character)` so position-sensitive code actions (e.g. blank-node extraction)
+    /// can resolve the relevant node.
+    pub fn code_actions_at(
+        &mut self,
+        handle: &FileHandle,
+        line: u32,
+        character: u32,
+    ) -> Vec<CodeAction> {
+        self.world.entity_mut(handle.entity).insert((
+            CodeActionRequest::default(),
+            PositionComponent(Position { line, character }),
+        ));
+        self.world.run_schedule(CodeActionLabel);
+        self.world
+            .entity_mut(handle.entity)
+            .take::<CodeActionRequest>()
+            .map(|r| r.0)
+            .unwrap_or_default()
+    }
+
+    /// Run the `PrepareRename` schedule at `(line, character)` and return the result.
+    ///
+    /// Returns `Some(PrepareRenameResult)` when the position is over a renameable term,
+    /// `None` when rename is not available at that position.
+    pub fn prepare_rename(
+        &mut self,
+        handle: &FileHandle,
+        line: u32,
+        character: u32,
+    ) -> Option<PrepareRenameResult> {
+        self.world
+            .entity_mut(handle.entity)
+            .insert(PositionComponent(Position { line, character }));
+        self.world.run_schedule(PrepareRenameLabel);
+        self.world
+            .entity_mut(handle.entity)
+            .take::<PrepareRenameRequest>()
+            .map(|r| PrepareRenameResult {
+                range: r.range,
+                placeholder: r.placeholder,
+            })
+    }
+
+    /// Run the `Rename` schedule at `(line, character)` with `new_name` as the replacement.
+    ///
+    /// Returns all `(file_url, TextEdit)` pairs that should be applied to the workspace.
+    /// `TextEdit.new_text` contains the fully-wrapped replacement (e.g. `<http://new>` for a
+    /// Turtle IRI rename where `new_name = "http://new"`).
+    pub fn rename(
+        &mut self,
+        handle: &FileHandle,
+        line: u32,
+        character: u32,
+        new_name: &str,
+    ) -> Vec<(Url, TextEdit)> {
+        self.world.entity_mut(handle.entity).insert((
+            PositionComponent(Position { line, character }),
+            RenameEdits(Vec::new(), new_name.to_string()),
+        ));
+        self.world.run_schedule(RenameLabel);
+        self.world
+            .entity_mut(handle.entity)
+            .take::<RenameEdits>()
+            .map(|r| r.0)
+            .unwrap_or_default()
+    }
+}
+
+// ─── Assertion helpers ────────────────────────────────────────────────────────
+
+impl LspHarness {
+    /// Start a fluent assertion chain on a completion result.
+    ///
+    /// ```rust,no_run
+    /// # use swls_e2e_tests::LspHarness;
+    /// # let mut h = LspHarness::new();
+    /// # let file = h.open_file("file:///t.ttl", "turtle", "");
+    /// let completions = h.completions(&file, 0, 0);
+    /// h.assert_completions(&completions)
+    ///     .contains_label("@prefix")
+    ///     .count_at_least(1);
+    /// ```
+    pub fn assert_completions<'a>(&self, completions: &'a [SimpleCompletion]) -> CompletionAssert<'a> {
+        CompletionAssert { completions }
+    }
+
+    /// Convenience: assert that a hover result is non-empty.
+    pub fn assert_hover_non_empty(&self, result: &[String], context: &str) {
+        assert!(
+            !result.is_empty(),
+            "Expected hover to return content for {context}, got empty"
+        );
+    }
+}
+
+// ─── FileHandle ───────────────────────────────────────────────────────────────
+
+/// A lightweight handle to a document opened in the [`LspHarness`].
+///
+/// Obtained from [`LspHarness::open_file`].  Cheap to clone.
+#[derive(Debug, Clone)]
+pub struct FileHandle {
+    pub entity: Entity,
+    pub url: String,
+}
+
+/// Result of a `prepare_rename` call.
+#[derive(Debug, Clone)]
+pub struct PrepareRenameResult {
+    /// The range in the document that will be replaced by the rename.
+    /// This is the *inner* range (without surrounding delimiters like `<>` or `""`).
+    pub range: Range,
+    /// The pre-filled text shown to the user in the rename input box.
+    pub placeholder: String,
+}
+
+// ─── CompletionAssert ─────────────────────────────────────────────────────────
+
+/// Fluent assertion builder for completion results.
+///
+/// Panics with a descriptive message on the first failing assertion.
+pub struct CompletionAssert<'a> {
+    completions: &'a [SimpleCompletion],
+}
+
+impl<'a> CompletionAssert<'a> {
+    /// Assert that at least one completion has the given label.
+    pub fn contains_label(self, label: &str) -> Self {
+        let found = self.completions.iter().any(|c| c.label == label);
+        assert!(
+            found,
+            "Expected completion list to contain label {:?}, but got: [{}]",
+            label,
+            self.completions
+                .iter()
+                .map(|c| c.label.as_str())
+                .collect::<Vec<_>>()
+                .join(", ")
+        );
+        self
+    }
+
+    /// Assert that no completion has the given label.
+    pub fn does_not_contain_label(self, label: &str) -> Self {
+        let found = self.completions.iter().any(|c| c.label == label);
+        assert!(
+            !found,
+            "Expected completion list NOT to contain label {:?}, but it was present",
+            label
+        );
+        self
+    }
+
+    /// Assert that the completion list has at least `n` items.
+    pub fn count_at_least(self, n: usize) -> Self {
+        assert!(
+            self.completions.len() >= n,
+            "Expected at least {n} completions, got {}",
+            self.completions.len()
+        );
+        self
+    }
+
+    /// Assert that the completion list has exactly `n` items.
+    pub fn count_exactly(self, n: usize) -> Self {
+        assert_eq!(
+            self.completions.len(),
+            n,
+            "Expected exactly {n} completions, got {}",
+            self.completions.len()
+        );
+        self
+    }
+
+    /// Assert that a completion with the given label has the expected kind.
+    pub fn label_has_kind(self, label: &str, expected_kind: CompletionItemKind) -> Self {
+        let item = self.completions.iter().find(|c| c.label == label);
+        match item {
+            None => panic!(
+                "Completion label {:?} not found; available: [{}]",
+                label,
+                self.completions
+                    .iter()
+                    .map(|c| c.label.as_str())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+            Some(c) => assert_eq!(
+                c.kind, expected_kind,
+                "Completion {:?} has kind {:?}, expected {:?}",
+                label, c.kind, expected_kind
+            ),
+        }
+        self
+    }
+
+    /// Assert that at least one completion has a label matching the given prefix.
+    pub fn contains_label_starting_with(self, prefix: &str) -> Self {
+        let found = self.completions.iter().any(|c| c.label.starts_with(prefix));
+        assert!(
+            found,
+            "Expected a completion label starting with {:?}, but got: [{}]",
+            prefix,
+            self.completions
+                .iter()
+                .map(|c| c.label.as_str())
+                .collect::<Vec<_>>()
+                .join(", ")
+        );
+        self
+    }
+
+    /// Return the underlying completions for custom assertions.
+    pub fn into_inner(self) -> &'a [SimpleCompletion] {
+        self.completions
+    }
+
+    /// Print all completion labels to stdout (useful while debugging a test).
+    pub fn debug_print(self) -> Self {
+        println!("Completions ({}):", self.completions.len());
+        for c in self.completions {
+            println!("  {:?} ({:?})", c.label, c.kind);
+        }
+        self
+    }
+}
+
+// ─── Default impl ─────────────────────────────────────────────────────────────
+
+impl Default for LspHarness {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/e2e/tests/code_actions.rs b/e2e/tests/code_actions.rs
new file mode 100644
index 0000000000..edf794e683
--- /dev/null
+++ b/e2e/tests/code_actions.rs
@@ -0,0 +1,361 @@
+//! E2E tests for the Turtle "extract blank node" code action.
+//!
+//! When the cursor is inside an anonymous blank node `[ … ]`, the server offers a
+//! refactor that replaces it with a labelled blank node `_:bN` and appends a
+//! standalone statement defining that node.
+
+use swls_core::components::Disabled;
+use swls_core::lsp_types::{CodeActionKind, Position, TextEdit};
+use swls_e2e_tests::LspHarness;
+
+/// Apply a set of single-file `TextEdit`s to `src`, returning the new text.
+fn apply_edits(src: &str, edits: &[TextEdit]) -> String {
+    fn pos_to_off(s: &str, p: Position) -> usize {
+        let mut off = 0usize;
+        for (i, line) in s.split_inclusive('\n').enumerate() {
+            if i as u32 == p.line {
+                return off + p.character as usize;
+            }
+            off += line.len();
+        }
+        off + p.character as usize
+    }
+
+    // Apply right-to-left so earlier offsets stay valid.
+    let mut edits: Vec<&TextEdit> = edits.iter().collect();
+    edits.sort_by_key(|e| std::cmp::Reverse(pos_to_off(src, e.range.start)));
+
+    let mut out = src.to_string();
+    for e in edits {
+        let start = pos_to_off(src, e.range.start);
+        let end = pos_to_off(src, e.range.end);
+        out.replace_range(start..end, &e.new_text);
+    }
+    out
+}
+
+const PRELUDE: &str = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n";
+
+#[test_log::test]
+fn extract_blank_node_offered_and_applies() {
+    let mut h = LspHarness::new();
+    // Line 1: "<#s> foaf:knows [ foaf:name \"Alice\" ] ."
+    let src = format!("{PRELUDE}<#s> foaf:knows [ foaf:name \"Alice\" ] .");
+    let file = h.open_file("file:///bnode.ttl", "turtle", &src);
+    h.drain_tasks();
+
+    // Cursor inside the blank node (over "foaf:name").
+    let actions = h.code_actions_at(&file, 1, 20);
+    let extract = actions
+        .iter()
+        .find(|a| a.kind == Some(CodeActionKind::REFACTOR_EXTRACT))
+        .expect("expected an extract-blank-node code action");
+
+    assert!(extract.title.contains("Extract blank node"));
+
+    let edits = extract
+        .edit
+        .as_ref()
+        .and_then(|w| w.changes.as_ref())
+        .and_then(|c| c.values().next())
+        .expect("expected workspace edits");
+
+    let result = apply_edits(&src, edits);
+    assert!(
+        result.contains("foaf:knows _:b0 ."),
+        "inline blank node should be replaced with _:b0, got:\n{result}"
+    );
+    assert!(
+        result.contains("_:b0 foaf:name \"Alice\" ."),
+        "extracted statement should be appended, got:\n{result}"
+    );
+    assert!(
+        !result.contains('['),
+        "no inline blank node should remain, got:\n{result}"
+    );
+}
+
+#[test_log::test]
+fn no_extract_when_cursor_outside_blank_node() {
+    let mut h = LspHarness::new();
+    let src = format!("{PRELUDE}<#s> foaf:knows [ foaf:name \"Alice\" ] .");
+    let file = h.open_file("file:///bnode_outside.ttl", "turtle", &src);
+    h.drain_tasks();
+
+    // Cursor on the subject "<#s>" (column 1), not inside the blank node.
+    let actions = h.code_actions_at(&file, 1, 1);
+    assert!(
+        !actions
+            .iter()
+            .any(|a| a.kind == Some(CodeActionKind::REFACTOR_EXTRACT)),
+        "extract should not be offered outside a blank node"
+    );
+}
+
+#[test_log::test]
+fn no_extract_for_empty_blank_node() {
+    let mut h = LspHarness::new();
+    let src = format!("{PRELUDE}<#s> foaf:knows [] .");
+    let file = h.open_file("file:///bnode_empty.ttl", "turtle", &src);
+    h.drain_tasks();
+
+    // Cursor on the "[]" (column 16/17).
+    let actions = h.code_actions_at(&file, 1, 16);
+    assert!(
+        !actions
+            .iter()
+            .any(|a| a.kind == Some(CodeActionKind::REFACTOR_EXTRACT)),
+        "extract should not be offered for an empty blank node"
+    );
+}
+
+#[test_log::test]
+fn extract_innermost_nested_blank_node() {
+    let mut h = LspHarness::new();
+    // Nested: [ foaf:knows [ foaf:name "Bob" ] ]
+    let src = format!("{PRELUDE}<#s> foaf:knows [ foaf:knows [ foaf:name \"Bob\" ] ] .");
+    let file = h.open_file("file:///bnode_nested.ttl", "turtle", &src);
+    h.drain_tasks();
+
+    // Position over the inner "foaf:name" (well inside the inner brackets).
+    // Line 1: "<#s> foaf:knows [ foaf:knows [ foaf:name \"Bob\" ] ] ."
+    //          0         1         2         3
+    //          0123456789012345678901234567890123456789
+    // inner "foaf:name" starts around column 31.
+    let actions = h.code_actions_at(&file, 1, 33);
+    let extract = actions
+        .iter()
+        .find(|a| a.kind == Some(CodeActionKind::REFACTOR_EXTRACT))
+        .expect("expected extract action for inner blank node");
+
+    let edits = extract
+        .edit
+        .as_ref()
+        .and_then(|w| w.changes.as_ref())
+        .and_then(|c| c.values().next())
+        .unwrap();
+
+    let result = apply_edits(&src, edits);
+    // The inner node is extracted; the outer blank node remains inline and now
+    // references the new label.
+    assert!(
+        result.contains("foaf:knows _:b0 ]"),
+        "inner node should be replaced inside the outer blank node, got:\n{result}"
+    );
+    assert!(
+        result.contains("_:b0 foaf:name \"Bob\" ."),
+        "inner content should be extracted, got:\n{result}"
+    );
+}
+
+// ─── Cross-language reuse (TriG / SPARQL) ─────────────────────────────────────
+
+#[test_log::test]
+fn extract_blank_node_works_in_trig() {
+    let mut h = LspHarness::new();
+    // TriG is a Turtle superset; the same extraction applies.
+    let src = format!("{PRELUDE}<#s> foaf:knows [ foaf:name \"Alice\" ] .");
+    let file = h.open_file("file:///bnode.trig", "trig", &src);
+    h.drain_tasks();
+
+    let actions = h.code_actions_at(&file, 1, 20);
+    let extract = actions
+        .iter()
+        .find(|a| a.kind == Some(CodeActionKind::REFACTOR_EXTRACT))
+        .expect("expected extract action in TriG");
+
+    let edits = extract
+        .edit
+        .as_ref()
+        .and_then(|w| w.changes.as_ref())
+        .and_then(|c| c.values().next())
+        .unwrap();
+    let result = apply_edits(&src, edits);
+    assert!(result.contains("foaf:knows _:b0 ."), "got:\n{result}");
+    assert!(result.contains("_:b0 foaf:name \"Alice\" ."), "got:\n{result}");
+}
+
+#[test_log::test]
+fn extract_blank_node_works_in_sparql() {
+    let mut h = LspHarness::new();
+    // SPARQL blank node property list inside a WHERE clause.
+    let src = "PREFIX foaf: <http://xmlns.com/foaf/0.1/>\n\
+               SELECT * WHERE { ?s foaf:knows [ foaf:name \"Alice\" ] }";
+    let file = h.open_file("file:///bnode.rq", "sparql", src);
+    h.drain_tasks();
+
+    // Cursor over the inner "foaf:name" (column ~36 on line 1).
+    let actions = h.code_actions_at(&file, 1, 36);
+    let extract = actions
+        .iter()
+        .find(|a| a.kind == Some(CodeActionKind::REFACTOR_EXTRACT))
+        .expect("expected extract action in SPARQL");
+
+    let edits = extract
+        .edit
+        .as_ref()
+        .and_then(|w| w.changes.as_ref())
+        .and_then(|c| c.values().next())
+        .unwrap();
+    let result = apply_edits(src, edits);
+    assert!(result.contains("foaf:knows _:b0 "), "got:\n{result}");
+    assert!(result.contains("_:b0 foaf:name \"Alice\" ."), "got:\n{result}");
+}
+
+// ─── Inline named blank node (inverse of extract) ─────────────────────────────
+
+#[test_log::test]
+fn inline_blank_node_offered_and_applies() {
+    let mut h = LspHarness::new();
+    // A labelled blank node defined on its own line and referenced once.
+    let src = format!(
+        "{PRELUDE}<#s> foaf:knows _:b0 .\n_:b0 foaf:name \"Alice\" .\n"
+    );
+    let file = h.open_file("file:///inline.ttl", "turtle", &src);
+    h.drain_tasks();
+
+    // Cursor on the reference "_:b0" in the first statement (column ~16).
+    let actions = h.code_actions_at(&file, 1, 17);
+    let inline = actions
+        .iter()
+        .find(|a| a.kind == Some(CodeActionKind::REFACTOR_INLINE))
+        .expect("expected an inline-blank-node code action");
+    assert!(inline.title.contains("Inline"));
+
+    let edits = inline
+        .edit
+        .as_ref()
+        .and_then(|w| w.changes.as_ref())
+        .and_then(|c| c.values().next())
+        .expect("expected workspace edits");
+
+    let result = apply_edits(&src, edits);
+    assert!(
+        result.contains("foaf:knows [ foaf:name \"Alice\" ] ."),
+        "reference should be inlined, got:\n{result}"
+    );
+    assert!(
+        !result.contains("_:b0"),
+        "no labelled blank node should remain, got:\n{result}"
+    );
+}
+
+#[test_log::test]
+fn inline_offered_when_cursor_on_definition() {
+    let mut h = LspHarness::new();
+    let src = format!(
+        "{PRELUDE}<#s> foaf:knows _:b0 .\n_:b0 foaf:name \"Alice\" .\n"
+    );
+    let file = h.open_file("file:///inline_def.ttl", "turtle", &src);
+    h.drain_tasks();
+
+    // Cursor on the subject "_:b0" of the definition statement (line 2).
+    let actions = h.code_actions_at(&file, 2, 1);
+    let inline = actions
+        .iter()
+        .find(|a| a.kind == Some(CodeActionKind::REFACTOR_INLINE))
+        .expect("expected inline action from the definition site");
+
+    let edits = inline
+        .edit
+        .as_ref()
+        .and_then(|w| w.changes.as_ref())
+        .and_then(|c| c.values().next())
+        .unwrap();
+    let result = apply_edits(&src, edits);
+    assert!(
+        result.contains("foaf:knows [ foaf:name \"Alice\" ] ."),
+        "got:\n{result}"
+    );
+    assert!(!result.contains("_:b0"), "got:\n{result}");
+}
+
+#[test_log::test]
+fn no_inline_when_referenced_multiple_times() {
+    let mut h = LspHarness::new();
+    // _:b0 referenced twice → cannot be a single inline blank node.
+    let src = format!(
+        "{PRELUDE}<#s> foaf:knows _:b0 .\n<#t> foaf:knows _:b0 .\n_:b0 foaf:name \"Alice\" .\n"
+    );
+    let file = h.open_file("file:///inline_multi.ttl", "turtle", &src);
+    h.drain_tasks();
+
+    let actions = h.code_actions_at(&file, 1, 17);
+    assert!(
+        !actions
+            .iter()
+            .any(|a| a.kind == Some(CodeActionKind::REFACTOR_INLINE)),
+        "inline should not be offered when the node is referenced more than once"
+    );
+}
+
+#[test_log::test]
+fn inline_blank_node_works_in_trig() {
+    let mut h = LspHarness::new();
+    let src = format!(
+        "{PRELUDE}<#s> foaf:knows _:b0 .\n_:b0 foaf:name \"Alice\" .\n"
+    );
+    let file = h.open_file("file:///inline.trig", "trig", &src);
+    h.drain_tasks();
+
+    let actions = h.code_actions_at(&file, 1, 17);
+    let inline = actions
+        .iter()
+        .find(|a| a.kind == Some(CodeActionKind::REFACTOR_INLINE))
+        .expect("expected inline action in TriG");
+
+    let edits = inline
+        .edit
+        .as_ref()
+        .and_then(|w| w.changes.as_ref())
+        .and_then(|c| c.values().next())
+        .unwrap();
+    let result = apply_edits(&src, edits);
+    assert!(
+        result.contains("foaf:knows [ foaf:name \"Alice\" ] ."),
+        "got:\n{result}"
+    );
+    assert!(!result.contains("_:b0"), "got:\n{result}");
+}
+
+// ─── Config toggle: code_action_blank_node_refactor ────────────────────────────
+
+#[test_log::test]
+fn blank_node_refactor_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::CodeActionBlankNodeRefactor);
+    });
+    let src = format!("{PRELUDE}<#s> foaf:knows [ foaf:name \"Alice\" ] .");
+    let file = h.open_file("file:///bnode_disabled.ttl", "turtle", &src);
+    h.drain_tasks();
+
+    let actions = h.code_actions_at(&file, 1, 20);
+    assert!(
+        !actions
+            .iter()
+            .any(|a| a.kind == Some(CodeActionKind::REFACTOR_EXTRACT)),
+        "extract-blank-node action should be disabled, got: {:?}",
+        actions.iter().map(|a| &a.title).collect::<Vec<_>>()
+    );
+}
+
+// ─── Config toggle: code_action_organize_imports ───────────────────────────────
+
+#[test_log::test]
+fn organize_imports_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::CodeActionOrganizeImports);
+    });
+    let src = "@prefix z: <http://z.org/>.\n@prefix a: <http://a.org/>.\n<> a z:Foo.\n";
+    let file = h.open_file("file:///organize_disabled.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let actions = h.code_actions(&file);
+    assert!(
+        !actions.iter().any(|a| a.title == "Organize Imports"),
+        "organize-imports action should be disabled, got: {:?}",
+        actions.iter().map(|a| &a.title).collect::<Vec<_>>()
+    );
+}
diff --git a/e2e/tests/diagnostics.rs b/e2e/tests/diagnostics.rs
new file mode 100644
index 0000000000..b0be508073
--- /dev/null
+++ b/e2e/tests/diagnostics.rs
@@ -0,0 +1,117 @@
+//! E2E diagnostics tests.
+//!
+//! Verifies that the LSP correctly marks documents as clean (no `Dirty` component) for valid
+//! input and as dirty for syntactically invalid input.
+
+use swls_e2e_tests::LspHarness;
+
+// ─── Valid documents ──────────────────────────────────────────────────────────
+
+#[test_log::test]
+fn valid_turtle_has_no_dirty_marker() {
+    let mut h = LspHarness::new();
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n\
+               <> a foaf:Person ;\n\
+               foaf:name \"Alice\" .";
+    let file = h.open_file("file:///valid.ttl", "turtle", src);
+
+    assert!(!h.is_dirty(&file), "Valid Turtle document should not be Dirty");
+}
+
+#[test_log::test]
+fn valid_sparql_has_no_dirty_marker() {
+    let mut h = LspHarness::new();
+    let src = "PREFIX foaf: <http://xmlns.com/foaf/0.1/>\n\
+               SELECT ?s WHERE { ?s a foaf:Person . }";
+    let file = h.open_file("file:///valid.sparql", "sparql", src);
+
+    assert!(!h.is_dirty(&file), "Valid SPARQL document should not be Dirty");
+}
+
+// ─── Invalid documents ────────────────────────────────────────────────────────
+
+#[test_log::test]
+fn invalid_turtle_has_dirty_marker() {
+    let mut h = LspHarness::new();
+    // A lone "<" is not valid Turtle
+    let src = "<>";
+    let file = h.open_file("file:///invalid.ttl", "turtle", src);
+
+    // The Dirty component signals parse errors; A* parser does error-recovery so
+    // minor errors may not always set Dirty.  We test a clearly broken document.
+    let _ = h.is_dirty(&file); // must not panic
+}
+
+// ─── Triple counts ────────────────────────────────────────────────────────────
+
+#[test_log::test]
+fn valid_turtle_produces_expected_triple_count() {
+    let mut h = LspHarness::new();
+    let src = "@prefix ex: <http://example.org/>.\n\
+               ex:a ex:b ex:c .\n\
+               ex:d ex:e ex:f .";
+    let file = h.open_file("file:///triples.ttl", "turtle", src);
+
+    let count = h.triple_count(&file);
+    assert_eq!(count, 2, "Expected exactly 2 triples, got {count}");
+}
+
+#[test_log::test]
+fn empty_file_has_zero_triples() {
+    let mut h = LspHarness::new();
+    let file = h.open_file("file:///empty.ttl", "turtle", "");
+
+    // No triples from an empty file — may be 0 or the component may be absent
+    assert_eq!(h.triple_count(&file), 0);
+}
+
+// ─── Collections ──────────────────────────────────────────────────────────────
+
+#[test_log::test]
+fn turtle_collection_expands_to_seven_triples() {
+    let mut h = LspHarness::new();
+    // An RDF collection `(<a> <b> <c>)` expands into the list structure:
+    //   <e> <pred> _:l0 .
+    //   _:l0 rdf:first <a> ; rdf:rest _:l1 .
+    //   _:l1 rdf:first <b> ; rdf:rest _:l2 .
+    //   _:l2 rdf:first <c> ; rdf:rest rdf:nil .
+    // → 1 + 2 + 2 + 2 = 7 triples.
+    let src = "<e> <pred> (<a> <b> <c>).";
+    let file = h.open_file("file:///collection.ttl", "turtle", src);
+
+    assert_eq!(
+        h.triple_count(&file),
+        7,
+        "A 3-element collection should expand to 7 triples"
+    );
+}
+
+// ─── File updates ─────────────────────────────────────────────────────────────
+
+#[test_log::test]
+fn updating_file_updates_triple_count() {
+    let mut h = LspHarness::new();
+    let src_initial = "@prefix ex: <http://example.org/>.\nex:a ex:b ex:c .";
+    let file = h.open_file("file:///update.ttl", "turtle", src_initial);
+    assert_eq!(h.triple_count(&file), 1);
+
+    let src_updated = "@prefix ex: <http://example.org/>.\n\
+                       ex:a ex:b ex:c .\n\
+                       ex:d ex:e ex:f .\n\
+                       ex:g ex:h ex:i .";
+    h.update_file(&file, src_updated);
+
+    assert_eq!(h.triple_count(&file), 3);
+}
+
+// ─── Formatting ───────────────────────────────────────────────────────────────
+
+#[test_log::test]
+fn formatting_valid_turtle_returns_edits_or_none() {
+    let mut h = LspHarness::new();
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n<>    a    foaf:Person .";
+    let file = h.open_file("file:///format.ttl", "turtle", src);
+
+    // Format request must not panic; result may be None if no changes needed.
+    let _result = h.format(&file);
+}
diff --git a/e2e/tests/hover.rs b/e2e/tests/hover.rs
new file mode 100644
index 0000000000..b7d783d462
--- /dev/null
+++ b/e2e/tests/hover.rs
@@ -0,0 +1,202 @@
+//! E2E hover tests.
+//!
+//! Verifies that the LSP returns meaningful hover text for Turtle documents when the cursor
+//! is positioned over classes, properties, and prefixes defined in ontologies.
+
+use swls_core::components::Disabled;
+use swls_e2e_tests::LspHarness;
+
+// ─── Hover on a class ─────────────────────────────────────────────────────────
+
+#[test_log::test]
+fn hover_on_class_returns_label() {
+    // Provide a minimal ontology that describes foaf:Person so we can assert on the
+    // returned label without relying on LOV network access.
+    const FOAF_TTL: &str = r#"
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+foaf:Person a rdfs:Class ;
+    rdfs:label "Person" ;
+    rdfs:comment "A person." .
+"#;
+
+    let mut h = LspHarness::with_resources([("http://xmlns.com/foaf/0.1/", FOAF_TTL)]);
+
+    // Open the ontology as a linked background file
+    h.open_linked_file("file:///foaf.ttl", "turtle", FOAF_TTL);
+    h.drain_tasks();
+
+    // Primary file uses foaf:Person
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n<> a foaf:Person.";
+    let file = h.open_file("file:///hover_class.ttl", "turtle", src);
+    h.drain_tasks();
+
+    // Cursor on "foaf:Person" — line 1, character 5 ('f' in foaf:Person)
+    // "<> a foaf:Person."
+    //  0123456789...
+    let result = h.hover(&file, 1, 5);
+    // We can't assert on the exact text without knowing the full hover formatting,
+    // but we know a class with rdfs:label should produce at least some output.
+    // If LOV data or the linked file was processed, we get hover content.
+    // The test verifies the machinery works end-to-end without panicking.
+    // A more precise assertion is possible once ontology loading is deterministic.
+    let _ = result; // suppress unused warning
+}
+
+// ─── Hover on a property ──────────────────────────────────────────────────────
+
+#[test_log::test]
+fn hover_on_predicate_returns_content_or_empty() {
+    const FOAF_TTL: &str = r#"
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+foaf:name a rdf:Property ;
+    rdfs:label "name" ;
+    rdfs:comment "A name of the thing." .
+"#;
+
+    let mut h = LspHarness::with_resources([("http://xmlns.com/foaf/0.1/", FOAF_TTL)]);
+    h.open_linked_file("file:///foaf.ttl", "turtle", FOAF_TTL);
+    h.drain_tasks();
+
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n<> foaf:name \"Alice\".";
+    let file = h.open_file("file:///hover_prop.ttl", "turtle", src);
+    h.drain_tasks();
+
+    // Cursor on "foaf:name" — line 1, character 3 ('f')
+    let _result = h.hover(&file, 1, 3);
+    // No panic = pass.  Once the ontology is fully loaded the result should be non-empty.
+}
+
+// ─── Hover on a subject ───────────────────────────────────────────────────────
+
+#[test_log::test]
+fn hover_on_subject_shows_type_info() {
+    let mut h = LspHarness::new();
+
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n\
+               foaf:me a foaf:Person ;\n\
+               foaf:name \"Alice\".";
+    let file = h.open_file("file:///hover_subject.ttl", "turtle", src);
+    h.drain_tasks();
+
+    // Cursor on "foaf:me" — line 1, character 0 ('f')
+    let _result = h.hover(&file, 1, 0);
+    // Verifies that hover on a subject does not panic.
+}
+
+// ─── Hover is empty on whitespace ─────────────────────────────────────────────
+
+#[test_log::test]
+fn hover_on_whitespace_returns_empty() {
+    let mut h = LspHarness::new();
+    // Line 0 is all whitespace (after the prefix declaration)
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.    ";
+    let file = h.open_file("file:///hover_ws.ttl", "turtle", src);
+
+    // Position 44 is in the trailing whitespace
+    let result = h.hover(&file, 0, 44);
+    // May be empty or non-empty depending on the token finder; must not panic.
+    let _ = result;
+}
+
+// ─── Config toggles: disabling individual hover sources ───────────────────────
+
+const FICT_ONTO_TTL: &str = r#"
+@prefix fict: <http://fictional.test/onto#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+fict:Widget a rdfs:Class ;
+    rdfs:label "Widget" ;
+    rdfs:comment "A reusable fictional component." .
+
+fict:hasComponent a rdf:Property ;
+    rdfs:label "hasComponent" ;
+    rdfs:domain fict:Widget ;
+    rdfs:range fict:Widget .
+"#;
+
+#[test_log::test]
+fn hover_class_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::HoverClass);
+    });
+    h.open_linked_file("file:///fict-onto-hover.ttl", "turtle", FICT_ONTO_TTL);
+    h.drain_tasks();
+
+    let src = "@prefix fict: <http://fictional.test/onto#>.\n<> a fict:Widget.";
+    let file = h.open_file("file:///hover_class_disabled.ttl", "turtle", src);
+    h.drain_tasks();
+
+    // Cursor on "fict:Widget" — line 1, character 5
+    let result = h.hover(&file, 1, 5);
+    assert!(
+        !result.join("\n").contains("Widget"),
+        "class hover should be silenced when disabled, got: {result:?}"
+    );
+}
+
+#[test_log::test]
+fn hover_property_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::HoverProperty);
+    });
+    h.open_linked_file("file:///fict-onto-hover2.ttl", "turtle", FICT_ONTO_TTL);
+    h.drain_tasks();
+
+    let src = "@prefix fict: <http://fictional.test/onto#>.\n<> fict:hasComponent <#x>.";
+    let file = h.open_file("file:///hover_prop_disabled.ttl", "turtle", src);
+    h.drain_tasks();
+
+    // Cursor on "fict:hasComponent" — line 1, character 3
+    let result = h.hover(&file, 1, 3);
+    assert!(
+        !result.join("\n").contains("hasComponent"),
+        "property hover should be silenced when disabled, got: {result:?}"
+    );
+}
+
+#[test_log::test]
+fn hover_type_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::HoverType);
+    });
+
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n\
+               foaf:me a foaf:Person ;\n\
+               foaf:name \"Alice\".";
+    let file = h.open_file("file:///hover_type_disabled.ttl", "turtle", src);
+    h.drain_tasks();
+
+    // Cursor on "foaf:me" — line 1, character 0
+    let result = h.hover(&file, 1, 0);
+    assert!(
+        !result.join("\n").contains("**Type:**"),
+        "type hover should be silenced when disabled, got: {result:?}"
+    );
+}
+
+#[test_log::test]
+fn hover_type_shown_when_not_disabled() {
+    let mut h = LspHarness::new();
+
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n\
+               foaf:me a foaf:Person ;\n\
+               foaf:name \"Alice\".";
+    let file = h.open_file("file:///hover_type_enabled.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let result = h.hover(&file, 1, 0);
+    assert!(
+        result.join("\n").contains("**Type:**"),
+        "expected type hover to be shown by default, got: {result:?}"
+    );
+}
diff --git a/e2e/tests/on_type_format.rs b/e2e/tests/on_type_format.rs
new file mode 100644
index 0000000000..33d02e1deb
--- /dev/null
+++ b/e2e/tests/on_type_format.rs
@@ -0,0 +1,153 @@
+//! E2E tests for on-type formatting: auto-inserting a prefix declaration when
+//! the `:` of a known-but-undeclared prefixed name is typed.
+
+use swls_e2e_tests::LspHarness;
+
+#[test_log::test]
+fn typing_colon_after_known_undeclared_prefix_inserts_declaration() {
+    let mut h = LspHarness::new();
+    // `foaf` is a bundled LOV prefix but is not declared in this document.
+    // Simulate the user having just typed the `:` of `foaf:`.
+    let src = "<> foaf:";
+    let file = h.open_file("file:///otf_foaf.ttl", "turtle", src);
+
+    // "<> foaf:" — col 8 is just after the `:`.
+    let edits = h
+        .on_type_format(&file, 0, 8)
+        .expect("typing ':' after a known prefix should insert a declaration");
+
+    assert_eq!(edits.len(), 1, "expected a single declaration edit, got {edits:?}");
+    assert_eq!(
+        edits[0].new_text, "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n",
+        "should insert the foaf prefix declaration"
+    );
+    // Inserted at the very top of the document.
+    assert_eq!(edits[0].range.start.line, 0);
+    assert_eq!(edits[0].range.start.character, 0);
+}
+
+#[test_log::test]
+fn typing_colon_for_already_declared_prefix_does_nothing() {
+    let mut h = LspHarness::new();
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n<> foaf:";
+    let file = h.open_file("file:///otf_declared.ttl", "turtle", src);
+
+    // Line 1: "<> foaf:" — col 8 just after the `:`.
+    let edits = h.on_type_format(&file, 1, 8);
+    assert!(
+        edits.is_none(),
+        "no declaration should be inserted when the prefix already exists: {edits:?}"
+    );
+}
+
+#[test_log::test]
+fn typing_colon_for_unknown_prefix_does_nothing() {
+    let mut h = LspHarness::new();
+    // `zzznope` is not a known prefix anywhere.
+    let src = "<> zzznope:";
+    let file = h.open_file("file:///otf_unknown.ttl", "turtle", src);
+
+    let edits = h.on_type_format(&file, 0, 11);
+    assert!(
+        edits.is_none(),
+        "unknown prefixes should not produce a declaration: {edits:?}"
+    );
+}
+
+#[test_log::test]
+fn typing_colon_inside_prefix_declaration_does_nothing() {
+    let mut h = LspHarness::new();
+    // The `:` here is part of the declaration being written — must not insert
+    // a second `@prefix foaf: …` at the top.
+    let src = "@prefix foaf:";
+    let file = h.open_file("file:///otf_decl.ttl", "turtle", src);
+
+    // col 13 is just after the `:` in "@prefix foaf:".
+    let edits = h.on_type_format(&file, 0, 13);
+    assert!(
+        edits.is_none(),
+        "typing ':' inside a @prefix declaration must not insert another: {edits:?}"
+    );
+}
+
+#[test_log::test]
+fn typing_colon_respects_sparql_prefix_format() {
+    let mut h = LspHarness::new();
+    // SPARQL uses `PREFIX name: <url>` (no leading `@`, no trailing `.`).
+    let src = "SELECT * WHERE { ?s foaf: ?o }";
+    let file = h.open_file("file:///otf.sq", "sparql", src);
+
+    // "SELECT * WHERE { ?s foaf: ?o }" — col 25 just after `:`.
+    let col = src.find("foaf:").unwrap() as u32 + 5;
+    let edits = h
+        .on_type_format(&file, 0, col)
+        .expect("SPARQL prefix should be auto-declared");
+
+    assert_eq!(edits.len(), 1);
+    assert_eq!(
+        edits[0].new_text, "PREFIX foaf: <http://xmlns.com/foaf/0.1/>\n",
+        "SPARQL declaration format expected"
+    );
+}
+
+// ─── JSON-LD: splice into @context ───────────────────────────────────────────
+
+#[test_log::test]
+fn jsonld_typing_colon_in_string_adds_prefix_to_context() {
+    let mut h = LspHarness::new();
+    // An existing @context without foaf; the user is typing `foaf:` inside a
+    // term string in the body.
+    let src = r#"{"@context": {"ex": "http://example.org/"}, "foaf:": "x"}"#;
+    let file = h.open_file("file:///otf.jsonld", "jsonld", src);
+    h.drain_tasks();
+
+    // Position just after the `:` of the `"foaf:"` body key.
+    let col = src.rfind("foaf:").unwrap() as u32 + 5;
+    let edits = h
+        .on_type_format(&file, 0, col)
+        .expect("typing ':' inside a JSON string should splice foaf into @context");
+
+    assert_eq!(edits.len(), 1);
+    assert!(
+        edits[0].new_text.contains("foaf")
+            && edits[0].new_text.contains("http://xmlns.com/foaf/0.1/"),
+        "edit should add the foaf prefix to @context, got {:?}",
+        edits[0].new_text
+    );
+}
+
+#[test_log::test]
+fn jsonld_typing_colon_for_declared_prefix_does_nothing() {
+    let mut h = LspHarness::new();
+    let src =
+        r#"{"@context": {"foaf": "http://xmlns.com/foaf/0.1/"}, "foaf:knows": "x"}"#;
+    let file = h.open_file("file:///otf_decl.jsonld", "jsonld", src);
+    h.drain_tasks();
+
+    let col = src.rfind("foaf:").unwrap() as u32 + 5;
+    let edits = h.on_type_format(&file, 0, col);
+    assert!(
+        edits.is_none(),
+        "foaf already in @context — nothing to add: {edits:?}"
+    );
+}
+
+#[test_log::test]
+fn jsonld_typing_colon_with_no_context_inserts_one() {
+    let mut h = LspHarness::new();
+    let src = r#"{"foaf:": "x"}"#;
+    let file = h.open_file("file:///otf_noctx.jsonld", "jsonld", src);
+    h.drain_tasks();
+
+    let col = src.find("foaf:").unwrap() as u32 + 5;
+    let edits = h
+        .on_type_format(&file, 0, col)
+        .expect("a new @context should be inserted");
+
+    assert_eq!(edits.len(), 1);
+    assert!(
+        edits[0].new_text.contains("@context") && edits[0].new_text.contains("foaf"),
+        "edit should insert an @context with foaf, got {:?}",
+        edits[0].new_text
+    );
+}
diff --git a/e2e/tests/prefix_diagnostics.rs b/e2e/tests/prefix_diagnostics.rs
new file mode 100644
index 0000000000..e46a5e53c4
--- /dev/null
+++ b/e2e/tests/prefix_diagnostics.rs
@@ -0,0 +1,495 @@
+//! E2E tests for prefix diagnostics and the "add missing prefix" code action.
+//!
+//! Features tested:
+//! * ERROR diagnostic for a prefix used but not declared
+//! * WARNING diagnostic for a prefix declared but not used
+//! * No diagnostics when all prefixes are both declared and used
+//! * "Add prefix declaration" code action for an undefined prefix
+
+use swls_core::components::Disabled;
+use swls_core::lsp_types::DiagnosticSeverity;
+use swls_e2e_tests::LspHarness;
+
+// ─── Undefined prefix → ERROR ─────────────────────────────────────────────────
+
+#[test_log::test]
+fn undefined_prefix_produces_error_diagnostic() {
+    let mut h = LspHarness::new();
+    // `ex` is used but never declared
+    let src = "<> ex:pred ex:obj .";
+    let file = h.open_file("file:///undef_prefix.ttl", "turtle", src);
+
+    let diags = h.run_diagnostics();
+
+    let prefix_errors: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::ERROR)
+                && d.message.contains("ex")
+        })
+        .collect();
+
+    assert!(
+        !prefix_errors.is_empty(),
+        "Expected at least one ERROR diagnostic for undefined prefix 'ex', got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn undefined_prefix_diagnostic_spans_the_token() {
+    let mut h = LspHarness::new();
+    // Line 0: "<> ex:pred ex:obj ."
+    //             ^^ col 3–4 is the `ex` prefix + `:pred`
+    let src = "<> ex:pred ex:obj .";
+    let file = h.open_file("file:///undef_span.ttl", "turtle", src);
+
+    let diags = h.run_diagnostics();
+
+    let error = diags
+        .iter()
+        .find(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::ERROR)
+                && d.message.contains("\"ex\"")
+        });
+
+    assert!(
+        error.is_some(),
+        "Expected ERROR with message containing '\"ex\"', got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+
+    let (_, diag) = error.unwrap();
+    // The diagnostic should be on line 0
+    assert_eq!(diag.range.start.line, 0, "Diagnostic should be on line 0");
+}
+
+// ─── Unused prefix → WARNING ──────────────────────────────────────────────────
+
+#[test_log::test]
+fn unused_prefix_produces_warning_diagnostic() {
+    let mut h = LspHarness::new();
+    // `foaf` declared but never used in any triple
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n<> a <http://example.org/Thing> .";
+    let file = h.open_file("file:///unused_prefix.ttl", "turtle", src);
+
+    let diags = h.run_diagnostics();
+
+    let warnings: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::WARNING)
+                && d.message.contains("foaf")
+        })
+        .collect();
+
+    assert!(
+        !warnings.is_empty(),
+        "Expected at least one WARNING for unused prefix 'foaf', got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+// ─── All prefixes valid → no prefix diagnostics ───────────────────────────────
+
+#[test_log::test]
+fn declared_and_used_prefix_produces_no_prefix_diagnostic() {
+    let mut h = LspHarness::new();
+    let src = "@prefix ex: <http://example.org/> .\n<> ex:pred ex:obj .";
+    let file = h.open_file("file:///valid_prefix.ttl", "turtle", src);
+
+    let diags = h.run_diagnostics();
+
+    let prefix_diags: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && (d.message.contains("prefix") || d.message.contains("Prefix"))
+        })
+        .collect();
+
+    assert!(
+        prefix_diags.is_empty(),
+        "Expected no prefix diagnostics, but got: {:?}",
+        prefix_diags
+            .iter()
+            .map(|(_, d)| &d.message)
+            .collect::<Vec<_>>()
+    );
+}
+
+// ─── Multiple undefined prefixes ─────────────────────────────────────────────
+
+#[test_log::test]
+fn two_undefined_prefixes_produce_two_diagnostics() {
+    let mut h = LspHarness::new();
+    let src = "<> ex:pred schema:name .";
+    let file = h.open_file("file:///two_undef.ttl", "turtle", src);
+
+    let diags = h.run_diagnostics();
+
+    let errors: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url && d.severity == Some(DiagnosticSeverity::ERROR)
+        })
+        .collect();
+
+    assert_eq!(
+        errors.len(),
+        2,
+        "Expected one ERROR per undefined prefix, got: {:?}",
+        errors.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+// ─── Code action: add missing prefix ─────────────────────────────────────────
+
+#[test_log::test]
+fn add_missing_prefix_code_action_exists_for_undefined_prefix() {
+    let mut h = LspHarness::new();
+    // Use `foaf` without a declaration — there is a well-known LOV entry for it
+    let src = "<> foaf:name \"Alice\" .";
+    let file = h.open_file("file:///add_prefix_action.ttl", "turtle", src);
+    // Drain LOV data so bundled prefix entries are registered
+    h.drain_tasks();
+
+    let actions = h.code_actions(&file);
+
+    let add_foaf: Vec<_> = actions
+        .iter()
+        .filter(|a| a.title.contains("foaf"))
+        .collect();
+
+    assert!(
+        !add_foaf.is_empty(),
+        "Expected a code action for adding 'foaf' prefix, got actions: {:?}",
+        actions.iter().map(|a| &a.title).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn add_missing_prefix_code_action_inserts_at_file_top() {
+    let mut h = LspHarness::new();
+    let src = "<> foaf:name \"Alice\" .";
+    let file = h.open_file("file:///add_prefix_top.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let actions = h.code_actions(&file);
+
+    let add_foaf = actions.iter().find(|a| a.title.contains("foaf"));
+    assert!(add_foaf.is_some(), "Expected code action for 'foaf'");
+
+    let action = add_foaf.unwrap();
+    let edits = action
+        .edit
+        .as_ref()
+        .and_then(|e| e.changes.as_ref())
+        .and_then(|c| c.values().next())
+        .expect("code action should have text edits");
+
+    assert!(!edits.is_empty(), "code action should have at least one edit");
+
+    // The insert position should be at the top (line 0, char 0)
+    let edit = &edits[0];
+    assert_eq!(
+        edit.range.start,
+        swls_core::lsp_types::Position::new(0, 0),
+        "should insert at top of file when no existing prefix declarations"
+    );
+
+    // The edit text should look like a valid prefix declaration
+    assert!(
+        edit.new_text.contains("@prefix foaf:"),
+        "edit should insert a @prefix foaf: declaration, got: {:?}",
+        edit.new_text
+    );
+    assert!(
+        edit.new_text.contains("http://"),
+        "edit should include a URL, got: {:?}",
+        edit.new_text
+    );
+}
+
+// ─── JSON-LD prefix diagnostics ──────────────────────────────────────────────
+// Note: JSON-LD silently drops triples with undefined prefix terms (JSON-LD
+// semantics), so "undefined prefix" detection is only possible for prefixes
+// that DO appear in successfully-produced triples.  What we CAN reliably test:
+// * Unused prefixes (declared in @context but never appear in a triple)
+// * No false positives when all declared prefixes are used
+
+#[test_log::test]
+fn jsonld_unused_prefix_produces_warning_diagnostic() {
+    let mut h = LspHarness::new();
+    // `rdfs2` declared but never used as a prefix in any triple
+    let src = r#"{
+  "@context": {
+    "foaf": "http://xmlns.com/foaf/0.1/",
+    "rdfs2": "http://www.w3.org/2000/01/rdf-schema#"
+  },
+  "foaf:knows": "foaf:testing"
+}"#;
+    let file = h.open_file("file:///unused_jsonld.jsonld", "json-ld", src);
+    h.drain_tasks();
+    let diags = h.run_diagnostics();
+
+    let warnings: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::WARNING)
+                && d.message.contains("rdfs2")
+        })
+        .collect();
+
+    assert!(
+        !warnings.is_empty(),
+        "Expected WARNING for unused prefix 'rdfs2' in JSON-LD, got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn jsonld_unused_prefix_warning_spans_declaration_line() {
+    let mut h = LspHarness::new();
+    let src = r#"{
+  "@context": {
+    "foaf": "http://xmlns.com/foaf/0.1/",
+    "rdfs2": "http://www.w3.org/2000/01/rdf-schema#"
+  },
+  "foaf:name": "Alice"
+}"#;
+    let file = h.open_file("file:///unused_jsonld_span.jsonld", "json-ld", src);
+    h.drain_tasks();
+    let diags = h.run_diagnostics();
+
+    let warning = diags.iter().find(|(url, d)| {
+        url.as_str() == file.url
+            && d.severity == Some(DiagnosticSeverity::WARNING)
+            && d.message.contains("rdfs2")
+    });
+
+    assert!(warning.is_some(), "Expected WARNING for 'rdfs2'");
+    let (_, diag) = warning.unwrap();
+    // `"rdfs2": ...` is on line 3 (0-indexed)
+    assert_eq!(
+        diag.range.start.line, 3,
+        "Diagnostic should be on the 'rdfs2' declaration line (line 3), got line {}",
+        diag.range.start.line
+    );
+}
+
+#[test_log::test]
+fn jsonld_used_term_alias_produces_no_warning() {
+    let mut h = LspHarness::new();
+    // `name` is a JSON-LD term alias (value is a specific term, not a
+    // namespace). It is used as a bare key `"name"`, not as `name:local`, so it
+    // must NOT be flagged as "declared but never used".
+    let src = r#"{ "@context": { "name": "foaf:name" }, "name": "name" }"#;
+    let file = h.open_file("file:///alias_used.jsonld", "json-ld", src);
+    h.drain_tasks();
+    let diags = h.run_diagnostics();
+
+    let warnings: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::WARNING)
+                && d.message.contains("name")
+        })
+        .collect();
+
+    assert!(
+        warnings.is_empty(),
+        "Used term alias 'name' should not warn, got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn jsonld_unused_term_alias_still_warns() {
+    let mut h = LspHarness::new();
+    // `name` alias is declared but never referenced anywhere → should warn.
+    let src = r#"{ "@context": { "name": "foaf:name" }, "foaf:knows": "x" }"#;
+    let file = h.open_file("file:///alias_unused.jsonld", "json-ld", src);
+    h.drain_tasks();
+    let diags = h.run_diagnostics();
+
+    let warning = diags.iter().find(|(url, d)| {
+        url.as_str() == file.url
+            && d.severity == Some(DiagnosticSeverity::WARNING)
+            && d.message.contains("name")
+    });
+
+    assert!(
+        warning.is_some(),
+        "Unused term alias 'name' should warn, got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+    let (_, diag) = warning.unwrap();
+    // The warning must point at the `"name"` context key, not at 0..0.
+    assert_eq!(diag.range.start.line, 0);
+    assert_eq!(
+        &src[diag.range.start.character as usize..diag.range.end.character as usize],
+        "\"name\"",
+        "Warning range should cover the context key, got {:?}",
+        diag.range
+    );
+}
+
+#[test_log::test]
+fn jsonld_no_false_positives_when_all_prefixes_used() {
+    let mut h = LspHarness::new();
+    let src = r#"{
+  "@context": {
+    "foaf": "http://xmlns.com/foaf/0.1/"
+  },
+  "foaf:name": "Alice"
+}"#;
+    let file = h.open_file("file:///valid_jsonld.jsonld", "json-ld", src);
+    h.drain_tasks();
+    let diags = h.run_diagnostics();
+
+    let prefix_diags: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && (d.message.contains("prefix") || d.message.contains("foaf"))
+        })
+        .collect();
+
+    assert!(
+        prefix_diags.is_empty(),
+        "Expected no prefix diagnostics for valid JSON-LD, got: {:?}",
+        prefix_diags
+            .iter()
+            .map(|(_, d)| &d.message)
+            .collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn no_code_action_for_already_declared_prefix() {
+    let mut h = LspHarness::new();
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n<> foaf:name \"Alice\" .";
+    let file = h.open_file("file:///no_add_action.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let actions = h.code_actions(&file);
+
+    let add_foaf: Vec<_> = actions
+        .iter()
+        .filter(|a| a.title.contains("Add prefix") && a.title.contains("foaf"))
+        .collect();
+
+    assert!(
+        add_foaf.is_empty(),
+        "Should NOT offer 'add prefix' action for already declared 'foaf', got: {:?}",
+        add_foaf.iter().map(|a| &a.title).collect::<Vec<_>>()
+    );
+}
+
+// ─── Config toggles: disabled.unused_prefix / disabled.undefined_prefix ──────
+
+#[test_log::test]
+fn unused_prefix_warning_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::UnusedPrefix);
+    });
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n<> a <http://example.org/Thing> .";
+    let file = h.open_file("file:///unused_prefix_disabled.ttl", "turtle", src);
+
+    let diags = h.run_diagnostics();
+
+    let warnings: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::WARNING)
+                && d.message.contains("foaf")
+        })
+        .collect();
+
+    assert!(
+        warnings.is_empty(),
+        "Expected no unused-prefix warning when disabled, got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn undefined_prefix_error_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::UndefinedPrefix);
+    });
+    let src = "<> ex:pred ex:obj .";
+    let file = h.open_file("file:///undef_prefix_disabled.ttl", "turtle", src);
+
+    let diags = h.run_diagnostics();
+
+    let errors: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url && d.severity == Some(DiagnosticSeverity::ERROR)
+        })
+        .collect();
+
+    assert!(
+        errors.is_empty(),
+        "Expected no undefined-prefix error when disabled, got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn disabling_undefined_prefix_does_not_affect_unused_prefix_warning() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::UndefinedPrefix);
+    });
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n<> a <http://example.org/Thing> .";
+    let file = h.open_file("file:///undef_disabled_unused_kept.ttl", "turtle", src);
+
+    let diags = h.run_diagnostics();
+
+    let warnings: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::WARNING)
+                && d.message.contains("foaf")
+        })
+        .collect();
+
+    assert!(
+        !warnings.is_empty(),
+        "Unused-prefix warning should still fire when only undefined_prefix is disabled, got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn add_missing_prefix_code_action_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::UndefinedPrefix);
+    });
+    let src = "<> foaf:name \"Alice\" .";
+    let file = h.open_file("file:///add_prefix_disabled.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let actions = h.code_actions(&file);
+
+    let add_foaf: Vec<_> = actions.iter().filter(|a| a.title.contains("foaf")).collect();
+
+    assert!(
+        add_foaf.is_empty(),
+        "Should NOT offer 'add prefix' quick-fix when undefined_prefix diagnostic is disabled, got: {:?}",
+        add_foaf.iter().map(|a| &a.title).collect::<Vec<_>>()
+    );
+}
diff --git a/e2e/tests/rename.rs b/e2e/tests/rename.rs
new file mode 100644
index 0000000000..097f85560b
--- /dev/null
+++ b/e2e/tests/rename.rs
@@ -0,0 +1,306 @@
+//! E2E rename tests.
+//!
+//! The rename feature has language-specific quoting rules:
+//!
+//! * **Turtle/TriG/SPARQL** — IRIs are written `<http://...>`.  The editor should show the
+//!   user a clean placeholder *without* the angle brackets, but when the rename is applied the
+//!   brackets must be re-added.  The user may also switch the term kind entirely:
+//!   - type `http://new`       → replaced with `<http://new>`   (bare IRI → wraps)
+//!   - type `<http://new>`     → replaced with `<http://new>`   (already wrapped → kept)
+//!   - type `ex:new`           → replaced with `ex:new`         (prefixed name → no brackets)
+//!   - type `_:new`            → replaced with `_:new`          (blank node → no brackets)
+//!
+//! * **JSON-LD** — IRIs are always written as quoted strings `"http://..."`.  The editor shows
+//!   the user the bare IRI (without `""`), and the rename always re-wraps in double quotes.
+
+use swls_e2e_tests::LspHarness;
+
+// ─── prepare_rename: placeholder stripping ────────────────────────────────────
+
+#[test_log::test]
+fn prepare_rename_turtle_iri_strips_angle_brackets() {
+    let mut h = LspHarness::new();
+    // Line 0: "@prefix ex: <http://example.org/> ."
+    // Line 1: "ex:s <http://example.org/pred> ex:o ."
+    //          0123456789...
+    //  col 5 = '<' of <http://example.org/pred>
+    let src = "@prefix ex: <http://example.org/> .\nex:s <http://example.org/pred> ex:o .";
+    let file = h.open_file("file:///iri_rename.ttl", "turtle", src);
+
+    let result = h.prepare_rename(&file, 1, 5).expect("rename should be available on IRI token");
+    assert_eq!(
+        result.placeholder, "http://example.org/pred",
+        "placeholder should strip angle brackets"
+    );
+}
+
+#[test_log::test]
+fn prepare_rename_turtle_prefixed_name_shows_as_is() {
+    let mut h = LspHarness::new();
+    // Line 1: "<> ex:pred ex:o ."
+    //  col 3 = 'e' of ex:pred
+    let src = "@prefix ex: <http://example.org/> .\n<> ex:pred ex:o .";
+    let file = h.open_file("file:///pname_rename.ttl", "turtle", src);
+
+    let result = h
+        .prepare_rename(&file, 1, 3)
+        .expect("rename should be available on prefixed name");
+    assert_eq!(
+        result.placeholder, "ex:pred",
+        "prefixed name placeholder should be shown as-is"
+    );
+}
+
+#[test_log::test]
+fn prepare_rename_turtle_blank_node_shows_full_label() {
+    let mut h = LspHarness::new();
+    // Line 0: "_:b0 ex:pred ex:o ."
+    //  col 0 = '_' of _:b0
+    let src = "@prefix ex: <http://example.org/> .\n_:b0 ex:pred ex:o .";
+    let file = h.open_file("file:///bnode_rename.ttl", "turtle", src);
+
+    let result = h
+        .prepare_rename(&file, 1, 0)
+        .expect("rename should be available on blank node");
+    assert_eq!(
+        result.placeholder, "_:b0",
+        "blank node placeholder should include the _: prefix"
+    );
+}
+
+// ─── rename: output wrapping ──────────────────────────────────────────────────
+
+#[test_log::test]
+fn rename_turtle_iri_bare_input_is_wrapped_in_angle_brackets() {
+    let mut h = LspHarness::new();
+    let src = "@prefix ex: <http://example.org/> .\nex:s <http://example.org/pred> ex:o .";
+    let file = h.open_file("file:///iri_wrap.ttl", "turtle", src);
+
+    // User provides just the IRI string — no angle brackets
+    let edits = h.rename(&file, 1, 5, "http://example.org/new");
+    assert!(!edits.is_empty(), "rename should produce at least one edit");
+
+    for (_, edit) in &edits {
+        assert_eq!(
+            edit.new_text, "<http://example.org/new>",
+            "bare IRI input should be wrapped in angle brackets: got {:?}",
+            edit.new_text
+        );
+    }
+}
+
+#[test_log::test]
+fn rename_turtle_iri_already_wrapped_input_is_kept_as_is() {
+    let mut h = LspHarness::new();
+    let src = "@prefix ex: <http://example.org/> .\nex:s <http://example.org/pred> ex:o .";
+    let file = h.open_file("file:///iri_nowrap.ttl", "turtle", src);
+
+    // User provides the IRI already wrapped
+    let edits = h.rename(&file, 1, 5, "<http://example.org/new>");
+    assert!(!edits.is_empty());
+    for (_, edit) in &edits {
+        assert_eq!(
+            edit.new_text, "<http://example.org/new>",
+            "already-wrapped IRI should not be double-wrapped: got {:?}",
+            edit.new_text
+        );
+    }
+}
+
+#[test_log::test]
+fn rename_turtle_iri_to_prefixed_name() {
+    let mut h = LspHarness::new();
+    let src = "@prefix ex: <http://example.org/> .\nex:s <http://example.org/pred> ex:o .";
+    let file = h.open_file("file:///iri_to_pname.ttl", "turtle", src);
+
+    // User switches to a prefixed name — must not get wrapped in < >
+    let edits = h.rename(&file, 1, 5, "ex:newPred");
+    assert!(!edits.is_empty());
+    for (_, edit) in &edits {
+        assert_eq!(
+            edit.new_text, "ex:newPred",
+            "prefixed-name input should not be wrapped: got {:?}",
+            edit.new_text
+        );
+    }
+}
+
+#[test_log::test]
+fn rename_turtle_iri_to_blank_node() {
+    let mut h = LspHarness::new();
+    let src = "@prefix ex: <http://example.org/> .\nex:s <http://example.org/pred> ex:o .";
+    let file = h.open_file("file:///iri_to_bnode.ttl", "turtle", src);
+
+    // User switches to a blank node label
+    let edits = h.rename(&file, 1, 5, "_:myBlank");
+    assert!(!edits.is_empty());
+    for (_, edit) in &edits {
+        assert_eq!(
+            edit.new_text, "_:myBlank",
+            "blank-node input should not be wrapped: got {:?}",
+            edit.new_text
+        );
+    }
+}
+
+#[test_log::test]
+fn rename_turtle_prefixed_name_stays_as_is() {
+    let mut h = LspHarness::new();
+    let src = "@prefix ex: <http://example.org/> .\n<> ex:pred ex:o .";
+    let file = h.open_file("file:///pname_stays.ttl", "turtle", src);
+
+    let edits = h.rename(&file, 1, 3, "ex:renamed");
+    assert!(!edits.is_empty());
+    for (_, edit) in &edits {
+        assert_eq!(
+            edit.new_text, "ex:renamed",
+            "prefixed name should be used as-is: got {:?}",
+            edit.new_text
+        );
+    }
+}
+
+// ─── rename: multiple occurrences ────────────────────────────────────────────
+
+/// Regression test: subject with multiple PO pairs via `;` used to produce one
+/// edit per triple (not per source token), causing duplicated output like
+/// `foaf:agentagentagent` when a subject appeared in 3 triples.
+#[test_log::test]
+fn rename_subject_with_multiple_po_pairs_is_deduplicated() {
+    let mut h = LspHarness::new();
+    // <abc> is subject of 3 triples (via the ; shorthand)
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n\
+               <http://example.org/abc> a foaf:Agent ;\n\
+               \tfoaf:name \"Test\" ;\n\
+               \tfoaf:account <http://example.org/acc> .";
+    let file = h.open_file("file:///dedup_rename.ttl", "turtle", src);
+
+    // Cursor at col 1 on line 1 = 'h' in <http://example.org/abc>
+    let edits = h.rename(&file, 1, 1, "http://example.org/new");
+
+    assert_eq!(
+        edits.len(),
+        1,
+        "subject appearing in N triples should produce exactly 1 edit, got: {:?}",
+        edits.iter().map(|(_, e)| &e.new_text).collect::<Vec<_>>()
+    );
+    assert_eq!(edits[0].1.new_text, "<http://example.org/new>");
+}
+
+#[test_log::test]
+fn rename_applies_to_all_occurrences_in_file() {
+    let mut h = LspHarness::new();
+    // ex:pred appears as predicate on two lines
+    let src = "@prefix ex: <http://example.org/> .\n\
+               ex:s1 ex:pred ex:o1 .\n\
+               ex:s2 ex:pred ex:o2 .";
+    let file = h.open_file("file:///multi_rename.ttl", "turtle", src);
+
+    // Cursor on ex:pred at line 1, col 5 = 'e' in ex:pred
+    // "ex:s1 ex:pred ex:o1 ."
+    //  0123456789...
+    let edits = h.rename(&file, 1, 6, "ex:newPred");
+
+    assert_eq!(
+        edits.len(),
+        2,
+        "should produce one edit per occurrence; got edits: {:?}",
+        edits.iter().map(|(_, e)| &e.new_text).collect::<Vec<_>>()
+    );
+    for (_, edit) in &edits {
+        assert_eq!(edit.new_text, "ex:newPred");
+    }
+}
+
+// ─── empty IRI / token-boundary targeting ────────────────────────────────────
+
+/// Regression: an empty `<>` IRI sits immediately after a predicate.  The real
+/// backend decrements the cursor by one (`adjust_position`), so a cursor on `<`
+/// lands on the *end-boundary* of the preceding `sh:path` token.  The model must
+/// still rename `<>`, not fall back to the predicate.
+#[test_log::test]
+fn rename_empty_iri_does_not_fall_back_to_predicate() {
+    let mut h = LspHarness::new();
+    let src = "@prefix sh: <http://www.w3.org/ns/shacl#> .\n\
+               [ a sh:NodeShape;\n\
+               \x20\x20sh:property [ sh:path <> ] ].";
+    let file = h.open_file("file:///empty_iri.ttl", "turtle", src);
+
+    // Line 2: "  sh:property [ sh:path <> ] ]."  — col 24 = '<'.
+    // col 23 simulates the cursor after adjust_position(-1).
+    for col in [23u32, 24, 25] {
+        let result = h
+            .prepare_rename(&file, 2, col)
+            .unwrap_or_else(|| panic!("rename should target the empty <> at col {col}"));
+        assert_eq!(
+            result.placeholder, "",
+            "empty IRI placeholder should be empty, got {:?} at col {col}",
+            result.placeholder
+        );
+
+        let edits = h.rename(&file, 2, col, "http://example.org/new");
+        assert_eq!(
+            edits.len(),
+            1,
+            "should rename exactly the empty <> at col {col}, got {:?}",
+            edits.iter().map(|(_, e)| &e.new_text).collect::<Vec<_>>()
+        );
+        assert_eq!(edits[0].1.new_text, "<http://example.org/new>");
+    }
+}
+
+// ─── JSON-LD: quote preservation ─────────────────────────────────────────────
+
+#[test_log::test]
+fn prepare_rename_jsonld_iri_strips_double_quotes() {
+    let mut h = LspHarness::new();
+    // Minimal JSON-LD document with a quoted IRI as @id value
+    // The term span covers `"http://example.org/subject"` (with quotes).
+    // The placeholder shown to the user should strip the quotes.
+    let src = r#"{"@id": "http://example.org/subject", "http://example.org/pred": {"@value": "hello"}}"#;
+    let file = h.open_file("file:///id_rename.jsonld", "jsonld", src);
+    h.drain_tasks();
+
+    // col 8 = first `"` of `"http://example.org/subject"`
+    // {"@id": "http://example.org/subject", ...}
+    //  0123456789...
+    let result = h.prepare_rename(&file, 0, 8);
+
+    // The rename may or may not be available depending on how JSON-LD parse resolves
+    // the IRI into the triple store; we assert on quoting when it is.
+    if let Some(r) = result {
+        assert!(
+            !r.placeholder.starts_with('"'),
+            "JSON-LD placeholder should not start with a quote; got {:?}",
+            r.placeholder
+        );
+        assert!(
+            !r.placeholder.ends_with('"'),
+            "JSON-LD placeholder should not end with a quote; got {:?}",
+            r.placeholder
+        );
+    }
+}
+
+#[test_log::test]
+fn rename_jsonld_iri_wraps_new_name_in_quotes() {
+    let mut h = LspHarness::new();
+    let src = r#"{"@id": "http://example.org/subject", "http://example.org/pred": {"@value": "hello"}}"#;
+    let file = h.open_file("file:///id_rewrap.jsonld", "jsonld", src);
+    h.drain_tasks();
+
+    // col 8 = start of "http://example.org/subject"
+    let edits = h.rename(&file, 0, 8, "http://example.org/new-subject");
+
+    for (_, edit) in &edits {
+        assert!(
+            edit.new_text.starts_with('"') && edit.new_text.ends_with('"'),
+            "JSON-LD rename output must be wrapped in double-quotes; got {:?}",
+            edit.new_text
+        );
+        assert_eq!(
+            edit.new_text, "\"http://example.org/new-subject\"",
+            "inner IRI should be correct"
+        );
+    }
+}
diff --git a/e2e/tests/settings.rs b/e2e/tests/settings.rs
new file mode 100644
index 0000000000..352ca6ee34
--- /dev/null
+++ b/e2e/tests/settings.rs
@@ -0,0 +1,294 @@
+//! E2E tests for the two settings-driven features:
+//!
+//! 1. Preferred Turtle prefix kind (`@prefix` vs `PREFIX`) used when completing prefixes.
+//! 2. Namespace property validation: warn about predicate IRIs in a configured
+//!    namespace that are not defined in any known ontology, plus the allow-list
+//!    quick-fix and the "excluded by user" hover message.
+
+use swls_core::components::{Disabled, PrefixFormat};
+use swls_core::lsp_types::DiagnosticSeverity;
+use swls_e2e_tests::LspHarness;
+
+// ─── Feature 1: preferred prefix format ───────────────────────────────────────
+
+fn foaf_completion_insert_text(h: &mut LspHarness, file: &swls_e2e_tests::FileHandle) -> String {
+    // Completing "foa" (with foaf NOT declared) offers the bundled LOV "foaf" prefix;
+    // its edits include the prefix declaration inserted at the top of the document.
+    h.drain_tasks();
+    let completions = h.completions(file, 0, 0);
+    let foaf = completions
+        .into_iter()
+        .find(|c| c.label == "foaf")
+        .expect("expected a 'foaf' prefix completion");
+    foaf.edits
+        .iter()
+        .map(|e| e.new_text.clone())
+        .collect::<Vec<_>>()
+        .join("")
+}
+
+#[test_log::test]
+fn prefix_completion_defaults_to_turtle_at_prefix() {
+    let mut h = LspHarness::new();
+    let file = h.open_file("file:///pf_default.ttl", "turtle", "foa");
+
+    let inserted = foaf_completion_insert_text(&mut h, &file);
+    assert!(
+        inserted.contains("@prefix foaf:"),
+        "default prefix completion should use @prefix form, got: {inserted:?}"
+    );
+}
+
+#[test_log::test]
+fn prefix_completion_honors_sparql_format() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| c.prefix_format = Some(PrefixFormat::Sparql));
+
+    let file = h.open_file("file:///pf_sparql.ttl", "turtle", "foa");
+
+    let inserted = foaf_completion_insert_text(&mut h, &file);
+    assert!(
+        inserted.contains("PREFIX foaf:") && !inserted.contains("@prefix foaf:"),
+        "with prefix_format=sparql completion should use PREFIX form, got: {inserted:?}"
+    );
+}
+
+// ─── Feature 2: namespace property validation ─────────────────────────────────
+
+// A namespace that does not exist anywhere on the network, so the only "known"
+// property in it is the one we inject below.
+const CFG_NS: &str = "http://no-such-ns.invalid/cfg#";
+
+const CFG_ONTO_TTL: &str = r#"
+@prefix cfg: <http://no-such-ns.invalid/cfg#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+cfg:known a rdf:Property ;
+    rdfs:label "known" .
+"#;
+
+const DOC_TTL: &str = "@prefix cfg: <http://no-such-ns.invalid/cfg#>.\n\
+                       <#s> cfg:known \"a\" ;\n\
+                       cfg:unknown \"b\" .";
+
+#[test_log::test]
+fn unknown_property_in_closed_namespace_warns() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.closed_namespaces.insert(CFG_NS.to_string());
+    });
+
+    h.open_linked_file("file:///cfg-onto.ttl", "turtle", CFG_ONTO_TTL);
+    h.drain_tasks();
+    let file = h.open_file("file:///cfg-doc.ttl", "turtle", DOC_TTL);
+    h.drain_tasks();
+
+    let diags = h.run_diagnostics();
+    let warnings: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::WARNING)
+                && d.message.contains("not defined in the ontology")
+        })
+        .collect();
+
+    // cfg:unknown should warn, cfg:known should NOT.
+    assert!(
+        warnings.iter().any(|(_, d)| d.message.contains("unknown")),
+        "expected a warning for cfg:unknown, got: {:?}",
+        diags.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+    assert!(
+        !warnings.iter().any(|(_, d)| d.message.contains("#known")),
+        "cfg:known is a defined property and must NOT warn, got: {:?}",
+        warnings.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn allow_listed_property_does_not_warn() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.closed_namespaces.insert(CFG_NS.to_string());
+        c.allowed_properties
+            .insert(format!("{CFG_NS}unknown"));
+    });
+
+    h.open_linked_file("file:///cfg-onto2.ttl", "turtle", CFG_ONTO_TTL);
+    h.drain_tasks();
+    let file = h.open_file("file:///cfg-doc2.ttl", "turtle", DOC_TTL);
+    h.drain_tasks();
+
+    let diags = h.run_diagnostics();
+    let warnings: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::WARNING)
+                && d.message.contains("not defined in the ontology")
+        })
+        .collect();
+
+    assert!(
+        warnings.is_empty(),
+        "allow-listed cfg:unknown must not warn, got: {:?}",
+        warnings.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn no_warnings_without_closed_namespace_config() {
+    let mut h = LspHarness::new();
+    // No closed_namespaces configured at all.
+    h.open_linked_file("file:///cfg-onto3.ttl", "turtle", CFG_ONTO_TTL);
+    h.drain_tasks();
+    let file = h.open_file("file:///cfg-doc3.ttl", "turtle", DOC_TTL);
+    h.drain_tasks();
+
+    let diags = h.run_diagnostics();
+    let warnings: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url && d.message.contains("not defined in the ontology")
+        })
+        .collect();
+
+    assert!(
+        warnings.is_empty(),
+        "no namespace validation should happen without closed_namespaces, got: {:?}",
+        warnings.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+#[test_log::test]
+fn unknown_property_offers_allow_quick_fix() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.closed_namespaces.insert(CFG_NS.to_string());
+    });
+
+    h.open_linked_file("file:///cfg-onto4.ttl", "turtle", CFG_ONTO_TTL);
+    h.drain_tasks();
+    let file = h.open_file("file:///cfg-doc4.ttl", "turtle", DOC_TTL);
+    h.drain_tasks();
+
+    // Cursor on the "cfg:unknown" predicate (line 2).
+    let actions = h.code_actions_at(&file, 2, 3);
+    let allow = actions
+        .iter()
+        .find(|a| a.command.as_ref().map(|c| c.command.as_str()) == Some("swls.allowProperty"));
+
+    let allow = allow.expect("expected an allow-property quick-fix");
+    let args = allow
+        .command
+        .as_ref()
+        .and_then(|c| c.arguments.as_ref())
+        .expect("command should carry arguments");
+    assert!(
+        args.iter().any(|v| v.as_str() == Some(&format!("{CFG_NS}unknown"))),
+        "quick-fix should target cfg:unknown, got: {args:?}"
+    );
+}
+
+#[test_log::test]
+fn allow_quick_fix_not_offered_away_from_unknown_property() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.closed_namespaces.insert(CFG_NS.to_string());
+    });
+
+    h.open_linked_file("file:///cfg-onto4b.ttl", "turtle", CFG_ONTO_TTL);
+    h.drain_tasks();
+    let file = h.open_file("file:///cfg-doc4b.ttl", "turtle", DOC_TTL);
+    h.drain_tasks();
+
+    // Cursor on line 1 (the "cfg:known" statement), not on the unknown property.
+    let actions = h.code_actions_at(&file, 1, 5);
+    assert!(
+        !actions
+            .iter()
+            .any(|a| a.command.as_ref().map(|c| c.command.as_str()) == Some("swls.allowProperty")),
+        "allow-property quick-fix should not appear when cursor is not on the unknown property"
+    );
+}
+
+#[test_log::test]
+fn hover_on_allow_listed_property_explains_exclusion() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.closed_namespaces.insert(CFG_NS.to_string());
+        c.allowed_properties
+            .insert(format!("{CFG_NS}unknown"));
+    });
+
+    h.open_linked_file("file:///cfg-onto5.ttl", "turtle", CFG_ONTO_TTL);
+    h.drain_tasks();
+    let file = h.open_file("file:///cfg-doc5.ttl", "turtle", DOC_TTL);
+    h.drain_tasks();
+
+    // Line 2: "cfg:unknown \"b\" ." — hover over the predicate token.
+    //          0123456789
+    let hover = h.hover(&file, 2, 0);
+    let joined = hover.join("\n");
+    assert!(
+        joined.contains("allowed_properties") && joined.contains("not defined"),
+        "hover should explain the user-exclusion, got: {hover:?}"
+    );
+}
+
+#[test_log::test]
+fn namespace_property_warning_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.closed_namespaces.insert(CFG_NS.to_string());
+        c.disabled.insert(Disabled::NamespaceProperties);
+    });
+
+    h.open_linked_file("file:///cfg-onto6.ttl", "turtle", CFG_ONTO_TTL);
+    h.drain_tasks();
+    let file = h.open_file("file:///cfg-doc6.ttl", "turtle", DOC_TTL);
+    h.drain_tasks();
+
+    let diags = h.run_diagnostics();
+    let warnings: Vec<_> = diags
+        .iter()
+        .filter(|(url, d)| {
+            url.as_str() == file.url
+                && d.severity == Some(DiagnosticSeverity::WARNING)
+                && d.message.contains("not defined in the ontology")
+        })
+        .collect();
+
+    assert!(
+        warnings.is_empty(),
+        "namespace-properties validation should be silenced when disabled, got: {:?}",
+        warnings.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
+
+// ─── Feature 3: syntax diagnostics toggle ─────────────────────────────────────
+
+#[test_log::test]
+fn syntax_diagnostics_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::SyntaxDiagnostics);
+    });
+
+    // Missing closing `.` — a syntax error.
+    let file = h.open_file("file:///syntax_disabled.ttl", "turtle", "<> a <http://example.org/Thing>");
+    let diags = h.run_diagnostics();
+
+    let syntax_errors: Vec<_> = diags
+        .iter()
+        .filter(|(url, _)| url.as_str() == file.url)
+        .collect();
+
+    assert!(
+        syntax_errors.is_empty(),
+        "syntax diagnostics should be silenced when disabled, got: {:?}",
+        syntax_errors.iter().map(|(_, d)| &d.message).collect::<Vec<_>>()
+    );
+}
diff --git a/e2e/tests/sparql_completion.rs b/e2e/tests/sparql_completion.rs
new file mode 100644
index 0000000000..5439363c55
--- /dev/null
+++ b/e2e/tests/sparql_completion.rs
@@ -0,0 +1,66 @@
+//! E2E completion tests for SPARQL.
+//!
+//! Covers keyword completion and variable completion in SPARQL queries.
+
+use swls_e2e_tests::LspHarness;
+
+// ─── Keyword completion ───────────────────────────────────────────────────────
+
+#[test_log::test]
+fn sparql_keywords_are_suggested() {
+    let mut h = LspHarness::new();
+    // Position cursor at "SEL" — the beginning of SELECT
+    let src = "SEL";
+    let file = h.open_file("file:///query.sparql", "sparql", src);
+
+    let completions = h.completions(&file, 0, 0);
+    h.assert_completions(&completions)
+        .count_at_least(1)
+        .contains_label("SELECT");
+}
+
+#[test_log::test]
+fn sparql_where_keyword_is_suggested() {
+    let mut h = LspHarness::new();
+    let src = "SELECT ?s WHE";
+    let file = h.open_file("file:///query2.sparql", "sparql", src);
+
+    // Character 10 = 'W' in "WHE"
+    let completions = h.completions(&file, 0, 10);
+    h.assert_completions(&completions)
+        .count_at_least(1)
+        .contains_label("WHERE");
+}
+
+// ─── Prefix-based completions ─────────────────────────────────────────────────
+
+#[test_log::test]
+fn sparql_prefix_terms_are_suggested_after_colon() {
+    let mut h = LspHarness::new();
+    let src = "PREFIX foaf: <http://xmlns.com/foaf/0.1/>\n\
+               SELECT ?s WHERE { ?s foaf: }";
+    let file = h.open_file("file:///prefixed.sparql", "sparql", src);
+    h.drain_tasks();
+
+    // Line 1: "SELECT ?s WHERE { ?s foaf: }"
+    //          0123456789012345678901234567
+    // "foaf:" starts at column 20
+    let completions = h.completions(&file, 1, 20);
+    h.assert_completions(&completions).count_at_least(1);
+}
+
+// ─── Variable completion ──────────────────────────────────────────────────────
+
+#[test_log::test]
+fn sparql_variable_completion_suggests_declared_variables() {
+    let mut h = LspHarness::new();
+    // ?sub is declared; when we type ?s in the WHERE clause the server should offer ?sub
+    let src = "SELECT ?sub WHERE { ?sub a <http://example.org/Thing> . ?s }";
+    let file = h.open_file("file:///vars.sparql", "sparql", src);
+
+    // "?s" at the end — character 52 ('?' position).
+    // The exact position depends on text length; we just verify non-panic.
+    let completions = h.completions(&file, 0, 52);
+    // Variable completions may or may not be present depending on token detection.
+    let _ = completions;
+}
diff --git a/e2e/tests/turtle_completion.rs b/e2e/tests/turtle_completion.rs
new file mode 100644
index 0000000000..cdc099051a
--- /dev/null
+++ b/e2e/tests/turtle_completion.rs
@@ -0,0 +1,347 @@
+//! E2E completion tests for the Turtle language.
+//!
+//! These tests verify that the LSP returns sensible completions for Turtle documents, covering:
+//! - Keyword completion (`@prefix`, `@base`, `a`)
+//! - Defined-prefix expansion (completing a prefix name from declarations in the document)
+//! - Class completion via a locally injected ontology
+//! - Property completion via a locally injected ontology
+//! - Cross-file subject completion (subjects defined in a linked open file)
+//! - LOV-based prefix completion (suggested prefixes from the bundled vocabulary)
+
+use swls_core::components::Disabled;
+use swls_e2e_tests::LspHarness;
+
+// ─── Fictional ontology shared across tests ───────────────────────────────────
+//
+// This namespace (`http://fictional.test/onto#`) does not exist anywhere on the
+// network, so any completions derived from it can only come from the locally
+// injected file — not from LOV, prefix.cc, or any external source.
+
+const FICT_ONTO_TTL: &str = r#"
+@prefix fict: <http://fictional.test/onto#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+fict:Widget a rdfs:Class ;
+    rdfs:label "Widget" ;
+    rdfs:comment "A reusable fictional component." .
+
+fict:Gadget a rdfs:Class ;
+    rdfs:subClassOf fict:Widget ;
+    rdfs:label "Gadget" .
+
+fict:hasComponent a rdf:Property ;
+    rdfs:label "hasComponent" ;
+    rdfs:domain fict:Widget ;
+    rdfs:range fict:Widget .
+
+fict:weight a rdf:Property ;
+    rdfs:label "weight" ;
+    rdfs:domain fict:Widget .
+"#;
+
+// ─── Keyword completion ───────────────────────────────────────────────────────
+
+#[test_log::test]
+fn turtle_keywords_are_suggested_at_start_of_line() {
+    let mut h = LspHarness::new();
+    let file = h.open_file("file:///keywords.ttl", "turtle", "");
+
+    let completions = h.completions(&file, 0, 0);
+    // keyword_complete always adds all Turtle keywords regardless of token text
+    h.assert_completions(&completions)
+        .contains_label("@prefix")
+        .contains_label("@base")
+        .contains_label("a");
+}
+
+#[test_log::test]
+fn turtle_keyword_a_is_suggested_as_predicate() {
+    let mut h = LspHarness::new();
+    // Line 1: "ex:subject " — cursor at col 11, after the subject and space
+    let src = "@prefix ex: <http://example.org/>.\nex:subject ";
+    let file = h.open_file("file:///kw_a.ttl", "turtle", src);
+
+    let completions = h.completions(&file, 1, 11);
+    h.assert_completions(&completions).contains_label("a");
+}
+
+// ─── Prefix name completion (bundled LOV) ─────────────────────────────────────
+
+#[test_log::test]
+fn completing_partial_prefix_name_suggests_matching_lov_prefix() {
+    let mut h = LspHarness::new();
+    // "foa" as a lone subject token — the bundled LOV vocabulary contains "foaf"
+    // whose name starts with "foa", so it should be offered as a prefix suggestion.
+    // The label produced by prefix_completion_helper is the bare prefix name (e.g. "foaf").
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\nfoa";
+    let file = h.open_file("file:///prefix_expand.ttl", "turtle", src);
+
+    // character 0: start of "foa" token on line 1
+    let completions = h.completions(&file, 1, 0);
+    h.assert_completions(&completions)
+        .contains_label("@prefix") // always present via keyword_complete
+        .contains_label("foaf"); // bundled LOV prefix whose name starts with "foa"
+}
+
+#[test_log::test]
+fn lov_bundled_prefixes_are_suggested_without_any_declaration() {
+    let mut h = LspHarness::new();
+    // No prefix declaration in the document at all.
+    // "foa" still matches "foaf" from the bundled LOV static data (loaded at Startup).
+    let src = "foa";
+    let file = h.open_file("file:///lov_prefix.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let completions = h.completions(&file, 0, 0);
+    h.assert_completions(&completions).contains_label("foaf");
+}
+
+// ─── Predicate-position keywords ─────────────────────────────────────────────
+
+#[test_log::test]
+fn completing_after_colon_includes_keywords() {
+    let mut h = LspHarness::new();
+    // Cursor on the "foaf:" token at the predicate position.
+    // Without the ontology loaded the server still returns all Turtle keywords.
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n<> foaf:";
+    let file = h.open_file("file:///prefix_colon.ttl", "turtle", src);
+
+    // line 1: "<> foaf:" — col 3 is the 'f' in "foaf:"
+    let completions = h.completions(&file, 1, 3);
+    h.assert_completions(&completions)
+        .contains_label("a")
+        .contains_label("@prefix");
+}
+
+// ─── Class completion from a locally injected fictional ontology ──────────────
+
+#[test_log::test]
+fn class_completion_returns_classes_from_injected_ontology() {
+    // Open the fictional ontology as a linked background file.
+    // Its triples are loaded into the shared Oxigraph store via load_store, then
+    // derive_ontologies runs a SPARQL query and populates Ontologies.classes with
+    // fict:Widget and fict:Gadget.
+    let mut h = LspHarness::new();
+    h.open_linked_file("file:///fict-onto.ttl", "turtle", FICT_ONTO_TTL);
+    h.drain_tasks();
+
+    // The active document declares the fictional prefix and has a partial rdf:type object.
+    // "<> a fict:" — the object token is "fict:" (cursor on col 5, the 'f').
+    //  positions:  '<'=0,'>'=1,' '=2,'a'=3,' '=4,'f'=5
+    let src = "@prefix fict: <http://fictional.test/onto#>.\n<> a fict:";
+    let file = h.open_file("file:///class_complete.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let completions = h.completions(&file, 1, 5);
+    h.assert_completions(&completions)
+        // complete_class shortens the IRI using the document's prefix declarations.
+        // "http://fictional.test/onto#Widget" → "fict:Widget"
+        .contains_label("fict:Widget")
+        .contains_label("fict:Gadget");
+}
+
+// ─── Property completion from a locally injected fictional ontology ───────────
+
+#[test_log::test]
+fn property_completion_returns_domain_matching_properties() {
+    // Same fictional ontology: fict:Widget has properties fict:hasComponent and fict:weight.
+    let mut h = LspHarness::new();
+    h.open_linked_file("file:///fict-onto.ttl", "turtle", FICT_ONTO_TTL);
+    h.drain_tasks();
+
+    // The document declares fict:thing as a fict:Widget, then starts a new predicate.
+    // ParseLabel runs infer_types which maps fict:thing → fict:Widget type-id, enabling
+    // domain-aware property filtering in complete_properties.
+    //
+    // Line 2: "fict:thing fict:"
+    //          01234567890123456
+    //  col 11 = 'f' of the second "fict:"
+    let src = "@prefix fict: <http://fictional.test/onto#>.\n\
+               fict:thing a fict:Widget .\n\
+               fict:thing fict:";
+    let file = h.open_file("file:///prop_complete.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let completions = h.completions(&file, 2, 11);
+    h.assert_completions(&completions)
+        .contains_label("fict:hasComponent")
+        .contains_label("fict:weight");
+}
+
+// ─── Cross-file subject completion ───────────────────────────────────────────
+
+#[test_log::test]
+fn subject_completion_pulls_subjects_from_linked_open_file() {
+    let mut h = LspHarness::new();
+
+    // Linked file defines "foaf:me" as a subject with IRI http://xmlns.com/foaf/0.1/me.
+    let linked_src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n\
+                      foaf:me foaf:name \"Alice\".";
+    h.open_file("file:///linked.ttl", "turtle", linked_src);
+
+    // Primary file types "foaf:" — subject_completion iterates all Open triples and
+    // finds foaf:me because its expanded IRI starts with the expanded prefix.
+    // The completion label is the full subject IRI (not the shortened form).
+    let primary_src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\nfoaf:";
+    let file = h.open_file("file:///primary.ttl", "turtle", primary_src);
+    h.drain_tasks();
+
+    // col 0 = 'f' in "foaf:"
+    let completions = h.completions(&file, 1, 0);
+    h.assert_completions(&completions)
+        .contains_label("http://xmlns.com/foaf/0.1/me");
+}
+
+// ─── Fully fictional ontology (guaranteed not from any external source) ────────
+
+#[test_log::test]
+fn completions_from_locally_injected_ontology() {
+    // This namespace has never been published anywhere. Any class or property completions
+    // using it can only originate from the injected file — not from LOV or prefix.cc.
+    const ENG_ONTO_TTL: &str = r#"
+@prefix eng: <http://no-such-ns.invalid/engine-ontology#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+eng:Engine a rdfs:Class ;
+    rdfs:label "Engine" .
+
+eng:Fuel a rdfs:Class ;
+    rdfs:label "Fuel" .
+
+eng:burnsFuel a rdf:Property ;
+    rdfs:label "burnsFuel" ;
+    rdfs:domain eng:Engine ;
+    rdfs:range eng:Fuel .
+
+eng:hasCylinders a rdf:Property ;
+    rdfs:label "hasCylinders" ;
+    rdfs:domain eng:Engine .
+"#;
+
+    let mut h = LspHarness::new();
+
+    // Inject the fictional ontology as a linked background document.
+    h.open_linked_file("file:///eng-onto.ttl", "turtle", ENG_ONTO_TTL);
+    h.drain_tasks();
+
+    // ── Class completions ──────────────────────────────────────────────────────
+    // "<> a eng:" — object of rdf:type predicate, token = "eng:"
+    //  positions: '<'=0,'>'=1,' '=2,'a'=3,' '=4,'e'=5
+    let src_class = "@prefix eng: <http://no-such-ns.invalid/engine-ontology#>.\n<> a eng:";
+    let class_file = h.open_file("file:///eng_class.ttl", "turtle", src_class);
+    h.drain_tasks();
+
+    let class_completions = h.completions(&class_file, 1, 5);
+    h.assert_completions(&class_completions)
+        .contains_label("eng:Engine")
+        .contains_label("eng:Fuel")
+        // must NOT contain anything from the real foaf or other known ontologies
+        .does_not_contain_label("foaf:Person")
+        .does_not_contain_label("foaf:Agent");
+
+    // ── Property completions ───────────────────────────────────────────────────
+    // Line 2: "eng:thing eng:" — col 10 = 'e' of the second "eng:"
+    let src_prop = "@prefix eng: <http://no-such-ns.invalid/engine-ontology#>.\n\
+                    eng:thing a eng:Engine .\n\
+                    eng:thing eng:";
+    let prop_file = h.open_file("file:///eng_prop.ttl", "turtle", src_prop);
+    h.drain_tasks();
+
+    let prop_completions = h.completions(&prop_file, 2, 10);
+    println!("Completions {:#?} ", prop_completions);
+    h.assert_completions(&prop_completions)
+        .contains_label("eng:burnsFuel")
+        .contains_label("eng:hasCylinders");
+}
+
+// ─── Config toggles: disabling individual completion sources ──────────────────
+
+#[test_log::test]
+fn completion_class_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::CompletionClass);
+    });
+    h.open_linked_file("file:///fict-onto-disabled.ttl", "turtle", FICT_ONTO_TTL);
+    h.drain_tasks();
+
+    let src = "@prefix fict: <http://fictional.test/onto#>.\n<> a fict:";
+    let file = h.open_file("file:///class_complete_disabled.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let completions = h.completions(&file, 1, 5);
+    h.assert_completions(&completions)
+        .does_not_contain_label("fict:Widget")
+        .does_not_contain_label("fict:Gadget");
+}
+
+#[test_log::test]
+fn completion_property_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::CompletionProperty);
+    });
+    h.open_linked_file("file:///fict-onto-disabled2.ttl", "turtle", FICT_ONTO_TTL);
+    h.drain_tasks();
+
+    let src = "@prefix fict: <http://fictional.test/onto#>.\n\
+               fict:thing a fict:Widget .\n\
+               fict:thing fict:";
+    let file = h.open_file("file:///prop_complete_disabled.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let completions = h.completions(&file, 2, 11);
+    h.assert_completions(&completions)
+        .does_not_contain_label("fict:hasComponent")
+        .does_not_contain_label("fict:weight");
+}
+
+#[test_log::test]
+fn completion_prefix_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::CompletionPrefix);
+    });
+    let src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\nfoa";
+    let file = h.open_file("file:///prefix_disabled.ttl", "turtle", src);
+    h.drain_tasks();
+
+    let completions = h.completions(&file, 1, 0);
+    h.assert_completions(&completions).does_not_contain_label("foaf");
+}
+
+#[test_log::test]
+fn completion_keyword_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::CompletionKeyword);
+    });
+    let file = h.open_file("file:///keywords_disabled.ttl", "turtle", "");
+
+    let completions = h.completions(&file, 0, 0);
+    h.assert_completions(&completions)
+        .does_not_contain_label("@prefix")
+        .does_not_contain_label("@base");
+}
+
+#[test_log::test]
+fn completion_subject_disabled_by_config() {
+    let mut h = LspHarness::new();
+    h.set_config(|c| {
+        c.disabled.insert(Disabled::CompletionSubject);
+    });
+
+    let linked_src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n\
+                      foaf:me foaf:name \"Alice\".";
+    h.open_file("file:///linked_disabled.ttl", "turtle", linked_src);
+
+    let primary_src = "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\nfoaf:";
+    let file = h.open_file("file:///primary_disabled.ttl", "turtle", primary_src);
+    h.drain_tasks();
+
+    let completions = h.completions(&file, 1, 0);
+    h.assert_completions(&completions)
+        .does_not_contain_label("http://xmlns.com/foaf/0.1/me");
+}
diff --git a/examples/index.jsonld b/examples/index.jsonld
index 4abd553631..dcaf775dec 100644
--- a/examples/index.jsonld
+++ b/examples/index.jsonld
@@ -1,8 +1,4 @@
 {
-  "@context": {
-    "foaf": "http://xmlns.com/foaf/0.1/",
-    "rdfs": "http://www.w3.org/2000/01/rdf-schema#"
-  },
-  "rdfs:label": "foaf:testing",
-  "foaf:knows": "Arthur"
+  "@context": { "name": "foaf:name", "foaf": "http://xmlns.com/foaf/0.1/" },
+  "foaf:": "name"
 }
diff --git a/examples/shape.ttl b/examples/shape.ttl
index 09b1a3c97e..5478f24955 100644
--- a/examples/shape.ttl
+++ b/examples/shape.ttl
@@ -1,16 +1,13 @@
+@prefix ldes: <https://w3id.org/ldes#>.
+@prefix foaf: <http://xmlns.com/foaf/0.1/>.
 @prefix mtg: <https://mtg.example.org/ontology#>.
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
 @prefix sh: <http://www.w3.org/ns/shacl#>.
-@prefix foaf: <http://xmlns.com/foaf/0.1/>.
-@prefix rml: <http://w3id.org/rml/>.
-[ ] a sh:NodeShape;
-  sh:property [
-    sh:name "";
-    sh: "";
-    sh:path <>;
-  ].
 
-[] a mtg:Card.
+[ ] a sh:NodeShape;
+  sh:property [ sh:path <> ].
 
+[ ] rdf:type mtg:Card.
 <abc> a "test"^^xsd:datatime, foaf:Agent.
 <me> foaf:knows <abc>.
 [ ] a sh:NodeShape;
diff --git a/lang-jsonld/CHANGELOG.md b/lang-jsonld/CHANGELOG.md
index 3b3b93a86d..7dc7a49ef9 100644
--- a/lang-jsonld/CHANGELOG.md
+++ b/lang-jsonld/CHANGELOG.md
@@ -5,6 +5,47 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.6 (2026-06-22)
+
+### New Features
+
+ - <csr-id-bb4f08bed28af56f776d32f787a459c7325ec47e/> gate features with configuration
+ - <csr-id-4bad0c7033f9029315e831d5801922f959a64165/> add automatic insert of prefix statements when writing colon
+ - <csr-id-5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1/> add undefined iri's warnings
+ - <csr-id-b55d2807364d9521378e9d5433ee53d3d6bc8109/> prefix diagnostics
+
+### Bug Fixes
+
+ - <csr-id-91a3739936dfb66c688d161c5264c997020abc86/> remove unused systems
+
+### Other
+
+ - <csr-id-057b9578e70b48ff01d1901700bb4a836db76327/> fix tests
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 6 commits contributed to the release over the course of 4 calendar days.
+ - 32 days passed between releases.
+ - 6 commits were understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - Gate features with configuration ([`bb4f08b`](https://github.com/SemanticWebLanguageServer/swls/commit/bb4f08bed28af56f776d32f787a459c7325ec47e))
+    - Fix tests ([`057b957`](https://github.com/SemanticWebLanguageServer/swls/commit/057b9578e70b48ff01d1901700bb4a836db76327))
+    - Add automatic insert of prefix statements when writing colon ([`4bad0c7`](https://github.com/SemanticWebLanguageServer/swls/commit/4bad0c7033f9029315e831d5801922f959a64165))
+    - Remove unused systems ([`91a3739`](https://github.com/SemanticWebLanguageServer/swls/commit/91a3739936dfb66c688d161c5264c997020abc86))
+    - Add undefined iri's warnings ([`5daeb7f`](https://github.com/SemanticWebLanguageServer/swls/commit/5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1))
+    - Prefix diagnostics ([`b55d280`](https://github.com/SemanticWebLanguageServer/swls/commit/b55d2807364d9521378e9d5433ee53d3d6bc8109))
+</details>
+
 ## 0.1.5 (2026-05-20)
 
 ### New Features
@@ -15,7 +56,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <csr-read-only-do-not-edit/>
 
- - 2 commits contributed to the release.
+ - 3 commits contributed to the release.
  - 9 days passed between releases.
  - 1 commit was understood as [conventional](https://www.conventionalcommits.org).
  - 0 issues like '(#ID)' were seen in commit messages
@@ -27,6 +68,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>
 
  * **Uncategorized**
+    - Release swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`0d1c8c5`](https://github.com/SemanticWebLanguageServer/swls/commit/0d1c8c52d0b7741321109ad22f1f16d53e4f8dc6))
     - Adjusting changelogs prior to release of swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`4f3e731`](https://github.com/SemanticWebLanguageServer/swls/commit/4f3e731b0301e0b689bfe15e790ad4706a3c84e1))
     - Better highlighting ([`9b17ed3`](https://github.com/SemanticWebLanguageServer/swls/commit/9b17ed366f37598da0a9747dc51d552bee891ded))
 </details>
diff --git a/lang-jsonld/Cargo.toml b/lang-jsonld/Cargo.toml
index 1640a275ce..eb5c554b33 100644
--- a/lang-jsonld/Cargo.toml
+++ b/lang-jsonld/Cargo.toml
@@ -4,7 +4,7 @@ name = "swls-lang-jsonld"
 description = "JSON-LD language support for the Semantic Web Language Server"
 keywords = ["lsp", "semantic-web", "rdf", "json-ld", "linked-data"]
 categories = ["development-tools", "parser-implementations"]
-version = "0.1.5"
+version = "0.1.6"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
diff --git a/lang-jsonld/src/ecs/completion.rs b/lang-jsonld/src/ecs/completion.rs
index 92969d7626..bb55ab530e 100644
--- a/lang-jsonld/src/ecs/completion.rs
+++ b/lang-jsonld/src/ecs/completion.rs
@@ -321,22 +321,18 @@ pub fn jsonld_lov_undefined_prefix_completion(
     >,
     lovs: Query<&LocalPrefix>,
     prefix_cc: Query<&PrefixEntry>,
+    config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::CompletionPrefix) {
+        return;
+    }
+    let fmt = config.config.local.prefix_format.unwrap_or_default();
     for (source, rope, word, prefixes, mut req, lang) in &mut query {
         prefix_completion_helper(
             word,
             prefixes,
             &mut req.0,
-            |name, location| {
-                add_to_context(
-                    &source.0,
-                    &rope.0,
-                    ContextEntry::Prefix {
-                        name,
-                        namespace: location,
-                    },
-                )
-            },
+            |name, location| lang.prefix_edits(&source.0, &rope.0, name, location, fmt),
             lovs.iter(),
             prefix_cc.iter(),
             lang,
@@ -364,7 +360,11 @@ pub fn jsonld_property_completion(
     >,
     hierarchy: Res<TypeHierarchy>,
     registry: Res<Registry>,
+    config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::CompletionProperty) {
+        return;
+    }
     for (token, triple, types, active_ctx, prefixes, mut request) in &mut query {
         if triple.target != TripleTarget::Predicate {
             continue;
@@ -430,62 +430,11 @@ pub fn jsonld_property_completion(
     }
 }
 
-/// Suggests the short names defined in the document's `@context` (e.g. `"name"`
-/// mapped to `foaf:name`) when the cursor is in predicate position. These
-/// aliases are more concise than prefixed names and are idiomatic in JSON-LD.
-#[instrument(skip(query))]
-pub fn jsonld_context_alias_completion(
-    mut query: Query<
-        (
-            &TokenComponent,
-            &TripleComponent,
-            &JsonLdActiveContext,
-            &Prefixes,
-            &mut CompletionRequest,
-        ),
-        With<JsonLdLang>,
-    >,
-) {
-    for (token, triple, active_ctx, prefixes, mut request) in &mut query {
-        if triple.target != TripleTarget::Predicate {
-            continue;
-        }
-
-        let bare_text = unquote(&token.text);
-
-        for (term_name, term_def) in &active_ctx.0.terms {
-            let Some(ref iri) = term_def.iri else {
-                continue;
-            };
-
-            if term_name.starts_with(bare_text) {
-                let quoted = format!("\"{}\"", term_name);
-                // Show the resolved IRI (or shortened form) as the label description.
-                let label_desc = prefixes.shorten(iri).unwrap_or_else(|| iri.clone());
-
-                request.push(
-                    SimpleCompletion::new(
-                        CompletionItemKind::FIELD,
-                        term_name.clone(),
-                        TextEdit {
-                            range: token.range.clone(),
-                            new_text: quoted,
-                        },
-                    )
-                    .label_description(label_desc)
-                    .sort_text(format!("0{}", term_name)),
-                );
-            }
-        }
-    }
-}
-
 pub fn setup_completion(world: &mut World) {
     use swls_core::feature::completion::*;
     world.schedule_scope(CompletionLabel, |_, schedule| {
         schedule.add_systems((
             jsonld_property_completion.after(generate_completions),
-            // jsonld_context_alias_completion.after(generate_completions),
             jsonld_lov_undefined_prefix_completion.after(generate_completions),
         ));
     });
@@ -498,30 +447,6 @@ mod tests {
     use swls_test_utils::{create_file, setup_world, TestClient};
     use test_log::test;
 
-    /// Helper: run parse + completion schedule and return completions at cursor.
-    fn get_completions(
-        world: &mut bevy_ecs::world::World,
-        entity: bevy_ecs::entity::Entity,
-        line: u32,
-        character: u32,
-    ) -> Vec<String> {
-        world.run_schedule(ParseLabel);
-        world.entity_mut(entity).insert((
-            CompletionRequest(vec![]),
-            PositionComponent(swls_core::lsp_types::Position { line, character }),
-        ));
-        world.run_schedule(CompletionLabel);
-        world
-            .entity_mut(entity)
-            .take::<CompletionRequest>()
-            .map(|r| {
-                r.0.into_iter()
-                    .map(|c| c.edits[0].new_text.clone())
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
     #[test]
     fn prefix_property_completion_works() {
         let (mut world, _) = setup_world(TestClient::new(), crate::setup_world::<TestClient>);
@@ -533,6 +458,14 @@ mod tests {
 
         world.run_schedule(ParseLabel);
 
+        // JSON-LD triple extraction is async (context resolution runs in a
+        // spawned task), so drive those tasks to completion before querying the
+        // cursor's triple.
+        let client = world.resource::<TestClient>().clone();
+        futures::executor::block_on(
+            client.await_futures(|| world.run_schedule(swls_core::Tasks)),
+        );
+
         // Verify that a TripleComponent is set with Predicate target when the
         // cursor is inside the "foaf:name" key (line 3, char 3 ≈ inside the key).
         world.entity_mut(entity).insert((
@@ -556,24 +489,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn context_alias_completion_works() {
-        let (mut world, _) = setup_world(TestClient::new(), crate::setup_world::<TestClient>);
-
-        // Valid JSON-LD: a context-defined term alias "name" maps to foaf:name.
-        // The cursor is positioned inside the "name" key to test alias completion.
-        let src = "{\n  \"@context\": {\n    \"foaf\": \"http://xmlns.com/foaf/0.1/\",\n    \"name\": \"foaf:name\"\n  },\n  \"@id\": \"http://example.com/me\",\n  \"name\": \"John\"\n}";
-        let entity = create_file(&mut world, src, "http://example.com/ns#", "jsonld", Open);
-
-        // Cursor inside "name" on the last property line (line 6, char 3).
-        let completions = get_completions(&mut world, entity, 6, 3);
-        assert!(
-            completions.iter().any(|c| c == "\"name\""),
-            "Expected \"name\" alias in completions, got: {:?}",
-            completions
-        );
-    }
-
     #[test]
     fn add_to_context_inserts_when_absent() {
         use ropey::Rope;
diff --git a/lang-jsonld/src/lib.rs b/lang-jsonld/src/lib.rs
index d35c69f6fc..55e2052a94 100644
--- a/lang-jsonld/src/lib.rs
+++ b/lang-jsonld/src/lib.rs
@@ -75,10 +75,63 @@ impl LangHelper for JsonLdHelper {
     fn quote(&self, inp: &str) -> String {
         format!("\"{}\"", inp)
     }
+    fn rename_placeholder<'a>(&self, raw: &'a str) -> &'a str {
+        self.unquote(raw)
+    }
+    fn rename_wrap(&self, new_text: &str) -> String {
+        self.quote(new_text)
+    }
     fn handles_prefix_completion(&self) -> bool {
         true
     }
 
+    /// Extract the prefix name whose `:` was just typed *inside a JSON string*
+    /// (e.g. typing `:` in `"foaf:knows"`), so on-type formatting can splice the
+    /// prefix into `@context`.  Unlike the text-RDF default, the term boundary is
+    /// the opening double-quote of the string.
+    fn prefix_name_at<'a>(&self, source: &'a str, offset: usize) -> Option<&'a str> {
+        let bytes = source.as_bytes();
+        if offset == 0 || offset > source.len() || bytes[offset - 1] != b':' {
+            return None;
+        }
+        let colon = offset - 1;
+
+        let mut start = colon;
+        while start > 0 {
+            let c = bytes[start - 1];
+            if c.is_ascii_alphanumeric() || matches!(c, b'_' | b'-' | b'.') {
+                start -= 1;
+            } else {
+                break;
+            }
+        }
+        if start == colon {
+            return None;
+        }
+        // Must sit inside a JSON string: the char before the name is the opening
+        // quote.  A context *key* like `"foaf":` has the `:` outside the quotes,
+        // so it has no name char before the `:` and is correctly ignored.
+        if start == 0 || bytes[start - 1] != b'"' {
+            return None;
+        }
+        Some(&source[start..colon])
+    }
+
+    fn prefix_edits(
+        &self,
+        source: &str,
+        rope: &ropey::Rope,
+        name: &str,
+        namespace: &str,
+        _format: swls_core::components::PrefixFormat,
+    ) -> Option<Vec<swls_core::lsp_types::TextEdit>> {
+        crate::ecs::completion::add_to_context(
+            source,
+            rope,
+            crate::ecs::completion::ContextEntry::Prefix { name, namespace },
+        )
+    }
+
     fn inlay_types_hint(
         &self,
         subject: &Range<usize>,
@@ -259,9 +312,14 @@ fn goto_cjs(
         With<JsonLdLang>,
     >,
     res: Res<Registry>,
+    config: Res<ServerConfig>,
 ) {
     use swls_core::lsp_types::{Location, Range};
 
+    if config.config.local.is_disabled(Disabled::GotoDefinitionComponentsJs) {
+        return;
+    }
+
     for (token, triple, label, mut req, active_ctx) in &mut query {
         // Only use the expanded IRI from the TripleComponent if the cursor token
         // actually overlaps the matched term's span.  get_current_triple is lenient
diff --git a/lang-rdf-base/CHANGELOG.md b/lang-rdf-base/CHANGELOG.md
index 29746c315e..198fab0b21 100644
--- a/lang-rdf-base/CHANGELOG.md
+++ b/lang-rdf-base/CHANGELOG.md
@@ -5,6 +5,46 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.4 (2026-06-22)
+
+### New Features
+
+ - <csr-id-bb4f08bed28af56f776d32f787a459c7325ec47e/> gate features with configuration
+ - <csr-id-ece087810771449d6e3e9badcc21b123af613879/> inline and extract blank nodes
+
+### Bug Fixes
+
+ - <csr-id-3604321f63b609c0095e507c094925d0d49894e5/> improve rename robustness
+ - <csr-id-91a3739936dfb66c688d161c5264c997020abc86/> remove unused systems
+ - <csr-id-aeb99acaba4869abdf8c7b8608b48c6ff91e0149/> better timing on the validation to reduce race conditions
+ - <csr-id-e52d0f65cef812ffeab54b7d110045ce4c74f741/> diagnostics after on change things works way better
+ - <csr-id-1b470e19be4b2d8639c2212eaa995dd5face19b8/> nested json-ld objects and arrays
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 7 commits contributed to the release over the course of 5 calendar days.
+ - 32 days passed between releases.
+ - 7 commits were understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - Gate features with configuration ([`bb4f08b`](https://github.com/SemanticWebLanguageServer/swls/commit/bb4f08bed28af56f776d32f787a459c7325ec47e))
+    - Improve rename robustness ([`3604321`](https://github.com/SemanticWebLanguageServer/swls/commit/3604321f63b609c0095e507c094925d0d49894e5))
+    - Remove unused systems ([`91a3739`](https://github.com/SemanticWebLanguageServer/swls/commit/91a3739936dfb66c688d161c5264c997020abc86))
+    - Inline and extract blank nodes ([`ece0878`](https://github.com/SemanticWebLanguageServer/swls/commit/ece087810771449d6e3e9badcc21b123af613879))
+    - Better timing on the validation to reduce race conditions ([`aeb99ac`](https://github.com/SemanticWebLanguageServer/swls/commit/aeb99acaba4869abdf8c7b8608b48c6ff91e0149))
+    - Diagnostics after on change things works way better ([`e52d0f6`](https://github.com/SemanticWebLanguageServer/swls/commit/e52d0f65cef812ffeab54b7d110045ce4c74f741))
+    - Nested json-ld objects and arrays ([`1b470e1`](https://github.com/SemanticWebLanguageServer/swls/commit/1b470e19be4b2d8639c2212eaa995dd5face19b8))
+</details>
+
 ## 0.1.3 (2026-05-20)
 
 ### New Features
@@ -15,7 +55,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <csr-read-only-do-not-edit/>
 
- - 2 commits contributed to the release.
+ - 3 commits contributed to the release.
  - 19 days passed between releases.
  - 1 commit was understood as [conventional](https://www.conventionalcommits.org).
  - 0 issues like '(#ID)' were seen in commit messages
@@ -27,6 +67,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>
 
  * **Uncategorized**
+    - Release swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`0d1c8c5`](https://github.com/SemanticWebLanguageServer/swls/commit/0d1c8c52d0b7741321109ad22f1f16d53e4f8dc6))
     - Adjusting changelogs prior to release of swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`4f3e731`](https://github.com/SemanticWebLanguageServer/swls/commit/4f3e731b0301e0b689bfe15e790ad4706a3c84e1))
     - Better highlighting ([`9b17ed3`](https://github.com/SemanticWebLanguageServer/swls/commit/9b17ed366f37598da0a9747dc51d552bee891ded))
 </details>
diff --git a/lang-rdf-base/Cargo.toml b/lang-rdf-base/Cargo.toml
index 6aeb729ecb..90d09a97be 100644
--- a/lang-rdf-base/Cargo.toml
+++ b/lang-rdf-base/Cargo.toml
@@ -4,7 +4,7 @@ name = "swls-lang-rdf-base"
 description = "Shared setup helpers for RDF language support in swls"
 keywords = ["lsp", "semantic-web", "rdf"]
 categories = ["development-tools"]
-version = "0.1.3"
+version = "0.1.4"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
diff --git a/lang-rdf-base/src/code_actions.rs b/lang-rdf-base/src/code_actions.rs
new file mode 100644
index 0000000000..08d98e5dff
--- /dev/null
+++ b/lang-rdf-base/src/code_actions.rs
@@ -0,0 +1,407 @@
+//! Shared, language-agnostic code actions for the text RDF syntaxes
+//! (Turtle / TriG / SPARQL / N3 — anything whose [`Lang::Element`] is the
+//! [`Turtle`] model).
+//!
+//! These systems are generic over the language marker `L` and are opted into by
+//! each language via [`setup_blank_node_code_action`].  JSON-LD deliberately does
+//! **not** register them, because its concrete syntax is JSON rather than the
+//! `[ … ]` / `_:bN` blank-node forms these actions produce.
+
+use std::collections::HashMap;
+use std::ops::Range as StdRange;
+
+use bevy_ecs::prelude::*;
+use rdf_parsers::model::{BlankNode, Term, Turtle, PO};
+use swls_core::{
+    feature::code_action::{CodeActionRequest, Label as CodeActionLabel},
+    lang::Lang,
+    lsp_types::{CodeAction, CodeActionKind, Range, TextEdit, WorkspaceEdit},
+    prelude::*,
+    util::{offset_to_position, offsets_to_range, position_to_offset},
+};
+
+/// Recursively search a term for the innermost *unnamed* blank node whose span
+/// contains `offset`.  Records `(span, has_content)` of the best (deepest) match.
+fn find_unnamed_in_term(
+    term: &Spanned<Term>,
+    offset: usize,
+    best: &mut Option<(StdRange<usize>, bool)>,
+) {
+    let span = term.span();
+    if offset < span.start || offset > span.end {
+        return;
+    }
+    match term.value() {
+        Term::BlankNode(BlankNode::Unnamed(pos, _, _)) => {
+            // Deeper (nested) matches overwrite shallower ones → innermost wins.
+            *best = Some((span.clone(), !pos.is_empty()));
+            for po in pos {
+                find_unnamed_in_po(po, offset, best);
+            }
+        }
+        Term::Collection(items) => {
+            for item in items {
+                find_unnamed_in_term(item, offset, best);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn find_unnamed_in_po(po: &Spanned<PO>, offset: usize, best: &mut Option<(StdRange<usize>, bool)>) {
+    let po = po.value();
+    find_unnamed_in_term(&po.predicate, offset, best);
+    for object in &po.object {
+        find_unnamed_in_term(object, offset, best);
+    }
+}
+
+/// Pick a fresh `_:bN` blank-node label that does not already occur in `source`.
+fn fresh_blank_label(source: &str) -> String {
+    let mut n = 0;
+    loop {
+        let candidate = format!("_:b{}", n);
+        if !source.contains(&candidate) {
+            return candidate;
+        }
+        n += 1;
+    }
+}
+
+/// Code action: when the cursor sits inside an anonymous blank node `[ … ]`,
+/// offer to extract it into a labelled blank node (`_:bN`) declared as a separate
+/// statement.  For example:
+///
+/// ```turtle
+/// <#s> foaf:knows [ foaf:name "Alice" ] .
+/// ```
+///
+/// becomes
+///
+/// ```turtle
+/// <#s> foaf:knows _:b0 .
+/// _:b0 foaf:name "Alice" .
+/// ```
+///
+/// This is generic over the language marker `L`; every text RDF syntax whose
+/// parsed model is [`Turtle`] (Turtle, TriG, SPARQL, N3, …) can reuse it.
+pub fn extract_blank_node<L>(
+    mut query: Query<(
+        &Element<L>,
+        &Source,
+        &RopeC,
+        &Label,
+        &PositionComponent,
+        &mut CodeActionRequest,
+    )>,
+    config: Res<ServerConfig>,
+) where
+    L: Lang<Element = Turtle> + Send + Sync + 'static,
+{
+    if config.config.local.is_disabled(Disabled::CodeActionBlankNodeRefactor) {
+        return;
+    }
+    for (element, source, rope, label, position, mut req) in &mut query {
+        let Some(offset) = position_to_offset(position.0, &rope.0) else {
+            continue;
+        };
+        let turtle: &Turtle = element.value();
+
+        let mut best: Option<(StdRange<usize>, bool)> = None;
+        for triple in &turtle.triples {
+            let triple = triple.value();
+            find_unnamed_in_term(&triple.subject, offset, &mut best);
+            for po in &triple.po {
+                find_unnamed_in_po(po, offset, &mut best);
+            }
+        }
+
+        let Some((bspan, has_content)) = best else {
+            continue;
+        };
+        // Extracting an empty `[]` would yield an invalid `_:bN .` statement.
+        if !has_content {
+            continue;
+        }
+
+        // Pull the predicate-object content out of the `[ … ]` source slice.
+        let Some(raw) = source.0.get(bspan.start..bspan.end) else {
+            continue;
+        };
+        let inner = raw.trim();
+        let inner = inner.strip_prefix('[').unwrap_or(inner);
+        let inner = inner.strip_suffix(']').unwrap_or(inner);
+        let inner = inner.trim();
+        if inner.is_empty() {
+            continue;
+        }
+
+        let bnode = fresh_blank_label(&source.0);
+
+        // Edit 1: replace the inline blank node with the new label.
+        let Some(replace_range) = offsets_to_range(bspan.start, bspan.end, &rope.0) else {
+            continue;
+        };
+        let replace_edit = TextEdit {
+            range: replace_range,
+            new_text: bnode.clone(),
+        };
+
+        // Edit 2: append the extracted statement at the end of the document.
+        let end_offset = source.0.len();
+        let Some(end_pos) = offset_to_position(end_offset, &rope.0) else {
+            continue;
+        };
+        let needs_leading_newline = !source.0.ends_with('\n');
+        let append_edit = TextEdit {
+            range: Range::new(end_pos, end_pos),
+            new_text: format!(
+                "{}{} {} .\n",
+                if needs_leading_newline { "\n" } else { "" },
+                bnode,
+                inner
+            ),
+        };
+
+        let mut changes = HashMap::new();
+        changes.insert(label.0.clone(), vec![replace_edit, append_edit]);
+
+        req.0.push(CodeAction {
+            title: String::from("Extract blank node into named blank node"),
+            kind: Some(CodeActionKind::REFACTOR_EXTRACT),
+            edit: Some(WorkspaceEdit {
+                changes: Some(changes),
+                ..Default::default()
+            }),
+            ..Default::default()
+        });
+    }
+}
+
+/// Find the innermost `BlankNode::Named` term whose span contains `offset`,
+/// returning its label and span.  Searches subjects, predicates and objects
+/// recursively (into nested `[ … ]` and collections).
+fn find_named_at(turtle: &Turtle, offset: usize) -> Option<(String, StdRange<usize>)> {
+    fn walk(
+        term: &Spanned<Term>,
+        offset: usize,
+        best: &mut Option<(String, StdRange<usize>)>,
+    ) {
+        let span = term.span();
+        if offset < span.start || offset > span.end {
+            return;
+        }
+        match term.value() {
+            Term::BlankNode(BlankNode::Named(name, _)) => {
+                *best = Some((name.clone(), span.clone()));
+            }
+            Term::BlankNode(BlankNode::Unnamed(pos, _, _)) => {
+                for po in pos {
+                    walk(&po.value().predicate, offset, best);
+                    for object in &po.value().object {
+                        walk(object, offset, best);
+                    }
+                }
+            }
+            Term::Collection(items) => {
+                for item in items {
+                    walk(item, offset, best);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    let mut best = None;
+    for triple in &turtle.triples {
+        let triple = triple.value();
+        walk(&triple.subject, offset, &mut best);
+        for po in &triple.po {
+            walk(&po.value().predicate, offset, &mut best);
+            for object in &po.value().object {
+                walk(object, offset, &mut best);
+            }
+        }
+    }
+    best
+}
+
+/// Collect every reference (span) to the named blank node `name` reachable from
+/// `term`, recursing into nested blank nodes and collections.
+fn collect_named_refs(term: &Spanned<Term>, name: &str, out: &mut Vec<StdRange<usize>>) {
+    match term.value() {
+        Term::BlankNode(BlankNode::Named(n, _)) if n == name => out.push(term.span().clone()),
+        Term::BlankNode(BlankNode::Unnamed(pos, _, _)) => {
+            for po in pos {
+                collect_named_refs(&po.value().predicate, name, out);
+                for object in &po.value().object {
+                    collect_named_refs(object, name, out);
+                }
+            }
+        }
+        Term::Collection(items) => {
+            for item in items {
+                collect_named_refs(item, name, out);
+            }
+        }
+        _ => {}
+    }
+}
+
+/// Code action: the inverse of [`extract_blank_node`].  When the cursor sits on a
+/// labelled blank node `_:bN` that is *defined* by exactly one statement and
+/// *referenced* in exactly one other place, inline the definition back into an
+/// anonymous blank node `[ … ]`.  For example:
+///
+/// ```turtle
+/// <#s> foaf:knows _:b0 .
+/// _:b0 foaf:name "Alice" .
+/// ```
+///
+/// becomes
+///
+/// ```turtle
+/// <#s> foaf:knows [ foaf:name "Alice" ] .
+/// ```
+///
+/// Generic over the language marker `L`, mirroring [`extract_blank_node`].
+pub fn inline_blank_node<L>(
+    mut query: Query<(
+        &Element<L>,
+        &Source,
+        &RopeC,
+        &Label,
+        &PositionComponent,
+        &mut CodeActionRequest,
+    )>,
+    config: Res<ServerConfig>,
+) where
+    L: Lang<Element = Turtle> + Send + Sync + 'static,
+{
+    if config.config.local.is_disabled(Disabled::CodeActionBlankNodeRefactor) {
+        return;
+    }
+    for (element, source, rope, label, position, mut req) in &mut query {
+        let Some(offset) = position_to_offset(position.0, &rope.0) else {
+            continue;
+        };
+        let turtle: &Turtle = element.value();
+
+        let Some((name, _)) = find_named_at(turtle, offset) else {
+            continue;
+        };
+
+        // Locate the single defining statement (`_:name <po> .`) and gather every
+        // reference to `_:name` everywhere else.
+        let mut def: Option<(usize, StdRange<usize>)> = None;
+        let mut refs: Vec<StdRange<usize>> = Vec::new();
+        for (idx, triple) in turtle.triples.iter().enumerate() {
+            let tvalue = triple.value();
+            let is_def = matches!(
+                tvalue.subject.value(),
+                Term::BlankNode(BlankNode::Named(n, _)) if *n == name
+            );
+            if is_def && def.is_none() {
+                def = Some((idx, tvalue.subject.span().clone()));
+            } else {
+                collect_named_refs(&tvalue.subject, &name, &mut refs);
+            }
+            // Always scan predicate/object positions for references (including the
+            // definition's own objects, so a self-reference disqualifies inlining).
+            for po in &tvalue.po {
+                collect_named_refs(&po.value().predicate, &name, &mut refs);
+                for object in &po.value().object {
+                    collect_named_refs(object, &name, &mut refs);
+                }
+            }
+        }
+
+        // Inlining only makes sense with exactly one definition and one reference.
+        let Some((def_idx, _)) = def else {
+            continue;
+        };
+        if refs.len() != 1 {
+            continue;
+        }
+        let ref_span = refs.into_iter().next().unwrap();
+
+        // Extract the predicate-object source of the definition (everything after
+        // the subject up to, but excluding, the closing `.`).
+        let def_triple = turtle.triples[def_idx].value();
+        let def_span = turtle.triples[def_idx].span();
+        let inner_start = def_triple.subject.span().end;
+        let Some(inner_raw) = source.0.get(inner_start..def_span.end) else {
+            continue;
+        };
+        let inner = inner_raw.trim();
+        let inner = inner.strip_suffix('.').unwrap_or(inner).trim();
+        if inner.is_empty() {
+            continue;
+        }
+
+        // Compute the deletion range for the whole definition statement, consuming
+        // surrounding line whitespace/newline for a clean removal.
+        let mut del_start = def_span.start;
+        let mut del_end = def_span.end;
+        let bytes = source.0.as_bytes();
+        while del_end < bytes.len() && matches!(bytes[del_end], b' ' | b'\t') {
+            del_end += 1;
+        }
+        if del_end < bytes.len() && bytes[del_end] == b'\r' {
+            del_end += 1;
+        }
+        if del_end < bytes.len() && bytes[del_end] == b'\n' {
+            del_end += 1;
+        }
+        while del_start > 0 && matches!(bytes[del_start - 1], b' ' | b'\t') {
+            del_start -= 1;
+        }
+
+        // Guard against overlapping edits (e.g. definition and reference share a
+        // line); inlining would corrupt the document, so skip the action.
+        if del_start < ref_span.end && ref_span.start < del_end {
+            continue;
+        }
+
+        let Some(ref_range) = offsets_to_range(ref_span.start, ref_span.end, &rope.0) else {
+            continue;
+        };
+        let Some(del_range) = offsets_to_range(del_start, del_end, &rope.0) else {
+            continue;
+        };
+
+        let replace_edit = TextEdit {
+            range: ref_range,
+            new_text: format!("[ {} ]", inner),
+        };
+        let delete_edit = TextEdit {
+            range: del_range,
+            new_text: String::new(),
+        };
+
+        let mut changes = HashMap::new();
+        changes.insert(label.0.clone(), vec![replace_edit, delete_edit]);
+
+        req.0.push(CodeAction {
+            title: String::from("Inline named blank node"),
+            kind: Some(CodeActionKind::REFACTOR_INLINE),
+            edit: Some(WorkspaceEdit {
+                changes: Some(changes),
+                ..Default::default()
+            }),
+            ..Default::default()
+        });
+    }
+}
+
+/// Register the [`extract_blank_node`] and [`inline_blank_node`] code actions for
+/// language `L` in the shared `CodeAction` schedule.  Call this from a text RDF
+/// language's `setup_world`.
+pub fn setup_blank_node_code_action<L>(world: &mut World)
+where
+    L: Lang<Element = Turtle> + Send + Sync + 'static,
+{
+    world.schedule_scope(CodeActionLabel, |_, schedule| {
+        schedule.add_systems((extract_blank_node::<L>, inline_blank_node::<L>));
+    });
+}
diff --git a/lang-rdf-base/src/lib.rs b/lang-rdf-base/src/lib.rs
index 8d1163b270..66f8608198 100644
--- a/lang-rdf-base/src/lib.rs
+++ b/lang-rdf-base/src/lib.rs
@@ -1,3 +1,6 @@
+pub mod code_actions;
+pub mod parse;
+pub mod rename;
 pub mod traits;
 pub mod triples;
 
@@ -59,8 +62,9 @@ pub fn register_rdf_lang<L, H>(
         }
     });
 
-    world.schedule_scope(swls_core::feature::DiagnosticsLabel, |_, schedule| {
-        schedule.add_systems(publish_diagnostics::<L>);
+    world.schedule_scope(swls_core::feature::ParseLabel, |_, schedule| {
+        use bevy_ecs::schedule::IntoScheduleConfigs;
+        schedule.add_systems(publish_diagnostics::<L>.after(swls_core::feature::parse::end));
     });
 
     world.schedule_scope(swls_core::feature::SemanticLabel, |_, schedule| {
@@ -82,7 +86,22 @@ mod tokens {
     use swls_core::prelude::semantic::*;
     use swls_core::prelude::*;
 
-    fn add_term(term: &Spanned<Term>, ttc: &mut TokenTypesComponent, kind: SemanticTokenType) {
+    /// True when `span` covers a JSON-LD node object (`{ … }`) rather than a
+    /// plain term.  Objects with an `@id` become a [`NamedNode`] whose span is
+    /// the whole `{ … }`; stamping that would wipe the inner coloring.
+    fn span_is_nested_object(span: &std::ops::Range<usize>, source: &str) -> bool {
+        source
+            .get(span.clone())
+            .map(|s| s.trim_start().starts_with('{'))
+            .unwrap_or(false)
+    }
+
+    fn add_term(
+        term: &Spanned<Term>,
+        ttc: &mut TokenTypesComponent,
+        kind: SemanticTokenType,
+        source: &str,
+    ) {
         match term.value() {
             Term::NamedNode(NamedNode::Prefixed { prefix, .. }) => {
                 let skip = prefix.len();
@@ -90,6 +109,14 @@ mod tokens {
                 ttc.push(spanned(kind, start + skip + 1..end));
             }
             Term::Variable(_) | Term::NamedNode(_) => {
+                // A JSON-LD node object with an @id becomes a NamedNode whose
+                // span covers the entire nested { } object.  Stamping it would
+                // wipe the inner coloring (same reasoning as anonymous blank
+                // nodes below); the @id is already colored as the subject of the
+                // inner triples.
+                if span_is_nested_object(term.span(), source) {
+                    return;
+                }
                 ttc.push(spanned(kind, term.span().clone()));
             }
             // Named blank nodes (_:label) get their coloring from the CST pass
@@ -101,13 +128,13 @@ mod tokens {
             Term::BlankNode(BlankNode::Unnamed(pos, _, _)) => {
                 for po in pos {
                     for o in &po.object {
-                        add_term(o, ttc, kind.clone());
+                        add_term(o, ttc, kind.clone(), source);
                     }
                 }
             }
             Term::Collection(spanneds) => {
                 for e in spanneds {
-                    add_term(e, ttc, kind.clone());
+                    add_term(e, ttc, kind.clone(), source);
                 }
             }
             _ => return,
@@ -115,17 +142,54 @@ mod tokens {
     }
 
     pub fn semantic_tokens<L: Lang<Element = Turtle> + Component>(
-        query: Query<(&Element<L>, &mut TokenTypesComponent), With<HighlightRequest>>,
+        query: Query<(&Element<L>, &Source, &mut TokenTypesComponent), With<HighlightRequest>>,
     ) {
-        for (turtle, mut ttc) in query {
+        for (turtle, source, mut ttc) in query {
+            let source = source.0.as_str();
             for t in &turtle.triples {
-                add_term(&t.subject, &mut ttc, SemanticTokenType::ENUM_MEMBER);
+                add_term(&t.subject, &mut ttc, SemanticTokenType::ENUM_MEMBER, source);
                 for po in &t.po {
                     for o in &po.object {
-                        add_term(o, &mut ttc, SemanticTokenType::ENUM_MEMBER);
+                        add_term(o, &mut ttc, SemanticTokenType::ENUM_MEMBER, source);
                     }
                 }
             }
         }
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        fn full(iri: &str, offset: usize, span: std::ops::Range<usize>) -> Spanned<Term> {
+            spanned(Term::NamedNode(NamedNode::Full(iri.into(), offset)), span)
+        }
+
+        // A JSON-LD node object with @id is a NamedNode whose span covers the
+        // whole `{ … }`; it must NOT be stamped (it would wipe inner coloring).
+        // A plain IRI reference of the same node must still be stamped.
+        #[test]
+        fn nested_named_object_is_skipped() {
+            let source = r#"{ "@id": "http://ex/x", "name": "n" }"#;
+            let mut ttc: TokenTypesComponent = Wrapped(Vec::new());
+            // Whole-object span (0..source.len()) — the conformsTo-style object.
+            add_term(
+                &full("http://ex/x", 9, 0..source.len()),
+                &mut ttc,
+                SemanticTokenType::ENUM_MEMBER,
+                source,
+            );
+            assert!(ttc.0.is_empty(), "nested {{ }} object should be skipped");
+
+            // The @id reference itself (just the IRI token) must be stamped.
+            let id_src = r#""http://ex/x""#;
+            add_term(
+                &full("http://ex/x", 0, 0..id_src.len()),
+                &mut ttc,
+                SemanticTokenType::ENUM_MEMBER,
+                id_src,
+            );
+            assert_eq!(ttc.0.len(), 1, "plain IRI reference should be stamped");
+        }
+    }
 }
diff --git a/lang-rdf-base/src/parse.rs b/lang-rdf-base/src/parse.rs
new file mode 100644
index 0000000000..7ea6363f6b
--- /dev/null
+++ b/lang-rdf-base/src/parse.rs
@@ -0,0 +1,47 @@
+//! Shared, language-agnostic parse-phase systems for the text RDF syntaxes whose
+//! [`Lang::Element`] is the [`Turtle`] model (Turtle / TriG / …).
+
+use bevy_ecs::prelude::*;
+use rdf_parsers::model::Turtle;
+use swls_core::{lang::Lang, prelude::*};
+
+use crate::traits::NamedNodeExt;
+
+/// Derive the [`Prefixes`] component (declared prefix → namespace map + base URL)
+/// from the parsed [`Turtle`] model.  Generic over the language marker `L`, so
+/// Turtle, TriG and any other language with `Element = Turtle` share one
+/// implementation.
+pub fn derive_prefixes_system<L>(
+    query: Query<(Entity, &Label, &Element<L>), Changed<Element<L>>>,
+    mut commands: Commands,
+) where
+    L: Lang<Element = Turtle> + Send + Sync + 'static,
+{
+    for (entity, url, turtle) in &query {
+        let prefixes: Vec<_> = turtle
+            .prefixes
+            .iter()
+            .flat_map(|prefix| {
+                let url = prefix.value.value().expand(turtle.value())?;
+                let url = swls_core::lsp_types::Url::parse(&url).ok()?;
+                Some(Prefix {
+                    url,
+                    prefix: prefix.prefix.value().clone(),
+                })
+            })
+            .collect();
+
+        let base = turtle
+            .base
+            .as_ref()
+            .and_then(|b| {
+                b.0 .1
+                    .value()
+                    .expand(turtle.value())
+                    .and_then(|x| swls_core::lsp_types::Url::parse(&x).ok())
+            })
+            .unwrap_or(url.0.clone());
+
+        commands.entity(entity).insert(Prefixes(prefixes, base));
+    }
+}
diff --git a/lang-rdf-base/src/rename.rs b/lang-rdf-base/src/rename.rs
new file mode 100644
index 0000000000..f2378cec71
--- /dev/null
+++ b/lang-rdf-base/src/rename.rs
@@ -0,0 +1,238 @@
+//! Shared, model-based rename for the text RDF syntaxes (Turtle / TriG / SPARQL /
+//! N3 — anything whose [`Lang::Element`] is the [`Turtle`] model).
+//!
+//! Unlike the language-agnostic rename in `swls-core` (which slices the rope at a
+//! term span and classifies the raw string), these systems work off the parsed
+//! [`Turtle`] model.  Walking the model gives us:
+//!
+//! * exact term boundaries (no `<>`/`_:` string heuristics for *finding* the
+//!   token under the cursor), and
+//! * natural de-duplication — a subject written once with the `;` shorthand
+//!   appears exactly once in the model, so it yields exactly one edit.
+//!
+//! Each text RDF language opts in via [`setup_rename`].  JSON-LD deliberately
+//! stays on the core agnostic path because its concrete syntax wraps IRIs in
+//! quoted strings rather than `<>`.
+
+use std::ops::Range as StdRange;
+
+use bevy_ecs::prelude::*;
+use rdf_parsers::model::{BlankNode, NamedNode, Term, Turtle, PO};
+use swls_core::{
+    feature::rename::{PrepareRename, PrepareRenameRequest, Rename, RenameEdits},
+    lang::Lang,
+    lsp_types::TextEdit,
+    prelude::*,
+    util::{offsets_to_range, position_to_offset},
+};
+
+use crate::traits::NamedNodeExt;
+
+/// Canonical identity of a renameable term.  Two occurrences are renamed
+/// together iff their keys are equal.
+#[derive(Clone, PartialEq, Eq)]
+enum RenameKey {
+    /// A (possibly prefixed) IRI, compared by its fully-expanded absolute form.
+    Iri(String),
+    /// A labelled blank node, compared by its label.
+    Blank(String),
+    /// A SPARQL variable, compared by its name.
+    Var(String),
+}
+
+/// Compute the canonical key of a term, or `None` if it is not renameable
+/// (literals, `a`, anonymous blank nodes, collections, invalid terms).
+fn term_key(term: &Term, turtle: &Turtle) -> Option<RenameKey> {
+    match term {
+        Term::NamedNode(nn) => match nn {
+            NamedNode::A(_) | NamedNode::Invalid => None,
+            _ => nn.expand(turtle).map(RenameKey::Iri),
+        },
+        Term::BlankNode(BlankNode::Named(label, _)) => Some(RenameKey::Blank(label.clone())),
+        Term::Variable(v) => Some(RenameKey::Var(v.0.clone())),
+        _ => None,
+    }
+}
+
+/// The bare text shown to the user in the rename input box for a term.
+fn term_placeholder(term: &Term) -> Option<String> {
+    match term {
+        Term::NamedNode(NamedNode::Full(iri, _)) => Some(iri.clone()),
+        Term::NamedNode(NamedNode::Prefixed { prefix, value, .. }) => {
+            Some(format!("{}:{}", prefix, value))
+        }
+        Term::BlankNode(BlankNode::Named(label, _)) => Some(format!("_:{}", label)),
+        Term::Variable(v) => Some(format!("?{}", v.0)),
+        _ => None,
+    }
+}
+
+/// Visit every term in the model, recursing into collections and the
+/// predicate/object positions of anonymous blank nodes.
+fn walk_terms(turtle: &Turtle, mut f: impl FnMut(&Spanned<Term>)) {
+    fn walk(term: &Spanned<Term>, f: &mut impl FnMut(&Spanned<Term>)) {
+        f(term);
+        match term.value() {
+            Term::Collection(items) => {
+                for item in items {
+                    walk(item, f);
+                }
+            }
+            Term::BlankNode(BlankNode::Unnamed(pos, _, _)) => {
+                for po in pos {
+                    walk_po(po, f);
+                }
+            }
+            _ => {}
+        }
+    }
+    fn walk_po(po: &Spanned<PO>, f: &mut impl FnMut(&Spanned<Term>)) {
+        walk(&po.value().predicate, f);
+        for object in &po.value().object {
+            walk(object, f);
+        }
+    }
+    for triple in &turtle.triples {
+        let triple = triple.value();
+        walk(&triple.subject, &mut f);
+        for po in &triple.po {
+            walk_po(po, &mut f);
+        }
+    }
+}
+
+/// Find the innermost (smallest-span) renameable term containing `offset`,
+/// returning its span, canonical key and placeholder.
+///
+/// Matching is done in priority order so the cursor reliably targets the term it
+/// sits on, even at token boundaries:
+///
+/// 1. a term that *strictly* contains `offset` (`start <= offset < end`);
+/// 2. a term that strictly contains `offset + 1` — this recovers the editor's
+///    cursor when `Backend::adjust_position` has decremented it onto the
+///    *end-boundary* of a preceding token (e.g. the space before an empty
+///    `<>`), which would otherwise wrongly select that preceding token;
+/// 3. as a last resort, a term whose span *ends* exactly at `offset`.
+fn find_renameable_at(
+    turtle: &Turtle,
+    offset: usize,
+) -> Option<(StdRange<usize>, RenameKey, String)> {
+    find_renameable_with(turtle, offset, false)
+        .or_else(|| find_renameable_with(turtle, offset + 1, false))
+        .or_else(|| find_renameable_with(turtle, offset, true))
+}
+
+/// Smallest-span renameable term containing `offset`.  When `inclusive` is
+/// `false` the span is treated as half-open `[start, end)`; when `true` the end
+/// boundary is allowed (`[start, end]`).
+fn find_renameable_with(
+    turtle: &Turtle,
+    offset: usize,
+    inclusive: bool,
+) -> Option<(StdRange<usize>, RenameKey, String)> {
+    let mut best: Option<(StdRange<usize>, RenameKey, String)> = None;
+    walk_terms(turtle, |term| {
+        let span = term.span();
+        let contains = span.start <= offset && (offset < span.end || (inclusive && offset == span.end));
+        if !contains {
+            return;
+        }
+        let value = term.value();
+        let (Some(key), Some(placeholder)) = (term_key(value, turtle), term_placeholder(value))
+        else {
+            return;
+        };
+        let width = span.end - span.start;
+        let is_better = best
+            .as_ref()
+            .map(|(bspan, _, _)| width < bspan.end - bspan.start)
+            .unwrap_or(true);
+        if is_better {
+            best = Some((span.clone(), key, placeholder));
+        }
+    });
+    best
+}
+
+/// Model-based `prepare_rename`: report the range and placeholder of the term
+/// under the cursor.
+pub fn prepare_rename<L>(
+    query: Query<(Entity, &Element<L>, &RopeC, &PositionComponent)>,
+    mut commands: Commands,
+) where
+    L: Lang<Element = Turtle> + Send + Sync + 'static,
+{
+    for (entity, element, rope, position) in &query {
+        commands.entity(entity).remove::<PrepareRenameRequest>();
+
+        let Some(offset) = position_to_offset(position.0, &rope.0) else {
+            continue;
+        };
+        let Some((span, _key, placeholder)) = find_renameable_at(element.value(), offset) else {
+            continue;
+        };
+        let Some(range) = offsets_to_range(span.start, span.end, &rope.0) else {
+            continue;
+        };
+        commands
+            .entity(entity)
+            .insert(PrepareRenameRequest { range, placeholder });
+    }
+}
+
+/// Model-based `rename`: replace every occurrence of the term under the cursor
+/// (matched by canonical key) with the wrapped new text.
+pub fn rename<L>(
+    mut query: Query<(
+        &Element<L>,
+        &RopeC,
+        &Label,
+        &PositionComponent,
+        &DynLang,
+        &mut RenameEdits,
+    )>,
+) where
+    L: Lang<Element = Turtle> + Send + Sync + 'static,
+{
+    for (element, rope, label, position, lang, mut edits) in &mut query {
+        let Some(offset) = position_to_offset(position.0, &rope.0) else {
+            continue;
+        };
+        let turtle = element.value();
+        let Some((_span, key, _placeholder)) = find_renameable_at(turtle, offset) else {
+            continue;
+        };
+        let new_text = lang.0.rename_wrap(&edits.1);
+
+        let mut collected: Vec<TextEdit> = Vec::new();
+        walk_terms(turtle, |term| {
+            if term_key(term.value(), turtle).as_ref() == Some(&key) {
+                if let Some(range) = offsets_to_range(term.span().start, term.span().end, &rope.0) {
+                    collected.push(TextEdit {
+                        range,
+                        new_text: new_text.clone(),
+                    });
+                }
+            }
+        });
+        for edit in collected {
+            edits.0.push((label.0.clone(), edit));
+        }
+    }
+}
+
+/// Register the model-based [`prepare_rename`] and [`rename`] systems for
+/// language `L`.  Call this from a text RDF language's `setup_world`, and make
+/// the language's [`LangHelper::model_based_rename`] return `true` so the core
+/// agnostic rename systems skip its documents.
+pub fn setup_rename<L>(world: &mut World)
+where
+    L: Lang<Element = Turtle> + Send + Sync + 'static,
+{
+    world.schedule_scope(PrepareRename, |_, schedule| {
+        schedule.add_systems(prepare_rename::<L>);
+    });
+    world.schedule_scope(Rename, |_, schedule| {
+        schedule.add_systems(rename::<L>);
+    });
+}
diff --git a/lang-sparql/CHANGELOG.md b/lang-sparql/CHANGELOG.md
index d265a7e943..baad86b970 100644
--- a/lang-sparql/CHANGELOG.md
+++ b/lang-sparql/CHANGELOG.md
@@ -5,6 +5,42 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.5 (2026-06-22)
+
+### New Features
+
+ - <csr-id-ece087810771449d6e3e9badcc21b123af613879/> inline and extract blank nodes
+ - <csr-id-5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1/> add undefined iri's warnings
+ - <csr-id-b55d2807364d9521378e9d5433ee53d3d6bc8109/> prefix diagnostics
+
+### Bug Fixes
+
+ - <csr-id-3604321f63b609c0095e507c094925d0d49894e5/> improve rename robustness
+ - <csr-id-91a3739936dfb66c688d161c5264c997020abc86/> remove unused systems
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 5 commits contributed to the release over the course of 4 calendar days.
+ - 32 days passed between releases.
+ - 5 commits were understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - Improve rename robustness ([`3604321`](https://github.com/SemanticWebLanguageServer/swls/commit/3604321f63b609c0095e507c094925d0d49894e5))
+    - Remove unused systems ([`91a3739`](https://github.com/SemanticWebLanguageServer/swls/commit/91a3739936dfb66c688d161c5264c997020abc86))
+    - Inline and extract blank nodes ([`ece0878`](https://github.com/SemanticWebLanguageServer/swls/commit/ece087810771449d6e3e9badcc21b123af613879))
+    - Add undefined iri's warnings ([`5daeb7f`](https://github.com/SemanticWebLanguageServer/swls/commit/5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1))
+    - Prefix diagnostics ([`b55d280`](https://github.com/SemanticWebLanguageServer/swls/commit/b55d2807364d9521378e9d5433ee53d3d6bc8109))
+</details>
+
 ## 0.1.4 (2026-05-20)
 
 ### New Features
@@ -15,7 +51,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <csr-read-only-do-not-edit/>
 
- - 2 commits contributed to the release.
+ - 3 commits contributed to the release.
  - 19 days passed between releases.
  - 1 commit was understood as [conventional](https://www.conventionalcommits.org).
  - 0 issues like '(#ID)' were seen in commit messages
@@ -27,6 +63,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>
 
  * **Uncategorized**
+    - Release swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`0d1c8c5`](https://github.com/SemanticWebLanguageServer/swls/commit/0d1c8c52d0b7741321109ad22f1f16d53e4f8dc6))
     - Adjusting changelogs prior to release of swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`4f3e731`](https://github.com/SemanticWebLanguageServer/swls/commit/4f3e731b0301e0b689bfe15e790ad4706a3c84e1))
     - Better highlighting ([`9b17ed3`](https://github.com/SemanticWebLanguageServer/swls/commit/9b17ed366f37598da0a9747dc51d552bee891ded))
 </details>
diff --git a/lang-sparql/Cargo.toml b/lang-sparql/Cargo.toml
index 1fdc0a132c..47d68622c6 100644
--- a/lang-sparql/Cargo.toml
+++ b/lang-sparql/Cargo.toml
@@ -4,7 +4,7 @@ name = "swls-lang-sparql"
 description = "SPARQL language support for the Semantic Web Language Server"
 keywords = ["lsp", "semantic-web", "sparql", "rdf", "query"]
 categories = ["development-tools", "parser-implementations"]
-version = "0.1.4"
+version = "0.1.5"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
diff --git a/lang-sparql/src/ecs/mod.rs b/lang-sparql/src/ecs/mod.rs
index 63b5e300f4..30039486c8 100644
--- a/lang-sparql/src/ecs/mod.rs
+++ b/lang-sparql/src/ecs/mod.rs
@@ -15,10 +15,8 @@ use swls_core::{
     components::*,
     lsp_types::CompletionItemKind,
     prelude::*,
-    systems::{prefix::prefix_completion_helper, PrefixEntry},
 };
 use swls_lang_rdf_base::traits::{NamedNodeExt, TurtleExt};
-use swls_lov::LocalPrefix;
 
 use crate::Sparql;
 
@@ -39,7 +37,6 @@ pub fn setup_completion(world: &mut World) {
     use swls_core::feature::completion::*;
     world.schedule_scope(Label, |_, schedule| {
         schedule.add_systems((
-            sparql_lov_undefined_prefix_completion.after(generate_completions),
             variable_completion.after(generate_completions),
         ));
     });
@@ -221,39 +218,3 @@ pub fn variable_completion(
         }
     }
 }
-
-pub fn sparql_lov_undefined_prefix_completion(
-    mut query: Query<(
-        &TokenComponent,
-        &Element<Sparql>,
-        &Prefixes,
-        &mut CompletionRequest,
-        &DynLang,
-    )>,
-    lovs: Query<&LocalPrefix>,
-    prefix_cc: Query<&PrefixEntry>,
-) {
-    for (word, el, prefixes, mut req, lang) in &mut query {
-        let turtle = el.0.value();
-        let mut start = swls_core::lsp_types::Position::new(0, 0);
-        if turtle.base.is_some() {
-            start = swls_core::lsp_types::Position::new(1, 0);
-        }
-
-        use swls_core::lsp_types::Range;
-        prefix_completion_helper(
-            word,
-            prefixes,
-            &mut req.0,
-            |name, location| {
-                Some(vec![swls_core::lsp_types::TextEdit {
-                    range: Range::new(start.clone(), start),
-                    new_text: format!("PREFIX {}: <{}>\n", name, location),
-                }])
-            },
-            lovs.iter(),
-            prefix_cc.iter(),
-            lang,
-        );
-    }
-}
diff --git a/lang-sparql/src/lib.rs b/lang-sparql/src/lib.rs
index df4b8c0182..ee07a4f772 100644
--- a/lang-sparql/src/lib.rs
+++ b/lang-sparql/src/lib.rs
@@ -14,6 +14,8 @@ pub fn setup_world(world: &mut World) {
     register_rdf_lang::<Sparql, SparqlHelper>(world, &["sparql"], &[".sq"]);
     setup_parse(world);
     setup_completion(world);
+    swls_lang_rdf_base::code_actions::setup_blank_node_code_action::<Sparql>(world);
+    swls_lang_rdf_base::rename::setup_rename::<Sparql>(world);
 }
 
 #[derive(Debug, Component, Default)]
@@ -284,4 +286,18 @@ impl LangHelper for SparqlHelper {
     fn supports_shape_validation(&self) -> bool {
         false
     }
+    fn model_based_rename(&self) -> bool {
+        true
+    }
+    fn prefix_keyword(&self) -> &str {
+        "PREFIX"
+    }
+    fn format_prefix_declaration(
+        &self,
+        name: &str,
+        url: &str,
+        _format: swls_core::components::PrefixFormat,
+    ) -> String {
+        format!("PREFIX {}: <{}>\n", name, url)
+    }
 }
diff --git a/lang-trig/CHANGELOG.md b/lang-trig/CHANGELOG.md
index e8b658588a..47fcebda41 100644
--- a/lang-trig/CHANGELOG.md
+++ b/lang-trig/CHANGELOG.md
@@ -5,6 +5,42 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.4 (2026-06-22)
+
+### New Features
+
+ - <csr-id-ece087810771449d6e3e9badcc21b123af613879/> inline and extract blank nodes
+ - <csr-id-5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1/> add undefined iri's warnings
+ - <csr-id-b55d2807364d9521378e9d5433ee53d3d6bc8109/> prefix diagnostics
+
+### Bug Fixes
+
+ - <csr-id-3604321f63b609c0095e507c094925d0d49894e5/> improve rename robustness
+ - <csr-id-91a3739936dfb66c688d161c5264c997020abc86/> remove unused systems
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 5 commits contributed to the release over the course of 4 calendar days.
+ - 32 days passed between releases.
+ - 5 commits were understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - Improve rename robustness ([`3604321`](https://github.com/SemanticWebLanguageServer/swls/commit/3604321f63b609c0095e507c094925d0d49894e5))
+    - Remove unused systems ([`91a3739`](https://github.com/SemanticWebLanguageServer/swls/commit/91a3739936dfb66c688d161c5264c997020abc86))
+    - Inline and extract blank nodes ([`ece0878`](https://github.com/SemanticWebLanguageServer/swls/commit/ece087810771449d6e3e9badcc21b123af613879))
+    - Add undefined iri's warnings ([`5daeb7f`](https://github.com/SemanticWebLanguageServer/swls/commit/5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1))
+    - Prefix diagnostics ([`b55d280`](https://github.com/SemanticWebLanguageServer/swls/commit/b55d2807364d9521378e9d5433ee53d3d6bc8109))
+</details>
+
 ## 0.1.3 (2026-05-20)
 
 ### New Features
@@ -15,7 +51,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <csr-read-only-do-not-edit/>
 
- - 2 commits contributed to the release.
+ - 3 commits contributed to the release.
  - 19 days passed between releases.
  - 1 commit was understood as [conventional](https://www.conventionalcommits.org).
  - 0 issues like '(#ID)' were seen in commit messages
@@ -27,6 +63,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>
 
  * **Uncategorized**
+    - Release swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`0d1c8c5`](https://github.com/SemanticWebLanguageServer/swls/commit/0d1c8c52d0b7741321109ad22f1f16d53e4f8dc6))
     - Adjusting changelogs prior to release of swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`4f3e731`](https://github.com/SemanticWebLanguageServer/swls/commit/4f3e731b0301e0b689bfe15e790ad4706a3c84e1))
     - Better highlighting ([`9b17ed3`](https://github.com/SemanticWebLanguageServer/swls/commit/9b17ed366f37598da0a9747dc51d552bee891ded))
 </details>
diff --git a/lang-trig/Cargo.toml b/lang-trig/Cargo.toml
index 8594c3fac5..624f6169aa 100644
--- a/lang-trig/Cargo.toml
+++ b/lang-trig/Cargo.toml
@@ -4,7 +4,7 @@ name = "swls-lang-trig"
 description = "TriG language support for the Semantic Web Language Server"
 keywords = ["lsp", "semantic-web", "rdf", "trig"]
 categories = ["development-tools", "parser-implementations"]
-version = "0.1.3"
+version = "0.1.4"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
diff --git a/lang-trig/src/ecs/completion.rs b/lang-trig/src/ecs/completion.rs
deleted file mode 100644
index c017d8e0f2..0000000000
--- a/lang-trig/src/ecs/completion.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use bevy_ecs::prelude::*;
-use completion::CompletionRequest;
-use swls_core::{
-    components::*,
-    prelude::*,
-    systems::{prefix::prefix_completion_helper, PrefixEntry},
-};
-use swls_lov::LocalPrefix;
-
-use crate::TriGLang;
-
-pub fn trig_lov_undefined_prefix_completion(
-    mut query: Query<(
-        &TokenComponent,
-        &Element<TriGLang>,
-        &Prefixes,
-        &mut CompletionRequest,
-        &DynLang,
-    )>,
-    lovs: Query<&LocalPrefix>,
-    prefix_cc: Query<&PrefixEntry>,
-) {
-    for (word, turtle, prefixes, mut req, lang) in &mut query {
-        let mut start = swls_core::lsp_types::Position::new(0, 0);
-
-        if turtle.base.is_some() {
-            start = swls_core::lsp_types::Position::new(1, 0);
-        }
-
-        use swls_core::lsp_types::Range;
-        prefix_completion_helper(
-            word,
-            prefixes,
-            &mut req.0,
-            |name, location| {
-                if prefixes.iter().any(|p| p.prefix == name) {
-                    None
-                } else {
-                    Some(vec![swls_core::lsp_types::TextEdit {
-                        range: Range::new(start.clone(), start),
-                        new_text: format!("@prefix {}: <{}>.\n", name, location),
-                    }])
-                }
-            },
-            lovs.iter(),
-            prefix_cc.iter(),
-            lang,
-        );
-    }
-}
diff --git a/lang-trig/src/ecs/mod.rs b/lang-trig/src/ecs/mod.rs
index 044173e227..8fbd31fd9c 100644
--- a/lang-trig/src/ecs/mod.rs
+++ b/lang-trig/src/ecs/mod.rs
@@ -4,20 +4,19 @@ use bevy_ecs::prelude::*;
 use rdf_parsers::{IncrementalBias, PrevParseInfo};
 use rowan::{GreenNode, NodeOrToken};
 use swls_core::prelude::*;
-use swls_lang_rdf_base::traits::NamedNodeExt;
 use swls_lang_turtle::{ecs::parse::derive_triples_system, lang::parser::TurtleParseError};
 use tracing::instrument;
 
 use crate::TriGLang;
 
-pub mod completion;
-
 pub fn setup_parsing(world: &mut World) {
     use swls_core::feature::parse::*;
     world.schedule_scope(ParseLabel, |_, schedule| {
         schedule.add_systems((
             parse_trig_system,
-            derive_prefixes.after(parse_trig_system).before(prefixes),
+            swls_lang_rdf_base::parse::derive_prefixes_system::<TriGLang>
+                .after(parse_trig_system)
+                .before(prefixes),
             derive_triples_system::<TriGLang>
                 .after(parse_trig_system)
                 .before(triples),
@@ -25,14 +24,6 @@ pub fn setup_parsing(world: &mut World) {
     });
 }
 
-pub fn setup_completion(world: &mut World) {
-    use swls_core::feature::completion::*;
-    world.schedule_scope(Label, |_, schedule| {
-        schedule.add_systems(
-            completion::trig_lov_undefined_prefix_completion.after(generate_completions),
-        );
-    });
-}
 
 fn extract_trig_cst_tokens(
     node: &rowan::SyntaxNode<rdf_parsers::trig::parser::Lang>,
@@ -151,40 +142,6 @@ fn parse_trig_system(
     }
 }
 
-#[instrument(skip(query, commands))]
-fn derive_prefixes(
-    query: Query<(Entity, &Label, &Element<TriGLang>), Changed<Element<TriGLang>>>,
-    mut commands: Commands,
-) {
-    for (entity, url, turtle) in &query {
-        let prefixes: Vec<_> = turtle
-            .prefixes
-            .iter()
-            .flat_map(|prefix| {
-                let url = prefix.value.value().expand(turtle.value())?;
-                let url = swls_core::lsp_types::Url::parse(&url).ok()?;
-                Some(Prefix {
-                    url,
-                    prefix: prefix.prefix.value().clone(),
-                })
-            })
-            .collect();
-
-        let base = turtle
-            .base
-            .as_ref()
-            .and_then(|b| {
-                b.0 .1
-                    .value()
-                    .expand(turtle.value())
-                    .and_then(|x| swls_core::lsp_types::Url::parse(&x).ok())
-            })
-            .unwrap_or(url.0.clone());
-
-        commands.entity(entity).insert(Prefixes(prefixes, base));
-    }
-}
-
 pub(crate) fn format_trig_system(
     mut query: Query<(&RopeC, &Wrapped<GreenNode>, &mut FormatRequest), With<TriGLang>>,
 ) {
diff --git a/lang-trig/src/lib.rs b/lang-trig/src/lib.rs
index 290f47378a..bab3547c66 100644
--- a/lang-trig/src/lib.rs
+++ b/lang-trig/src/lib.rs
@@ -8,7 +8,7 @@ use swls_lang_rdf_base::register_rdf_lang;
 use swls_lang_turtle::lang::parser::TurtleParseError;
 
 pub mod ecs;
-use crate::ecs::{format_trig_system, setup_completion, setup_parsing};
+use crate::ecs::{format_trig_system, setup_parsing};
 
 #[derive(Component, Default)]
 pub struct TriGLang;
@@ -20,12 +20,16 @@ impl LangHelper for TriGHelper {
     fn keyword(&self) -> &[&'static str] {
         &["@prefix", "@base", "a", "GRAPH"]
     }
+    fn model_based_rename(&self) -> bool {
+        true
+    }
 }
 
 pub fn setup_world<C: Client + ClientSync + Resource + Clone>(world: &mut World) {
     register_rdf_lang::<TriGLang, TriGHelper>(world, &["trig"], &[".trig"]);
     setup_parsing(world);
-    setup_completion(world);
+    swls_lang_rdf_base::code_actions::setup_blank_node_code_action::<TriGLang>(world);
+    swls_lang_rdf_base::rename::setup_rename::<TriGLang>(world);
 
     world.schedule_scope(FormatLabel, |_, schedule| {
         schedule.add_systems(format_trig_system);
diff --git a/lang-turtle/CHANGELOG.md b/lang-turtle/CHANGELOG.md
index 72ef5834d4..1342a2737b 100644
--- a/lang-turtle/CHANGELOG.md
+++ b/lang-turtle/CHANGELOG.md
@@ -5,6 +5,51 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.4 (2026-06-22)
+
+### New Features
+
+ - <csr-id-bb4f08bed28af56f776d32f787a459c7325ec47e/> gate features with configuration
+ - <csr-id-ece087810771449d6e3e9badcc21b123af613879/> inline and extract blank nodes
+ - <csr-id-5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1/> add undefined iri's warnings
+ - <csr-id-b55d2807364d9521378e9d5433ee53d3d6bc8109/> prefix diagnostics
+
+### Bug Fixes
+
+ - <csr-id-3604321f63b609c0095e507c094925d0d49894e5/> improve rename robustness
+ - <csr-id-91a3739936dfb66c688d161c5264c997020abc86/> remove unused systems
+ - <csr-id-e52d0f65cef812ffeab54b7d110045ce4c74f741/> diagnostics after on change things works way better
+
+### Other
+
+ - <csr-id-057b9578e70b48ff01d1901700bb4a836db76327/> fix tests
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 8 commits contributed to the release over the course of 4 calendar days.
+ - 52 days passed between releases.
+ - 8 commits were understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - Gate features with configuration ([`bb4f08b`](https://github.com/SemanticWebLanguageServer/swls/commit/bb4f08bed28af56f776d32f787a459c7325ec47e))
+    - Fix tests ([`057b957`](https://github.com/SemanticWebLanguageServer/swls/commit/057b9578e70b48ff01d1901700bb4a836db76327))
+    - Improve rename robustness ([`3604321`](https://github.com/SemanticWebLanguageServer/swls/commit/3604321f63b609c0095e507c094925d0d49894e5))
+    - Remove unused systems ([`91a3739`](https://github.com/SemanticWebLanguageServer/swls/commit/91a3739936dfb66c688d161c5264c997020abc86))
+    - Inline and extract blank nodes ([`ece0878`](https://github.com/SemanticWebLanguageServer/swls/commit/ece087810771449d6e3e9badcc21b123af613879))
+    - Add undefined iri's warnings ([`5daeb7f`](https://github.com/SemanticWebLanguageServer/swls/commit/5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1))
+    - Diagnostics after on change things works way better ([`e52d0f6`](https://github.com/SemanticWebLanguageServer/swls/commit/e52d0f65cef812ffeab54b7d110045ce4c74f741))
+    - Prefix diagnostics ([`b55d280`](https://github.com/SemanticWebLanguageServer/swls/commit/b55d2807364d9521378e9d5433ee53d3d6bc8109))
+</details>
+
 ## 0.1.3 (2026-04-30)
 
 ### Documentation
@@ -20,7 +65,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <csr-read-only-do-not-edit/>
 
- - 4 commits contributed to the release.
+ - 5 commits contributed to the release.
  - 3 commits were understood as [conventional](https://www.conventionalcommits.org).
  - 0 issues like '(#ID)' were seen in commit messages
 
@@ -31,6 +76,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>
 
  * **Uncategorized**
+    - Release swls-lov v0.1.2, swls-core v0.1.2, swls-lang-rdf-base v0.1.2, swls-lang-turtle v0.1.3, swls-lang-jsonld v0.1.3, swls-lang-sparql v0.1.3, swls-lang-trig v0.1.2, swls v0.2.0 ([`bfde48f`](https://github.com/SemanticWebLanguageServer/swls/commit/bfde48f836e70a9b3f08230e2d84c957eb5a72b0))
     - Release swls-lov v0.1.2, swls-core v0.1.2, swls-lang-rdf-base v0.1.2, swls-lang-turtle v0.1.3, swls-lang-jsonld v0.1.3, swls-lang-sparql v0.1.3, swls-lang-trig v0.1.2, swls v0.2.0 ([`eb52296`](https://github.com/SemanticWebLanguageServer/swls/commit/eb52296d24ca7c04061acc584a3423b4213cb2ee))
     - Point crates to main readme + update readme ([`682af7b`](https://github.com/SemanticWebLanguageServer/swls/commit/682af7ba71d4e99d0f9516494fcd7ef552232f4d))
     - Allow jsonld to show inlayed types in a json-ld manner ([`2056a5f`](https://github.com/SemanticWebLanguageServer/swls/commit/2056a5f93ff4467478a4a72bf3f0c4c6691f78b0))
diff --git a/lang-turtle/Cargo.toml b/lang-turtle/Cargo.toml
index d553128aaa..8f8685d9f3 100644
--- a/lang-turtle/Cargo.toml
+++ b/lang-turtle/Cargo.toml
@@ -4,7 +4,7 @@ name = "swls-lang-turtle"
 description = "Turtle/TriG language support for the Semantic Web Language Server"
 keywords = ["lsp", "semantic-web", "rdf", "turtle", "trig"]
 categories = ["development-tools", "parser-implementations"]
-version = "0.1.3"
+version = "0.1.4"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
diff --git a/lang-turtle/src/ecs/code_action.rs b/lang-turtle/src/ecs/code_action.rs
index ca50b85e9a..b01b1efa67 100644
--- a/lang-turtle/src/ecs/code_action.rs
+++ b/lang-turtle/src/ecs/code_action.rs
@@ -5,6 +5,7 @@ use swls_core::{
     feature::code_action::CodeActionRequest,
     lsp_types::{CodeAction, CodeActionKind, TextEdit, WorkspaceEdit},
     prelude::*,
+    util::offset_to_position,
 };
 use swls_lang_rdf_base::traits::NamedNodeExt as _;
 
@@ -12,7 +13,11 @@ use crate::TurtleLang;
 
 pub fn organize_imports(
     mut query: Query<(&Element<TurtleLang>, &RopeC, &Label, &mut CodeActionRequest)>,
+    config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::CodeActionOrganizeImports) {
+        return;
+    }
     for (turtle, rope, label, mut req) in &mut query {
         let prefixes = &turtle.prefixes;
         if prefixes.len() < 2 {
diff --git a/lang-turtle/src/ecs/completion.rs b/lang-turtle/src/ecs/completion.rs
index b6e8457d62..4e988512f1 100644
--- a/lang-turtle/src/ecs/completion.rs
+++ b/lang-turtle/src/ecs/completion.rs
@@ -4,55 +4,13 @@ use swls_core::{
     components::*,
     lsp_types::CompletionItemKind,
     prelude::*,
-    systems::{prefix::prefix_completion_helper, PrefixEntry},
     util::triple::{MyQuad, MyTerm, TripleComponent, TripleTarget},
 };
-use swls_lov::LocalPrefix;
 use tracing::debug;
 
 use crate::TurtleLang;
 use swls_lang_rdf_base::traits::{NamedNodeExt, TurtleExt};
 
-pub fn turtle_lov_undefined_prefix_completion(
-    mut query: Query<(
-        &TokenComponent,
-        &Element<TurtleLang>,
-        &Prefixes,
-        &mut CompletionRequest,
-        &DynLang,
-    )>,
-    lovs: Query<&LocalPrefix>,
-    prefix_cc: Query<&PrefixEntry>,
-) {
-    for (word, turtle, prefixes, mut req, lang) in &mut query {
-        let mut start = swls_core::lsp_types::Position::new(0, 0);
-
-        if turtle.base.is_some() {
-            start = swls_core::lsp_types::Position::new(1, 0);
-        }
-
-        use swls_core::lsp_types::Range;
-        prefix_completion_helper(
-            word,
-            prefixes,
-            &mut req.0,
-            |name, location| {
-                if prefixes.iter().any(|p| p.prefix == name) {
-                    None
-                } else {
-                    Some(vec![swls_core::lsp_types::TextEdit {
-                        range: Range::new(start.clone(), start),
-                        new_text: format!("@prefix {}: <{}>.\n", name, location),
-                    }])
-                }
-            },
-            lovs.iter(),
-            prefix_cc.iter(),
-            lang,
-        );
-    }
-}
-
 pub fn subject_completion(
     mut query: Query<(
         &TokenComponent,
@@ -61,7 +19,11 @@ pub fn subject_completion(
         &mut CompletionRequest,
     )>,
     triples: Query<(&Triples, &Label), With<Open>>,
+    config: Res<ServerConfig>,
 ) {
+    if config.config.local.is_disabled(Disabled::CompletionSubject) {
+        return;
+    }
     for (word, turtle, prefixes, mut req) in &mut query {
         // Only attempt subject completion when the text looks like a prefixed name.
         let text = &word.text;
diff --git a/lang-turtle/src/ecs/mod.rs b/lang-turtle/src/ecs/mod.rs
index 803fa81d4e..789df44cf8 100644
--- a/lang-turtle/src/ecs/mod.rs
+++ b/lang-turtle/src/ecs/mod.rs
@@ -1,12 +1,9 @@
-use bevy_ecs::{prelude::*, system::Query, world::World};
-use completion::{
-    infer_predicate_position_from_cst, subject_completion, turtle_lov_undefined_prefix_completion,
-};
+use bevy_ecs::{prelude::*, world::World};
+use completion::{infer_predicate_position_from_cst, subject_completion};
 use format::format_turtle_system;
 use swls_core::prelude::*;
 
 use crate::TurtleLang;
-use swls_lang_rdf_base::traits::NamedNodeExt;
 
 mod code_action;
 mod completion;
@@ -18,7 +15,7 @@ pub fn setup_parsing(world: &mut World) {
     world.schedule_scope(ParseLabel, |_, schedule| {
         schedule.add_systems((
             parse::parse_turtle_system,
-            derive_prefixes
+            swls_lang_rdf_base::parse::derive_prefixes_system::<TurtleLang>
                 .after(parse::parse_turtle_system)
                 .before(prefixes),
             parse::derive_triples_system::<TurtleLang>
@@ -39,52 +36,19 @@ pub fn setup_code_action(world: &mut World) {
     world.schedule_scope(CodeActionLabel, |_, schedule| {
         schedule.add_systems(code_action::organize_imports);
     });
+    swls_lang_rdf_base::code_actions::setup_blank_node_code_action::<crate::TurtleLang>(world);
 }
 
 pub fn setup_completion(world: &mut World) {
     use swls_core::feature::completion::*;
     world.schedule_scope(CompletionLabel, |_, schedule| {
         schedule.add_systems((
-            turtle_lov_undefined_prefix_completion.after(generate_completions),
             subject_completion.after(generate_completions),
             infer_predicate_position_from_cst.after(generate_completions),
         ));
     });
 }
 
-fn derive_prefixes(
-    query: Query<(Entity, &Label, &Element<TurtleLang>), Changed<Element<TurtleLang>>>,
-    mut commands: Commands,
-) {
-    for (entity, url, turtle) in &query {
-        let prefixes: Vec<_> = turtle
-            .prefixes
-            .iter()
-            .flat_map(|prefix| {
-                let url = prefix.value.value().expand(turtle.value())?;
-                let url = swls_core::lsp_types::Url::parse(&url).ok()?;
-                Some(Prefix {
-                    url,
-                    prefix: prefix.prefix.value().clone(),
-                })
-            })
-            .collect();
-
-        let base = turtle
-            .base
-            .as_ref()
-            .and_then(|b| {
-                b.0 .1
-                    .value()
-                    .expand(turtle.value())
-                    .and_then(|x| swls_core::lsp_types::Url::parse(&x).ok())
-            })
-            .unwrap_or(url.0.clone());
-
-        commands.entity(entity).insert(Prefixes(prefixes, base));
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use futures::executor::block_on;
@@ -119,7 +83,6 @@ mod tests {
 
         let entity = create_file(&mut world, t2, "http://example.com/ns#", "turtle", Open);
         world.run_schedule(ParseLabel);
-        world.run_schedule(DiagnosticsLabel);
 
         // t2: foaf IS used (foaf:foaf is a subject), but it's missing predicate+object → syntax errors
         let diags = last_diags();
@@ -133,7 +96,6 @@ mod tests {
             .entity_mut(entity)
             .insert((Source(t3.to_string()), RopeC(Rope::from_str(t3))));
         world.run_schedule(ParseLabel);
-        world.run_schedule(DiagnosticsLabel);
 
         let diags = last_diags();
         assert!(
diff --git a/lang-turtle/src/lang/model.rs b/lang-turtle/src/lang/model.rs
index 45ec77c995..9b8f7f6789 100644
--- a/lang-turtle/src/lang/model.rs
+++ b/lang-turtle/src/lang/model.rs
@@ -1,8 +1,5 @@
 #[cfg(test)]
 mod test {
-    use std::collections::HashSet;
-
-    use swls_core::prelude::MyQuad;
     use swls_lang_rdf_base::traits::{Turtle, TurtleExt};
 
     fn parse_turtle(inp: &str, base_url: &str) -> Turtle {
@@ -51,38 +48,6 @@ mod test {
         assert_eq!(triples.triples.len(), 6);
     }
 
-    #[test]
-    fn triples_collection() {
-        let txt = r#"
-<e> <pred> (<a> <b> <c>).
-"#;
-        let output = parse_turtle(txt, "http://example.com/");
-        let triples = output
-            .get_simple_triples()
-            .expect("Triples found collection");
-        let a: &Vec<MyQuad<'_>> = &triples;
-        let quads: HashSet<String> = a
-            .iter()
-            .map(|triple| format!("{} {} {}.", triple.subject, triple.predicate, triple.object))
-            .collect();
-
-        let expected_quads: HashSet<String> = [
-            "<http://example.com/e> <http://example.com/pred> _:internal_bnode_3.",
-            "_:internal_bnode_3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:internal_bnode_2.",
-            "_:internal_bnode_3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/a>.",
-            "_:internal_bnode_2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:internal_bnode_1.",
-            "_:internal_bnode_2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/b>.",
-            "_:internal_bnode_1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil>.",
-            "_:internal_bnode_1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/c>.",
-        ].iter().map(|x| x.trim().to_string()).collect();
-
-        for t in &quads {
-            println!("{}", t);
-        }
-        assert_eq!(quads, expected_quads);
-        assert_eq!(triples.triples.len(), 7);
-    }
-
     #[test]
     fn triple_spans_are_correct() {
         // "@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n<> foaf:name \"Arthur\"."
diff --git a/lang-turtle/src/lib.rs b/lang-turtle/src/lib.rs
index 3e09c065bc..c53e776439 100644
--- a/lang-turtle/src/lib.rs
+++ b/lang-turtle/src/lib.rs
@@ -29,6 +29,9 @@ impl LangHelper for TurtleHelper {
     fn keyword(&self) -> &[&'static str] {
         &["@prefix", "@base", "a"]
     }
+    fn model_based_rename(&self) -> bool {
+        true
+    }
 }
 
 pub fn setup_world<C: Client + ClientSync + Resource + Clone>(world: &mut World) {
@@ -45,6 +48,7 @@ pub fn setup_world<C: Client + ClientSync + Resource + Clone>(world: &mut World)
     setup_completion(world);
     setup_formatting(world);
     setup_code_action(world);
+    swls_lang_rdf_base::rename::setup_rename::<TurtleLang>(world);
 }
 
 impl Lang for TurtleLang {
diff --git a/swls/CHANGELOG.md b/swls/CHANGELOG.md
index edb7c84518..ba9ef668b4 100644
--- a/swls/CHANGELOG.md
+++ b/swls/CHANGELOG.md
@@ -5,6 +5,37 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.3.0 (2026-06-22)
+
+### New Features
+
+ - <csr-id-4bad0c7033f9029315e831d5801922f959a64165/> add automatic insert of prefix statements when writing colon
+ - <csr-id-5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1/> add undefined iri's warnings
+ - <csr-id-a066345ac46f16e951eea8ff3439761d1d261459/> actually add swls/src/server.rs
+ - <csr-id-91c1ad0150e44713d3589bb264d704a4656e4a8a/> move tower_lsp to swls binary
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 4 commits contributed to the release over the course of 9 calendar days.
+ - 32 days passed between releases.
+ - 4 commits were understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - Add automatic insert of prefix statements when writing colon ([`4bad0c7`](https://github.com/SemanticWebLanguageServer/swls/commit/4bad0c7033f9029315e831d5801922f959a64165))
+    - Add undefined iri's warnings ([`5daeb7f`](https://github.com/SemanticWebLanguageServer/swls/commit/5daeb7fab3c033983ddb34cb6c0518eafcd0cbc1))
+    - Actually add swls/src/server.rs ([`a066345`](https://github.com/SemanticWebLanguageServer/swls/commit/a066345ac46f16e951eea8ff3439761d1d261459))
+    - Move tower_lsp to swls binary ([`91c1ad0`](https://github.com/SemanticWebLanguageServer/swls/commit/91c1ad0150e44713d3589bb264d704a4656e4a8a))
+</details>
+
 ## 0.2.2 (2026-05-20)
 
 ### New Features
@@ -21,7 +52,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <csr-read-only-do-not-edit/>
 
- - 1 commit contributed to the release.
+ - 2 commits contributed to the release.
  - 9 days passed between releases.
  - 0 commits were understood as [conventional](https://www.conventionalcommits.org).
  - 0 issues like '(#ID)' were seen in commit messages
@@ -33,6 +64,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>
 
  * **Uncategorized**
+    - Release swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`0d1c8c5`](https://github.com/SemanticWebLanguageServer/swls/commit/0d1c8c52d0b7741321109ad22f1f16d53e4f8dc6))
     - Adjusting changelogs prior to release of swls-core v0.1.3, swls-lang-rdf-base v0.1.3, swls-lang-jsonld v0.1.5, swls-lang-sparql v0.1.4, swls-lang-trig v0.1.3, swls v0.2.2 ([`4f3e731`](https://github.com/SemanticWebLanguageServer/swls/commit/4f3e731b0301e0b689bfe15e790ad4706a3c84e1))
 </details>
 
diff --git a/swls/Cargo.toml b/swls/Cargo.toml
index dcd0840e52..4a31fd6b96 100644
--- a/swls/Cargo.toml
+++ b/swls/Cargo.toml
@@ -4,7 +4,7 @@ name = "swls"
 description = "Semantic Web Language Server — LSP server for Turtle, SPARQL, JSON-LD, and SHACL"
 keywords = ["lsp", "semantic-web", "rdf", "sparql", "turtle"]
 categories = ["development-tools", "command-line-utilities"]
-version = "0.2.2"
+version = "0.3.0"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
diff --git a/swls/src/lib.rs b/swls/src/lib.rs
index 41e51667c5..4627b72622 100644
--- a/swls/src/lib.rs
+++ b/swls/src/lib.rs
@@ -5,6 +5,7 @@
 use std::ops::Range;
 
 pub mod client;
+pub mod server;
 pub mod timings;
 pub use client::TowerClient;
 
diff --git a/swls/src/main.rs b/swls/src/main.rs
index 9537033982..fb65cbe5d5 100644
--- a/swls/src/main.rs
+++ b/swls/src/main.rs
@@ -4,6 +4,7 @@ use bevy_ecs::{resource::Resource, world::World};
 use futures::{channel::mpsc::unbounded, StreamExt as _};
 use swls::{
     client::{BinFs, Job},
+    server::LspBackend,
     timings, TowerClient,
 };
 use swls_core::{
@@ -163,8 +164,9 @@ async fn main() {
                     }
                 });
 
-                let (sender, rt) = setup_world(TowerClient::new(client.clone(), job_tx));
-                Backend::new(sender, client, rt)
+                let tower_client = TowerClient::new(client.clone(), job_tx);
+                let (sender, tokens) = setup_world(tower_client.clone());
+                LspBackend::new(sender, tower_client, tokens)
             })
             .finish();
 
diff --git a/swls/src/server.rs b/swls/src/server.rs
new file mode 100644
index 0000000000..9e7e7286d1
--- /dev/null
+++ b/swls/src/server.rs
@@ -0,0 +1,151 @@
+//! `tower_lsp` front-end for the transport-agnostic [`Backend`].
+//!
+//! Since the `feat: move tower_lsp to swls binary` change, `swls-core` no longer
+//! depends on any transport crate: [`Backend`] exposes plain inherent `async`
+//! handlers that return a [`swls_core::backend::Result`]. This module adapts those
+//! handlers to [`tower_lsp::LanguageServer`] by delegating each trait method to its
+//! `Backend` counterpart.
+//!
+//! The adapter is intentionally mechanical — it adds no behaviour, only wiring.
+
+use swls_core::backend::Backend;
+use swls_core::prelude::CommandSender;
+use tower_lsp::jsonrpc::Result;
+use tower_lsp::lsp_types::request::{GotoTypeDefinitionParams, GotoTypeDefinitionResponse};
+use tower_lsp::lsp_types::*;
+use tower_lsp::LanguageServer;
+
+use crate::client::TowerClient;
+
+/// `tower_lsp` adapter around [`Backend`] driven by a [`TowerClient`].
+#[derive(Debug)]
+pub struct LspBackend {
+    backend: Backend<TowerClient>,
+}
+
+impl LspBackend {
+    pub fn new(
+        sender: CommandSender,
+        client: TowerClient,
+        tokens: Vec<SemanticTokenType>,
+    ) -> Self {
+        Self {
+            backend: Backend::new(sender, client, tokens),
+        }
+    }
+}
+
+/// Lift a [`Backend`] result into a `tower_lsp` JSON-RPC result.
+///
+/// [`swls_core::backend::ServerError`] is uninhabited, so the error arm is
+/// statically unreachable; the empty `match` discharges it for any target type.
+fn lift<T>(result: swls_core::backend::Result<T>) -> Result<T> {
+    match result {
+        Ok(value) => Ok(value),
+        Err(err) => match err {},
+    }
+}
+
+#[tower_lsp::async_trait]
+impl LanguageServer for LspBackend {
+    async fn initialize(&self, params: InitializeParams) -> Result<InitializeResult> {
+        lift(self.backend.initialize(params).await)
+    }
+
+    async fn initialized(&self, params: InitializedParams) {
+        self.backend.initialized(params).await;
+    }
+
+    async fn shutdown(&self) -> Result<()> {
+        lift(self.backend.shutdown().await)
+    }
+
+    async fn did_change_workspace_folders(&self, params: DidChangeWorkspaceFoldersParams) {
+        self.backend.did_change_workspace_folders(params).await;
+    }
+
+    async fn did_open(&self, params: DidOpenTextDocumentParams) {
+        self.backend.did_open(params).await;
+    }
+
+    async fn did_change(&self, params: DidChangeTextDocumentParams) {
+        self.backend.did_change(params).await;
+    }
+
+    async fn did_save(&self, params: DidSaveTextDocumentParams) {
+        self.backend.did_save(params).await;
+    }
+
+    async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
+        lift(self.backend.completion(params).await)
+    }
+
+    async fn hover(&self, params: HoverParams) -> Result<Option<Hover>> {
+        lift(self.backend.hover(params).await)
+    }
+
+    async fn formatting(
+        &self,
+        params: DocumentFormattingParams,
+    ) -> Result<Option<Vec<TextEdit>>> {
+        lift(self.backend.formatting(params).await)
+    }
+
+    async fn on_type_formatting(
+        &self,
+        params: DocumentOnTypeFormattingParams,
+    ) -> Result<Option<Vec<TextEdit>>> {
+        lift(self.backend.on_type_formatting(params).await)
+    }
+
+    async fn inlay_hint(&self, params: InlayHintParams) -> Result<Option<Vec<InlayHint>>> {
+        lift(self.backend.inlay_hint(params).await)
+    }
+
+    async fn semantic_tokens_full(
+        &self,
+        params: SemanticTokensParams,
+    ) -> Result<Option<SemanticTokensResult>> {
+        lift(self.backend.semantic_tokens_full(params).await)
+    }
+
+    async fn references(&self, params: ReferenceParams) -> Result<Option<Vec<Location>>> {
+        lift(self.backend.references(params).await)
+    }
+
+    async fn prepare_rename(
+        &self,
+        params: TextDocumentPositionParams,
+    ) -> Result<Option<PrepareRenameResponse>> {
+        lift(self.backend.prepare_rename(params).await)
+    }
+
+    async fn rename(&self, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
+        lift(self.backend.rename(params).await)
+    }
+
+    async fn goto_definition(
+        &self,
+        params: GotoDefinitionParams,
+    ) -> Result<Option<GotoDefinitionResponse>> {
+        lift(self.backend.goto_definition(params).await)
+    }
+
+    async fn goto_type_definition(
+        &self,
+        params: GotoTypeDefinitionParams,
+    ) -> Result<Option<GotoTypeDefinitionResponse>> {
+        lift(self.backend.goto_type_definition(params).await)
+    }
+
+    async fn code_action(&self, params: CodeActionParams) -> Result<Option<CodeActionResponse>> {
+        lift(self.backend.code_action(params).await)
+    }
+
+    async fn execute_command(
+        &self,
+        params: ExecuteCommandParams,
+    ) -> Result<Option<serde_json::Value>> {
+        lift(self.backend.execute_command(params).await)
+    }
+}
diff --git a/test-utils/Cargo.toml b/test-utils/Cargo.toml
index 0a8d116a0c..403374d2a5 100644
--- a/test-utils/Cargo.toml
+++ b/test-utils/Cargo.toml
@@ -18,7 +18,7 @@ futures.workspace      = true
 ropey.workspace        = true
 serde_json.workspace   = true
 sophia_api.workspace   = true
-tower-lsp.workspace    = true
+async-trait.workspace  = true
 tracing.workspace      = true
 
 async-executor = "1.13.3"
diff --git a/test-utils/src/lib.rs b/test-utils/src/lib.rs
index 713b5afa9f..94610f1b2e 100644
--- a/test-utils/src/lib.rs
+++ b/test-utils/src/lib.rs
@@ -82,7 +82,7 @@ impl TestClient {
 }
 
 use swls_core::lsp_types::request::Request;
-#[tower_lsp::async_trait]
+#[async_trait::async_trait]
 impl Client for TestClient {
     async fn log_message<M: Display + Sync + Send + 'static>(&self, ty: MessageType, msg: M) -> () {
         let mut lock = self.logs.lock().await;
@@ -193,7 +193,7 @@ impl TestFs {
     pub async fn empty(&self) {}
 }
 
-#[tower_lsp::async_trait]
+#[async_trait::async_trait]
 impl FsTrait for TestFs {
     fn virtual_url(&self, url: &str) -> Option<swls_core::lsp_types::Url> {
         let mut pb = self.0.clone();