metaobjects 0.9.0__py3-none-any.whl

metaobjects/meta/__init__.py

@@ -0,0 +1 @@
+"""metaobjects.meta — node base and per-concern node modules."""

metaobjects/meta/core/attr/attr_constants.py

@@ -0,0 +1,31 @@
+"""Attribute subtype vocabulary (colocated with the attr node — ADR-0003)."""
+from ....shared.base_types import SUBTYPE_BASE  # noqa: F401 (re-export convenience)
+
+ATTR_SUBTYPE_STRING = "string"
+ATTR_SUBTYPE_INT = "int"
+ATTR_SUBTYPE_LONG = "long"
+ATTR_SUBTYPE_DOUBLE = "double"
+ATTR_SUBTYPE_BOOLEAN = "boolean"
+ATTR_SUBTYPE_FILTER = "filter"
+ATTR_SUBTYPE_PROPERTIES = "properties"
+ATTR_SUBTYPE_CLASS = "class"
+
+# The retired "stringarray" array attr subtype. It is NO LONGER a registered
+# (attr, sub_type) (not in ATTR_SUBTYPES) — array-ness is modeled as a "string"
+# attr with the orthogonal AttrSchema.is_array flag (matching Java's
+# StringAttribute + @isArray), so "stringarray" never appears in the registry
+# manifest. The constant survives only as the array-coercion class-map key
+# (bare-string → one-element list).
+ATTR_SUBTYPE_STRINGARRAY = "stringarray"
+
+ATTR_SUBTYPES = (
+    SUBTYPE_BASE,
+    ATTR_SUBTYPE_STRING,
+    ATTR_SUBTYPE_INT,
+    ATTR_SUBTYPE_LONG,
+    ATTR_SUBTYPE_DOUBLE,
+    ATTR_SUBTYPE_BOOLEAN,
+    ATTR_SUBTYPE_FILTER,
+    ATTR_SUBTYPE_PROPERTIES,
+    ATTR_SUBTYPE_CLASS,
+)

metaobjects/meta/core/attr/meta_attr.py

