fix(python): pre-merge review — complete FR5a envelope coverage

Three issues surfaced by the pre-merge review:

* Parser-constructed attr nodes were never source-stamped. Both the inline
  `@`-attr path (`_build`) and the typed attr-child path (`_parse_attr_child`)
  called `parent.set_attr(...)` which constructs a fresh MetaAttribute via
  `MetaData.set_attr` (meta_data.py:61-69) without copying provenance — so
  every parser-created attr node wore `CodeSource.DEFAULT` instead of a
  `JsonSource`. Now: locate the just-set attr via `own_meta_attr` and call
  `set_source(_current_envelope(...))`. Mirrors C# Parser.cs:1039
  (`attrModel.SetSource(st.CurrentSource())`). Two regression tests cover
  both call sites.

* `_parse_source` carved out a `<inline>` case and fell back to
  `CodeSource.DEFAULT` while the parser's `_current_envelope` built a
  `JsonSource(files=("<inline>",), ...)`. Two same-source errors carried
  inconsistent envelope formats. Drop the carve-out — match C# Parser.cs:140
  which only checks `Source is null`. No tests relied on the old behavior.

* `ERR_PROVIDER_ATTR_CONFLICT` was the only one of 29 MetaError sites that
  omitted `envelope=`. Thread the current node into `_effective_schemas` and
  attach `envelope=node.source`. Mirrors C# ValidationPasses.cs:593-596.

Test count: 494 → 496 (2 new tests; all pass).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: dmealing

server/python/src/metaobjects/loader/meta_data_loader.py

