@@ -129,6 +129,40 @@ preserved the wire shape exactly. Everything below is what went wrong on the way
   `"type": "commonjs"` explicitly — false on the dominant first-touch path. (Introduced by
   `0.24.4`'s own fix to that same line, which corrected the tense and got the premise wrong.)
 
+### Fixed — two ports scattering or skipping work while reporting success (Maven, NuGet)
+
+Found the same way as the eight above, by a different exercise: generating ONE small model
+with every port, from the repo root, to build the corpus the website publishes as real
+`meta gen` output. Both are the shape this release keeps finding — a tool saying something
+untrue about work it had just done.
+
+- **Java/Kotlin: `<loader><sourceDir>` with no `<sources>` loaded NOTHING, ran the
+  generators against an empty model, wrote zero files, and reported `BUILD SUCCESS`.**
+  The precedence ladder consults the port-neutral config only when the pom names *neither*
+  key — naming either means the pom owns the concern — so `<sourceDir>` alone took the
+  pom-owns-it branch with an empty source list. That is the shape the shipped adopter
+  guidance teaches, and it is also the remedy `0.24.0`'s own `ERR_COLLECTION_NOT_FOUND`
+  prints (*"declare `<sourceDir>`/`<sources>` explicitly"*), so following the fix for a
+  silently-empty model put you back into one. A directory now expands through the SAME
+  `DirectorySource` walk the loader itself uses for a directory source, so "which files
+  count as metadata" keeps one definition; a `<sourceDir>` that exists but holds no
+  metadata is `ERR_COLLECTION_NOT_FOUND` rather than an empty model, since reaching the
+  expensive outcome by a different road is still the expensive outcome. A nonexistent
+  `<sourceDir>` already failed and still does. **Purely additive** — a pom naming
+  `<sources>`, or naming neither, is unaffected.
+- **C#: `dotnet meta gen` anchored `.gen-state/.hashes.json` on the process working
+  directory**, so generating from anywhere but the project root wrote a stray
+  `.metaobjects/` into the caller's cwd and left the real project with no record of what
+  was written — the entire reason that manifest is committed. The Python port already
+  anchors on the metadata dir's parent and its docstring says why. The C# **test assembly
+  had been doing this into its own `bin/`** for as long as the manifest has existed,
+  invisible because `bin/` is ignored, and worse than untidy: every test in the assembly
+  then shared ONE manifest keyed by bare filename — precisely the collision that docstring
+  warns about. An explicit `<metadataDir>` now anchors on its parent; with it omitted the
+  `.metaobjects/config.json` ladder has already resolved relative to cwd, so cwd is the
+  project. **Not a behaviour change for the documented invocation** — only the
+  cwd-is-not-the-project case moves, and that case was broken.
+
 
 ## [0.24.4] — 2026-08-28
 
 
@@ -48,11 +48,14 @@
         <artifactId>metaobjects-maven-plugin</artifactId>
         <version>${metaobjects.version}</version>
         <configuration>
+          <!-- <sourceDir> with no <sources> is the documented shape: a directory
+               names a directory, and the plugin expands it. Needs the plugin at or
+               after the version that made that true — before it, naming <sourceDir>
+               alone loaded nothing, ran the generators against an empty model and
+               reported BUILD SUCCESS. `bun scripts/regen-showcase.ts` fails loudly
+               on that now rather than emptying the committed trees. -->
           <loader>
             <sourceDir>../metaobjects</sourceDir>
-            <sources>
-              <source>meta.subscriber.yaml</source>
-            </sources>
           </loader>
           <generators>
             <generator>
 
@@ -211,6 +211,17 @@ function selectPorts(): Port[] {
 function generateInto(project: string, ports: Port[]): void {
   for (const p of ports) {
     p.generate(project);
+    // A generator that wrote nothing and exited 0 is the failure this whole corpus
+    // exists to catch, and it is not hypothetical: the Maven plugin ran both JVM
+    // generators against an empty model, wrote zero files, and reported BUILD
+    // SUCCESS. In write mode that would silently EMPTY a committed tree, and `✓`
+    // would still print. A port that produced nothing did not succeed.
+    const empty = p.dirs.filter((d) => listFiles(join(project, "generated", d)).length === 0);
+    if (empty.length) {
+      throw new Error(
+        `${p.name} exited 0 but wrote no files to ${empty.map((d) => `generated/${d}`).join(", ")}`,
+      );
+    }
     console.log(`  ✓ ${p.name}`);
   }
 }
 
@@ -270,6 +270,22 @@ protected MetaDataLoader createLoader(ClassLoader projectClassLoader) {
         List<String> neutralSources = resolveNeutralSourcesIfPomIsSilent(loaderConfig);
         if (!neutralSources.isEmpty()) {
             sources = neutralSources;
+        } else if ((sources == null || sources.isEmpty()) && srcDir != null) {
+            // <sourceDir> alone. The ladder above deliberately does not fire here —
+            // naming EITHER key means the pom owns the concern — which used to leave
+            // this branch with an empty source list: the generators ran against an
+            // empty model, wrote zero files, and the build reported SUCCESS.
+            //
+            // That is the shape the adopter guidance teaches, and it is also the
+            // remedy 0.24.0's own ERR_COLLECTION_NOT_FOUND prints ("declare
+            // <sourceDir>/<sources> explicitly"), so following the fix for a silent
+            // empty model landed you back in one. A directory names a directory:
+            // expand it, through the SAME DirectorySource walk the loader itself uses
+            // (via SourceResolver), so "which files count as metadata" keeps one
+            // definition. The sourceDir base is dropped because the expansion is
+            // already absolute.
+            sources = expandSourceDir(srcDir);
+            sourceDir = null;
         }
 
         // An unknown <library> name is a HARD failure naming the ones this version ships,
@@ -534,6 +550,37 @@ protected File getProjectBaseDir() {
      *     either {@code <sourceDir>} or {@code <sources>} (i.e. the neutral file is
      *     not consulted at all)
      */
+    /**
+     * Expand a {@code <loader><sourceDir>} that carries no {@code <sources>} into the
+     * metadata files it holds.
+     *
+     * <p>Delegates to {@link com.metaobjects.config.SourceResolver}, so the extension
+     * filter and ordering are {@code DirectorySource}'s — the same walk the loader
+     * performs for a directory source, rather than a second definition of what counts
+     * as metadata.
+     *
+     * <p>A directory holding NOTHING is a failure, not an empty model. The whole point
+     * of this branch is that generating zero files while reporting success is the
+     * expensive outcome, and an empty directory reaches it by a different road than an
+     * unnamed one.
+     */
+    protected List<String> expandSourceDir(File srcDir) {
+        Path dir = srcDir.getAbsoluteFile().toPath().normalize();
+        List<String> expanded = com.metaobjects.config.SourceResolver
+                .resolveSources(getProjectBaseDir().toPath(),
+                        List.of(java.util.Map.of("path", dir.toString())))
+                .stream()
+                .map(p -> "model:file:" + p.toString().replace(java.io.File.separatorChar, '/'))
+                .toList();
+        if (expanded.isEmpty()) {
+            throw new MetaDataException(
+                    "<loader><sourceDir> " + dir + " holds no metadata files. Point it at a "
+                            + "directory containing metadata, or name the files with <sources>.",
+                    ErrorCode.ERR_COLLECTION_NOT_FOUND);
+        }
+        return expanded;
+    }
+
     protected List<String> resolveNeutralSourcesIfPomIsSilent(LoaderParam loaderConfig) {
         boolean pomNamesLocation =
                 (loaderConfig.getSourceDir() != null && !loaderConfig.getSourceDir().isBlank())
 
@@ -0,0 +1,144 @@
+package com.metaobjects.mojo;
+
+import com.metaobjects.MetaDataException;
+import com.metaobjects.loader.MetaDataLoader;
+import org.apache.maven.project.MavenProject;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * A {@code <loader>} naming {@code <sourceDir>} and NOTHING else must load that
+ * directory's metadata.
+ *
+ * <p>It used to load nothing at all — and say nothing about it. The precedence
+ * ladder consults the port-neutral config only when the pom names NEITHER
+ * {@code <sourceDir>} nor {@code <sources>}, so naming {@code <sourceDir>} alone
+ * took the pom-owns-the-concern branch with an empty source list: the generators
+ * ran against an empty model, wrote zero files, and the build reported SUCCESS.
+ *
+ * <p>Which matters because {@code <sourceDir>} alone is exactly what the shipped
+ * adopter guidance teaches, and it is also the remedy 0.24.0's own
+ * {@code ERR_COLLECTION_NOT_FOUND} prints ("declare {@code <sourceDir>}/{@code
+ * <sources>} explicitly") — so following the fix for the silent-empty model put
+ * you straight back into a silent-empty model.
+ *
+ * <p>Two neighbouring cases are pinned alongside it, because the fix makes this
+ * branch tolerant and both are ways it could go quiet again: a {@code <sourceDir>}
+ * that does not exist (already loud, an {@code IllegalArgumentException} naming the
+ * path), and one that exists but holds no metadata at all.
+ *
+ * <p>Paths here are ABSOLUTE on purpose — {@code <sourceDir>} resolves against the
+ * process working directory, not the module basedir, so a relative path in a test
+ * would be measuring the runner's cwd rather than the mojo.
+ */
+public class SourceDirWithoutSourcesTest {
+
+    private static final String WIDGET_JSON = """
+            {
+              "metadata.root": {
+                "package": "sourcedir::only",
+                "children": [
+                  { "object.entity": { "name": "Widget", "children": [
+                    { "field.long": { "name": "id" } }
+                  ] } }
+                ]
+              }
+            }
+            """;
+
+    /** A pom naming <sourceDir> and no <sources> — the documented shape. */
+    private MetaDataGeneratorMojo mojoWithSourceDirOnly(Path basedir, String sourceDir) {
+        MavenProject mavenProject = Mockito.mock(MavenProject.class);
+        Mockito.when(mavenProject.getBasedir()).thenReturn(basedir.toFile());
+
+        MetaDataGeneratorMojo mojo = new MetaDataGeneratorMojo();
+        mojo.project = mavenProject;
+        mojo.setLoader(LoaderParam.builder("sourcedir-only-test")
+                .withClassname("com.metaobjects.loader.MetaDataLoader")
+                .withSourceDir(sourceDir)
+                .build());
+        mojo.setGenerators(Collections.emptyList());
+        mojo.setGlobals(Collections.emptyMap());
+        return mojo;
+    }
+
+    @Test
+    public void sourceDirAloneLoadsThatDirectorysMetadata() throws IOException {
+        Path root = Files.createTempDirectory("mo-mojo-srcdir-").toAbsolutePath().normalize();
+        try {
+            Path metaDir = root.resolve("src/main/metaobjects");
+            Files.createDirectories(metaDir);
+            Files.write(metaDir.resolve("meta.widget.json"), WIDGET_JSON.getBytes(StandardCharsets.UTF_8));
+
+            MetaDataGeneratorMojo mojo = mojoWithSourceDirOnly(root, metaDir.toString());
+            MetaDataLoader loaded = mojo.createLoader(mojo.createProjectClassLoader());
+
+            assertEquals("a <sourceDir> with no <sources> must load the directory, not nothing",
+                    1, loaded.getMetaObjects().size());
+            assertEquals("Widget", loaded.getMetaObjects().get(0).getShortName());
+        } finally {
+            deleteRecursive(root);
+        }
+    }
+
+    @Test
+    public void aSourceDirThatDoesNotExistFailsRatherThanLoadingNothing() throws IOException {
+        Path root = Files.createTempDirectory("mo-mojo-srcdir-missing-").toAbsolutePath().normalize();
+        Path typo = root.resolve("src/main/typo");
+        try {
+            MetaDataGeneratorMojo mojo = mojoWithSourceDirOnly(root, typo.toString());
+            try {
+                MetaDataLoader loaded = mojo.createLoader(mojo.createProjectClassLoader());
+                fail("expected a failure naming the missing directory, got a loader with "
+                        + loaded.getMetaObjects().size() + " object(s)");
+            } catch (RuntimeException expected) {
+                assertTrue("the message must name the path that did not resolve, got: "
+                                + expected.getMessage(),
+                        expected.getMessage().contains(typo.toString()));
+            }
+        } finally {
+            deleteRecursive(root);
+        }
+    }
+
+    @Test
+    public void aSourceDirHoldingNoMetadataFailsRatherThanLoadingNothing() throws IOException {
+        Path root = Files.createTempDirectory("mo-mojo-srcdir-empty-").toAbsolutePath().normalize();
+        try {
+            Path metaDir = root.resolve("src/main/metaobjects");
+            Files.createDirectories(metaDir);
+
+            MetaDataGeneratorMojo mojo = mojoWithSourceDirOnly(root, metaDir.toString());
+            try {
+                MetaDataLoader loaded = mojo.createLoader(mojo.createProjectClassLoader());
+                fail("expected a failure naming the empty directory, got a loader with "
+                        + loaded.getMetaObjects().size() + " object(s)");
+            } catch (MetaDataException expected) {
+                assertTrue("the message must name the directory that held nothing, got: "
+                                + expected.getMessage(),
+                        expected.getMessage().contains(metaDir.toString()));
+            }
+        } finally {
+            deleteRecursive(root);
+        }
+    }
+
+    private static void deleteRecursive(Path root) throws IOException {
+        if (!Files.exists(root)) return;
+        try (Stream<Path> walk = Files.walk(root)) {
+            walk.sorted(Comparator.reverseOrder()).forEach(p -> p.toFile().delete());
+        }
+    }
+}