@@ -0,0 +1,136 @@
+"""MetaAttr base + value-shaped subclasses. Value behavior lives here (ADR-0002)."""
+from __future__ import annotations
+
+from ....attr_class_map import register_attr_class, register_fallback_attr_class
+from ....datatype import DataType
+from ...meta_data import MetaData
+from ....shared.base_types import SUBTYPE_BASE
+from .attr_constants import (
+    ATTR_SUBTYPE_BOOLEAN,
+    ATTR_SUBTYPE_CLASS,
+    ATTR_SUBTYPE_DOUBLE,
+    ATTR_SUBTYPE_FILTER,
+    ATTR_SUBTYPE_INT,
+    ATTR_SUBTYPE_LONG,
+    ATTR_SUBTYPE_PROPERTIES,
+    ATTR_SUBTYPE_STRING,
+    ATTR_SUBTYPE_STRINGARRAY,
+)
+
+_SCALAR_DATA_TYPE = {
+    ATTR_SUBTYPE_STRING: DataType.STRING,
+    ATTR_SUBTYPE_INT: DataType.INT,
+    ATTR_SUBTYPE_LONG: DataType.LONG,
+    ATTR_SUBTYPE_DOUBLE: DataType.DOUBLE,
+    ATTR_SUBTYPE_BOOLEAN: DataType.BOOLEAN,
+}
+
+
+class MetaAttr(MetaData):
+    def __init__(self, type_: str, sub_type: str, name: str) -> None:
+        super().__init__(type_, sub_type, name)
+        self.value: object = None
+
+    @property
+    def data_type(self) -> DataType:
+        return _SCALAR_DATA_TYPE.get(self.sub_type, DataType.STRING)
+
+    def coerce(self, raw: object) -> object:
+        """Base coercion mirrors TS convertToDataType (data-converter.ts):
+        directional toward the declared DataType.
+
+        SUBTYPE_BASE is the polymorphic/unconstrained marker (an undeclared
+        @-attr or an attr.base child node): the value is preserved as-is and
+        never stringified. Only attrs whose owner declared `value_type=string`
+        (i.e. the registry mapped them to ATTR_SUBTYPE_STRING) are coerced.
+        This keeps cross-language parity with TS: YAML 1.2 scalar coercion is
+        reported once by the desugar's D2 guard (ERR_YAML_COERCION) and the
+        downstream attr-schema validator does NOT double-report the same
+        offence (since the stored value already matches the declared type).
+        """
+        if self.sub_type == SUBTYPE_BASE:
+            return raw  # polymorphic / unconstrained — type-preserve
+        if self.sub_type == ATTR_SUBTYPE_STRING:
+            if raw is None or isinstance(raw, str):
+                return raw
+            if isinstance(raw, bool):
+                # bool must NOT be Pythonically rendered as "True"/"False" —
+                # use the JSON lower-cased form for cross-language byte parity.
+                return "true" if raw else "false"
+            if isinstance(raw, (int, float)):
+                return str(raw)
+            return raw
+        return raw
+
+    def desugar(self, value: object) -> object:
+        return value
+
+    def set_value(self, raw: object) -> None:
+        self._require_mutable()
+        self.value = self.desugar(self.coerce(raw))
+
+
+class StringArrayAttr(MetaAttr):
+    @property
+    def data_type(self) -> DataType:
+        return DataType.STRING_ARRAY
+
+    def coerce(self, raw: object) -> object:
+        if isinstance(raw, list):
+            return [str(el) for el in raw]
+        if isinstance(raw, str):
+            return [raw]  # degenerate scalar form -> single-element list
+        return raw
+
+
+_FILTER_OPS = frozenset({"eq", "ne", "gt", "gte", "lt", "lte", "in", "like", "isNull"})
+
+
+def _is_op_object(value: object) -> bool:
+    """Return True if value is already a filter op-object (all keys are filter ops)."""
+    return (
+        isinstance(value, dict)
+        and len(value) > 0
+        and all(k in _FILTER_OPS for k in value)
+    )
+
+
+def _desugar_filter_value(value: object) -> object:
+    """Desugar a single field-level filter shorthand into an op-object."""
+    if value is None:
+        return {"isNull": True}
+    if isinstance(value, list):
+        return {"in": value}
+    if _is_op_object(value):
+        return value  # already an op-object — pass through unchanged
+    return {"eq": value}
+
+
+class FilterAttr(MetaAttr):
+    @property
+    def data_type(self) -> DataType:
+        return DataType.OBJECT
+
+    def desugar(self, value: object) -> object:
+        if not isinstance(value, dict):
+            return value
+        return {field: _desugar_filter_value(v) for field, v in value.items()}
+
+
+class PropertiesAttr(MetaAttr):
+    @property
+    def data_type(self) -> DataType:
+        return DataType.OBJECT
+
+
+class ClassAttr(MetaAttr):
+    @property
+    def data_type(self) -> DataType:
+        return DataType.STRING
+
+
+register_fallback_attr_class(MetaAttr)
+register_attr_class(ATTR_SUBTYPE_STRINGARRAY, StringArrayAttr)
+register_attr_class(ATTR_SUBTYPE_FILTER, FilterAttr)
+register_attr_class(ATTR_SUBTYPE_PROPERTIES, PropertiesAttr)
+register_attr_class(ATTR_SUBTYPE_CLASS, ClassAttr)

metaobjects/meta/core/field/field_constants.py

