@@ -75,7 +75,7 @@ PyPI has had no product change since `0.25.0` — nothing is broken.
 - **Kotlin** — `codegen-kotlin` (KotlinPoet on JVM): entity + Exposed table + Spring controller + payload + relations + filter allowlist + validator + stored-proc + output-parser generators. `integration-tests-kotlin` runs the persistence-conformance corpus through Exposed against Testcontainers Postgres.
 
 **Cross-port conformance corpora** (every port runs the shared corpus):
-- Metamodel: `fixtures/conformance/` (361 fixtures; 25 shared corpora in total — per-corpus counts + the corpus x port matrix live in `docs/CONFORMANCE.md`). TS / C# / Java / Python all green.
+- Metamodel: `fixtures/conformance/` (362 fixtures; 25 shared corpora in total — per-corpus counts + the corpus x port matrix live in `docs/CONFORMANCE.md`). TS / C# / Java / Python all green.
 - Render: `fixtures/render-conformance/`. TS / C# / Java / Kotlin / Python byte-identical.
 - Persistence: `fixtures/persistence-conformance/`. **Query** scenarios run on every port (TS / C# / Java / Kotlin / Python), each provisioning its test DB by executing the committed, TS-produced `canonical/schema.postgres.sql` (Postgres only — Derby dropped for the cross-port query corpus, ADR-0015). The **migration** scenarios are exercised by **TS only** (TS owns schema migrations). **The corpus now gates WRITES, not just reads (SP-H):** an `op: roundtrip` scenario type INSERTs through each port's runtime/ORM write codec (NOT raw SQL), reads the row back, and asserts the wire-normalized value. The `AllTypes` entity (`roundtrip-all-types.yaml`) carries one field of **every** persistable `field.*` subtype — string/int/long/double/float/decimal/boolean/date/time/timestamp(+tz)/currency/enum/uuid/object — plus an **array-of-VO** `field.object @isArray @storage:jsonb` column (`labels`, written as 2-element / empty-`[]` / single-element arrays across the three rows) — so every subtype write+read (incl. the array-of-value-object jsonb codec) round-trips through every port against Testcontainers PG. (`field.byte`/`field.short`/`field.class` were cut as non-functional registration-only stubs — the matrix tracks only genuinely-supported subtypes; see `fixtures/registry-conformance/README.md` → "Per-subtype write-round-trip matrix".)
 - API-contract: `fixtures/api-contract-conformance/`. TS / C# / Java / Kotlin / Python all green — each port runs **two lanes**: a hand-rolled reference server AND its **generated** API artifact booted over HTTP (the deployed controller/routes; TS+C# full-stack vs Testcontainers PG, Java/Kotlin/Python generated controller + in-memory repo behind the consumer seam). The generated fan-out found 10 real deployment bugs golden snapshots missed. Two sub-corpora run the **generated lane only, on all five ports** — `write-through/` and `projection/` (F22: a view-only `object.projection` serves GET list + GET by id and answers every write verb with `405 {"error": "method_not_allowed"}`). That is deliberate, not a gap: what is under test is whether a port's GENERATOR emits those routes, and a hand-rolled reference server would answer every scenario by construction. The `m2m/` sub-corpus also gates **TPH x M:N together** (base-declared, subtype-declared, abstract-mid-declared, a non-subtype source onto a subtype TARGET, and the cross-subtype source id answering `200 []`) — the two corpora were originally built disjoint (`tph/` had no relationships, `m2m/` no discriminators), which is precisely how that defect class survived.
 
@@ -64,6 +64,14 @@ it until 1.1 ships._
 
 ### Fixed
 
+- **Python, C#, Java: an inline object-valued attribute now loads as an `attr.properties` bag.**
+  `"@store": { "collection": "orders" }` on a node that declares no `@store` is the registered
+  property bag, the same thing the explicit `{ "attr.properties": { "name": ..., "value": {...} } }`
+  child produces. TypeScript always loaded it that way. Python loaded it as `attr.base` and
+  failed a strict load with `ERR_UNKNOWN_ATTR`; C# rejected the value with `ERR_BAD_ATTR_VALUE`;
+  Java (and so Kotlin) loaded it but stored the bag as a JSON-text string. All four loaders now
+  agree, gated by the `attr-properties-inline` conformance fixture. Nothing that loaded before
+  stops loading.
 - **Java OMDB reads a projection whose view is named by `@view`.** The read mapping took the
   view name from `@table` only, so a projection declared with the kind-matching `@view` alias
   had no read mapping. It now resolves the source's physical name (`@view`, then the legacy
 
@@ -261,7 +261,7 @@ metaobjects/
 ├── CLAUDE.md                       # project instructions for Claude
 ├── spec/                           # canonical metamodel docs, ADRs, roadmap
 ├── fixtures/                       # 25 cross-language conformance corpora — the oracle
-│   ├── conformance/                # metamodel (loader + serializer + navigation), 361 fixtures
+│   ├── conformance/                # metamodel (loader + serializer + navigation), 362 fixtures
 │   ├── yaml-conformance/           # YAML authoring desugar
 │   ├── render-conformance/         # FR-004 byte-identical render oracle
 │   ├── verify-conformance/         # FR-004 template-drift gate
 
@@ -26,7 +26,7 @@ regenerate with `ls -d fixtures/<corpus>/*/ | wc -l` for directory-shaped corpor
 
 | Corpus | Fixtures | TS | Java | Kotlin | C# | Python |
 |---|---|---|---|---|---|---|
-| [`fixtures/conformance/`](../fixtures/conformance/) (metamodel) | 361 | ✓ | ✓ | inherits via `metadata-ktx` | ✓ | ✓ |
+| [`fixtures/conformance/`](../fixtures/conformance/) (metamodel) | 362 | ✓ | ✓ | inherits via `metadata-ktx` | ✓ | ✓ |
 | [`fixtures/yaml-conformance/`](../fixtures/yaml-conformance/) | 16 | 16 / 16 | 15 / 16 (1 ledgered: `yaml-quoted-leading-zero` — Java pipeline strips quotes off `"007"`) | inherits via Java | 15 / 16 (1 ledgered: `error-yaml-coerced-hex-in-string` — YamlDotNet doesn't coerce `0xFF`) | 16 / 16 |
 | [`fixtures/verify-conformance/`](../fixtures/verify-conformance/) | 31 | ✓ | ✓ | inherits via Java | ✓ | ✓ |
 | [`fixtures/verify-strict-conformance/`](../fixtures/verify-strict-conformance/) | 1 | ✓ | — | — | — | ✓ |
@@ -202,7 +202,7 @@ unit-test runners (`bun test`, `dotnet test`, `pytest`, `mvn test`) pull Docker.
 
 ## Fixture-to-doc mapping
 
-### `fixtures/conformance/` — metamodel loader + canonical serializer (361)
+### `fixtures/conformance/` — metamodel loader + canonical serializer (362)
 
 | Fixture prefix | Feature doc |
 |---|---|
@@ -397,7 +397,7 @@ own those two functions), and
 
 ## Orphaned fixtures (tested but not yet documented)
 
-The fixtures in the nine corpora mapped above (metamodel 361 + yaml 16 + verify 31
+The fixtures in the nine corpora mapped above (metamodel 362 + yaml 16 + verify 31
 + render 15 + persistence 39 + api-contract 61 + source-resolution 25 + scope 10 +
 dependency 23) each map to a feature doc. None are orphaned today. The remaining
 corpora in the totals table gate tooling contracts (registry manifests, provider
 
@@ -0,0 +1,30 @@
+{
+  "metadata.root": {
+    "package": "acme",
+    "children": [
+      {
+        "object.entity": {
+          "name": "Order",
+          "@store": {
+            "collection": "orders"
+          },
+          "children": [
+            {
+              "field.long": {
+                "name": "id"
+              }
+            },
+            {
+              "identity.primary": {
+                "name": "id",
+                "@fields": [
+                  "id"
+                ]
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}
@@ -0,0 +1,26 @@
+{
+  "metadata.root": {
+    "package": "acme",
+    "children": [
+      {
+        "object.entity": {
+          "name": "Order",
+          "@store": { "collection": "orders" },
+          "children": [
+            {
+              "field.long": {
+                "name": "id"
+              }
+            },
+            {
+              "identity.primary": {
+                "name": "id",
+                "@fields": ["id"]
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}
@@ -1597,6 +1597,26 @@ private static void ApplyInlineAttrsAndUnknownKeys(
                 .AttrsOf(model.Type, model.SubType)
                 .FirstOrDefault(a => a.Name == attrName);
 
+            // An UNDECLARED @-attr whose value is a JSON object is the registered
+            // `attr.properties` bag — materialize it exactly as the explicit
+            // `{"attr.properties": {...}}` child form does (structural attr child +
+            // SetAttr map entry), so the strict-attr pass exempts it. Mirrors TS
+            // parser-core inferUndeclaredAttrSubType.
+            if (attrSpec is null
+                && rawVal.ValueKind == JsonValueKind.Object
+                && st.Registry.Find(TYPE_ATTR, ATTR_SUBTYPE_PROPERTIES) is { } bagDef)
+            {
+                object bag = DataConverter.ToAttrObject(rawVal);
+                MetaData bagModel = bagDef.Factory(bagDef.TypeId, attrName);
+                st.Builder.PushKey(key);
+                bagModel.SetSource(st.CurrentSource());
+                st.Builder.Pop();
+                bagModel.SetAttr(RESERVED_KEY_VALUE, bag);
+                model.AddChild(bagModel);
+                model.SetAttr(attrName, bag);
+                continue;
+            }
+
             object? value;
             try
             {
 
@@ -1432,6 +1432,20 @@ private void processAttributes(MetaData md, JsonObject body) {
             // This lets the base parser's existing [...]  → comma-delimited → isArray=true
             // path fire correctly, without any hardcoded attribute names.
             JsonElement rawValue = entry.getValue();
+            // An UNDECLARED @-attr whose value is a JSON object is the registered
+            // attr.properties bag — materialize it as that subtype, exactly as the
+            // explicit {"attr.properties": {...}} child form does. The base parser's
+            // value-shape inference knows only scalars and arrays and would store the
+            // bag as a JSON-text STRING attr. Mirrors TS inferUndeclaredAttrSubType.
+            if (isExemptPropertiesAttr(rawValue) && !isDeclaredAttribute(md, attrName)) {
+                MetaAttribute<?> bag = (MetaAttribute<?>) getTypeRegistry().createInstance(
+                    MetaAttribute.TYPE_ATTR,
+                    com.metaobjects.attr.PropertiesAttribute.SUBTYPE_PROPERTIES, attrName);
+                md.addChild(bag);
+                bag.setValueAsString(jsonElementToString(rawValue));
+                tagAttrChildWithJsonSource(md, attrName);
+                continue;
+            }
             // Cross-port: object-valued attrs (e.g. attr.filter) MUST be authored as
             // a JSON object. The legacy form `@filter: "..."` (string-quoted JSON) is
             // rejected here so the loader surfaces ERR_BAD_ATTR_VALUE before the
 
@@ -5,7 +5,7 @@
 from typing import cast
 
 from .errors import ErrorCode, MetaError
-from .meta.core.attr.attr_constants import ATTR_SUBTYPE_STRINGARRAY
+from .meta.core.attr.attr_constants import ATTR_SUBTYPE_PROPERTIES, ATTR_SUBTYPE_STRINGARRAY
 from .meta.meta_data import MetaData
 from .meta.meta_root import MetaRoot
 from .naming_refs import REF_BEARING_ATTR_NAMES, is_relative_ref
@@ -460,6 +460,12 @@ def _build(
                 if schema is not None and schema.is_array
                 else (schema.value_type if schema else None)
             )
+            # An UNDECLARED attr whose value is a JSON object is the registered
+            # `attr.properties` bag, exactly as the explicit
+            # `{"attr.properties": {...}}` child form loads it — so strict-attr
+            # exempts it. Mirrors TS parser-core inferUndeclaredAttrSubType.
+            if schema is None and isinstance(value, dict):
+                attr_sub_type = ATTR_SUBTYPE_PROPERTIES
             node.set_attr(attr_name, value, sub_type=attr_sub_type)
             # FR5a / ADR-0009 — stamp the just-constructed MetaAttribute node with
             # its origin envelope. Mirrors C# Parser.cs:1039 (attrModel.SetSource).