metaobjects 0.21.6__tar.gz → 0.22.0__tar.gz

{metaobjects-0.21.6 → metaobjects-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: metaobjects
-Version: 0.21.6
+Version: 0.22.0
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-0.21.6 → metaobjects-0.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.21.6"
+version = "0.22.0"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-0.21.6 → metaobjects-0.22.0}/src/metaobjects/core_types.py

@@ -62,6 +62,19 @@ from .meta.core.object.object_constants import (
     OBJECT_SUBTYPES,
 )
 from .meta.core.relationship.meta_relationship import MetaRelationship
+from .meta.core.requirement.meta_requirement import MetaRequirement
+from .meta.core.requirement.requirement_constants import (
+    REQUIREMENT_ATTR_IMPLEMENTED_BY,
+    REQUIREMENT_ATTR_LEVEL,
+    REQUIREMENT_ATTR_STATEMENT,
+    REQUIREMENT_ATTR_STATUS,
+    REQUIREMENT_ATTR_SUPERSEDED_BY,
+    REQUIREMENT_ATTR_VERIFIED_BY,
+    REQUIREMENT_ATTR_VIOLATION,
+    REQUIREMENT_STATUSES,
+    REQUIREMENT_SUBTYPE_ARCHITECTURAL,
+    REQUIREMENT_SUBTYPE_FUNCTIONAL,
+)
 from .meta.core.relationship.relationship_constants import (
     REFERENTIAL_ACTIONS,
     RELATIONSHIP_ATTR_CARDINALITY,
@@ -134,6 +147,7 @@ from .shared.base_types import (
     TYPE_OBJECT,
     TYPE_ORIGIN,
     TYPE_RELATIONSHIP,
+    TYPE_REQUIREMENT,
     TYPE_SOURCE,
     TYPE_TEMPLATE,
     TYPE_VALIDATOR,
@@ -186,8 +200,9 @@ def _register_subtypes(
 # NOT declared in any spec/metamodel/*.json provider file; both this port and the TS
 # reference HAND-CODE the root (the single documented hand-coded exception to the
 # JSON-sourced model). Its STRUCTURAL children must byte-match the cross-port golden:
-# description "Root metadata document" and EXACTLY the four genuinely-open structural
-# wildcards a document root legitimately holds — field / object / template / validator
+# description "Root metadata document" and EXACTLY the five genuinely-open structural
+# wildcards a document root legitimately holds — field / object / requirement /
+# template / validator
 # (mirrors the TS core-types.ts root def and the Java MetaRoot registration). Because
 # it is undeclared in the JSON, the strict-children pass leaves it untouched, so the
 # children registered HERE are emitted verbatim. The any-attr wildcard is intentionally
@@ -201,6 +216,8 @@ core_provider.add(
         child_rules=[
             ChildRule(TYPE_FIELD, "*"),
             ChildRule(TYPE_OBJECT, "*"),
+            # Capability requirements are declared beside the entities they describe.
+            ChildRule(TYPE_REQUIREMENT, "*"),
             ChildRule(TYPE_TEMPLATE, "*"),
             ChildRule(TYPE_VALIDATOR, "*"),
         ],
@@ -545,6 +562,75 @@ for _idx_sub in INDEX_SUBTYPES:
         )
     )
 
+# requirement.* (functional, architectural) — the capability ledger IS a metadata
+# model (requirements-as-metadata ruling, amendment 3), so it is registered
+# vocabulary rather than a hand-parsed side file: @status is an allowedValues enum
+# the LOADER refuses a typo on. The axis is CHECK POLARITY, a genuine behaviour
+# difference (ADR-0037 §2): `functional` is checked by EXISTENCE (nothing
+# implements it -> fail), `architectural` by UNIVERSALITY (something violates it
+# -> fail). Architectural carries no @level and no @verifiedBy — levels come from
+# object-in-focus decomposition and an architectural requirement is
+# object-independent by definition.
+#
+# Hierarchy is NESTING, not a parent attr: requirement.functional admits nested
+# requirement children (the strict graph in spec/metamodel/requirement.json, which
+# _apply_strict_structural_children re-derives onto this registration).
+#
+# @implementedBy is deliberately NOT declared as a loader `references` descriptor.
+# That pass always ERRORS on an unresolved target, and a requirement with status
+# `abandoned`/`superseded` exists precisely to name nodes that are GONE — declaring
+# it here would make those entries fail to load. The loader owns what is
+# unconditional; `verify` owns @implementedBy resolution, whose severity depends on
+# @status.
+_REQUIREMENT_COMMON_ATTRS = [
+    AttrSchema(
+        name=REQUIREMENT_ATTR_STATUS,
+        value_type=ATTR_SUBTYPE_STRING,
+        required=True,
+        allowed_values=REQUIREMENT_STATUSES,
+    ),
+    AttrSchema(name=REQUIREMENT_ATTR_STATEMENT, value_type=ATTR_SUBTYPE_STRING, required=True),
+    AttrSchema(name=REQUIREMENT_ATTR_VIOLATION, value_type=ATTR_SUBTYPE_STRING, required=True),
+    AttrSchema(
+        name=REQUIREMENT_ATTR_IMPLEMENTED_BY,
+        value_type=ATTR_SUBTYPE_STRING,
+        required=False,
+        is_array=True,
+    ),
+    AttrSchema(name=REQUIREMENT_ATTR_SUPERSEDED_BY, value_type=ATTR_SUBTYPE_STRING, required=False),
+]
+core_provider.add(
+    TypeDefinition(
+        type=TYPE_REQUIREMENT,
+        sub_type=REQUIREMENT_SUBTYPE_FUNCTIONAL,
+        factory=MetaRequirement,
+        attrs=[
+            AttrSchema(name=REQUIREMENT_ATTR_LEVEL, value_type=ATTR_SUBTYPE_INT, required=True),
+            *_REQUIREMENT_COMMON_ATTRS,
+            AttrSchema(
+                name=REQUIREMENT_ATTR_VERIFIED_BY,
+                value_type=ATTR_SUBTYPE_STRING,
+                required=False,
+                is_array=True,
+            ),
+        ],
+        child_rules=[
+            ChildRule(TYPE_ATTR, "*"),
+            # Hierarchy IS nesting — an L1 solution contains its L2 segments.
+            ChildRule(TYPE_REQUIREMENT, "*"),
+        ],
+    )
+)
+core_provider.add(
+    TypeDefinition(
+        type=TYPE_REQUIREMENT,
+        sub_type=REQUIREMENT_SUBTYPE_ARCHITECTURAL,
+        factory=MetaRequirement,
+        attrs=list(_REQUIREMENT_COMMON_ATTRS),
+        child_rules=[ChildRule(TYPE_ATTR, "*")],
+    )
+)
+
 # relationship.* (base, association, aggregation, composition).
 # @onDelete / @onUpdate are validated against REFERENTIAL_ACTIONS — kebab-case
 # values (cascade / set-null / restrict / no-action). Defaults derive from the
@@ -825,26 +911,94 @@ for _sub, _attrs in _VALIDATOR_ATTRS_BY_SUBTYPE.items():
         )
     )
 
