@@ -138,6 +138,48 @@ generator catalog and the Atlas evaluation are 1.2 work.
     `GeneratorRegistry.GeneratorInfo.ejectWith()`, the classes eject copies with a
     generator.
 
+- **C#: an ejected generator owns the emitters it writes through, and `api-docs` can be
+  ejected.** `dotnet meta eject` used to copy one file per generator, so an owned `entity`
+  still called four packaged writers, and an owned `output-parser`, `extractor` or
+  `output-prompt` still called the prompt tier's field mapping and format-spec writer. A
+  defect in any of them waited for a release. Eject now hands
+  over the writers with the generator, into `codegen/generators/`, in the same
+  `Codegen.Generators` namespace: `Fr019SharedEnum`, `XmlDocBuilder`, `M2MNavigation` and
+  `ReverseFinders` with `entity`, `db-context` and `routes` as each calls them;
+  `ExtractDelegateEmitter`, `Fr010FieldMapping` and `OutputFormatSpecEmitter` with
+  `output-parser`, `extractor` and `output-prompt`. A file two generators share is copied once
+  and never overwritten (`--force` replaces it, as it replaces the generator). What stays in
+  the package is the engine: the generator base, `CSharpNaming`, `ValueObjectNames` and
+  `PackageBindingResolver` (the naming and type-mapping tables), and the questions asked of
+  the model (`FindInbound`, `TphPlan`, `InstanceArtifacts`, `ReportRows`). `template` is not
+  ejectable: it has no emit logic of its own. Packaged output is unchanged and gated to be.
+  - **`api-docs` is a generator you can own.** `dotnet meta eject api-docs` copies the page
+    generator with its page model, builder, renderer and path math. `dotnet meta docs` hands
+    off to `dotnet run --project codegen -- docs` once `codegen/generators/ApiDocsGenerator.cs`
+    exists, so your copy writes the reference. What the reference documents comes from the
+    generators in your `Program.cs` list: an owned `routes` whose `AppliesTo` you changed is
+    documented as it behaves, not as the packaged one does (`GeneratorApplicability.From`).
+    `dotnet meta gen` skips a docs generator and says so, and `verify --codegen` leaves it out.
+    New public API in `MetaObjects.Codegen`: `IDocsGenerator`, `DocsRunFacts`,
+    `GeneratorApplicability`, `GenContext.Applicability` and `GenContext.Docs`,
+    `CodegenCli.RunDocs`, and `ValueObjectNames.ResolveValueObject` (moved from
+    `RenderHelperGenerator`, where it was `internal`). `CSharpStringLiteral` moved from
+    `Fr010FieldMapping` to `CSharpNaming`, so `names` needs no emitter; the old member stays as an
+    `[Obsolete]` forwarder (see **Deprecated**).
+  - **A copy you ejected before this release** keeps compiling and running: it finds the
+    packaged emitters as it always did. `dotnet meta gen --list` now marks it as missing the
+    ones it was not handed (`Fr019SharedEnum.cs missing`). To own them, eject the same name
+    into a scratch directory (`dotnet meta eject entity --root <scratch>`) and copy the emitter
+    files from its `codegen/generators/` into yours; your copy and your edits are untouched,
+    and it resolves the new files by namespace.
+  - **A gate for the rule.** For every ejectable generator the registry lists, a test ejects it
+    alone, compiles it against the public API, fails on any reference to a packaged emitter,
+    generator or docs writer outside a written engine surface, fails on a handed-over file
+    nothing calls, and compares its output with the packaged generator's over the shared
+    corpora. A registered generator with no eject source and no written exemption fails it, as
+    does a generator class the package ships that no registry entry builds.
+  The cross-port manifest lists `api-docs` for `csharp`.
+
 - **The stock `entity`, `queries`, `routes` and `barrel` generators are importable again
   (TypeScript).** `entityFile`, `queriesFile`, `routesFile` and `barrel` are exported from
   `@metaobjectsdev/codegen-ts/generators` once more, beside `namesFile`, `routesFileHono`
