@@ -1203,20 +1203,28 @@ public void addChild(MetaData data, boolean checkExists)  throws InvalidMetaData
             }
         }
 
-        // v6.0.0: Unified registry validation before adding child
-        MetaDataRegistry registry = MetaDataRegistry.getInstance();
-        if (!registry.acceptsChild(this.getType(), this.getSubType(), 
+        // Resolve the registry from the owning loader so a loader running against
+        // its own typeRegistry (multi-tenant, plugin isolation, tests) validates in
+        // isolation. Falls back to the global singleton for loader-detached nodes —
+        // identical to prior behavior for every consumer that never sets a custom
+        // registry (getTypeRegistry() defaults to getInstance()). See
+        // docs/superpowers/specs/2026-05-29-java-per-loader-registry-design.md.
+        MetaDataLoader owningLoader = getLoader();
+        MetaDataRegistry registry = (owningLoader != null)
+            ? owningLoader.getTypeRegistry()
+            : MetaDataRegistry.getInstance();
+        if (!registry.acceptsChild(this.getType(), this.getSubType(),
                                  data.getType(), data.getSubType(), data.getName())) {
             String supportedChildren = registry.getSupportedChildrenDescription(this.getType(), this.getSubType());
             throw new InvalidMetaDataException(data, String.format(
                 "%s.%s does not accept child '%s' of type %s.%s. %s",
                 this.getType(), this.getSubType(), data.getName(),
                 data.getType(), data.getSubType(), supportedChildren));
         }
-        
-        // v6.0.0: Constraint enforcement during construction
+
+        // Constraint enforcement during construction, against the resolved registry.
         ConstraintEnforcer constraintEnforcer = ConstraintEnforcer.getInstance();
-        constraintEnforcer.enforceConstraintsOnAddChild(this, data);
+        constraintEnforcer.enforceConstraintsOnAddChild(this, data, registry);
 
         data.attachParent(this);
 
 
@@ -62,29 +62,13 @@ public class MetaRoot extends MetaData {
     // Self-registration of the metadata.root type with the unified registry.
     // metadata.root accepts the same top-level children as metadata.base; it is
     // the concrete tree-root produced by MetaDataLoader.
+    // metadata.root self-registers against the singleton on class-load. The same
+    // registration is also wired into the ServiceLoader bootstrap
+    // (CoreTypeMetaDataProvider) so isolated registries created via
+    // MetaDataRegistry.createWithCoreProviders() get it too; the idempotency guard
+    // in registerTypes() makes the two paths safe.
     static {
-        try {
-            MetaDataRegistry.getInstance().registerType(MetaRoot.class, def -> def
-                .type(TYPE_METADATA).subType(SUBTYPE_ROOT)
-                .description("Root metadata node — tree root produced by MetaDataLoader")
-
-                // ROOT LEVEL accepts all top-level metadata types
-                .optionalChild(MetaObject.TYPE_OBJECT, "*", "*")            // Any object type
-                .optionalChild(MetaField.TYPE_FIELD, "*", "*")              // Any field type
-                .optionalChild(MetaAttribute.TYPE_ATTR, "*", "*")           // Any attribute type
-                .optionalChild(MetaValidator.TYPE_VALIDATOR, "*", "*")      // Any validator type
-                .optionalChild(MetaView.TYPE_VIEW, "*", "*")                // Any view type
-                .optionalChild(com.metaobjects.identity.MetaIdentity.TYPE_IDENTITY, "*", "*")        // Any identity type
-                .optionalChild(com.metaobjects.relationship.MetaRelationship.TYPE_RELATIONSHIP, "*", "*") // Any relationship type
-                .optionalChild(com.metaobjects.layout.MetaLayout.TYPE_LAYOUT, "*", "*")  // Any layout type (root-level shared layouts)
-                .optionalChild(com.metaobjects.template.TemplateConstants.TYPE_TEMPLATE, "*", "*") // Any template type (FR-004)
-            );
-            // ADR-0006 Rule 1 — bare `metadata:` YAML key fuses to `metadata.root`.
-            MetaDataRegistry.getInstance().setDefaultSubType(TYPE_METADATA, SUBTYPE_ROOT);
-            log.debug("Registered MetaRoot type (metadata.root) with unified registry");
-        } catch (Exception e) {
-            log.error("Failed to register MetaRoot type with unified registry", e);
-        }
+        registerTypes(MetaDataRegistry.getInstance());
     }
 
     /**
@@ -96,6 +80,12 @@ public class MetaRoot extends MetaData {
      */
     public static void registerTypes(MetaDataRegistry registry) {
         try {
+            // Idempotent: the static block (singleton) and the ServiceLoader
+            // bootstrap (CoreTypeMetaDataProvider, for isolated registries) both
+            // call this; skip if metadata.root is already registered.
+            if (registry.isRegistered(TYPE_METADATA, SUBTYPE_ROOT)) {
+                return;
+            }
             registry.registerType(MetaRoot.class, def -> def
                 .type(TYPE_METADATA).subType(SUBTYPE_ROOT)
                 .description("Root metadata node — tree root produced by MetaDataLoader")
@@ -109,6 +99,9 @@ public static void registerTypes(MetaDataRegistry registry) {
                 .optionalChild(com.metaobjects.layout.MetaLayout.TYPE_LAYOUT, "*", "*")
                 .optionalChild(com.metaobjects.template.TemplateConstants.TYPE_TEMPLATE, "*", "*")
             );
+            // ADR-0006 Rule 1 — bare `metadata:` YAML key fuses to `metadata.root`.
+            registry.setDefaultSubType(TYPE_METADATA, SUBTYPE_ROOT);
+            log.debug("Registered MetaRoot type (metadata.root) with unified registry");
         } catch (Exception e) {
             log.error("Failed to register MetaRoot type with unified registry", e);
         }
 
@@ -66,12 +66,28 @@ public static ConstraintEnforcer getInstance() {
      * @throws ConstraintViolationException If constraints are violated
      */
     public void enforceConstraintsOnAddChild(MetaData parent, MetaData child) throws ConstraintViolationException {
+        // Default registry-bound path (preserves all existing callers).
+        enforceConstraintsOnAddChild(parent, child, this.metaDataRegistry);
+    }
+
+    /**
+     * Registry-parameterized enforcement: reads constraints from the supplied
+     * registry instead of the enforcer's singleton-bound one. Used when a loader
+     * runs against its own {@code typeRegistry} (multi-loader isolation).
+     *
+     * @param parent   the parent metadata object
+     * @param child    the child being added
+     * @param registry the registry whose validation constraints to enforce
+     * @throws ConstraintViolationException If constraints are violated
+     */
+    public void enforceConstraintsOnAddChild(MetaData parent, MetaData child,
+                                             MetaDataRegistry registry) throws ConstraintViolationException {
         if (!isConstraintCheckingEnabled(parent)) {
             return;
         }
-        
+
         // UNIFIED: Single enforcement path for all constraints
-        List<Constraint> allConstraints = metaDataRegistry.getAllValidationConstraints();
+        List<Constraint> allConstraints = registry.getAllValidationConstraints();
 
         if (allConstraints.isEmpty()) {
             log.trace("No constraints registered - allowing operation");
 
@@ -1,6 +1,7 @@
 package com.metaobjects.core;
 
 import com.metaobjects.MetaData;
+import com.metaobjects.MetaRoot;
 import com.metaobjects.registry.MetaDataRegistry;
 import com.metaobjects.registry.MetaDataTypeProvider;
 import org.slf4j.Logger;
@@ -32,6 +33,10 @@ public class CoreTypeMetaDataProvider implements MetaDataTypeProvider {
     public void registerTypes(MetaDataRegistry registry) {
         // Register the fundamental metadata.base type that all others inherit from
         MetaData.registerTypes(registry);
+        // Register the concrete tree-root type (metadata.root) onto the SAME
+        // registry — so isolated registries (createWithCoreProviders) get it too,
+        // not just the singleton via MetaRoot's static block. Idempotent.
+        MetaRoot.registerTypes(registry);
 
         log.debug("Core base types registered via provider");
     }
 
@@ -281,12 +281,17 @@ private static void runConformanceChecks(FixtureDiscovery.Fixture fix,
 
         LoaderOptions opts = LoaderOptions.create(false, false, true);
         MetaDataLoader loader = new MetaDataLoader(opts, MetaDataLoader.SUBTYPE_MANUAL, loaderName);
-        // Lazy-register the test-only template.briefing subtype into the
-        // singleton on first encounter. See {@link #ensureBriefingRegistered}
-        // for the alphabetical-ordering rationale that keeps this safe.
+        // A fixture that requires the test-only example-template-briefing provider
+        // gets its OWN registry (core + briefing) via setTypeRegistry — no global
+        // singleton mutation, so the success/fail provider-extension pair is
+        // order-independent and isolated. See PerLoaderRegistryTest and
+        // docs/superpowers/specs/2026-05-29-java-per-loader-registry-design.md.
         if (fix.hasProvidersJson
                 && fix.requiredProviders.contains("example-template-briefing")) {
-            ensureBriefingRegistered();
+            com.metaobjects.registry.MetaDataRegistry fixtureRegistry =
+                com.metaobjects.registry.MetaDataRegistry.createWithCoreProviders();
+            ConformanceTestProviders.BriefingTemplate.registerTypes(fixtureRegistry);
+            loader.setTypeRegistry(fixtureRegistry);
         }
         loader.init();
 
@@ -667,34 +672,6 @@ private static Set<String> discoverAvailableProviders() {
         return Collections.unmodifiableSet(ids);
     }
 
-    /**
-     * Lazy, idempotent in-place registration of the test-only
-     * {@code template.briefing} subtype into the default singleton registry.
-     *
-     * <p>The architectural constraint: {@link com.metaobjects.MetaData#addChild}
-     * validates against {@link com.metaobjects.registry.MetaDataRegistry#getInstance()}
-     * hardcoded, so a per-fixture custom registry on the loader is not consulted
-     * for child-acceptance checks. The only way to make a test subtype visible
-     * to the validator is to register it into the singleton.</p>
-     *
-     * <p>That contaminates the singleton for any later fixture that expects
-     * the same subtype to be unknown. We rely on alphabetical fixture order
-     * to keep this safe: {@code provider-extension-missing-provider-fails}
-     * (which requires briefing to NOT be registered) sorts BEFORE
-     * {@code provider-extension-new-subtype-success} (which requires it to BE
-     * registered). The fail-fixture runs first, sees briefing absent, asserts
-     * ERR_UNKNOWN_SUBTYPE; then the success fixture lazy-registers briefing
-     * via this method and proceeds.</p>
-     */
-    private static volatile boolean briefingRegistered = false;
-    private static synchronized void ensureBriefingRegistered() {
-        if (!briefingRegistered) {
-            ConformanceTestProviders.BriefingTemplate.registerTypes(
-                com.metaobjects.registry.MetaDataRegistry.getInstance());
-            briefingRegistered = true;
-        }
-    }
-
     /** Cross-port envelope record for the Java conformance runner. */
     private static final class EnvelopeRecord {
         final String code;
 
@@ -0,0 +1,90 @@
+package com.metaobjects.conformance;
+
+import com.metaobjects.MetaDataException;
+import com.metaobjects.loader.InMemoryStringSource;
+import com.metaobjects.loader.LoaderOptions;
+import com.metaobjects.loader.MetaDataLoader;
+import com.metaobjects.loader.MetaDataSource;
+import com.metaobjects.registry.MetaDataRegistry;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Proves two loaders with different type registries in one JVM validate
+ * independently (per-loader-registry design, success-criterion #3). A loader
+ * whose registry knows {@code template.briefing} accepts it; a loader whose
+ * registry does not rejects it — regardless of construction order, with no
+ * global-singleton contamination.
+ */
+public class PerLoaderRegistryTest {
+
+    // Structurally-valid canonical metadata declaring a template.briefing node
+    // (mirrors fixtures/conformance/provider-extension-new-subtype-success input:
+    // briefing requires @payloadRef -> an object.value, plus @author/@recipient).
+    private static final String META =
+        "{ \"metadata.root\": { \"package\": \"examples\", \"children\": ["
+        + "  { \"object.value\": { \"name\": \"BriefingNotes\", \"children\": ["
+        + "      { \"field.string\": { \"name\": \"summary\" } },"
+        + "      { \"field.string\": { \"name\": \"context\" } }"
+        + "  ] } },"
+        + "  { \"template.briefing\": { \"name\": \"DailyBriefing\","
+        + "      \"@payloadRef\": \"BriefingNotes\","
+        + "      \"@author\": \"Lorekeeper\", \"@recipient\": \"Council\" } }"
+        + "] } }";
+
+    private static MetaDataLoader newLoader(String name, MetaDataRegistry reg) {
+        LoaderOptions opts = LoaderOptions.create(false, false, true);
+        MetaDataLoader loader = new MetaDataLoader(opts, MetaDataLoader.SUBTYPE_MANUAL, name);
+        loader.setTypeRegistry(reg);
+        loader.init();
+        return loader;
+    }
+
+    private static void load(MetaDataLoader loader) {
+        loader.load(List.<MetaDataSource>of(new InMemoryStringSource(META, "meta.t.json")));
+    }
+
+    /** Registry WITH briefing -> load succeeds (must not throw). */
+    private static void assertAccepts(MetaDataRegistry reg) {
+        load(newLoader("with-briefing", reg));
+    }
+
+    /** Registry WITHOUT briefing -> load fails (unknown subtype / not accepted). */
+    private static void assertRejects(MetaDataRegistry reg) {
+        try {
+            load(newLoader("without-briefing", reg));
+            fail("expected load to fail: template.briefing is unknown in this registry");
+        } catch (MetaDataException expected) {
+            String m = String.valueOf(expected.getMessage());
+            assertTrue("expected an unknown-subtype/not-accepted failure, got: " + m,
+                m.contains("UNKNOWN_SUBTYPE")
+                || m.contains("does not accept child")
+                || m.contains("briefing"));
+        }
+    }
+
+    @Test
+    public void twoLoadersValidateIndependently_withFirst() {
+        MetaDataRegistry withBriefing = MetaDataRegistry.createWithCoreProviders();
+        ConformanceTestProviders.BriefingTemplate.registerTypes(withBriefing);
+        MetaDataRegistry withoutBriefing = MetaDataRegistry.createWithCoreProviders();
+
+        assertAccepts(withBriefing);
+        assertRejects(withoutBriefing);
+    }
+
+    @Test
+    public void twoLoadersValidateIndependently_withoutFirst() {
+        // Reverse order: proves no ordering dependency / no global contamination.
+        MetaDataRegistry withoutBriefing = MetaDataRegistry.createWithCoreProviders();
+        MetaDataRegistry withBriefing = MetaDataRegistry.createWithCoreProviders();
+        ConformanceTestProviders.BriefingTemplate.registerTypes(withBriefing);
+
+        assertRejects(withoutBriefing);
+        assertAccepts(withBriefing);
+    }
+}