-# template.* (FR-004) — base + prompt + output + toolcall. FR-033 — core registers
-# the four template TYPES (a single MetaTemplate backs every subtype; validation in
-# validation_passes.py) but carries NO own per-subtype attrs. The full per-subtype
-# template attr vocabulary (@payloadRef / @textRef / @format / @maxChars / @kind /
-# @promptStyle / @toolName / @responseRef / …) is re-homed to the prompt domain
-# provider (`prompt_provider`, metaobjects-prompt) via TypeRegistry.extend
-# (prompt.json declares them on template.prompt / output / toolcall), matching the TS
-# core-types→promptProvider split (where the template type is also attr-free in core).
-for _tmpl_sub in (
-    SUBTYPE_BASE,
-    tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_SUBTYPE_PROMPT,
-    tc.TEMPLATE_SUBTYPE_TOOLCALL,
-):
+# template.* (FR-004) — base + prompt + output + toolcall. A single MetaTemplate
+# node class backs every subtype (validation lives in validation_passes.py); the
+# per-subtype attr vocabulary is registered HERE, WITH the type, in core — not in
+# the prompt domain provider (`prompt_provider`, metaobjects-prompt).
+#
+# Supersedes the prior FR-033 S2 homing, which put every template.* attr —
+# including the REQUIRED @payloadRef / @toolName — in prompt_provider. That made a
+# core type's validity depend on an OPTIONAL provider: compose coreProviders
+# without metaobjects-prompt and template.prompt stayed "registered" with zero
+# attrs, so the required-attr rule silently stopped firing (invalid metadata —
+# e.g. a template.prompt with no @payloadRef — loaded clean instead of erroring).
+#
+# THE RULE this corrects (ADR-0011 / FR-004): an attr the type is invalid or not
+# meaningfully itself without ("own") registers WITH the type, in a provider that
+# is always composed, never optional. An attr PROJECTING a different concern onto
+# a type that is complete without it ("projected") registers in the concern
+# provider and MUST stay optional — e.g. prompt.json's @xmlText/@example on every
+# field, @enumAlias on field.enum, @normalize on object.value; see
+# prompt_provider.py. template.base carries no attrs of its own (matches Java and
+# the cross-port canonical); the concrete subtypes below add their reference +
+# governance attrs exactly per spec/metamodel/template.json's "types" blocks.
+_TEMPLATE_GOVERNANCE_ATTRS = [
+    AttrSchema(name=tc.TEMPLATE_ATTR_OWNER, value_type=ATTR_SUBTYPE_STRING),
+    AttrSchema(name=tc.TEMPLATE_ATTR_SINCE, value_type=ATTR_SUBTYPE_STRING),
+]
+_TEMPLATE_ATTRS_BY_SUBTYPE: dict[str, list[AttrSchema]] = {
+    SUBTYPE_BASE: [],
+    tc.TEMPLATE_SUBTYPE_PROMPT: [
+        AttrSchema(name=tc.TEMPLATE_ATTR_PAYLOAD_REF, value_type=ATTR_SUBTYPE_STRING, required=True),
+        AttrSchema(name=tc.TEMPLATE_ATTR_TEXT_REF, value_type=ATTR_SUBTYPE_STRING),
+        AttrSchema(
+            name=tc.TEMPLATE_ATTR_FORMAT,
+            value_type=ATTR_SUBTYPE_STRING,
+            default=tc.TEMPLATE_FORMAT_DEFAULT,
+            allowed_values=tc.ALLOWED_FORMATS,
+        ),
+        AttrSchema(name=tc.TEMPLATE_ATTR_MAX_CHARS, value_type=ATTR_SUBTYPE_INT),
+        *_TEMPLATE_GOVERNANCE_ATTRS,
+        AttrSchema(name=tc.TEMPLATE_ATTR_REQUIRED_TAGS, value_type=ATTR_SUBTYPE_STRING, is_array=True),
+        AttrSchema(name=tc.TEMPLATE_ATTR_MAX_TOKENS, value_type=ATTR_SUBTYPE_INT),
+        AttrSchema(name=tc.TEMPLATE_ATTR_REQUIRED_SLOTS, value_type=ATTR_SUBTYPE_STRING, is_array=True),
+        AttrSchema(name=tc.TEMPLATE_ATTR_MODEL, value_type=ATTR_SUBTYPE_STRING),
+        AttrSchema(name=tc.TEMPLATE_ATTR_RESPONSE_REF, value_type=ATTR_SUBTYPE_STRING),
+    ],
+    tc.TEMPLATE_SUBTYPE_OUTPUT: [
+        AttrSchema(name=tc.TEMPLATE_ATTR_PAYLOAD_REF, value_type=ATTR_SUBTYPE_STRING, required=True),
+        AttrSchema(name=tc.TEMPLATE_ATTR_TEXT_REF, value_type=ATTR_SUBTYPE_STRING),
+        AttrSchema(
+            name=tc.TEMPLATE_ATTR_FORMAT,
+            value_type=ATTR_SUBTYPE_STRING,
+            default=tc.TEMPLATE_FORMAT_DEFAULT,
+            allowed_values=tc.ALLOWED_FORMATS,
+        ),
+        AttrSchema(name=tc.TEMPLATE_ATTR_MAX_CHARS, value_type=ATTR_SUBTYPE_INT),
+        *_TEMPLATE_GOVERNANCE_ATTRS,
+        AttrSchema(name=tc.TEMPLATE_ATTR_REQUIRED_TAGS, value_type=ATTR_SUBTYPE_STRING, is_array=True),
+        AttrSchema(
+            name=tc.TEMPLATE_ATTR_PROMPT_STYLE,
+            value_type=ATTR_SUBTYPE_STRING,
+            default=tc.PROMPT_STYLE_DEFAULT,
+            allowed_values=tc.PROMPT_STYLES,
+        ),
+        AttrSchema(
+            name=tc.TEMPLATE_ATTR_KIND,
+            value_type=ATTR_SUBTYPE_STRING,
+            default=tc.TEMPLATE_KIND_DEFAULT,
+            allowed_values=tc.ALLOWED_KINDS,
+        ),
+        AttrSchema(name=tc.TEMPLATE_ATTR_SUBJECT_REF, value_type=ATTR_SUBTYPE_STRING),
+        AttrSchema(name=tc.TEMPLATE_ATTR_HTML_BODY_REF, value_type=ATTR_SUBTYPE_STRING),
+        AttrSchema(name=tc.TEMPLATE_ATTR_TEXT_BODY_REF, value_type=ATTR_SUBTYPE_STRING),
+    ],
+    tc.TEMPLATE_SUBTYPE_TOOLCALL: [
+        # Does NOT inherit the generic prompt/output reference attrs — its own
+        # minimal set (ADR-0011): no renderable text body, so no @textRef/@format.
+        AttrSchema(name=tc.TEMPLATE_ATTR_TOOL_NAME, value_type=ATTR_SUBTYPE_STRING, required=True),
+        AttrSchema(name=tc.TEMPLATE_ATTR_PAYLOAD_REF, value_type=ATTR_SUBTYPE_STRING, required=True),
+        *_TEMPLATE_GOVERNANCE_ATTRS,
+        AttrSchema(name=tc.TEMPLATE_ATTR_MAX_TOKENS, value_type=ATTR_SUBTYPE_INT),
+    ],
+}
+for _tmpl_sub, _tmpl_attrs in _TEMPLATE_ATTRS_BY_SUBTYPE.items():
     core_provider.add(
         TypeDefinition(
             type=TYPE_TEMPLATE,
             sub_type=_tmpl_sub,
             factory=MetaTemplate,
-            attrs=[],
+            attrs=list(_tmpl_attrs),
             child_rules=[ChildRule(TYPE_ATTR, "*")],
         )
     )
