From d0768017018aab471336565b97ed7e91daf4ee46 Mon Sep 17 00:00:00 2001
From: KernelPanic <aaronkoonce25@gmail.com>
Date: Fri, 28 Aug 2026 16:06:07 -0400
Subject: [PATCH 1/5] chore(build): bump Gradle to 9.7.1

Prerequisite for adding Stonecutter, which refuses to apply below
Gradle 9 (checked directly: 0.8.4, 0.9.1, and 0.9.7 all reject 8.x).
Verified clean on 9.7.1 first - full compile, unit tests, and the
whole task graph (Loom, Architectury, Dokka, ModFusioner, ModPublisher,
Shadow, the actualizer/archie plugins) all configure and run across
every module with no changes beyond the two below.

- Gradle 9 stopped bundling its own JUnit Platform launcher for
  useJUnitPlatform() - added junit-platform-launcher to the catalog
  and wired it once as testRuntimeOnly in the shared subprojects{}
  dependencies block.
- core/common's verifyGuiSpriteAssets task used the `by registering {}`
  delegate, deprecated in 9.6 and removed in 10 - switched to
  `register("...")`.

architectury-loom's pinned version also now reads 1.17.491 instead of
1.13.469 in gradle/libs.versions.toml. This wasn't a deliberate edit -
noticed the file already showed 1.17.491 when checked, with no edit
made by this work to explain it. Left as-is since it's what actually
resolved and ran successfully throughout verification, but flagging it
since its cause is unexplained.
---
 build.gradle.kts                         | 4 ++++
 core/common/build.gradle.kts             | 2 +-
 gradle/libs.versions.toml                | 3 ++-
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 4 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 9bf320bec..7aaf5e1c5 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -115,6 +115,10 @@ subprojects {
 		})
 
 		compileOnly("org.jetbrains:annotations:24.1.0")
+
+		// Gradle 9 stopped bundling its own copy of the JUnit Platform launcher for
+		// useJUnitPlatform() - every module needs this on the test runtime classpath now.
+		"testRuntimeOnly"(rootProject.libs.junit.platform.launcher)
 	}
 
 	// One MavenPublication per module, published to kernelpanicsoft.net's Reposilite - archie-core/
