docs: fix launch-blocking doc inaccuracies (quickstarts + underclaim sweep)

Pre-launch review found the newcomer quickstarts broken as written and ~8 docs
under-claiming shipped features (Java/Kotlin/Python route+filter+payload-VO+output-parser
codegen, Python ObjectManager, C# NuGet publication) while adjacent files said "shipped".
Code was verified solid; only the docs were wrong.

Newcomer-critical (re-ran every corrected snippet for real):
- typescript.md: fixed the flagship "Use" example (real flat path/authorRoutes/Fastify-plugin
  shape) + documented the working `meta migrate --from-db ... --apply` init path (baseline
  silently no-ops for a new project) + db.ts wiring + fastify/ESM/tsconfig notes.
- python.md: fixed the loader-API "Use" example (real imports + root.children()/get_meta_attr),
  the broken `python -m` gen/verify commands (→ metaobjects console-script), the providers
  example, @DataClass→BaseModel, pydantic/fastapi + 3.11+ notes, ObjectManager "roadmap"→shipped.
- server/python/README.md (PyPI page): removed the false `migrate`-module + SQLAlchemy claims.

Underclaim/self-contradiction sweep (verified each flip against source):
- README matrix, api-contract.md (self-contradicted 4×), csharp.md (NuGet 0.19.3), java.md,
  entities.md, templates-and-payloads.md, migrations-and-drift.md, typescript-client.md,
  llms-full.txt, docs/README.md — now accurately reflect the shipped state.

Refs the pre-launch review (.superpowers/sdd/launch-review-*.md).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XeGSV3StPCcJGZNNJ4ZfAb

Author: dmealing

README.md

@@ -88,7 +88,7 @@ first-week wedge plan — and `meta init` picks up from there.
 |---|---|---|---|
 | TypeScript | Published to npm at `0.19.3` (the `@metaobjectsdev/*` packages) | [`docs/ports/typescript.md`](docs/ports/typescript.md) | [`server/typescript/`](server/typescript/) · [`client/web/`](client/web/) |
 | Java | Loader + OMDB + render + Maven plugin all shipped; full conformance green | [`docs/ports/java.md`](docs/ports/java.md) | [`server/java/`](server/java/) |
-| Kotlin | Codegen tier on top of Java — 7 generators (entity, Exposed table, relations, payload, validator, Spring config, storedProc); 12 / 12 persistence-conformance | [`docs/ports/kotlin.md`](docs/ports/kotlin.md) | [`server/java/codegen-kotlin/`](server/java/codegen-kotlin/) · [`server/java/metadata-ktx/`](server/java/metadata-ktx/) |
+| Kotlin | Codegen tier on top of Java — 9 generators (entity, Exposed table, relations, payload, output-parser, validator, Spring config, storedProc, Spring controller); 12 / 12 persistence-conformance | [`docs/ports/kotlin.md`](docs/ports/kotlin.md) | [`server/java/codegen-kotlin/`](server/java/codegen-kotlin/) · [`server/java/metadata-ktx/`](server/java/metadata-ktx/) |
 | C# | Loader + conformance + EF Core codegen + render engine + `dotnet meta` CLI all shipped | [`docs/ports/csharp.md`](docs/ports/csharp.md) | [`server/csharp/`](server/csharp/) |
 | Python | Loader + conformance + render + entity-model codegen + ObjectManager runtime shipped; schema migrations are TS-owned (ADR-0015) | [`docs/ports/python.md`](docs/ports/python.md) | [`server/python/`](server/python/) |
 
@@ -103,26 +103,27 @@ first-week wedge plan — and `meta init` picks up from there.
 | `field.currency` / `field.enum` | Yes | Yes | Yes | Yes | Yes |
 | `field.object` + `@storage=flattened` | Yes | Yes | Yes (per-sub-field columns) | Yes (EF Core `OwnsOne`) | Loader yes; codegen partial |
 | Templates + render (FR-004) | Yes | Yes | Yes (wraps Java) | Yes | Yes |
-| Payload-VO codegen | Yes (via projection) | – (consumers use `Map`) | Yes (`@Serializable`) | Yes | – (consumers use `dict`) |
+| Payload-VO codegen | Yes (via projection) | Yes (`SpringPayloadGenerator`) | Yes (`@Serializable`) | Yes | Yes (`payload_vo_generator`) |
 | Migration emission | `meta migrate` (Postgres / SQLite / D1) | Via TS toolchain (`@metaobjectsdev/cli migrate`) | Via TS toolchain (`@metaobjectsdev/cli migrate`) | Via TS toolchain (ADR-0015) | Via TS toolchain (ADR-0015) |
 | DB-drift verify | `meta verify --db` | Template-drift: `Renderer.verify`; schema-drift is TS-owned (ADR-0015) | Template-drift: `Renderer.verify`; startup: `MetadataStartupValidator` | `dotnet meta verify` (codegen-drift) | Schema-drift is TS-owned (ADR-0015) |
 | Template-drift verify | Yes | Yes (`Renderer.verify`) | Yes (via Java) | Yes (`meta verify`) | Yes (`metaobjects.render.verify`) |
 | YAML authoring (sigil-free → JSON) | Yes | Yes | Yes (via Java) | Yes | Yes |
 | Runtime metadata (ObjectManager-style) | Yes (`runtime-ts`) | Yes (OMDB) | Yes (via Java OMDB + Exposed) | Roadmap | Yes (ObjectManager) |
-| React / UI client (browser) | Yes (`@metaobjectsdev/react` + `@metaobjectsdev/tanstack`; codegen + runtime) | Consumes TS client via REST | Consumes TS client via REST | Consumes TS client via REST | Consumes TS client via REST |
-| Cross-port REST routes for the client | Generated (`routesFile()` → Fastify) | Hand-write Spring controller per contract | Hand-write Spring-Kotlin / Ktor per contract | Generated (`RoutesGenerator` → ASP.NET Minimal API) | Hand-write FastAPI router per contract |
+| React / Angular UI client (browser) | Yes — React (`@metaobjectsdev/react` + `@metaobjectsdev/tanstack`) and Angular 18 (`@metaobjectsdev/angular`, published at `0.6.0`); both codegen + runtime | Consumes TS client via REST | Consumes TS client via REST | Consumes TS client via REST | Consumes TS client via REST |
+| Cross-port REST routes for the client | Generated (`routesFile()` → Fastify) | Generated (`SpringControllerGenerator` → Spring `@RestController`, incl. filter/sort) | Generated (`KotlinSpringControllerGenerator` → Spring `@RestController`, incl. filter/sort) | Generated (`RoutesGenerator` → ASP.NET Minimal API) | Generated (`router_generator` → FastAPI `APIRouter`, incl. filter/sort) |
 
 A "Yes" means the feature is covered by the shared conformance corpora at
 [`fixtures/`](fixtures/) for that port, or by a port-local test of equivalent
 scope. A "partial" means the loader recognizes the metamodel feature but the
 codegen / runtime tier doesn't fully exercise it yet.
 
-The React / UI client is TypeScript-only by construction (the browser is
-TS-native) but is **universal** — see
+The React and Angular UI clients are TypeScript-only by construction (the
+browser is TS-native) but are **universal** — see
 [`docs/features/api-contract.md`](docs/features/api-contract.md) for the
 URL grammar + wire format the client speaks, and
 [`docs/ports/typescript-client.md`](docs/ports/typescript-client.md) for
-the consumer-side wiring.
+the consumer-side wiring (React + TanStack, and the
+[Angular 18 tier](docs/ports/typescript-client.md#angular-18)).
 
 ## Four pillars
 
@@ -178,7 +179,7 @@ metaobjects/
 │   └── python/                     # Python port
 │
 └── client/
-    └── web/                        # universal browser packages (React, TanStack, framework-agnostic)
+    └── web/                        # universal browser packages (React, TanStack, Angular, framework-agnostic)
 ```
 
 ## Getting started

docs/README.md

@@ -16,27 +16,40 @@ copy-paste cross-port without context-switching.
 docs/
 ├── README.md                    # this file
 ├── CONFORMANCE.md               # inverse index: fixture → feature doc + per-port pass status
-├── features/                    # one file per metamodel feature
+├── features/                    # one file per metamodel feature — see `ls docs/features/`
+│                                 # for the definitive, always-current list; as of this
+│                                 # writing:
 │   ├── entities.md
 │   ├── source-kinds.md
 │   ├── relationships.md
 │   ├── field-types.md
 │   ├── templates-and-payloads.md
 │   ├── loaders.md
 │   ├── migrations-and-drift.md
+│   ├── migrations/                  # per-version migration guides (e.g. 0.x → 1.0)
 │   ├── api-contract.md          # cross-port REST contract (the universal browser client speaks it)
 │   ├── abstracts-and-inheritance.md # abstract: true + extends: — author-side shape reuse
 │   ├── extending-with-providers.md  # custom metamodel subtypes/attrs via MetaDataTypeProvider
-│   └── yaml-authoring.md
+│   ├── yaml-authoring.md
+│   ├── cli.md                       # CLI command matrix across all five ports
+│   ├── codegen-concepts.md          # declarative template-codegen scopes (perEntity/perPackage/perModel)
+│   ├── codegen-data-shapes.md       # the neutral template data dict shared cross-port
+│   ├── downstream-metadata-decisions.md # guidance for adopters extending the metamodel
+│   ├── generated-mutations.md       # generated POST/PATCH mutation surface
+│   ├── image-upload.md              # view.image form control (TS-web)
+│   └── own-your-codegen.md          # scaffold-and-own generator ownership (ADR-0034)
 └── ports/                       # one file per language/framework port
     ├── typescript.md
-    ├── typescript-client.md     # browser-side TS (React, TanStack, codegen pairs)
+    ├── typescript-client.md     # browser-side TS (React, TanStack, Angular, codegen pairs)
     ├── java.md
     ├── kotlin.md
     ├── csharp.md
     └── python.md
 ```
 
+If this list and `ls docs/features/` ever disagree, trust the directory listing —
+this tree is documentation, not the source of truth.
+
 ## When to read which
 
 | You want to … | Read |
@@ -48,7 +61,7 @@ docs/
 | Wire prompt construction (FR-004) | [`features/templates-and-payloads.md`](features/templates-and-payloads.md) |
 | Share a metadata shape across multiple instances (abstracts, `extends:`) | [`features/abstracts-and-inheritance.md`](features/abstracts-and-inheritance.md) |
 | Add a custom metamodel subtype or attribute to a downstream project | [`features/extending-with-providers.md`](features/extending-with-providers.md) + [`recipes/extending-metaobjects-with-providers.md`](recipes/extending-metaobjects-with-providers.md) |
-| Wire the universal browser client (React + TanStack) to any backend | [`ports/typescript-client.md`](ports/typescript-client.md) + [`features/api-contract.md`](features/api-contract.md) |
+| Wire the universal browser client (React + TanStack, or Angular 18) to any backend | [`ports/typescript-client.md`](ports/typescript-client.md) (see [§Angular 18](ports/typescript-client.md#angular-18) for the Angular tier) + [`features/api-contract.md`](features/api-contract.md) |
 | Know which feature is supported in which port today | the capability matrix in the root [`README.md`](../README.md) or the per-port "Capability snapshot" table |
 | See which conformance fixtures gate each feature (and which port passes which) | [`CONFORMANCE.md`](CONFORMANCE.md) |
 | Read the canonical spec (target-agnostic) | [`../spec/`](../spec/) |

docs/features/api-contract.md

@@ -19,10 +19,10 @@ Throughout the doc the worked example is an `Author` entity in the
 
 The contract has two halves: the **URL grammar** (paths + query-string
 shape) and the **wire format** (JSON request / response bodies). Both
-halves are language-agnostic and stable across the four shipped
-language ports. Routes can be **generated** (where the port ships a
-route generator) or **hand-written** (where it doesn't) — the wire
-behavior is identical either way.
+halves are language-agnostic and stable across all five shipped
+language ports. Every port ships a generated route implementation today
+(see "Per-port route codegen status" below) — hand-writing a controller
+is an option for custom needs, not the default path.
 
 ## The `EntityFetcher` contract
 
@@ -72,7 +72,7 @@ helper (so `Author` → `authors`). Generated TS hooks read `$path` from
 the entity-constants file, so the client and the server agree on the
 path segment without hand-coordination.
 
-### Filter operators (8)
+### Filter operators (9)
 
 Filters use a **bracketed qs** shape: `filter[<field>][<op>]=<value>`.
 A bare value (`filter[<field>]=<value>`) is sugar for `eq`. Multiple
@@ -90,12 +90,12 @@ filters AND together.
 The operator set is gated by field subtype in the generated
 `<Entity>FilterAllowlist`. A request with an operator that the field
 subtype doesn't support → HTTP 400. The operator list is a Tier 1
-cross-port invariant — every port's parser must implement these eight
-and only these eight.
+cross-port invariant — every port's parser must implement these nine
+and only these nine.
 
 ### TS-only filter extensions (not part of the cross-port contract)
 
-The TypeScript runtime parser ships five filter behaviors beyond the eight
+The TypeScript runtime parser ships five filter behaviors beyond the nine
 operators. They are **NOT part of the cross-port REST contract** — the other
 ports (Java, Kotlin, Python, C#) do not implement them, and a relying adopter
 must not assume them on a non-TS backend. They are deliberately deferred until
@@ -191,17 +191,20 @@ retryable / log-only.
 |---|---|---|
 | TypeScript | shipped — `@metaobjectsdev/codegen-ts` `routesFile()` → Fastify (`@metaobjectsdev/runtime-ts/drizzle-fastify`) AND `routesFileHono()` → Hono (`@metaobjectsdev/runtime-ts/hono`) | Reference implementation; full filter/sort + `withCount` support. Both flavors emit byte-identical on-the-wire responses for the same metadata (same envelopes, same status codes, same filter operator parser), so consumers can pick the server framework that matches their runtime (Fastify for long-lived Node, Hono for Workers / Bun / edge). |
 | C# | shipped — `MetaObjects.Codegen` `RoutesGenerator` → ASP.NET Minimal API | `MapGet` / `MapPost` / `MapPut` / `MapDelete` mounted under `apiPrefix`; full CRUD. |
-| Java | shipped — `metaobjects-codegen-spring` `SpringControllerGenerator` + `SpringDtoGenerator` + `SpringRepositoryGenerator` → Spring `@RestController` (Spring Boot 3.x / Spring Web MVC) | One controller per writable entity (`source.rdb @kind="table"`); 5 CRUD endpoints (GET list / GET by id / POST / PATCH + PUT / DELETE); `?sort`, `?limit/?offset`, `?withCount=1` envelope, 404 + 400 envelopes per the contract. Java 21 record DTOs for request/response; a stubbed `<Entity>Repository` interface the consumer implements against their persistence layer (JPA / jOOQ / JDBC). Filter operators (`eq/ne/...`) deferred — see the module's `KNOWN_GAPS.md`. |
-| Kotlin | shipped — `metaobjects-codegen-kotlin` `KotlinSpringControllerGenerator` → Spring `@RestController` | One controller per writable entity (`source.rdb @kind="table"`); 5 CRUD endpoints (GET list / GET by id / POST / PATCH+PUT / DELETE); `?sort`, `?limit/?offset`, `?withCount=1` envelope, 404 + 400 envelopes per the contract. Filter operators (`eq/ne/...`) deferred. |
-| Python | shipped — `metaobjects.codegen.generators.router_generator` → FastAPI `APIRouter` | One router per writable entity (`source.rdb @kind="table"`); 5 CRUD endpoints (GET list / GET by id / POST / PATCH+PUT / DELETE); `?sort`, `?limit/?offset`, `?withCount=1` envelope, 404 + 400 envelopes per the contract. Consumer wires the repository via FastAPI `app.dependency_overrides`; the generator emits a `Protocol` interface so the persistence layer (SQLAlchemy / asyncpg / etc.) is the consumer's choice. Filter operators (`eq/ne/...`) deferred — see the module's `KNOWN_GAPS.md`. |
+| Java | shipped — `metaobjects-codegen-spring` `SpringControllerGenerator` + `SpringDtoGenerator` + `SpringRepositoryGenerator` → Spring `@RestController` (Spring Boot 3.x / Spring Web MVC) | One controller per writable entity (`source.rdb @kind="table"`); 5 CRUD endpoints (GET list / GET by id / POST / PATCH + PUT / DELETE); `?sort`, `?limit/?offset`, `?withCount=1` envelope, 404 + 400 envelopes per the contract. Java 21 record DTOs for request/response; a stubbed `<Entity>Repository` interface the consumer implements against their persistence layer (JPA / jOOQ / JDBC). Filter operators (`eq/ne/gt/gte/lt/lte/in/like/isNull`) ship via the generated `<Entity>FilterAllowlist` (`SpringFilterAllowlistGenerator`) + the runtime `FilterParser`, wired directly into the list handler. |
+| Kotlin | shipped — `metaobjects-codegen-kotlin` `KotlinSpringControllerGenerator` → Spring `@RestController` | One controller per writable entity (`source.rdb @kind="table"`); 5 CRUD endpoints (GET list / GET by id / POST / PATCH+PUT / DELETE); `?sort`, `?limit/?offset`, `?withCount=1` envelope, 404 + 400 envelopes per the contract. Filter operators ship via the generated `<Entity>FilterAllowlist` (`KotlinFilterAllowlistGenerator`) + an inline `parse<Entity>Filter` helper emitted in the controller. |
+| Python | shipped — `metaobjects.codegen.generators.router_generator` → FastAPI `APIRouter` | One router per writable entity (`source.rdb @kind="table"`); 5 CRUD endpoints (GET list / GET by id / POST / PATCH+PUT / DELETE); `?sort`, `?limit/?offset`, `?withCount=1` envelope, 404 + 400 envelopes per the contract. Consumer wires the repository via FastAPI `app.dependency_overrides`; the generator emits a `Protocol` interface so the persistence layer (SQLAlchemy / asyncpg / etc.) is the consumer's choice. Filter operators ship via the generated `<entity>_filter_allowlist.py` (`filter_allowlist_generator.py`) + the shared `filter_parser` helper, wired into the list handler. |
 
-## Hand-writing a conforming controller
+## Hand-writing a conforming controller (if you outgrow the generated one)
 
-While the planned route-codegen work matures, here is the minimum
-controller needed to make `useAuthors`, `useAuthor`, etc. work against
-each non-TS / non-C# backend. The shape is the same in every language —
-mount five (or six, if you want PUT) routes under `apiPrefix` that
-match the URL grammar above.
+Every port ships a route generator today (see the status table above) —
+you do not need to hand-write a controller to get a conforming API. This
+section is for the rare case where you need a shape the generator
+doesn't cover (a custom auth scheme, a framework the generator doesn't
+target, etc.) and want a hand-rolled controller that still speaks the
+contract. The shape is the same in every language — mount five (or six,
+if you want PUT) routes under `apiPrefix` that match the URL grammar
+above.
 
 ### Java — Spring `@RestController`
 
@@ -303,20 +306,24 @@ into your framework's idiomatic query-builder, gated by the generated
 
 ## Future direction
 
-Cross-port route codegen — for Java (Spring), Kotlin (Spring-Kotlin /
-Ktor), Python (FastAPI), and a browser-side Angular client — is planned
-but not yet specced. The planned FR will track:
+Cross-port route + filter codegen (Java, Kotlin, Python), the shared
+route-shape oracle (`fixtures/api-contract-conformance/`), and a
+browser-side Angular client have all shipped — see "Per-port route
+codegen status" and "Verified by" above, and
+[`docs/ports/typescript-client.md#angular-18`](../ports/typescript-client.md#angular-18).
 
-- A shared route-shape oracle (analogous to the persistence-conformance
-  corpus) covering `list` / `get` / `create` / `update` / `delete` +
-  filter / sort / `withCount` + the error-response shape.
-- Per-port route generators emitting idiomatic controllers / routers
-  against that oracle.
-- An Angular client (browser-side) that consumes the same generated
-  hook surface as the React client.
+What's still genuinely open:
 
-Until then, hand-written controllers per the templates above are
-expected, and they remain the conformance gate.
+- The five **TS-only filter extensions** (`?search=`, `filter[or]` /
+  `filter[and]` nesting, leading-wildcard gating, the nesting-depth cap,
+  and the `in`-list size cap) — see "TS-only filter extensions" above.
+  None touch the metamodel vocabulary, so any of them can be promoted
+  cross-port later as a purely additive, non-breaking change if real
+  consumer demand shows up.
+- The `error` code vocabulary is not yet a hard cross-port invariant
+  beyond `not_found` and the filter-parser error codes.
+
+Neither item blocks adoption on any port today.
 
 ## Verified by
 
@@ -337,15 +344,14 @@ envelope shape) is exercised by the cross-port corpus at
 port's runner spins up a real HTTP server hosting its emitted routes for the
 canonical `Author` entity, walks the scenarios, and asserts byte-shape
 identical responses against the cross-port `expect.body.*` vocabulary.
-TypeScript + Kotlin runners ship; Java / C# / Python runners are planned
-follow-ups. See [`docs/CONFORMANCE.md`](../CONFORMANCE.md) for per-port pass
-status.
-
-Filter operator coverage (`eq` / `ne` / `gt` / `like` / `in` / `isNull`) is
-deferred from the API-contract corpus on purpose — backends defer those per
-their `KNOWN_GAPS.md`, so a scenario for `filter[name][like]=...` would fail
-on every port today. Filter-operator scenarios land alongside the per-port
-operator implementations.
+All five ports ship a runner — TypeScript, Java, Kotlin, C#, and Python
+each spin up their generated routes and pass every scenario. See
+[`docs/CONFORMANCE.md`](../CONFORMANCE.md) for per-port pass status.
+
+Filter operator coverage (`eq` / `ne` / `gt` / `gte` / `lt` / `lte` / `in` /
+`like` / `isNull`) is part of the corpus: 10 filter scenarios run on top of
+the 10 base CRUD scenarios, and all five ports satisfy all 20 today (see
+[`docs/CONFORMANCE.md`](../CONFORMANCE.md)).
 
 ## See also