@@ -859,8 +1013,11 @@ for _tmpl_sub in (
 # domain (`prompt_provider`) and UI / query-surface domain (`ui_provider`) then
 # EXTEND the core types via TypeRegistry.extend, and the documentation provider adds
 # the common doc attrs. FR-033 re-homed the field's filter/sort/teaching/extract +
-# view/layout + template attrs out of core into ui/prompt; the composed set is
-# unchanged. Spread to add more: `[*core_providers, my_provider]`.
+# view/layout attrs out of core into ui/prompt (all OPTIONAL vocabulary on types
+# that stay complete without them); template.* attrs are OWN and stay registered
+# with the type in core (see the template.* block above) — dropping a concern
+# provider must never invalidate a type another provider registers. The composed
+# set is unchanged. Spread to add more: `[*core_providers, my_provider]`.
 # ---------------------------------------------------------------------------
 from .meta.persistence.db.db_provider import db_provider  # noqa: E402
 from .meta.template.prompt_provider import prompt_provider  # noqa: E402

{metaobjects-0.21.6 → metaobjects-0.22.0}/src/metaobjects/errors.py

@@ -41,6 +41,14 @@ class ErrorCode(str, Enum):
     ERR_PROVIDER_DUPLICATE_ID = "ERR_PROVIDER_DUPLICATE_ID"
     ERR_PROVIDER_MISSING_DEPENDENCY = "ERR_PROVIDER_MISSING_DEPENDENCY"
     ERR_PROVIDER_ATTR_CONFLICT = "ERR_PROVIDER_ATTR_CONFLICT"
+    # ADR-0050: a provider tried to PROJECT a REQUIRED attribute onto a type it does
+    # not own (via TypeRegistry.extend). Projection is optional-only — a required
+    # attr registered this way disappears silently whenever that provider is
+    # composed out, taking its required-attr validation rule with it. This is
+    # exactly how FR-033 broke template.*'s @payloadRef/@toolName in all five
+    # ports. If an attr is genuinely required it is OWN: declare it with the type,
+    # in the type's own provider.
+    ERR_EXTEND_REQUIRED_ATTR = "ERR_EXTEND_REQUIRED_ATTR"
     ERR_SUBTYPE_RULE_VIOLATION = "ERR_SUBTYPE_RULE_VIOLATION"
     ERR_OVERLAY_NO_TARGET = "ERR_OVERLAY_NO_TARGET"
     # FR5c — two contributing files set the same @attr to different non-empty

metaobjects-0.22.0/src/metaobjects/meta/core/requirement/meta_requirement.py

@@ -0,0 +1,71 @@
+"""MetaRequirement — concrete node class for type=requirement nodes.
+
+Extends MetaData directly: no model wrapper, no indirection. Accessors are
+RESOLVING (ADR-0039) so a requirement that ``extends`` an abstract parent
+inherits its properties — note the Python naming inversion: ``attr()`` is
+OWN-ONLY here, so every read below goes through ``get_meta_attr()``.
+"""
+from __future__ import annotations
+
+from ...meta_data import MetaData
+from .requirement_constants import (
+    REQUIREMENT_ATTR_IMPLEMENTED_BY,
+    REQUIREMENT_ATTR_LEVEL,
+    REQUIREMENT_ATTR_STATUS,
+    REQUIREMENT_ATTR_VERIFIED_BY,
+    REQUIREMENT_LINK_FLOOR_LEVEL,
+    REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES,
+    REQUIREMENT_SUBTYPE_ARCHITECTURAL,
+    REQUIREMENT_SUBTYPE_FUNCTIONAL,
+)
+
+
+class MetaRequirement(MetaData):
+    def is_functional(self) -> bool:
+        """What the product does for a user — checked by EXISTENCE."""
+        return self.sub_type == REQUIREMENT_SUBTYPE_FUNCTIONAL
+
+    def is_architectural(self) -> bool:
+        """How the system is built — checked by UNIVERSALITY (the opposite polarity)."""
+        return self.sub_type == REQUIREMENT_SUBTYPE_ARCHITECTURAL
+
+    def level(self) -> int | None:
+        """ADR-0039: resolving. 1 solution · 2 segment · 3 service · 4 object ·
+        5 member. Architectural requirements carry none — they are
+        object-independent by definition."""
+        v = self.get_meta_attr(REQUIREMENT_ATTR_LEVEL)
+        return v if isinstance(v, int) and not isinstance(v, bool) else None
+
+    def status(self) -> str | None:
+        """ADR-0039: resolving. One of REQUIREMENT_STATUSES (a closed enum the
+        registry enforces via allowed_values)."""
+        v = self.get_meta_attr(REQUIREMENT_ATTR_STATUS)
+        return v if isinstance(v, str) else None
+
+    def implemented_by(self) -> list[str]:
+        """ADR-0039: resolving. FQN references to the model nodes realising this
+        requirement (many-to-many by construction)."""
+        v = self.get_meta_attr(REQUIREMENT_ATTR_IMPLEMENTED_BY)
+        return [str(x) for x in v] if isinstance(v, list) else []
+
+    def verified_by(self) -> list[str]:
+        """ADR-0039: resolving. Names of the tests proving the behaviour."""
+        v = self.get_meta_attr(REQUIREMENT_ATTR_VERIFIED_BY)
+        return [str(x) for x in v] if isinstance(v, list) else []
+
+    def may_reference_model(self) -> bool:
+        """True when this requirement is permitted to reference the model at all.
+        Architectural requirements always may (their claim set is the point);
+        functional ones only at or below the link floor, so the organisational
+        tiers stay organisational."""
+        if self.is_architectural():
+            return True
+        lvl = self.level()
+        return lvl is not None and lvl >= REQUIREMENT_LINK_FLOOR_LEVEL
+
+    def requires_live_nodes(self) -> bool:
+        """True when a dangling ``@implementedBy`` is an ERROR rather than
+        expected. An abandoned or superseded requirement's nodes are supposed to
+        be gone."""
+        s = self.status()
+        return s is not None and s in REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES

metaobjects-0.22.0/src/metaobjects/meta/core/requirement/requirement_constants.py

@@ -0,0 +1,72 @@
+"""Requirement subtype + attr vocabulary.
+
+``requirement.*`` is REGISTERED metamodel vocabulary (requirements-as-metadata
+ruling, amendment 3): the capability ledger IS a metadata model, so it is
+declared in ``metaobjects/`` beside the entities it describes and validated by
+the loader like everything else — never hand-parsed from a side file.
+"""
+
+# ---------------------------------------------------------------------------
+# Subtypes — the axis is the CHECK POLARITY, a genuine behaviour difference and
+# therefore a subtype under ADR-0037 §2:
+#   functional    -> EXISTENCE:    fails when nothing implements it
+#   architectural -> UNIVERSALITY: fails when something violates it
+# ---------------------------------------------------------------------------
+REQUIREMENT_SUBTYPE_FUNCTIONAL = "functional"
+REQUIREMENT_SUBTYPE_ARCHITECTURAL = "architectural"
+
+REQUIREMENT_SUBTYPES = (
+    REQUIREMENT_SUBTYPE_FUNCTIONAL,
+    REQUIREMENT_SUBTYPE_ARCHITECTURAL,
+)
+
+# ---------------------------------------------------------------------------
+# Attrs
+# ---------------------------------------------------------------------------
+#: 1 solution · 2 segment (app/library) · 3 service · 4 object · 5 member.
+REQUIREMENT_ATTR_LEVEL = "level"
+REQUIREMENT_ATTR_STATUS = "status"
+REQUIREMENT_ATTR_STATEMENT = "statement"
+REQUIREMENT_ATTR_VIOLATION = "violation"
+REQUIREMENT_ATTR_IMPLEMENTED_BY = "implementedBy"
+REQUIREMENT_ATTR_VERIFIED_BY = "verifiedBy"
+REQUIREMENT_ATTR_SUPERSEDED_BY = "supersededBy"
+
+# ---------------------------------------------------------------------------
+# Status — a closed enum, enforced by the registry via allowed_values.
+# ---------------------------------------------------------------------------
+REQUIREMENT_STATUS_LIVE = "live"
+REQUIREMENT_STATUS_PARTIAL = "partial"
+REQUIREMENT_STATUS_ABANDONED = "abandoned"
+REQUIREMENT_STATUS_SUPERSEDED = "superseded"
+
+REQUIREMENT_STATUSES = (
+    REQUIREMENT_STATUS_LIVE,
+    REQUIREMENT_STATUS_PARTIAL,
+    REQUIREMENT_STATUS_ABANDONED,
+    REQUIREMENT_STATUS_SUPERSEDED,
+)
+
+#: Statuses whose implementing nodes are supposed to still exist. A dangling
+#: ``@implementedBy`` on one of these means the model moved and the requirement
+#: is stale; on the other two the nodes are supposed to be GONE, which is the
+#: whole point of the entry. The asymmetry inverts as a pair.
+REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES = (
+    REQUIREMENT_STATUS_LIVE,
+    REQUIREMENT_STATUS_PARTIAL,
+)
+
+# ---------------------------------------------------------------------------
+# Levels — organisational above the link floor, model-referencing at or below.
+# ---------------------------------------------------------------------------
+REQUIREMENT_LEVEL_SOLUTION = 1
+REQUIREMENT_LEVEL_SEGMENT = 2
+REQUIREMENT_LEVEL_SERVICE = 3
+REQUIREMENT_LEVEL_OBJECT = 4
+REQUIREMENT_LEVEL_MEMBER = 5
+
+#: The lowest level that may reference the model. L1-L3 are organisational and
+#: carrying ``@implementedBy`` there is an error.
+REQUIREMENT_LINK_FLOOR_LEVEL = REQUIREMENT_LEVEL_OBJECT
+REQUIREMENT_MIN_LEVEL = REQUIREMENT_LEVEL_SOLUTION
+REQUIREMENT_MAX_LEVEL = REQUIREMENT_LEVEL_MEMBER

{metaobjects-0.21.6 → metaobjects-0.22.0}/src/metaobjects/meta/template/prompt_provider.py

@@ -2,23 +2,33 @@
 (cross-port ``metaobjects-prompt``; FR-004 / FR-006 / FR-010 / FR-011).
 
 EXTENDS the core-registered types with the prompt / AI-domain markers that are
-NOT core properties:
+NOT core properties — every one of them PROJECTED and OPTIONAL, onto a type that
+stays complete without it:
   - every field subtype: ``@xmlText`` (XML text-content extract), ``@example``,
     ``@instruction`` (FR-010 field-teaching prompt fragment);
   - ``field.enum`` only: ``@enumAlias`` / ``@enumDoc`` / ``@coerceDefault`` /
     ``@normalize`` (FR-010 / FR-011 tolerant-extract overlays);
   - ``object.value`` only: ``@normalize`` (the object-level default normalization
-    mode for its enum fields' tolerant extract);
-  - ``template.prompt`` / ``template.output`` / ``template.toolcall``: the full
-    per-subtype template attr vocabulary (``@payloadRef`` / ``@textRef`` /
-    ``@format`` / ``@maxChars`` / ``@kind`` / ``@promptStyle`` / ``@toolName`` / …).
-
-These were previously registered in ``core_types`` (the field / object / template
-attrs) and ``template_provider`` (``@xmlText``); FR-033 re-homes them all here to
-match the TS provider split (``promptProvider`` renamed from ``templateProvider``),
-the C# ``PromptMetaDataProvider``, and Java's prompt concern provider. The attrs +
-their value-types / required-ness / allowed-values / defaults are DATA — read from
-the embedded ``spec/metamodel/prompt.json`` (single-sourced, never hand-copied) via
+    mode for its enum fields' tolerant extract).
+
+The ``template.prompt`` / ``template.output`` / ``template.toolcall`` attr
+vocabulary (``@payloadRef`` / ``@textRef`` / ``@format`` / ``@toolName`` / …) does
+**NOT** live here. FR-033 originally re-homed it to this provider, including the
+REQUIRED ``@payloadRef`` / ``@toolName`` — that made a core type's validity depend
+on an optional provider: compose ``core_providers`` without ``metaobjects-prompt``
+and ``template.prompt`` stayed "registered" with zero attrs, so the required-attr
+rule silently stopped firing. Those attrs are OWN (the type is invalid without
+them) and now register WITH the type in ``core_types.py``, always — see the
+``template.*`` block there. Only genuinely OPTIONAL projections belong in a
+concern provider; this module's remaining attrs (above) all satisfy that.
+
+``@xmlText`` was previously registered in ``template_provider``; the rest of this
+module's attrs were previously registered in ``core_types`` (the field / object
+attrs). FR-033 re-homed them here to match the TS provider split (``promptProvider``
+renamed from ``templateProvider``), the C# ``PromptMetaDataProvider``, and Java's
+prompt concern provider. The attrs + their value-types / required-ness /
+allowed-values / defaults are DATA — read from the embedded
+``spec/metamodel/prompt.json`` (single-sourced, never hand-copied) via
 :func:`load_provider_extends`. The composed registry is UNCHANGED (the manifest is
 provider-agnostic) — this only moves WHICH provider registers each attr.
 
@@ -35,11 +45,12 @@ from ...shared.base_types import TYPE_FIELD
 from ..core.field import field_constants as fc
 
 # The prompt.json ``extends`` directives apply to ``field.*`` (every field subtype),
-# ``field.enum``, ``object.value`` and the three concrete ``template.*`` subtypes.
-# register_extends() expands the ``"*"`` field subtype to every concrete field
-# subtype (the shared FIELD_SUBTYPES tuple — which excludes ``enum`` — PLUS
-# ``field.enum``), mirroring db_provider / the prior template_provider, so the
-# field-teaching + serialization markers reach every field including enum.
+# ``field.enum`` and ``object.value`` — the template.* attrs are OWN (registered in
+# core_types.py, not here; see this module's docstring). register_extends()
+# expands the ``"*"`` field subtype to every concrete field subtype (the shared
+# FIELD_SUBTYPES tuple — which excludes ``enum`` — PLUS ``field.enum``), mirroring
+# db_provider, so the field-teaching + serialization markers reach every field
+# including enum.
 _FIELD_SUBTYPES: tuple[str, ...] = (*fc.FIELD_SUBTYPES, fc.FIELD_SUBTYPE_ENUM)
 
 #: The embedded shared provider-definition file this provider sources its attrs from.

{metaobjects-0.21.6 → metaobjects-0.22.0}/src/metaobjects/registry.py

@@ -216,6 +216,20 @@ class TypeRegistry:
         """
         self._check_not_sealed("register_common_attrs")
         for attr in attrs:
+            # ADR-0050, the second door. A common attr is projected onto EVERY registered
+            # type, so a required one is the same defect as a required extend() -- with the
+            # widest possible blast radius: drop the provider and every type silently loses
+            # a required-attr rule. Java is immune by construction (its
+            # registerCommonAttribute takes no required parameter); AttrSchema carries
+            # `required`, so this port needs the explicit guard.
+            if attr.required:
+                raise ParseError(
+                    f'TypeRegistry.register_common_attrs: attribute "{attr.name}" is '
+                    "REQUIRED. A common attr is projected onto every registered type, so a "
+                    "required one would vanish from all of them whenever its provider is "
+                    "composed out. Common attrs must be optional (ADR-0050).",
+                    ErrorCode.ERR_EXTEND_REQUIRED_ATTR,
+                )
             if any(existing.name == attr.name for existing in self._common_attrs):
                 continue  # first registration wins
             self._common_attrs.append(attr)
@@ -261,6 +275,17 @@ class TypeRegistry:
         :raises ParseError: ``ERR_PROVIDER_ATTR_CONFLICT`` if an attribute
             name already exists on the type (own-only check — common-attr
             collisions are still surfaced separately at validation time).
+        :raises ParseError: ``ERR_EXTEND_REQUIRED_ATTR`` if an attribute being
+            added is ``required`` (ADR-0050). ``extend`` is how a concern
+            provider PROJECTS an attr onto a type it does not own, and a
+            concern can be composed out of a registry composition. A required
+            attr arriving this way makes the target type's validity depend on
+            an optional provider — the failure is silent: drop the provider
+            and the type stays registered while its required-attr rule stops
+            firing, so invalid metadata begins loading clean. A genuinely
+            required attr is OWN and belongs with its type, in the type's own
+            provider — never via ``extend``. Fails CLOSED: the offending attr
+            is not appended before the raise.
 
         Note: providers calling ``extend`` MUST declare a dependency on the
         provider that originally registered the ``(type_, sub_type)`` so
@@ -289,6 +314,23 @@ class TypeRegistry:
                     f'on "{type_}.{sub_type}"',
                     ErrorCode.ERR_PROVIDER_ATTR_CONFLICT,
                 )
+            # ADR-0050: a REQUIRED attr may never be PROJECTED onto someone else's
+            # type. A provider may only project OPTIONAL attributes onto a type it
+            # does not own — a required attr registered this way disappears,
+            # silently, whenever that provider is composed out. If the attr is
+            # genuinely required, it is OWN: declare it with the type instead, in
+            # the type's own provider. Checked (and raised) before the attr is
+            # appended, so the offending attr is never half-applied.
+            if attr.required:
+                raise ParseError(
+                    f'TypeRegistry.extend: attribute "{attr.name}" being added to '
+                    f'"{type_}.{sub_type}" is REQUIRED. A provider may only project '
+                    f"OPTIONAL attributes onto a type it does not own — a required "
+                    f"attr registered this way disappears, silently, whenever that "
+                    f"provider is composed out. Declare it with the type instead "
+                    f"(ADR-0050).",
+                    ErrorCode.ERR_EXTEND_REQUIRED_ATTR,
+                )
             definition.attrs.append(attr)
             # #265 — stamp the extending provider as this attr's origin.
             self._attr_provenance[(type_, sub_type, attr.name)] = origin

{metaobjects-0.21.6 → metaobjects-0.22.0}/src/metaobjects/shared/base_types.py

@@ -12,6 +12,7 @@ TYPE_LAYOUT = "layout"
 TYPE_SOURCE = "source"
 TYPE_ORIGIN = "origin"
 TYPE_TEMPLATE = "template"
+TYPE_REQUIREMENT = "requirement"
 
 SUBTYPE_BASE = "base"
 SUBTYPE_ROOT = "root"

{metaobjects-0.21.6 → metaobjects-0.22.0}/src/metaobjects/spec_metamodel/__init__.py

@@ -52,6 +52,7 @@ SPEC_FILES: tuple[str, ...] = (
     "origin.json",
     "prompt.json",
     "relationship.json",
+    "requirement.json",
     "source.json",
     "template.json",
     "ui.json",