@@ -0,0 +1,105 @@
+"""Field subtype vocabulary (colocated)."""
+from ....shared.base_types import SUBTYPE_BASE
+
+FIELD_SUBTYPE_STRING = "string"
+FIELD_SUBTYPE_INT = "int"
+FIELD_SUBTYPE_LONG = "long"
+FIELD_SUBTYPE_DOUBLE = "double"
+FIELD_SUBTYPE_FLOAT = "float"
+FIELD_SUBTYPE_BOOLEAN = "boolean"
+FIELD_SUBTYPE_DATE = "date"
+FIELD_SUBTYPE_TIMESTAMP = "timestamp"
+FIELD_SUBTYPE_TIME = "time"
+FIELD_SUBTYPE_DECIMAL = "decimal"
+FIELD_SUBTYPE_OBJECT = "object"
+FIELD_SUBTYPE_CURRENCY = "currency"
+FIELD_SUBTYPE_ENUM = "enum"
+# R6 Plan 2a — field.uuid is a logical identity scalar (ADR-0013). String-backed
+# on the wire (lowercase-canonical UUID string); the idiomatic native binding
+# (Python uuid.UUID) is a build-time codegen concern. A bare scalar like
+# field.long: no required attrs, no loader value-validation.
+FIELD_SUBTYPE_UUID = "uuid"
+
+FIELD_SUBTYPES = (
+    SUBTYPE_BASE,
+    FIELD_SUBTYPE_STRING,
+    FIELD_SUBTYPE_INT,
+    FIELD_SUBTYPE_LONG,
+    FIELD_SUBTYPE_DOUBLE,
+    FIELD_SUBTYPE_FLOAT,
+    FIELD_SUBTYPE_BOOLEAN,
+    FIELD_SUBTYPE_DATE,
+    FIELD_SUBTYPE_TIMESTAMP,
+    FIELD_SUBTYPE_TIME,
+    FIELD_SUBTYPE_DECIMAL,
+    FIELD_SUBTYPE_OBJECT,
+    FIELD_SUBTYPE_CURRENCY,
+    FIELD_SUBTYPE_UUID,
+    # Note: FIELD_SUBTYPE_ENUM is intentionally excluded here; it is registered
+    # separately in core_types.py with its dedicated @values AttrSchema.
+)
+
+# Reserved field attribute names (read by codegen; open attrs at load time).
+# Mirrors server/typescript/packages/metadata/src/core/field/field-constants.ts.
+FIELD_ATTR_REQUIRED = "required"
+# @readOnly — boolean; the field is exposed read-only (omitted from create/update
+# input DTOs). On every field subtype. Mirrors TS FIELD_ATTR_READ_ONLY.
+FIELD_ATTR_READ_ONLY = "readOnly"
+FIELD_ATTR_UNIQUE = "unique"
+# @currency — ISO 4217 code on a field.currency. Storage is integer minor units;
+# defaults to "USD" when omitted. Only on field.currency. Mirrors TS FIELD_ATTR_CURRENCY.
+FIELD_ATTR_CURRENCY = "currency"
+FIELD_ATTR_DEFAULT = "default"
+FIELD_ATTR_MAX_LENGTH = "maxLength"
+FIELD_ATTR_PRECISION = "precision"
+FIELD_ATTR_SCALE = "scale"
+FIELD_ATTR_FILTERABLE = "filterable"
+FIELD_ATTR_SORTABLE = "sortable"
+FIELD_ATTR_SORTABLE_DEFAULT_ORDER = "sortableDefaultOrder"
+FIELD_ATTR_AUTO_SET = "autoSet"
+FIELD_ATTR_OBJECT_REF = "objectRef"
+FIELD_ATTR_VALUES = "values"
+# FR-010 field-teaching attrs (any field; drive the output-format prompt fragment).
+# Never carried in comments.
+FIELD_ATTR_EXAMPLE = "example"
+FIELD_ATTR_INSTRUCTION = "instruction"
+# FR-010 enum attrs (field.enum only). `properties`-shaped maps:
+#   @enumAlias: off-vocabulary token -> canonical member (feeds the extract alias-fold).
+#   @enumDoc:   member -> human-readable description (shown per-member in the 'guide' prompt).
+FIELD_ATTR_ENUM_ALIAS = "enumAlias"
+FIELD_ATTR_ENUM_DOC = "enumDoc"
+# FR-011 enum extract-hardening attrs (field.enum only).
+#   @coerceDefault: present-but-uncoercible extract fallback member → DEFAULTED.
+#       Member-validated against the effective @values (own or inherited).
+#   @normalize:     ASCII normalization mode applied during tolerant enum extract.
+#       Closed enum (none|collapse|strip, default strip). On field.enum (per-field)
+#       and object.value (object-level default for its enum fields). NOT on entity/base.
+# @default (FIELD_ATTR_DEFAULT, declared above) doubles as the enum absent-fill member.
+FIELD_ATTR_COERCE_DEFAULT = "coerceDefault"
+FIELD_ATTR_NORMALIZE = "normalize"
+# @normalize closed-enum modes (cross-port; ASCII-only normalization rule).
+NORMALIZE_NONE = "none"
+NORMALIZE_COLLAPSE = "collapse"
+NORMALIZE_STRIP = "strip"
+# Default @normalize mode when absent on both field and owning object.
+NORMALIZE_DEFAULT = NORMALIZE_STRIP
+NORMALIZE_MODES = (NORMALIZE_NONE, NORMALIZE_COLLAPSE, NORMALIZE_STRIP)
+# Persistence-side storage shape for owned field.object data. Cross-port values.
+FIELD_ATTR_STORAGE = "storage"
+STORAGE_VALUES = ("flattened", "jsonb", "subdocument")
+# Physical column name override (cross-port; renamed from @dbColumn).
+FIELD_ATTR_COLUMN = "column"
+
+# @autoSet allowed values (cross-port).
+AUTO_SET_ON_CREATE = "onCreate"
+AUTO_SET_ON_UPDATE = "onUpdate"
+AUTO_SET_VALUES = (AUTO_SET_ON_CREATE, AUTO_SET_ON_UPDATE)
+
+# @sortableDefaultOrder allowed values (cross-port).
+SORT_ORDER_ASC = "asc"
+SORT_ORDER_DESC = "desc"
+SORT_ORDER_VALUES = (SORT_ORDER_ASC, SORT_ORDER_DESC)
+
+# Regex pattern for enum member symbols — must be identifier-safe.
+# Cross-language contract: every port enforces this pattern.
+ENUM_MEMBER_PATTERN = r"^[A-Za-z_][A-Za-z0-9_]*$"

