feat(java): add MetaDataLoader.fromDirectory/fromUris/fromString factories

Unified cross-language factories matching TS/C#/Python. Each factory
constructs a fresh loader via createManual(false, name), runs init() →
load(sources) → register() in the canonical pipeline order, and wraps
any failure as MetaDataLoadingException with phase context.

fromResources(name, List<String>) also added for classpath-resource
loading parity (replaces createFromResources).

The deprecated createFromURIs / createFromResources aliases remain
temporarily; they are removed in the subsequent FileMetaDataLoader
retirement commit.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: dmealing

server/java/metadata/src/main/java/com/metaobjects/loader/MetaDataLoader.java

@@ -26,11 +26,13 @@
 import java.io.InputStream;
 import java.net.URI;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
@@ -214,6 +216,112 @@ public static MetaDataLoader createFromResources(String name, List<String> resou
         return createFromURIs(name, uris);
     }
 
+    ///////////////////////////////////////////////////////////////////////
+    // Unified static factories (cross-language consistent — see TS / C# / Python)
+
+    /**
+     * Build a {@link DirectorySource} for the given path and load all files
+     * in deterministic order. Convenience for the 99% case.
+     *
+     * @param name      the loader name
+     * @param directory the directory containing metadata files
+     * @return a fully-initialized loader with all directory files loaded
+     */
+    public static MetaDataLoader fromDirectory(String name, Path directory) {
+        return fromDirectory(name, directory, new DirectorySource.Options());
+    }
+
+    /**
+     * Build a {@link DirectorySource} for the given path with the supplied
+     * options and load all matching files.
+     *
+     * @param name      the loader name
+     * @param directory the directory containing metadata files
+     * @param opts      expansion options (exclude list, recursion)
+     * @return a fully-initialized loader with all directory files loaded
+     */
+    public static MetaDataLoader fromDirectory(String name, Path directory, DirectorySource.Options opts) {
+        MetaDataLoader loader = createManual(false, name);
+        try {
+            loader.init();
+            List<MetaDataSource> sources = new DirectorySource(directory, opts).expandToList();
+            loader.load(sources);
+            loader.register();
+        } catch (MetaDataLoadingException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new MetaDataLoadingException(
+                "Failed to load from directory " + directory, name,
+                loader.getLoadingState().getCurrentPhase(), 0, e);
+        }
+        return loader;
+    }
+
+    /**
+     * Build {@link UriSource}s and load them. Replaces the deprecated
+     * {@link #createFromURIs(String, List)} alias.
+     *
+     * @param name the loader name
+     * @param uris model URIs to load
+     * @return a fully-initialized loader with all URIs loaded
+     */
+    public static MetaDataLoader fromUris(String name, List<URI> uris) {
+        MetaDataLoader loader = createManual(false, name);
+        try {
+            loader.init();
+            List<MetaDataSource> sources = uris.stream()
+                .map(uri -> (MetaDataSource) new UriSource(uri))
+                .collect(Collectors.toList());
+            loader.load(sources);
+            loader.register();
+        } catch (MetaDataLoadingException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new MetaDataLoadingException(
+                "Failed to load from URIs", name,
+                loader.getLoadingState().getCurrentPhase(), 0, e);
+        }
+        return loader;
+    }
+
+    /**
+     * Load a list of classpath resource paths. Each path is wrapped as a
+     * {@code model:resource:<path>} URI and routed through {@link #fromUris(String, List)}.
+     *
+     * @param name      the loader name
+     * @param resources classpath resource paths (no {@code model:} prefix needed)
+     * @return a fully-initialized loader with all resources loaded
+     */
+    public static MetaDataLoader fromResources(String name, List<String> resources) {
+        List<URI> uris = new ArrayList<>();
+        for (String r : resources) uris.add(URIHelper.toURI("model:resource:" + r));
+        return fromUris(name, uris);
+    }
+
+    /**
+     * Load a single in-memory string of the given format.
+     *
+     * @param name    the loader name
+     * @param content the raw document content
+     * @param format  the document format
+     * @return a fully-initialized loader with the inline content loaded
+     */
+    public static MetaDataLoader fromString(String name, String content, MetaDataSource.MetaDataFormat format) {
+        MetaDataLoader loader = createManual(false, name);
+        try {
+            loader.init();
+            loader.load(List.of(new InMemoryStringSource(content, "<inline>", format)));
+            loader.register();
+        } catch (MetaDataLoadingException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new MetaDataLoadingException(
+                "Failed to load from string", name,
+                loader.getLoadingState().getCurrentPhase(), 0, e);
+        }
+        return loader;
+    }
+
     ///////////////////////////////////////////////////////////////////////
     // Identity
 

server/java/metadata/src/test/java/com/metaobjects/loader/MetaDataLoaderFactoryTest.java

@@ -0,0 +1,42 @@
+package com.metaobjects.loader;
+
+import com.metaobjects.registry.SharedRegistryTestBase;
+import org.junit.Test;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import static org.junit.Assert.*;
+
+/**
+ * Tests for the unified static factories on {@link MetaDataLoader}:
+ * {@link MetaDataLoader#fromDirectory(String, Path)},
+ * {@link MetaDataLoader#fromUris(String, java.util.List)},
+ * {@link MetaDataLoader#fromString(String, String, MetaDataSource.MetaDataFormat)}.
+ *
+ * <p>These factories supersede the deprecated {@code createFromURIs} /
+ * {@code createFromResources} pair and match the cross-language convention
+ * (TS/C#/Python all expose the same shape).</p>
+ */
+public class MetaDataLoaderFactoryTest extends SharedRegistryTestBase {
+
+    @Test public void fromDirectoryLoadsCanonicalJson() throws IOException {
+        Path dir = Files.createTempDirectory("mdl-");
+        Path file = dir.resolve("meta.tiny.json");
+        Files.writeString(file, "{\"metadata.root\":{\"package\":\"x\",\"children\":[]}}");
+        try {
+            MetaDataLoader loader = MetaDataLoader.fromDirectory("factoryTestDir", dir);
+            assertNotNull(loader.getRoot());
+        } finally {
+            Files.deleteIfExists(file);
+            Files.deleteIfExists(dir);
+        }
+    }
+
+    @Test public void fromStringLoadsInlineJson() {
+        MetaDataLoader loader = MetaDataLoader.fromString(
+            "factoryTestString",
+            "{\"metadata.root\":{\"package\":\"x\",\"children\":[]}}",
+            MetaDataSource.MetaDataFormat.JSON);
+        assertNotNull(loader.getRoot());
+    }
+}