feat(python): metaJson helper for the GET /_meta contract

Exports META_ROUTE_PATH ("/_meta") and meta_json(root), a thin wrapper over
canonical_serialize_effective. Python ships the helper only, not a mount:
neither metaobjects.runtime nor metaobjects.codegen.runtime imports a web
framework, and one endpoint is not a reason to make either framework-bound
(mirrors the C# and Java ports).

Closes a barrel gap: canonical_serialize_effective was not exported from
metaobjects/__init__.py — exported it alongside meta_json.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015NrWUxA6euwvnFcwKxcK6A

Author: dmealing

server/python/src/metaobjects/__init__.py

@@ -35,7 +35,9 @@
     extract_schema_for,
 )
 from .meta.core.object.value_object import ValueObject
+from .meta_endpoint import META_ROUTE_PATH, meta_json
 from .naming import resolve_column_name
+from .serializer_json import canonical_serialize_effective
 
 # Module-level shortcuts: the 99% case for callers who don't need a
 # long-lived loader. Signatures + docstrings come straight from the
@@ -60,6 +62,10 @@
     "load_uris",
     "load_string",
     "resolve_column_name",
+    # UI-1 — the metadata API contract (GET /_meta)
+    "META_ROUTE_PATH",
+    "meta_json",
+    "canonical_serialize_effective",
     # Runtime object model (Phase A)
     "ValueObject",
     "MetaObjectAware",

server/python/src/metaobjects/meta_endpoint.py

@@ -0,0 +1,30 @@
+"""UI-1 — the metadata API contract.
+
+Python ships the helper and not a mount: neither ``metaobjects.runtime`` nor
+``metaobjects.codegen.runtime`` imports a web framework, and one endpoint is not
+a reason to make either of them framework-bound. Mount it yourself::
+
+    @app.get(f"/api{META_ROUTE_PATH}")
+    def meta() -> Response:
+        return Response(meta_json(root), media_type="application/json")
+
+Guard that route with your own authorization — ``/_meta`` publishes the shape of
+the model (entity and field names, types, validators, layouts), though no row data.
+"""
+from __future__ import annotations
+
+from metaobjects.meta.meta_data import MetaData
+from metaobjects.serializer_json import canonical_serialize_effective
+
+#: The endpoint path, mounted under the host's API prefix. A cross-port contract
+#: value — one browser read-model works against every backend.
+META_ROUTE_PATH = "/_meta"
+
+
+def meta_json(root: MetaData) -> str:
+    """The response body: the model as EFFECTIVE canonical JSON.
+
+    Effective, not raw: the effective form materializes the super-chain merge, so
+    a browser reading it never resolves ``extends`` itself.
+    """
+    return canonical_serialize_effective(root)

server/python/tests/test_meta_endpoint.py

@@ -0,0 +1,69 @@
+"""UI-1 — GET /_meta contract: the Python `meta_json` helper.
+
+Loads the shared `extends-abstract-base` conformance fixture (real object-level
+inheritance: `Subscriber extends acme::BaseEntity`, and `BaseEntity` declares
+`createdAt`) and asserts `meta_json` returns the EFFECTIVE canonical
+serialization — the one that inlines inherited members — never the raw one.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from metaobjects import META_ROUTE_PATH, MetaDataLoader, meta_json
+from metaobjects.core_types import core_provider
+from metaobjects.serializer_json import canonical_serialize, canonical_serialize_effective
+
+
+def _fixtures_root() -> Path:
+    """Walk up from this file to find the repo-shared `fixtures/conformance` dir
+    (mirrors `tests/conformance/corpus.py`'s `corpus_root()` — no hardcoded path)."""
+    here = Path(__file__).resolve()
+    for parent in [here, *here.parents]:
+        candidate = parent / "fixtures" / "conformance"
+        if candidate.is_dir():
+            return candidate
+    raise RuntimeError("could not locate fixtures/conformance from " + str(here))
+
+
+def load_extends_fixture():
+    """Load `fixtures/conformance/extends-abstract-base/input` and assert a
+    clean load (ADR-0023: a fixture with no `expected-errors.json` must load
+    with zero errors)."""
+    input_dir = _fixtures_root() / "extends-abstract-base" / "input"
+    result = MetaDataLoader.from_directory(input_dir, providers=[core_provider])
+    assert not result.errors, result.errors
+    return result.root
+
+
+def test_meta_route_path_is_the_cross_port_contract_value() -> None:
+    assert META_ROUTE_PATH == "/_meta"
+
+
+def test_meta_json_returns_the_effective_canonical_serialization() -> None:
+    root = load_extends_fixture()
+    assert meta_json(root) == canonical_serialize_effective(root)
+
+
+def test_meta_json_inlines_a_member_inherited_via_extends() -> None:
+    """The real discriminator: `createdAt` is declared only on `BaseEntity`, not
+    on `Subscriber`. `Subscriber` is the last top-level object in the fixture's
+    document, in both raw and effective form, so slicing from its `"name"` key
+    to end-of-document isolates exactly its own block (own children only, raw;
+    the super-chain-merged set, effective) without picking up `BaseEntity`'s
+    unrelated `createdAt` declaration earlier in the same document.
+
+    `createdAt` must appear in that slice for the EFFECTIVE serialization
+    (proving the super-chain merge ran) and must be ABSENT from that slice for
+    the RAW one — which is exactly what would fail if `meta_json` ever called
+    `canonical_serialize` instead of `canonical_serialize_effective`.
+    """
+    root = load_extends_fixture()
+
+    effective = meta_json(root)
+    raw = canonical_serialize(root)
+
+    effective_subscriber = effective[effective.index('"name": "Subscriber"'):]
+    raw_subscriber = raw[raw.index('"name": "Subscriber"'):]
+
+    assert "createdAt" in effective_subscriber
+    assert "createdAt" not in raw_subscriber