diff --git a/README.md b/README.md
index 3220c59..295888b 100644
--- a/README.md
+++ b/README.md
@@ -18,8 +18,9 @@ The whole project is published to GitHub Pages as a single unified single-page a
 | [Entities](https://link-assistant.github.io/human-language/app.html#mode=entity) | Browse any Wikidata Q-id, with IPA toggle and an inline test runner. | [`js/src/app/modes/entity.jsx`](js/src/app/modes/entity.jsx) |
 | [Properties](https://link-assistant.github.io/human-language/app.html#mode=property) | Same lens as Entities but for P-ids. | [`js/src/app/modes/property.jsx`](js/src/app/modes/property.jsx) |
 | [Text → Q/P Transformer](https://link-assistant.github.io/human-language/app.html#mode=transformer) | Turn English text into a sequence of Wikidata entities (Q) and properties (P), with n-gram support. | [`js/src/app/modes/transformer.jsx`](js/src/app/modes/transformer.jsx) |
+| [Q/P → Text Generation](https://link-assistant.github.io/human-language/app.html#mode=generation) | The reverse direction: render a typed constructor (subject · predicate · object, or a subject · value · unit measurement, with negation, tense, Romance gender agreement and Russian prepositional case) into sentences across the six official UN languages. | [`js/src/app/modes/generation.jsx`](js/src/app/modes/generation.jsx) |
 
-The legacy URLs (`entities.html`, `properties.html`, `transformation/index.html`, and bare hashes like `entities.html#Q35120`) still work — they now redirect into the unified SPA preserving any parameters.
+The legacy URLs (`entities.html`, `properties.html`, `transformation/index.html`, `generation/index.html`, and bare hashes like `entities.html#Q35120`) still work — they now redirect into the unified SPA preserving any parameters.
 
 ### Internal pages (for contributors)
 
@@ -62,28 +63,36 @@ This project will fundamentally transform how we store, access, and verify human
 - **Real-time transformation**: Interactive web demo at `transformation/index.html`
 - [Learn more →](transformation/README.md)
 
-### 2. Entity & Property Viewer
+### 2. Q/P-to-Text Generation (reverse renderer)
+- **Closes the round-trip**: the reverse of the transformer — typed meaning → natural-language text
+- **Abstract-Wikipedia-style constructors**: typed containers (`instance_of`, `located_in`, `relation`, `quantity`) with named roles — including a `quantity` measurement constructor (`subject` · `value` · `unit`) mirroring a Wikidata quantity claim
+- **Multi-language rendering**: one templatic renderer per constructor-per-language across the six official UN languages (en, ar, es, fr, ru, zh)
+- **Grammatical features**: negation, tense, English `a`/`an` indefinite-article phonotactics, Romance gender agreement (es `un`/`una`, fr `un`/`une`), and Russian prepositional-case inflection for the locative object (Германия → Германии)
+- **Offline-friendly**: role values may be Wikidata ids (resolved to labels) or plain text (rendered verbatim, no network)
+- Interactive web demo at `app.html#mode=generation`; library entry point [`human-language/generate`](js/src/generation/qp-to-text.js)
+
+### 3. Entity & Property Viewer
 - **Beautiful UI**: Modern, responsive interface with dark/light themes
 - **Multi-language support**: Automatic language detection and switching
 - **Rich statements display**: View all properties and relationships
 - **Direct Wikidata links**: Seamlessly navigate to source data
 - View entities at `entities.html` and properties at `properties.html`
 
-### 3. Advanced Search & Disambiguation
+### 4. Advanced Search & Disambiguation
 - **Exact & fuzzy matching**: Find entities even with typos
 - **Context-aware ranking**: Domain and type preferences
 - **Batch searching**: Efficient parallel searches
 - **Multi-language search**: Search in any supported language
 - [API Documentation →](SEARCH_README.md)
 
-### 4. Intelligent Caching System
+### 5. Intelligent Caching System
 - **Multi-tier caching**: File system (Node.js) and IndexedDB (browser)
 - **Automatic fallback**: Seamless switching between cache types
 - **Performance optimized**: Reduces API calls and improves response times
 - **Cross-platform**: Works in both Node.js and browser environments
 - **Persistent storage**: Cached data survives across sessions
 
-### 5. Comprehensive Language Support
+### 6. Comprehensive Language Support
 - **100+ languages**: Full support for all major Wikidata languages
 - **Locale-specific quotes**: Proper quotation marks for each language
 - **Flag emojis**: Visual language indicators for better UX
@@ -179,18 +188,25 @@ Based on our [GitHub issues](https://github.com/link-assistant/human-language/is
    - N-gram generation and matching
    - Parallel search execution
    - Priority-based result merging
+   - Typed-constructor output (`transformToConstructor`) with negation, tense, question (`detectQuestion`) and quantity (`extractQuantities`) detection, plus adjacent-duplicate collapsing (`dedupeSequence`)
+
+3. **Q/P → Text Renderer** (`js/src/generation/qp-to-text.js`, `js/src/generation/constructors.js`)
+   - Typed constructors with named roles (Abstract-Wikipedia-style), including a `quantity` measurement constructor
+   - One templatic renderer per constructor-per-language across the UN 6 languages
+   - Negation, tense, English `a`/`an` phonotactics, Romance gender agreement (`un`/`una`, `un`/`une`) and Russian prepositional-case inflection on the locative object (`russianPrepositional`)
+   - Batch label resolution via the Wikidata client (`getLabels`), pluggable for offline use
 
-3. **Search Utilities** (`js/src/wikidata-api.js`)
+4. **Search Utilities** (`js/src/wikidata-api.js`)
    - Exact and fuzzy search algorithms
    - Context-aware ranking system
    - Multi-language support
 
-4. **Caching System** (`js/src/unified-cache.js`)
+5. **Caching System** (`js/src/unified-cache.js`)
    - Factory pattern for cache creation
    - File system cache for Node.js
    - IndexedDB cache for browsers
 
-5. **UI Components** (`js/src/statements.jsx`, `js/src/loading.jsx`)
+6. **UI Components** (`js/src/statements.jsx`, `js/src/loading.jsx`)
    - React 19 components with JSX
    - No build step required (Babel in-browser)
    - Responsive and theme-aware design
@@ -259,6 +275,7 @@ See the [🎬 Demos](#-demos) section above for the full table — every demo is
 - **Entity Viewer** — [`entities.html`](https://link-assistant.github.io/human-language/entities.html)
 - **Property Viewer** — [`properties.html`](https://link-assistant.github.io/human-language/properties.html)
 - **Text Transformer** — [`transformation/index.html`](https://link-assistant.github.io/human-language/transformation/index.html)
+- **Q/P → Text Generation** — [`app.html#mode=generation`](https://link-assistant.github.io/human-language/app.html#mode=generation)
 - **N-gram Test** — [`transformation/test-ngram.html`](https://link-assistant.github.io/human-language/transformation/test-ngram.html)
 - **Search Demo** — [`search-demo.html`](https://link-assistant.github.io/human-language/search-demo.html)
 - **Caching Demo** — [`cache-demo.html`](https://link-assistant.github.io/human-language/cache-demo.html)
@@ -269,9 +286,9 @@ See the [🎬 Demos](#-demos) section above for the full table — every demo is
 
 The text transformation system currently has some limitations:
 
-1. **Negation handling**: Phrases with "not" aren't properly processed
+1. **Negation handling**: The raw Q/P sequence does not encode negation — but `transformToConstructor` now detects it and the generation renderer expresses it ("X is not a Y")
 2. **Question parsing**: Direct questions (who, what, when) aren't supported
-3. **Verb tenses**: Past/future tenses may not be accurately captured
+3. **Verb tenses**: The raw sequence drops tense — `transformToConstructor` detects past/present/future and the renderer inflects the copula where grammatical (e.g. English "X was a Y", "X will be a Y", and the Spanish/French/Russian/Arabic equivalents). Languages that need noun-case morphology for a given tense (e.g. Russian/Arabic *instance_of* past) fall back to the present form, pending the Wikidata Lexeme integration tracked in `research/`
 4. **Pronoun resolution**: Cannot resolve pronouns like "he", "she", "it"
 5. **Complex sentences**: Struggles with subordinate clauses
 
diff --git a/app.html b/app.html
index 05f6ede..0d2383a 100644
--- a/app.html
+++ b/app.html
@@ -40,6 +40,9 @@
     import * as ipa from './js/src/app/ipa.js';
     import { TextToQPTransformer } from './js/src/transformation/text-to-qp-transformer.js';
     import { TextTransformerTest, demonstrateTransformer } from './js/src/transformation/text-transformer-test.js';
+    import { QPRenderer } from './js/src/generation/qp-to-text.js';
+    import { CONSTRUCTORS, UN6_LANGUAGES, LANGUAGE_NAMES, buildConstructor, validateConstructor }
+      from './js/src/generation/constructors.js';
 
     // Shared globals expected by the unified shell and legacy components
     // (statements.jsx, loading.jsx) that we re-mount inside the SPA.
@@ -70,6 +73,12 @@
       TextToQPTransformer,
       TextTransformerTest,
       demonstrateTransformer,
+      QPRenderer,
+      CONSTRUCTORS,
+      UN6_LANGUAGES,
+      LANGUAGE_NAMES,
+      buildConstructor,
+      validateConstructor,
       modes: {},
     };
   </script>
@@ -88,6 +97,7 @@
   <script type="text/babel" src="./js/src/app/modes/entity.jsx"></script>
   <script type="text/babel" src="./js/src/app/modes/property.jsx"></script>
   <script type="text/babel" src="./js/src/app/modes/transformer.jsx"></script>
+  <script type="text/babel" src="./js/src/app/modes/generation.jsx"></script>
 
   <!-- Mount the SPA. We wait until the next macrotask so every text/babel
        script above has been transformed and executed before App reads
diff --git a/docs/case-studies/issue-18/README.md b/docs/case-studies/issue-18/README.md
new file mode 100644
index 0000000..e6b9a30
--- /dev/null
+++ b/docs/case-studies/issue-18/README.md
@@ -0,0 +1,81 @@
+# Case Study — Issue #18
+
+> **Issue:** [link-assistant/human-language#18](https://github.com/link-assistant/human-language/issues/18)
+> "Learn from Abstract Wikipedia development"
+> **Pull request:** [#19](https://github.com/link-assistant/human-language/pull/19)
+> **Branch:** `issue-18-ef8b353c`
+
+## Summary
+
+Issue #18 asked us to learn from the [Abstract Wikipedia /
+Wikifunctions](https://meta.wikimedia.org/wiki/Abstract_Wikipedia)
+project. The first half of the work (see
+[`research/`](../../../research)) gathered fresh 2025–2026 research and a
+feature-gap analysis. This half acts on that analysis: it **implements**
+the most valuable missing capability the research surfaced — the reverse
+of our existing Text → Q/P transformer.
+
+Until now the project could only do *analysis* (English text → a sequence
+of Wikidata entities and properties). Abstract Wikipedia's core idea is
+the other direction: hold meaning in a language-independent, typed form
+and *render* it into natural language in many languages. That direction —
+**generation** — is what closes the round-trip the README vision depends
+on ("Language of Meaning", "Zero-Cost Translation").
+
+## What shipped
+
+A new **Generation** service (Q/P → text), built in the project's
+established style — pure data layer, an injectable renderer, offline-first
+unit tests, package subpath exports, hand-written type declarations, a
+unified-SPA mode, a legacy redirect shell, and e2e coverage.
+
+| Layer | File |
+| --- | --- |
+| Typed constructors + multi-language templates (pure, dependency-free) | [`js/src/generation/constructors.js`](../../../js/src/generation/constructors.js) |
+| The renderer (`QPRenderer`) | [`js/src/generation/qp-to-text.js`](../../../js/src/generation/qp-to-text.js) |
+| Batch labels + lexeme search on the Wikidata client | [`js/src/wikidata-api.js`](../../../js/src/wikidata-api.js), [`js/src/wikidata-api-browser.js`](../../../js/src/wikidata-api-browser.js) |
+| Typed-constructor output from the transformer (negation/tense) | [`js/src/transformation/text-to-qp-transformer.js`](../../../js/src/transformation/text-to-qp-transformer.js) |
+| SPA mode | [`js/src/app/modes/generation.jsx`](../../../js/src/app/modes/generation.jsx) |
+| Legacy redirect shell | [`generation/index.html`](../../../generation/index.html) |
+| Unit tests (offline) | [`js/tests/unit/qp-to-text.test.mjs`](../../../js/tests/unit/qp-to-text.test.mjs) |
+| e2e tests | [`js/tests/e2e/app.spec.mjs`](../../../js/tests/e2e/app.spec.mjs) |
+
+## Documents in this case study
+
+| File | Purpose |
+| --- | --- |
+| [`requirements.md`](./requirements.md) | Every requirement extracted from the issue and its PR comments, with status. |
+| [`architecture.md`](./architecture.md) | How the generation service is structured and which Abstract-Wikipedia concepts it maps to. |
+
+## The Abstract-Wikipedia concepts we adopted
+
+* **Constructors** — typed containers with named argument *roles*
+  (`instance_of`, `located_in`, `relation`, and the `quantity`
+  measurement constructor `subject` · `value` · `unit`). Our
+  `CONSTRUCTORS` catalogue mirrors this.
+* **Templatic renderers** — one template per constructor *per language*.
+  We ship the six official UN languages (en, ar, es, fr, ru, zh), the
+  same demonstration set Abstract Wikipedia uses for its first
+  natural-language-generation "semantic fragments" (e.g. Z26039 "Berlin
+  is a city").
+* **Grow the grammar incrementally** — we deliberately start with a
+  handful of high-value constructors plus English `a`/`an` phonotactics,
+  Romance gender agreement (es `un`/`una`, fr `un`/`une`, driven by
+  the object noun's grammatical gender — Wikidata P5185) and Russian
+  prepositional-case inflection on the locative object (Германия →
+  Германии) as the first grammatical features, exactly the way Abstract
+  Wikipedia grew its grammar.
+
+## Round-trip in one example
+
+```
+"Berlin is a city"        (English text)
+   → transformToConstructor → { type: 'instance_of', subject: 'Berlin', object: 'city' }
+   → QPRenderer.renderAll →
+        en: Berlin is a city      es: Berlin es un city
+        fr: Berlin est un city    ru: Berlin — city
+        zh: Berlin是city          ar: Berlin city
+```
+
+(With Wikidata ids in the roles instead of plain text, each label is
+resolved in the target language before rendering.)
diff --git a/docs/case-studies/issue-18/architecture.md b/docs/case-studies/issue-18/architecture.md
new file mode 100644
index 0000000..9f6c2fa
--- /dev/null
+++ b/docs/case-studies/issue-18/architecture.md
@@ -0,0 +1,118 @@
+# Architecture — Generation service (Q/P → text)
+
+This note explains how the reverse-generation service is put together and
+how each piece maps onto an Abstract Wikipedia concept. It mirrors the
+existing transformer so the two directions are symmetric.
+
+## Layers
+
+```
+                    ┌─────────────────────────────────────────────┐
+                    │  app.html (unified SPA)                      │
+                    │   app/modes/generation.jsx  ── UI mode       │
+                    └───────────────┬─────────────────────────────┘
+                                    │ window.HumanLanguageApp.QPRenderer
+                                    ▼
+   js/src/generation/qp-to-text.js  ── QPRenderer (orchestration)
+                                    │
+              ┌─────────────────────┴───────────────────────┐
+              ▼                                              ▼
+ js/src/generation/constructors.js              js/src/wikidata-api*.js
+   • CONSTRUCTORS catalogue                        • getLabels(ids, lang)  (batch)
+   • templates per constructor-per-language        • searchLexemes(term, lang)
+   • fillTemplate / validateConstructor
+   • englishIndefiniteArticle (a/an)
+   • romanceIndefiniteArticle (un/una · un/une)
+   • russianPrepositional (Германия → Германии)
+```
+
+### `constructors.js` — the pure data layer
+
+Dependency-free and synchronous, so it unit-tests offline with no Wikidata
+round-trip. It holds:
+
+- **`CONSTRUCTORS`** — the typed catalogue. Each entry has `roles` (named
+  argument slots), a `description`, and `templates` keyed by language with
+  a `positive` and (where the language differs) a `negative` pattern, plus
+  optional `past`/`future` variants that inflect the verb for tense. This
+  is the direct analogue of an Abstract Wikipedia *constructor* plus its
+  per-language *templatic renderers*. The catalogue includes a `quantity`
+  constructor (`subject` · `value` · `unit`) that renders a measurement in
+  all six languages — the direct analogue of a Wikidata quantity claim
+  (e.g. P2048 height), closing the numerical round-trip.
+- **`buildConstructor` / `validateConstructor`** — construct and check an
+  instance against the catalogue (unknown type / missing role throw).
+- **`fillTemplate`** — pick the tense forms (`constructor.tense`, falling
+  back to the present `positive`/`negative` when a language has no variant),
+  substitute the role tokens (`{subject}`/`{predicate}`/`{object}`,
+  `{value}`/`{unit}`) — applying any per-role morphological inflection the
+  template declares via `inflect` (e.g. Russian prepositional case on the
+  locative object) — and the `{article}` phonotactics token, collapsing the
+  whitespace an empty article leaves behind. Tense variants are added only
+  where they stay grammatical without noun-case morphology (copula tense in
+  en/es/fr, the locative verb in en/es/fr/ru/ar); cases that would need
+  morphology fall back to present.
+- **`englishIndefiniteArticle`** — the first grammatical feature (`a`/`an`).
+- **`romanceIndefiniteArticle`** — the second: agrees the Spanish/French
+  indefinite article (`un`/`una`, `un`/`une`) with the object noun's
+  grammatical gender (the constructor's `gender`, ultimately a Wikidata
+  Lexeme P5185 statement), defaulting to masculine when none is supplied.
+- **`russianPrepositional`** — the third: inflects the `located_in` object
+  to the prepositional case the preposition «в» governs (Германия →
+  Германии). A documented heuristic seed that leaves indeclinable foreign
+  endings, abbreviations and gender-ambiguous soft-sign nouns untouched, so
+  it only ever improves output.
+
+### `qp-to-text.js` — the renderer
+
+`QPRenderer` is a thin orchestration layer:
+
+- `renderWithLabels(constructor, labels, lang)` — pure/synchronous; use
+  when labels are already in hand (tests, batch pipelines).
+- `render(constructor, lang)` — resolves only the *id-shaped* roles
+  (`/^[QPL]\d+$/`) via the label provider, then calls `renderWithLabels`.
+  Plain-text roles pass through unchanged, so the service demonstrates
+  end-to-end with zero network.
+- `renderAll(constructor, langs = UN6_LANGUAGES)` — renders the same
+  meaning across the six official UN languages, the multi-language render
+  Abstract Wikipedia demonstrates.
+
+**Label resolution is pluggable.** The constructor accepts either a
+`labelProvider` (`async (ids, lang) => { id: label }`) or an `apiClient`.
+Tests inject a dictionary provider; production lazily constructs the right
+Wikidata client (browser vs Node) exactly like the transformer does.
+
+### Transformer → constructor bridge
+
+`text-to-qp-transformer.js` gained `transformToConstructor(text)`, which
+runs the normal analysis and then folds the flat Q/P sequence into a typed
+constructor: first Q → `subject`, first P → `predicate`, next Q →
+`object` — or, when a measurement is present, a `quantity` constructor
+(`subject` · `value` · `unit`). It also extracts **modifiers** — `negated`
+(via `not`/`n't`/`never`) and `tense` (`present`/`past`/`future`, handling
+`-ed` and a set of irregular past forms) — classifies **questions**
+(`detectQuestion`: wh-word → `entity`/`thing`/`time`/`place`/`reason`/
+`manner`/`quantity`, plus polar questions), pulls out **quantities**
+(`extractQuantities`: number + unit), and collapses adjacent duplicate ids
+(`dedupeSequence`). This is what makes the round-trip `text → Q/P → text`
+possible and closes the negation / question / numerical / repetition gaps
+the analysis surfaced.
+
+## Why this shape
+
+- **Offline-first** keeps the gating CI suite network-free — the sandbox
+  blocks outbound requests, and live-API suites are informational only.
+- **Pure data layer + thin renderer** matches how Abstract Wikipedia
+  separates the constructor catalogue from the rendering functions, and
+  lets the grammar grow by *adding data*, not rewriting code.
+- **Symmetry with the transformer** (runtime client selection, SPA mode,
+  redirect shell, package exports, type declarations) means the new
+  service is discoverable and maintainable by anyone who already knows the
+  transformer.
+
+## Extending it
+
+To add a constructor: add an entry to `CONSTRUCTORS` with its `roles` and
+per-language `templates`. To add a language: add its code to
+`UN6_LANGUAGES`/`LANGUAGE_NAMES` and a template under each constructor. No
+renderer code changes are required — the grammar is data.
diff --git a/docs/case-studies/issue-18/requirements.md b/docs/case-studies/issue-18/requirements.md
new file mode 100644
index 0000000..7b0838b
--- /dev/null
+++ b/docs/case-studies/issue-18/requirements.md
@@ -0,0 +1,82 @@
+# Requirements — Issue #18
+
+Extracted from the issue body and the binding follow-up comments on PR #19.
+
+## From the issue
+
+> **"Learn from Abstract Wikipedia development"**
+
+| # | Requirement | Status |
+| --- | --- | --- |
+| R1 | Study Abstract Wikipedia / Wikifunctions and capture the lessons | ✅ `research/abstract-wikipedia-analysis.md`, `research/missing-features-and-improvements.md` |
+| R2 | Identify the features it has that we are missing | ✅ Feature-gap table in `research/missing-features-and-improvements.md` |
+
+## From the PR comments (binding)
+
+> **"Get latest fresh data about Abstract Wikipedia research, and improve
+> quality of all our services, and also point to missing features we can
+> also support."**
+
+| # | Requirement | Status |
+| --- | --- | --- |
+| R3 | Fresh (2025–2026) research | ✅ Refreshed analysis doc |
+| R4 | Point to missing features we can support | ✅ Prioritised gap table |
+| R5 | Improve quality of our services | ✅ Batch `getLabels`, `searchLexemes`, typed-constructor transformer output |
+
+> **"Get latest changes from default branch, and implement everything in
+> the established style our other features have. Please plan and execute
+> everything in this single pull request … until each and every
+> requirement is fully addressed."**
+
+| # | Requirement | Status |
+| --- | --- | --- |
+| R6 | Merge latest `main` into the branch | ✅ |
+| R7 | **Implement** the missing features (not just document them) | ✅ Generation service (Q/P → text) |
+| R8 | Reverse generation (Q/P → text) | ✅ `js/src/generation/qp-to-text.js` |
+| R9 | Typed, role-labelled constructors | ✅ `js/src/generation/constructors.js` + `transformToConstructor` |
+| R10 | Multi-language rendering (UN 6) | ✅ `renderAll` across en/ar/es/fr/ru/zh |
+| R11 | Grammatical features + phonotactics | ✅ English `a`/`an`, negation, tense, Romance gender agreement (`un`/`una`, `un`/`une`), Russian prepositional case (Германия → Германии) |
+| R12 | Wikidata Lexeme integration | ✅ `searchLexemes` on both API clients |
+| R13 | Follow the established style (library export, types, SPA mode, redirect shell, tests, demo) | ✅ See `architecture.md` |
+| R14 | Single PR (#19), branch `issue-18-ef8b353c` | ✅ |
+
+> **"Double check again, and implement unimplemented or delayed, make
+> sure we support all test cases Abstract Wikipedia project has. And also
+> expand on our use cases and features … If you see clearly wrong tests
+> (in the entire codebase), that can be improved — do it."**
+
+| # | Requirement | Status |
+| --- | --- | --- |
+| R15 | Close the documented analysis gaps (negation, questions, numerical, repetition) in the *analysis* direction | ✅ `extractModifiers`, `detectQuestion`, `extractQuantities`, `dedupeSequence` on `transformToConstructor` |
+| R16 | Expand the constructor catalogue — numerical round-trip | ✅ `quantity` constructor (`subject`·`value`·`unit`) renders across the UN 6 and is emitted by `toConstructor` |
+| R17 | Add a grammatical feature beyond English phonotactics | ✅ Romance gender agreement (es/fr indefinite article, P5185-style gender) |
+| R18 | Fix clearly-wrong tests | ✅ Corrected the ungrammatical es/fr gender assertions (`una ciudad`, `une ville`) in `qp-to-text.test.mjs` |
+| R19 | Make the limitation harness reflect the structural handling | ✅ `limitation-test.mjs` now scores `transformToConstructor`; documented problems 12 → 4 (remaining are knowledge-base/data limits, not logic) |
+| R20 | Wire the new features into the SPA + docs | ✅ Role-aware Generation mode (value/unit, gender selector), README + case-study updates |
+
+> **"Make sure our roadmap, vision and all requirements listed in the
+> repository are fully and correctly implemented. Double check tests for
+> obviously wrong cases and fix them also."**
+
+| # | Requirement | Status |
+| --- | --- | --- |
+| R21 | Fix the obviously-wrong Russian locative output | ✅ `russianPrepositional` inflects the `located_in` object after «в» (Германия → Германии); the test that blessed the nominative form is corrected and the helper is unit-tested with its indeclinable/abbreviation guards |
+
+## Established-style checklist (R13 in detail)
+
+The project has a recognisable shape for every feature; the generation
+service follows all of it:
+
+- [x] Pure, dependency-free data layer (`generation/constructors.js`)
+- [x] Runtime API-client selection (Node `fs` vs browser) like the transformer
+- [x] Public package surface: `js/src/index.js` re-exports + `package.json`
+      subpath exports (`./generate`, `./generate/constructors`)
+- [x] Hand-written type declarations in `js/src/index.d.ts`
+- [x] Offline-first unit tests gated in `run-unit-tests.mjs`
+- [x] Unified-SPA mode (`app/modes/generation.jsx`) wired into routing +
+      shell + `app.html`
+- [x] Legacy redirect shell (`generation/index.html`) like
+      `transformation/index.html`
+- [x] e2e coverage in `js/tests/e2e/app.spec.mjs`
+- [x] README + landing-page (`index.html`) entries
+- [x] Version bump (`0.1.0` → `0.2.0`) to trigger the release workflow
diff --git a/generation/index.html b/generation/index.html
new file mode 100644
index 0000000..91755e5
--- /dev/null
+++ b/generation/index.html
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Wikidata Q/P to Text Generation — Human Language</title>
+  <meta http-equiv="refresh" content="0;url=../app.html#mode=generation">
+  <link rel="canonical" href="../app.html#mode=generation">
+  <style>
+    body { font-family: system-ui, sans-serif; background: #121212; color: #E0E0E0; padding: 40px; text-align: center; }
+    a { color: #00FF00; }
+  </style>
+</head>
+<body>
+  <p>Redirecting to the unified <a href="../app.html">Human Language SPA</a>…</p>
+  <script>
+    // Preserve any query/hash params when redirecting into the SPA.
+    (function redirect() {
+      const hash = (window.location.hash || '').replace(/^#/, '');
+      let target = '../app.html#mode=generation';
+      if (hash.includes('=')) {
+        const params = new URLSearchParams(hash);
+        params.set('mode', 'generation');
+        target = `../app.html#${params.toString()}`;
+      } else if (window.location.search) {
+        const params = new URLSearchParams(window.location.search);
+        params.set('mode', 'generation');
+        target = `../app.html#${params.toString()}`;
+      }
+      window.location.replace(target);
+    })();
+  </script>
+</body>
+</html>
diff --git a/index.html b/index.html
index 2893147..2fbb232 100644
--- a/index.html
+++ b/index.html
@@ -4,7 +4,7 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>Human Language Project</title>
-  <meta name="description" content="A new kind of language for all people on earth — a unified SPA over Wikidata for alphabet, dictionary, ontology, entity, property and transformer exploration.">
+  <meta name="description" content="A new kind of language for all people on earth — a unified SPA over Wikidata for alphabet, dictionary, ontology, entity, property, transformer and generation exploration.">
   <link rel="canonical" href="https://link-assistant.github.io/human-language/">
   <meta property="og:title" content="Human Language Project">
   <meta property="og:description" content="A new kind of language for all people on earth.">
@@ -178,6 +178,12 @@ <h3>Text → Q/P transformer</h3>
           <p>Paste any English sentence and watch it become a sequence of Wikidata entities and properties, with n-gram support for multi-word terms.</p>
           <span class="file">app.html#mode=transformer</span>
         </a>
+        <a class="card" href="app.html#mode=generation">
+          <span class="tag">Generation</span>
+          <h3>Q/P → text generation</h3>
+          <p>The reverse direction: render a typed constructor (subject · predicate · object, with negation and tense) into sentences across the six official UN languages — an Abstract-Wikipedia-style renderer.</p>
+          <span class="file">app.html#mode=generation</span>
+        </a>
       </div>
     </section>
 
diff --git a/js/scripts/limitation-test.mjs b/js/scripts/limitation-test.mjs
index e6c1849..bf7ec30 100644
--- a/js/scripts/limitation-test.mjs
+++ b/js/scripts/limitation-test.mjs
@@ -186,7 +186,10 @@ class LimitationTest {
       
       try {
         const startTime = Date.now();
-        const result = await this.transformer.transform(testCase.input, {
+        // Use the structured pipeline so detected modifiers (negation/tense),
+        // questions, quantities and the typed constructor are available to the
+        // analysis below — the flat transform() loses all of that signal.
+        const result = await this.transformer.transformToConstructor(testCase.input, {
           maxCandidates: 3,
           includeLabels: false,
           searchLimit: 5
@@ -246,15 +249,17 @@ class LimitationTest {
         break;
         
       case "should_handle_negation":
-        // Current system ignores "not" - this is a known limitation
-        if (result.sequence.length > 0) {
+        // Negation is now detected by extractModifiers() and carried on the
+        // typed constructor (negated: true), so the meaning is preserved.
+        if (!result.modifiers?.negated && !result.constructor?.negated) {
           issues.push('Negation not properly handled - "not" should affect meaning');
         }
         break;
-        
+
       case "should_handle_questions":
-        // Questions should be handled differently
-        if (result.sequence.length > 0) {
+        // Questions are now classified by detectQuestion() (wh-word + type),
+        // so they are no longer silently treated as plain statements.
+        if (!result.question?.isQuestion) {
           issues.push('Questions treated as statements - need special handling');
         }
         break;
@@ -268,9 +273,12 @@ class LimitationTest {
         break;
         
       case "numerical":
-        // Should handle quantities differently
-        const hasQuantity = result.formatted.match(/\d/);
-        if (!hasQuantity) {
+        // Quantities are now extracted with their unit and surfaced as a
+        // typed 'quantity' constructor, so the value is no longer lost.
+        const capturedQuantity =
+          (Array.isArray(result.quantities) && result.quantities.some(q => q.unit)) ||
+          result.constructor?.type === 'quantity';
+        if (!capturedQuantity) {
           issues.push('Numerical values lost in transformation');
         }
         break;
@@ -361,18 +369,18 @@ class LimitationTest {
       });
     }
     
-    console.log('\n💡 PRIORITY IMPROVEMENTS NEEDED:');
+    console.log('\n💡 IMPROVEMENT STATUS:');
     const improvements = [
-      '1. Implement negation handling ("not", "never", etc.)',
-      '2. Add question detection and special processing',
-      '3. Improve temporal expression recognition',
-      '4. Handle numerical values and units properly',
-      '5. Add multi-language support for non-Latin scripts',
-      '6. Implement entity deduplication for repeated terms',
-      '7. Add confidence scoring to reduce ambiguous results',
-      '8. Optimize phrase detection to reduce over-segmentation'
+      '✅ Negation handling ("not", "never", etc.) — extractModifiers()',
+      '✅ Question detection and classification — detectQuestion()',
+      '✅ Temporal/tense recognition — extractModifiers() tense',
+      '✅ Numerical values and units — extractQuantities() + quantity constructor',
+      '✅ Entity deduplication for repeated terms — dedupeSequence()',
+      '⬜ Multi-language support for non-Latin scripts (knowledge-base dependent)',
+      '⬜ Confidence scoring to reduce ambiguous results',
+      '⬜ Phrase detection tuning to reduce over-segmentation'
     ];
-    
+
     improvements.forEach(improvement => console.log(improvement));
   }
 
diff --git a/js/scripts/run-unit-tests.mjs b/js/scripts/run-unit-tests.mjs
index 3f82f4e..2f02125 100755
--- a/js/scripts/run-unit-tests.mjs
+++ b/js/scripts/run-unit-tests.mjs
@@ -17,6 +17,7 @@ const FAST_SUITES = [
   'js/tests/unit/persistent-cache.test.mjs',
   'js/tests/unit/server.test.mjs',
   'js/tests/unit/cli.test.mjs',
+  'js/tests/unit/qp-to-text.test.mjs',
 ];
 
 const INTEGRATION_SUITES = [
diff --git a/js/src/app/modes/generation.jsx b/js/src/app/modes/generation.jsx
new file mode 100644
index 0000000..e3c8b7c
--- /dev/null
+++ b/js/src/app/modes/generation.jsx
@@ -0,0 +1,312 @@
+// Generation mode (reverse: Q/P → text).
+//
+// The mirror image of the Transformer mode. Where the transformer does
+// analysis (English text → a sequence of Wikidata Q/P), this mode does
+// generation: a typed constructor (subject / predicate / object, plus
+// negation and tense modifiers) is rendered into natural-language
+// sentences across the six official UN languages — exactly the
+// "templatic renderer" pattern Abstract Wikipedia uses.
+//
+// The underlying renderer (`generation/qp-to-text.js`) is reused verbatim.
+// Role values may be either Wikidata ids (Q64, P31, …), which are resolved
+// to labels in each language, or plain text, which passes through
+// unchanged — so the mode demonstrates end-to-end without a network call.
+
+(function attachGeneration() {
+  // Read everything from `window.HumanLanguageApp` — Babel-standalone
+  // rewrites dynamic `import()` to `require()`, which is undefined in the
+  // browser (issue #35). app.html exposes the symbols we need.
+  const {
+    TestsPanel,
+    QPRenderer,
+    CONSTRUCTORS,
+    UN6_LANGUAGES,
+    LANGUAGE_NAMES,
+    buildConstructor,
+    validateConstructor,
+    flagMap,
+  } = window.HumanLanguageApp;
+
+  // Example constructors. Values are plain labels so the demo renders with
+  // no Wikidata round-trip; swap in Q/P ids to exercise label resolution.
+  const EXAMPLES = [
+    { title: 'Berlin is a city',        type: 'instance_of', subject: 'Berlin',   object: 'city' },
+    { title: 'Einstein is a scientist', type: 'instance_of', subject: 'Einstein', object: 'scientist' },
+    { title: 'Paris is in France',      type: 'located_in',  subject: 'Paris',    object: 'France' },
+    { title: 'An apple is a fruit',     type: 'instance_of', subject: 'apple',    object: 'fruit' },
+    { title: 'Whale is not a fish',     type: 'instance_of', subject: 'Whale',    object: 'fish', negated: true },
+    { title: 'Berlin is a city (fem.)', type: 'instance_of', subject: 'Berlin',   object: 'ciudad', gender: 'feminine' },
+    { title: 'Einstein wrote books',    type: 'relation',    subject: 'Einstein', predicate: 'wrote', object: 'books', tense: 'past' },
+    { title: 'Everest is 8848 m tall',  type: 'quantity',    subject: 'Mount Everest', value: '8848', unit: 'meters' },
+  ];
+
+  const TENSES = ['present', 'past', 'future'];
+  const GENDERS = ['masculine', 'feminine'];
+
+  function GenerationMode() {
+    const [type, setType]           = React.useState('instance_of');
+    const [subject, setSubject]     = React.useState('Berlin');
+    const [predicate, setPredicate] = React.useState('');
+    const [object, setObject]       = React.useState('city');
+    const [value, setValue]         = React.useState('');
+    const [unit, setUnit]           = React.useState('');
+    const [gender, setGender]       = React.useState('masculine');
+    const [negated, setNegated]     = React.useState(false);
+    const [tense, setTense]         = React.useState('present');
+    const [result, setResult]       = React.useState(null);
+    const [busy, setBusy]           = React.useState(false);
+    const [error, setError]         = React.useState('');
+    const [renderer, setRenderer]   = React.useState(null);
+
+    React.useEffect(() => {
+      try {
+        if (!QPRenderer) throw new Error('QPRenderer not loaded by app.html');
+        setRenderer(new QPRenderer());
+      } catch (e) {
+        setError(`Failed to load renderer: ${e?.message || e}`);
+      }
+    }, []);
+
+    const spec = CONSTRUCTORS[type];
+    const roleSet = spec?.roles || [];
+    const usesPredicate = roleSet.includes('predicate');
+    const usesObject = roleSet.includes('object');
+    const usesValue = roleSet.includes('value');
+    const usesUnit = roleSet.includes('unit');
+    // Gender only drives the Romance indefinite article, which only appears
+    // in templates that interpolate `{article}` (today: instance_of).
+    const usesGender = !!spec && Object.values(spec.templates || {})
+      .some((t) => JSON.stringify(t).includes('{article}'));
+
+    const buildCurrent = () => {
+      const roles = { subject };
+      if (usesObject) roles.object = object;
+      if (usesPredicate) roles.predicate = predicate;
+      if (usesValue) roles.value = value;
+      if (usesUnit) roles.unit = unit;
+      const modifiers = { negated, tense };
+      if (usesGender) modifiers.gender = gender;
+      return buildConstructor(type, roles, modifiers);
+    };
+
+    const onGenerate = async (e) => {
+      e?.preventDefault();
+      if (!renderer) return;
+      setBusy(true);
+      setError('');
+      setResult(null);
+      try {
+        const constructor = buildCurrent();
+        validateConstructor(constructor);
+        const sentences = await renderer.renderAll(constructor, UN6_LANGUAGES);
+        setResult({ constructor, sentences });
+      } catch (err) {
+        setError(err?.message || String(err));
+      } finally {
+        setBusy(false);
+      }
+    };
+
+    const onClear = () => {
+      setSubject(''); setPredicate(''); setObject(''); setValue(''); setUnit('');
+      setGender('masculine'); setNegated(false); setTense('present');
+      setResult(null); setError('');
+    };
+
+    const loadExample = (ex) => {
+      setType(ex.type);
+      setSubject(ex.subject || '');
+      setPredicate(ex.predicate || '');
+      setObject(ex.object || '');
+      setValue(ex.value || '');
+      setUnit(ex.unit || '');
+      setGender(ex.gender || 'masculine');
+      setNegated(!!ex.negated);
+      setTense(ex.tense || 'present');
+    };
+
+    const onRandom = () => loadExample(EXAMPLES[Math.floor(Math.random() * EXAMPLES.length)]);
+
+    const fieldStyle = {
+      background: 'var(--background)',
+      color: 'var(--text)',
+      border: '1px solid var(--rule)',
+      borderRadius: '4px',
+      padding: '8px',
+      fontFamily: 'inherit',
+      fontSize: '1rem',
+    };
+
+    const testRunners = [
+      {
+        label: 'Render the UN 6 languages',
+        run: async () => {
+          const r = new QPRenderer();
+          const c = buildConstructor('instance_of', { subject: 'Berlin', object: 'city' });
+          const out = await r.renderAll(c, UN6_LANGUAGES);
+          for (const lang of UN6_LANGUAGES) {
+            console.log(`${lang}: ${out[lang]}`);
+          }
+        },
+      },
+      {
+        label: 'Render negation + located_in',
+        run: async () => {
+          const r = new QPRenderer();
+          console.log('positive:', await r.render(buildConstructor('located_in', { subject: 'Paris', object: 'France' }), 'en'));
+          console.log('negative:', await r.render(buildConstructor('instance_of', { subject: 'Whale', object: 'fish' }, { negated: true }), 'en'));
+        },
+      },
+      {
+        label: 'Romance gender agreement (un / una · un / une)',
+        run: async () => {
+          const r = new QPRenderer();
+          const masc = buildConstructor('instance_of', { subject: 'Berlín', object: 'pueblo' }, { gender: 'masculine' });
+          const fem = buildConstructor('instance_of', { subject: 'Berlín', object: 'ciudad' }, { gender: 'feminine' });
+          console.log('es masculine:', await r.render(masc, 'es'));
+          console.log('es feminine:', await r.render(fem, 'es'));
+          console.log('fr feminine:', await r.render(buildConstructor('instance_of', { subject: 'Berlin', object: 'ville' }, { gender: 'feminine' }), 'fr'));
+        },
+      },
+      {
+        label: 'Render a quantity (measurement) across the UN 6',
+        run: async () => {
+          const r = new QPRenderer();
+          const c = buildConstructor('quantity', { subject: 'Mount Everest', value: '8848', unit: 'meters' });
+          const out = await r.renderAll(c, UN6_LANGUAGES);
+          for (const lang of UN6_LANGUAGES) {
+            console.log(`${lang}: ${out[lang]}`);
+          }
+        },
+      },
+    ];
+
+    return (
+      <section aria-label="Generation">
+        <h1>Generation</h1>
+        <p>
+          Render a typed constructor (subject · predicate · object — or a
+          subject · value · unit measurement — with negation, tense and
+          Romance gender agreement) into natural-language sentences across the
+          six official UN languages — the reverse of the Transformer. Role
+          values may be Wikidata ids (resolved to labels per language) or plain
+          text.
+        </p>
+
+        <form className="toolbar" onSubmit={onGenerate} style={{ flexDirection: 'column', alignItems: 'stretch' }}>
+          <div style={{ display: 'flex', flexWrap: 'wrap', gap: '12px', alignItems: 'center' }}>
+            <label>
+              Constructor{' '}
+              <select value={type} onChange={(e) => setType(e.target.value)} style={fieldStyle}>
+                {Object.keys(CONSTRUCTORS).map((t) => (
+                  <option key={t} value={t}>{t}</option>
+                ))}
+              </select>
+            </label>
+            <span style={{ color: 'var(--description-text)' }}>{spec?.description}</span>
+          </div>
+
+          <div style={{ display: 'flex', flexWrap: 'wrap', gap: '12px', alignItems: 'center' }}>
+            <label>Subject <input value={subject} onChange={(e) => setSubject(e.target.value)} placeholder="Berlin or Q64" style={fieldStyle} /></label>
+            {usesPredicate ? (
+              <label>Predicate <input value={predicate} onChange={(e) => setPredicate(e.target.value)} placeholder="wrote or P800" style={fieldStyle} /></label>
+            ) : null}
+            {usesObject ? (
+              <label>Object <input value={object} onChange={(e) => setObject(e.target.value)} placeholder="city or Q515" style={fieldStyle} /></label>
+            ) : null}
+            {usesValue ? (
+              <label>Value <input value={value} onChange={(e) => setValue(e.target.value)} placeholder="8848" style={fieldStyle} /></label>
+            ) : null}
+            {usesUnit ? (
+              <label>Unit <input value={unit} onChange={(e) => setUnit(e.target.value)} placeholder="meters" style={fieldStyle} /></label>
+            ) : null}
+          </div>
+
+          <div style={{ display: 'flex', flexWrap: 'wrap', gap: '12px', alignItems: 'center' }}>
+            <label>
+              <input type="checkbox" checked={negated} onChange={(e) => setNegated(e.target.checked)} /> Negated
+            </label>
+            <label>
+              Tense{' '}
+              <select value={tense} onChange={(e) => setTense(e.target.value)} style={fieldStyle}>
+                {TENSES.map((t) => <option key={t} value={t}>{t}</option>)}
+              </select>
+            </label>
+            {usesGender ? (
+              <label title="Drives Romance indefinite-article agreement (es un/una, fr un/une)">
+                Object gender{' '}
+                <select value={gender} onChange={(e) => setGender(e.target.value)} style={fieldStyle}>
+                  {GENDERS.map((g) => <option key={g} value={g}>{g}</option>)}
+                </select>
+              </label>
+            ) : null}
+          </div>
+
+          <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
+            <button type="submit" disabled={busy || !renderer}>{busy ? 'Generating…' : 'Generate'}</button>
+            <button type="button" onClick={onClear}>Clear</button>
+            <button type="button" onClick={onRandom}>Load example</button>
+          </div>
+        </form>
+
+        {error ? <p style={{ color: 'var(--badge-ambiguous)' }}>{error}</p> : null}
+
+        {result ? (
+          <div className="dictionary-result">
+            <h2>Sentences</h2>
+            <div className="statement-card">
+              <table style={{ width: '100%', borderCollapse: 'collapse' }}>
+                <tbody>
+                  {UN6_LANGUAGES.map((lang) => (
+                    <tr key={lang}>
+                      <td style={{ padding: '6px 12px 6px 0', whiteSpace: 'nowrap', verticalAlign: 'top' }}>
+                        <span style={{ marginRight: '6px' }}>{flagMap[lang] || ''}</span>
+                        <strong>{LANGUAGE_NAMES[lang] || lang}</strong>
+                      </td>
+                      <td style={{ padding: '6px 0' }} lang={lang} dir={lang === 'ar' ? 'rtl' : 'ltr'}>
+                        {result.sentences[lang]}
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+            <h2>Constructor</h2>
+            <div className="statement-card">
+              <code style={{ wordBreak: 'break-word' }}>{JSON.stringify(result.constructor)}</code>
+            </div>
+          </div>
+        ) : null}
+
+        <h2 style={{ marginTop: '24px' }}>Example constructors</h2>
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: '8px' }}>
+          {EXAMPLES.map((ex) => (
+            <button
+              key={ex.title}
+              type="button"
+              onClick={() => loadExample(ex)}
+              style={{
+                textAlign: 'left',
+                padding: '10px',
+                border: '1px solid var(--rule)',
+                background: 'var(--accent-bg)',
+                color: 'var(--text)',
+                borderRadius: '6px',
+                fontFamily: 'inherit',
+                cursor: 'pointer',
+              }}
+            >
+              <strong style={{ display: 'block' }}>{ex.title}</strong>
+              <em style={{ color: 'var(--description-text)' }}>{ex.type}</em>
+            </button>
+          ))}
+        </div>
+
+        <TestsPanel title="Run renderer demos" runners={testRunners} />
+      </section>
+    );
+  }
+
+  window.HumanLanguageApp.modes = window.HumanLanguageApp.modes || {};
+  window.HumanLanguageApp.modes.generation = GenerationMode;
+})();
diff --git a/js/src/app/routing.js b/js/src/app/routing.js
index 80700c7..e1c5632 100644
--- a/js/src/app/routing.js
+++ b/js/src/app/routing.js
@@ -16,6 +16,7 @@ export const MODES = [
   'entity',
   'property',
   'transformer',
+  'generation',
 ];
 
 export const DEFAULT_MODE = 'entity';
diff --git a/js/src/app/shell.jsx b/js/src/app/shell.jsx
index 10139ff..dc792e1 100644
--- a/js/src/app/shell.jsx
+++ b/js/src/app/shell.jsx
@@ -63,6 +63,7 @@
     entity: 'Entities',
     property: 'Properties',
     transformer: 'Transformer',
+    generation: 'Generation',
   };
 
   function ModeTabs({ mode, params }) {
diff --git a/js/src/generation/constructors.js b/js/src/generation/constructors.js
new file mode 100644
index 0000000..46691d9
--- /dev/null
+++ b/js/src/generation/constructors.js
@@ -0,0 +1,346 @@
+// Typed constructors and multi-language templates for the reverse
+// generation service (Q/P → text).
+//
+// This is the data layer that mirrors Abstract Wikipedia's "constructors"
+// (typed containers with named argument roles) and the per-constructor,
+// per-language "templatic renderers" that turn one constructor into a
+// sentence. We deliberately start small — a handful of high-value
+// constructors across the six official UN languages — following Abstract
+// Wikipedia's own lesson: start with simple, high-value fragments and grow
+// the grammar incrementally.
+//
+// Everything here is pure and dependency-free so it can be unit-tested
+// offline (no Wikidata round-trip) and reused in both Node and the browser.
+
+/**
+ * The six official languages of the United Nations — the same demonstration
+ * set Abstract Wikipedia uses for its first natural-language-generation
+ * "semantic fragments".
+ */
+export const UN6_LANGUAGES = ['en', 'ar', 'es', 'fr', 'ru', 'zh'];
+
+/** Human-readable names for the supported languages. */
+export const LANGUAGE_NAMES = {
+  en: 'English',
+  ar: 'Arabic',
+  es: 'Spanish',
+  fr: 'French',
+  ru: 'Russian',
+  zh: 'Chinese',
+};
+
+/**
+ * English indefinite-article phonotactics (a / an). This is the first
+ * grammatical feature of the renderer. It is a documented heuristic — it
+ * keys off the first letter and so does not yet handle silent-h ("an hour")
+ * or vowel-letter/consonant-sound words ("a university"). Abstract
+ * Wikipedia models the full phonological rule set; this is the seed.
+ *
+ * @param {string} word - The word the article precedes
+ * @returns {string} - 'a' or 'an'
+ */
+export function englishIndefiniteArticle(word) {
+  if (!word) return 'a';
+  const first = word.trim().charAt(0).toLowerCase();
+  return 'aeiou'.includes(first) ? 'an' : 'a';
+}
+
+/**
+ * Grammatical-gender agreement for the Romance indefinite article — the
+ * second grammatical feature of the renderer. Spanish and French inflect the
+ * indefinite article for the *object* noun's gender (es *un/una*, fr
+ * *un/une*), so "Berlín es un ciudad" is ungrammatical: *ciudad* is feminine
+ * and requires *una*.
+ *
+ * The gender of a Wikidata noun ultimately comes from its Lexeme's
+ * grammatical-gender statement (Wikidata P5185), the same source Abstract
+ * Wikipedia uses; until that integration lands (tracked in `research/`), the
+ * caller supplies it via the constructor's `gender` modifier. When no gender
+ * is given we fall back to masculine — the unmarked default in both languages
+ * — and document that as a known approximation rather than emit nothing.
+ *
+ * @param {string} lang - 'es' or 'fr'
+ * @param {string} [gender] - 'feminine' | 'f' | 'masculine' | 'm' (default masculine)
+ * @returns {string} - The indefinite article, or '' for an unsupported language
+ */
+export function romanceIndefiniteArticle(lang, gender) {
+  const feminine = gender === 'feminine' || gender === 'f';
+  if (lang === 'es') return feminine ? 'una' : 'un';
+  if (lang === 'fr') return feminine ? 'une' : 'un';
+  return '';
+}
+
+/**
+ * Russian prepositional-case inflection for the object of a locative phrase —
+ * the third grammatical feature of the renderer. The preposition «в» ("in")
+ * governs the prepositional case, so the nominative Wikidata label is
+ * ungrammatical: «Берлин находится в Германия» must become «…в Германии».
+ *
+ * Like the article helpers above this is a documented heuristic seed, not a
+ * full morphology engine (that awaits the Wikidata Lexeme integration tracked
+ * in `research/`). It applies the regular prepositional endings and — crucially
+ * — leaves a word untouched whenever inflecting it would be *wrong*, so it can
+ * only ever improve output, never regress it:
+ *   - «-ия» → «-ии» (Германия → Германии, Россия → России)
+ *   - «-а»  → «-е»  (Москва → Москве, Америка → Америке)
+ *   - «-я»  → «-е»  (земля → земле)
+ *   - «-й»  → «-е»  (Китай → Китае, Уругвай → Уругвае)
+ *   - a consonant-final masculine noun → «+е» (город → городе, Лондон → Лондоне)
+ *   - indeclinable vowel endings (о/е/у/ю/и/э/ы): unchanged (Токио, Чикаго, Осло)
+ *   - gender-ambiguous soft-sign («-ь») endings: unchanged (avoid guessing)
+ *   - all-caps abbreviations (США, ООН) and non-Cyrillic words: unchanged
+ *
+ * @param {string} word - The nominative Russian label
+ * @returns {string} - The prepositional-case form (or the input unchanged)
+ */
+export function russianPrepositional(word) {
+  if (!word) return word;
+  const w = String(word).trim();
+  if (!w) return w;
+  // Non-Cyrillic words (Latin labels, numbers) are not Russian — leave them.
+  if (!/[а-яёА-ЯЁ]/.test(w)) return w;
+  // All-caps abbreviations are indeclinable (США, ООН, ЕС).
+  if (/^[А-ЯЁA-Z]{2,}$/.test(w)) return w;
+  if (/ия$/.test(w)) return `${w.slice(0, -2)}ии`;
+  if (/[ая]$/.test(w)) return `${w.slice(0, -1)}е`;
+  if (/й$/.test(w)) return `${w.slice(0, -1)}е`;
+  // Indeclinable foreign vowel endings stay as-is (Токио, Перу, Чили, Осло).
+  if (/[оеуюиэы]$/.test(w)) return w;
+  // Soft-sign endings are gender-ambiguous (m → -е, f → -и); don't guess.
+  if (/ь$/.test(w)) return w;
+  // Otherwise a consonant-final masculine noun takes «+е».
+  return `${w}е`;
+}
+
+/**
+ * Constructor catalogue. Each constructor is a typed container with named
+ * argument roles and one templatic renderer per supported language.
+ *
+ * Template placeholders:
+ *   {subject} {predicate} {object} - replaced by the role's resolved label
+ *   {article}                      - replaced by the language's indefinite
+ *                                    article (English a/an phonotactics; the
+ *                                    gender-agreeing Romance un/una, un/une
+ *                                    keyed off the constructor's `gender`)
+ *
+ * A template provides a `positive` pattern and, where the language differs,
+ * a `negative` pattern used when the constructor carries `negated: true`.
+ *
+ * Tense (`past` / `future`) is optional and inflects the verb only. We add
+ * a tense variant *only* where it is grammatically correct without the noun
+ * morphology this renderer does not yet have (that awaits the Wikidata
+ * Lexeme integration tracked in `research/`). Concretely:
+ *   - copula tense (en/es/fr "is→was→will be") leaves the predicate noun
+ *     unchanged, so it is safe;
+ *   - Russian/Arabic *instance_of* past needs case changes on the noun
+ *     (instrumental / accusative), so those fall back to the present copula;
+ *   - Chinese copulas (是 / 在) do not inflect for tense, so the present form
+ *     is already correct for every tense and needs no variant.
+ * When a language has no variant for the requested tense, `fillTemplate`
+ * falls back to the (always-present) `positive`/`negative` patterns.
+ */
+export const CONSTRUCTORS = {
+  // X is an instance of Y — Wikidata P31. Mirrors Abstract Wikipedia's
+  // Z26039 "Berlin is a city" semantic fragment.
+  instance_of: {
+    roles: ['subject', 'object'],
+    description: 'X is an instance of Y (Wikidata P31)',
+    templates: {
+      en: {
+        positive: '{subject} is {article} {object}', negative: '{subject} is not {article} {object}', article: 'en-indefinite',
+        past: { positive: '{subject} was {article} {object}', negative: '{subject} was not {article} {object}' },
+        future: { positive: '{subject} will be {article} {object}', negative: '{subject} will not be {article} {object}' },
+      },
+      es: {
+        positive: '{subject} es {article} {object}', negative: '{subject} no es {article} {object}', article: 'es-indefinite',
+        past: { positive: '{subject} era {article} {object}', negative: '{subject} no era {article} {object}' },
+        future: { positive: '{subject} será {article} {object}', negative: '{subject} no será {article} {object}' },
+      },
+      fr: {
+        positive: '{subject} est {article} {object}', negative: "{subject} n'est pas {article} {object}", article: 'fr-indefinite',
+        past: { positive: '{subject} était {article} {object}', negative: "{subject} n'était pas {article} {object}" },
+        future: { positive: '{subject} sera {article} {object}', negative: '{subject} ne sera pas {article} {object}' },
+      },
+      // ru/ar instance_of past needs noun case morphology we lack — fall back
+      // to the present copula rather than emit ungrammatical case.
+      ru: { positive: '{subject} — {object}', negative: '{subject} — не {object}' },
+      zh: { positive: '{subject}是{object}', negative: '{subject}不是{object}' },
+      ar: { positive: '{subject} {object}', negative: '{subject} ليس {object}' },
+    },
+  },
+
+  // X is located in Y — Wikidata P131 / P276. The object's case is constant
+  // across tenses in every language below, so tense is safe to inflect on the
+  // verb everywhere it inflects. Russian additionally needs the object in the
+  // prepositional case after «в» (Германия → Германии); the ru template marks
+  // the object for `russianPrepositional` inflection (see `inflect` below).
+  located_in: {
+    roles: ['subject', 'object'],
+    description: 'X is located in Y (Wikidata P131/P276)',
+    templates: {
+      en: {
+        positive: '{subject} is in {object}', negative: '{subject} is not in {object}',
+        past: { positive: '{subject} was in {object}', negative: '{subject} was not in {object}' },
+        future: { positive: '{subject} will be in {object}', negative: '{subject} will not be in {object}' },
+      },
+      es: {
+        positive: '{subject} está en {object}', negative: '{subject} no está en {object}',
+        past: { positive: '{subject} estaba en {object}', negative: '{subject} no estaba en {object}' },
+        future: { positive: '{subject} estará en {object}', negative: '{subject} no estará en {object}' },
+      },
+      fr: {
+        positive: '{subject} est en {object}', negative: "{subject} n'est pas en {object}",
+        past: { positive: '{subject} était en {object}', negative: "{subject} n'était pas en {object}" },
+        future: { positive: '{subject} sera en {object}', negative: '{subject} ne sera pas en {object}' },
+      },
+      ru: {
+        positive: '{subject} находится в {object}', negative: '{subject} не находится в {object}',
+        past: { positive: '{subject} находился в {object}', negative: '{subject} не находился в {object}' },
+        future: { positive: '{subject} будет в {object}', negative: '{subject} не будет в {object}' },
+        // «в» governs the prepositional case: inflect the object's label.
+        inflect: { object: russianPrepositional },
+      },
+      zh: { positive: '{subject}在{object}', negative: '{subject}不在{object}' },
+      ar: {
+        positive: '{subject} في {object}', negative: '{subject} ليس في {object}',
+        past: { positive: '{subject} كان في {object}', negative: '{subject} لم يكن في {object}' },
+        future: { positive: '{subject} سيكون في {object}', negative: '{subject} لن يكون في {object}' },
+      },
+    },
+  },
+
+  // X measures VALUE UNIT — a quantity/measurement statement. Mirrors a
+  // Wikidata quantity claim (e.g. P2048 height, P2052 speed) carrying a
+  // numeric value and a unit. This closes the "numerical values lost in
+  // transformation" limitation: the transformer's extractQuantities() feeds
+  // { value, unit } straight into this constructor. The verb is the canonical
+  // measurement verb per language (en copula "is", es "mide", fr "mesure"),
+  // documented as a generic seed the way the other templates are.
+  quantity: {
+    roles: ['subject', 'value', 'unit'],
+    description: 'X measures VALUE UNIT (Wikidata quantity claim)',
+    templates: {
+      en: { positive: '{subject} is {value} {unit}', negative: '{subject} is not {value} {unit}' },
+      es: { positive: '{subject} mide {value} {unit}', negative: '{subject} no mide {value} {unit}' },
+      fr: { positive: '{subject} mesure {value} {unit}', negative: '{subject} ne mesure pas {value} {unit}' },
+      ru: { positive: '{subject} — {value} {unit}', negative: '{subject} — не {value} {unit}' },
+      zh: { positive: '{subject}是{value}{unit}', negative: '{subject}不是{value}{unit}' },
+      ar: { positive: '{subject} يساوي {value} {unit}', negative: '{subject} لا يساوي {value} {unit}' },
+    },
+  },
+
+  // Generic fallback: subject — predicate — object, where the predicate is
+  // itself a (property) label. This lets the round-trip render *any*
+  // text → Q/P result, not only the two specialised constructors above.
+  relation: {
+    roles: ['subject', 'predicate', 'object'],
+    description: 'Generic subject–predicate–object relation',
+    templates: {
+      en: { positive: '{subject} {predicate} {object}', negative: '{subject} does not {predicate} {object}' },
+      es: { positive: '{subject} {predicate} {object}', negative: '{subject} no {predicate} {object}' },
+      fr: { positive: '{subject} {predicate} {object}', negative: '{subject} ne {predicate} pas {object}' },
+      ru: { positive: '{subject} {predicate} {object}', negative: '{subject} не {predicate} {object}' },
+      zh: { positive: '{subject}{predicate}{object}', negative: '{subject}不{predicate}{object}' },
+      ar: { positive: '{subject} {predicate} {object}', negative: '{subject} لا {predicate} {object}' },
+    },
+  },
+};
+
+/**
+ * Build a typed constructor object.
+ *
+ * @param {string} type - A key of CONSTRUCTORS (e.g. 'instance_of')
+ * @param {Object} roles - Role → value map, e.g. { subject: 'Q64', object: 'Q515' }
+ * @param {Object} [modifiers] - Optional flags, e.g. { negated: true, tense: 'past' }
+ * @returns {Object} - The constructor
+ */
+export function buildConstructor(type, roles = {}, modifiers = {}) {
+  return { type, ...roles, ...modifiers };
+}
+
+/**
+ * Validate a constructor against the catalogue.
+ *
+ * @param {Object} constructor
+ * @throws {Error} if the type is unknown or a required role is missing
+ */
+export function validateConstructor(constructor) {
+  if (!constructor || typeof constructor !== 'object') {
+    throw new Error('Constructor must be an object');
+  }
+  const spec = CONSTRUCTORS[constructor.type];
+  if (!spec) {
+    const known = Object.keys(CONSTRUCTORS).join(', ');
+    throw new Error(`Unknown constructor type "${constructor.type}" (known: ${known})`);
+  }
+  for (const role of spec.roles) {
+    if (constructor[role] == null || constructor[role] === '') {
+      throw new Error(`Constructor "${constructor.type}" is missing role "${role}"`);
+    }
+  }
+  return true;
+}
+
+/**
+ * Fill a single language template from a constructor and a `{ id: label }`
+ * map. Pure and synchronous — the async `QPRenderer.render` is a thin
+ * wrapper that resolves labels first, then calls this.
+ *
+ * @param {Object} spec - The constructor spec (with `roles`)
+ * @param {Object} template - The per-language template (positive/negative/article)
+ * @param {Object} constructor - The constructor instance
+ * @param {Object} labels - Map of `{ id: label }`
+ * @returns {string}
+ */
+export function fillTemplate(spec, template, constructor, labels) {
+  // Select the verb forms for the requested tense, falling back to the
+  // always-present (present-tense) patterns when a language has no variant.
+  const tense = constructor.tense;
+  const forms = (tense && tense !== 'present' && template[tense]) || template;
+  const pattern = constructor.negated
+    ? (forms.negative || forms.positive)
+    : forms.positive;
+
+  let out = pattern;
+  for (const role of spec.roles) {
+    const value = constructor[role];
+    let label = (labels && labels[value]) || value || '';
+    // Apply any per-role morphological inflection the template declares
+    // (e.g. Russian prepositional case on the located_in object).
+    const inflector = template.inflect && template.inflect[role];
+    if (inflector && label) label = inflector(label);
+    out = out.split(`{${role}}`).join(label);
+  }
+
+  if (out.includes('{article}')) {
+    const objectLabel = (labels && labels[constructor.object]) || constructor.object || '';
+    let article = '';
+    switch (template.article) {
+      case 'en-indefinite':
+        article = englishIndefiniteArticle(objectLabel);
+        break;
+      case 'es-indefinite':
+        article = romanceIndefiniteArticle('es', constructor.gender);
+        break;
+      case 'fr-indefinite':
+        article = romanceIndefiniteArticle('fr', constructor.gender);
+        break;
+    }
+    out = out.split('{article}').join(article);
+  }
+
+  // Collapse any double spaces an empty article may have left behind.
+  return out.replace(/\s{2,}/g, ' ').trim();
+}
+
+export default {
+  UN6_LANGUAGES,
+  LANGUAGE_NAMES,
+  CONSTRUCTORS,
+  englishIndefiniteArticle,
+  romanceIndefiniteArticle,
+  russianPrepositional,
+  buildConstructor,
+  validateConstructor,
+  fillTemplate,
+};
diff --git a/js/src/generation/qp-to-text.js b/js/src/generation/qp-to-text.js
new file mode 100644
index 0000000..0321be3
--- /dev/null
+++ b/js/src/generation/qp-to-text.js
@@ -0,0 +1,136 @@
+// Q/P → Text renderer (reverse generation).
+//
+// This is the missing counterpart of the Text → Q/P transformer. The
+// transformer does *analysis* (text → meaning); this does *generation*
+// (meaning → text), closing the round-trip the README vision depends on
+// ("Zero-Cost Translation", "Language of Meaning"). It mirrors Abstract
+// Wikipedia's renderers: a typed constructor goes in, a sentence in any of
+// the six official UN languages comes out.
+//
+// The renderer is deliberately small and grammar-light — one templatic
+// renderer per constructor-per-language, plus English a/an phonotactics as
+// the first grammatical feature. It grows by adding constructors and
+// templates, exactly the way Abstract Wikipedia grew its grammar.
+
+import {
+  CONSTRUCTORS,
+  UN6_LANGUAGES,
+  LANGUAGE_NAMES,
+  validateConstructor,
+  fillTemplate,
+} from './constructors.js';
+
+// Pick the right Wikidata API at runtime: the browser version avoids Node's
+// `fs`/`path` imports that the file-cache backend pulls in. Mirrors the
+// runtime selection in `transformation/text-to-qp-transformer.js`.
+let WikidataAPIClient;
+async function loadApiClient() {
+  if (WikidataAPIClient) return WikidataAPIClient;
+  if (typeof window !== 'undefined') {
+    ({ WikidataAPIClient } = await import('../wikidata-api-browser.js'));
+  } else {
+    ({ WikidataAPIClient } = await import('../wikidata-api.js'));
+  }
+  return WikidataAPIClient;
+}
+
+/**
+ * Renders typed Q/P constructors into natural-language sentences.
+ */
+class QPRenderer {
+  /**
+   * @param {Object} [options]
+   * @param {Function} [options.labelProvider] - async `(ids, lang) => { id: label }`.
+   *   When supplied, the renderer never touches the network — ideal for
+   *   tests and offline use.
+   * @param {Object} [options.apiClient] - A pre-built Wikidata client with a
+   *   `getLabels(ids, lang)` method. Defaults to lazily constructing one.
+   */
+  constructor(options = {}) {
+    this.labelProvider = options.labelProvider || null;
+    this.apiClient = options.apiClient || null;
+  }
+
+  /** Languages this renderer can currently target. */
+  get languages() {
+    return [...UN6_LANGUAGES];
+  }
+
+  /** Constructor types this renderer knows how to render. */
+  get constructorTypes() {
+    return Object.keys(CONSTRUCTORS);
+  }
+
+  async _client() {
+    if (this.apiClient) return this.apiClient;
+    const Client = await loadApiClient();
+    this.apiClient = new Client();
+    return this.apiClient;
+  }
+
+  async _resolveLabels(ids, lang) {
+    if (this.labelProvider) {
+      return await this.labelProvider(ids, lang);
+    }
+    const client = await this._client();
+    return await client.getLabels(ids, lang);
+  }
+
+  /**
+   * Render a constructor into text from an already-resolved `{ id: label }`
+   * map. Pure and synchronous — no network. Use this when you have labels
+   * in hand (e.g. tests, batch pipelines).
+   *
+   * @param {Object} constructor - Typed constructor
+   * @param {Object} labels - Map of `{ id: label }`
+   * @param {string} [lang='en'] - Target language code
+   * @returns {string}
+   */
+  renderWithLabels(constructor, labels, lang = 'en') {
+    validateConstructor(constructor);
+    const spec = CONSTRUCTORS[constructor.type];
+    const template = spec.templates[lang];
+    if (!template) {
+      throw new Error(`No "${lang}" renderer for constructor "${constructor.type}"`);
+    }
+    return fillTemplate(spec, template, constructor, labels || {});
+  }
+
+  /**
+   * Render a constructor into text in one language, resolving labels via
+   * the label provider / Wikidata client as needed.
+   *
+   * @param {Object} constructor - Typed constructor
+   * @param {string} [lang='en'] - Target language code
+   * @returns {Promise<string>}
+   */
+  async render(constructor, lang = 'en') {
+    validateConstructor(constructor);
+    const spec = CONSTRUCTORS[constructor.type];
+    const ids = spec.roles
+      .map((role) => constructor[role])
+      .filter((value) => typeof value === 'string' && /^[QPL]\d+$/.test(value));
+    const labels = ids.length ? await this._resolveLabels(ids, lang) : {};
+    return this.renderWithLabels(constructor, labels, lang);
+  }
+
+  /**
+   * Render a constructor across multiple languages. Labels are fetched
+   * per-language (Wikidata labels differ by language), which is exactly the
+   * multi-language render Abstract Wikipedia demonstrates with the UN 6 set.
+   *
+   * @param {Object} constructor - Typed constructor
+   * @param {Array<string>} [langs] - Languages to render (default: UN 6)
+   * @returns {Promise<Object>} - Map of `{ lang: sentence }`
+   */
+  async renderAll(constructor, langs = UN6_LANGUAGES) {
+    const out = {};
+    for (const lang of langs) {
+      out[lang] = await this.render(constructor, lang);
+    }
+    return out;
+  }
+}
+
+export { QPRenderer, UN6_LANGUAGES, LANGUAGE_NAMES, CONSTRUCTORS };
+export default QPRenderer;
diff --git a/js/src/index.d.ts b/js/src/index.d.ts
index 7832fe3..9b035a9 100644
--- a/js/src/index.d.ts
+++ b/js/src/index.d.ts
@@ -39,6 +39,28 @@ export interface TransformOptions {
   searchLimit?: number;
   preferProperties?: boolean;
   maxNgramSize?: number;
+  /** Collapse adjacent duplicate ids in the sequence (default true). */
+  dedupe?: boolean;
+}
+
+export type QuestionType =
+  | 'entity' | 'thing' | 'time' | 'place' | 'reason' | 'manner' | 'quantity' | 'polar';
+
+export interface QuestionInfo {
+  isQuestion: boolean;
+  word: string | null;
+  type: QuestionType | null;
+}
+
+export interface Quantity {
+  value: number;
+  unit: string | null;
+  raw: string;
+}
+
+export interface Modifiers {
+  negated: boolean;
+  tense: Tense;
 }
 
 export interface TransformResult {
@@ -47,21 +69,75 @@ export interface TransformResult {
   sequence: Array<string | { type: string; alternatives: Array<{ id: string; description?: string }> }>;
   formatted: string;
   alternatives: unknown[];
+  modifiers?: Modifiers;
+  question?: QuestionInfo;
+  quantities?: Quantity[];
+  constructor?: Constructor | null;
 }
 
 export class TextToQPTransformer {
   constructor();
   transform(text: string, options?: TransformOptions): Promise<TransformResult>;
+  transformToConstructor(text: string, options?: TransformOptions): Promise<TransformResult>;
   transformWithContext(
     text: string,
     context?: Record<string, string>,
     options?: TransformOptions,
   ): Promise<TransformResult>;
+  extractModifiers(text: string): Modifiers;
+  detectQuestion(text: string): QuestionInfo;
+  extractQuantities(text: string): Quantity[];
+  dedupeSequence(sequence: TransformResult['sequence']): TransformResult['sequence'];
+  toConstructor(result: TransformResult): Constructor | null;
 }
 
 export function formatSequenceAsLino(sequence: TransformResult['sequence']): string;
 export function formatTransformResultAsLino(result: TransformResult): string;
 
+// ---------------------------------------------------------------------------
+// Generation (reverse: Q/P -> text)
+// ---------------------------------------------------------------------------
+
+export type Tense = 'past' | 'present' | 'future';
+export type Gender = 'masculine' | 'feminine' | 'm' | 'f';
+
+/** A typed, role-labelled constructor consumed by the renderer. */
+export interface Constructor {
+  type: string;
+  subject?: string;
+  predicate?: string | null;
+  object?: string | null;
+  value?: string | number | null;
+  unit?: string | null;
+  negated?: boolean;
+  tense?: Tense;
+  /** Grammatical gender of the object noun (drives Romance article agreement). */
+  gender?: Gender;
+  [role: string]: unknown;
+}
+
+export interface QPRendererOptions {
+  labelProvider?: (ids: string[], lang: string) => Promise<Record<string, string>>;
+  apiClient?: WikidataAPIClient;
+}
+
+export class QPRenderer {
+  constructor(options?: QPRendererOptions);
+  readonly languages: string[];
+  readonly constructorTypes: string[];
+  renderWithLabels(constructor: Constructor, labels: Record<string, string>, lang?: string): string;
+  render(constructor: Constructor, lang?: string): Promise<string>;
+  renderAll(constructor: Constructor, langs?: string[]): Promise<Record<string, string>>;
+}
+
+export const CONSTRUCTORS: Record<string, { roles: string[]; description: string; templates: Record<string, unknown> }>;
+export const UN6_LANGUAGES: readonly string[];
+export const LANGUAGE_NAMES: Record<string, string>;
+export function buildConstructor(type: string, roles?: Record<string, unknown>, modifiers?: Record<string, unknown>): Constructor;
+export function validateConstructor(constructor: Constructor): boolean;
+export function englishIndefiniteArticle(word: string): 'a' | 'an';
+export function romanceIndefiniteArticle(lang: string, gender?: Gender): string;
+
 // ---------------------------------------------------------------------------
 // Wikidata API
 // ---------------------------------------------------------------------------
@@ -72,6 +148,8 @@ export class WikidataAPIClient {
   fetchEntities(ids: string | string[], props?: string, languages?: string): Promise<unknown>;
   fetchProperty(id: string, languages?: string): Promise<unknown>;
   fetchLabels(ids: string[], languages?: string): Promise<unknown>;
+  getLabels(ids: string[] | string, language?: string): Promise<Record<string, string>>;
+  searchLexemes(term: string, language?: string, limit?: number): Promise<Array<{ id: string; label: string; description: string }>>;
   searchExactMatch(query: string, languages?: string, limit?: number, type?: string): Promise<unknown>;
   searchFuzzy(query: string, languages?: string, limit?: number, type?: string): Promise<unknown>;
   setCacheType(cacheType: string, cacheOptions?: Record<string, unknown>): void;
diff --git a/js/src/index.js b/js/src/index.js
index f7c0a5f..959f89a 100644
--- a/js/src/index.js
+++ b/js/src/index.js
@@ -27,6 +27,18 @@ export {
 
 export { TextToQPTransformer } from './transformation/text-to-qp-transformer.js';
 
+export { QPRenderer } from './generation/qp-to-text.js';
+
+export {
+  CONSTRUCTORS,
+  UN6_LANGUAGES,
+  LANGUAGE_NAMES,
+  buildConstructor,
+  validateConstructor,
+  englishIndefiniteArticle,
+  romanceIndefiniteArticle,
+} from './generation/constructors.js';
+
 export {
   formatSequenceAsLino,
   formatTransformResultAsLino,
diff --git a/js/src/transformation/text-to-qp-transformer.js b/js/src/transformation/text-to-qp-transformer.js
index f836f2b..19bc7c0 100644
--- a/js/src/transformation/text-to-qp-transformer.js
+++ b/js/src/transformation/text-to-qp-transformer.js
@@ -2,6 +2,8 @@
 // Transforms English text into sequences of Wikidata entities (Q) and properties (P)
 // with disambiguation support using [Q1 or Q2 or Q3] syntax
 
+import { buildConstructor } from '../generation/constructors.js';
+
 // Pick the right Wikidata API at runtime: the browser version avoids Node's
 // `fs`/`path` imports that the file-cache backend pulls in.
 let WikidataAPIClient, WikidataSearchUtility;
@@ -37,6 +39,26 @@ class TextToQPTransformer {
     
     // Words to skip entirely
     this.stopWords = ['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'];
+
+    // Tense markers. Today the flat-list output silently drops these (see
+    // limitations-found.json), so "discovered" and "discovers" collapse to
+    // the same sequence. The typed constructor keeps them as a `tense` slot.
+    this.pastTenseWords = ['was', 'were', 'had', 'did'];
+    this.futureTenseWords = ['will', 'shall'];
+
+    // A small set of common irregular past-tense verbs the regular `-ed`
+    // rule cannot catch. Not exhaustive — a documented seed, the same way
+    // Abstract Wikipedia grows its lexicon incrementally.
+    this.irregularPastWords = [
+      'wrote', 'built', 'made', 'found', 'bought', 'taught', 'sought',
+      'brought', 'came', 'ran', 'went', 'saw', 'took', 'gave', 'led',
+      'held', 'drew', 'became', 'won', 'lost', 'met', 'kept', 'sent',
+      'spent', 'told', 'sold', 'paid', 'said', 'began', 'wore', 'knew',
+    ];
+
+    // `instance of` indicators that map a generic relation onto the
+    // specialised `instance_of` constructor the renderer knows about.
+    this.instanceOfWords = ['is', 'was', 'are', 'were', 'instance of'];
   }
 
   /**
@@ -51,7 +73,8 @@ class TextToQPTransformer {
       includeLabels = false,
       searchLimit = 10,
       preferProperties = false,
-      maxNgramSize = 3 // Configurable max n-gram size
+      maxNgramSize = 3, // Configurable max n-gram size
+      dedupe = true // Collapse adjacent duplicate ids (see dedupeSequence)
     } = options;
 
     const result = {
@@ -76,8 +99,9 @@ class TextToQPTransformer {
       // Match tokens using longest-first priority
       const matches = this.matchTokensWithPriority(tokens, ngramResults, maxCandidates, includeLabels);
       
-      // Build the final sequence
-      result.sequence = matches;
+      // Build the final sequence, collapsing adjacent duplicate ids unless
+      // the caller opts out.
+      result.sequence = dedupe ? this.dedupeSequence(matches) : matches;
 
       // Format the final sequence
       result.formatted = this.formatSequence(result.sequence);
@@ -409,6 +433,245 @@ class TextToQPTransformer {
     return alternatives;
   }
 
+  /**
+   * Extract structural modifiers (negation, tense) from the input text.
+   *
+   * The flat Q/P list drops meaning-bearing words like "not" and tense
+   * markers — exactly the cluster of failures documented in
+   * `limitations-found.json`. Abstract Wikipedia keeps these structurally
+   * (in the constructor), so we capture them as explicit flags rather than
+   * discarding the tokens.
+   *
+   * @param {string} text - The original input text
+   * @returns {{negated: boolean, tense: 'past'|'present'|'future'}}
+   */
+  extractModifiers(text) {
+    const lower = ` ${(text || '').toLowerCase()} `;
+    const tokens = this.tokenize(text || '').map((t) => t.toLowerCase());
+
+    // Negation: "not", contracted "n't", or "never".
+    const negated = /\bnot\b|n't|\bnever\b/.test(lower);
+
+    // Tense: explicit markers first, then a regular `-ed` past-tense fallback.
+    let tense = 'present';
+    if (tokens.some((t) => this.futureTenseWords.includes(t))) {
+      tense = 'future';
+    } else if (
+      tokens.some((t) => this.pastTenseWords.includes(t)) ||
+      tokens.some((t) => this.irregularPastWords.includes(t)) ||
+      tokens.some((t) => /[a-z]{3,}ed$/.test(t))
+    ) {
+      tense = 'past';
+    }
+
+    return { negated, tense };
+  }
+
+  /**
+   * Detect whether the input is a question and classify it.
+   *
+   * Questions are the second cluster of failures documented in
+   * `limitations-found.json` ("Who/What/When question" are *treated as
+   * statements*). A flat Q/P list cannot express interrogation; Abstract
+   * Wikipedia keeps it structurally. We capture it as an explicit flag plus a
+   * coarse semantic type so a downstream renderer (or query layer) knows what
+   * is being asked for, rather than silently dropping the wh-word.
+   *
+   * @param {string} text - The original input text
+   * @returns {{isQuestion: boolean, word: string|null, type: string|null}}
+   *   `type` is one of entity / thing / time / place / reason / manner /
+   *   quantity / polar (yes-no), or null when not a question.
+   */
+  detectQuestion(text) {
+    const trimmed = (text || '').trim();
+    if (!trimmed) return { isQuestion: false, word: null, type: null };
+
+    const lower = trimmed.toLowerCase();
+    const first = this.tokenize(lower)[0] || '';
+
+    // Wh-words map to the kind of thing being asked for.
+    const whTypes = {
+      who: 'entity', whom: 'entity', whose: 'entity',
+      what: 'thing', which: 'thing',
+      when: 'time', where: 'place', why: 'reason', how: 'manner',
+    };
+    // "How many / how much" asks for a quantity.
+    if (first === 'how' && /^how\s+(many|much)\b/.test(lower)) {
+      return { isQuestion: true, word: 'how', type: 'quantity' };
+    }
+    if (Object.prototype.hasOwnProperty.call(whTypes, first)) {
+      return { isQuestion: true, word: first, type: whTypes[first] };
+    }
+
+    // Yes/no (polar) questions open with an auxiliary/copula verb, or any
+    // sentence ending in a question mark we have not otherwise classified.
+    const auxiliaries = [
+      'is', 'are', 'was', 'were', 'am', 'be',
+      'do', 'does', 'did', 'has', 'have', 'had',
+      'can', 'could', 'will', 'would', 'shall', 'should', 'may', 'might', 'must',
+    ];
+    if (auxiliaries.includes(first) && trimmed.endsWith('?')) {
+      return { isQuestion: true, word: first, type: 'polar' };
+    }
+    if (trimmed.endsWith('?')) {
+      return { isQuestion: true, word: null, type: 'polar' };
+    }
+
+    return { isQuestion: false, word: null, type: null };
+  }
+
+  /**
+   * Extract numeric quantities (with their units) from the input.
+   *
+   * "Numerical values lost in transformation" is the third documented
+   * limitation: "Mount Everest is 8848 meters tall" produced an empty
+   * sequence because bare numbers match no Wikidata entity. Rather than drop
+   * them, we surface them as structured `{ value, unit }` pairs the way
+   * Wikidata models a quantity statement (P1082 population, P2048 height, …)
+   * with a unit (Q-item) — and the way the new `quantity` constructor renders
+   * them back to text.
+   *
+   * @param {string} text - The original input text
+   * @returns {Array<{value: number, unit: string|null, raw: string}>}
+   */
+  extractQuantities(text) {
+    if (!text) return [];
+    const out = [];
+    // A number (optionally grouped with commas / a decimal point) followed by
+    // an optional unit word, which may itself be a "<unit> per <unit>" rate.
+    const re = /(-?\d[\d,]*(?:\.\d+)?)\s*([a-zA-Z%°]+(?:\s+per\s+[a-zA-Z]+)?)?/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const value = parseFloat(m[1].replace(/,/g, ''));
+      if (Number.isNaN(value)) continue;
+      let unit = (m[2] || '').trim() || null;
+      // A trailing word that is a stop word ("a", "the", …) is not a unit.
+      if (unit && this.stopWords.includes(unit.toLowerCase())) unit = null;
+      out.push({ value, unit, raw: m[0].trim() });
+    }
+    return out;
+  }
+
+  /**
+   * Collapse consecutive identical ids in a matched sequence.
+   *
+   * "Repeated entities not properly deduplicated" is the final documented
+   * limitation: "Paris Paris France France" produced "Q90 Q90 Q142 Q142".
+   * Adjacent repetition of the *same* id is almost always an analysis
+   * artefact rather than meaning, so we collapse runs of it. Ambiguous
+   * matches are never merged (their alternatives may differ even when the
+   * bracketed text looks the same).
+   *
+   * @param {Array} sequence - Matched Q/P items
+   * @returns {Array} - The sequence with adjacent duplicates removed
+   */
+  dedupeSequence(sequence) {
+    const out = [];
+    for (const item of sequence) {
+      const prev = out[out.length - 1];
+      if (
+        prev && item &&
+        prev.type !== 'ambiguous' && item.type !== 'ambiguous' &&
+        prev.id === item.id
+      ) {
+        continue;
+      }
+      out.push(item);
+    }
+    return out;
+  }
+
+  /**
+   * Convert a transform() result into a typed, role-labelled constructor —
+   * the representation the multi-language generation service consumes. This
+   * is the bridge that makes the round-trip `text → Q/P → text` possible.
+   *
+   * It reads the sequence left-to-right, taking the first entity (Q) as the
+   * subject, the first property (P) as the predicate, and the next entity
+   * (Q) as the object. A `P31` predicate (or an `is/was` indicator) maps to
+   * the specialised `instance_of` constructor; anything else becomes the
+   * generic `relation` constructor. Negation and tense are preserved as
+   * modifier flags.
+   *
+   * @param {Object} result - The return value of `transform`
+   * @returns {Object|null} - A typed constructor, or null if no subject was found
+   */
+  toConstructor(result) {
+    if (!result || !Array.isArray(result.sequence)) return null;
+
+    // Collapse the sequence to its primary ids (first candidate of any
+    // ambiguous match), keeping the textual order.
+    const items = result.sequence
+      .filter(Boolean)
+      .map((item) => {
+        if (item.type === 'ambiguous' && item.alternatives && item.alternatives.length) {
+          return { id: item.alternatives[0].id };
+        }
+        return { id: item.id };
+      })
+      .filter((item) => /^[QP]\d+$/.test(item.id));
+
+    let subject = null;
+    let predicate = null;
+    let object = null;
+    for (const { id } of items) {
+      if (id.startsWith('Q')) {
+        if (subject == null) subject = id;
+        else if (object == null) object = id;
+      } else if (id.startsWith('P') && predicate == null) {
+        predicate = id;
+      }
+    }
+
+    if (subject == null) return null;
+
+    const { negated, tense } = this.extractModifiers(result.original || '');
+
+    // A measurement ("Mount Everest is 8848 meters tall") maps to the
+    // quantity constructor rather than a bare instance_of/relation, so the
+    // number and unit survive the round-trip instead of being dropped.
+    const quantity = Array.isArray(result.quantities)
+      ? result.quantities.find((q) => q.unit)
+      : null;
+    if (quantity) {
+      return buildConstructor(
+        'quantity',
+        { subject, value: quantity.value, unit: quantity.unit },
+        { negated, tense },
+      );
+    }
+
+    const lower = (result.original || '').toLowerCase();
+    const isInstanceOf = predicate === 'P31'
+      || this.instanceOfWords.some((w) => new RegExp(`\\b${w}\\b`).test(lower));
+
+    if (isInstanceOf && object != null) {
+      return buildConstructor('instance_of', { subject, object }, { negated, tense });
+    }
+    if (predicate != null && object != null) {
+      return buildConstructor('relation', { subject, predicate, object }, { negated, tense });
+    }
+    // Not enough structure for a full relation — still surface what we have.
+    return buildConstructor('relation', { subject, predicate: predicate || null, object: object || null }, { negated, tense });
+  }
+
+  /**
+   * Transform text and additionally return the typed constructor.
+   *
+   * @param {string} text - Text to transform
+   * @param {Object} options - Transformation options
+   * @returns {Promise<Object>} - The transform() result with a `constructor`
+   *   field and a `modifiers` field added.
+   */
+  async transformToConstructor(text, options = {}) {
+    const result = await this.transform(text, options);
+    result.modifiers = this.extractModifiers(text);
+    result.question = this.detectQuestion(text);
+    result.quantities = this.extractQuantities(text);
+    result.constructor = this.toConstructor(result);
+    return result;
+  }
+
   /**
    * Transform with context for better disambiguation
    * @param {string} text - Text to transform
diff --git a/js/src/wikidata-api-browser.js b/js/src/wikidata-api-browser.js
index c5718f9..b4bc6cf 100644
--- a/js/src/wikidata-api-browser.js
+++ b/js/src/wikidata-api-browser.js
@@ -95,6 +95,72 @@ class WikidataAPIClient {
     return data.entities || {};
   }
 
+  /**
+   * Fetch entity/property labels in batch and flatten them into a simple
+   * `{ id: label }` map for the requested language — the round-trip
+   * counterpart used by the multi-language generation service.
+   *
+   * @param {Array<string>|string} ids - One or more Q/P ids
+   * @param {string} language - A single language code (e.g. 'en', 'es')
+   * @returns {Promise<Object>} - Map of `{ id: label }`; ids without a label
+   *                              in the requested language fall back to the id
+   */
+  async getLabels(ids, language = 'en') {
+    const idList = Array.isArray(ids) ? ids : [ids];
+    const unique = [...new Set(idList.filter(Boolean))];
+    const out = {};
+    if (unique.length === 0) {
+      return out;
+    }
+
+    const entities = await this.fetchLabels(unique, language);
+    for (const id of unique) {
+      const entity = entities[id];
+      const label = entity && entity.labels && entity.labels[language]
+        ? entity.labels[language].value
+        : null;
+      out[id] = label || id;
+    }
+    return out;
+  }
+
+  /**
+   * Search Wikidata Lexemes (L-ids) by a search term — the lexeme-search
+   * counterpart of entity/property search, used for morphology-aware
+   * disambiguation and generation.
+   *
+   * @param {string} term - Search term (a word/lemma)
+   * @param {string} language - Language to search in (default: 'en')
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Array>} - Array of `{ id, label, description }` lexeme matches
+   */
+  async searchLexemes(term, language = 'en', limit = 10) {
+    if (!term) {
+      return [];
+    }
+
+    const url = this.buildApiUrl({
+      action: 'wbsearchentities',
+      search: term,
+      language: language,
+      type: 'lexeme',
+      limit: limit,
+      format: 'json'
+    });
+
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+    return (data.search || []).map((item) => ({
+      id: item.id,
+      label: item.label,
+      description: item.description || ''
+    }));
+  }
+
   /**
    * Fetch property data
    * @param {string} propertyId - Property ID (e.g., 'P31')
diff --git a/js/src/wikidata-api.js b/js/src/wikidata-api.js
index 8d0fb24..eacaad8 100644
--- a/js/src/wikidata-api.js
+++ b/js/src/wikidata-api.js
@@ -96,6 +96,76 @@ class WikidataAPIClient {
     return data.entities || {};
   }
 
+  /**
+   * Fetch entity/property labels in batch and flatten them into a simple
+   * `{ id: label }` map for the requested language. This is the round-trip
+   * counterpart used by the multi-language generation service, which needs
+   * to turn a list of Q/P ids into human-readable words with a single API
+   * round-trip rather than one request per id.
+   *
+   * @param {Array<string>|string} ids - One or more Q/P ids
+   * @param {string} language - A single language code (e.g. 'en', 'es')
+   * @returns {Promise<Object>} - Map of `{ id: label }`; ids without a label
+   *                              in the requested language fall back to the id
+   */
+  async getLabels(ids, language = 'en') {
+    const idList = Array.isArray(ids) ? ids : [ids];
+    const unique = [...new Set(idList.filter(Boolean))];
+    const out = {};
+    if (unique.length === 0) {
+      return out;
+    }
+
+    const entities = await this.fetchLabels(unique, language);
+    for (const id of unique) {
+      const entity = entities[id];
+      const label = entity && entity.labels && entity.labels[language]
+        ? entity.labels[language].value
+        : null;
+      out[id] = label || id;
+    }
+    return out;
+  }
+
+  /**
+   * Search Wikidata Lexemes (L-ids) by a search term. Lexemes are
+   * first-class lexical units in Wikidata — distinct from items (Q) and
+   * properties (P) — and carry the morphological forms and senses that the
+   * generation service and morphology-aware search rely on. The existing
+   * search only covers items and properties; this closes that gap.
+   *
+   * @param {string} term - Search term (a word/lemma)
+   * @param {string} language - Language to search in (default: 'en')
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Array>} - Array of `{ id, label, description }` lexeme matches
+   */
+  async searchLexemes(term, language = 'en', limit = 10) {
+    if (!term) {
+      return [];
+    }
+
+    const url = this.buildApiUrl({
+      action: 'wbsearchentities',
+      search: term,
+      language: language,
+      type: 'lexeme',
+      limit: limit,
+      format: 'json'
+    });
+
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+    return (data.search || []).map((item) => ({
+      id: item.id,
+      label: item.label,
+      description: item.description || ''
+    }));
+  }
+
   /**
    * Fetch property data
    * @param {string} propertyId - Property ID (e.g., 'P31')
diff --git a/js/tests/e2e/app.spec.mjs b/js/tests/e2e/app.spec.mjs
index 7885def..9b8b9cf 100644
--- a/js/tests/e2e/app.spec.mjs
+++ b/js/tests/e2e/app.spec.mjs
@@ -35,7 +35,7 @@ async function attachErrorCollectors(page) {
 }
 
 test.describe('Unified SPA - app.html', () => {
-  test('landing page renders with all six mode tabs', async ({ page }) => {
+  test('landing page renders with all seven mode tabs', async ({ page }) => {
     const errors = await attachErrorCollectors(page);
     await page.goto(APP);
     await expect(page.getByRole('button', { name: 'Alphabet' })).toBeVisible();
@@ -44,6 +44,7 @@ test.describe('Unified SPA - app.html', () => {
     await expect(page.getByRole('button', { name: 'Entities' })).toBeVisible();
     await expect(page.getByRole('button', { name: 'Properties' })).toBeVisible();
     await expect(page.getByRole('button', { name: 'Transformer' })).toBeVisible();
+    await expect(page.getByRole('button', { name: 'Generation' })).toBeVisible();
     expect(errors).toEqual([]);
   });
 });
@@ -142,3 +143,50 @@ test.describe('Transformer mode - regression for issue #35', () => {
     await expect(ta).toHaveValue('');
   });
 });
+
+test.describe('Generation mode (Q/P → text)', () => {
+  test('mode boots and the Generate button is enabled', async ({ page }) => {
+    const errors = await attachErrorCollectors(page);
+    await page.goto(`${APP}#mode=generation`);
+
+    await expect(page.getByRole('heading', { name: 'Generation', exact: false })).toBeVisible({ timeout: 10000 });
+    await expect(page.locator('body')).not.toContainText('Failed to load renderer');
+    await expect(page.locator('body')).not.toContainText('require is not defined');
+
+    const generateBtn = page.getByRole('button', { name: 'Generate', exact: true });
+    await expect(generateBtn).toBeVisible();
+    await expect(generateBtn).toBeEnabled({ timeout: 5000 });
+    expect(errors).toEqual([]);
+  });
+
+  test('Generate renders the default constructor across the UN 6 languages offline', async ({ page }) => {
+    const errors = await attachErrorCollectors(page);
+    await page.goto(`${APP}#mode=generation`);
+    await page.getByRole('button', { name: 'Generate', exact: true }).waitFor({ state: 'visible' });
+    await page.getByRole('button', { name: 'Generate', exact: true }).click();
+
+    // Plain-text role values render with no Wikidata round-trip, so the
+    // English sentence is deterministic.
+    await expect(page.locator('body')).toContainText('Sentences', { timeout: 10000 });
+    await expect(page.locator('body')).toContainText('Berlin is a city');
+    await expect(page.locator('body')).toContainText('English');
+    await expect(page.locator('body')).toContainText('Chinese');
+    expect(errors).toEqual([]);
+  });
+
+  test('quantity constructor exposes value/unit fields and renders a measurement offline', async ({ page }) => {
+    const errors = await attachErrorCollectors(page);
+    await page.goto(`${APP}#mode=generation`);
+    await page.getByRole('button', { name: 'Generate', exact: true }).waitFor({ state: 'visible' });
+
+    // Switching to the quantity constructor swaps Object out for Value + Unit.
+    await page.getByRole('combobox').first().selectOption('quantity');
+    await page.getByRole('textbox', { name: 'Subject' }).fill('Mount Everest');
+    await page.getByRole('textbox', { name: 'Value' }).fill('8848');
+    await page.getByRole('textbox', { name: 'Unit' }).fill('meters');
+    await page.getByRole('button', { name: 'Generate', exact: true }).click();
+
+    await expect(page.locator('body')).toContainText('Mount Everest is 8848 meters', { timeout: 10000 });
+    expect(errors).toEqual([]);
+  });
+});
diff --git a/js/tests/unit/qp-to-text.test.mjs b/js/tests/unit/qp-to-text.test.mjs
new file mode 100644
index 0000000..e42ffb6
--- /dev/null
+++ b/js/tests/unit/qp-to-text.test.mjs
@@ -0,0 +1,435 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  englishIndefiniteArticle,
+  romanceIndefiniteArticle,
+  russianPrepositional,
+  fillTemplate,
+  validateConstructor,
+  buildConstructor,
+  CONSTRUCTORS,
+  UN6_LANGUAGES,
+} from '../../src/generation/constructors.js';
+import { QPRenderer } from '../../src/generation/qp-to-text.js';
+import { TextToQPTransformer } from '../../src/transformation/text-to-qp-transformer.js';
+
+// A small offline label dictionary so the renderer never touches the network.
+const LABELS = {
+  en: { Q64: 'Berlin', Q515: 'city', Q183: 'Germany', Q1: 'island', P50: 'author', Q571: 'book' },
+  es: { Q64: 'Berlín', Q515: 'ciudad', Q183: 'Alemania', Q571: 'libro' },
+  fr: { Q64: 'Berlin', Q515: 'ville', Q183: 'Allemagne', Q571: 'livre' },
+  ru: { Q64: 'Берлин', Q515: 'город', Q183: 'Германия' },
+  zh: { Q64: '柏林', Q515: '城市', Q183: '德国' },
+  ar: { Q64: 'برلين', Q515: 'مدينة', Q183: 'ألمانيا' },
+};
+
+const labelProvider = async (_ids, lang) => LABELS[lang] || {};
+
+// ---------------------------------------------------------------------------
+// Phonotactics
+// ---------------------------------------------------------------------------
+
+test('englishIndefiniteArticle picks "an" before a vowel and "a" otherwise', () => {
+  assert.equal(englishIndefiniteArticle('island'), 'an');
+  assert.equal(englishIndefiniteArticle('apple'), 'an');
+  assert.equal(englishIndefiniteArticle('city'), 'a');
+  assert.equal(englishIndefiniteArticle(''), 'a');
+  assert.equal(englishIndefiniteArticle(undefined), 'a');
+});
+
+test('romanceIndefiniteArticle agrees with gender and falls back to masculine', () => {
+  assert.equal(romanceIndefiniteArticle('es', 'feminine'), 'una');
+  assert.equal(romanceIndefiniteArticle('es', 'f'), 'una');
+  assert.equal(romanceIndefiniteArticle('es', 'masculine'), 'un');
+  assert.equal(romanceIndefiniteArticle('es', undefined), 'un'); // documented fallback
+  assert.equal(romanceIndefiniteArticle('fr', 'feminine'), 'une');
+  assert.equal(romanceIndefiniteArticle('fr', undefined), 'un');
+  assert.equal(romanceIndefiniteArticle('de', 'feminine'), ''); // unsupported language
+});
+
+test('russianPrepositional inflects declinable nouns and leaves the rest untouched', () => {
+  // Regular prepositional endings.
+  assert.equal(russianPrepositional('Германия'), 'Германии');
+  assert.equal(russianPrepositional('Россия'), 'России');
+  assert.equal(russianPrepositional('Москва'), 'Москве');
+  assert.equal(russianPrepositional('Китай'), 'Китае');
+  assert.equal(russianPrepositional('город'), 'городе');
+  assert.equal(russianPrepositional('Лондон'), 'Лондоне');
+  // Indeclinable foreign vowel endings stay as-is — inflecting them is wrong.
+  assert.equal(russianPrepositional('Токио'), 'Токио');
+  assert.equal(russianPrepositional('Чикаго'), 'Чикаго');
+  assert.equal(russianPrepositional('Перу'), 'Перу');
+  // Abbreviations, non-Cyrillic words and gender-ambiguous soft signs: untouched.
+  assert.equal(russianPrepositional('США'), 'США');
+  assert.equal(russianPrepositional('Germany'), 'Germany');
+  assert.equal(russianPrepositional('Тверь'), 'Тверь');
+  assert.equal(russianPrepositional(''), '');
+  assert.equal(russianPrepositional(undefined), undefined);
+});
+
+// ---------------------------------------------------------------------------
+// Constructor validation
+// ---------------------------------------------------------------------------
+
+test('validateConstructor accepts a well-formed constructor', () => {
+  assert.equal(validateConstructor({ type: 'instance_of', subject: 'Q64', object: 'Q515' }), true);
+});
+
+test('validateConstructor rejects unknown types and missing roles', () => {
+  assert.throws(() => validateConstructor({ type: 'nope', subject: 'Q1' }), /Unknown constructor/);
+  assert.throws(() => validateConstructor({ type: 'instance_of', subject: 'Q64' }), /missing role "object"/);
+  assert.throws(() => validateConstructor(null), /must be an object/);
+});
+
+test('buildConstructor merges roles and modifiers', () => {
+  const c = buildConstructor('instance_of', { subject: 'Q64', object: 'Q515' }, { negated: true });
+  assert.deepEqual(c, { type: 'instance_of', subject: 'Q64', object: 'Q515', negated: true });
+});
+
+// ---------------------------------------------------------------------------
+// fillTemplate (pure)
+// ---------------------------------------------------------------------------
+
+test('fillTemplate applies English a/an phonotactics', () => {
+  const spec = CONSTRUCTORS.instance_of;
+  const tpl = spec.templates.en;
+  assert.equal(
+    fillTemplate(spec, tpl, { type: 'instance_of', subject: 'Q64', object: 'Q515' }, LABELS.en),
+    'Berlin is a city',
+  );
+  assert.equal(
+    fillTemplate(spec, tpl, { type: 'instance_of', subject: 'Q64', object: 'Q1' }, LABELS.en),
+    'Berlin is an island',
+  );
+});
+
+// ---------------------------------------------------------------------------
+// QPRenderer.renderWithLabels — multi-language + negation
+// ---------------------------------------------------------------------------
+
+test('renderWithLabels renders instance_of across the UN 6 languages', () => {
+  const r = new QPRenderer();
+  // ciudad/ville are feminine, so the Romance article agrees: una/une.
+  const c = { type: 'instance_of', subject: 'Q64', object: 'Q515', gender: 'feminine' };
+  assert.equal(r.renderWithLabels(c, LABELS.en, 'en'), 'Berlin is a city');
+  assert.equal(r.renderWithLabels(c, LABELS.es, 'es'), 'Berlín es una ciudad');
+  assert.equal(r.renderWithLabels(c, LABELS.fr, 'fr'), 'Berlin est une ville');
+  assert.equal(r.renderWithLabels(c, LABELS.ru, 'ru'), 'Берлин — город');
+  assert.equal(r.renderWithLabels(c, LABELS.zh, 'zh'), '柏林是城市');
+  assert.equal(r.renderWithLabels(c, LABELS.ar, 'ar'), 'برلين مدينة');
+});
+
+test('renderWithLabels agrees the Romance indefinite article with grammatical gender', () => {
+  const r = new QPRenderer();
+  // Feminine object -> una / une.
+  const fem = { type: 'instance_of', subject: 'Q64', object: 'Q515', gender: 'feminine' };
+  assert.equal(r.renderWithLabels(fem, LABELS.es, 'es'), 'Berlín es una ciudad');
+  assert.equal(r.renderWithLabels(fem, LABELS.fr, 'fr'), 'Berlin est une ville');
+  // Masculine object (libro/livre) -> un / un.
+  const masc = { type: 'instance_of', subject: 'Q64', object: 'Q571', gender: 'masculine' };
+  assert.equal(r.renderWithLabels(masc, LABELS.es, 'es'), 'Berlín es un libro');
+  assert.equal(r.renderWithLabels(masc, LABELS.fr, 'fr'), 'Berlin est un livre');
+  // No gender supplied -> documented masculine fallback (un), not a crash.
+  const dflt = { type: 'instance_of', subject: 'Q64', object: 'Q571' };
+  assert.equal(r.renderWithLabels(dflt, LABELS.es, 'es'), 'Berlín es un libro');
+  assert.equal(r.renderWithLabels(dflt, LABELS.fr, 'fr'), 'Berlin est un livre');
+});
+
+test('renderWithLabels honours the negated flag', () => {
+  const r = new QPRenderer();
+  const c = { type: 'instance_of', subject: 'Q64', object: 'Q515', negated: true };
+  assert.equal(r.renderWithLabels(c, LABELS.en, 'en'), 'Berlin is not a city');
+  assert.equal(r.renderWithLabels(c, LABELS.zh, 'zh'), '柏林不是城市');
+  assert.equal(r.renderWithLabels(c, LABELS.ru, 'ru'), 'Берлин — не город');
+});
+
+test('renderWithLabels inflects tense on the copula where it is grammatical', () => {
+  const r = new QPRenderer();
+  // instance_of: en/es/fr inflect; ru/zh/ar keep the present copula form.
+  const past = { type: 'instance_of', subject: 'Q64', object: 'Q515', tense: 'past', gender: 'feminine' };
+  assert.equal(r.renderWithLabels(past, LABELS.en, 'en'), 'Berlin was a city');
+  assert.equal(r.renderWithLabels(past, LABELS.es, 'es'), 'Berlín era una ciudad');
+  assert.equal(r.renderWithLabels(past, LABELS.fr, 'fr'), 'Berlin était une ville');
+  assert.equal(r.renderWithLabels(past, LABELS.ru, 'ru'), 'Берлин — город'); // graceful fallback
+  const future = { type: 'instance_of', subject: 'Q64', object: 'Q1', tense: 'future' };
+  assert.equal(r.renderWithLabels(future, LABELS.en, 'en'), 'Berlin will be an island');
+});
+
+test('renderWithLabels combines tense and negation', () => {
+  const r = new QPRenderer();
+  const c = { type: 'instance_of', subject: 'Q64', object: 'Q515', tense: 'past', negated: true, gender: 'feminine' };
+  assert.equal(r.renderWithLabels(c, LABELS.en, 'en'), 'Berlin was not a city');
+  assert.equal(r.renderWithLabels(c, LABELS.fr, 'fr'), "Berlin n'était pas une ville");
+});
+
+test('renderWithLabels inflects located_in tense across en/es/fr/ru/ar', () => {
+  const r = new QPRenderer();
+  const past = { type: 'located_in', subject: 'Q64', object: 'Q183', tense: 'past' };
+  assert.equal(r.renderWithLabels(past, LABELS.en, 'en'), 'Berlin was in Germany');
+  assert.equal(r.renderWithLabels(past, LABELS.es, 'es'), 'Berlín estaba en Alemania');
+  assert.equal(r.renderWithLabels(past, LABELS.fr, 'fr'), 'Berlin était en Allemagne');
+  // Russian «в» governs the prepositional case: Германия → Германии.
+  assert.equal(r.renderWithLabels(past, LABELS.ru, 'ru'), 'Берлин находился в Германии');
+  const future = { type: 'located_in', subject: 'Q64', object: 'Q183', tense: 'future' };
+  assert.equal(r.renderWithLabels(future, LABELS.en, 'en'), 'Berlin will be in Germany');
+  assert.equal(r.renderWithLabels(future, LABELS.ru, 'ru'), 'Берлин будет в Германии');
+});
+
+test('renderWithLabels puts the Russian located_in object in the prepositional case', () => {
+  const r = new QPRenderer();
+  const c = { type: 'located_in', subject: 'Q64', object: 'Q183' };
+  assert.equal(r.renderWithLabels(c, LABELS.ru, 'ru'), 'Берлин находится в Германии');
+  const neg = { type: 'located_in', subject: 'Q64', object: 'Q183', negated: true };
+  assert.equal(r.renderWithLabels(neg, LABELS.ru, 'ru'), 'Берлин не находится в Германии');
+});
+
+test('renderWithLabels treats an explicit present tense like the default', () => {
+  const r = new QPRenderer();
+  const c = { type: 'instance_of', subject: 'Q64', object: 'Q515', tense: 'present' };
+  assert.equal(r.renderWithLabels(c, LABELS.en, 'en'), 'Berlin is a city');
+});
+
+test('renderWithLabels supports the located_in constructor', () => {
+  const r = new QPRenderer();
+  const c = { type: 'located_in', subject: 'Q64', object: 'Q183' };
+  assert.equal(r.renderWithLabels(c, LABELS.en, 'en'), 'Berlin is in Germany');
+  assert.equal(r.renderWithLabels(c, LABELS.fr, 'fr'), 'Berlin est en Allemagne');
+});
+
+test('renderWithLabels supports the generic relation constructor with a predicate label', () => {
+  const r = new QPRenderer();
+  const c = { type: 'relation', subject: 'Q64', predicate: 'P50', object: 'Q571' };
+  assert.equal(r.renderWithLabels(c, LABELS.en, 'en'), 'Berlin author book');
+});
+
+test('renderWithLabels renders the quantity constructor across the UN 6 languages', () => {
+  const r = new QPRenderer();
+  const c = { type: 'quantity', subject: 'Mount Everest', value: 8848, unit: 'meters' };
+  assert.equal(r.renderWithLabels(c, {}, 'en'), 'Mount Everest is 8848 meters');
+  assert.equal(r.renderWithLabels(c, {}, 'es'), 'Mount Everest mide 8848 meters');
+  assert.equal(r.renderWithLabels(c, {}, 'fr'), 'Mount Everest mesure 8848 meters');
+  assert.equal(r.renderWithLabels(c, {}, 'ru'), 'Mount Everest — 8848 meters');
+  assert.equal(r.renderWithLabels(c, {}, 'zh'), 'Mount Everest是8848meters');
+  assert.equal(r.renderWithLabels(c, {}, 'ar'), 'Mount Everest يساوي 8848 meters');
+});
+
+test('renderWithLabels honours negation on the quantity constructor', () => {
+  const r = new QPRenderer();
+  const c = { type: 'quantity', subject: 'X', value: 5, unit: 'kg', negated: true };
+  assert.equal(r.renderWithLabels(c, {}, 'en'), 'X is not 5 kg');
+  assert.equal(r.renderWithLabels(c, {}, 'fr'), 'X ne mesure pas 5 kg');
+});
+
+test('validateConstructor enforces the quantity roles', () => {
+  assert.equal(validateConstructor({ type: 'quantity', subject: 'X', value: 5, unit: 'kg' }), true);
+  assert.throws(() => validateConstructor({ type: 'quantity', subject: 'X', value: 5 }), /missing role "unit"/);
+});
+
+test('renderWithLabels throws for an unsupported language', () => {
+  const r = new QPRenderer();
+  assert.throws(
+    () => r.renderWithLabels({ type: 'instance_of', subject: 'Q64', object: 'Q515' }, LABELS.en, 'de'),
+    /No "de" renderer/,
+  );
+});
+
+// ---------------------------------------------------------------------------
+// QPRenderer.render / renderAll — async, label-provider injected (offline)
+// ---------------------------------------------------------------------------
+
+test('render resolves labels via the injected provider', async () => {
+  const r = new QPRenderer({ labelProvider });
+  const sentence = await r.render({ type: 'instance_of', subject: 'Q64', object: 'Q515', gender: 'feminine' }, 'es');
+  assert.equal(sentence, 'Berlín es una ciudad');
+});
+
+test('renderAll renders every UN 6 language', async () => {
+  const r = new QPRenderer({ labelProvider });
+  const all = await r.renderAll({ type: 'instance_of', subject: 'Q64', object: 'Q515' });
+  assert.deepEqual(Object.keys(all).sort(), [...UN6_LANGUAGES].sort());
+  assert.equal(all.en, 'Berlin is a city');
+  assert.equal(all.ru, 'Берлин — город');
+});
+
+test('render resolves id-shaped roles through an injected apiClient.getLabels', async () => {
+  const calls = [];
+  const apiClient = {
+    async getLabels(ids, lang) {
+      calls.push({ ids: [...ids], lang });
+      return LABELS[lang] || {};
+    },
+  };
+  const r = new QPRenderer({ apiClient });
+  const sentence = await r.render({ type: 'instance_of', subject: 'Q64', object: 'Q515' }, 'en');
+  assert.equal(sentence, 'Berlin is a city');
+  // Only id-shaped roles (Q64, Q515) are looked up — not plain text.
+  assert.deepEqual(calls, [{ ids: ['Q64', 'Q515'], lang: 'en' }]);
+});
+
+test('render skips label lookup entirely for plain-text roles', async () => {
+  let called = false;
+  const apiClient = { async getLabels() { called = true; return {}; } };
+  const r = new QPRenderer({ apiClient });
+  const sentence = await r.render({ type: 'instance_of', subject: 'Berlin', object: 'city' }, 'en');
+  assert.equal(sentence, 'Berlin is a city');
+  assert.equal(called, false);
+});
+
+test('QPRenderer exposes its languages and constructor types', () => {
+  const r = new QPRenderer();
+  assert.deepEqual(r.languages, UN6_LANGUAGES);
+  assert.ok(r.constructorTypes.includes('instance_of'));
+  assert.ok(r.constructorTypes.includes('relation'));
+});
+
+// ---------------------------------------------------------------------------
+// Transformer: modifier extraction + typed constructor (offline, pure logic)
+// ---------------------------------------------------------------------------
+
+test('extractModifiers detects negation', () => {
+  const t = new TextToQPTransformer();
+  assert.equal(t.extractModifiers('Einstein did not discover gravity').negated, true);
+  assert.equal(t.extractModifiers("Berlin isn't a village").negated, true);
+  assert.equal(t.extractModifiers('Einstein never slept').negated, true);
+  assert.equal(t.extractModifiers('Berlin is a city').negated, false);
+});
+
+test('extractModifiers detects tense', () => {
+  const t = new TextToQPTransformer();
+  assert.equal(t.extractModifiers('Berlin is a city').tense, 'present');
+  assert.equal(t.extractModifiers('Einstein discovered radium').tense, 'past');
+  assert.equal(t.extractModifiers('Caesar was a general').tense, 'past');
+  assert.equal(t.extractModifiers('She will travel').tense, 'future');
+});
+
+test('detectQuestion classifies wh-, polar and non-questions', () => {
+  const t = new TextToQPTransformer();
+  assert.deepEqual(t.detectQuestion('Who discovered America?'), { isQuestion: true, word: 'who', type: 'entity' });
+  assert.deepEqual(t.detectQuestion('What is the capital of Japan?'), { isQuestion: true, word: 'what', type: 'thing' });
+  assert.deepEqual(t.detectQuestion('When was Einstein born?'), { isQuestion: true, word: 'when', type: 'time' });
+  assert.deepEqual(t.detectQuestion('Where is Berlin?'), { isQuestion: true, word: 'where', type: 'place' });
+  assert.deepEqual(t.detectQuestion('How many moons does Mars have?'), { isQuestion: true, word: 'how', type: 'quantity' });
+  assert.deepEqual(t.detectQuestion('Is Berlin a city?'), { isQuestion: true, word: 'is', type: 'polar' });
+  assert.equal(t.detectQuestion('Berlin is a city').isQuestion, false);
+  assert.equal(t.detectQuestion('').isQuestion, false);
+});
+
+test('extractQuantities keeps numbers and units instead of dropping them', () => {
+  const t = new TextToQPTransformer();
+  assert.deepEqual(t.extractQuantities('Mount Everest is 8848 meters tall'), [
+    { value: 8848, unit: 'meters', raw: '8848 meters' },
+  ]);
+  assert.deepEqual(t.extractQuantities('Speed of light is 299792458 meters per second'), [
+    { value: 299792458, unit: 'meters per second', raw: '299792458 meters per second' },
+  ]);
+  assert.deepEqual(t.extractQuantities('World War II ended in 1945'), [
+    { value: 1945, unit: null, raw: '1945' },
+  ]);
+  // Grouped thousands are normalised to a single numeric value.
+  assert.deepEqual(t.extractQuantities('It costs 1,200 dollars'), [
+    { value: 1200, unit: 'dollars', raw: '1,200 dollars' },
+  ]);
+  assert.deepEqual(t.extractQuantities('Berlin is a city'), []);
+});
+
+test('dedupeSequence collapses adjacent duplicate ids but keeps distinct ones', () => {
+  const t = new TextToQPTransformer();
+  const seq = [{ id: 'Q90' }, { id: 'Q90' }, { id: 'Q142' }, { id: 'Q142' }];
+  assert.deepEqual(t.dedupeSequence(seq).map((i) => i.id), ['Q90', 'Q142']);
+  // Non-adjacent repetition is preserved (it carries meaning).
+  const seq2 = [{ id: 'Q90' }, { id: 'Q142' }, { id: 'Q90' }];
+  assert.deepEqual(t.dedupeSequence(seq2).map((i) => i.id), ['Q90', 'Q142', 'Q90']);
+  // Ambiguous matches are never merged.
+  const amb = { type: 'ambiguous', id: '[Q43 or Q4229558]', alternatives: [{ id: 'Q43' }] };
+  assert.deepEqual(t.dedupeSequence([amb, amb]).length, 2);
+});
+
+test('toConstructor builds an instance_of constructor preserving negation', () => {
+  const t = new TextToQPTransformer();
+  const result = {
+    original: 'Berlin is not a village',
+    sequence: [{ id: 'Q64' }, { id: 'P31' }, { id: 'Q532' }],
+  };
+  const c = t.toConstructor(result);
+  assert.equal(c.type, 'instance_of');
+  assert.equal(c.subject, 'Q64');
+  assert.equal(c.object, 'Q532');
+  assert.equal(c.negated, true);
+});
+
+test('toConstructor builds a quantity constructor when a measurement is present', () => {
+  const t = new TextToQPTransformer();
+  const original = 'Mount Everest is 8848 meters tall';
+  const result = {
+    original,
+    sequence: [{ id: 'Q513' }],
+    quantities: t.extractQuantities(original),
+  };
+  const c = t.toConstructor(result);
+  assert.equal(c.type, 'quantity');
+  assert.equal(c.subject, 'Q513');
+  assert.equal(c.value, 8848);
+  assert.equal(c.unit, 'meters');
+});
+
+test('round-trip: a measurement survives text → quantity constructor → text', () => {
+  const t = new TextToQPTransformer();
+  const r = new QPRenderer();
+  const original = 'Mount Everest is 8848 meters tall';
+  const result = { original, sequence: [{ id: 'Q513' }], quantities: t.extractQuantities(original) };
+  const c = t.toConstructor(result);
+  assert.equal(r.renderWithLabels(c, { Q513: 'Mount Everest' }, 'en'), 'Mount Everest is 8848 meters');
+});
+
+test('toConstructor falls back to a generic relation', () => {
+  const t = new TextToQPTransformer();
+  const result = {
+    original: 'Einstein wrote books',
+    sequence: [{ id: 'Q937' }, { id: 'P50' }, { id: 'Q571' }],
+  };
+  const c = t.toConstructor(result);
+  assert.equal(c.type, 'relation');
+  assert.equal(c.predicate, 'P50');
+  assert.equal(c.tense, 'past');
+});
+
+test('toConstructor resolves ambiguous matches to their first candidate', () => {
+  const t = new TextToQPTransformer();
+  const result = {
+    original: 'Berlin is a city',
+    sequence: [
+      { type: 'ambiguous', alternatives: [{ id: 'Q64' }, { id: 'Q4115712' }] },
+      { id: 'P31' },
+      { id: 'Q515' },
+    ],
+  };
+  const c = t.toConstructor(result);
+  assert.equal(c.subject, 'Q64');
+  assert.equal(c.type, 'instance_of');
+});
+
+test('round-trip: a transformer constructor renders back to text', () => {
+  const t = new TextToQPTransformer();
+  const r = new QPRenderer();
+  const result = {
+    original: 'Berlin is a city',
+    sequence: [{ id: 'Q64' }, { id: 'P31' }, { id: 'Q515' }],
+  };
+  const c = t.toConstructor(result);
+  assert.equal(r.renderWithLabels(c, LABELS.en, 'en'), 'Berlin is a city');
+  assert.equal(r.renderWithLabels(c, LABELS.ru, 'ru'), 'Берлин — город');
+});
+
+test('round-trip: past tense survives text → Q/P → text', () => {
+  const t = new TextToQPTransformer();
+  const r = new QPRenderer();
+  const result = {
+    original: 'Berlin was a city',
+    sequence: [{ id: 'Q64' }, { id: 'P31' }, { id: 'Q515' }],
+  };
+  const c = t.toConstructor(result);
+  assert.equal(c.type, 'instance_of');
+  assert.equal(c.tense, 'past');
+  assert.equal(r.renderWithLabels(c, LABELS.en, 'en'), 'Berlin was a city');
+});
diff --git a/js/tests/unit/routing.test.mjs b/js/tests/unit/routing.test.mjs
index 711ccaa..10b5e85 100644
--- a/js/tests/unit/routing.test.mjs
+++ b/js/tests/unit/routing.test.mjs
@@ -61,8 +61,8 @@ test('serializeHash: drops empty / nullish params', () => {
   assert.equal(hash, '#mode=entity&id=Q1');
 });
 
-test('MODES contains exactly the six expected modes', () => {
+test('MODES contains exactly the seven expected modes', () => {
   assert.deepEqual([...MODES].sort(), [
-    'alphabet', 'dictionary', 'entity', 'ontology', 'property', 'transformer',
+    'alphabet', 'dictionary', 'entity', 'generation', 'ontology', 'property', 'transformer',
   ]);
 });
diff --git a/limitations-found.json b/limitations-found.json
index b3b8787..6936ef5 100644
--- a/limitations-found.json
+++ b/limitations-found.json
@@ -1,79 +1,9 @@
 {
-  "timestamp": "2025-07-27T12:23:08.732Z",
+  "timestamp": "2026-06-10T09:42:56.324Z",
   "summary": {
     "total": 31,
-    "problems": 12,
+    "problems": 4,
     "issues": [
-      {
-        "name": "Simple negation",
-        "input": "Einstein did not discover gravity",
-        "expected": "should_handle_negation",
-        "output": "Q937",
-        "issues": [
-          "Negation not properly handled - \"not\" should affect meaning"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "Negative statement",
-        "input": "Paris is not in Germany",
-        "expected": "should_handle_negation",
-        "output": "Q90",
-        "issues": [
-          "Negation not properly handled - \"not\" should affect meaning"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "Who question",
-        "input": "Who discovered America?",
-        "expected": "should_handle_questions",
-        "output": "P61",
-        "issues": [
-          "Questions treated as statements - need special handling"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "What question",
-        "input": "What is the capital of Japan?",
-        "expected": "should_handle_questions",
-        "output": "P36",
-        "issues": [
-          "Questions treated as statements - need special handling"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "When question",
-        "input": "When was Einstein born?",
-        "expected": "should_handle_questions",
-        "output": "Q937 P569",
-        "issues": [
-          "Questions treated as statements - need special handling"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "Height measurement",
-        "input": "Mount Everest is 8848 meters tall",
-        "expected": "numerical",
-        "output": "",
-        "issues": [
-          "Numerical values lost in transformation"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "Speed measurement",
-        "input": "Speed of light is 299792458 meters per second",
-        "expected": "numerical",
-        "output": "",
-        "issues": [
-          "Numerical values lost in transformation"
-        ],
-        "duration": 0
-      },
       {
         "name": "Ambiguous Turkey",
         "input": "Turkey is delicious",
@@ -113,92 +43,12 @@
           "Non-Latin script terms not recognized"
         ],
         "duration": 0
-      },
-      {
-        "name": "Mixed repetition",
-        "input": "Paris Paris France France",
-        "expected": "repetition",
-        "output": "Q90 Q90 Q142 Q142",
-        "issues": [
-          "Repeated entities not properly deduplicated"
-        ],
-        "duration": 0
       }
     ],
     "failures": []
   },
   "details": {
     "issues": [
-      {
-        "name": "Simple negation",
-        "input": "Einstein did not discover gravity",
-        "expected": "should_handle_negation",
-        "output": "Q937",
-        "issues": [
-          "Negation not properly handled - \"not\" should affect meaning"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "Negative statement",
-        "input": "Paris is not in Germany",
-        "expected": "should_handle_negation",
-        "output": "Q90",
-        "issues": [
-          "Negation not properly handled - \"not\" should affect meaning"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "Who question",
-        "input": "Who discovered America?",
-        "expected": "should_handle_questions",
-        "output": "P61",
-        "issues": [
-          "Questions treated as statements - need special handling"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "What question",
-        "input": "What is the capital of Japan?",
-        "expected": "should_handle_questions",
-        "output": "P36",
-        "issues": [
-          "Questions treated as statements - need special handling"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "When question",
-        "input": "When was Einstein born?",
-        "expected": "should_handle_questions",
-        "output": "Q937 P569",
-        "issues": [
-          "Questions treated as statements - need special handling"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "Height measurement",
-        "input": "Mount Everest is 8848 meters tall",
-        "expected": "numerical",
-        "output": "",
-        "issues": [
-          "Numerical values lost in transformation"
-        ],
-        "duration": 0
-      },
-      {
-        "name": "Speed measurement",
-        "input": "Speed of light is 299792458 meters per second",
-        "expected": "numerical",
-        "output": "",
-        "issues": [
-          "Numerical values lost in transformation"
-        ],
-        "duration": 0
-      },
       {
         "name": "Ambiguous Turkey",
         "input": "Turkey is delicious",
@@ -238,16 +88,6 @@
           "Non-Latin script terms not recognized"
         ],
         "duration": 0
-      },
-      {
-        "name": "Mixed repetition",
-        "input": "Paris Paris France France",
-        "expected": "repetition",
-        "output": "Q90 Q90 Q142 Q142",
-        "issues": [
-          "Repeated entities not properly deduplicated"
-        ],
-        "duration": 0
       }
     ],
     "failures": []
diff --git a/package-lock.json b/package-lock.json
index 3bab89f..0923d33 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "human-language",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "human-language",
-      "version": "0.1.0",
+      "version": "0.2.0",
       "license": "MIT",
       "dependencies": {
         "lino-arguments": "^0.3.0",
diff --git a/package.json b/package.json
index 19db42b..b46ae7b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "human-language",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Human Language: a Wikidata-backed library, CLI and HTTP microservice for transforming English text into sequences of Wikidata entities (Q) and properties (P), with alphabet/dictionary/ontology browsing and IPA support.",
   "license": "MIT",
   "repository": {
@@ -49,6 +49,12 @@
     "./transform/lino": {
       "import": "./js/src/transformation/lino-format.js"
     },
+    "./generate": {
+      "import": "./js/src/generation/qp-to-text.js"
+    },
+    "./generate/constructors": {
+      "import": "./js/src/generation/constructors.js"
+    },
     "./wikidata": {
       "import": "./js/src/wikidata-api.js"
     },
diff --git a/research/abstract-wikipedia-analysis.md b/research/abstract-wikipedia-analysis.md
new file mode 100644
index 0000000..a2713e5
--- /dev/null
+++ b/research/abstract-wikipedia-analysis.md
@@ -0,0 +1,321 @@
+# Learning from Abstract Wikipedia Development
+
+## Executive Summary
+
+Abstract Wikipedia, launched with Wikifunctions in July 2023, offers valuable lessons for the human-language project. This analysis identifies key improvements and strategies that could accelerate development or enhance the semantic transformation approach.
+
+> **Companion document:** For the concrete, actionable output of this analysis — a feature-gap map and per-service quality improvements — see [`missing-features-and-improvements.md`](./missing-features-and-improvements.md).
+
+## 2025–2026 Status Update (Fresh Research)
+
+*This section reflects research gathered in June 2026 and supersedes the older training-data-based notes below where they conflict. Full source links are listed in [Sources](#sources).*
+
+### Where the project stands now
+
+- **Wikifunctions** went live to the public on **26 July 2023** — the first new Wikimedia project since 2012. By 2025 contributors from **50+ countries** had created **2,400+ functions**, with names and descriptions in **100+ languages**.
+- **2025 focus is the technical foundation for Natural Language Generation (NLG).** The team is building "**semantic fragments**" — small, reusable functions that turn Wikidata data plus a language code into a sentence (e.g. function `Z26039` renders *"Berlin is a city" / "Berlín es una ciudad" / "Flughafen Berlin Brandenburg ist ein Flughafen"*). Progress is tracked across the **"UN 6" languages**: English, Arabic, Spanish, French, Russian, and Chinese.
+- A **Natural Language Generation Special Interest Group (NLG SIG)** now meets roughly monthly (4th meeting July 2025, 5th in Sept 2025, continuing into late 2025) to converge on how grammatical features are represented.
+
+### Published roadmap
+
+| Date | Milestone |
+|------|-----------|
+| Aug 2022 | Wikifunctions Beta |
+| Jul 2023 | Wikifunctions in production |
+| Apr 2025 | Embedded function-call results enabled on select wikis |
+| **Late 2025** | First **live functions for generating simple sentences** in natural languages |
+| **2026** | **Soft launch** of Abstract Wikipedia |
+
+### The NLG architecture (the part most relevant to us)
+
+Abstract Wikipedia separates **language-independent meaning** from **language-specific rendering** — the same goal as this project's Q/P sequences, but with a fuller pipeline:
+
+1. **Constructors** — language-agnostic containers of arguments (e.g. `Existence(subject)`); they carry no logic and are community-extensible. Roughly analogous to our Q/P sequence, but **typed and role-labelled** rather than a flat list.
+2. **Renderers** — one **templatic renderer per constructor-per-language**, written by the community. Templates mix static text with slots filled by arguments, Wikidata **lexemes**, or other renderers' output.
+3. **Syntactic tree** — renderers emit **Universal Dependencies** (or Surface-Syntactic UD) trees of *non-inflected lemmas* with morphological constraints.
+4. **Morphological inflection** — grammar specifications inflect lemmas using **Wikidata lexeme** forms / inflection tables; dependency relations use **feature unification** (e.g. a subject relation unifies noun–verb number and person agreement).
+5. **Phonotactics** — language-specific sandhi (English *a/an*, French *de + le → du*).
+6. **Text assembler** — final spacing, capitalization, and punctuation.
+
+The reference implementation pair is **Ninai** (high-level constructors and item→sense resolution) and **Udiron** (low-level, per-language text manipulation), with grammar logic written in **Lua**.
+
+### Documented risks and criticism (lessons to internalize)
+
+- A **January 2023 Google.org Fellows evaluation** rated the project at **"substantial risk of failure"** for thin technical planning, and recommended (a) decoupling Abstract Wikipedia from Wikifunctions, (b) refining **Lua** rather than inventing new languages, and (c) converging on an existing NLG framework. The Wikimedia Foundation **rejected** these recommendations.
+- WMF declined existing frameworks such as **Grammatical Framework**, arguing they under-serve **Niger-Congo B** languages and risk replicating an "English-focused Western-thinking" bias. The trade-off chosen — community-editable templates that **prioritize accessibility over guaranteed grammaticality** — means poorly designed templates *can* emit ungrammatical text. This is a direct, real-world data point on the equity-vs-correctness tension we also face.
+
+## Abstract Wikipedia Project Overview
+
+### Core Architecture
+- **Wikifunctions**: Computational functions for data processing
+- **Wikidata**: Structured semantic data repository  
+- **Abstract Content**: Language-independent article representations
+- **Natural Language Generation**: Functions to render content in multiple languages
+
+### Technical Approach
+```
+Abstract Content → Wikifunctions → Language-Specific Rendering
+(Structured Data)   (Processing)    (Human-Readable Text)
+```
+
+## Key Lessons for Human-Language Project
+
+### 1. Structured Content Representation
+
+**Abstract Wikipedia Strategy:**
+- Uses Wikidata QIDs to represent predicates, participants, and modifiers
+- Creates nested list-like structures for complex semantic relationships
+- Enables language-agnostic content representation
+
+**Application to Human-Language:**
+```javascript
+// Current approach in text-to-qp-transformer.js
+"Einstein was born in Germany" → ["Q937", "P19", "Q183"]
+
+// Enhanced approach inspired by Abstract Wikipedia
+{
+  predicate: "P569", // date of birth
+  subject: "Q937",   // Einstein
+  object: {
+    date: "1879-03-14",
+    location: "Q183"  // Germany
+  },
+  context: {
+    precision: "day",
+    calendar: "Q1985727" // proleptic Gregorian calendar
+  }
+}
+```
+
+### 2. Modular Function Architecture
+
+**Lesson:** Break complex transformations into reusable, composable functions.
+
+**Recommended Implementation:**
+```javascript
+// Inspired by Wikifunctions approach
+class SemanticFunctionLibrary {
+  constructor() {
+    this.functions = {
+      'temporal_relation': this.handleTemporalRelations,
+      'spatial_relation': this.handleSpatialRelations,
+      'causal_relation': this.handleCausalRelations,
+      'identity_relation': this.handleIdentityRelations
+    };
+  }
+  
+  // Compose functions for complex semantic structures
+  compose(functions, input) {
+    return functions.reduce((result, fn) => this.functions[fn](result), input);
+  }
+}
+```
+
+### 3. Lexicographic Integration
+
+**Abstract Wikipedia Focus:** Extensive work with Wikidata Lexemes for linguistic accuracy.
+
+**Recommendation for Human-Language:**
+- Integrate Wikidata Lexemes API for better word sense disambiguation
+- Use lexicographic data to improve n-gram matching accuracy
+- Handle morphological variations and inflected forms
+
+```javascript
+// Enhanced search with lexeme support
+class EnhancedSearchUtility extends WikidataSearchUtility {
+  async searchWithLexemes(term, language = 'en') {
+    const [entityResults, lexemeResults] = await Promise.all([
+      this.searchEntities(term),
+      this.searchLexemes(term, language)
+    ]);
+    
+    return this.mergeAndRankResults(entityResults, lexemeResults);
+  }
+}
+```
+
+### 4. Context-Aware Transformation
+
+**Challenge Identified:** Current system struggles with context-dependent meanings.
+
+**Solution Inspired by Abstract Wikipedia:**
+```javascript
+// Context-aware transformation with participant roles
+class ContextualTransformer {
+  async transform(text, context = {}) {
+    const parseTree = this.parseSemanticStructure(text);
+    const enrichedTree = await this.enrichWithContext(parseTree, context);
+    return this.generateQPSequence(enrichedTree);
+  }
+  
+  parseSemanticStructure(text) {
+    // Extract predicates, subjects, objects with their roles
+    // Similar to Abstract Wikipedia's participant role management
+  }
+}
+```
+
+## Identified Challenges and Solutions
+
+### 1. Language Bias and Equity
+
+**Challenge:** Abstract Wikipedia faces criticism for Indo-European language bias.
+
+**Mitigation Strategy:**
+- Prioritize support for diverse language families early in development
+- Use Universal Dependencies for syntactic parsing across languages
+- Implement cultural context awareness in semantic interpretation
+
+### 2. Community Understanding
+
+**Challenge:** Users confused about machine translation vs. structured generation.
+
+**Solution for Human-Language:**
+- Clear documentation distinguishing Q/P transformation from translation
+- Interactive demos showing semantic preservation across languages
+- Educational materials explaining the "language of meaning" concept
+
+### 3. Technical Integration Complexity
+
+**Challenge:** Complex integration with existing systems and workflows.
+
+**Approach:**
+- Start with simple, high-value use cases
+- Build backwards-compatible APIs
+- Provide clear migration paths from existing text processing
+
+## Specific Improvements for Human-Language
+
+### 1. Enhanced N-gram Processing
+
+```javascript
+// Inspired by Abstract Wikipedia's modular approach
+class AdvancedNgramProcessor {
+  constructor() {
+    this.processors = [
+      new TemporalNgramProcessor(),
+      new SpatialNgramProcessor(), 
+      new RelationalNgramProcessor()
+    ];
+  }
+  
+  async processNgrams(ngrams) {
+    const results = await Promise.all(
+      this.processors.map(p => p.process(ngrams))
+    );
+    return this.mergeResults(results);
+  }
+}
+```
+
+### 2. Semantic Validation System
+
+```javascript
+// Quality assurance inspired by Wikifunctions testing
+class SemanticValidator {
+  async validateTransformation(originalText, qpSequence) {
+    const checks = [
+      this.validateEntityConsistency(qpSequence),
+      this.validatePropertyUsage(qpSequence),
+      this.validateSemanticCoherence(originalText, qpSequence)
+    ];
+    
+    return Promise.all(checks);
+  }
+}
+```
+
+### 3. Multi-Language Generation
+
+```javascript
+// Generate human-readable text from Q/P sequences
+class LanguageGenerator {
+  async generateFromQP(sequence, targetLanguage) {
+    const template = await this.getLanguageTemplate(targetLanguage);
+    const enrichedData = await this.enrichWithLabels(sequence, targetLanguage);
+    return this.renderTemplate(template, enrichedData);
+  }
+}
+```
+
+## Implementation Roadmap
+
+### Phase 1: Foundation (Immediate)
+- [ ] Implement modular function architecture
+- [ ] Add lexeme-based disambiguation
+- [ ] Create semantic validation framework
+
+### Phase 2: Enhancement (3-6 months)
+- [ ] Context-aware transformation system
+- [ ] Multi-language generation capabilities
+- [ ] Advanced semantic structure parsing
+
+### Phase 3: Integration (6-12 months)
+- [ ] Wikidata contribution pipeline
+- [ ] Community validation system
+- [ ] Performance optimization at scale
+
+## Performance Optimization Lessons
+
+### 1. Caching Strategy
+Abstract Wikipedia's approach suggests:
+- Cache function results aggressively
+- Use incremental updates for dynamic data
+- Implement multi-tier caching (browser + server)
+
+### 2. Batch Processing
+```javascript
+// Optimize API calls like Wikifunctions
+class BatchProcessor {
+  async processBatch(items, batchSize = 50) {
+    const batches = this.chunk(items, batchSize);
+    return Promise.all(batches.map(batch => this.processItems(batch)));
+  }
+}
+```
+
+## Risk Mitigation
+
+### Technical Risks
+1. **Scalability**: Use proven caching and batch processing patterns
+2. **Accuracy**: Implement comprehensive validation and testing
+3. **Complexity**: Start simple and iterate based on user feedback
+
+### Community Risks
+1. **Adoption**: Focus on clear value propositions and ease of use
+2. **Understanding**: Invest in documentation and educational content
+3. **Contribution**: Design systems for community validation and improvement
+
+## Conclusion
+
+Abstract Wikipedia's development provides a roadmap for semantic language projects. Key takeaways:
+
+1. **Start with strong foundations**: Modular architecture and semantic validation
+2. **Think globally**: Design for multiple languages from the beginning  
+3. **Engage communities**: Clear communication and gradual integration
+4. **Iterate carefully**: Build on proven patterns while innovating thoughtfully
+
+The human-language project is well-positioned to learn from Abstract Wikipedia's successes and challenges, potentially achieving faster development and better outcomes through these insights.
+
+## Recommended Next Steps
+
+1. Implement lexeme-based disambiguation in the current transformer
+2. Add semantic validation to ensure transformation quality
+3. Create educational content explaining the semantic transformation approach
+4. Design community feedback mechanisms for continuous improvement
+5. Plan for multi-language support architecture from the outset
+
+These improvements could significantly accelerate the project's development while avoiding pitfalls encountered by Abstract Wikipedia.
+
+## Sources
+
+Fresh research gathered June 2026:
+
+- [Abstract Wikipedia — Meta-Wiki](https://meta.wikimedia.org/wiki/Abstract_Wikipedia) (roadmap, timeline, project goals)
+- [Abstract Wikipedia — Wikipedia](https://en.wikipedia.org/wiki/Abstract_Wikipedia) (launch, architecture, criticism)
+- [Natural language generation system architecture proposal — Meta-Wiki](https://meta.wikimedia.org/wiki/Abstract_Wikipedia/Natural_language_generation_system_architecture_proposal) (6-stage NLG pipeline)
+- [Wikifunctions:Abstract Wikipedia/2025 fragment experiments](https://www.wikifunctions.org/wiki/Wikifunctions:Abstract_Wikipedia/2025_fragment_experiments) (semantic fragments, `Z26039`, UN 6 languages)
+- [Wikifunctions:NLG SIG](https://www.wikifunctions.org/wiki/Wikifunctions:NLG_SIG) (Natural Language Generation Special Interest Group)
+- [Using Wikidata Lexemes and Items to Generate Text from Abstract Representations — Mahir Morshed, 2024 (Semantic Web Journal)](https://content.iospress.com/articles/semantic-web/sw243564) (Ninai/Udiron, constructors, renderers)
+- [Abstract Wikipedia/Google.org Fellows evaluation — Meta-Wiki](https://meta.wikimedia.org/wiki/Abstract_Wikipedia/Google.org_Fellows_evaluation) (risk-of-failure assessment)
+- [Wikifunctions status updates (2025)](https://www.wikifunctions.org/wiki/Wikifunctions:Status_updates/2025-06-21)
\ No newline at end of file
diff --git a/research/missing-features-and-improvements.md b/research/missing-features-and-improvements.md
new file mode 100644
index 0000000..2070553
--- /dev/null
+++ b/research/missing-features-and-improvements.md
@@ -0,0 +1,125 @@
+# Missing Features & Service-Quality Improvements
+
+*Derived from fresh (June 2026) research on Abstract Wikipedia / Wikifunctions — see
+[`abstract-wikipedia-analysis.md`](./abstract-wikipedia-analysis.md) for the full background and
+[Sources](./abstract-wikipedia-analysis.md#sources).*
+
+This document answers two practical questions:
+
+1. **What features does Abstract Wikipedia have that we are missing — and could support?**
+2. **How can we improve the quality of each of our existing services?**
+
+It is intentionally concrete and mapped to files in this repository.
+
+---
+
+## Part 1 — Feature gaps we can close
+
+Abstract Wikipedia and the human-language project share the same core idea: separate
+**language-independent meaning** from **language-specific text**. The difference is direction and
+depth. We currently do **text → Q/P** (analysis only); Abstract Wikipedia invests most heavily in
+**meaning → text** (generation), with a typed, grammar-aware pipeline. The biggest opportunities sit
+in the parts of their pipeline we have no equivalent for.
+
+| # | Missing feature | What Abstract Wikipedia does | Where it would live here | Priority | Status |
+|---|-----------------|------------------------------|--------------------------|----------|--------|
+| 1 | **Reverse generation (Q/P → text)** | Renderers turn a constructor into a sentence in any language (`Z26039` → "Berlin is a city" / "Berlín es una ciudad") | New `generation/qp-to-text.js` service | **High** | ✅ Done (PR #19) |
+| 2 | **Wikidata Lexeme integration** | Lexemes drive disambiguation and morphological inflection | `wikidata-api.js` (`searchLexemes`), used by transformer + search | **High** | ✅ `searchLexemes` (PR #19) |
+| 3 | **Typed, role-labelled representation** | Constructors are typed containers with named argument roles, not flat lists | Output schema of `text-to-qp-transformer.js` | **High** | ✅ `transformToConstructor` (PR #19) |
+| 4 | **Universal Dependencies parsing** | Renderers emit/consume UD (or Surface-Syntactic UD) trees | New parsing layer feeding the transformer | Medium | ⬜ Open |
+| 5 | **Multi-language rendering (UN 6)** | Same meaning rendered in English, Arabic, Spanish, French, Russian, Chinese | Generation service templates | Medium | ✅ Done (PR #19) |
+| 6 | **Modular function composition** | Wikifunctions composes small reusable functions; one templatic renderer per constructor-per-language | `SemanticFunctionLibrary` (sketched in analysis doc) | Medium | 🟡 Partial — one templatic renderer per constructor-per-language (PR #19) |
+| 7 | **Grammatical features + phonotactics** | Feature unification for agreement; sandhi rules (English *a/an*, French *de+le→du*) | Generation service | Medium | 🟡 Partial — English *a/an* + negation/tense (PR #19) |
+| 8 | **Embedded live function results** | Function-call results embedded in wiki pages (since Apr 2025) | Demo pages (`entities.html`, etc.) | Low | ⬜ Open |
+| 9 | **Community validation process** | NLG SIG + community-editable templates/grammar | Contribution docs + validation hooks | Low | ⬜ Open |
+
+### The single highest-leverage gap: reverse generation
+
+We can already parse text into Q/P. We cannot yet render Q/P back into a human sentence in any
+language — which is exactly the capability the README's vision ("Zero-Cost Translation", "Language of
+Meaning", "LLM Translation Pipeline") depends on. A minimal renderer that closes the loop, mirroring
+Abstract Wikipedia's `Z26039` "is-a" fragment:
+
+```javascript
+// generation/qp-to-text.js  (sketch)
+// Constructor:  { type: 'instance_of', subject: 'Q64', object: 'Q515' }  // Berlin, city
+// Renders:      "Berlin is a city" | "Berlín es una ciudad" | "Берлин — город"
+class QPRenderer {
+  async render(constructor, lang = 'en') {
+    const template = TEMPLATES[constructor.type]?.[lang];
+    if (!template) throw new Error(`No renderer for ${constructor.type}/${lang}`);
+    const labels = await this.api.getLabels(
+      [constructor.subject, constructor.object], lang
+    );
+    return this.applyPhonotactics(this.fill(template, labels, constructor), lang);
+  }
+}
+```
+
+Starting with one constructor (`instance_of`) across the **UN 6** languages is a small, demonstrable
+deliverable that proves the round-trip `text → Q/P → text` and directly de-risks the README roadmap.
+
+---
+
+## Part 2 — Per-service quality improvements
+
+### 1. Text-to-Q/P Transformer (`transformation/text-to-qp-transformer.js`)
+
+The transformer currently emits a **flat list** of Q/P ids and skips meaning-bearing words. The
+documented limitations in `limitations-found.json` (12/31 cases failing) cluster exactly where
+Abstract Wikipedia invests:
+
+- **Negation** ("Einstein did *not* discover gravity" → loses the *not*). Abstract Wikipedia models
+  this structurally via constructors; we should attach a `negated: true` flag to the relation rather
+  than dropping the token. Today `stopWords`/`propertyIndicators` (lines 30–40) silently discard such
+  words.
+- **Questions / tenses / pronouns** — also failing. A typed representation (gap #3) with a tense and
+  modality slot is the structural fix, not more keyword lists.
+- **Lexeme-based disambiguation (gap #2)** would replace the hand-maintained `propertyIndicators`
+  array with morphological lookup, handling inflected forms ("wrote" → P50/author) generically.
+
+**Quality win:** change the output from `["Q937", "P19", "Q183"]` to a typed constructor with roles,
+preserving negation/tense — turning today's silent failures into representable structure.
+
+### 2. Search & Disambiguation (`wikidata-api.js`, `SEARCH_README.md`)
+
+- Add **`searchLexemes(term, lang)`** alongside entity search and merge/rank results (Abstract
+  Wikipedia treats lexemes as first-class). The codebase only touches lexemes as a claim *datatype*
+  (`wikidata-api.js:424`) — there is no lexeme *search*.
+- Use lexeme forms to **normalize morphology before matching**, improving fuzzy search for inflected
+  inputs.
+
+### 3. Entity & Property Viewer (`entities.html`, `properties.html`, `statements.jsx`)
+
+- Surface **lexeme forms and senses** for an entity, and show an **auto-generated example sentence**
+  (using the new renderer) so users see meaning rendered, not just ids.
+- Adopt Abstract Wikipedia's terminology hint: render **per-language** example output for the UN 6 set.
+
+### 4. Caching System (`unified-cache.js`, `persistent-cache.js`)
+
+- Abstract Wikipedia caches function results aggressively. Add **HTTP `ETag` / conditional-request**
+  support and **incremental invalidation** so cached labels/lexemes refresh without full re-fetch.
+- Add **batch fetching** (`getLabels([...])`) to cut round-trips for multi-entity renders — required
+  by the generation service anyway.
+
+### 5. New service — Multi-language Generation (`generation/`)
+
+This is the missing counterpart to the transformer (gap #1). It should:
+
+- Live in a new `generation/` folder mirroring `transformation/` (templates + tests + demo HTML).
+- Start with the `instance_of` constructor across the UN 6 languages.
+- Reuse the cache and the new batch label fetch.
+- Include phonotactic post-processing (English *a/an*) as the first grammatical feature.
+
+---
+
+## Suggested sequencing
+
+1. **Add `searchLexemes` + batch `getLabels`** (foundation, low risk, helps every service).
+2. **Switch transformer output to a typed constructor** preserving negation/tense (fixes documented limitations).
+3. **Ship a minimal `generation/qp-to-text.js`** for `instance_of` across UN 6 (proves the round-trip).
+4. **Surface example sentences** in the entity/property viewers.
+5. **Layer in caching (ETag/incremental) and UD parsing** as the corpus grows.
+
+Each step is independently shippable and testable, following Abstract Wikipedia's own lesson:
+**start with simple, high-value fragments and grow the grammar incrementally.**