metaobjects 0.15.9__tar.gz → 0.15.11__tar.gz

{metaobjects-0.15.9 → metaobjects-0.15.11}/LICENSE

@@ -1,3 +1,4 @@
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
@@ -32,33 +33,36 @@
       not limited to compiled object code, generated documentation,
       and conversions to other media types.
 
-      "Work" shall mean the work of authorship made available under
-      the License, as indicated by a copyright notice that is included in
-      or attached to the work (an example is provided in the Appendix below).
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
 
       "Derivative Works" shall mean any work, whether in Source or Object
       form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other transformations
+      editorial revisions, annotations, elaborations, or other modifications
       represent, as a whole, an original work of authorship. For the purposes
       of this License, Derivative Works shall not include works that remain
       separable from, or merely link (or bind by name) to the interfaces of,
       the Work and Derivative Works thereof.
 
-      "Contribution" shall mean, as submitted to the Licensor for inclusion
-      in the Work by the copyright owner or by an individual or Legal Entity
-      authorized to submit on behalf of the copyright owner. For the purposes
-      of this definition, "submitted" means any form of electronic, verbal,
-      or written communication sent to the Licensor or its representatives,
-      including but not limited to communication on electronic mailing lists,
-      source code control systems, and issue tracking systems that are managed
-      by, or on behalf of, the Licensor for the purpose of recording and
-      discussing modifications to the Work, but excluding communication that
-      is conspicuously marked or designated in writing by the copyright owner
-      as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any Legal Entity on behalf of
-      whom a Contribution has been received by the Licensor and included
-      within the Work.
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
 
    2. Grant of Copyright License. Subject to the terms and conditions of
       this License, each Contributor hereby grants to You a perpetual,
@@ -74,22 +78,22 @@
       use, offer to sell, sell, import, and otherwise transfer the Work,
       where such license applies only to those patent claims licensable
       by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by the combination of their Contribution(s)
+      Contribution(s) alone or by combination of their Contribution(s)
       with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a cross-claim
-      or counterclaim in a lawsuit) alleging that the Work or any
-      Contribution embodied within the Work constitutes direct or contributory
-      patent infringement, then any patent licenses granted to You under
-      this License for that Work shall terminate as of the date such
-      litigation is filed.
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
 
    4. Redistribution. You may reproduce and distribute copies of the
       Work or Derivative Works thereof in any medium, with or without
       modifications, and in Source or Object form, provided that You
       meet the following conditions:
 
-      (a) You must give any other recipients of the Work or Derivative
-          Works a copy of this License; and
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
 
       (b) You must cause any modified files to carry prominent notices
           stating that You changed the files; and
@@ -101,24 +105,28 @@
           the Derivative Works; and
 
       (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, You must include a readable copy of the
-          attribution notices contained within such NOTICE file, in
-          at least one of the following places: within a NOTICE text
-          file distributed as part of the Derivative Works; within
-          the Source form or documentation, if provided along with the
-          Derivative Works; or, within a display generated by the
-          Derivative Works, if and wherever such third-party notices
-          normally appear. The contents of the NOTICE file are for
-          informational purposes only and do not modify the License.
-          You may add Your own attribution notices within Derivative
-          Works that You distribute, alongside or in addition to the
-          NOTICE text from the Work, provided that such additional
-          attribution notices cannot be construed as modifying the License.
-
-      You may add Your own license statement for Your modifications and
-      may provide additional grant of rights to use, reproduce, modify,
-      prepare derivative works of, distribute, and sublicense such modifications,
-      as an additional requirement of this License.
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
 
    5. Submission of Contributions. Unless You explicitly state otherwise,
       any Contribution intentionally submitted for inclusion in the Work
@@ -137,10 +145,10 @@
       agreed to in writing, Licensor provides the Work (and each
       Contributor provides its Contributions) on an "AS IS" BASIS,
       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any conditions of TITLE,
-      NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR
-      PURPOSE. You are solely responsible for determining the
-      appropriateness of using or reproducing the Work and assume any
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
       risks associated with Your exercise of permissions under this License.
 
    8. Limitation of Liability. In no event and under no legal theory,
@@ -148,20 +156,23 @@
       unless required by applicable law (such as deliberate and grossly
       negligent acts) or agreed to in writing, shall any Contributor be
       liable to You for damages, including any direct, indirect, special,
-      incidental, or exemplary damages of any character arising as a
+      incidental, or consequential damages of any character arising as a
       result of this License or out of the use or inability to use the
       Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or all other
-      commercial damages or losses), even if such Contributor has been
-      advised of the possibility of such damages.
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
 
    9. Accepting Warranty or Additional Liability. While redistributing
       the Work or Derivative Works thereof, You may choose to offer,
       and charge a fee for, acceptance of support, warranty, indemnity,
       or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may offer