metaobjects/meta/core/field/meta_field.py

@@ -0,0 +1,76 @@
+"""MetaField — data_type resolves by subtype (ADR-0002)."""
+from __future__ import annotations
+
+from ....datatype import DataType
+from ...meta_data import MetaData
+from . import field_constants as fc
+
+_FIELD_DATA_TYPE = {
+    fc.FIELD_SUBTYPE_STRING: DataType.STRING,
+    fc.FIELD_SUBTYPE_INT: DataType.INT,
+    fc.FIELD_SUBTYPE_LONG: DataType.LONG,
+    fc.FIELD_SUBTYPE_DOUBLE: DataType.DOUBLE,
+    fc.FIELD_SUBTYPE_FLOAT: DataType.DOUBLE,
+    fc.FIELD_SUBTYPE_BOOLEAN: DataType.BOOLEAN,
+    fc.FIELD_SUBTYPE_DATE: DataType.DATE,
+    fc.FIELD_SUBTYPE_TIMESTAMP: DataType.DATE,
+    fc.FIELD_SUBTYPE_TIME: DataType.DATE,
+    fc.FIELD_SUBTYPE_DECIMAL: DataType.DECIMAL,
+    fc.FIELD_SUBTYPE_OBJECT: DataType.OBJECT,
+    fc.FIELD_SUBTYPE_CURRENCY: DataType.LONG,
+    fc.FIELD_SUBTYPE_ENUM: DataType.STRING,
+    # R6 Plan 2a — field.uuid is string-backed on the wire; the native uuid.UUID
+    # binding is surfaced at codegen time (see codegen/type_map.py).
+    fc.FIELD_SUBTYPE_UUID: DataType.STRING,
+}
+
+
+class MetaField(MetaData):
+    @property
+    def data_type(self) -> DataType:
+        return _FIELD_DATA_TYPE.get(self.sub_type, DataType.STRING)
+
+    @property
+    def object_ref(self) -> str | None:
+        """The ``@objectRef`` target FQN for ``field.object`` fields, else None.
+
+        The value is the package-folded form (e.g. ``com::example::om::Address``)
+        — matching a target object's ``resolution_key()``.
+        """
+        v = self.attr(fc.FIELD_ATTR_OBJECT_REF)
+        return str(v) if v is not None else None
+
+    def get_value(self, obj: object, name: str | None = None) -> object:
+        """Read this field's value from a backing object.
+
+        Dispatches on backing kind: a dict-backed ``ValueObject`` reads through
+        its map; any other object reads the attribute via ``getattr``. *name*
+        defaults to this field's own ``name`` (override to read a differently
+        keyed slot). Arrays are plain Python lists; nested objects are whatever
+        the consumer stored (typically another ValueObject / native instance).
+        """
+        from ..object.value_object import ValueObject
+
+        key = name if name is not None else self.name
+        if isinstance(obj, ValueObject):
+            return obj.get(key)
+        return getattr(obj, key, None)
+
+    def set_value(
+        self, obj: object, value: object, name: str | None = None
+    ) -> None:
+        """Write *value* into a backing object under *name* (defaults to this
+        field's own ``name``).
+
+        ValueObject -> map set; any other object -> ``setattr`` typed property.
+        No coercion here. Nested objects / arrays are stored as-given (the
+        consumer recurses for nested OBJECT fields: resolve the child via
+        ``object_ref`` + ``new_instance`` and ``set_value`` it).
+        """
+        from ..object.value_object import ValueObject
+
+        key = name if name is not None else self.name
+        if isinstance(obj, ValueObject):
+            obj.set(key, value)
+            return
+        setattr(obj, key, value)

