metaobjects 1.0.8rc1__tar.gz → 1.0.9__tar.gz

{metaobjects-1.0.8rc1 → metaobjects-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: metaobjects
-Version: 1.0.8rc1
+Version: 1.0.9
 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-1.0.8rc1 → metaobjects-1.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "1.0.8rc1"
+version = "1.0.9"
 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-1.0.8rc1 → metaobjects-1.0.9}/src/metaobjects/cli.py

@@ -57,7 +57,7 @@ from pathlib import Path
 from typing import Callable
 
 from metaobjects import MetaDataLoader
-from metaobjects.errors import ParseError
+from metaobjects.errors import ErrorCode, MetaError, ParseError
 from metaobjects.config.dependencies import (
     Collection,
     imported_from,
@@ -276,9 +276,14 @@ def _load_root(
     strict: bool = False,
     providers: list[object] | None = None,
     libraries: list[str] | None = None,
+    unknown_attr_out: list[str] | None = None,
 ) -> tuple[MetaData | None, list[str]]:
     """Load metadata; return ``(root, error_messages)``. ``root`` is None on error.
 
+    ``unknown_attr_out`` — when given on a LENIENT load, a second strict load of the
+    same metadata is run and its ``ERR_UNKNOWN_ATTR`` findings are appended, formatted,
+    so ``gen`` can warn about what ``verify`` would reject instead of staying silent.
+
     ``strict`` (ADR-0023, #96) — when True, an undeclared own ``@attr`` →
     ``ERR_UNKNOWN_ATTR``. Defaults False so ``gen`` / ``docs`` keep the legacy
     open-attr load; only ``verify`` opts in (strict-by-default with a ``--lax``
@@ -312,20 +317,24 @@ def _load_root(
         return None, [f"{exc.code}: {exc}"]
     all_libraries = _merge_libraries(neutral.libraries if neutral is not None else None, libraries)
 
-    try:
+    def load(strict_load: bool) -> LoadResult:
         if providers:
             from metaobjects.core_types import core_providers
 
-            result = MetaDataLoader.from_directory(
+            return MetaDataLoader.from_directory(
                 metadata_dir,
                 providers=[*core_providers, *providers],
-                strict=strict,
+                strict=strict_load,
                 libraries=all_libraries,
             )
-        else:
-            result = MetaDataLoader.from_directory(
-                metadata_dir, strict=strict, libraries=all_libraries
-            )
+        return MetaDataLoader.from_directory(
+            metadata_dir, strict=strict_load, libraries=all_libraries
+        )
+
+    try:
+        result = load(strict)
+        if unknown_attr_out is not None and not strict and not result.errors:
+            unknown_attr_out.extend(_unknown_attr_findings(load(True)))
     except OSError as e:
         # `DirectorySource.expand()` walks via `iterdir()` (not `rglob()`, so it
         # can follow a symlinked subdirectory — the I1 fix) and raises a plain
@@ -416,6 +425,7 @@ def _load_root_from_collection(
     strict: bool = False,
     providers: list[object] | None = None,
     libraries: list[str] | None = None,
+    unknown_attr_out: list[str] | None = None,
 ) -> tuple[MetaData | None, list[str]]:
     """Load a resolved `Collection` — the source-resolution ladder's
     ``.metaobjects/config.json`` rung (:func:`resolve_metadata_location`), which
@@ -432,9 +442,58 @@ def _load_root_from_collection(
     if result.errors:
         msgs = [f"{e.code}: {e.message}" for e in result.errors]
         return None, msgs
+    if unknown_attr_out is not None and not strict:
+        # See `_load_root`: what a strict load (`verify`) would reject, for `gen` to warn.
+        try:
+            strict_result = _load_collection_result(
+                collection, strict=True, providers=providers, libraries=libraries
+            )
+        except ParseError:
+            strict_result = None
+        if strict_result is not None:
+            unknown_attr_out.extend(_unknown_attr_findings(strict_result))
     return result.root, []
 
 
+#: Trailing advice after ``gen``'s unknown-attribute warnings. ``gen`` has no strict
+#: flag of its own; ``verify`` is the strict door (ADR-0023), so that is what it names.
+UNKNOWN_ATTR_GEN_ADVICE = (
+    "metaobjects gen loads leniently and generated anyway, but `metaobjects verify` "
+    "rejects this metadata (ADR-0023): fix or remove the attribute - a typo'd one "
+    "(`isAbstrakt`, `requird`) silently changes what is generated."
+)
+
+
+def _format_unknown_attr(err: MetaError) -> str:
+    """One ``gen`` warning: code + message (naming attribute and node), then the file."""
+    env = getattr(err, "envelope", None)
+    files = [f for f in (getattr(env, "files", None) or ()) if f]
+    json_path = getattr(env, "json_path", None)
+    where = " ".join(
+        p for p in (", ".join(files) if files else None, f"at {json_path}" if json_path else None) if p
+    )
+    head = f"{err.code.value if hasattr(err.code, 'value') else err.code}: {err.message}"
+    return f"{head}\n  in {where}" if where else head
+
+
+def _unknown_attr_findings(result: LoadResult) -> list[str]:
+    """The ERR_UNKNOWN_ATTR findings of a STRICT load, formatted for ``gen``."""
+    return [
+        _format_unknown_attr(e) for e in result.errors
+        if (e.code.value if hasattr(e.code, "value") else e.code) == ErrorCode.ERR_UNKNOWN_ATTR.value
+    ]
+
+
+def _print_unknown_attr_warnings(findings: list[str]) -> None:
+    """``gen`` loads leniently; an unknown attribute ``verify`` would reject is named here
+    as a warning (attribute, node, file). Advisory only: the exit code is unchanged."""
+    if not findings:
+        return
+    for f in findings:
+        print(f"warning: {f}", file=sys.stderr)
+    print(f"warning: {UNKNOWN_ATTR_GEN_ADVICE}", file=sys.stderr)
+
+
 def _strict_load_hint() -> str:
     """Actionable next-steps when strict verify rejects an undeclared @attr."""
     return (
@@ -1005,6 +1064,8 @@ def _cmd_list(_args: argparse.Namespace) -> int:
         status = owned.owned_status(root, entry)
         mark = f" [owned — {status}]" if status is not None else ""
         print(f"{entry.name} — {entry.description}{requires}{mark}")
+    for path, status in owned.runtime_status(root):
+        print(f"runtime {path.as_posix()} [owned — {status}]")
     return 0
 
 
@@ -1097,12 +1158,16 @@ def _cmd_gen(args: argparse.Namespace) -> int:
         return 1
     # Load the metadata ONCE; both the default suite and the (optional)
     # --template-spec pass run against this single loaded root.
-    root, load_errors = _load_root(args.metadata_dir, providers=providers)
+    unknown_attrs: list[str] = []
+    root, load_errors = _load_root(
+        args.metadata_dir, providers=providers, unknown_attr_out=unknown_attrs
+    )
     if root is None:
         print("error: failed to load metadata:", file=sys.stderr)
         for msg in load_errors:
             print(f"  {msg}", file=sys.stderr)
         return 1
+    _print_unknown_attr_warnings(unknown_attrs)
     gen_state = gen_state_dir_for(args.metadata_dir)
     # Same anchor the manifest itself uses. Both passes below key against it, so a
     # `--template-spec` artifact and a default-suite artifact land in one key space.
@@ -1366,14 +1431,17 @@ def _cmd_gen_config(args: argparse.Namespace) -> int:
     if collection is None:
         return 1
 
+    unknown_attrs: list[str] = []
     root, load_errors = _load_root_from_collection(
-        collection, providers=providers, libraries=config.libraries
+        collection, providers=providers, libraries=config.libraries,
+        unknown_attr_out=unknown_attrs,
     )
     if root is None:
         print("error: failed to load metadata:", file=sys.stderr)
         for msg in load_errors:
             print(f"  {msg}", file=sys.stderr)
         return 1
+    _print_unknown_attr_warnings(unknown_attrs)
 
     for t in targets:
         imported_refusal = _refuse_imported_entities(t.entities, root, collection)

{metaobjects-1.0.8rc1 → metaobjects-1.0.9}/src/metaobjects/codegen/eject.py

@@ -9,6 +9,14 @@ to wire instead.
 
 A copy imports the same ``metaobjects.codegen.*`` module paths the packaged generator
 does. Those module paths are the documented surface an owned generator builds on.
+
+What the copy's OUTPUT imports is a different question. A generator whose generated code
+imports helper runtime (``routes``: ``filter_parser``, ``constraint_errors``) lists it on
+its registry entry, and eject hands that over too: the runtime source lands in
+``codegen/runtime/`` and the copy's ``OWNED_RUNTIME`` switch is flipped, so the owned
+generator emits that source into the generated package and its output imports the local
+copy. Core modules (loader, registry, render, extract, ``ObjectManager``) stay package
+imports. An existing runtime copy is never overwritten, even with ``--force``.
 """
 from __future__ import annotations
 
@@ -30,6 +38,14 @@ from metaobjects.codegen.generator_registry import (
 #: Where an owned copy lands, relative to the project root. Mirrors the TS layout.
 OWNED_DIR = Path("codegen") / "generators"
 
+#: Where the helper runtime an owned generator's output depends on lands. A sibling of
+#: :data:`OWNED_DIR`, which is where the owned router reads it from.
+RUNTIME_DIR = Path("codegen") / "runtime"
+
+#: The switch an owned copy flips to emit and import its runtime locally.
+_RUNTIME_SWITCH_OFF = "OWNED_RUNTIME = False"
+_RUNTIME_SWITCH_ON = "OWNED_RUNTIME = True"
+
 
 def owned_stem(name: str) -> str:
     """The module name of an owned copy: the stable name with ``-`` as ``_``."""
@@ -52,6 +68,32 @@ def packaged_source(entry: GeneratorEntry) -> str:
     return Path(module.__file__).read_text(encoding="utf-8")
 
 
+def ejected_source(entry: GeneratorEntry) -> str:
+    """What ``eject`` writes for *entry*: the packaged source, with the runtime switch on
+    when its output imports helper runtime. This is the reference an owned copy is
+    compared against."""
+    source = packaged_source(entry)
+    if not entry.runtime:
+        return source
+    if source.count(_RUNTIME_SWITCH_OFF) != 1:
+        raise RuntimeError(
+            f"{entry.source_module} must carry exactly one {_RUNTIME_SWITCH_OFF!r} line "
+            "for eject to hand its runtime over"
+        )
+    return source.replace(_RUNTIME_SWITCH_OFF, _RUNTIME_SWITCH_ON)
+
+
+def packaged_runtime_path(module: str) -> Path:
+    """The installed source of helper runtime *module*."""
+    package = importlib.import_module("metaobjects.codegen.runtime")
+    assert package.__file__ is not None
+    return Path(package.__file__).parent / f"{module}.py"
+
+
+def runtime_path(root: Path, module: str) -> Path:
+    return root / RUNTIME_DIR / f"{module}.py"
+
+
 def ejectable() -> list[GeneratorEntry]:
     return [e for e in GENERATOR_REGISTRY.values() if e.source is not None]
 
@@ -88,9 +130,19 @@ def eject(names: list[str], root: Path, *, force: bool = False) -> EjectResult:
     for n in names:
         entry = known[n]
         target = owned_path(root, n)
-        target.write_text(packaged_source(entry), encoding="utf-8")
+        target.write_text(ejected_source(entry), encoding="utf-8")
         out.append(f"ejected {n} -> {target.relative_to(root)}")
         out.append(f"  wire it: replace \"{n}\" in `generators` with {owned_token(entry)}")
+        for module in entry.runtime:
+            rt = runtime_path(root, module)
+            rel = rt.relative_to(root)
+            if rt.exists():
+                out.append(f"  runtime {rel}: kept your copy (eject never overwrites runtime)")
+                continue
+            rt.parent.mkdir(parents=True, exist_ok=True)
+            rt.write_text(packaged_runtime_path(module).read_text(encoding="utf-8"),
+                          encoding="utf-8")
+            out.append(f"  runtime {rel}: copied — its generated output imports this copy")
     out.append("")
     out.append(
         "The copies are yours: edit them freely. Keep only one of the packaged name and your "
@@ -112,8 +164,12 @@ def owned_status(root: Path, entry: GeneratorEntry) -> str | None:
     path = owned_path(root, entry.name)
     if entry.source is None or not path.exists():
         return None
-    mine = _normalised(path.read_text(encoding="utf-8"))
-    ref = _normalised(packaged_source(entry))
+    return _compare(path.read_text(encoding="utf-8"), ejected_source(entry))
+
+
+def _compare(mine_text: str, ref_text: str) -> str:
+    mine = _normalised(mine_text)
+    ref = _normalised(ref_text)
     behind = sum((ref - mine).values())
     own = sum((mine - ref).values())
     if behind == 0 and own == 0:
@@ -121,6 +177,23 @@ def owned_status(root: Path, entry: GeneratorEntry) -> str | None:
     return f"DIFFERS: {behind} behind, {own} of your own"
 
 
+def runtime_status(root: Path) -> list[tuple[Path, str]]:
+    """``(relative path, status)`` for each owned runtime copy, against the installed one.
+
+    Same verdict shape as :func:`owned_status`, so ``--list`` can say when an upgrade
+    changed runtime you own."""
+    modules = sorted({m for e in ejectable() for m in e.runtime})
+    rows: list[tuple[Path, str]] = []
+    for module in modules:
+        path = runtime_path(root, module)
+        if path.exists():
+            rows.append((path.relative_to(root), _compare(
+                path.read_text(encoding="utf-8"),
+                packaged_runtime_path(module).read_text(encoding="utf-8"),
+            )))
+    return rows
+
+
 def build_owned(spec: str, root: Path, ctx: GeneratorBuildContext) -> tuple[Generator | None, str | None]:
     """Resolve a ``module:symbol`` generator entry against the project at *root*.
 

{metaobjects-1.0.8rc1 → metaobjects-1.0.9}/src/metaobjects/codegen/generator_registry.py

@@ -40,7 +40,10 @@ from metaobjects.codegen.generators.output_prompt_generator import (
 from metaobjects.codegen.generators.render_helper_generator import (
     render_helper_generator,
 )
-from metaobjects.codegen.generators.router_generator import router_generator
+from metaobjects.codegen.generators.router_generator import (
+    RUNTIME_MODULES as _ROUTER_RUNTIME,
+    router_generator,
+)
 from metaobjects.codegen.generators.template_generator import template_generator
 from metaobjects.codegen.generators.trace_helper_generator import trace_helper_generator
 from metaobjects.render.verify import InMemoryProvider
@@ -113,6 +116,13 @@ class GeneratorEntry:
     #: symbol the copy is wired by. ``None`` = not ejectable (the ``template`` primitive
     #: has no emit logic of its own to own).
     source: Callable[..., Generator] | None = None
+    #: Helper runtime modules (under ``metaobjects.codegen.runtime``) the generator's
+    #: OUTPUT imports. ``metaobjects eject`` copies their source into the adopter's
+    #: ``codegen/runtime/`` beside the owned generator, and the owned copy's output imports
+    #: that copy instead of the installed package (ADR-0034 Amendment 3: the adopter owns
+    #: every helper line its generated code depends on). Core modules — loader, registry,
+    #: render, extract, ``ObjectManager`` — are never listed here: they stay package imports.
+    runtime: tuple[str, ...] = ()
 
     @property
     def source_module(self) -> str | None:
@@ -186,10 +196,11 @@ GENERATOR_REGISTRY: dict[str, GeneratorEntry] = {
         # generated package fails at import (ModuleNotFoundError).
         requires=("entity", "filter-allowlist"),
         source=router_generator,
+        runtime=_ROUTER_RUNTIME,
     ),
     "output-parser": GeneratorEntry(
         name="output-parser",
-        description="Per-template tolerant output parser (recover-on-receipt).",
+        description="Per-template response parser: a strict parse that rejects a reply not matching the @responseRef shape, plus a tolerant, never-raising extract_lenient.",
         tier="native",
         layer="capability",
         factory=lambda _ctx: output_parser_generator(),
@@ -215,7 +226,7 @@ GENERATOR_REGISTRY: dict[str, GeneratorEntry] = {
     ),
     "extractor": GeneratorEntry(
         name="extractor",
-        description="Per-template strict typed extract<Name> helper (strict payload extraction).",
+        description="Per-template typed extract<Name> helper: tolerant recovery of the typed response from dirty model text; raises only when a @required field is lost.",
         tier="native",
         layer="capability",
         factory=lambda _ctx: extractor_generator(),

{metaobjects-1.0.8rc1 → metaobjects-1.0.9}/src/metaobjects/codegen/generators/extractor_generator.py

@@ -9,7 +9,7 @@ arrays-of-objects populated) in ONE call:
 
     extract_<snake>(root, text, opts=None) -> <Vo>
         r = extract_lenient_<snake>_with_loader(root, text, opts)  # nested-capable extract
-        if r.report.has_lost_required(): raise ValueError(...)
+        if r.report.has_lost_required() or r.report.has_malformed_required(): raise ValueError(...)
         return _to_strict_<vo>(r.data)                             # mirror -> strict mapper
 
 Why the loaded ``root``: the SELF-CONTAINED ``extract_<snake>(text)`` leaves nested
@@ -173,16 +173,23 @@ def render_extractor(
     lines.append("    value-object). Runs the tolerant nested-capable extract, then maps the")
     lines.append("    extracted mirror graph onto the strict Pydantic payload graph.")
     lines.append("")
-    lines.append("    :raises ValueError: iff a ``@required`` field was lost (the strict gate).")
+    lines.append("    :raises ValueError: iff a ``@required`` field was lost, or present but")
+    lines.append("        unusable (MALFORMED: an undeclared enum member, text for a number).")
     lines.append('    """')
     lines.append(f"    r = {extract_lenient_with_fn}(root, text, opts)")
-    lines.append("    if r.report.has_lost_required():")
-    lines.append("        raise ValueError(")
+    lines.append("    if r.report.has_lost_required() or r.report.has_malformed_required():")
+    lines.append("        unusable = []")
+    lines.append("        if r.report.has_lost_required():")
     lines.append(
-        f'            "{extract_fn}: lost required field(s): "'
+        '            unusable.append("lost required field(s): "'
+        ' + ", ".join(r.report.lost_required()))'
     )
-    lines.append('            + ", ".join(r.report.lost_required())')
-    lines.append("        )")
+    lines.append("        if r.report.has_malformed_required():")
+    lines.append(
+        '            unusable.append("malformed required field(s): "'
+        ' + ", ".join(r.report.malformed_required()))'
+    )
+    lines.append(f'        raise ValueError("{extract_fn}: " + "; ".join(unusable))')
     lines.append(f"    return {root_mapper}(r.data)")
     lines.append("")
     lines.append("")

{metaobjects-1.0.8rc1 → metaobjects-1.0.9}/src/metaobjects/codegen/generators/router_generator.py

@@ -39,11 +39,12 @@ pick their preferred persistence layer.
 from __future__ import annotations
 
 from dataclasses import dataclass
+from pathlib import Path
 
 from metaobjects.apidocs.naming import route_path as _route_path
 from metaobjects.apidocs.naming import reverse_finder_fn, reverse_finder_in_fn
 from metaobjects.apidocs.naming import snake_case as _snake_case
-from metaobjects.codegen.constants import generated_header
+from metaobjects.codegen.constants import GENERATED_MARKER, generated_header
 from metaobjects.codegen.format import ruff_format
 from metaobjects.codegen.fr010_field_mapping import is_required
 from metaobjects.codegen.generator import EmittedFile, GenContext, Generator, per_entity
@@ -81,6 +82,61 @@ from metaobjects.naming import DEFAULT_COLUMN_NAMING
 from metaobjects.shared.base_types import TYPE_IDENTITY
 from metaobjects.shared.separators import PACKAGE_SEP
 
+#: Where the emitted router imports its helper runtime (``filter_parser``,
+#: ``constraint_errors``) from. ``False`` — the packaged generator — imports the copy
+#: installed with ``metaobjects``: ``from metaobjects.codegen.runtime.<m> import ...``.
+#: ``metaobjects eject routes`` flips this line to ``True`` in the owned copy, which then
+#: EMITS that runtime's source from ``codegen/runtime/`` (the directory beside the owned
+#: generators, :data:`RUNTIME_SOURCE_DIR`) into the generated package as ``_runtime/`` and
+#: imports it package-relatively. The runtime is then code the adopter owns: edit
+#: ``codegen/runtime/<m>.py``, regenerate, and the generated package carries the change.
+OWNED_RUNTIME = False
+
+#: The helper runtime modules the emitted router imports (ADR-0034 Amendment 3: helper
+#: tier, not core). Listed on the registry entry too, which is what ``eject`` copies.
+RUNTIME_MODULES: tuple[str, ...] = ("constraint_errors", "filter_parser")
+
+#: The generated subpackage an owned router emits the runtime into.
+RUNTIME_SUBPACKAGE = "_runtime"
+
+#: Where an owned router reads the runtime source it emits. The packaged generator and an
+#: ejected copy sit at the same depth relative to their ``runtime/`` sibling
+#: (``metaobjects/codegen/generators`` vs ``codegen/generators``), so one expression
+#: serves both.
+RUNTIME_SOURCE_DIR = Path(__file__).resolve().parent.parent / "runtime"
+
+
+def _runtime_module(module: str) -> str:
+    """The module path an emitted router imports runtime *module* from."""
+    if OWNED_RUNTIME:
+        return f".{RUNTIME_SUBPACKAGE}.{module}"
+    return f"metaobjects.codegen.runtime.{module}"
+
+
+def _owned_runtime_files() -> list[EmittedFile]:
+    """The runtime source an owned router emits beside itself, marked as generated."""
+    files = [EmittedFile(
+        path=f"{RUNTIME_SUBPACKAGE}/__init__.py",
+        content=f"# {GENERATED_MARKER} — DO NOT EDIT.\n"
+        f"# Helper runtime for the generated routers. Its source is codegen/runtime/.\n",
+    )]
+    for module in RUNTIME_MODULES:
+        src = RUNTIME_SOURCE_DIR / f"{module}.py"
+        if not src.is_file():
+            raise FileNotFoundError(
+                f"the owned routes generator emits its runtime from {src}, which does not "
+                f"exist. Copy {module}.py back from the installed package's "
+                "metaobjects/codegen/runtime/ directory (`python -c \"import "
+                "metaobjects.codegen.runtime as r; print(r.__path__[0])\"` prints it)."
+            )
+        files.append(EmittedFile(
+            path=f"{RUNTIME_SUBPACKAGE}/{module}.py",
+            content=f"# {GENERATED_MARKER} — DO NOT EDIT. Copied from "
+            f"codegen/runtime/{module}.py: edit that file and regenerate.\n"
+            + src.read_text(encoding="utf-8"),
+        ))
+    return files
+
 
 def _effective_fqn(entity: MetaObject) -> str:
     """``package::name`` via the canonical :meth:`MetaData.resolution_key` (own
@@ -928,10 +984,10 @@ class RouterGenerator:
         parts.append("from fastapi.responses import JSONResponse")
         parts.append("from pydantic import BaseModel, ValidationError")
         parts.append("")
-        parts.append("from metaobjects.codegen.runtime.constraint_errors import (")
+        parts.append(f"from {_runtime_module('constraint_errors')} import (")
         parts.append("    classify_constraint_error,")
         parts.append(")")
-        parts.append("from metaobjects.codegen.runtime.filter_parser import (")
+        parts.append(f"from {_runtime_module('filter_parser')} import (")
         parts.append("    FilterPredicate,")
         parts.append("    parse_filter,")
         parts.append(")")
@@ -1280,10 +1336,10 @@ class RouterGenerator:
         parts.append("from fastapi.responses import JSONResponse")
         parts.append("from pydantic import BaseModel, ValidationError")
         parts.append("")
-        parts.append("from metaobjects.codegen.runtime.constraint_errors import (")
+        parts.append(f"from {_runtime_module('constraint_errors')} import (")
         parts.append("    classify_constraint_error,")
         parts.append(")")
-        parts.append("from metaobjects.codegen.runtime.filter_parser import (")
+        parts.append(f"from {_runtime_module('filter_parser')} import (")
         parts.append("    FilterPredicate,")
         parts.append("    parse_filter,")
         parts.append(")")
@@ -1447,7 +1503,7 @@ class RouterGenerator:
         parts.append("from fastapi.responses import JSONResponse")
         parts.append("from pydantic import BaseModel")
         parts.append("")
-        parts.append("from metaobjects.codegen.runtime.filter_parser import (")
+        parts.append(f"from {_runtime_module('filter_parser')} import (")
         parts.append("    FilterPredicate,")
         parts.append("    parse_filter,")
         parts.append(")")
@@ -1528,7 +1584,10 @@ class RouterGenerator:
                 )
             ]
 
-        return per_entity(emit)(ctx)
+        files = per_entity(emit)(ctx)
+        if OWNED_RUNTIME and files:
+            files.extend(_owned_runtime_files())
+        return files
 
 
 def render_router(

{metaobjects-1.0.8rc1 → metaobjects-1.0.9}/src/metaobjects/codegen/generators/trace_helper_generator.py

@@ -282,13 +282,18 @@ def render_trace_helper(entity: MetaObject, root: MetaData) -> str | None:
             "    :param redact:   optional row redaction applied before the single record.",
             '    """',
             "    outcome = extract(input.llm_response_text, _RESPONSE_SCHEMA)",
-            "    failed = outcome.report.has_lost_required()",
+            "    # A required field lost OR malformed (present but unusable) has no value,",
+            "    # so either fails the call.",
+            "    unusable = []",
+            "    if outcome.report.has_lost_required():",
+            '        unusable.append("lost required: " + ", ".join(outcome.report.lost_required()))',
+            "    if outcome.report.has_malformed_required():",
+            "        unusable.append(",
+            '            "malformed required: " + ", ".join(outcome.report.malformed_required())',
+            "        )",
+            "    failed = bool(unusable)",
             "    status = STATUS_ERROR if failed else STATUS_OK",
-            "    error_detail = (",
-            '        "lost required: " + ", ".join(outcome.report.lost_required())',
-            "        if failed",
-            "        else None",
-            "    )",
+            '    error_detail = "; ".join(unusable) if failed else None',
             "    # Extraction owns the derived status/error_detail — fold them into the input",
             "    # before building the base row (dataclasses.replace, leaving the original",
             "    # input untouched).",

metaobjects-1.0.9/src/metaobjects/codegen/model_walk.py

@@ -0,0 +1,101 @@
+"""Everything a generator written from scratch needs, in one import (ADR-0034 Amendment 4).
+
+MetaObjects' product is the core; the outputs an application needs beyond the reference
+generators — OpenAPI, JSON Schema, a client, docs — are generators the adopter writes. A
+generator is any object with a ``name`` and a ``generate(ctx) -> list[EmittedFile]``; wire it
+as ``module:symbol`` in ``--generators`` or in ``metaobjects.config.yaml``'s
+``targets.<name>.generators`` and ``metaobjects gen`` runs it and ``metaobjects verify
+--codegen`` drift-gates it. See ``docs/recipes/write-your-own-generator.md``.
+
+These helpers answer the questions whose right answer is a rule the engine already owns.
+Before this module they were spread over five internal modules, one of them private, and the
+obvious spelling of several was wrong:
+
+* **Python's ``attr(name)`` is OWN-ONLY** (ADR-0039's naming inversion). A field that inherits
+  ``@maxLength`` or ``@required`` through ``extends`` reads ``None`` through it. Read effective
+  values with ``node.attrs().get(name)`` — or the helpers below, which do.
+* ``field.is_array`` is the raw own flag; :func:`field_is_array` resolves.
+* An ``@objectRef`` is resolved package-locally (ADR-0042), never by short name.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from metaobjects.apidocs.naming import route_path
+from metaobjects.codegen.generator import (
+    EmittedFile,
+    GenContext,
+    Generator,
+    once_per_run,
+    per_entity,
+    per_model,
+    per_package,
+)
+from metaobjects.codegen.instance_artifacts import is_abstract
+from metaobjects.codegen.template_codegen.template_data import package_of
+from metaobjects.codegen.type_map import effective_enum_values, field_is_array
+from metaobjects.codegen.value_objects import object_ref_target
+from metaobjects.meta.core.field.field_constants import FIELD_ATTR_MAX_LENGTH, FIELD_ATTR_REQUIRED
+from metaobjects.naming import to_snake_case
+
+__all__ = [
+    "EmittedFile",
+    "GenContext",
+    "Generator",
+    "description",
+    "enum_values",
+    "field_is_array",
+    "is_abstract",
+    "is_required",
+    "max_length",
+    "object_ref_target",
+    "once_per_run",
+    "package_of",
+    "per_entity",
+    "per_model",
+    "per_package",
+    "primary_key_fields",
+    "route_path",
+    "to_snake_case",
+]
+
+_TYPE_VALIDATOR = "validator"
+_VALIDATOR_REQUIRED = "required"
+_DOC_DESCRIPTION = "description"
+_IDENTITY_FIELDS = "fields"
+
+
+def is_required(field: Any) -> bool:
+    """Effective required-ness: ``@required: true`` or a ``validator.required`` child, own or
+    inherited through ``extends`` — the same rule the neutral template data uses."""
+    if field.attrs().get(FIELD_ATTR_REQUIRED) is True:
+        return True
+    return any(c.type == _TYPE_VALIDATOR and c.sub_type == _VALIDATOR_REQUIRED for c in field.children())
+
+
+def max_length(field: Any) -> int | None:
+    """Effective ``@maxLength``, or ``None``."""
+    v = field.attrs().get(FIELD_ATTR_MAX_LENGTH)
+    return int(v) if isinstance(v, (int, float)) and not isinstance(v, bool) else None
+
+
+def enum_values(field: Any) -> list[str]:
+    """A ``field.enum``'s effective ``@values`` (empty when absent)."""
+    return effective_enum_values(field)
+
+
+def description(node: Any) -> str | None:
+    """The node's effective ``@description``, or ``None``."""
+    v = node.attrs().get(_DOC_DESCRIPTION)
+    return v if isinstance(v, str) else None
+
+
+def primary_key_fields(obj: Any) -> list[str]:
+    """The primary identity's field names, own or inherited (empty when none)."""
+    identity = obj.primary_identity()
+    if identity is None:
+        return []
+    v = identity.attrs().get(_IDENTITY_FIELDS)
+    if isinstance(v, str):
+        return [s.strip() for s in v.split(",") if s.strip()]
+    return [str(x) for x in v] if isinstance(v, (list, tuple)) else []

{metaobjects-1.0.8rc1 → metaobjects-1.0.9}/src/metaobjects/codegen/runner.py

@@ -130,9 +130,13 @@ def run_gen(
     # to out_dir). The generated modules use package-relative imports, so without
     # this a consumer can't import them. A generator-emitted __init__.py wins; a
     # hand-authored one is left untouched by the overwrite policy below.
+    #
+    # Only directories that hold a generated PYTHON module: an adopter's own generator
+    # emitting JSON Schema or OpenAPI into `schemas/` is not writing a package, and an
+    # `__init__.py` there is litter that makes the tree look importable.
     if config.emit_package_init:
         pkg_rel_dirs: set[str] = set()
-        for full in list(emitted):
+        for full in [p for p in emitted if p.endswith(".py")]:
             d = os.path.dirname(os.path.relpath(full, config.out_dir))
             while True:
                 pkg_rel_dirs.add(d)