-      only obligations consistent to this License provided that the
-      obligations are consistent with this License.
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
 
    END OF TERMS AND CONDITIONS
 
@@ -171,19 +182,21 @@
       boilerplate notice, with the fields enclosed by brackets "[]"
       replaced with your own identifying information. (Don't include
       the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format in question. Also add information
-      on how to contact you electronically and/or by mail.
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
 
-      Copyright 2026 MetaObjects Contributors
+   Copyright 2026 MetaObjects Contributors
 
-      Licensed under the Apache License, Version 2.0 (the "License");
-      you may not use this file except in compliance with the License.
-      You may obtain a copy of the License at
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
 
-          http://www.apache.org/licenses/LICENSE-2.0
+       http://www.apache.org/licenses/LICENSE-2.0
 
-      Unless required by applicable law or agreed to in writing, software
-      distributed under the License is distributed on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-      See the License for the specific language governing permissions and
-      limitations under the License.
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

{metaobjects-0.15.9 → metaobjects-0.15.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.15.9
+Version: 0.15.11
 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.15.9 → metaobjects-0.15.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.15.9"
+version = "0.15.11"
 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.15.9 → metaobjects-0.15.11}/src/metaobjects/core_types.py

@@ -6,6 +6,7 @@ from .attr_class_map import attr_class_for
 from .meta.core.attr import meta_attr as _attr  # noqa: F401
 from .meta.core.attr.attr_constants import (
     ATTR_SUBTYPE_BOOLEAN,
+    ATTR_SUBTYPE_FILTER,
     ATTR_SUBTYPE_INT,
     ATTR_SUBTYPE_STRING,
     ATTR_SUBTYPES,
@@ -35,7 +36,6 @@ from .meta.core.field.field_constants import (
 )
 from .meta.core.field.meta_field import MetaField
 from .meta.persistence.db.db_constants import (
-    FIELD_ATTR_DB_COLUMN_TYPE,
     FIELD_ATTR_DB_INDEXED,
 )
 from .meta.core.identity.identity_constants import (
@@ -49,7 +49,7 @@ from .meta.core.identity.identity_constants import (
     IDENTITY_SUBTYPE_SECONDARY,
 )
 from .meta.core.identity.meta_identity import MetaIdentity
-from .meta.core.index.index_constants import INDEX_ATTR_FIELDS, INDEX_SUBTYPE_LOOKUP, INDEX_SUBTYPES
+from .meta.core.index.index_constants import INDEX_ATTR_FIELDS, INDEX_SUBTYPES
 from .meta.core.index.meta_index import MetaIndex
 from .meta.core.object.meta_object import MetaObject
 from .meta.core.object.object_constants import (
@@ -57,7 +57,6 @@ from .meta.core.object.object_constants import (
     OBJECT_ATTR_DISCRIMINATOR_VALUE,
     OBJECT_SUBTYPE_ENTITY,
     OBJECT_SUBTYPE_PROJECTION,
-    OBJECT_SUBTYPE_VALUE,
     OBJECT_SUBTYPES,
 )
 from .meta.core.relationship.meta_relationship import MetaRelationship
@@ -77,6 +76,8 @@ from .meta.meta_root import MetaRoot
 from .meta.persistence.origin.meta_origin import MetaOrigin
 from .meta.persistence.origin.origin_constants import (
     ORIGIN_ATTR_AGG,
+    ORIGIN_ATTR_CONVERT,
+    ORIGIN_ATTR_FILTER,
     ORIGIN_ATTR_FROM,
     ORIGIN_ATTR_OF,
     ORIGIN_ATTR_VIA,
@@ -595,7 +596,7 @@ core_provider.add(
     )
 )
 
-# origin.passthrough — @from required, @via optional
+# origin.passthrough — @from required, @via optional, @convert optional (#185).
 core_provider.add(
     TypeDefinition(
         type=TYPE_ORIGIN,
@@ -604,6 +605,8 @@ core_provider.add(
         attrs=[
             AttrSchema(name=ORIGIN_ATTR_FROM, value_type=ATTR_SUBTYPE_STRING, required=True),
             AttrSchema(name=ORIGIN_ATTR_VIA, value_type=ATTR_SUBTYPE_STRING, required=False),
+            # #185 — opt out of the type-preserving ERR_PASSTHROUGH_TYPE_MISMATCH check.
+            AttrSchema(name=ORIGIN_ATTR_CONVERT, value_type=ATTR_SUBTYPE_BOOLEAN, required=False),
         ],
         child_rules=[ChildRule(TYPE_ATTR, "*")],
     )
@@ -630,6 +633,7 @@ core_provider.add(
             ),
             AttrSchema(name=ORIGIN_ATTR_OF, value_type=ATTR_SUBTYPE_STRING, required=True),
             AttrSchema(name=ORIGIN_ATTR_VIA, value_type=ATTR_SUBTYPE_STRING, required=False),
+            AttrSchema(name=ORIGIN_ATTR_FILTER, value_type=ATTR_SUBTYPE_FILTER, required=False),
         ],
         child_rules=[ChildRule(TYPE_ATTR, "*")],
     )

{metaobjects-0.15.9 → metaobjects-0.15.11}/src/metaobjects/errors.py

@@ -102,7 +102,13 @@ class ErrorCode(str, Enum):
     ERR_PARAMETER_REF_UNRESOLVED = "ERR_PARAMETER_REF_UNRESOLVED"
     ERR_PARAMETER_REF_NOT_VALUE_OBJECT = "ERR_PARAMETER_REF_NOT_VALUE_OBJECT"
     ERR_PARAMETER_REF_ON_NON_CALLABLE_KIND = "ERR_PARAMETER_REF_ON_NON_CALLABLE_KIND"
-    ERR_PARAMETER_REF_PASSTHROUGH_TYPE_MISMATCH = "ERR_PARAMETER_REF_PASSTHROUGH_TYPE_MISMATCH"
+    # #185 — a field forwarding another field's value via origin.passthrough must
+    # declare the SAME field.<subType> and array-ness as its resolved @from source
+    # (a passthrough forwards the value unchanged). A differing subType or array-ness
+    # → this error, unless @convert: true acknowledges a deliberate type change. This
+    # GENERALIZES and RETIRES the FR-015-narrow ERR_PARAMETER_REF_PASSTHROUGH_TYPE_
+    # MISMATCH (the origin-paths pass runs over every object, value hosts included).
+    ERR_PASSTHROUGH_TYPE_MISMATCH = "ERR_PASSTHROUGH_TYPE_MISMATCH"
     # FR-014 — TPH discriminator cross-attribute validation. Cross-language
     # vocabulary; Python loader does not emit these yet.
     ERR_DISCRIMINATOR_FIELD_NOT_FOUND = "ERR_DISCRIMINATOR_FIELD_NOT_FOUND"

{metaobjects-0.15.9 → metaobjects-0.15.11}/src/metaobjects/loader/validate_source_parameter_ref.py

@@ -8,9 +8,13 @@ Codes:
       object.
     * ``ERR_PARAMETER_REF_NOT_VALUE_OBJECT`` — ``@parameterRef`` points at an
       object that is not an ``object.value``.
-    * ``ERR_PARAMETER_REF_PASSTHROUGH_TYPE_MISMATCH`` — a parameter field uses
-      ``origin.passthrough @from: "Entity.field"`` but its subtype does not match
-      the referenced field's subtype.
+
+Note (#185): the parameter-field passthrough type-match check formerly emitted
+here (``ERR_PARAMETER_REF_PASSTHROUGH_TYPE_MISMATCH``) is RETIRED. It is subsumed
+by the universal ``ERR_PASSTHROUGH_TYPE_MISMATCH`` in ``validation_passes.py``,
+whose origin-paths pass runs over every object — value hosts (parameter shapes)
+included — so a parameter field's ``origin.passthrough`` type mismatch is now
+caught there (with the ``@convert: true`` opt-out).
 
 Mirrors the TS reference
 ``packages/metadata/src/persistence/source/validate-source-parameter-ref.ts``.
@@ -30,11 +34,7 @@ from ..meta.core.object.object_constants import (
     OBJECT_SUBTYPE_ENTITY,
     OBJECT_SUBTYPE_VALUE,
 )
-from ..meta.persistence.origin.origin_constants import (
-    ORIGIN_ATTR_FROM,
-    ORIGIN_SUBTYPE_PASSTHROUGH,
-)
-from ..shared.base_types import TYPE_FIELD, TYPE_OBJECT, TYPE_ORIGIN, TYPE_SOURCE
+from ..shared.base_types import TYPE_OBJECT, TYPE_SOURCE
 from ..shared.separators import PACKAGE_SEP
 
 _CALLABLE_KINDS = frozenset({SOURCE_KIND_STORED_PROC, SOURCE_KIND_TABLE_FUNCTION})
@@ -122,60 +122,7 @@ def validate_source_parameter_ref(root: MetaData, errors: list[MetaError]) -> No
                 )
                 continue
 
-            # ERR_PARAMETER_REF_PASSTHROUGH_TYPE_MISMATCH — each parameter field
-            # with origin.passthrough must match the referenced field's subtype.
-            # ADR-0039: resolving — the parameter value-object's fields may be
-            # inherited via extends (mirrors the TS `target.children()` —
-            # validate-source-parameter-ref.ts:122).
-            for param_field in target.children():
-                if param_field.type != TYPE_FIELD:
-                    continue
-                # ADR-0039 own: origin.* never inherits (ADR-0029); the origin child
-                # is read own (mirrors the TS `paramField.ownChildren()`).
-                passthrough = next(
-                    (
-                        c
-                        for c in param_field.own_children()
-                        if c.type == TYPE_ORIGIN
-                        and c.sub_type == ORIGIN_SUBTYPE_PASSTHROUGH
-                    ),
-                    None,
-                )
-                if passthrough is None:
-                    continue
-                frm = passthrough.attr(ORIGIN_ATTR_FROM)  # ADR-0039 sanctioned own: origin.* never inherits (ADR-0029)
-                if not isinstance(frm, str) or frm == "":
-                    continue
-                dot = frm.find(".")
-                if dot < 0:
-                    continue
-                target_entity_name = frm[:dot]
-                target_field_name = frm[dot + 1:]
-                target_entity = object_index.get(target_entity_name)
-                if target_entity is None:
-                    continue  # origin-paths pass surfaces this
-                # ADR-0039: resolving — the referenced entity's field may be
-                # inherited via extends (mirrors the TS `targetEntity.children()` —
-                # validate-source-parameter-ref.ts:139).
-                target_field = next(
-                    (
-                        c
-                        for c in target_entity.children()
-                        if c.type == TYPE_FIELD and c.name == target_field_name
-                    ),
-                    None,
-                )
-                if target_field is None:
-                    continue
-                if param_field.sub_type != target_field.sub_type:
-                    errors.append(
-                        MetaError(
-                            f'parameter field "{param_field.name}" '
-                            f"(field.{param_field.sub_type}) on @parameterRef "
-                            f'"{ref}" uses origin.passthrough @from: "{frm}", but '
-                            f"{target_entity.name}.{target_field_name} is "
-                            f"field.{target_field.sub_type}; types must match",
-                            ErrorCode.ERR_PARAMETER_REF_PASSTHROUGH_TYPE_MISMATCH,
-                            envelope=param_field.source,
-                        )
-                    )
+            # #185 — the parameter-field passthrough type-match check formerly here
+            # (ERR_PARAMETER_REF_PASSTHROUGH_TYPE_MISMATCH) is RETIRED; the universal
+            # ERR_PASSTHROUGH_TYPE_MISMATCH in validation_passes.py now covers it
+            # (its origin-paths pass runs over every object, value hosts included).

{metaobjects-0.15.9 → metaobjects-0.15.11}/src/metaobjects/loader/validation_passes.py

@@ -78,6 +78,7 @@ from ..meta.presentation.layout.layout_constants import (
     LAYOUT_SUBTYPE_DATA_GRID,
 )
 from ..meta.persistence.origin.origin_constants import (
+    ORIGIN_ATTR_CONVERT,
     ORIGIN_ATTR_FROM,
     ORIGIN_ATTR_OF,
     ORIGIN_ATTR_VIA,
@@ -94,7 +95,6 @@ from ..meta.core.relationship.relationship_constants import (
     RELATIONSHIP_ATTR_THROUGH,
 )
 from ..meta.core.identity.identity_constants import (
-    IDENTITY_SUBTYPE_PRIMARY,
     IDENTITY_SUBTYPE_REFERENCE,
     IDENTITY_REFERENCE_ATTR_REFERENCES,
 )
@@ -1476,6 +1476,54 @@ def _check_extends_origin_agreement(
     )
 
 
+def _check_passthrough_type(
+    field: MetaData,
+    from_field: MetaData,
+    from_attr: str,
+    convert: bool,
+    obj: MetaData,
+    origin_source: object,
+    referrer: str,
+    errors: list[MetaError],
+) -> None:
+    """#185 — a passthrough is type-preserving. A field forwarding another field's
+    value via origin.passthrough must declare the SAME field.<subType> and the same
+    array-ness as its resolved @from source — otherwise the projected type silently
+    diverges from its source (e.g. a field.uuid surfaced as field.string, forcing
+    hand-written String<->UUID bridging).
+
+    Compares the RESOLVING/effective subType + isArray (ADR-0039), so a field
+    inheriting its shape via ``extends`` is judged on its effective type. Nullability
+    is deliberately NOT judged: a view over an outer join legitimately widens a NOT
+    NULL source column to nullable.
+
+    Escape hatch: ``@convert: true`` on the origin.passthrough acknowledges a
+    deliberate type change and suppresses the error (it does NOT emit a cast — the
+    consumer owns any coercion; real converting projections are #159's
+    origin.expression). Host-agnostic (projections, entities, values, and the
+    FR-015 stored-proc parameter refs the retired ERR_PARAMETER_REF_PASSTHROUGH_
+    TYPE_MISMATCH used to cover). Mirrors the TS reference ``_checkPassthroughType``.
+    """
+    if convert:
+        return  # deliberate type change acknowledged
+    # Compare both axes at once via the type-label: subtype names never contain
+    # "[]", so equal labels <=> same subType AND same array-ness.
+    declared = f"field.{field.sub_type}{'[]' if field.resolved_is_array() else ''}"
+    source = f"field.{from_field.sub_type}{'[]' if from_field.resolved_is_array() else ''}"
+    if declared == source:
+        return
+    errors.append(
+        MetaError(
+            f"origin.passthrough on {obj.name}.{field.name}: field is {declared} but its "
+            f"@from source '{from_attr}' is {source} — a passthrough forwards the value "
+            f"unchanged, so the types must match. Declare {source}, or set @convert: true "
+            f"to acknowledge a deliberate type change.",
+            ErrorCode.ERR_PASSTHROUGH_TYPE_MISMATCH,
+            envelope=resolved_source(origin_source, referrer, from_attr),
+        )
+    )
+
+
 def _validate_origin_paths(
     root: MetaData,
     errors: list[MetaError],
@@ -1533,6 +1581,12 @@ def _validate_origin_paths(
                     _check_extends_origin_agreement(
                         node, from_target[1], from_ref, obj, origin.source, referrer, errors
                     )
+                    # #185 — passthrough is type-preserving unless @convert acknowledges
+                    # a change. ADR-0039 sanctioned own: origin.* never inherits (ADR-0029).
+                    convert = origin.attr(ORIGIN_ATTR_CONVERT) is True
+                    _check_passthrough_type(
+                        node, from_target[1], from_ref, convert, obj, origin.source, referrer, errors
+                    )
                 via = origin.attr(ORIGIN_ATTR_VIA)
                 if isinstance(via, str) and via:
                     hops = _validate_via_path(via, ctx, object_index, errors, origin, referrer)

{metaobjects-0.15.9 → metaobjects-0.15.11}/src/metaobjects/meta/persistence/origin/origin_constants.py

@@ -14,7 +14,14 @@ ORIGIN_SUBTYPES = (
 # passthrough attrs
 ORIGIN_ATTR_FROM = "from"
 ORIGIN_ATTR_VIA = "via"
+# #185 — acknowledges a deliberate type change on origin.passthrough (opt out of
+# the type-preserving ERR_PASSTHROUGH_TYPE_MISMATCH check). Mirrors the TS
+# ORIGIN_PASSTHROUGH_ATTR_CONVERT.
+ORIGIN_ATTR_CONVERT = "convert"
 
 # aggregate attrs
 ORIGIN_ATTR_AGG = "agg"
 ORIGIN_ATTR_OF = "of"
+# @filter (attr.filter object): optional scoping predicate on the aggregated rows,
+# rendered as SQL FILTER (WHERE ...) by the projection view emitter.
+ORIGIN_ATTR_FILTER = "filter"

{metaobjects-0.15.9 → metaobjects-0.15.11}/src/metaobjects/runtime/object_manager.py

@@ -27,6 +27,7 @@ from __future__ import annotations
 
 import datetime as _dt
 import decimal as _decimal
+import json as _json
 import uuid as _uuid
 from collections.abc import Iterable
 from typing import Any, Protocol
@@ -693,9 +694,24 @@ def _coerce_write_value(field: MetaField, value: Any) -> Any:
         is_tz = field.get_meta_attr(dbc.FIELD_ATTR_LOCAL_TIME) is not True  # ADR-0039 resolving: @localTime may be inherited
         return _parse_datetime(str(value), tz_aware=is_tz)
 
-    # field.object (jsonb storage): a dict/list passes through — pg8000 binds it
-    # to the jsonb column natively (no manual JSON.stringify, unlike node-pg).
-    # A field.string pinned to a jsonb column behaves the same way.
+    # field.object / field.map stored as a single jsonb column: serialize to a
+    # JSON text string so pg8000 sends it as jsonb text (PG assignment-casts text
+    # → jsonb). pg8000 binds a native *dict* to jsonb natively, but a native
+    # *list* (array-of-VO, isArray:true) it adapts as a Postgres ARRAY literal
+    # `{...,...}` which the JSONB column rejects with 22P02 'invalid input syntax
+    # for type json' — so we cannot rely on driver magic for the list form.
+    # Serializing both shapes to a JSON string is the explicit codec every other
+    # port has (Java/Gson, C#/System.Text.Json, TS/JSON.stringify, Kotlin/Jackson)
+    # and handles dict (single VO), list (array-of-VO), and [] uniformly.
+    #
+    # Scope: only jsonb-storage field.object/field.map. A *flattened* field.object
+    # is expanded to separate scalar columns (never reaches here as the object
+    # node) and must not be touched; a field.string pinned to a jsonb column via
+    # @dbColumnType already carries a string value and is left alone above.
+    if sub in (fc.FIELD_SUBTYPE_OBJECT, fc.FIELD_SUBTYPE_MAP):
+        storage = field.get_meta_attr(fc.FIELD_ATTR_STORAGE)  # ADR-0039 resolving
+        if storage != "flattened":  # None / "jsonb" / "subdocument" → single jsonb column
+            return _json.dumps(value)
     # Everything else (string / int / long / double / float / boolean / enum)
     # is already the native type pg8000 binds directly.
     return value

{metaobjects-0.15.9 → metaobjects-0.15.11}/src/metaobjects/spec_metamodel/origin.json

@@ -13,7 +13,8 @@
       "whenToUse": "A projection field just surfaces a field from a related entity. Declare the cross-entity passthrough instead of re-joining and re-selecting it by hand.",
       "children": [
         { "type": "attr", "subType": "string", "name": "from", "min": 1, "max": 1, "description": "Dotted Entity.field reference identifying the source value this projection field passes through (e.g. 'Program.title')." },
-        { "type": "attr", "subType": "string", "name": "via", "min": 0, "max": 1, "description": "Optional dotted relationship path used to reach the source entity (e.g. 'Program.weeks')." }
+        { "type": "attr", "subType": "string", "name": "via", "min": 0, "max": 1, "description": "Optional dotted relationship path used to reach the source entity (e.g. 'Program.weeks')." },
+        { "type": "attr", "subType": "boolean", "name": "convert", "min": 0, "max": 1, "description": "Acknowledges that this field's declared type deliberately differs from its @from source field's type (#185). Absent/false (the default), a passthrough is type-preserving — a differing field.<subType> or array-ness fails with ERR_PASSTHROUGH_TYPE_MISMATCH. Set true to opt out. This is an acknowledgement only: it does NOT generate a cast — the value flows through unchanged and the consumer owns any coercion. Real type-converting projections are origin.expression's job (#159)." }
       ]
     },
     {
@@ -25,7 +26,8 @@
       "children": [
         { "type": "attr", "subType": "string", "name": "agg", "min": 1, "max": 1, "allowedValues": ["count", "sum", "avg", "min", "max"], "description": "Aggregate function applied over the relationship path: count, sum, avg, min, or max." },
         { "type": "attr", "subType": "string", "name": "of", "min": 1, "max": 1, "description": "Dotted Entity.field reference identifying the column being aggregated (e.g. 'Week.durationMinutes')." },
-        { "type": "attr", "subType": "string", "name": "via", "min": 0, "max": 1, "description": "Dotted relationship path from the base entity to the aggregated rows (e.g. 'Program.weeks' or 'Program.weeks.workouts'). May be omitted only when exactly one single-hop relationship leads from the base entity to the @of entity (FR-024, ADR-0029)." }
+        { "type": "attr", "subType": "string", "name": "via", "min": 0, "max": 1, "description": "Dotted relationship path from the base entity to the aggregated rows (e.g. 'Program.weeks' or 'Program.weeks.workouts'). May be omitted only when exactly one single-hop relationship leads from the base entity to the @of entity (FR-024, ADR-0029)." },
+        { "type": "attr", "subType": "filter", "name": "filter", "min": 0, "max": 1, "description": "Optional scoping filter restricting which related rows the aggregate spans, rendered as a SQL FILTER (WHERE ...) clause. Structured filter object desugared to canonical { field: { op: value } } form at parse time." }
       ]
     },
     {