metaobjects/meta/core/identity/identity_constants.py

@@ -0,0 +1,19 @@
+"""Identity subtype + attr vocabulary (colocated)."""
+IDENTITY_SUBTYPE_PRIMARY = "primary"
+IDENTITY_SUBTYPE_SECONDARY = "secondary"
+IDENTITY_SUBTYPE_REFERENCE = "reference"
+IDENTITY_SUBTYPES = (IDENTITY_SUBTYPE_PRIMARY, IDENTITY_SUBTYPE_SECONDARY, IDENTITY_SUBTYPE_REFERENCE)
+
+IDENTITY_ATTR_FIELDS = "fields"
+IDENTITY_ATTR_GENERATION = "generation"
+IDENTITY_ATTR_UNIQUE = "unique"
+
+# Allowed values for @generation on identity.primary
+GENERATION_INCREMENT = "increment"
+GENERATION_UUID = "uuid"
+GENERATION_ASSIGNED = "assigned"
+GENERATION_VALUES = (GENERATION_INCREMENT, GENERATION_UUID, GENERATION_ASSIGNED)
+
+# identity.reference attrs: target entity and enforcement flag
+IDENTITY_REFERENCE_ATTR_REFERENCES = "references"
+IDENTITY_REFERENCE_ATTR_ENFORCE = "enforce"

metaobjects/meta/core/identity/meta_identity.py

@@ -0,0 +1,8 @@
+"""MetaIdentity — primary/secondary."""
+from __future__ import annotations
+
+from ...meta_data import MetaData
+
+
+class MetaIdentity(MetaData):
+    pass

metaobjects/meta/core/object/meta_object.py