diff --git a/core/common/build.gradle.kts b/core/common/build.gradle.kts
index 6bb4f71fb..fbecbe5df 100644
--- a/core/common/build.gradle.kts
+++ b/core/common/build.gradle.kts
@@ -61,7 +61,7 @@ dependencies {
 tasks {
 	base.archivesName.set(base.archivesName.get() + "-common")
 
-	val verifyGuiSpriteAssets by registering {
+	val verifyGuiSpriteAssets = register("verifyGuiSpriteAssets") {
 		group = "verification"
 		description = "Verifies GUI sprite metadata files have matching PNG assets."
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c9f00784d..bae881017 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -18,7 +18,7 @@ parchment = "2024.11.17"
 
 architectury = "13.0.8"
 architectury-plugin = { require = "[3.4, 3.5[" }
-architectury-loom = { require = "1.13.469" }
+architectury-loom = { require = "1.17.491" }
 architectury-kotlin = "2.0.0"
 
 modfusioner = "1.0.12"
@@ -124,6 +124,7 @@ neoforge = { module = "net.neoforged:neoforge", version.ref = "neoforge" }
 modmenu = { module = "com.terraformersmc:modmenu", version.ref = "modmenu" }
 junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit" }
 junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" }
+junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher", version.ref = "junit-platform" }
 
 [plugins]
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index cea7a793a..c42672d95 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.7.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

From 7c017f3e91b1c8b7b57e6875497304e6aa720e7e Mon Sep 17 00:00:00 2001
From: KernelPanic <aaronkoonce25@gmail.com>
Date: Fri, 28 Aug 2026 18:18:49 -0400
Subject: [PATCH 2/5] feat(build): migrate core to Stonecutter (validation
 slice)

Converts core/{common,fabric,neoforge} to a Stonecutter-managed tree/branch
structure (settings.gradle.kts: stonecutter { create("core") { branch(...) } }),
keeping datagen/gametest/test on the old includeModule() scheme until this
slice is proven out.

Root build.gradle.kts guards subprojects{}/allprojects{} plugin application
against Stonecutter's synthetic tree/branch container projects (:core,
:core:common, etc. - real leaf projects nest under them and must not get
build plugins applied directly).

Sibling-project references (fabric/neoforge -> common) go through Stonecutter's
node.sibling("common").project API rather than a hardcoded project path -
ProjectNode.project resolves straight to the sibling's Gradle Project.

The old namedElements/transformProductionX cross-project dependency (Loom's
own common() mechanism) produces a circular task dependency under Stonecutter's
nested per-version project paths, so fabric/neoforge instead depend directly
on common's own "jar" task output as a FileCollection. (A plain SourceSetOutput
FileCollection almost works the same way, but breaks shadowJar - Shadow's copy
action expects zip-safe entries, not raw class/resource directories.)

Also bumps the Shadow plugin from com.github.johnrengelman.shadow 8.1.1 to the
maintained com.gradleup.shadow 9.6.1 fork - the old one is incompatible with
Gradle 9.7.1 (MissingPropertyException: mode in ShadowCopyAction), independent
of the Stonecutter migration itself.

Disables the background-session worktree-isolation guard for this repo
(.claude/settings.json) at the user's request.

Verified: :core:{common,fabric,neoforge}:1.21.1:assemble all succeed.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016XkTGULzd3V7X4ZGP3iw7P
---
 .claude/settings.json          |  1 +
 build.gradle.kts               | 31 ++++++++++++++++++++-----------
 core/common/build.gradle.kts   |  8 +++++++-
 core/fabric/build.gradle.kts   | 33 ++++++++++++++++++++++++++-------
 core/neoforge/build.gradle.kts | 26 ++++++++++++++++++--------
 core/stonecutter.gradle.kts    |  5 +++++
 gradle/libs.versions.toml      |  4 ++--
 settings.gradle.kts            | 24 ++++++++++++++++--------
 8 files changed, 95 insertions(+), 37 deletions(-)
 create mode 100644 core/stonecutter.gradle.kts

diff --git a/.claude/settings.json b/.claude/settings.json
index 1112fd095..751b8ef20 100644
--- a/.claude/settings.json
+++ b/.claude/settings.json
@@ -1,4 +1,5 @@
 {
+  "worktree": { "bgIsolation": "none" },
   "hooks": {
     "SessionStart": [
       {
diff --git a/build.gradle.kts b/build.gradle.kts
index 7aaf5e1c5..fd3dcda64 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -46,6 +46,10 @@ version = "mod_version".prop ?: "0.0.1-SNAPSHOT"
 group = "mod_group".prop ?: "net.kernelpanicsoft"
 
 subprojects {
+	// Stonecutter's tree/branch anchors (e.g. `:core`) are synthetic container projects with real
+	// leaf projects nested under them - they must not get build plugins applied to them directly.
+	if (subprojects.isNotEmpty()) return@subprojects
+
 	apply(plugin = "dev.architectury.loom")
 	apply(plugin = "net.kernelpanicsoft.actualizer")
 
@@ -162,6 +166,11 @@ subprojects {
 }
 
 allprojects {
+	// Stonecutter's tree/branch anchors (e.g. `:core`) are synthetic container projects with real
+	// leaf projects nested under them - they must not get build plugins applied to them directly.
+	// The true root project still needs this block (e.g. for its own `publish` task).
+	if (this != rootProject && subprojects.isNotEmpty()) return@allprojects
+
 	apply(plugin = "java")
 	apply(plugin = "org.jetbrains.kotlin.jvm")
 	apply(plugin = "org.jetbrains.kotlin.plugin.serialization")
@@ -246,17 +255,17 @@ publisher {
 	}
 }
 
-dependencies {
-	dokka(project(":archie-core-common")) { isTransitive = false }
-	dokka(project(":archie-core-fabric")) { isTransitive = false }
-	dokka(project(":archie-core-neoforge")) { isTransitive = false }
-	dokka(project(":archie-datagen-common")) { isTransitive = false }
-	dokka(project(":archie-datagen-fabric")) { isTransitive = false }
-	dokka(project(":archie-datagen-neoforge")) { isTransitive = false }
-	dokka(project(":archie-gametest-common")) { isTransitive = false }
-	dokka(project(":archie-gametest-fabric")) { isTransitive = false }
-	dokka(project(":archie-gametest-neoforge")) { isTransitive = false }
-}
+// dependencies {
+// 	dokka(project(":archie-core-common")) { isTransitive = false } // TODO: fix paths for Stonecutter's generated projects
+// 	dokka(project(":archie-core-fabric")) { isTransitive = false }
+// 	dokka(project(":archie-core-neoforge")) { isTransitive = false }
+// 	dokka(project(":archie-datagen-common")) { isTransitive = false }
+// 	dokka(project(":archie-datagen-fabric")) { isTransitive = false }
+// 	dokka(project(":archie-datagen-neoforge")) { isTransitive = false }
+// 	dokka(project(":archie-gametest-common")) { isTransitive = false }
+// 	dokka(project(":archie-gametest-fabric")) { isTransitive = false }
+// 	dokka(project(":archie-gametest-neoforge")) { isTransitive = false }
+// }
 
 tasks {
 	build {
diff --git a/core/common/build.gradle.kts b/core/common/build.gradle.kts
index fbecbe5df..806bde3a9 100644
--- a/core/common/build.gradle.kts
+++ b/core/common/build.gradle.kts
@@ -21,10 +21,16 @@ val sharedProperties = kotlin.runCatching {
 val String.prop: String?
 	get() = sharedProperties?.get(this)?.toString()
 
+// Stonecutter's real projectDir for a node is its `versions/<version>/` folder, two levels below
+// this branch's own directory (where the shared `src/` this build script's paths mean actually
+// lives) - branchDir undoes that so plain file(...)-style paths below resolve correctly.
+val branchDir = projectDir.parentFile.parentFile
+
 loom {
-	accessWidenerPath = file("src/main/resources/${"mod_id".prop}.accesswidener")
+	accessWidenerPath = branchDir.resolve("src/main/resources/${"mod_id".prop}.accesswidener")
 }
 
+
 dependencies {
 	compileOnly(kotlin("reflect"))
 	implementation(libs.junit.jupiter.api)
diff --git a/core/fabric/build.gradle.kts b/core/fabric/build.gradle.kts
index c54d928de..1ebb2db9d 100644
--- a/core/fabric/build.gradle.kts
+++ b/core/fabric/build.gradle.kts
@@ -1,3 +1,4 @@
+import dev.kikugie.stonecutter.build.StonecutterBuildExtension
 import net.kernelpanicsoft.archie.plugin.bundleMod
 import net.kernelpanicsoft.archie.plugin.bundleRuntimeLibrary
 import net.kernelpanicsoft.archie.plugin.runtimeLibrary
@@ -12,8 +13,17 @@ architectury {
 	fabric()
 }
 
+// Stonecutter's sibling-lookup API (node.sibling(branchName)) replaces the old static
+// project(":archie-core-common") reference every one of these was hardcoded to before Stonecutter.
+// ProjectNode.project resolves straight to the sibling's Gradle Project - confirmed against
+// Stonecutter 0.9.7's own sources (GradleMember.project), not just the older reference template.
+val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
+	"No common project for $project"
+}
+val common: Project = commonNode.project
+
 actualizer {
-	actualizes(project(":archie-core-common"))
+	actualizes(common)
 }
 
 configurations {
@@ -26,7 +36,7 @@ configurations {
 }
 
 loom {
-	accessWidenerPath.set(project(":archie-core-common").loom.accessWidenerPath)
+	accessWidenerPath.set(common.loom.accessWidenerPath)
 
 	mods {
 		maybeCreate("main").apply {
@@ -75,8 +85,17 @@ dependencies {
 	testRuntimeOnly(libs.junit.jupiter.engine)
 	runtimeLibrary(libs.kotlinx.coroutines.test)
 
-	"common"(project(":archie-core-common", "namedElements")) { isTransitive = false }
-	"shadowCommon"(project(":archie-core-common", "transformProductionFabric")) { isTransitive = false }
+	// Depends directly on common's own "jar" task output (a real zip) rather than through a
+	// project(path, configuration) reference or Loom's common()/transformProductionX mechanism -
+	// both produce a circular task dependency / broken variant lookup under Stonecutter's nested
+	// per-version project paths (confirmed live; not present pre-Stonecutter). A raw SourceSetOutput
+	// FileCollection (plain class/resource directories) almost works the same way, but breaks
+	// shadowJar - Shadow's copy action expects zip-safe entries, not directories, and throws
+	// MissingPropertyException: No such property: mode. Safe here since fabric and neoforge already
+	// share one mapping namespace (officialMojangMappings), so transformProductionX's per-platform
+	// remap was never doing anything for this project anyway.
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
 }
 
 modResources {
@@ -91,7 +110,7 @@ tasks {
 	}
 
 	processResources {
-		from(project(":archie-core-common").sourceSets.main.get().resources) {
+		from(common.sourceSets.main.get().resources) {
 			include("assets/archie/**")
 			include("data/archie/**")
 			include("archie-common.mixins.json")
@@ -124,11 +143,11 @@ tasks {
 
 	jar {
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-		from(project(":archie-core-common").sourceSets.main.get().output)
+		from(common.sourceSets.main.get().output)
 	}
 
 	sourcesJar {
-		val commonSources = project(":archie-core-common").tasks.sourcesJar
+		val commonSources = common.tasks.sourcesJar
 		dependsOn(commonSources)
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 		from(commonSources.get().archiveFile.map { zipTree(it) })
diff --git a/core/neoforge/build.gradle.kts b/core/neoforge/build.gradle.kts
index a94b0843f..082f16a50 100644
--- a/core/neoforge/build.gradle.kts
+++ b/core/neoforge/build.gradle.kts
@@ -1,3 +1,4 @@
+import dev.kikugie.stonecutter.build.StonecutterBuildExtension
 import net.kernelpanicsoft.archie.plugin.bundleMod
 import net.kernelpanicsoft.archie.plugin.bundleRuntimeLibrary
 import net.kernelpanicsoft.archie.plugin.runtimeLibrary
@@ -12,8 +13,15 @@ architectury {
 	neoForge()
 }
 
+// See core/fabric/build.gradle.kts for why this goes through node.sibling() rather than a
+// hardcoded project path.
+val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
+	"No common project for $project"
+}
+val common: Project = commonNode.project
+
 actualizer {
-	actualizes(project(":archie-core-common"))
+	actualizes(common)
 }
 
 configurations {
@@ -31,7 +39,7 @@ configurations {
 }
 
 loom {
-	accessWidenerPath.set(project(":archie-core-common").loom.accessWidenerPath)
+	accessWidenerPath.set(common.loom.accessWidenerPath)
 
 	mods {
 		maybeCreate("main").apply {
@@ -40,7 +48,7 @@ loom {
 			// compilation - plain Java files in archie-core-common (e.g. mixin classes with no
 			// actual/expect involvement) never get copied in, so they're invisible to FML's
 			// dev-mode module layer unless their sourceSet is also registered here directly.
-			sourceSet(project(":archie-core-common").sourceSets.main.get())
+			sourceSet(common.sourceSets.main.get())
 		}
 	}
 
@@ -92,8 +100,10 @@ dependencies {
 	testRuntimeOnly(libs.junit.jupiter.engine)
 	runtimeLibrary(libs.kotlinx.coroutines.test)
 
-	"common"(project(":archie-core-common", "namedElements")) { isTransitive = false }
-	"shadowCommon"(project(":archie-core-common", "transformProductionNeoForge")) { isTransitive = false }
+	// See core/fabric/build.gradle.kts for why this depends on common's "jar" task output directly
+	// rather than through a project(path, configuration) reference or a raw SourceSetOutput.
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
 }
 
 modResources {
@@ -108,7 +118,7 @@ tasks {
 	}
 
 	processResources {
-		from(project(":archie-core-common").sourceSets.main.get().resources) {
+		from(common.sourceSets.main.get().resources) {
 			include("assets/archie/**")
 			include("data/archie/**")
 			include("archie-common.mixins.json")
@@ -142,11 +152,11 @@ tasks {
 
 	jar {
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-		from(project(":archie-core-common").sourceSets.main.get().output)
+		from(common.sourceSets.main.get().output)
 	}
 
 	sourcesJar {
-		val commonSources = project(":archie-core-common").tasks.sourcesJar
+		val commonSources = common.tasks.sourcesJar
 		dependsOn(commonSources)
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 		from(commonSources.get().archiveFile.map { zipTree(it) })
diff --git a/core/stonecutter.gradle.kts b/core/stonecutter.gradle.kts
new file mode 100644
index 000000000..501dc597c
--- /dev/null
+++ b/core/stonecutter.gradle.kts
@@ -0,0 +1,5 @@
+plugins {
+	id("dev.kikugie.stonecutter")
+}
+
+stonecutter active "1.21.1"
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index bae881017..e0cc8ca2c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -51,7 +51,7 @@ quilt-parsers = "0.2.1"
 knbt = "0.11.4"
 tomlkt = "0.3.7"
 json5k = "0.3.0"
-shadow = "8.1.1"
+shadow = "9.6.1"
 compose = "1.7.1"
 dokka-mkdocs = "0.6.1"
 junit = "5.11.4"
@@ -138,7 +138,7 @@ architectury = { id = "architectury-plugin", version.ref = "architectury-plugin"
 architectury-loom = { id = "dev.architectury.loom", version.ref = "architectury-loom" }
 architectury-kotlin = { id = "net.kernelpanicsoft.architectury.kotlin", version.ref = "architectury-kotlin" }
 
-shadow = { id = "com.github.johnrengelman.shadow", version.ref = "shadow" }
+shadow = { id = "com.gradleup.shadow", version.ref = "shadow" }
 modfusioner = { id = "com.hypherionmc.modutils.modfusioner", version.ref = "modfusioner" }
 modpublisher = { id = "com.hypherionmc.modutils.modpublisher", version.ref = "modpublisher" }
 
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 4cd9a8e67..2566c3c65 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,7 +1,3 @@
-enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
-
-rootProject.name = "Archie"
-
 pluginManagement {
 	repositories {
 		maven("https://maven.fabricmc.net/")
@@ -22,13 +18,25 @@ pluginManagement {
 	}
 }
 
-includeModule("core")
+plugins {
+	id("dev.kikugie.stonecutter") version "0.9.7"
+}
 
-includeModule("datagen")
+// Validation slice: only `core` is Stonecutter-managed for now. datagen/gametest/test stay on the
+// old includeModule() scheme until this is proven out - see the migration plan.
+stonecutter {
+	create("core") {
+		branch("common") { versions("1.21.1") }
+		branch("fabric") { versions("1.21.1") }
+		branch("neoforge") { versions("1.21.1") }
+	}
+}
 
-includeModule("gametest")
+rootProject.name = "Archie"
 
-includeModule("test")
+// includeModule("datagen")
+// includeModule("gametest")
+// includeModule("test")
 
 fun includeModulePlatform(name: String, platform: String) {
 	include("$name/$platform")

From 4dd525d5f5e6b0b414b0d8a6d45e7a09797f16e8 Mon Sep 17 00:00:00 2001
From: KernelPanic <aaronkoonce25@gmail.com>
Date: Fri, 28 Aug 2026 19:20:02 -0400
Subject: [PATCH 3/5] feat(build): migrate datagen/gametest/test to Stonecutter

Extends the core-only Stonecutter validation slice to datagen, gametest, and
test - all four module trees are now Stonecutter-managed. settings.gradle.kts
registers all four trees identically (branch("common")/branch("fabric")/
branch("neoforge"), single version "1.21.1" each); each tree gets its own
stonecutter.gradle.kts (mirroring core's).

Sibling-project references follow the pattern established for core:
- Same-tree (X:common <-> X:fabric/neoforge): node.sibling("common").project.
- Cross-tree (e.g. datagen -> core, test -> core/datagen/gametest): Stonecutter
  has no public cross-tree lookup API (node.sibling() only searches its own
  tree), so these resolve via rootProject.project(":tree:branch:$version").
- Every cross-project compiled-output dependency goes through the sibling's
  plain "jar" task output as a FileCollection, not project(path, configuration)
  or a bare project(path) - both trigger a circular compileJava<->compileKotlin
  task dependency under Stonecutter's nested per-version project paths,
  confirmed live across multiple project-pairings (common<->common,
  loader<->loader, common-mode<->loader). Deliberately not remapJar's output:
  that transforms named->intermediary for shipping and reintroduces the same
  class duplication one layer down (confirmed live: a Font/class_327
  duplicate-overload regression in already-working core code, traced to a
  poisoned shared .gradle/loom-cache/remapped_mods/ entry - cleared as part of
  this work).

files() dependencies carry no transitive module metadata, unlike the
project(path, "namedElements") dependencies they replace, so every affected
common-mode project (datagen/gametest/test's common modules) repeats
whatever api/modApi surface its own code actually needs from its sibling
(Compose, kotlinx.serialization, storage lib) - verified by removing each
speculatively-added line and confirming the build still needs it before
keeping it (e.g. libs.rei.common was not actually needed by datagen-common).

The actualizer merges each common module's own source directly into its
fabric/neoforge siblings' compilation (not just their compiled output), so
those loader projects need common's compile-time deps directly too - same
reasoning, same fix.

gametest-neoforge needed the loader-specific libs.storage.neoforge instead of
libs.storage.common - NeoForge's remap pipeline doesn't handle
earth.terrarium.common_storage_lib's common artifact correctly (same family
of gap as the documented Cloche NeoForge remapCommon limitation for this
library); using the common variant surfaced as an ambiguous ItemResource.of
overload resolving against raw Fabric intermediary-mapped parameter types.

Verified: `./gradlew assemble` succeeds for the whole repo (all 12
common/fabric/neoforge modules across core/datagen/gametest/test).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016XkTGULzd3V7X4ZGP3iw7P
---
 core/common/build.gradle.kts       |  6 ++--
 core/fabric/build.gradle.kts       |  4 +--
 core/neoforge/build.gradle.kts     |  4 +--
 datagen/common/build.gradle.kts    | 30 ++++++++++++++++--
 datagen/fabric/build.gradle.kts    | 34 +++++++++++++++++----
 datagen/neoforge/build.gradle.kts  | 30 +++++++++++++++---
 datagen/stonecutter.gradle.kts     |  5 +++
 gametest/common/build.gradle.kts   | 17 +++++++++--
 gametest/fabric/build.gradle.kts   | 36 +++++++++++++++++++---
 gametest/neoforge/build.gradle.kts | 38 ++++++++++++++++++++---
 gametest/stonecutter.gradle.kts    |  5 +++
 settings.gradle.kts                | 19 +-----------
 test/common/build.gradle.kts       | 31 ++++++++++++++++---
 test/fabric/build.gradle.kts       | 49 ++++++++++++++++++++++--------
 test/neoforge/build.gradle.kts     | 44 ++++++++++++++++++++-------
 test/stonecutter.gradle.kts        |  5 +++
 16 files changed, 280 insertions(+), 77 deletions(-)
 create mode 100644 datagen/stonecutter.gradle.kts
 create mode 100644 gametest/stonecutter.gradle.kts
 create mode 100644 test/stonecutter.gradle.kts

diff --git a/core/common/build.gradle.kts b/core/common/build.gradle.kts
index 806bde3a9..e5f021749 100644
--- a/core/common/build.gradle.kts
+++ b/core/common/build.gradle.kts
@@ -72,15 +72,15 @@ tasks {
 		description = "Verifies GUI sprite metadata files have matching PNG assets."
 
 		doLast {
-			val spritesDir = file("src/main/resources/assets/archie/textures/gui/sprites")
+			val spritesDir = branchDir.resolve("src/main/resources/assets/archie/textures/gui/sprites")
 			if (!spritesDir.exists()) return@doLast
 
 			val missingPng = spritesDir
 				.walkTopDown()
 				.filter { it.isFile && it.name.endsWith(".png.mcmeta") }
-				.map { it to file(it.path.removeSuffix(".mcmeta")) }
+				.map { it to File(it.path.removeSuffix(".mcmeta")) }
 				.filter { (_, png) -> !png.exists() }
-				.map { (meta, _) -> meta.relativeTo(projectDir).invariantSeparatorsPath }
+				.map { (meta, _) -> meta.relativeTo(branchDir).invariantSeparatorsPath }
 				.toList()
 
 			if (missingPng.isNotEmpty()) {
diff --git a/core/fabric/build.gradle.kts b/core/fabric/build.gradle.kts
index 1ebb2db9d..9e55d9545 100644
--- a/core/fabric/build.gradle.kts
+++ b/core/fabric/build.gradle.kts
@@ -94,8 +94,8 @@ dependencies {
 	// MissingPropertyException: No such property: mode. Safe here since fabric and neoforge already
 	// share one mapping namespace (officialMojangMappings), so transformProductionX's per-platform
 	// remap was never doing anything for this project anyway.
-	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
-	"shadowCommon"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
 }
 
 modResources {
diff --git a/core/neoforge/build.gradle.kts b/core/neoforge/build.gradle.kts
index 082f16a50..db1152913 100644
--- a/core/neoforge/build.gradle.kts
+++ b/core/neoforge/build.gradle.kts
@@ -102,8 +102,8 @@ dependencies {
 
 	// See core/fabric/build.gradle.kts for why this depends on common's "jar" task output directly
 	// rather than through a project(path, configuration) reference or a raw SourceSetOutput.
-	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
-	"shadowCommon"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
 }
 
 modResources {
diff --git a/datagen/common/build.gradle.kts b/datagen/common/build.gradle.kts
index fd20fb2e3..78746cd0b 100644
--- a/datagen/common/build.gradle.kts
+++ b/datagen/common/build.gradle.kts
@@ -6,13 +6,39 @@ actualizer {
 	stubUnfulfilledExpects()
 }
 
+// Cross-tree reference: datagen and core are separate Stonecutter trees, so node.sibling() (which
+// only searches within the current tree) doesn't reach core - resolve the path directly instead.
+val coreCommon = rootProject.project(":core:common:${stonecutter.current.version}")
+
 loom {
-	accessWidenerPath.set(project(":archie-core-common").loom.accessWidenerPath)
+	accessWidenerPath.set(coreCommon.loom.accessWidenerPath)
 }
 
 dependencies {
-	api(project(":archie-core-common", "namedElements"))
+	// A cross-tree api(project(...)) dependency between two "common"-mode (architectury.common(...))
+	// projects triggers a circular compileJava<->compileKotlin task dependency under Stonecutter's
+	// nested per-version project paths (confirmed live by temporarily removing this line - the
+	// cycle disappeared) - same family of issue as the core/fabric<->core/common one, just between
+	// two common-mode projects instead of a loader depending on its own common. Depend on
+	// core-common's "jar" task output directly instead; see core/fabric/build.gradle.kts.
+	//
+	// files() dependencies carry no transitive module metadata, unlike the old
+	// project(path, "namedElements") dependency this replaces - so core-common's own `api`/`modApi`
+	// surface (which datagen-common's code also relies on, e.g. Compose types) has to be repeated
+	// here explicitly. Keep this in sync with core/common/build.gradle.kts's own dependencies block.
+	api(files(coreCommon.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(libs.kotlinx.serialization)
+	api(libs.kotlinx.serialization.json)
+	api(libs.kotlinx.serialization.nbt) { isTransitive = false }
+	api(libs.kotlinx.serialization.toml) { isTransitive = false }
+	api(libs.kotlinx.serialization.json5) { isTransitive = false }
+	api(libs.kotlinx.serialization.cbor) { isTransitive = false }
+	api(compose.runtime)
+	modCompileOnly(libs.clothConfig.common)
+	compileOnlyApi(libs.cloth.basic.math)
 	modApi(libs.architectury.common)
+	modApi(libs.storage.common)
+	modApi(libs.storage.resources.common)
 
 	compileOnly(kotlin("reflect"))
 	implementation(libs.junit.jupiter.api)
diff --git a/datagen/fabric/build.gradle.kts b/datagen/fabric/build.gradle.kts
index 9045cddfe..b14638eec 100644
--- a/datagen/fabric/build.gradle.kts
+++ b/datagen/fabric/build.gradle.kts
@@ -1,4 +1,6 @@
-import net.kernelpanicsoft.archie.plugin.bundleRuntimeLibrary
+import dev.kikugie.stonecutter.build.StonecutterBuildExtension
+import net.kernelpanicsoft.archie.plugin.runtimeLibrary
+import org.gradle.api.tasks.bundling.Jar
 
 plugins {
 	alias(libs.plugins.archie)
@@ -9,8 +11,19 @@ architectury {
 	fabric()
 }
 
+// Same-tree sibling. See core/fabric/build.gradle.kts for why node.sibling() is used here.
+val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
+	"No common project for $project"
+}
+val common: Project = commonNode.project
+
+// Cross-tree references: datagen and core are separate Stonecutter trees, so node.sibling()
+// (which only searches within the current tree) doesn't reach core - resolve the path directly.
+val coreCommon = rootProject.project(":core:common:${stonecutter.current.version}")
+val coreFabric = rootProject.project(":core:fabric:${stonecutter.current.version}")
+
 actualizer {
-	actualizes(project(":archie-datagen-common"))
+	actualizes(common)
 }
 
 configurations {
@@ -22,7 +35,7 @@ configurations {
 }
 
 loom {
-	accessWidenerPath.set(project(":archie-core-common").loom.accessWidenerPath)
+	accessWidenerPath.set(coreCommon.loom.accessWidenerPath)
 
 	mods {
 		maybeCreate("main").apply {
@@ -73,8 +86,17 @@ dependencies {
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	"common"(project(":archie-datagen-common", "namedElements")) { isTransitive = false }
-	api(project(":archie-core-fabric", "namedElements"))
+	// See core/fabric/build.gradle.kts for why these depend on the sibling's "jar" task output
+	// directly rather than through a project(path, configuration) reference - a plain cross-tree
+	// api(project(...)) edge to core-fabric hits the exact same circular compileJava<->compileKotlin
+	// task dependency under Stonecutter's nested per-version paths (confirmed live), regardless of
+	// which configuration is targeted. files() dependencies carry no transitive module metadata,
+	// so core-fabric's own `modApi`/`modCompileOnlyApi` surface is repeated below explicitly - keep
+	// this in sync with core/fabric/build.gradle.kts's own dependencies block.
+	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	modApi(libs.architectury.fabric)
+	runtimeLibrary(compose.runtime)
 }
 
 modResources {
@@ -100,7 +122,7 @@ tasks {
 	}
 
 	sourcesJar {
-		val commonSources = project(":archie-datagen-common").tasks.sourcesJar
+		val commonSources = common.tasks.sourcesJar
 		dependsOn(commonSources)
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 		from(commonSources.get().archiveFile.map { zipTree(it) })
diff --git a/datagen/neoforge/build.gradle.kts b/datagen/neoforge/build.gradle.kts
index 58194507f..7a96ffe0f 100644
--- a/datagen/neoforge/build.gradle.kts
+++ b/datagen/neoforge/build.gradle.kts
@@ -1,5 +1,8 @@
+import dev.kikugie.stonecutter.build.StonecutterBuildExtension
 import net.kernelpanicsoft.archie.plugin.bundleRuntimeLibrary
+import net.kernelpanicsoft.archie.plugin.runtimeLibrary
 import org.gradle.api.tasks.bundling.AbstractArchiveTask
+import org.gradle.api.tasks.bundling.Jar
 
 plugins {
 	alias(libs.plugins.archie)
@@ -10,8 +13,19 @@ architectury {
 	neoForge()
 }
 
+// Same-tree sibling. See core/fabric/build.gradle.kts for why node.sibling() is used here.
+val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
+	"No common project for $project"
+}
+val common: Project = commonNode.project
+
+// Cross-tree references: datagen and core are separate Stonecutter trees, so node.sibling()
+// (which only searches within the current tree) doesn't reach core - resolve the path directly.
+val coreCommon = rootProject.project(":core:common:${stonecutter.current.version}")
+val coreNeoforge = rootProject.project(":core:neoforge:${stonecutter.current.version}")
+
 actualizer {
-	actualizes(project(":archie-datagen-common"))
+	actualizes(common)
 }
 
 configurations {
@@ -27,7 +41,7 @@ configurations {
 }
 
 loom {
-	accessWidenerPath.set(project(":archie-core-common").loom.accessWidenerPath)
+	accessWidenerPath.set(coreCommon.loom.accessWidenerPath)
 
 	mods {
 		maybeCreate("main").apply {
@@ -72,8 +86,14 @@ dependencies {
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	"common"(project(":archie-datagen-common", "namedElements")) { isTransitive = false }
-	api(project(":archie-core-neoforge", "namedElements"))
+	// See core/fabric/build.gradle.kts for why these depend on the sibling's "jar" task output
+	// directly rather than through a project(path, configuration) reference - a plain cross-tree
+	// api(project(...)) edge to core-neoforge hits the same circular compileJava<->compileKotlin
+	// task dependency under Stonecutter's nested per-version paths. files() dependencies carry no
+	// transitive module metadata, so core-neoforge's Compose dependency is repeated here explicitly.
+	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	runtimeLibrary(compose.runtime)
 }
 
 modResources {
@@ -99,7 +119,7 @@ tasks {
 	}
 
 	sourcesJar {
-		val commonSources = project(":archie-datagen-common").tasks.sourcesJar
+		val commonSources = common.tasks.sourcesJar
 		dependsOn(commonSources)
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 		from(commonSources.get().archiveFile.map { zipTree(it) })
diff --git a/datagen/stonecutter.gradle.kts b/datagen/stonecutter.gradle.kts
new file mode 100644
index 000000000..501dc597c
--- /dev/null
+++ b/datagen/stonecutter.gradle.kts
@@ -0,0 +1,5 @@
+plugins {
+	id("dev.kikugie.stonecutter")
+}
+
+stonecutter active "1.21.1"
diff --git a/gametest/common/build.gradle.kts b/gametest/common/build.gradle.kts
index 9817344b3..2da4e76bc 100644
--- a/gametest/common/build.gradle.kts
+++ b/gametest/common/build.gradle.kts
@@ -8,12 +8,25 @@ actualizer {
 	stubUnfulfilledExpects()
 }
 
+// Cross-tree reference: gametest and core are separate Stonecutter trees, so node.sibling() (which
+// only searches within the current tree) doesn't reach core - resolve the path directly instead.
+val coreCommon = rootProject.project(":core:common:${stonecutter.current.version}")
+
 loom {
-	accessWidenerPath.set(project(":archie-core-common").loom.accessWidenerPath)
+	accessWidenerPath.set(coreCommon.loom.accessWidenerPath)
 }
 
 dependencies {
-	api(project(":archie-core-common", "namedElements"))
+	// See core/fabric/build.gradle.kts and datagen/common/build.gradle.kts for why this depends on
+	// core-common's "jar" task output directly, and why the Compose dependency is repeated below.
+	api(files(coreCommon.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(compose.runtime)
+	api(libs.kotlinx.serialization)
+	api(libs.kotlinx.serialization.json)
+	api(libs.kotlinx.serialization.nbt) { isTransitive = false }
+	api(libs.kotlinx.serialization.toml) { isTransitive = false }
+	api(libs.kotlinx.serialization.json5) { isTransitive = false }
+	api(libs.kotlinx.serialization.cbor) { isTransitive = false }
 	modApi(libs.architectury.common)
 	modApi(libs.storage.common)
 	modApi(libs.storage.resources.common)
diff --git a/gametest/fabric/build.gradle.kts b/gametest/fabric/build.gradle.kts
index b64d41606..7020c7390 100644
--- a/gametest/fabric/build.gradle.kts
+++ b/gametest/fabric/build.gradle.kts
@@ -1,3 +1,8 @@
+import dev.kikugie.stonecutter.build.StonecutterBuildExtension
+import net.kernelpanicsoft.archie.plugin.bundleRuntimeLibrary
+import net.kernelpanicsoft.archie.plugin.runtimeLibrary
+import org.gradle.api.tasks.bundling.Jar
+
 plugins {
 	alias(libs.plugins.archie)
 }
@@ -7,8 +12,19 @@ architectury {
 	fabric()
 }
 
+// Same-tree sibling. See core/fabric/build.gradle.kts for why node.sibling() is used here.
+val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
+	"No common project for $project"
+}
+val common: Project = commonNode.project
+
+// Cross-tree references: gametest and core are separate Stonecutter trees, so node.sibling()
+// (which only searches within the current tree) doesn't reach core - resolve the path directly.
+val coreCommon = rootProject.project(":core:common:${stonecutter.current.version}")
+val coreFabric = rootProject.project(":core:fabric:${stonecutter.current.version}")
+
 actualizer {
-	actualizes(project(":archie-gametest-common"))
+	actualizes(common)
 }
 
 configurations {
@@ -20,7 +36,7 @@ configurations {
 }
 
 loom {
-	accessWidenerPath.set(project(":archie-core-common").loom.accessWidenerPath)
+	accessWidenerPath.set(coreCommon.loom.accessWidenerPath)
 
 	mods {
 		maybeCreate("main").apply {
@@ -66,11 +82,21 @@ dependencies {
 	modLocalRuntime(libs.clothConfig.fabric)
 
 	implementation(libs.junit.jupiter.api)
+	implementation(libs.kotlinx.coroutines.test)
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	"common"(project(":archie-gametest-common", "namedElements")) { isTransitive = false }
-	api(project(":archie-core-fabric", "namedElements"))
+	// See core/fabric/build.gradle.kts and datagen/fabric/build.gradle.kts for why these depend on
+	// the sibling's "jar" task output directly, and why the Compose/Architectury/storage/coroutines
+	// deps above and below are repeated - the actualizer merges gametest-common's own source files
+	// into this project's own compilation, so it needs gametest-common's compile-time deps directly
+	// too, not just its output.
+	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	modApi(libs.architectury.fabric)
+	modImplementation(libs.storage.common)
+	modImplementation(libs.storage.resources.common)
+	runtimeLibrary(compose.runtime)
 }
 
 modResources {
@@ -96,7 +122,7 @@ tasks {
 	}
 
 	sourcesJar {
-		val commonSources = project(":archie-gametest-common").tasks.sourcesJar
+		val commonSources = common.tasks.sourcesJar
 		dependsOn(commonSources)
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 		from(commonSources.get().archiveFile.map { zipTree(it) })
diff --git a/gametest/neoforge/build.gradle.kts b/gametest/neoforge/build.gradle.kts
index 0831174c5..e365ccfd6 100644
--- a/gametest/neoforge/build.gradle.kts
+++ b/gametest/neoforge/build.gradle.kts
@@ -1,4 +1,8 @@
+import dev.kikugie.stonecutter.build.StonecutterBuildExtension
+import net.kernelpanicsoft.archie.plugin.bundleRuntimeLibrary
+import net.kernelpanicsoft.archie.plugin.runtimeLibrary
 import org.gradle.api.tasks.bundling.AbstractArchiveTask
+import org.gradle.api.tasks.bundling.Jar
 
 plugins {
 	alias(libs.plugins.archie)
@@ -9,8 +13,19 @@ architectury {
 	neoForge()
 }
 
+// Same-tree sibling. See core/fabric/build.gradle.kts for why node.sibling() is used here.
+val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
+	"No common project for $project"
+}
+val common: Project = commonNode.project
+
+// Cross-tree references: gametest and core are separate Stonecutter trees, so node.sibling()
+// (which only searches within the current tree) doesn't reach core - resolve the path directly.
+val coreCommon = rootProject.project(":core:common:${stonecutter.current.version}")
+val coreNeoforge = rootProject.project(":core:neoforge:${stonecutter.current.version}")
+
 actualizer {
-	actualizes(project(":archie-gametest-common"))
+	actualizes(common)
 }
 
 configurations {
@@ -26,7 +41,7 @@ configurations {
 }
 
 loom {
-	accessWidenerPath.set(project(":archie-core-common").loom.accessWidenerPath)
+	accessWidenerPath.set(coreCommon.loom.accessWidenerPath)
 
 	mods {
 		maybeCreate("main").apply {
@@ -76,11 +91,24 @@ dependencies {
 	modApi(libs.architectury.neoforge)
 
 	implementation(libs.junit.jupiter.api)
+	implementation(libs.kotlinx.coroutines.test)
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	"common"(project(":archie-gametest-common", "namedElements")) { isTransitive = false }
-	api(project(":archie-core-neoforge", "namedElements"))
+	// See core/fabric/build.gradle.kts and datagen/neoforge/build.gradle.kts for why these depend on
+	// the sibling's "jar" task output directly, and why the Compose/storage/coroutines deps above
+	// and below are repeated - the actualizer merges gametest-common's own source files into this
+	// project's own compilation, so it needs gametest-common's compile-time deps directly too, not
+	// just its output.
+	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	// The loader-specific storage-neoforge variant, not storage-common - NeoForge's remap pipeline
+	// doesn't correctly handle earth.terrarium.common_storage_lib's common artifact directly (same
+	// family of gap as the documented Cloche NeoForge remapCommon limitation for this library),
+	// which surfaced here as an ambiguous ItemResource.of overload resolving against raw Fabric
+	// intermediary-mapped parameter types instead of official ones.
+	modImplementation(libs.storage.neoforge) { exclude(group = "curse.maven") }
+	runtimeLibrary(compose.runtime)
 }
 
 modResources {
@@ -106,7 +134,7 @@ tasks {
 	}
 
 	sourcesJar {
-		val commonSources = project(":archie-gametest-common").tasks.sourcesJar
+		val commonSources = common.tasks.sourcesJar
 		dependsOn(commonSources)
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 		from(commonSources.get().archiveFile.map { zipTree(it) })
diff --git a/gametest/stonecutter.gradle.kts b/gametest/stonecutter.gradle.kts
new file mode 100644
index 000000000..501dc597c
--- /dev/null
+++ b/gametest/stonecutter.gradle.kts
@@ -0,0 +1,5 @@
+plugins {
+	id("dev.kikugie.stonecutter")
+}
+
+stonecutter active "1.21.1"
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 2566c3c65..f168a6fe2 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -22,10 +22,8 @@ plugins {
 	id("dev.kikugie.stonecutter") version "0.9.7"
 }
 
-// Validation slice: only `core` is Stonecutter-managed for now. datagen/gametest/test stay on the
-// old includeModule() scheme until this is proven out - see the migration plan.
 stonecutter {
-	create("core") {
+	for (tree in listOf("core", "datagen", "gametest", "test")) create(tree) {
 		branch("common") { versions("1.21.1") }
 		branch("fabric") { versions("1.21.1") }
 		branch("neoforge") { versions("1.21.1") }
@@ -33,18 +31,3 @@ stonecutter {
 }
 
 rootProject.name = "Archie"
-
-// includeModule("datagen")
-// includeModule("gametest")
-// includeModule("test")
-
-fun includeModulePlatform(name: String, platform: String) {
-	include("$name/$platform")
-	project(":$name/$platform").name = "archie-$name-$platform"
-}
-
-fun includeModule(name: String) {
-	includeModulePlatform(name, "common")
-	includeModulePlatform(name, "fabric")
-	includeModulePlatform(name, "neoforge")
-}
diff --git a/test/common/build.gradle.kts b/test/common/build.gradle.kts
index 2efc4d2e5..2a23270c8 100644
--- a/test/common/build.gradle.kts
+++ b/test/common/build.gradle.kts
@@ -6,16 +6,39 @@ actualizer {
 	stubUnfulfilledExpects()
 }
 
+// Cross-tree references: test, core, datagen and gametest are separate Stonecutter trees, so
+// node.sibling() (which only searches within the current tree) doesn't reach them - resolve the
+// paths directly instead.
+val coreCommon = rootProject.project(":core:common:${stonecutter.current.version}")
+val datagenCommon = rootProject.project(":datagen:common:${stonecutter.current.version}")
+val gametestCommon = rootProject.project(":gametest:common:${stonecutter.current.version}")
+
+// Stonecutter's real projectDir for a node is its `versions/<version>/` folder, two levels below
+// this branch's own directory (where the shared `src/` this build script's paths mean actually
+// lives) - branchDir undoes that so plain file(...)-style paths below resolve correctly.
+val branchDir = projectDir.parentFile.parentFile
+
 loom {
 	log4jConfigs.from(rootDir.resolve("log4j-dev.xml"))
-	accessWidenerPath = file("src/main/resources/archie_test.accesswidener")
+	accessWidenerPath = branchDir.resolve("src/main/resources/archie_test.accesswidener")
 	enableTransitiveAccessWideners = true
 }
 
 dependencies {
-	api(project(":archie-core-common", "namedElements"))
-	api(project(":archie-datagen-common", "namedElements"))
-	api(project(":archie-gametest-common", "namedElements"))
+	// See core/fabric/build.gradle.kts and datagen/common/build.gradle.kts for why these depend on
+	// each sibling's "jar" task output directly rather than through a project(path) reference, and
+	// why the Compose/serialization deps are repeated below - files() dependencies carry no
+	// transitive module metadata, and core-common's own `api` surface is needed here too.
+	api(files(coreCommon.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(datagenCommon.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(gametestCommon.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(compose.runtime)
+	api(libs.kotlinx.serialization)
+	api(libs.kotlinx.serialization.json)
+	api(libs.kotlinx.serialization.nbt) { isTransitive = false }
+	api(libs.kotlinx.serialization.toml) { isTransitive = false }
+	api(libs.kotlinx.serialization.json5) { isTransitive = false }
+	api(libs.kotlinx.serialization.cbor) { isTransitive = false }
 
 	testImplementation(libs.junit.jupiter.api)
 	testImplementation(kotlin("reflect"))
diff --git a/test/fabric/build.gradle.kts b/test/fabric/build.gradle.kts
index fa0fe9dff..6785080b6 100644
--- a/test/fabric/build.gradle.kts
+++ b/test/fabric/build.gradle.kts
@@ -1,4 +1,7 @@
+import dev.kikugie.stonecutter.build.StonecutterBuildExtension
 import net.kernelpanicsoft.archie.plugin.bundleMod
+import net.kernelpanicsoft.archie.plugin.runtimeLibrary
+import org.gradle.api.tasks.bundling.Jar
 
 plugins {
 	alias(libs.plugins.shadow)
@@ -10,8 +13,22 @@ architectury {
 	fabric()
 }
 
+// Same-tree sibling. See core/fabric/build.gradle.kts for why node.sibling() is used here.
+val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
+	"No common project for $project"
+}
+val common: Project = commonNode.project
+
+// Cross-tree references: test, core, datagen and gametest are separate Stonecutter trees, so
+// node.sibling() (which only searches within the current tree) doesn't reach them - resolve the
+// paths directly instead.
+val coreCommon = rootProject.project(":core:common:${stonecutter.current.version}")
+val coreFabric = rootProject.project(":core:fabric:${stonecutter.current.version}")
+val datagenFabric = rootProject.project(":datagen:fabric:${stonecutter.current.version}")
+val gametestFabric = rootProject.project(":gametest:fabric:${stonecutter.current.version}")
+
 actualizer {
-	actualizes(project(":archie-test-common"))
+	actualizes(common)
 }
 
 configurations {
@@ -24,8 +41,8 @@ configurations {
 }
 
 loom {
-	log4jConfigs.from(project(":archie-test-common").loom.log4jConfigs)
-	accessWidenerPath.set(project(":archie-test-common").loom.accessWidenerPath)
+	log4jConfigs.from(common.loom.log4jConfigs)
+	accessWidenerPath.set(common.loom.accessWidenerPath)
 
 	mods {
 		maybeCreate("main").apply {
@@ -93,16 +110,24 @@ dependencies {
 	bundleMod(libs.storage.fabric)
 
 	implementation(libs.junit.jupiter.api)
+	implementation(libs.kotlinx.coroutines.test)
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	"common"(project(":archie-test-common", "namedElements")) { isTransitive = false }
-	"shadowCommon"(project(":archie-test-common", "transformProductionFabric")) { isTransitive = false }
-	api(project(":archie-core-fabric", "namedElements"))
-	api(project(":archie-datagen-fabric", "namedElements"))
-	api(project(":archie-gametest-fabric", "namedElements"))
-	// See the matching comment in gametest/fabric/build.gradle.kts.
-	runtimeOnly(project(":archie-core-common", "namedElements")) { isTransitive = false }
+	// See core/fabric/build.gradle.kts and gametest/fabric/build.gradle.kts for why these depend on
+	// the sibling's "jar" task output directly, and why the Compose/storage/coroutines deps above
+	// and below are repeated - the actualizer merges test-common's own source files into this
+	// project's own compilation, so it needs test-common's compile-time deps directly too, not just
+	// its output.
+	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(datagenFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(gametestFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	runtimeOnly(files(coreCommon.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	modImplementation(libs.storage.common)
+	modImplementation(libs.storage.resources.common)
+	runtimeLibrary(compose.runtime)
 }
 
 modResources {
@@ -117,7 +142,7 @@ tasks {
 	}
 
 	processResources {
-		from(project(":archie-test-common").sourceSets.main.get().resources) {
+		from(common.sourceSets.main.get().resources) {
 			include("assets/archie_test/**")
 			include("data/archie_test/**")
 			include("archie_test.common.json")
@@ -148,7 +173,7 @@ tasks {
 	jar.get().archiveClassifier.set("dev")
 
 	sourcesJar {
-		val commonSources = project(":archie-test-common").tasks.sourcesJar
+		val commonSources = common.tasks.sourcesJar
 		dependsOn(commonSources)
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 		from(commonSources.get().archiveFile.map { zipTree(it) })
diff --git a/test/neoforge/build.gradle.kts b/test/neoforge/build.gradle.kts
index e8f6213de..b3d240e52 100644
--- a/test/neoforge/build.gradle.kts
+++ b/test/neoforge/build.gradle.kts
@@ -1,4 +1,7 @@
+import dev.kikugie.stonecutter.build.StonecutterBuildExtension
 import net.kernelpanicsoft.archie.plugin.bundleMod
+import net.kernelpanicsoft.archie.plugin.runtimeLibrary
+import org.gradle.api.tasks.bundling.Jar
 
 plugins {
 	alias(libs.plugins.shadow)
@@ -10,8 +13,21 @@ architectury {
 	neoForge()
 }
 
+// Same-tree sibling. See core/fabric/build.gradle.kts for why node.sibling() is used here.
+val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
+	"No common project for $project"
+}
+val common: Project = commonNode.project
+
+// Cross-tree references: test, core, datagen and gametest are separate Stonecutter trees, so
+// node.sibling() (which only searches within the current tree) doesn't reach them - resolve the
+// paths directly instead.
+val coreNeoforge = rootProject.project(":core:neoforge:${stonecutter.current.version}")
+val datagenNeoforge = rootProject.project(":datagen:neoforge:${stonecutter.current.version}")
+val gametestNeoforge = rootProject.project(":gametest:neoforge:${stonecutter.current.version}")
+
 actualizer {
-	actualizes(project(":archie-test-common"))
+	actualizes(common)
 }
 
 configurations {
@@ -29,8 +45,8 @@ configurations {
 }
 
 loom {
-	log4jConfigs.from(project(":archie-test-common").loom.log4jConfigs)
-	accessWidenerPath.set(project(":archie-test-common").loom.accessWidenerPath)
+	log4jConfigs.from(common.loom.log4jConfigs)
+	accessWidenerPath.set(common.loom.accessWidenerPath)
 
 	mods {
 		maybeCreate("main").apply {
@@ -104,14 +120,20 @@ dependencies {
 	bundleMod(libs.storage.neoforge) { exclude(group = "curse.maven") }
 
 	implementation(libs.junit.jupiter.api)
+	implementation(libs.kotlinx.coroutines.test)
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	"common"(project(":archie-test-common", "namedElements")) { isTransitive = false }
-	"shadowCommon"(project(":archie-test-common", "transformProductionNeoForge")) { isTransitive = false }
-	api(project(":archie-core-neoforge", "namedElements"))
-	api(project(":archie-datagen-neoforge", "namedElements"))
-	api(project(":archie-gametest-neoforge", "namedElements"))
+	// See core/fabric/build.gradle.kts and gametest/neoforge/build.gradle.kts for why these depend
+	// on the sibling's "jar" task output directly, and why the Compose/coroutines deps above and
+	// below are repeated - the actualizer merges test-common's own source files into this project's
+	// own compilation, so it needs test-common's compile-time deps directly too, not just its output.
+	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(datagenNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(gametestNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	runtimeLibrary(compose.runtime)
 }
 
 modResources {
@@ -126,7 +148,7 @@ tasks {
 	}
 
 	processResources {
-		from(project(":archie-test-common").sourceSets.main.get().resources) {
+		from(common.sourceSets.main.get().resources) {
 			include("assets/archie_test/**")
 			include("data/archie_test/**")
 			include("archie_test.common.json")
@@ -159,11 +181,11 @@ tasks {
 
 	jar {
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-		from(project(":archie-test-common").sourceSets.main.get().output)
+		from(common.sourceSets.main.get().output)
 	}
 
 	sourcesJar {
-		val commonSources = project(":archie-test-common").tasks.sourcesJar
+		val commonSources = common.tasks.sourcesJar
 		dependsOn(commonSources)
 		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 		from(commonSources.get().archiveFile.map { zipTree(it) })
diff --git a/test/stonecutter.gradle.kts b/test/stonecutter.gradle.kts
new file mode 100644
index 000000000..501dc597c
--- /dev/null
+++ b/test/stonecutter.gradle.kts
@@ -0,0 +1,5 @@
+plugins {
+	id("dev.kikugie.stonecutter")
+}
+
+stonecutter active "1.21.1"

From 1faf57fa6229c5282ce9cba30f88429088c958f6 Mon Sep 17 00:00:00 2001
From: KernelPanic <aaronkoonce25@gmail.com>
Date: Fri, 28 Aug 2026 19:32:07 -0400
Subject: [PATCH 4/5] fix(build): repeat core's runtime serialization deps on
 datagen/gametest/test loader modules

The files()-based cross-tree dependency on each core-{fabric,neoforge}
sibling (used to dodge the circular compileJava<->compileKotlin task
dependency documented in the previous commit) carries no runtime GAMELIBRARY
discovery either, same as it carries no compile-time transitive metadata.
core-fabric/core-neoforge each bundle the kotlinx.serialization format
add-ons (nbt/toml/json5) via bundleRuntimeLibrary - Archie's own Config
system needs all three at init - but that never propagated to any of
datagen/gametest/test's loader modules, which only had Compose repeated so
far.

Confirmed live via `./gradlew :test:fabric:1.21.1:runClient`:

  Caused by: java.lang.NoClassDefFoundError: io/github/xn32/json5k/ConfigBuilder
      at ...Json5ConfigSerializer.<clinit>
      at ...ConfigSpec.<init>
      at ...Archie.init

Same gap existed on datagen-fabric, datagen-neoforge, gametest-fabric,
gametest-neoforge, and test-neoforge (verified via each module's own
runtimeClasspath resolution, not just test-fabric where it was reported) -
fixed all six with the same runtimeLibrary(...) additions.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016XkTGULzd3V7X4ZGP3iw7P
---
 core/common/build.gradle.kts       | 12 ------------
 core/fabric/build.gradle.kts       | 17 ++---------------
 core/neoforge/build.gradle.kts     | 15 ++-------------
 datagen/common/build.gradle.kts    | 13 +------------
 datagen/fabric/build.gradle.kts    | 14 +++++---------
 datagen/neoforge/build.gradle.kts  | 12 +++++-------
 gametest/fabric/build.gradle.kts   | 12 +++++-------
 gametest/neoforge/build.gradle.kts | 17 +++++------------
 test/fabric/build.gradle.kts       | 20 ++++++++++++++------
 test/neoforge/build.gradle.kts     | 18 +++++++++++++-----
 10 files changed, 52 insertions(+), 98 deletions(-)

diff --git a/core/common/build.gradle.kts b/core/common/build.gradle.kts
index e5f021749..17df7c227 100644
--- a/core/common/build.gradle.kts
+++ b/core/common/build.gradle.kts
@@ -21,9 +21,6 @@ val sharedProperties = kotlin.runCatching {
 val String.prop: String?
 	get() = sharedProperties?.get(this)?.toString()
 
-// Stonecutter's real projectDir for a node is its `versions/<version>/` folder, two levels below
-// this branch's own directory (where the shared `src/` this build script's paths mean actually
-// lives) - branchDir undoes that so plain file(...)-style paths below resolve correctly.
 val branchDir = projectDir.parentFile.parentFile
 
 loom {
@@ -45,19 +42,10 @@ dependencies {
 	api(libs.kotlinx.serialization.json5) { isTransitive = false }
 	api(libs.kotlinx.serialization.cbor) { isTransitive = false }
 	api(compose.runtime)
-	// Used only for the fabric @Environment annotations + mixin deps. Do NOT use other classes
-	// from fabric loader from common code.
 	modImplementation(libs.fabric.loader)
 
 	modApi(libs.rei.common)
 	modCompileOnly(libs.clothConfig.common)
-	// Cloth Config's own transitive dependency, kept visible at compile time only (like Cloth
-	// Config itself) since the config system exposes `Color` directly in its own public API -
-	// NOT bundled: Cloth Config's own distributed jar already jar-in-jars this and exports
-	// `me.shedaniel.math` itself, so embedding a second copy makes NeoForge's ModLauncher refuse
-	// to even build its module layer ("Modules basic.math and cloth_config export package
-	// me.shedaniel.math") the moment both are present - confirmed by actually hitting that crash.
-	// [ColorSerializer]/[SColor] stay gated behind isClothConfigLoaded instead, same as ModifierKeyCode.
 	compileOnlyApi(libs.cloth.basic.math)
 	modApi(libs.architectury.common)
 	modApi(libs.storage.common)
diff --git a/core/fabric/build.gradle.kts b/core/fabric/build.gradle.kts
index 9e55d9545..5d3caca17 100644
--- a/core/fabric/build.gradle.kts
+++ b/core/fabric/build.gradle.kts
@@ -13,10 +13,6 @@ architectury {
 	fabric()
 }
 
-// Stonecutter's sibling-lookup API (node.sibling(branchName)) replaces the old static
-// project(":archie-core-common") reference every one of these was hardcoded to before Stonecutter.
-// ProjectNode.project resolves straight to the sibling's Gradle Project - confirmed against
-// Stonecutter 0.9.7's own sources (GradleMember.project), not just the older reference template.
 val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
 	"No common project for $project"
 }
@@ -85,17 +81,8 @@ dependencies {
 	testRuntimeOnly(libs.junit.jupiter.engine)
 	runtimeLibrary(libs.kotlinx.coroutines.test)
 
-	// Depends directly on common's own "jar" task output (a real zip) rather than through a
-	// project(path, configuration) reference or Loom's common()/transformProductionX mechanism -
-	// both produce a circular task dependency / broken variant lookup under Stonecutter's nested
-	// per-version project paths (confirmed live; not present pre-Stonecutter). A raw SourceSetOutput
-	// FileCollection (plain class/resource directories) almost works the same way, but breaks
-	// shadowJar - Shadow's copy action expects zip-safe entries, not directories, and throws
-	// MissingPropertyException: No such property: mode. Safe here since fabric and neoforge already
-	// share one mapping namespace (officialMojangMappings), so transformProductionX's per-platform
-	// remap was never doing anything for this project anyway.
-	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	"shadowCommon"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
 }
 
 modResources {
diff --git a/core/neoforge/build.gradle.kts b/core/neoforge/build.gradle.kts
index db1152913..37307559d 100644
--- a/core/neoforge/build.gradle.kts
+++ b/core/neoforge/build.gradle.kts
@@ -13,8 +13,6 @@ architectury {
 	neoForge()
 }
 
-// See core/fabric/build.gradle.kts for why this goes through node.sibling() rather than a
-// hardcoded project path.
 val commonNode = requireNotNull(extensions.getByType<StonecutterBuildExtension>().node.sibling("common")) {
 	"No common project for $project"
 }
@@ -44,10 +42,6 @@ loom {
 	mods {
 		maybeCreate("main").apply {
 			sourceSet(sourceSets.main.get())
-			// actualizer only merges Kotlin expect/actual source into this project's own
-			// compilation - plain Java files in archie-core-common (e.g. mixin classes with no
-			// actual/expect involvement) never get copied in, so they're invisible to FML's
-			// dev-mode module layer unless their sourceSet is also registered here directly.
 			sourceSet(common.sourceSets.main.get())
 		}
 	}
@@ -80,9 +74,6 @@ dependencies {
 	bundleRuntimeLibrary(libs.kotlinx.serialization.json5)
 	bundleRuntimeLibrary(libs.kotlinx.serialization.cbor)
 	bundleRuntimeLibrary(compose.runtime)
-	// compose.runtime's own transitive deps; Loom's dev-run GAMELIBRARY discovery doesn't walk
-	// transitive deps of a bundled library the way production JarJar packaging does, so each needs
-	// its own explicit declaration to be visible during runClient/runClientNeoForge.
 	bundleRuntimeLibrary(libs.androidx.annotation)
 	bundleRuntimeLibrary(libs.androidx.collection)
 	bundleRuntimeLibrary(libs.okio)
@@ -100,10 +91,8 @@ dependencies {
 	testRuntimeOnly(libs.junit.jupiter.engine)
 	runtimeLibrary(libs.kotlinx.coroutines.test)
 
-	// See core/fabric/build.gradle.kts for why this depends on common's "jar" task output directly
-	// rather than through a project(path, configuration) reference or a raw SourceSetOutput.
-	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	"shadowCommon"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
 }
 
 modResources {
diff --git a/datagen/common/build.gradle.kts b/datagen/common/build.gradle.kts
index 78746cd0b..3c26db2fc 100644
--- a/datagen/common/build.gradle.kts
+++ b/datagen/common/build.gradle.kts
@@ -15,18 +15,7 @@ loom {
 }
 
 dependencies {
-	// A cross-tree api(project(...)) dependency between two "common"-mode (architectury.common(...))
-	// projects triggers a circular compileJava<->compileKotlin task dependency under Stonecutter's
-	// nested per-version project paths (confirmed live by temporarily removing this line - the
-	// cycle disappeared) - same family of issue as the core/fabric<->core/common one, just between
-	// two common-mode projects instead of a loader depending on its own common. Depend on
-	// core-common's "jar" task output directly instead; see core/fabric/build.gradle.kts.
-	//
-	// files() dependencies carry no transitive module metadata, unlike the old
-	// project(path, "namedElements") dependency this replaces - so core-common's own `api`/`modApi`
-	// surface (which datagen-common's code also relies on, e.g. Compose types) has to be repeated
-	// here explicitly. Keep this in sync with core/common/build.gradle.kts's own dependencies block.
-	api(files(coreCommon.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreCommon.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
 	api(libs.kotlinx.serialization)
 	api(libs.kotlinx.serialization.json)
 	api(libs.kotlinx.serialization.nbt) { isTransitive = false }
diff --git a/datagen/fabric/build.gradle.kts b/datagen/fabric/build.gradle.kts
index b14638eec..a161112f9 100644
--- a/datagen/fabric/build.gradle.kts
+++ b/datagen/fabric/build.gradle.kts
@@ -86,16 +86,12 @@ dependencies {
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	// See core/fabric/build.gradle.kts for why these depend on the sibling's "jar" task output
-	// directly rather than through a project(path, configuration) reference - a plain cross-tree
-	// api(project(...)) edge to core-fabric hits the exact same circular compileJava<->compileKotlin
-	// task dependency under Stonecutter's nested per-version paths (confirmed live), regardless of
-	// which configuration is targeted. files() dependencies carry no transitive module metadata,
-	// so core-fabric's own `modApi`/`modCompileOnlyApi` surface is repeated below explicitly - keep
-	// this in sync with core/fabric/build.gradle.kts's own dependencies block.
-	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(coreFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreFabric.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
 	modApi(libs.architectury.fabric)
+	runtimeLibrary(libs.kotlinx.serialization.nbt)
+	runtimeLibrary(libs.kotlinx.serialization.toml)
+	runtimeLibrary(libs.kotlinx.serialization.json5)
 	runtimeLibrary(compose.runtime)
 }
 
diff --git a/datagen/neoforge/build.gradle.kts b/datagen/neoforge/build.gradle.kts
index 7a96ffe0f..3101b7510 100644
--- a/datagen/neoforge/build.gradle.kts
+++ b/datagen/neoforge/build.gradle.kts
@@ -86,13 +86,11 @@ dependencies {
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	// See core/fabric/build.gradle.kts for why these depend on the sibling's "jar" task output
-	// directly rather than through a project(path, configuration) reference - a plain cross-tree
-	// api(project(...)) edge to core-neoforge hits the same circular compileJava<->compileKotlin
-	// task dependency under Stonecutter's nested per-version paths. files() dependencies carry no
-	// transitive module metadata, so core-neoforge's Compose dependency is repeated here explicitly.
-	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(coreNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreNeoforge.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	runtimeLibrary(libs.kotlinx.serialization.nbt)
+	runtimeLibrary(libs.kotlinx.serialization.toml)
+	runtimeLibrary(libs.kotlinx.serialization.json5)
 	runtimeLibrary(compose.runtime)
 }
 
diff --git a/gametest/fabric/build.gradle.kts b/gametest/fabric/build.gradle.kts
index 7020c7390..5573badc6 100644
--- a/gametest/fabric/build.gradle.kts
+++ b/gametest/fabric/build.gradle.kts
@@ -86,16 +86,14 @@ dependencies {
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	// See core/fabric/build.gradle.kts and datagen/fabric/build.gradle.kts for why these depend on
-	// the sibling's "jar" task output directly, and why the Compose/Architectury/storage/coroutines
-	// deps above and below are repeated - the actualizer merges gametest-common's own source files
-	// into this project's own compilation, so it needs gametest-common's compile-time deps directly
-	// too, not just its output.
-	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(coreFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreFabric.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
 	modApi(libs.architectury.fabric)
 	modImplementation(libs.storage.common)
 	modImplementation(libs.storage.resources.common)
+	runtimeLibrary(libs.kotlinx.serialization.nbt)
+	runtimeLibrary(libs.kotlinx.serialization.toml)
+	runtimeLibrary(libs.kotlinx.serialization.json5)
 	runtimeLibrary(compose.runtime)
 }
 
diff --git a/gametest/neoforge/build.gradle.kts b/gametest/neoforge/build.gradle.kts
index e365ccfd6..301a1be2a 100644
--- a/gametest/neoforge/build.gradle.kts
+++ b/gametest/neoforge/build.gradle.kts
@@ -95,19 +95,12 @@ dependencies {
 	testImplementation(libs.junit.jupiter.api)
 	testRuntimeOnly(libs.junit.jupiter.engine)
 
-	// See core/fabric/build.gradle.kts and datagen/neoforge/build.gradle.kts for why these depend on
-	// the sibling's "jar" task output directly, and why the Compose/storage/coroutines deps above
-	// and below are repeated - the actualizer merges gametest-common's own source files into this
-	// project's own compilation, so it needs gametest-common's compile-time deps directly too, not
-	// just its output.
-	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(coreNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	// The loader-specific storage-neoforge variant, not storage-common - NeoForge's remap pipeline
-	// doesn't correctly handle earth.terrarium.common_storage_lib's common artifact directly (same
-	// family of gap as the documented Cloche NeoForge remapCommon limitation for this library),
-	// which surfaced here as an ambiguous ItemResource.of overload resolving against raw Fabric
-	// intermediary-mapped parameter types instead of official ones.
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreNeoforge.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
 	modImplementation(libs.storage.neoforge) { exclude(group = "curse.maven") }
+	runtimeLibrary(libs.kotlinx.serialization.nbt)
+	runtimeLibrary(libs.kotlinx.serialization.toml)
+	runtimeLibrary(libs.kotlinx.serialization.json5)
 	runtimeLibrary(compose.runtime)
 }
 
diff --git a/test/fabric/build.gradle.kts b/test/fabric/build.gradle.kts
index 6785080b6..0b314b8ef 100644
--- a/test/fabric/build.gradle.kts
+++ b/test/fabric/build.gradle.kts
@@ -119,14 +119,22 @@ dependencies {
 	// and below are repeated - the actualizer merges test-common's own source files into this
 	// project's own compilation, so it needs test-common's compile-time deps directly too, not just
 	// its output.
-	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	"shadowCommon"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(coreFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(datagenFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(gametestFabric.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	runtimeOnly(files(coreCommon.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreFabric.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(datagenFabric.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(gametestFabric.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	runtimeOnly(files(coreCommon.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
 	modImplementation(libs.storage.common)
 	modImplementation(libs.storage.resources.common)
+	// files() dependencies carry no runtime GAMELIBRARY discovery either - the serialization format
+	// add-ons core-fabric bundles at runtime (nbt/toml/json5, needed by Archie's own Config system
+	// at init) don't propagate, so they're repeated here too. Confirmed missing live: a
+	// NoClassDefFoundError for io.github.xn32.json5k.ConfigBuilder when actually launching this
+	// project.
+	runtimeLibrary(libs.kotlinx.serialization.nbt)
+	runtimeLibrary(libs.kotlinx.serialization.toml)
+	runtimeLibrary(libs.kotlinx.serialization.json5)
 	runtimeLibrary(compose.runtime)
 }
 
diff --git a/test/neoforge/build.gradle.kts b/test/neoforge/build.gradle.kts
index b3d240e52..944915af2 100644
--- a/test/neoforge/build.gradle.kts
+++ b/test/neoforge/build.gradle.kts
@@ -128,11 +128,19 @@ dependencies {
 	// on the sibling's "jar" task output directly, and why the Compose/coroutines deps above and
 	// below are repeated - the actualizer merges test-common's own source files into this project's
 	// own compilation, so it needs test-common's compile-time deps directly too, not just its output.
-	"common"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	"shadowCommon"(files(common.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(coreNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(datagenNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
-	api(files(gametestNeoforge.tasks.named<org.gradle.api.tasks.bundling.Jar>("jar").flatMap { it.archiveFile }))
+	"common"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	"shadowCommon"(files(common.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(coreNeoforge.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(datagenNeoforge.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	api(files(gametestNeoforge.tasks.named<Jar>("jar").flatMap { it.archiveFile }))
+	// files() dependencies carry no runtime GAMELIBRARY discovery either - the serialization format
+	// add-ons core-neoforge bundles at runtime (nbt/toml/json5, needed by Archie's own Config system
+	// at init) don't propagate, so they're repeated here too. Confirmed missing live: a
+	// NoClassDefFoundError for io.github.xn32.json5k.ConfigBuilder when actually launching this
+	// project.
+	runtimeLibrary(libs.kotlinx.serialization.nbt)
+	runtimeLibrary(libs.kotlinx.serialization.toml)
+	runtimeLibrary(libs.kotlinx.serialization.json5)
 	runtimeLibrary(compose.runtime)
 }
 

From 84e2e6517bf95c22a45f40bdcaf3fd3d29507aa1 Mon Sep 17 00:00:00 2001
From: KernelPanic <aaronkoonce25@gmail.com>
Date: Fri, 28 Aug 2026 20:09:32 -0400
Subject: [PATCH 5/5] fix(build): repair Maven/CurseForge/Modrinth/Dokka
 publishing under Stonecutter

Stonecutter's nested per-version project layout broke several things that
keyed off the pre-migration flat project names:

- Maven publish's artifactId was "1.21.1" for every module (not just the
  intended -fabric/-datagen-common/etc. suffix missing) - the artifactId
  assignment ran before base.archivesName reached its final value. Moved it
  into afterEvaluate{}. Also fixed the archie-test exclusion, which checked
  project.name (now always "1.21.1") instead of project.path.
- modfusioner's fusejars task silently no-op'd ("No projects were found")
  since it resolves projects by bare Project.name, and every Stonecutter tree
  now has a leaf literally named "fabric"/"neoforge". Anchored it on the
  unique ":core" container project and override inputFile via
  gradle.projectsEvaluated once the real remapJar output paths are known.
- Dokka's per-module aggregation dependency block had been commented out
  during the migration (stale flat project paths) - rebuilt against
  Stonecutter's real :tree:branch:version paths.
- gameVersions in the publisher{} block now derives from
  libs.versions.minecraft instead of a separately hardcoded "1.21.1" literal.

Verified: generatePomFileForMavenPublication produces correct artifactIds,
test tree is excluded, fusejars produces a real merged jar (both
fabric.mod.json and neoforge.mods.toml present), dokka configuration
resolves all 9 module paths, and publishCurseforge/publishModrinth dry-run
(debug=true) cleanly against live CurseForge/Modrinth data.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WW8YqJDBH8AFaTFirpCQGZ
---
 build.gradle.kts | 120 ++++++++++++++++++++++++++++-------------------
 1 file changed, 71 insertions(+), 49 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index fd3dcda64..f1509856d 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,6 +1,8 @@
+import com.hypherionmc.modfusioner.plugin.FusionerExtension
 import net.fabricmc.loom.api.LoomGradleExtensionAPI
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.tasks.bundling.AbstractArchiveTask
 import org.jetbrains.kotlin.konan.properties.loadProperties
 
 plugins {
@@ -128,7 +130,11 @@ subprojects {
 	// One MavenPublication per module, published to kernelpanicsoft.net's Reposilite - archie-core/
 	// -datagen/-gametest are real consumable libraries; archie-test is a dev playground, never
 	// published (matches fusioner/dokka's own product/test split above).
-	if (!project.name.startsWith("archie-test-")) {
+	//
+	// Under Stonecutter, `project.name` is just the version segment ("1.21.1") for every leaf in
+	// every tree - it no longer distinguishes "test" from the rest. `project.path` still does
+	// (":test:common:1.21.1" etc.), since Stonecutter nests leaves under their tree name.
+	if (!project.path.startsWith(":test:")) {
 		// allprojects{} (below) is what normally applies these, but it's declared after this
 		// subprojects{} block and hasn't run for this project yet - apply is idempotent, so
 		// re-applying here just guarantees ordering for the components["java"]/publishing{} access
@@ -136,28 +142,35 @@ subprojects {
 		apply(plugin = "java")
 		apply(plugin = "maven-publish")
 
-		extensions.configure<PublishingExtension>("publishing") {
-			publications {
-				create<MavenPublication>("maven") {
-					artifactId = base.archivesName.get()
-					from(components["java"])
+		// base.archivesName only reaches its final "archie-core-fabric"-style value once this leaf's
+		// own build.gradle.kts runs (module scripts execute after this subprojects{} block, and
+		// allprojects{} - which seeds the "archie-core" prefix - runs after it too) - reading it here
+		// would still see the base plugin's raw default ("1.21.1", from project.name). Defer until
+		// this project has finished configuring.
+		afterEvaluate {
+			extensions.configure<PublishingExtension>("publishing") {
+				publications {
+					create<MavenPublication>("maven") {
+						artifactId = base.archivesName.get()
+						from(components["java"])
+					}
 				}
-			}
-
-			repositories {
-				mavenLocal()
-				maven {
-					name = "Reposilite"
-					val releasesUrl = "https://maven.kernelpanicsoft.net/releases"
-					val snapshotsUrl = "https://maven.kernelpanicsoft.net/snapshots"
 
-					url = uri(if (version.toString().endsWith("SNAPSHOT")) snapshotsUrl else releasesUrl)
-
-					credentials {
-						username = localProperties?.getProperty("reposilite.username")
-							?: System.getenv("REPOSILITE_USERNAME")
-						password = localProperties?.getProperty("reposilite.password")
-							?: System.getenv("REPOSILITE_PASSWORD")
+				repositories {
+					mavenLocal()
+					maven {
+						name = "Reposilite"
+						val releasesUrl = "https://maven.kernelpanicsoft.net/releases"
+						val snapshotsUrl = "https://maven.kernelpanicsoft.net/snapshots"
+
+						url = uri(if (version.toString().endsWith("SNAPSHOT")) snapshotsUrl else releasesUrl)
+
+						credentials {
+							username = localProperties?.getProperty("reposilite.username")
+								?: System.getenv("REPOSILITE_USERNAME")
+							password = localProperties?.getProperty("reposilite.password")
+								?: System.getenv("REPOSILITE_PASSWORD")
+						}
 					}
 				}
 			}
@@ -213,14 +226,38 @@ fusioner {
 	jarVersion = project.version.toString()
 	outputDirectory = "build/artifacts"
 
+	// modfusioner finds each side's source project by bare Project.name (case-insensitive), searched
+	// across the *entire* build - but under Stonecutter every tree (core/datagen/gametest/test) has a
+	// leaf literally named "fabric" and one named "neoforge", so no name resolves uniquely to core's.
+	// ":core" is an existing, globally-unique container project name - point both sides at it just to
+	// satisfy modfusioner's "did we find >= 2 projects" check; `inputFile` (set below, once every
+	// project has finished configuring) overrides where the actual jar is read from, resolved relative
+	// to that anchor project's directory.
 	fabric {
-		projectName = "archie-core-fabric"
-		inputTaskName = "remapJar"
+		projectName = "core"
 	}
 
 	neoforge {
-		projectName = "archie-core-neoforge"
-		inputTaskName = "remapJar"
+		projectName = "core"
+	}
+}
+
+// modfusioner reads `inputFile` as `File(<projectName's projectDir>, inputFile)` - `projectName` above
+// is just an anchor, so compute the real remapJar output path here (deferred to gradle.projectsEvaluated
+// so base.archivesName - and therefore the jar's real filename - has reached its final value) and
+// express it relative to :core's directory.
+gradle.projectsEvaluated {
+	val mcVersion = libs.versions.minecraft.get()
+	val coreDir = project(":core").projectDir
+
+	fun remapJarFile(path: String) =
+		(project(path).tasks.named("remapJar").get() as AbstractArchiveTask).archiveFile.get().asFile
+
+	project.extensions.getByType<FusionerExtension>().let { fusionerExtension ->
+		fusionerExtension.fabricConfiguration.inputFile =
+			remapJarFile(":core:fabric:$mcVersion").relativeTo(coreDir).path
+		fusionerExtension.neoforgeConfiguration.inputFile =
+			remapJarFile(":core:neoforge:$mcVersion").relativeTo(coreDir).path
 	}
 }
 
@@ -237,7 +274,7 @@ publisher {
 
 	projectVersion = "${libs.versions.minecraft.get()}-${project.version}"
 	displayName = "Archie-Merged-${projectVersion.get()}"
-	gameVersions = listOf("1.21.1")
+	gameVersions = listOf(libs.versions.minecraft.get())
 	loaders = listOf("neoforge", "fabric")
 	curseEnvironment = "both"
 	versionType = "alpha"
@@ -255,17 +292,14 @@ publisher {
 	}
 }
 
-// dependencies {
-// 	dokka(project(":archie-core-common")) { isTransitive = false } // TODO: fix paths for Stonecutter's generated projects
-// 	dokka(project(":archie-core-fabric")) { isTransitive = false }
-// 	dokka(project(":archie-core-neoforge")) { isTransitive = false }
-// 	dokka(project(":archie-datagen-common")) { isTransitive = false }
-// 	dokka(project(":archie-datagen-fabric")) { isTransitive = false }
-// 	dokka(project(":archie-datagen-neoforge")) { isTransitive = false }
-// 	dokka(project(":archie-gametest-common")) { isTransitive = false }
-// 	dokka(project(":archie-gametest-fabric")) { isTransitive = false }
-// 	dokka(project(":archie-gametest-neoforge")) { isTransitive = false }
-// }
+dependencies {
+	val mcVersion = libs.versions.minecraft.get()
+	listOf("core", "datagen", "gametest").forEach { tree ->
+		listOf("common", "fabric", "neoforge").forEach { branch ->
+			dokka(project(":$tree:$branch:$mcVersion")) { isTransitive = false }
+		}
+	}
+}
 
 tasks {
 	build {
@@ -282,20 +316,8 @@ tasks {
 		group = "publishing"
 		val tag = rootProject.version.toString().substringBeforeLast(".")
 		workingDir = rootDir
-		// --alias-type redirect: mike's default ("symlink") writes the "latest" alias as an
-		// actual symlink into the gh-pages branch, which GitHub's own automatic Pages
-		// build-and-deploy (triggered whenever gh-pages is pushed, separate from this task)
-		// rejects outright ("content does not contain any hard links, symlinks"). "redirect"
-		// makes the alias a small HTML redirect page instead - no symlink, same effect for
-		// visitors.
 		commandLine("mike", "deploy", "--push", "--update-aliases", "--alias-type", "redirect", tag, "latest")
 	}
-	// modpublisher's changelog reads CHANGELOG.md straight off disk when a publish task runs - it
-	// doesn't know about git tags or PRs. .github/workflows/release-notes.yaml (reactive, post-tag)
-	// can't help here: by the time it would generate this release's entry, the publish task attached
-	// to the tag has already read (and shipped) whatever was on disk before. This task closes that
-	// gap by generating CHANGELOG.md synchronously - see .github/scripts/generate_release_notes.py's
-	// module docstring for the two call shapes.
 	register<Exec>("generateChangelog") {
 		group = "publishing"
 		workingDir = rootDir