@@ -141,10 +141,13 @@ def _parse_source(
         the merge set.
         """
         # FR5a / ADR-0009 — top-level envelope for the source. Until the parser
-        # walk descends, the offending location is the root (`$`).
+        # walk descends, the offending location is the root (`$`). Matches C#
+        # Parser.cs:140 — only fall back to CodeSource when there is no source
+        # id at all; "<inline>" is a valid source identifier and must yield a
+        # JsonSource so envelope formats remain consistent across error sites.
         envelope: ErrorSource = (
             JsonSource(files=(src.id,), json_path="$")
-            if src.id and src.id != "<inline>"
+            if src.id
             else CodeSource.DEFAULT
         )
 

server/python/src/metaobjects/loader/validation_passes.py

@@ -139,11 +139,14 @@ def _effective_schemas(
     common_attrs: list[AttrSchema],
     registry: TypeRegistry,
     errors: list[MetaError],
+    node: MetaData,
 ) -> tuple[list[AttrSchema], dict[str, AttrSchema]]:
     """Compute the effective attr schema for a (type, sub_type).
 
     Per-type attrs win over common attrs of the same name. If any collision
     exists, append a single ERR_PROVIDER_ATTR_CONFLICT for this (type, sub_type).
+    *node* supplies the FR5a envelope for the conflict error (matches C#
+    ValidationPasses.cs:593-596 — ``Envelope: node.Source``).
     """
     per_type_attrs = registry.attrs_of(type_, sub_type)
     per_type_names = {s.name for s in per_type_attrs}
@@ -155,6 +158,7 @@ def _effective_schemas(
                     f"{type_}.{sub_type} has a per-type attr '@{ca.name}' "
                     f"that conflicts with a common attr of the same name",
                     ErrorCode.ERR_PROVIDER_ATTR_CONFLICT,
+                    envelope=node.source,
                 )
             )
             break  # one error per (type, sub_type) is sufficient
@@ -177,7 +181,7 @@ def _validate_attr_schema(
         key = (node.type, node.sub_type)
         cached = schema_cache.get(key)
         if cached is None:
-            cached = _effective_schemas(node.type, node.sub_type, common_attrs, registry, errors)
+            cached = _effective_schemas(node.type, node.sub_type, common_attrs, registry, errors, node)
             schema_cache[key] = cached
         schemas, schema_by_name = cached
 

server/python/src/metaobjects/parser.py

@@ -174,6 +174,14 @@ def _build(
                 continue
             schema = registry.attr_schema(type_, sub_type, attr_name)
             node.set_attr(attr_name, value, sub_type=schema.value_type if schema else None)
+            # FR5a / ADR-0009 — stamp the just-constructed MetaAttribute node with
+            # its origin envelope. Mirrors C# Parser.cs:1039 (attrModel.SetSource).
+            # The attr's JsonPath points at the @-key on the parent body.
+            attr_node = node.own_meta_attr(attr_name)
+            if attr_node is not None:
+                builder.push_key(key)
+                attr_node.set_source(_current_envelope(source, builder))
+                builder.pop()
 
     # The context package for children: use this node's own package if set, else inherit.
     child_ctx_pkg = node.package or ctx_pkg
@@ -233,6 +241,12 @@ def _parse_attr_child(
     # Resolve the attr sub_type; fall back to base if unregistered.
     resolved_sub = sub_type if registry.find(TYPE_ATTR, sub_type) is not None else None
     parent.set_attr(attr_name, raw_value, sub_type=resolved_sub)
+    # FR5a / ADR-0009 — stamp the just-constructed MetaAttribute node with its
+    # origin envelope. Mirrors C# Parser.cs:1039 (attrModel.SetSource). The
+    # builder already points at the `attr.<sub>` wrapper (caller pushed it).
+    attr_node = parent.own_meta_attr(attr_name)
+    if attr_node is not None:
+        attr_node.set_source(_current_envelope(source, builder))
 
 
 def _iter_children(body: dict[str, object]) -> list[tuple[str, object]]:

server/python/tests/source/test_source_on_node.py

@@ -157,3 +157,90 @@ def test_metadata_subclass_inherits_source_attribute() -> None:
     root = MetaRoot(TYPE_METADATA, SUBTYPE_ROOT, "")
     assert isinstance(root, MetaData)
     assert root.source.format == "code"
+
+
+def test_parser_stamps_source_on_inline_attribute_nodes() -> None:
+    # FR5a / ADR-0009 — every parser-constructed MetaAttribute node (inline
+    # @-prefixed attr on a body) carries a JsonSource. Mirrors C# Parser.cs:1039
+    # (attrModel.SetSource). Without source-stamping the attr node wears
+    # CodeSource.DEFAULT, which violates the FR5a envelope-coverage invariant.
+    json_text = """
+        { "metadata.root": {
+            "package": "demo",
+            "children": [
+              { "object.entity": {
+                  "name": "Widget",
+                  "children": [
+                    { "field.string": { "name": "email", "@filterable": true } }
+                  ]
+              } }
+            ]
+        } }
+    """
+    loader = MetaDataLoader()
+    result = loader.load([
+        InMemoryStringSource(
+            json_text, format=MetaDataFormat.JSON, id="metaobjects/widget.json",
+        ),
+    ])
+    assert not result.errors
+
+    root = result.root
+    entity = next(c for c in root.own_children() if c.type == TYPE_OBJECT)
+    email = next(c for c in entity.own_children() if c.type == TYPE_FIELD)
+    filterable_attr = email.own_meta_attr("filterable")
+    assert filterable_attr is not None
+    assert isinstance(filterable_attr.source, JsonSource), (
+        f"expected JsonSource on inline @filterable attr node, "
+        f"got {type(filterable_attr.source).__name__}"
+    )
+    assert filterable_attr.source.files == ("metaobjects/widget.json",)
+    # The JsonPath points at the @-key on the parent body.
+    assert filterable_attr.source.json_path == (
+        "$['metadata.root'].children[0]['object.entity']"
+        ".children[0]['field.string']['@filterable']"
+    )
+
+
+def test_parser_stamps_source_on_typed_attr_child_nodes() -> None:
+    # FR5a / ADR-0009 — typed attr children (the `{ "attr.<sub>": {...} }` form)
+    # are also parser-constructed; they must carry a JsonSource too. Mirrors
+    # the same C# Parser.cs:1039 source-stamping path.
+    json_text = """
+        { "metadata.root": {
+            "package": "demo",
+            "children": [
+              { "object.entity": {
+                  "name": "Widget",
+                  "children": [
+                    { "field.string": { "name": "email", "children": [
+                      { "attr.boolean": { "name": "filterable", "value": true } }
+                    ] } }
+                  ]
+              } }
+            ]
+        } }
+    """
+    loader = MetaDataLoader()
+    result = loader.load([
+        InMemoryStringSource(
+            json_text, format=MetaDataFormat.JSON, id="metaobjects/widget.json",
+        ),
+    ])
+    assert not result.errors
+
+    root = result.root
+    entity = next(c for c in root.own_children() if c.type == TYPE_OBJECT)
+    email = next(c for c in entity.own_children() if c.type == TYPE_FIELD)
+    filterable_attr = email.own_meta_attr("filterable")
+    assert filterable_attr is not None
+    assert isinstance(filterable_attr.source, JsonSource), (
+        f"expected JsonSource on typed attr.boolean child node, "
+        f"got {type(filterable_attr.source).__name__}"
+    )
+    assert filterable_attr.source.files == ("metaobjects/widget.json",)
+    # Path threads to the attr.boolean wrapper key on the parent's children array.
+    assert filterable_attr.source.json_path == (
+        "$['metadata.root'].children[0]['object.entity']"
+        ".children[0]['field.string'].children[0]['attr.boolean']"
+    )