@@ -0,0 +1,65 @@
+"""MetaObject — typed accessors over children + runtime instantiation."""
+from __future__ import annotations
+
+from ...meta_data import MetaData
+from ..field.meta_field import MetaField
+from .object_class_registry import (
+    ObjectClassRegistry,
+    default_object_class_registry,
+)
+from .value_object import ValueObject
+
+
+class MetaObject(MetaData):
+    def fields(self) -> list[MetaField]:
+        """Effective fields: own + inherited via super chain (uses children())."""
+        return [c for c in self.children() if isinstance(c, MetaField)]
+
+    def own_fields(self) -> list[MetaField]:
+        """Own fields only — direct children, no inherited fields from super."""
+        return [c for c in self.own_children() if isinstance(c, MetaField)]
+
+    def find_field(self, name: str) -> MetaField | None:
+        """Find a field by name in effective fields (own + inherited)."""
+        return next((f for f in self.fields() if f.name == name), None)
+
+    def get_meta_field(self, name: str) -> MetaField | None:
+        """Alias for find_field — Java/TS parity (``getMetaField``)."""
+        return self.find_field(name)
+
+    def new_instance(self, registry: ObjectClassRegistry | None = None) -> object:
+        """Instantiate a backing object for this MetaObject (Java/TS parity:
+        ``newInstance``). Resolution order:
+
+          1. If ``registry.resolve(self.resolution_key())`` yields a factory,
+             call it; if the result is MetaObjectAware (has ``set_meta_data``),
+             attach this MetaObject as its back-reference.
+          2. Otherwise create a dict-backed ``ValueObject`` (the unbound default
+             for ``object.value``), which sets its own back-reference via the
+             constructor.
+
+        The registry key is this object's package-folded ``resolution_key()`` —
+        the SAME FQN form a nested field's ``@objectRef`` uses, so a factory
+        registered for an object's FQN is found whether instantiation is driven
+        top-down or via an object-ref. Reflection-free: only registered
+        factories are consulted.
+        """
+        reg = registry if registry is not None else default_object_class_registry
+        factory = reg.resolve(self.resolution_key())
+        if factory is not None:
+            instance = factory(self)
+            set_back_ref = getattr(instance, "set_meta_data", None)
+            if callable(set_back_ref):
+                set_back_ref(self)
+            return instance
+        return ValueObject(self)
+
+    def primary_identity(self) -> "MetaIdentity | None":  # type: ignore[name-defined]
+        """Primary identity node from effective children (own or inherited)."""
+        from ..identity.meta_identity import MetaIdentity
+        from ..identity.identity_constants import IDENTITY_SUBTYPE_PRIMARY
+        return next(
+            (c for c in self.children()
+             if isinstance(c, MetaIdentity) and c.sub_type == IDENTITY_SUBTYPE_PRIMARY),
+            None,
+        )

metaobjects/meta/core/object/meta_object_aware.py

