@@ -15,12 +15,10 @@
  */
 package com.metaobjects;
 
-import com.metaobjects.attr.MetaAttribute;
 import com.metaobjects.field.MetaField;
 import com.metaobjects.object.MetaObject;
 import com.metaobjects.registry.MetaDataRegistry;
 import com.metaobjects.validator.MetaValidator;
-import com.metaobjects.view.MetaView;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -97,18 +95,35 @@ public static void registerTypes(MetaDataRegistry registry) {
             if (registry.isRegistered(TYPE_METADATA, SUBTYPE_ROOT)) {
                 return;
             }
+            // FR-033 (sub-step B2b) — metadata.root is the document-root WRAPPER, not
+            // declared in any spec/metamodel/*.json provider file (both this port and
+            // the TS reference HAND-CODE the root; it is the single documented
+            // hand-coded exception to the JSON-sourced model). The manifest's
+            // STRUCTURAL children block must byte-match the cross-port golden:
+            // description "Root metadata document" and EXACTLY the four genuinely-open
+            // structural wildcards a document root legitimately holds — object / field
+            // / validator / template (mirrors the TS reference core-types.ts
+            // `def(TYPE_METADATA, SUBTYPE_ROOT, "Root metadata document",
+            // [wildcard(TYPE_OBJECT), wildcard(TYPE_FIELD), wildcard(TYPE_VALIDATOR),
+            // wildcard(TYPE_TEMPLATE)])`). The previously-registered
+            // view/identity/relationship/layout STRUCTURAL root wildcards are removed
+            // to match the strict contract.
+            //
+            // The any-attr wildcard (attr/"*"/"*") is RETAINED: it is NOT a structural
+            // child (the emitter classifies attr-typed wildcards into the attrs facet,
+            // not the children graph, so root still emits attrs:[] and the four
+            // children — byte-identical to the golden), and the Java loader runtime
+            // legitimately attaches metadata attributes directly to the loader root
+            // node (e.g. document-level attrs via MetaRoot.addMetaAttr). Dropping it
+            // would break that runtime capability without changing the manifest.
             registry.registerType(MetaRoot.class, def -> def
                 .type(TYPE_METADATA).subType(SUBTYPE_ROOT)
-                .description("Root metadata node — tree root produced by MetaDataLoader")
+                .description("Root metadata document")
                 .optionalChild(MetaObject.TYPE_OBJECT, "*", "*")
                 .optionalChild(MetaField.TYPE_FIELD, "*", "*")
-                .optionalChild(MetaAttribute.TYPE_ATTR, "*", "*")
                 .optionalChild(MetaValidator.TYPE_VALIDATOR, "*", "*")
-                .optionalChild(MetaView.TYPE_VIEW, "*", "*")
-                .optionalChild(com.metaobjects.identity.MetaIdentity.TYPE_IDENTITY, "*", "*")
-                .optionalChild(com.metaobjects.relationship.MetaRelationship.TYPE_RELATIONSHIP, "*", "*")
-                .optionalChild(com.metaobjects.layout.MetaLayout.TYPE_LAYOUT, "*", "*")
                 .optionalChild(com.metaobjects.template.TemplateConstants.TYPE_TEMPLATE, "*", "*")
+                .optionalChild(com.metaobjects.attr.MetaAttribute.TYPE_ATTR, "*", "*")
             );
             log.debug("Registered MetaRoot type (metadata.root) with unified registry");
         } catch (Exception e) {
 
@@ -817,6 +817,98 @@ public synchronized void applySpecDescriptions(com.metaobjects.registry.spec.Spe
         // Types NOT declared in the JSON (metadata.root, attr.*, object.managed,
         // the generic view.* controls) keep their existing structural children.
         applyStrictStructuralChildren(reader);
+
+        // Pass 5 (FR-033 B2b) — PRUNE each declared type's LOGICAL (INCLUDED) attr
+        // requirements down to the strict per-subtype allow-list the cross-port
+        // golden carries (sourced from spec/metamodel/*.json, extendsBase- and
+        // extends-composed). Java registers some attrs broadly (e.g. @maxLength /
+        // @storage / @objectRef / @autoSet / @precision / @scale on field.base +
+        // every field subtype, or @discriminator/@discriminatorValue on object.base
+        // inherited by value/projection); the strict graph scopes each to exactly
+        // the subtypes the JSON declares (e.g. @maxLength → field.string only,
+        // @precision/@scale → field.decimal, @storage/@objectRef → field.object,
+        // @autoSet → field.date/time/timestamp, @discriminator* → object.entity).
+        // CARVED-OUT attrs (the classifyPerTypeAttr exclusions — isArray/isAbstract/
+        // extends/implements/isInterface/object/objectAdapter/description) are LEFT
+        // REGISTERED: the emitter drops them from the manifest anyway and the loader
+        // needs them (e.g. an authored `extends:`). Only the INCLUDED logical attrs
+        // are pruned, which also TIGHTENS the loader — a misplaced attr (e.g.
+        // @maxLength on field.boolean) now → ERR_UNKNOWN_ATTR. Types NOT declared in
+        // the JSON keep their attrs untouched (no JSON-sourced strict set exists).
+        applyStrictAttrScoping(reader);
+    }
+
+    /**
+     * FR-033 (sub-step B2b) — Pass 5 of {@link #applySpecDescriptions}. For every
+     * registered {@code (type, subType)} the spec declares, drop every LOGICAL
+     * ({@link RegistryManifest.ExclusionReason#INCLUDED}) attr requirement whose name
+     * is NOT in the strict per-subtype allow-list
+     * ({@link com.metaobjects.registry.spec.SpecMetamodelReader#strictAttrNames}).
+     * Carved-out attrs (structural keywords / native bindings / the per-type
+     * {@code description} dup) are preserved — they are excluded from the manifest by
+     * the emitter and the loader still needs them. Pruning is applied to BOTH the
+     * direct and the inherited attr requirements (the strict set is per-subtype, so a
+     * subtype no longer keeps a broadly-inherited attr the JSON does not scope to it).
+     */
+    private void applyStrictAttrScoping(com.metaobjects.registry.spec.SpecMetamodelReader reader) {
+        for (Map.Entry<MetaDataTypeId, TypeDefinition> entry : new ArrayList<>(typeDefinitions.entrySet())) {
+            MetaDataTypeId id = entry.getKey();
+            TypeDefinition def = entry.getValue();
+
+            if (!reader.isDeclared(id.type(), id.subType())) {
+                continue; // not in the spec → keep Java's existing attr scoping
+            }
+
+            Set<String> allow = reader.strictAttrNames(id.type(), id.subType());
+
+            // Rebuild DIRECT requirements, dropping disallowed INCLUDED attrs.
+            Map<String, ChildRequirement> directReqs = new LinkedHashMap<>();
+            for (ChildRequirement req : def.getDirectChildRequirements()) {
+                if (isPrunableAttr(req) && !allow.contains(req.getName())) {
+                    continue; // logical attr not scoped to this subtype → prune
+                }
+                directReqs.put(directKey(req), req);
+            }
+
+            TypeDefinition rebuilt = new TypeDefinition(
+                    def.getImplementationClass(), id.type(), id.subType(), def.getDescription(),
+                    directReqs, def.getParentType(), def.getParentSubType(),
+                    def.getRules(), def.getExample(), def.getWhenToUse(), def.getParents());
+
+            // Re-populate inherited requirements, dropping disallowed INCLUDED attrs.
+            Map<String, ChildRequirement> inherited = new LinkedHashMap<>();
+            for (Map.Entry<String, ChildRequirement> e : def.getInheritedChildRequirements().entrySet()) {
+                ChildRequirement req = e.getValue();
+                if (isPrunableAttr(req) && !allow.contains(req.getName())) {
+                    continue; // logical attr not scoped to this subtype → prune
+                }
+                inherited.put(e.getKey(), req);
+            }
+            rebuilt.populateInheritedRequirements(inherited);
+
+            typeDefinitions.put(id, rebuilt);
+        }
+    }
+
+    /**
+     * FR-033 (sub-step B2b) — true when a requirement is a NAMED, LOGICAL attr the
+     * strict per-subtype scoping may prune: an {@code attr}-typed requirement with a
+     * concrete (non-wildcard) name that the manifest classifies as
+     * {@link RegistryManifest.ExclusionReason#INCLUDED}. Returns false for the
+     * any-attr wildcard, structural placement rules, and the carved-out attrs
+     * (structural keywords / native bindings / the {@code description} common-attr
+     * dup) — those are left registered.
+     */
+    private static boolean isPrunableAttr(ChildRequirement req) {
+        if (!MetaAttribute.TYPE_ATTR.equals(req.getExpectedType())) {
+            return false; // structural placement rule
+        }
+        String name = req.getName();
+        if (name == null || "*".equals(name)) {
+            return false; // the any-attr wildcard
+        }
+        return RegistryManifest.classifyPerTypeAttr(name)
+                == RegistryManifest.ExclusionReason.INCLUDED;
     }
 
     /**
 
@@ -454,7 +454,7 @@ private static List<ManifestChild> childrenOf(MetaDataRegistry registry, String
             // applySpecDescriptions); emit it (max:null literal when declared-unbounded).
             ManifestChild child = new ManifestChild(childType, childSubType, childName,
                     req.getMin(), req.getMax(), req.getNamed(), req.isMaxNull());
-            String key = childType + "
+            String key = childType + " " + childSubTypeKey(childSubType) + " " + childName;
             byKey.putIfAbsent(key, child);
         }
 
 
@@ -384,7 +384,52 @@ public List<StructChild> structuralChildren(String type, String subType) {
     }
 
     private static String structKey(StructChild c) {
-        return c.childType() + "" + c.childSubType() + "" + c.childName();
+        return c.childType() + " " + c.childSubType() + " " + c.childName();
+    }
+
+    /**
+     * FR-033 (sub-step B2b) — the STRICT per-subtype attr-name allow-list for
+     * {@code (type, subType)}: the set of attr names the cross-port golden scopes to
+     * this subtype. Composed from the shared JSON exactly as TS composes it:
+     * <ul>
+     *   <li>the subtype's OWN {@code types[].children} attr entries, PLUS</li>
+     *   <li>{@code <type>.base}'s attrs when the subtype carries
+     *       {@code extendsBase:true} (the {@code composeWithBase} rule — base attrs
+     *       union own attrs); the base subtype contributes only its own, and</li>
+     *   <li>every {@code extends} block (db/ui/prompt JSON) whose matcher targets
+     *       this {@code (type, subType)} — an exact subType, a list membership, or
+     *       the {@code "*"} wildcard (e.g. db.json's {@code @column} on
+     *       {@code field.*}, {@code @storage} on {@code field.object},
+     *       {@code @autoSet} on {@code field.[date,time,timestamp]}).</li>
+     * </ul>
+     *
+     * <p>This is the loader's strict attr allow-list for the subtype. Callers gate on
+     * {@link #isDeclared} first — an undeclared {@code (type, subType)} (e.g.
+     * {@code metadata.root}, {@code attr.*}, {@code object.managed}) has no
+     * JSON-sourced strict set and must NOT be pruned.</p>
+     */
+    public java.util.Set<String> strictAttrNames(String type, String subType) {
+        java.util.Set<String> names = new java.util.LinkedHashSet<>();
+        Map<String, AttrEntry> own = typeAttrDocs.get(key(type, subType));
+        if (own != null) {
+            names.addAll(own.keySet());
+        }
+        boolean extendsBase = Boolean.TRUE.equals(typeExtendsBase.get(key(type, subType)));
+        if (extendsBase && !BASE_SUBTYPE.equals(subType)) {
+            Map<String, AttrEntry> base = typeAttrDocs.get(key(type, BASE_SUBTYPE));
+            if (base != null) {
+                names.addAll(base.keySet());
+            }
+        }
+        for (ExtendsBlock b : extendsBlocks) {
+            if (!b.type().equals(type)) {
+                continue;
+            }
+            if (b.wildcardSubType() || b.subTypes().contains(subType)) {
+                names.addAll(b.attrs().keySet());
+            }
+        }
+        return names;
     }
 
     /** All registered {@code (type.subType)} keys parsed from the JSON (debug/diagnostics). */
Original file line number	Diff line number	Diff line change
`@@ -454,7 +454,7 @@ private static List<ManifestChild> childrenOf(MetaDataRegistry registry, String`
`454`	`454`	`// applySpecDescriptions); emit it (max:null literal when declared-unbounded).`
`455`	`455`	`ManifestChild child = new ManifestChild(childType, childSubType, childName,`
`456`	`456`	`req.getMin(), req.getMax(), req.getNamed(), req.isMaxNull());`
`457`		`- String key = childType + "`
	`457`	`+ String key = childType + " " + childSubTypeKey(childSubType) + " " + childName;`
`458`	`458`	`byKey.putIfAbsent(key, child);`
`459`	`459`	`}`
`460`	`460`