@@ -744,6 +786,12 @@ until you regenerate.
   One rule is relaxed: an authored `validator.length @min: 0` on a `@required` string now
   admits the empty string, as the generated schema already did.
 
+### Deprecated
+
+- **C#: `Fr010FieldMapping.CSharpStringLiteral(string)` is `[Obsolete]`.** It forwards to
+  `CSharpNaming.CSharpStringLiteral(string)`, which every generator now calls (so an ejected
+  `names` needs no emitter). Same signature and result; switch the call when you next touch it.
+
 ### Removed
 
 - **The standalone `mermaid-er` generator (TypeScript).** `mermaidErDiagram()`, its
 
@@ -1014,7 +1014,9 @@ ejectable generator's `.cs` file ships embedded in `MetaObjects.Codegen`, and a
 byte-identical to the file the package compiles. Eject writes it to
 `codegen/generators/<Name>Generator.cs`, renaming its namespace to `Codegen.Generators` and
 adding the `using` lines that rename needs; nothing else changes, except in `routes` (see
-[below](#ejecting-routes-hands-over-the-helper-runtime-too)).
+[below](#ejecting-routes-hands-over-the-helper-runtime-too)). The emitters the generator
+writes its output through come with it
+([below](#ejecting-a-generator-hands-over-the-emitters-it-writes-through)).
 
 On first use eject also writes `codegen/Codegen.csproj`, a console project referencing
 `MetaObjects.Codegen` at the tool's version, and `codegen/Program.cs`, which lists your
@@ -1031,14 +1033,88 @@ them. So ejecting `names` from a nine-generator selection changes one generator'
 not the other eight. The owned project finds metadata exactly as the tool does, including
 `.metaobjects/config.json`'s `sources` and `libraries`. Eject never overwrites a copy without `--force`, and
 `dotnet meta gen --list` marks owned copies `identical` or `DIFFERS: N behind, M of your
-own`. The `template` primitive is not ejectable; it has no emit logic of its own.
+own`, and names an emitter that was edited or removed after eject
+(`Fr019SharedEnum.cs DIFFERS: 0 behind, 1 of your own`). The `template` primitive is not
+ejectable; it has no emit logic of its own.
 
 `dotnet meta eject requirement-tests` copies `RequirementTestsGenerator.cs`, which holds the
 generator and its default rendering. Its options are public properties you set in
 `codegen/Program.cs` (`new RequirementTestsGenerator { WitnessClass = "…" }`); the hook
 types (`IRequirementTestRenderer`, `IRequirementTestFilter`), the identity function and the
 digest stay in the package.
 
+### Ejecting a generator hands over the emitters it writes through
+
+A generator that calls an emitter writes part of its output through it. If eject left the
+emitter in the package, the copy would own the orchestration and the package would still own
+the text, and a defect in that text would wait for a release. So eject copies the emitters
+too, next to the generator in `codegen/generators/`, in the same `Codegen.Generators`
+namespace:
+
+| Eject | Also writes |
+|---|---|
+| `entity` | `Fr019SharedEnum.cs` (shared and provided enums), `M2MNavigation.cs` (the many-to-many navigation), `ReverseFinders.cs` (the reverse FK finders), `XmlDocBuilder.cs` (doc comments) |
+| `db-context` | `Fr019SharedEnum.cs`, `M2MNavigation.cs`, `XmlDocBuilder.cs` |
+| `routes` | `M2MNavigation.cs` |
+| `output-parser`, `extractor` | `ExtractDelegateEmitter.cs`, `Fr010FieldMapping.cs`; `extractor` also `Fr019SharedEnum.cs` |
+| `output-prompt` | `OutputFormatSpecEmitter.cs`, `Fr010FieldMapping.cs` |
+| `api-docs` | the page model, builder, renderer and path math (below), `Fr010FieldMapping.cs`, `M2MNavigation.cs` |
+
+The copies are the packaged source with the same namespace edit as the generator and no
+other change. A file two generators share is written once: a later eject finds it, says
+`[kept — already yours]` and leaves your edits alone, and `--force` replaces it with the
+reference as it replaces the generator. The copies see one another as members of their own
+namespace, and a member of the namespace you are in wins over a name a `using` brings in, so
+an owned generator reaches its owned emitters and never the packaged ones of the same name.
+
+**What stays in the package is the engine**, public and unchanged: the generator contract
+(`IGenerator`, `GenContext`, `GenConfig`, `EmittedFile`), the naming and type-mapping tables
+(`CSharpNaming`, `ValueObjectNames`, `PackageBindingResolver`), and the questions a generator
+asks of the model (`FindInbound`, `TphPlan`, `InstanceArtifacts`, `ReportRows`). Anything that
+returns emitted text is handed over; a table or a model question is not. The line is written
+down and checked: a test ejects each generator the registry lists into an empty project,
+compiles it against the public API and fails on any reference to a packaged emitter, generator
+or docs writer that is not on that list.
+
+**A copy you ejected before the emitters were handed over** keeps compiling and running, with
+the packaged emitters. To own them, eject the same name into a scratch directory and copy the
+emitter files into your project; your copy and your edits are untouched:
+
+```bash
+scratch=$(mktemp -d)
+dotnet meta eject entity --root "$scratch"
+cp "$scratch"/codegen/generators/{Fr019SharedEnum,M2MNavigation,ReverseFinders,XmlDocBuilder}.cs codegen/generators/
+dotnet meta gen --list    # no longer reports an emitter missing
+```
+
+### `api-docs`: the api reference as an owned generator
+
+`dotnet meta docs` writes the C# api reference. `dotnet meta eject api-docs` copies the
+generator that writes it, with the page model (`CSharpApiModel.cs`), the builder that decides
+what to document (`CSharpApiModelBuilder.cs`), the renderer (`CSharpApiDocsRenderer.cs`) and
+the page-path math (`DocsPaths.cs`). Change which nodes get a page, how a page reads, or
+where it lands, by editing them.
+
+Once `codegen/generators/ApiDocsGenerator.cs` exists, `dotnet meta docs` hands off to
+`dotnet run --project codegen -- docs` with the same arguments, and the reference is written
+by your copy. A project that owns `codegen/` but not `api-docs` keeps the packaged reference:
+the hand-off for `docs` is keyed to the generator, not to the project, because an owned
+project pinned to an older `MetaObjects.Codegen` does not know the `docs` command.
+
+**It describes the generators you run.** The reference documents a route, an allowlist, a
+render helper only if the generator that emits it would. The packaged generators answer that
+through their static `AppliesTo`; when `docs` runs, the answers come from the generators in
+your `Program.cs` list instead, so an owned `routes` whose `AppliesTo` you changed is
+documented as it behaves. A generator you left in the package keeps answering as the package
+does. The builder asks through `GenContext.Applicability`
+(`GeneratorApplicability.From(list)` builds it), never through a generator class, which is
+why the copy depends on nothing but the engine.
+
+`Program.cs` lists `new ApiDocsGenerator()` beside the code generators. `dotnet meta gen` and
+`verify --codegen` skip it, and `gen` says so (`"api-docs" writes the api reference, so
+gen skipped it. Run it with dotnet meta docs.`): it writes pages under the docs directory,
+not code under `--out`.
+
 ### Ejecting routes hands over the helper runtime too
 
 Generated routes call a handful of helpers: the filter parser, the EF Core filter
 
@@ -81,7 +81,7 @@ for a worked example.
 
 ## Generate
 
-**Own a generator.** `dotnet meta eject <name>...` copies a reference generator into `codegen/generators/` and scaffolds an owned `codegen/` console project that `dotnet meta gen` then runs. See [Own your codegen → C#](../features/own-your-codegen.md#c-dotnet-meta-eject).
+**Own a generator.** `dotnet meta eject <name>...` copies a reference generator into `codegen/generators/` and scaffolds an owned `codegen/` console project that `dotnet meta gen` then runs. Every generator `dotnet meta gen --list` shows is ejectable except `template`, the Mustache primitive, which has no emit logic of its own to own. An ejected generator comes with the emitters it writes its output through (the enum, navigation, doc-comment and prompt-tier writers), so the copy owns the code that writes the file and not a shell around the package's; the naming and type-mapping tables (`CSharpNaming`, `ValueObjectNames`) stay in the package as the engine. `dotnet meta eject api-docs` does the same for the api reference `dotnet meta docs` writes, and the reference then describes the generators you own. See [Own your codegen → C#](../features/own-your-codegen.md#c-dotnet-meta-eject).
 
 ```bash
 # Generate EF Core entities + AppDbContext + CRUD minimal-API routes
 
@@ -90,8 +90,8 @@
       "concept": "Per-entity/template SDK API reference (generated-code API; human + agent forms).",
       "tier": "native",
       "layer": "docs",
-      "note": "Run by `meta docs` as its api surface (ADR-0025), not by `meta gen`: a `meta gen` config that lists it is warned about and skipped.",
-      "ports": ["typescript"]
+      "note": "Run by `meta docs` as its api surface (ADR-0025), not by `meta gen`: a `meta gen` config that lists it is warned about and skipped. On csharp it is run by `dotnet meta docs`, and `dotnet meta gen` skips it with a warning.",
+      "ports": ["typescript", "csharp"]
     },
     "trace-helper": {
       "concept": "Per-entity typed record<Entity>/call<Entity> trace helpers (extract + buildLlmCallRow + persist; LlmCallBase-derived entities only).",
 
@@ -0,0 +1,122 @@
+// ADR-0034 Amendment 3 — eject hands over the emitters a generator writes its output through
+// (GeneratorRegistryEntry.Companions), not just the generator. The compile-and-engine-surface
+// proof is MetaObjects.Codegen.Tests' EjectedGeneratorsAloneTests; this is the command's half:
+// what `dotnet meta eject <name>` actually writes, derived from the registry for every name.
+
+using MetaObjects.Cli;
+using MetaObjects.Codegen;
+using Xunit;
+
+namespace MetaObjects.Cli.Tests;
+
+public sealed class EjectCompanionsTests : IDisposable
+{
+    private readonly string _root = Path.Combine(Path.GetTempPath(), "meta-eject-companions-" + Guid.NewGuid().ToString("N"));
+    private string Owned(string relative) => Path.Combine(_root, relative.Replace('/', Path.DirectorySeparatorChar));
+
+    public EjectCompanionsTests() => Directory.CreateDirectory(_root);
+    public void Dispose() { try { Directory.Delete(_root, recursive: true); } catch { } }
+
+    public static TheoryData<string> Ejectables
+    {
+        get
+        {
+            var data = new TheoryData<string>();
+            foreach (var name in EjectCommand.EjectableNames()) data.Add(name);
+            return data;
+        }
+    }
+
+    [Theory]
+    [MemberData(nameof(Ejectables))]
+    public void Ejecting_a_generator_alone_writes_its_source_and_its_emitters_and_nothing_else_of_the_packages(string name)
+    {
+        var entry = GeneratorRegistry.Get(name)!;
+        var outcome = EjectCommand.Run([name], _root, force: false);
+        Assert.Equal(0, outcome.ExitCode);
+
+        // Everything under codegen/ the command wrote: the files it names, the scaffold, and the helper
+        // runtime for a generator whose output imports it.
+        var written = Directory.GetFiles(Owned("codegen"), "*", SearchOption.AllDirectories)
+            .Select(f => Path.GetRelativePath(_root, f).Replace(Path.DirectorySeparatorChar, '/'))
+            .Where(f => f is not "codegen/Codegen.csproj" and not "codegen/Program.cs" && !f.StartsWith("codegen/runtime/", StringComparison.Ordinal))
+            .Order(StringComparer.Ordinal)
+            .ToList();
+        var expected = EjectableGenerators.SourcePaths(entry)
+            .Select(EjectableGenerators.OwnedRelativePath)
+            .Order(StringComparer.Ordinal)
+            .ToList();
+        Assert.Equal(expected, written);
+
+        // Each is the embedded source, rewritten the one way eject rewrites it.
+        foreach (var sourcePath in EjectableGenerators.SourcePaths(entry))
+            Assert.Equal(
+                EjectableGenerators.RewriteForEject(EjectableGenerators.ReadSourcePath(sourcePath)),
+                File.ReadAllText(Owned(EjectableGenerators.OwnedRelativePath(sourcePath))));
+    }
+
+    [Fact]
+    public void An_emitter_two_generators_share_is_copied_once_and_the_report_names_it()
+    {
+        var outcome = EjectCommand.Run(["output-parser", "extractor"], _root, force: false);
+        Assert.Equal(0, outcome.ExitCode);
+
+        var report = string.Join("\n", outcome.Out);
+        Assert.Equal(1, System.Text.RegularExpressions.Regex.Matches(report, @"codegen/generators/ExtractDelegateEmitter\.cs \[created\]").Count);
+        Assert.Contains("codegen/generators/Fr010FieldMapping.cs [created]", report);
+        Assert.Contains("codegen/generators/Fr019SharedEnum.cs [created]", report);
+    }
+
+    [Fact]
+    public void A_later_eject_keeps_an_emitter_already_yours_and_force_replaces_it()
+    {
+        Assert.Equal(0, EjectCommand.Run(["output-parser"], _root, force: false).ExitCode);
+        var emitter = Owned("codegen/generators/ExtractDelegateEmitter.cs");
+        File.AppendAllText(emitter, "// my edit\n");
+        var edited = File.ReadAllText(emitter);
+
+        // `extractor` shares the emitter: it is not a refusal, and the edit survives.
+        var second = EjectCommand.Run(["extractor"], _root, force: false);
+        Assert.Equal(0, second.ExitCode);
+        Assert.Contains("codegen/generators/ExtractDelegateEmitter.cs [kept — already yours]", string.Join("\n", second.Out));
+        Assert.Equal(edited, File.ReadAllText(emitter));
+
+        // --force replaces the generator copy and its emitters with the reference, as it always has.
+        var forced = EjectCommand.Run(["extractor"], _root, force: true);
+        Assert.Equal(0, forced.ExitCode);
+        Assert.Contains("codegen/generators/ExtractDelegateEmitter.cs [replaced]", string.Join("\n", forced.Out));
+        Assert.DoesNotContain("my edit", File.ReadAllText(emitter));
+    }
+
+    [Fact]
+    public void A_generator_with_no_emitters_reports_none()
+    {
+        var outcome = EjectCommand.Run(["filter-allowlist"], _root, force: false);
+        Assert.DoesNotContain("emitters", string.Join("\n", outcome.Out));
+    }
+
+    [Fact]
+    public void Ejecting_api_docs_wires_it_into_the_scaffolded_program()
+    {
+        Assert.Equal(0, EjectCommand.Run(["api-docs"], _root, force: false).ExitCode);
+
+        var program = File.ReadAllText(Owned("codegen/Program.cs"));
+        Assert.Contains("new ApiDocsGenerator(),", program);
+        Assert.True(File.Exists(Owned("codegen/generators/CSharpApiModelBuilder.cs")));
+    }
+
+    [Fact]
+    public void Docs_hand_off_to_the_owned_project_only_when_the_project_owns_api_docs()
+    {
+        Assert.False(CodegenHandoff.HasOwnedDocs(_root));
+
+        // A project that ejected something else has an owned codegen project, and `gen` hands off to it; `docs`
+        // does not, because that project's package may predate the `docs` command.
+        Assert.Equal(0, EjectCommand.Run(["entity"], _root, force: false).ExitCode);
+        Assert.True(CodegenHandoff.HasOwnedCodegen(_root));
+        Assert.False(CodegenHandoff.HasOwnedDocs(_root));
+
+        Assert.Equal(0, EjectCommand.Run(["api-docs"], _root, force: false).ExitCode);
+        Assert.True(CodegenHandoff.HasOwnedDocs(_root));
+    }
+}