@@ -0,0 +1,43 @@
+"""MetaObjectAware — the runtime back-reference contract.
+
+Idiomatic Python port of Java's ``MetaObjectAware`` / the TS
+``MetaObjectAware`` interface: a backing object that knows the ``MetaObject``
+describing it. The default backing type (``ValueObject``) implements this;
+generated / registered native types may implement it too so they carry a
+back-reference after ``MetaObject.new_instance()``.
+
+Reflection-free — no ``importlib``, no runtime type resolution. The protocol is
+structural (``typing.Protocol``), so a native type only needs the two methods;
+it does not have to inherit from anything.
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from .meta_object import MetaObject
+
+
+@runtime_checkable
+class MetaObjectAware(Protocol):
+    """A backing object carrying a reference to the MetaObject describing it."""
+
+    def get_meta_data(self) -> "MetaObject | None":
+        """The MetaObject describing this instance, or None if not yet attached."""
+        ...
+
+    def set_meta_data(self, mo: "MetaObject") -> None:
+        """Attach the MetaObject describing this instance (back-reference)."""
+        ...
+
+
+def is_meta_object_aware(obj: object) -> bool:
+    """Structural check — True when *obj* satisfies the MetaObjectAware contract.
+
+    Mirrors the TS ``isMetaObjectAware`` type guard. Uses duck-typing rather
+    than ``isinstance(obj, MetaObjectAware)`` so it stays robust even when a
+    native type defines the two methods without importing the protocol.
+    """
+    return callable(getattr(obj, "get_meta_data", None)) and callable(
+        getattr(obj, "set_meta_data", None)
+    )

metaobjects/meta/core/object/object_class_registry.py

@@ -0,0 +1,56 @@
+"""ObjectClassRegistry — resolution-key -> factory binding for instantiation.
+
+Idiomatic Python port of Java's ``ObjectClassRegistry`` / the TS
+``ObjectClassRegistry``: maps an object's package-folded FQN (its
+``MetaData.resolution_key()``, e.g. ``com::example::om::Person``) to a factory
+that produces a native backing instance. Generated code self-registers at
+import time (``registry.register(fqn, factory)``) — NO reflection (no
+``importlib`` / ``Class.forName`` / ``Type.GetType`` equivalent), AOT/tree-shake
+safe per ADR-0001.
+
+DISTINCT from the metadata ``TypeRegistry``, which maps metamodel type/subType
+names to MetaData node classes. THIS registry maps a DATA object's FQN to a
+runtime BACKING instance factory.
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:
+    from .meta_object import MetaObject
+
+#: Produces a native backing instance for the given MetaObject.
+ObjectFactory = Callable[["MetaObject"], object]
+
+
+class ObjectClassRegistry:
+    """Binds a resolution-key (``package::name``) to a backing-instance factory."""
+
+    def __init__(self) -> None:
+        self._factories: dict[str, ObjectFactory] = {}
+
+    def register(self, fqn: str, factory: ObjectFactory) -> None:
+        """Bind a resolution-key to a backing-instance factory."""
+        self._factories[fqn] = factory
+
+    def resolve(self, fqn: str) -> Optional[ObjectFactory]:
+        """Resolve the factory bound to a resolution-key, or None if unbound."""
+        return self._factories.get(fqn)
+
+    def has(self, fqn: str) -> bool:
+        """True if a factory is bound to the resolution-key."""
+        return fqn in self._factories
+
+    def unregister(self, fqn: str) -> bool:
+        """Remove a binding (test/scoping convenience); True if present."""
+        if fqn in self._factories:
+            del self._factories[fqn]
+            return True
+        return False
+
+
+#: The module-level default registry. Generated code self-registers here at
+#: import time; ``MetaObject.new_instance()`` consults it when no explicit
+#: registry is passed. Tests should construct their own
+#: ``ObjectClassRegistry()`` to avoid leaking bindings across cases (scenario 6).
+default_object_class_registry = ObjectClassRegistry()

metaobjects/meta/core/object/object_constants.py

@@ -0,0 +1,13 @@
+"""Object subtype vocabulary (colocated)."""
+from ....shared.base_types import SUBTYPE_BASE
+
+OBJECT_SUBTYPE_ENTITY = "entity"
+OBJECT_SUBTYPE_VALUE = "value"
+OBJECT_SUBTYPES = (SUBTYPE_BASE, OBJECT_SUBTYPE_ENTITY, OBJECT_SUBTYPE_VALUE)
+
+# FR-014 — TPH (Table-per-Hierarchy single-table inheritance) discriminator attrs.
+# On every object subtype (base/entity/value). Mirrors TS object-constants.ts.
+#   @discriminator      — on a base entity: the field holding the subtype value.
+#   @discriminatorValue — on a subtype: the value identifying its rows.
+OBJECT_ATTR_DISCRIMINATOR = "discriminator"
+OBJECT_ATTR_DISCRIMINATOR_VALUE = "discriminatorValue"