Create a new CraftingInput for each craft

It's not actually safe to reuse this, as we need to recompute the
internal StackedContents each time the inventory changes, otherwise
ShapelessRecipe.matches will continue to return true, even if the actual
inventory doesn't include the required items.

Fixes #2094

.editorconfig

@@ -18,11 +18,6 @@ ij_any_if_brace_force = if_multiline
 ij_any_for_brace_force = if_multiline
 ij_any_spaces_within_array_initializer_braces = true
 
-ij_kotlin_allow_trailing_comma = true
-ij_kotlin_allow_trailing_comma_on_call_site = true
-ij_kotlin_method_parameters_wrap = off
-ij_kotlin_call_parameters_wrap = off
-
 [*.md]
 trim_trailing_whitespace = false
 
@@ -31,3 +26,16 @@ indent_size = 2
 
 [*.yml]
 indent_size = 2
+
+[{*.kt,*.kts}]
+ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL
+ij_kotlin_continuation_indent_size = 4
+ij_kotlin_spaces_around_equality_operators = true
+
+ij_kotlin_allow_trailing_comma = true
+ij_kotlin_allow_trailing_comma_on_call_site = true
+
+# Prefer to handle these manually
+ij_kotlin_method_parameters_wrap = off
+ij_kotlin_call_parameters_wrap = off
+ij_kotlin_extends_list_wrap = off

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -1,17 +1,17 @@
 name: Bug report
 description: Report some misbehaviour in the mod
 labels: [ bug ]
+type: bug
 body:
 - type: dropdown
   id: mc-version
   attributes:
     label: Minecraft Version
-    description: What version of Minecraft are you using?
+    description: |
+        What version of Minecraft are you using? If your version is not listed, please try to reproduce on one of the supported versions.
     options:
-      - 1.16.x
-      - 1.18.x
-      - 1.19.x
-      - 1.20.x
+      - 1.20.1
+      - 1.21.x
   validations:
     required: true
 - type: input
@@ -28,8 +28,7 @@ body:
     label: Details
     description: |
       Description of the bug. Please include the following:
-      - Logs: These will be located in the `logs/` directory of your Minecraft
-        instance. Please upload them as a gist or directly into this editor.
-      - Detailed reproduction steps: sometimes I can spot a bug pretty easily,
-        but often it's much more obscure. The more information I have to help
-        reproduce it, the quicker it'll get fixed.
+      - Logs: These will be located in the `logs/` directory of your Minecraft instance. This is always useful, even if it doesn't include errors, so please upload this!
+      - Detailed reproduction steps: sometimes I can spot a bug pretty easily, but often it's much more obscure. The more information I have to help reproduce it, the quicker it'll get fixed.
+
+      ![A gif of burning text reading "Upload your logs!!!"](https://tweaked.cc/images/logs.gif)

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,6 +2,7 @@
 name: Feature request
 about: Suggest an idea or improvement
 labels: enhancement
+type: feature
 ---
 
 <!--

.github/workflows/main-ci.yml

@@ -9,16 +9,16 @@ jobs:
 
     steps:
     - name: 📥 Clone repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     - name: 📥 Set up Java
-      uses: actions/setup-java@v3
+      uses: actions/setup-java@v4
       with:
-        java-version: 17
+        java-version: 21
         distribution: 'temurin'
 
     - name: 📥 Setup Gradle
-      uses: gradle/gradle-build-action@v2
+      uses: gradle/actions/setup-gradle@v3
       with:
         cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
 
@@ -30,8 +30,28 @@ jobs:
     - name: ⚒️ Build
       run: ./gradlew assemble || ./gradlew assemble
 
+    - name: 📦 Prepare Jars
+      run: |
+        # Find the main jar and append the git hash onto it.
+        mkdir -p jars
+        find projects/forge/build/libs projects/fabric/build/libs -type f -regex '.*[0-9.]+\(-SNAPSHOT\)?\.jar$' -exec bash -c 'cp {} "jars/$(basename {} .jar)-$(git rev-parse HEAD).jar"' \;
+
+    - name: 📤 Upload Jar
+      uses: actions/upload-artifact@v4
+      with:
+        name: CC-Tweaked
+        path: ./jars
+
+    - name: Cache pre-commit
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pre-commit
+        key: pre-commit-3|${{ env.pythonLocation }}|${{ hashFiles('.pre-commit-config.yaml') }}
+
     - name: 💡 Lint
-      uses: pre-commit/action@v3.0.0
+      run: |
+        pipx install pre-commit
+        pre-commit run --show-diff-on-failure --color=always
 
     - name: 🧪 Run tests
       run: ./gradlew test validateMixinNames checkChangelog
@@ -42,30 +62,10 @@ jobs:
     - name: 🧪 Run integration tests
       run: ./gradlew runGametest
 
-    - name: 🧪 Run client tests
-      run: ./gradlew runGametestClient # Not checkClient, as no point running rendering tests.
-      # These are a little flaky on GH actions: its useful to run them, but don't break the build.
-      continue-on-error: true
-
     - name: 🧪 Parse test reports
       run: ./tools/parse-reports.py
       if: ${{ failure() }}
 
-    - name: 📦 Prepare Jars
-      run: |
-        # Find the main jar and append the git hash onto it.
-        mkdir -p jars
-        find projects/forge/build/libs projects/fabric/build/libs -type f -regex '.*[0-9.]+\(-SNAPSHOT\)?\.jar$' -exec bash -c 'cp {} "jars/$(basename {} .jar)-$(git rev-parse HEAD).jar"' \;
-
-    - name: 📤 Upload Jar
-      uses: actions/upload-artifact@v3
-      with:
-        name: CC-Tweaked
-        path: ./jars
-
-    - name: 📤 Upload coverage
-      uses: codecov/codecov-action@v3
-
   build-core:
     strategy:
       fail-fast: false
@@ -81,24 +81,28 @@ jobs:
     runs-on: ${{ matrix.uses }}
 
     steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
+    - name: 📥 Clone repository
+      uses: actions/checkout@v4
 
-    - name: Set up Java
-      uses: actions/setup-java@v3
+    - name: 📥 Set up Java
+      uses: actions/setup-java@v4
       with:
-        java-version: 17
+        java-version: 21
         distribution: 'temurin'
 
-    - name: Setup Gradle
-      uses: gradle/gradle-build-action@v2
+    - name: 📥 Setup Gradle
+      uses: gradle/actions/setup-gradle@v3
       with:
         cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
 
-    - name: Run tests
+    - name: ⚒️ Build
+      run: |
+        ./gradlew --configure-on-demand :core:assemble
+
+    - name: 🧪 Run tests
       run: |
         ./gradlew --configure-on-demand :core:test
 
-    - name: Parse test reports
+    - name: 🧪 Parse test reports
       run: python3 ./tools/parse-reports.py
       if: ${{ failure() }}

.github/workflows/make-doc.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-DEST="${GITHUB_REF#refs/*/}"
-echo "Uploading docs to https://tweaked.cc/$DEST"
-
-# Setup ssh key
-mkdir -p "$HOME/.ssh/"
-echo "$SSH_KEY" > "$HOME/.ssh/key"
-chmod 600 "$HOME/.ssh/key"
-
-# And upload
-rsync -avc -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no -p $SSH_PORT" \
-      "$GITHUB_WORKSPACE/projects/web/build/site/" \
-      "$SSH_USER@$SSH_HOST:/$DEST"
-rsync -avc -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no -p $SSH_PORT" \
-      "$GITHUB_WORKSPACE/projects/common-api/build/docs/javadoc/" \
-      "$SSH_USER@$SSH_HOST:/$DEST/javadoc"

.github/workflows/make-doc.yml

@@ -3,8 +3,7 @@ name: Build documentation
 on:
   push:
     branches:
-    - mc-1.19.x
-    - mc-1.20.x
+    - mc-*
 
 jobs:
   make_doc:
@@ -12,30 +11,25 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
+    - name: 📥 Clone repository
+      uses: actions/checkout@v4
 
-    - name: Set up Java
-      uses: actions/setup-java@v1
+    - name: 📥 Set up Java
+      uses: actions/setup-java@v4
       with:
-        java-version: 17
+        java-version: 21
         distribution: 'temurin'
 
-    - name: Setup Gradle
-      uses: gradle/gradle-build-action@v2
+    - name: 📥 Setup Gradle
+      uses: gradle/actions/setup-gradle@v3
       with:
         cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/mc-') }}
 
-    - name: Build with Gradle
-      run: ./gradlew compileJava --no-daemon || ./gradlew compileJava --no-daemon
+    - name: ⚒️ Generate documentation
+      run: ./gradlew docWebsite --no-daemon
 
-    - name: Generate documentation
-      run: ./gradlew docWebsite :common-api:javadoc  --no-daemon
-
-    - name: Upload documentation
-      run: .github/workflows/make-doc.sh 2> /dev/null
-      env:
-        SSH_KEY:  ${{ secrets.SSH_KEY  }}
-        SSH_USER: ${{ secrets.SSH_USER }}
-        SSH_HOST: ${{ secrets.SSH_HOST }}
-        SSH_PORT: ${{ secrets.SSH_PORT }}
+    - name: 📤 Upload Jar
+      uses: actions/upload-artifact@v4
+      with:
+        name: Documentation
+        path: ./projects/web/build/site/

.gitignore

@@ -9,6 +9,7 @@
 /projects/*/logs
 /projects/fabric/fabricloader.log
 /projects/*/build
+/projects/*/src/test/generated_tests/
 /buildSrc/build
 /out
 /buildSrc/out
@@ -26,6 +27,7 @@
 *.iml
 .idea
 .gradle
+.kotlin
 *.DS_Store
 
 /.classpath

.gitpod.yml

@@ -1,26 +0,0 @@
-# SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: MPL-2.0
-
-image:
-  file: config/gitpod/Dockerfile
-
-ports:
-  - port: 25565
-    onOpen: notify
-
-vscode:
-  extensions:
-    - eamodio.gitlens
-    - github.vscode-pull-request-github
-    - ms-azuretools.vscode-docker
-    - redhat.java
-    - richardwillis.vscode-gradle
-    - vscjava.vscode-java-debug
-    - vscode.github
-
-tasks:
-  - name: Setup pre-commit hool
-    init: pre-commit install --allow-missing-config
-  - name: Install npm packages
-    init: npm ci

.pre-commit-config.yaml

@@ -27,7 +27,7 @@ repos:
     exclude: "^(.*\\.(bat)|LICENSE)$"
 
 - repo: https://github.com/fsfe/reuse-tool
-  rev: v2.1.0
+  rev: v5.0.2
   hooks:
   - id: reuse
 
@@ -58,6 +58,7 @@ repos:
 exclude: |
   (?x)^(
     projects/[a-z]+/src/generated|
+    projects/[a-z]+/src/examples/generatedResources|
     projects/core/src/test/resources/test-rom/data/json-parsing/|
     .*\.dfpwm
   )

.reuse/dep5

@@ -1,100 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Source: https://github.com/cc-tweaked/cc-tweaked
-Upstream-Name: CC: Tweaked
-Upstream-Contact: Jonathan Coates <git@squiddev.cc>
-
-Files:
-  projects/common/src/main/resources/assets/computercraft/sounds.json
-  projects/common/src/main/resources/assets/computercraft/sounds/empty.ogg
-  projects/common/src/testMod/resources/data/cctest/computercraft/turtle_upgrades/*
-  projects/common/src/testMod/resources/data/cctest/structures/*
-  projects/fabric/src/generated/*
-  projects/forge/src/generated/*
-  projects/web/src/htmlTransform/export/index.json
-  projects/web/src/htmlTransform/export/items/minecraft/*
-Comment: Generated/data files are CC0.
-Copyright: The CC: Tweaked Developers
-License: CC0-1.0
-
-Files:
-  doc/images/*
-  package.json
-  package-lock.json
-  projects/common/src/client/resources/computercraft-client.mixins.json
-  projects/common/src/main/resources/assets/minecraft/shaders/core/computercraft/monitor_tbo.json
-  projects/common/src/main/resources/computercraft.mixins.json
-  projects/common/src/testMod/resources/computercraft-gametest.mixins.json
-  projects/common/src/testMod/resources/data/computercraft/loot_tables/treasure_disk.json
-  projects/common/src/testMod/resources/pack.mcmeta
-  projects/core/src/main/resources/data/computercraft/lua/rom/modules/command/.ignoreme
-  projects/core/src/main/resources/data/computercraft/lua/rom/modules/main/.ignoreme
-  projects/core/src/main/resources/data/computercraft/lua/rom/modules/turtle/.ignoreme
-  projects/core/src/main/resources/data/computercraft/lua/rom/motd.txt
-  projects/fabric-api/src/main/modJson/fabric.mod.json
-  projects/fabric/src/client/resources/computercraft-client.fabric.mixins.json
-  projects/fabric/src/main/resources/computercraft.fabric.mixins.json
-  projects/fabric/src/main/resources/fabric.mod.json
-  projects/fabric/src/testMod/resources/computercraft-gametest.fabric.mixins.json
-  projects/fabric/src/testMod/resources/fabric.mod.json
-  projects/forge/src/client/resources/computercraft-client.forge.mixins.json
-  projects/web/src/frontend/mount/.settings
-  projects/web/src/frontend/mount/example.nfp
-  projects/web/src/frontend/mount/example.nft
-  projects/web/src/frontend/mount/expr_template.lua
-  projects/web/tsconfig.json
-Comment: Several assets where it's inconvenient to create a .license file.
-Copyright: The CC: Tweaked Developers
-License: MPL-2.0
-
-Files:
-  doc/logo.png
-  doc/logo-darkmode.png
-  projects/common/src/main/resources/assets/computercraft/models/*
-  projects/common/src/main/resources/assets/computercraft/textures/*
-  projects/common/src/main/resources/pack.mcmeta
-  projects/common/src/main/resources/pack.png
-  projects/core/src/main/resources/assets/computercraft/textures/gui/term_font.png
-  projects/core/src/main/resources/data/computercraft/lua/rom/autorun/.ignoreme
-  projects/core/src/main/resources/data/computercraft/lua/rom/help/*
-  projects/core/src/main/resources/data/computercraft/lua/rom/programs/fun/advanced/levels/*
-  projects/web/src/htmlTransform/export/items/computercraft/*
-Comment: Bulk-license original assets as CCPL.
-Copyright: 2011 Daniel Ratcliffe
-License: LicenseRef-CCPL
-
-Files:
-  projects/common/src/main/resources/assets/computercraft/lang/cs_cz.json
-  projects/common/src/main/resources/assets/computercraft/lang/ko_kr.json
-  projects/common/src/main/resources/assets/computercraft/lang/pl_pl.json
-  projects/common/src/main/resources/assets/computercraft/lang/pt_br.json
-  projects/common/src/main/resources/assets/computercraft/lang/ru_ru.json
-  projects/common/src/main/resources/assets/computercraft/lang/uk_ua.json
-  projects/common/src/main/resources/assets/computercraft/lang/zh_cn.json
-Comment: Community-contributed license files
-Copyright: 2017 The CC: Tweaked Developers
-License: LicenseRef-CCPL
-
-Files:
-  projects/common/src/main/resources/assets/computercraft/lang/*
-Comment: Community-contributed license files
-Copyright: 2017 The CC: Tweaked Developers
-License: MPL-2.0
-
-Files:
-  .github/*
-Comment:
-  GitHub build scripts are CC0. While we could add a header to each file,
-  it's unclear if it will break actions or issue templates in some way.
-Copyright: Jonathan Coates <git@squiddev.cc>
-License: CC0-1.0
-
-Files:
-  gradle/wrapper/*
-  gradlew
-  gradlew.bat
-Copyright: Gradle Inc
-License: Apache-2.0
-
-Files: projects/core/src/test/resources/test-rom/data/json-parsing/*
-Copyright: 2016 Nicolas Seriot
-License: MIT

CONTRIBUTING.md

@@ -22,16 +22,15 @@ If you have a bug, suggestion, or other feedback, the best thing to do is [file
 use the issue templates - they provide a useful hint on what information to provide.
 
 ## Translations
-Translations are managed through [Weblate], an online interface for managing language strings. This is synced
-automatically with GitHub, so please don't submit PRs adding/changing translations!
+Translations are managed through [CrowdIn], an online interface for managing language strings.
 
 ## Setting up a development environment
 In order to develop CC: Tweaked, you'll need to download the source code and then run it.
 
  - Make sure you've got the following software installed:
-   - Java Development Kit (JDK) installed. This can be downloaded from [Adoptium].
+   - Java Development Kit 21 (JDK). This can be downloaded from [Adoptium].
    - [Git](https://git-scm.com/).
-   - If you want to work on documentation, [NodeJS][node].
+   - [NodeJS 20 or later][node].
 
  - Download CC: Tweaked's source code:
    ```
@@ -49,9 +48,12 @@ If you want to run CC:T in a normal Minecraft instance, run `./gradlew assemble`
 `projects/forge/build/libs` (for Forge) or `projects/fabric/build/libs` (for Fabric).
 
 ## Developing CC: Tweaked
-Before making any major changes to CC: Tweaked, I'd recommend you have a read of the [the architecture
-document][architecture] first. While it's not a comprehensive document, it gives a good hint of where you should start
-looking to make your changes. As always, if you're not sure, [do ask the community][community]!
+Before making any major changes to CC: Tweaked, I'd recommend starting opening an issue or starting a discussion on
+GitHub first. It's often helpful to discuss features before spending time developing them!
+
+Once you're ready to start programming, have a read of the [the architecture document][architecture] first. While it's
+not a comprehensive document, it gives a good hint of where you should start looking to make your changes. As always, if
+you're not sure, [do ask the community][community]!
 
 ### Testing
 When making larger changes, it may be useful to write a test to make sure your code works as expected.
@@ -101,10 +103,10 @@ about how you can build on that until you've covered everything!
 [community]: README.md#community "Get in touch with the community."
 [Adoptium]: https://adoptium.net/temurin/releases?version=17 "Download OpenJDK 17"
 [illuaminate]: https://github.com/SquidDev/illuaminate/ "Illuaminate on GitHub"
-[weblate]: https://i18n.tweaked.cc/projects/cc-tweaked/minecraft/ "CC: Tweaked weblate instance"
 [docs]: https://tweaked.cc/ "CC: Tweaked documentation"
 [ldoc]: http://stevedonovan.github.io/ldoc/ "ldoc, a Lua documentation generator."
 [mc-test]: https://www.youtube.com/watch?v=vXaWOJTCYNg
 [busted]: https://github.com/Olivine-Labs/busted "busted: Elegant Lua unit testing."
 [node]: https://nodejs.org/en/ "Node.js"
 [architecture]: projects/ARCHITECTURE.md
+[Crowdin]: https://crowdin.com/project/cc-tweaked/

README.md

@@ -11,14 +11,13 @@ SPDX-License-Identifier: MPL-2.0
 </picture>
 
 [![Current build status](https://github.com/cc-tweaked/CC-Tweaked/workflows/Build/badge.svg)](https://github.com/cc-tweaked/CC-Tweaked/actions "Current build status")
-[![Download CC: Tweaked on CurseForge](https://img.shields.io/static/v1?label=Download&message=CC:%20Tweaked&color=E04E14&logoColor=E04E14&logo=CurseForge)][CurseForge]
 [![Download CC: Tweaked on Modrinth](https://img.shields.io/static/v1?label=Download&color=00AF5C&logoColor=00AF5C&logo=Modrinth&message=CC:%20Tweaked)][Modrinth]
 
 CC: Tweaked is a mod for Minecraft which adds programmable computers, turtles and more to the game. A fork of the
 much-beloved [ComputerCraft], it continues its legacy with improved performance and stability, along with a wealth of
 new features.
 
-CC: Tweaked can be installed from [CurseForge] or [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].
+CC: Tweaked can be installed from [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].
 
 ## Contributing
 Any contribution is welcome, be that using the mod, reporting bugs or contributing code. If you want to get started
@@ -26,8 +25,9 @@ developing the mod, [check out the instructions here](CONTRIBUTING.md#developing
 
 ## Community
 If you need help getting started with CC: Tweaked, want to show off your latest project, or just want to chat about
-ComputerCraft, do check out our [forum] and [GitHub discussions page][GitHub discussions]! There's also a fairly
-populated, albeit quiet [IRC channel][irc], if that's more your cup of tea.
+ComputerCraft, do check out our [GitHub discussions page][GitHub discussions]! There's also a fairly populated,
+albeit quiet IRC channel on [EsperNet], if that's more your cup of tea. You can join `#computercraft` through your
+desktop client, or online using [KiwiIRC].
 
 We also host fairly comprehensive documentation at [tweaked.cc](https://tweaked.cc/ "The CC: Tweaked website").
 
@@ -39,7 +39,7 @@ on is present.
 ```groovy
 repositories {
   maven {
-    url "https://squiddev.cc/maven/"
+    url "https://maven.squiddev.cc"
     content {
       includeGroup("cc.tweaked")
     }
@@ -51,9 +51,8 @@ dependencies {
   compileOnly("cc.tweaked:cc-tweaked-$mcVersion-common-api:$cctVersion")
 
   // Forge Gradle
-  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-core-api:$cctVersion")
-  compileOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge-api:$cctVersion"))
-  runtimeOnly(fg.deobf("cc.tweaked:cc-tweaked-$mcVersion-forge:$cctVersion"))
+  compileOnly("cc.tweaked:cc-tweaked-$mcVersion-forge-api:$cctVersion")
+  runtimeOnly("cc.tweaked:cc-tweaked-$mcVersion-forge:$cctVersion")
 
   // Fabric Loom
   modCompileOnly("cc.tweaked:cc-tweaked-$mcVersion-fabric-api:$cctVersion")
@@ -61,19 +60,6 @@ dependencies {
 }
 ```
 
-When using ForgeGradle, you may also need to add the following:
-
-```groovy
-minecraft {
-    runs {
-        configureEach {
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${buildDir}/createSrgToMcp/output.srg"
-        }
-    }
-}
-```
-
 You should also be careful to only use classes within the `dan200.computercraft.api` package. Non-API classes are
 subject to change at any point. If you depend on functionality outside the API (or need to mixin to CC:T), please file
 an issue to let me know!
@@ -82,10 +68,9 @@ We bundle the API sources with the jar, so documentation should be easily viewab
 the generated documentation [can be browsed online](https://tweaked.cc/javadoc/).
 
 [computercraft]: https://github.com/dan200/ComputerCraft "ComputerCraft on GitHub"
-[curseforge]: https://minecraft.curseforge.com/projects/cc-tweaked "Download CC: Tweaked from CurseForge"
 [modrinth]: https://modrinth.com/mod/gu7yAYhd "Download CC: Tweaked from Modrinth"
 [Minecraft Forge]: https://files.minecraftforge.net/ "Download Minecraft Forge."
 [Fabric]: https://fabricmc.net/use/installer/ "Download Fabric."
-[forum]: https://forums.computercraft.cc/
 [GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
+[EsperNet]: https://www.esper.net/
+[KiwiIRC]: https://kiwiirc.com/nextclient/#irc://irc.esper.net:+6697/#computercraft "#computercraft on EsperNet"

REUSE.toml

@@ -0,0 +1,100 @@
+# SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
+#
+# SPDX-License-Identifier: MPL-2.0
+
+version = 1
+SPDX-PackageName = "CC: Tweaked"
+SPDX-PackageSupplier = "Jonathan Coates <git@squiddev.cc>"
+SPDX-PackageDownloadLocation = "https://github.com/cc-tweaked/cc-tweaked"
+
+[[annotations]]
+SPDX-FileCopyrightText = "The CC: Tweaked Developers"
+SPDX-License-Identifier = "CC0-1.0"
+path = [
+    # Generated/data files are CC0.
+    "gradle/gradle-daemon-jvm.properties",
+    "projects/common/src/main/resources/assets/computercraft/sounds.json",
+    "projects/common/src/main/resources/assets/computercraft/sounds/empty.ogg",
+    "projects/common/src/testMod/resources/data/cctest/computercraft/turtle_upgrade/**",
+    "projects/common/src/testMod/resources/data/cctest/structures/**",
+    "projects/*/src/generated/**",
+    "projects/web/src/htmlTransform/export/index.json",
+    "projects/web/src/htmlTransform/export/items/minecraft/**",
+    # GitHub build scripts are CC0. While we could add a header to each file,
+    # it's unclear if it will break actions or issue templates in some way.
+    ".github/**",
+    # Example mod is CC0.
+    "projects/*/src/examples/**"
+]
+
+[[annotations]]
+# Several assets where it's inconvenient to create a .license file.
+SPDX-FileCopyrightText = "The CC: Tweaked Developers"
+SPDX-License-Identifier = "MPL-2.0"
+path = [
+    "doc/images/**",
+    "package.json",
+    "package-lock.json",
+    "projects/*/src/*/resources/*.mixins.json",
+    "projects/fabric/src/*/resources/fabric.mod.json",
+    "projects/common/src/main/resources/assets/minecraft/shaders/core/computercraft/monitor_tbo.json",
+    "projects/common/src/testMod/resources/data/computercraft/loot_tables/treasure_disk.json",
+    "projects/common/src/testMod/resources/pack.mcmeta",
+    "projects/core/src/main/resources/data/computercraft/lua/rom/modules/command/.ignoreme",
+    "projects/core/src/main/resources/data/computercraft/lua/rom/modules/main/.ignoreme",
+    "projects/core/src/main/resources/data/computercraft/lua/rom/modules/turtle/.ignoreme",
+    "projects/core/src/main/resources/data/computercraft/lua/rom/motd.txt",
+    "projects/web/src/frontend/mount/.settings",
+    "projects/web/src/frontend/mount/example.nfp",
+    "projects/web/src/frontend/mount/example.nft",
+    "projects/web/src/frontend/mount/expr_template.lua",
+    "projects/web/tsconfig.json",
+]
+
+[[annotations]]
+# Bulk-license original assets as CCPL.
+SPDX-FileCopyrightText = "2011 Daniel Ratcliffe"
+SPDX-License-Identifier = "LicenseRef-CCPL"
+path = [
+    "doc/logo.png",
+    "doc/logo-darkmode.png",
+    "projects/common/src/main/resources/assets/computercraft/models/**",
+    "projects/common/src/main/resources/assets/computercraft/textures/**",
+    "projects/common/src/main/resources/pack.mcmeta",
+    "projects/common/src/main/resources/pack.png",
+    "projects/core/src/main/resources/assets/computercraft/textures/gui/term_font.png",
+    "projects/core/src/main/resources/data/computercraft/lua/rom/autorun/.ignoreme",
+    "projects/core/src/main/resources/data/computercraft/lua/rom/help/**",
+    "projects/core/src/main/resources/data/computercraft/lua/rom/programs/fun/advanced/levels/**",
+    "projects/web/src/htmlTransform/export/items/computercraft/**",
+]
+
+[[annotations]]
+# Community-contributed language files
+SPDX-FileCopyrightText = "2017 The CC: Tweaked Developers"
+SPDX-License-Identifier = "LicenseRef-CCPL"
+path = [
+    "projects/common/src/main/resources/assets/computercraft/lang/cs_cz.json",
+    "projects/common/src/main/resources/assets/computercraft/lang/ko_kr.json",
+    "projects/common/src/main/resources/assets/computercraft/lang/pl_pl.json",
+    "projects/common/src/main/resources/assets/computercraft/lang/pt_br.json",
+    "projects/common/src/main/resources/assets/computercraft/lang/ru_ru.json",
+    "projects/common/src/main/resources/assets/computercraft/lang/uk_ua.json",
+    "projects/common/src/main/resources/assets/computercraft/lang/zh_cn.json",
+]
+
+[[annotations]]
+# Community-contributed language files
+SPDX-FileCopyrightText = "2017 The CC: Tweaked Developers"
+SPDX-License-Identifier = "MPL-2.0"
+path = "projects/common/src/main/resources/assets/computercraft/lang/**"
+
+[[annotations]]
+path = ["gradle/wrapper/**"]
+SPDX-FileCopyrightText = "Gradle Inc"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "projects/core/src/test/resources/test-rom/data/json-parsing/**"
+SPDX-FileCopyrightText = "2016 Nicolas Seriot"
+SPDX-License-Identifier = "MIT"

build.gradle.kts

@@ -5,9 +5,8 @@
 import cc.tweaked.gradle.JUnitExt
 import net.fabricmc.loom.api.LoomGradleExtensionAPI
 import net.fabricmc.loom.util.gradle.SourceSetHelper
-import org.jetbrains.gradle.ext.compiler
-import org.jetbrains.gradle.ext.runConfigurations
-import org.jetbrains.gradle.ext.settings
+import org.jetbrains.gradle.ext.*
+import org.jetbrains.gradle.ext.Application
 
 plugins {
     publishing
@@ -25,21 +24,19 @@ val mcVersion: String by extra
 
 githubRelease {
     token(findProperty("githubApiKey") as String? ?: "")
-    owner.set("cc-tweaked")
-    repo.set("CC-Tweaked")
-    targetCommitish.set(cct.gitBranch)
+    owner = "cc-tweaked"
+    repo = "CC-Tweaked"
+    targetCommitish = cct.gitBranch
 
-    tagName.set("v$mcVersion-$modVersion")
-    releaseName.set("[$mcVersion] $modVersion")
-    body.set(
-        provider {
-            "## " + project(":core").file("src/main/resources/data/computercraft/lua/rom/help/whatsnew.md")
-                .readLines()
-                .takeWhile { it != "Type \"help changelog\" to see the full version history." }
-                .joinToString("\n").trim()
-        },
-    )
-    prerelease.set(isUnstable)
+    tagName = "v$mcVersion-$modVersion"
+    releaseName = "[$mcVersion] $modVersion"
+    body = provider {
+        "## " + project(":core").file("src/main/resources/data/computercraft/lua/rom/help/whatsnew.md")
+            .readLines()
+            .takeWhile { it != "Type \"help changelog\" to see the full version history." }
+            .joinToString("\n").trim()
+    }
+    prerelease = isUnstable
 }
 
 tasks.publish { dependsOn(tasks.githubRelease) }
@@ -86,6 +83,19 @@ idea.project.settings.runConfigurations {
         moduleName = "${idea.project.name}.forge.test"
         packageName = ""
     }
+
+    register<Application>("Standalone") {
+        moduleName = "${idea.project.name}.standalone.main"
+        mainClass = "cc.tweaked.standalone.Main"
+        programParameters = "--resources=projects/core/src/main/resources --term=80x30 --allow-local-domains"
+    }
+}
+
+// Build with the IntelliJ, rather than through Gradle. This may require setting the "Compiler Output" option in
+// "Project Structure".
+idea.project.settings.delegateActions {
+    delegateBuildRunToGradle = false
+    testRunner = ActionDelegationConfig.TestRunner.PLATFORM
 }
 
 idea.project.settings.compiler.javac {
@@ -106,7 +116,7 @@ idea.project.settings.compiler.javac {
 }
 
 versionCatalogUpdate {
-    sortByKey.set(false)
+    sortByKey = false
     pin { versions.addAll("fastutil", "guava", "netty", "slf4j") }
-    keep { keepUnusedLibraries.set(true) }
+    keep { keepUnusedLibraries = true }
 }

buildSrc/build.gradle.kts

@@ -14,18 +14,10 @@ repositories {
     mavenCentral()
     gradlePluginPortal()
 
-    maven("https://maven.minecraftforge.net") {
-        name = "Forge"
+    maven("https://maven.neoforged.net") {
+        name = "NeoForge"
         content {
-            includeGroup("net.minecraftforge")
-            includeGroup("net.minecraftforge.gradle")
-        }
-    }
-
-    maven("https://maven.parchmentmc.org") {
-        name = "Librarian"
-        content {
-            includeGroupByRegex("^org\\.parchmentmc.*")
+            includeGroup("net.neoforged")
         }
     }
 
@@ -36,7 +28,7 @@ repositories {
         }
     }
 
-    maven("https://squiddev.cc/maven") {
+    maven("https://maven.squiddev.cc") {
         name = "SquidDev"
         content {
             includeGroup("cc.tweaked.vanilla-extract")
@@ -49,12 +41,10 @@ dependencies {
     implementation(libs.kotlin.plugin)
     implementation(libs.spotless)
 
-    implementation(libs.curseForgeGradle)
     implementation(libs.fabric.loom)
-    implementation(libs.forgeGradle)
     implementation(libs.ideaExt)
-    implementation(libs.librarian)
     implementation(libs.minotaur)
+    implementation(libs.modDevGradle)
     implementation(libs.vanillaExtract)
 }
 
@@ -78,7 +68,7 @@ gradlePlugin {
 }
 
 versionCatalogUpdate {
-    sortByKey.set(false)
-    keep { keepUnusedLibraries.set(true) }
-    catalogFile.set(file("../gradle/libs.versions.toml"))
+    sortByKey = false
+    keep { keepUnusedLibraries = true }
+    catalogFile = file("../gradle/libs.versions.toml")
 }

buildSrc/src/main/kotlin/cc-tweaked.fabric.gradle.kts

@@ -30,7 +30,7 @@ repositories {
 
 loom {
     splitEnvironmentSourceSets()
-    splitModDependencies.set(true)
+    splitModDependencies = true
 }
 
 MinecraftConfigurations.setup(project)

buildSrc/src/main/kotlin/cc-tweaked.forge.gradle.kts

@@ -10,21 +10,22 @@ import cc.tweaked.gradle.IdeaRunConfigurations
 import cc.tweaked.gradle.MinecraftConfigurations
 
 plugins {
-    id("net.minecraftforge.gradle")
-    // We must apply java-convention after Forge, as we need the fg extension to be present.
     id("cc-tweaked.java-convention")
-    id("org.parchmentmc.librarian.forgegradle")
+    id("net.neoforged.moddev")
 }
 
 plugins.apply(CCTweakedPlugin::class.java)
 
 val mcVersion: String by extra
 
-minecraft {
+neoForge {
     val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    mappings("parchment", "${libs.findVersion("parchmentMc").get()}-${libs.findVersion("parchment").get()}-$mcVersion")
+    version = libs.findVersion("neoForge").get().toString()
 
-    accessTransformer(project(":forge").file("src/main/resources/META-INF/accesstransformer.cfg"))
+    parchment {
+        minecraftVersion = libs.findVersion("parchmentMc").get().toString()
+        mappingsVersion = libs.findVersion("parchment").get().toString()
+    }
 }
 
 MinecraftConfigurations.setup(project)
@@ -32,13 +33,3 @@ MinecraftConfigurations.setup(project)
 extensions.configure(CCTweakedExtension::class.java) {
     linters(minecraft = true, loader = "forge")
 }
-
-dependencies {
-    val libs = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
-    "minecraft"("net.minecraftforge:forge:$mcVersion-${libs.findVersion("forge").get()}")
-}
-
-tasks.configureEach {
-    // genIntellijRuns isn't registered until much later, so we need this silly hijinks.
-    if (name == "genIntellijRuns") doLast { IdeaRunConfigurations(project).patch() }
-}

buildSrc/src/main/kotlin/cc-tweaked.java-convention.gradle.kts

@@ -29,7 +29,7 @@ base.archivesName.convention("cc-tweaked-$mcVersion-${project.name}")
 
 java {
     toolchain {
-        languageVersion.set(CCTweakedPlugin.JAVA_VERSION)
+        languageVersion= CCTweakedPlugin.JAVA_VERSION
     }
 
     withSourcesJar()
@@ -38,26 +38,16 @@ java {
 repositories {
     mavenCentral()
 
-    val mainMaven = maven("https://squiddev.cc/maven") {
+    val mainMaven = maven("https://maven.squiddev.cc/mirror") {
         name = "SquidDev"
-        content {
-            // Until https://github.com/SpongePowered/Mixin/pull/593 is merged
-            includeModule("org.spongepowered", "mixin")
-        }
     }
 
     exclusiveContent {
         forRepositories(mainMaven)
-
-        // Include the ForgeGradle repository if present. This requires that ForgeGradle is already present, which we
-        // enforce in our Forge overlay.
-        val fg =
-            project.extensions.findByType(net.minecraftforge.gradle.userdev.DependencyManagementExtension::class.java)
-        if (fg != null) forRepositories(fg.repository)
-
         filter {
             includeGroup("cc.tweaked")
             // Things we mirror
+            includeGroup("com.simibubi.create")
             includeGroup("commoble.morered")
             includeGroup("dev.architectury")
             includeGroup("dev.emi")
@@ -67,7 +57,6 @@ repositories {
             includeGroup("mezz.jei")
             includeGroup("org.teavm")
             includeModule("com.terraformersmc", "modmenu")
-            includeModule("me.lucko", "fabric-permissions-api")
         }
     }
 }
@@ -89,8 +78,16 @@ dependencies {
 // Configure default JavaCompile tasks with our arguments.
 sourceSets.all {
     tasks.named(compileJavaTaskName, JavaCompile::class.java) {
-        // Processing just gives us "No processor claimed any of these annotations", so skip that!
-        options.compilerArgs.addAll(listOf("-Xlint", "-Xlint:-processing"))
+
+        options.compilerArgs.addAll(
+            listOf(
+                "-Xlint",
+                // Processing just gives us "No processor claimed any of these annotations", so skip that!
+                "-Xlint:-processing",
+                // We violate this pattern too often for it to be a helpful warning. Something to improve one day!
+                "-Xlint:-this-escape",
+            ),
+        )
 
         options.errorprone {
             check("InvalidBlockTag", CheckSeverity.OFF) // Broken by @cc.xyz
@@ -98,11 +95,11 @@ sourceSets.all {
             check("InlineMeSuggester", CheckSeverity.OFF) // Minecraft uses @Deprecated liberally
             // Too many false positives right now. Maybe we need an indirection for it later on.
             check("ReferenceEquality", CheckSeverity.OFF)
-            check("UnusedVariable", CheckSeverity.OFF) // Too many false positives with records.
+            check("EnumOrdinal", CheckSeverity.OFF) // For now. We could replace most of these with EnumMap.
             check("OperatorPrecedence", CheckSeverity.OFF) // For now.
-            check("AlreadyChecked", CheckSeverity.OFF) // Seems to be broken?
             check("NonOverridingEquals", CheckSeverity.OFF) // Peripheral.equals makes this hard to avoid
             check("FutureReturnValueIgnored", CheckSeverity.OFF) // Too many false positives with Netty
+            check("InvalidInlineTag", CheckSeverity.OFF) // Triggered by @snippet. Can be removed on Java 21.
 
             check("NullAway", CheckSeverity.ERROR)
             option(
@@ -113,6 +110,8 @@ sourceSets.all {
             option("NullAway:CastToNonNullMethod", "dan200.computercraft.core.util.Nullability.assertNonNull")
             option("NullAway:CheckOptionalEmptiness")
             option("NullAway:AcknowledgeRestrictiveAnnotations")
+
+            excludedPaths = ".*/jmh_generated/.*"
         }
     }
 }
@@ -136,8 +135,8 @@ tasks.processResources {
 tasks.withType(AbstractArchiveTask::class.java).configureEach {
     isPreserveFileTimestamps = false
     isReproducibleFileOrder = true
-    dirMode = Integer.valueOf("755", 8)
-    fileMode = Integer.valueOf("664", 8)
+    filePermissions {}
+    dirPermissions {}
 }
 
 tasks.jar {
@@ -157,7 +156,7 @@ tasks.javadoc {
     options {
         val stdOptions = this as StandardJavadocDocletOptions
         stdOptions.addBooleanOption("Xdoclint:all,-missing", true)
-        stdOptions.links("https://docs.oracle.com/en/java/javase/17/docs/api/")
+        stdOptions.links("https://docs.oracle.com/en/java/javase/21/docs/api/")
     }
 }
 
@@ -171,8 +170,8 @@ tasks.test {
 }
 
 tasks.withType(JacocoReport::class.java).configureEach {
-    reports.xml.required.set(true)
-    reports.html.required.set(true)
+    reports.xml.required = true
+    reports.html.required =true
 }
 
 project.plugins.withType(CCTweakedPlugin::class.java) {
@@ -228,6 +227,5 @@ idea.module {
 
     // Force Gradle to write to inherit the output directory from the parent, instead of writing to out/xxx/classes.
     // This is required for Loom, and we patch Forge's run configurations to work there.
-    // TODO: Submit a patch to Forge to support ProjectRootManager.
     inheritOutputDirs = true
 }

buildSrc/src/main/kotlin/cc-tweaked.kotlin-convention.gradle.kts

@@ -1,25 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-import cc.tweaked.gradle.CCTweakedPlugin
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
-plugins {
-    kotlin("jvm")
-}
-
-kotlin {
-    jvmToolchain {
-        languageVersion.set(CCTweakedPlugin.JAVA_VERSION)
-    }
-}
-
-tasks.withType(KotlinCompile::class.java).configureEach {
-    // So technically we shouldn't need to do this as the toolchain sets it above. However, the option only appears
-    // to be set when the task executes, so doesn't get picked up by IDEs.
-    kotlinOptions.jvmTarget = when {
-        CCTweakedPlugin.JAVA_VERSION.asInt() > 8 -> CCTweakedPlugin.JAVA_VERSION.toString()
-        else -> "1.${CCTweakedPlugin.JAVA_VERSION.asInt()}"
-    }
-}

buildSrc/src/main/kotlin/cc-tweaked.mod-publishing.gradle.kts

@@ -2,11 +2,9 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-import net.darkhax.curseforgegradle.TaskPublishCurseForge
 import cc.tweaked.gradle.setProvider
 
 plugins {
-    id("net.darkhax.curseforgegradle")
     id("com.modrinth.minotaur")
     id("cc-tweaked.publishing")
 }
@@ -25,34 +23,17 @@ val isUnstable = project.properties["isUnstable"] == "true"
 val modVersion: String by extra
 val mcVersion: String by extra
 
-val publishCurseForge by tasks.registering(TaskPublishCurseForge::class) {
-    group = PublishingPlugin.PUBLISH_TASK_GROUP
-    description = "Upload artifacts to CurseForge"
-
-    apiToken = findProperty("curseForgeApiKey") ?: ""
-    enabled = apiToken != ""
-
-    val mainFile = upload("282001", modPublishing.output.get().archiveFile)
-    mainFile.changelog =
-        "Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion)."
-    mainFile.changelogType = "markdown"
-    mainFile.releaseType = if (isUnstable) "alpha" else "release"
-    mainFile.gameVersions.add(mcVersion)
-}
-
-tasks.publish { dependsOn(publishCurseForge) }
-
 modrinth {
-    token.set(findProperty("modrinthApiKey") as String? ?: "")
-    projectId.set("gu7yAYhd")
-    versionNumber.set(modVersion)
-    versionName.set(modVersion)
-    versionType.set(if (isUnstable) "alpha" else "release")
+    token = findProperty("modrinthApiKey") as String? ?: ""
+    projectId = "gu7yAYhd"
+    versionNumber = modVersion
+    versionName = modVersion
+    versionType = if (isUnstable) "alpha" else "release"
     uploadFile.setProvider(modPublishing.output)
     gameVersions.add(mcVersion)
-    changelog.set("Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion).")
+    changelog = "Release notes can be found on the [GitHub repository](https://github.com/cc-tweaked/CC-Tweaked/releases/tag/v$mcVersion-$modVersion)."
 
-    syncBodyFrom.set(provider { rootProject.file("doc/mod-page.md").readText() })
+    syncBodyFrom = provider { rootProject.file("doc/mod-page.md").readText() }
 }
 
 tasks.publish { dependsOn(tasks.modrinth) }

buildSrc/src/main/kotlin/cc-tweaked.mod.gradle.kts

@@ -2,44 +2,34 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-import cc.tweaked.gradle.clientClasses
-import cc.tweaked.gradle.commonClasses
-
 /**
  * Sets up the configurations for writing game tests.
  *
  * See notes in [cc.tweaked.gradle.MinecraftConfigurations] for the general design behind these cursed ideas.
  */
 
+import cc.tweaked.gradle.MinecraftConfigurations
+import cc.tweaked.gradle.clientClasses
+import cc.tweaked.gradle.commonClasses
+
 plugins {
-    id("cc-tweaked.kotlin-convention")
+    kotlin("jvm")
     id("cc-tweaked.java-convention")
 }
 
 val main = sourceSets["main"]
 val client = sourceSets["client"]
 
-// Both testMod and testFixtures inherit from the main and client classpath, just so we have access to Minecraft classes.
-val testMod by sourceSets.creating {
-    compileClasspath += main.compileClasspath + client.compileClasspath
-    runtimeClasspath += main.runtimeClasspath + client.runtimeClasspath
-}
+MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.DATAGEN)
+MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.EXAMPLES)
+MinecraftConfigurations.createDerivedConfiguration(project, MinecraftConfigurations.TEST_MOD)
 
-configurations {
-    named(testMod.compileClasspathConfigurationName) {
-        shouldResolveConsistentlyWith(compileClasspath.get())
-    }
+// Set up generated resources
+sourceSets.main { resources.srcDir("src/generated/resources") }
+sourceSets.named("examples") { resources.srcDir("src/examples/generatedResources") }
 
-    named(testMod.runtimeClasspathConfigurationName) {
-        shouldResolveConsistentlyWith(runtimeClasspath.get())
-    }
-}
-
-// Like the main test configurations, we're safe to depend on source set outputs.
-dependencies {
-    add(testMod.implementationConfigurationName, main.output)
-    add(testMod.implementationConfigurationName, client.output)
-}
+// Make sure our examples compile.
+tasks.check { dependsOn(tasks.named("compileExamplesJava")) }
 
 // Similar to java-test-fixtures, but tries to avoid putting the obfuscated jar on the classpath.
 

buildSrc/src/main/kotlin/cc-tweaked.publishing.gradle.kts

@@ -12,25 +12,26 @@ publishing {
         register<MavenPublication>("maven") {
             artifactId = base.archivesName.get()
             from(components["java"])
+            suppressAllPomMetadataWarnings()
 
             pom {
-                name.set("CC: Tweaked")
-                description.set("CC: Tweaked is a fork of ComputerCraft, adding programmable computers, turtles and more to Minecraft.")
-                url.set("https://github.com/cc-tweaked/CC-Tweaked")
+                name = "CC: Tweaked"
+                description = "CC: Tweaked is a fork of ComputerCraft, adding programmable computers, turtles and more to Minecraft."
+                url = "https://github.com/cc-tweaked/CC-Tweaked"
 
                 scm {
-                    url.set("https://github.com/cc-tweaked/CC-Tweaked.git")
+                    url = "https://github.com/cc-tweaked/CC-Tweaked.git"
                 }
 
                 issueManagement {
-                    system.set("github")
-                    url.set("https://github.com/cc-tweaked/CC-Tweaked/issues")
+                    system = "github"
+                    url = "https://github.com/cc-tweaked/CC-Tweaked/issues"
                 }
 
                 licenses {
                     license {
-                        name.set("ComputerCraft Public License, Version 1.0")
-                        url.set("https://github.com/cc-tweaked/CC-Tweaked/blob/HEAD/LICENSE")
+                        name = "ComputerCraft Public License, Version 1.0"
+                        url = "https://github.com/cc-tweaked/CC-Tweaked/blob/HEAD/LICENSE"
                     }
                 }
             }
@@ -38,7 +39,7 @@ publishing {
     }
 
     repositories {
-        maven("https://squiddev.cc/maven") {
+        maven("https://maven.squiddev.cc") {
             name = "SquidDev"
 
             credentials(PasswordCredentials::class)

buildSrc/src/main/kotlin/cc/tweaked/gradle/CCTweakedExtension.kt

@@ -10,23 +10,16 @@ import org.gradle.api.GradleException
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Project
 import org.gradle.api.Task
-import org.gradle.api.artifacts.Dependency
-import org.gradle.api.attributes.TestSuiteType
-import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Provider
 import org.gradle.api.provider.SetProperty
-import org.gradle.api.reporting.ReportingExtension
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.bundling.Jar
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.api.tasks.javadoc.Javadoc
-import org.gradle.configurationcache.extensions.capitalized
 import org.gradle.language.base.plugins.LifecycleBasePlugin
 import org.gradle.language.jvm.tasks.ProcessResources
 import org.gradle.process.JavaForkOptions
-import org.gradle.testing.jacoco.plugins.JacocoCoverageReport
 import org.gradle.testing.jacoco.plugins.JacocoPluginExtension
 import org.gradle.testing.jacoco.plugins.JacocoTaskExtension
 import org.gradle.testing.jacoco.tasks.JacocoReport
@@ -35,57 +28,42 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import java.io.File
 import java.io.IOException
 import java.net.URI
-import java.net.URL
 import java.util.regex.Pattern
 
-abstract class CCTweakedExtension(
-    private val project: Project,
-    private val fs: FileSystemOperations,
-) {
+abstract class CCTweakedExtension(private val project: Project) {
     /** Get the hash of the latest git commit. */
-    val gitHash: Provider<String> = gitProvider(project, "<no git hash>") {
-        ProcessHelpers.captureOut("git", "-C", project.rootProject.projectDir.absolutePath, "rev-parse", "HEAD").trim()
-    }
+    val gitHash: Provider<String> =
+        gitProvider("<no git commit>", listOf("rev-parse", "HEAD")) { it.trim() }
 
     /** Get the current git branch. */
-    val gitBranch: Provider<String> = gitProvider(project, "<no git branch>") {
-        ProcessHelpers.captureOut("git", "-C", project.rootProject.projectDir.absolutePath, "rev-parse", "--abbrev-ref", "HEAD")
-            .trim()
-    }
+    val gitBranch: Provider<String> =
+        gitProvider("<no git branch>", listOf("rev-parse", "--abbrev-ref", "HEAD")) { it.trim() }
 
     /** Get a list of all contributors to the project. */
-    val gitContributors: Provider<List<String>> = gitProvider(project, listOf()) {
-        ProcessHelpers.captureLines(
-            "git", "-C", project.rootProject.projectDir.absolutePath, "shortlog", "-ns",
-            "--group=author", "--group=trailer:co-authored-by", "HEAD",
-        )
-            .asSequence()
-            .map {
-                val matcher = COMMIT_COUNTS.matcher(it)
-                matcher.find()
-                matcher.group(1)
-            }
-            .filter { !IGNORED_USERS.contains(it) }
-            .toList()
-            .sortedWith(String.CASE_INSENSITIVE_ORDER)
-    }
+    val gitContributors: Provider<List<String>> =
+        gitProvider(listOf(), listOf("shortlog", "-ns", "--group=author", "--group=trailer:co-authored-by", "HEAD")) { input ->
+            input.lineSequence()
+                .filter { it.isNotEmpty() }
+                .map {
+                    val matcher = COMMIT_COUNTS.matcher(it)
+                    matcher.find()
+                    matcher.group(1)
+                }
+                .filter { !IGNORED_USERS.contains(it) }
+                .toList()
+                .sortedWith(String.CASE_INSENSITIVE_ORDER)
+        }
 
     /**
      * References to other sources
      */
     val sourceDirectories: SetProperty<SourceSetReference> = project.objects.setProperty(SourceSetReference::class.java)
 
-    /**
-     * Dependencies excluded from published artifacts.
-     */
-    private val excludedDeps: ListProperty<Dependency> = project.objects.listProperty(Dependency::class.java)
-
     /** All source sets referenced by this project. */
     val sourceSets = sourceDirectories.map { x -> x.map { it.sourceSet } }
 
     init {
         sourceDirectories.finalizeValueOnRead()
-        excludedDeps.finalizeValueOnRead()
         project.afterEvaluate { sourceDirectories.disallowChanges() }
     }
 
@@ -111,14 +89,13 @@ abstract class CCTweakedExtension(
         val otherJava = otherProject.extensions.getByType(JavaPluginExtension::class.java)
         val main = otherJava.sourceSets.getByName("main")
         val client = otherJava.sourceSets.getByName("client")
-        val testMod = otherJava.sourceSets.findByName("testMod")
-        val testFixtures = otherJava.sourceSets.findByName("testFixtures")
 
         // Pull in sources from the other project.
         extendSourceSet(otherProject, main)
         extendSourceSet(otherProject, client)
-        if (testMod != null) extendSourceSet(otherProject, testMod)
-        if (testFixtures != null) extendSourceSet(otherProject, testFixtures)
+        for (sourceSet in listOf(MinecraftConfigurations.DATAGEN, MinecraftConfigurations.EXAMPLES, MinecraftConfigurations.TEST_MOD, "testFixtures")) {
+            otherJava.sourceSets.findByName(sourceSet)?.let { extendSourceSet(otherProject, it) }
+        }
 
         // The extra source-processing tasks should include these files too.
         project.tasks.named(main.javadocTaskName, Javadoc::class.java) { source(main.allJava, client.allJava) }
@@ -181,23 +158,19 @@ abstract class CCTweakedExtension(
     }
 
     fun <T> jacoco(task: NamedDomainObjectProvider<T>) where T : Task, T : JavaForkOptions {
-        val classDump = project.layout.buildDirectory.dir("jacocoClassDump/${task.name}")
-        val reportTaskName = "jacoco${task.name.capitalized()}Report"
+        val reportTaskName = "jacoco${task.name.capitalise()}Report"
 
         val jacoco = project.extensions.getByType(JacocoPluginExtension::class.java)
         task.configure {
             finalizedBy(reportTaskName)
-
-            doFirst("Clean class dump directory") { fs.delete { delete(classDump) } }
-
             jacoco.applyTo(this)
+
             extensions.configure(JacocoTaskExtension::class.java) {
                 includes = listOf("dan200.computercraft.*")
-                classDumpDir = classDump.get().asFile
-
-                // Older versions of modlauncher don't include a protection domain (and thus no code
-                // source). Jacoco skips such classes by default, so we need to explicitly include them.
-                isIncludeNoLocationClasses = true
+                excludes = listOf(
+                    "dan200.computercraft.mixin.*", // Exclude mixins, as they're not executed at runtime.
+                    "dan200.computercraft.shared.Capabilities$*", // Exclude capability tokens, as Forge rewrites them.
+                )
             }
         }
 
@@ -206,15 +179,11 @@ abstract class CCTweakedExtension(
             description = "Generates code coverage report for the ${task.name} task."
 
             executionData(task.get())
-            classDirectories.from(classDump)
 
-            // Don't want to use sourceSets(...) here as we have a custom class directory.
-            for (ref in sourceSets.get()) sourceDirectories.from(ref.allSource.sourceDirectories)
-        }
-
-        project.extensions.configure(ReportingExtension::class.java) {
-            reports.register("${task.name}CodeCoverageReport", JacocoCoverageReport::class.java) {
-                testType.set(TestSuiteType.INTEGRATION_TEST)
+            // Don't want to use sourceSets(...) here as we don't use all class directories.
+            for (ref in this@CCTweakedExtension.sourceDirectories.get()) {
+                sourceDirectories.from(ref.sourceSet.allSource.sourceDirectories)
+                if (ref.classes) classDirectories.from(ref.sourceSet.output)
             }
         }
     }
@@ -226,12 +195,12 @@ abstract class CCTweakedExtension(
      * where possible.
      */
     fun downloadFile(label: String, url: String): File {
-        val url = URL(url)
-        val path = File(url.path)
+        val uri = URI(url)
+        val path = File(uri.path)
 
         project.repositories.ivy {
             name = label
-            setUrl(URI(url.protocol, url.userInfo, url.host, url.port, path.parent, null, null))
+            setUrl(URI(uri.scheme, uri.userInfo, uri.host, uri.port, path.parent, null, null))
             patternLayout {
                 artifact("[artifact].[ext]")
             }
@@ -254,40 +223,31 @@ abstract class CCTweakedExtension(
         ).resolve().single()
     }
 
-    /**
-     * Exclude a dependency from being published in Maven.
-     */
-    fun exclude(dep: Dependency) {
-        excludedDeps.add(dep)
-    }
+    private fun <T> gitProvider(default: T, command: List<String>, process: (String) -> T): Provider<T> {
+        val baseResult = project.providers.exec {
+            commandLine = listOf("git", "-C", project.rootDir.absolutePath) + command
+        }
 
-    /**
-     * Configure a [MavenDependencySpec].
-     */
-    fun configureExcludes(spec: MavenDependencySpec) {
-        for (dep in excludedDeps.get()) spec.exclude(dep)
+        return project.provider {
+            val res = try {
+                baseResult.standardOutput.asText.get()
+            } catch (e: IOException) {
+                project.logger.error("Cannot read Git repository: ${e.message}", e)
+                return@provider default
+            } catch (e: GradleException) {
+                project.logger.error("Cannot read Git repository: ${e.message}", e)
+                return@provider default
+            }
+            process(res)
+        }
     }
 
     companion object {
         private val COMMIT_COUNTS = Pattern.compile("""^\s*[0-9]+\s+(.*)$""")
         private val IGNORED_USERS = setOf(
-            "GitHub", "Daniel Ratcliffe", "Weblate",
+            "GitHub", "Daniel Ratcliffe", "NotSquidDev", "Weblate",
         )
 
-        private fun <T> gitProvider(project: Project, default: T, supplier: () -> T): Provider<T> {
-            return project.provider {
-                try {
-                    supplier()
-                } catch (e: IOException) {
-                    project.logger.error("Cannot read Git repository: ${e.message}")
-                    default
-                } catch (e: GradleException) {
-                    project.logger.error("Cannot read Git repository: ${e.message}")
-                    default
-                }
-            }
-        }
-
         private val isIdeSync: Boolean
             get() = java.lang.Boolean.parseBoolean(System.getProperty("idea.sync.active", "false"))
     }

buildSrc/src/main/kotlin/cc/tweaked/gradle/CCTweakedPlugin.kt

@@ -42,6 +42,6 @@ class CCTweakedPlugin : Plugin<Project> {
     }
 
     companion object {
-        val JAVA_VERSION = JavaLanguageVersion.of(17)
+        val JAVA_VERSION = JavaLanguageVersion.of(21)
     }
 }

buildSrc/src/main/kotlin/cc/tweaked/gradle/DependencyCheck.kt

@@ -22,19 +22,19 @@ import org.gradle.language.base.plugins.LifecycleBasePlugin
 
 abstract class DependencyCheck : DefaultTask() {
     @get:Input
-    abstract val configuration: ListProperty<Configuration>
+    protected abstract val dependencies: ListProperty<DependencyResult>
 
     /**
      * A mapping of module coordinates (`group:module`) to versions, overriding the requested version.
      */
     @get:Input
-    abstract val overrides: MapProperty<String, String>
+    protected abstract val overrides: MapProperty<String, String>
 
     init {
         description = "Check :core's dependencies are consistent with Minecraft's."
         group = LifecycleBasePlugin.VERIFICATION_GROUP
 
-        configuration.finalizeValueOnRead()
+        dependencies.finalizeValueOnRead()
         overrides.finalizeValueOnRead()
     }
 
@@ -45,13 +45,19 @@ abstract class DependencyCheck : DefaultTask() {
         overrides.putAll(project.provider { mutableMapOf(module.get().module.toString() to version) })
     }
 
+    /**
+     * Add a configuration to check.
+     */
+    fun configuration(configuration: Provider<Configuration>) {
+        // We can't store the Configuration in the cache, so store the resolved dependencies instead.
+        dependencies.addAll(configuration.map { it.incoming.resolutionResult.allDependencies })
+    }
+
     @TaskAction
     fun run() {
         var ok = true
-        for (configuration in configuration.get()) {
-            configuration.incoming.resolutionResult.allDependencies {
-                if (!check(this@allDependencies)) ok = false
-            }
+        for (configuration in dependencies.get()) {
+            if (!check(configuration)) ok = false
         }
 
         if (!ok) {

buildSrc/src/main/kotlin/cc/tweaked/gradle/Extensions.kt

@@ -9,6 +9,7 @@ import org.gradle.api.file.FileSystemLocation
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.JavaExec
+import org.gradle.kotlin.dsl.getByName
 import org.gradle.process.BaseExecSpec
 import org.gradle.process.JavaExecSpec
 import org.gradle.process.ProcessForkOptions
@@ -46,6 +47,21 @@ fun JavaExec.copyToFull(spec: JavaExec) {
     copyToExec(spec)
 }
 
+/**
+ * Base this [JavaExec] task on an existing task.
+ */
+fun JavaExec.copyFromTask(task: JavaExec) {
+    for (dep in task.dependsOn) dependsOn(dep)
+    task.copyToFull(this)
+}
+
+/**
+ * Base this [JavaExec] task on an existing task.
+ */
+fun JavaExec.copyFromTask(task: String) {
+    copyFromTask(project.tasks.getByName<JavaExec>(task))
+}
+
 /**
  * Copy additional [BaseExecSpec] options which aren't handled by [ProcessForkOptions.copyTo].
  */
@@ -143,7 +159,7 @@ fun getNextVersion(version: String): String {
     val lastIndex = mainVersion.lastIndexOf('.')
     if (lastIndex < 0) throw IllegalArgumentException("Cannot parse version format \"$version\"")
     val lastVersion = try {
-        version.substring(lastIndex + 1).toInt()
+        mainVersion.substring(lastIndex + 1).toInt()
     } catch (e: NumberFormatException) {
         throw IllegalArgumentException("Cannot parse version format \"$version\"", e)
     }
@@ -155,3 +171,15 @@ fun getNextVersion(version: String): String {
     if (dashIndex >= 0) out.append(version, dashIndex, version.length)
     return out.toString()
 }
+
+/**
+ * Capitalise the first letter of the string.
+ *
+ * This is a replacement for the now deprecated [String.capitalize].
+ */
+fun String.capitalise(): String {
+    if (isEmpty()) return this
+    val first = this[0]
+    val firstTitle = first.titlecaseChar()
+    return if (first == firstTitle) this else firstTitle + substring(1)
+}

buildSrc/src/main/kotlin/cc/tweaked/gradle/ForgeExtensions.kt

@@ -1,26 +0,0 @@
-// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import net.minecraftforge.gradle.common.util.RunConfig
-import net.minecraftforge.gradle.common.util.runs.setRunConfigInternal
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.tasks.JavaExec
-import org.gradle.jvm.toolchain.JavaToolchainService
-import java.nio.file.Files
-
-/**
- * Set [JavaExec] task to run a given [RunConfig].
- */
-fun JavaExec.setRunConfig(config: RunConfig) {
-    dependsOn("prepareRuns")
-    setRunConfigInternal(project, this, config)
-    doFirst("Create working directory") { Files.createDirectories(workingDir.toPath()) }
-
-    javaLauncher.set(
-        project.extensions.getByType(JavaToolchainService::class.java)
-            .launcherFor(project.extensions.getByType(JavaPluginExtension::class.java).toolchain),
-    )
-}

buildSrc/src/main/kotlin/cc/tweaked/gradle/MavenDependencySpec.kt

@@ -1,73 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package cc.tweaked.gradle
-
-import org.gradle.api.artifacts.Dependency
-import org.gradle.api.artifacts.MinimalExternalModuleDependency
-import org.gradle.api.artifacts.ProjectDependency
-import org.gradle.api.plugins.BasePluginExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.specs.Spec
-
-/**
- * A dependency in a POM file.
- */
-data class MavenDependency(val groupId: String?, val artifactId: String?, val version: String?, val scope: String?)
-
-/**
- * A spec specifying which dependencies to include/exclude.
- */
-class MavenDependencySpec {
-    private val excludeSpecs = mutableListOf<Spec<MavenDependency>>()
-
-    fun exclude(spec: Spec<MavenDependency>) {
-        excludeSpecs.add(spec)
-    }
-
-    fun exclude(dep: Dependency) {
-        exclude {
-            // We have to cheat a little for project dependencies, as the project name doesn't match the artifact group.
-            val name = when (dep) {
-                is ProjectDependency -> dep.dependencyProject.extensions.getByType(BasePluginExtension::class.java).archivesName.get()
-                else -> dep.name
-            }
-            (dep.group.isNullOrEmpty() || dep.group == it.groupId) &&
-                (name.isNullOrEmpty() || name == it.artifactId) &&
-                (dep.version.isNullOrEmpty() || dep.version == it.version)
-        }
-    }
-
-    fun exclude(dep: MinimalExternalModuleDependency) {
-        exclude {
-            dep.module.group == it.groupId && dep.module.name == it.artifactId
-        }
-    }
-
-    fun isIncluded(dep: MavenDependency) = !excludeSpecs.any { it.isSatisfiedBy(dep) }
-}
-
-/**
- * Configure dependencies present in this publication's POM file.
- *
- * While this approach is very ugly, it's the easiest way to handle it!
- */
-fun MavenPublication.mavenDependencies(action: MavenDependencySpec.() -> Unit) {
-    val spec = MavenDependencySpec()
-    action(spec)
-
-    pom.withXml {
-        val dependencies = XmlUtil.findChild(asNode(), "dependencies") ?: return@withXml
-        dependencies.children().map { it as groovy.util.Node }.forEach {
-            val dep = MavenDependency(
-                groupId = XmlUtil.findChild(it, "groupId")?.text(),
-                artifactId = XmlUtil.findChild(it, "artifactId")?.text(),
-                version = XmlUtil.findChild(it, "version")?.text(),
-                scope = XmlUtil.findChild(it, "scope")?.text(),
-            )
-
-            if (!spec.isIncluded(dep)) it.parent().remove(it)
-        }
-    }
-}

buildSrc/src/main/kotlin/cc/tweaked/gradle/MergeTrees.kt

@@ -0,0 +1,120 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package cc.tweaked.gradle
+
+import cc.tweaked.vanillaextract.core.util.MoreFiles
+import org.gradle.api.Action
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.file.*
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.tasks.*
+import javax.inject.Inject
+
+/**
+ * Merge common files across multiple directories into one destination directory.
+ *
+ * This is intended for merging the generated resources from the Forge and Fabric projects. Files common between the two
+ * are written to the global [output] directory, while distinct files are written to the per-source
+ * [MergeTrees.Source.output] directory.
+ */
+abstract class MergeTrees : DefaultTask() {
+    /**
+     * A source directory to read from.
+     */
+    interface Source {
+        /**
+         * The folder contianing all input files.
+         */
+        @get:InputFiles
+        @get:PathSensitive(PathSensitivity.RELATIVE)
+        val input: ConfigurableFileTree
+
+        fun input(configure: Action<ConfigurableFileTree>) {
+            configure.execute(input)
+        }
+
+        /**
+         * The folder to write files unique to this folder to.
+         */
+        @get:OutputDirectory
+        val output: DirectoryProperty
+    }
+
+    /**
+     * The list of sources.
+     */
+    @get:Nested
+    abstract val sources: ListProperty<Source>
+
+    /**
+     * Add and configure a new source.
+     */
+    fun source(configure: Action<Source>) {
+        val instance = objectFactory.newInstance(Source::class.java)
+        configure.execute(instance)
+        instance.output.disallowChanges()
+        sources.add(instance)
+    }
+
+    /**
+     * The directory to write common files to.
+     */
+    @get:OutputDirectory
+    abstract val output: DirectoryProperty
+
+    @get:Inject
+    protected abstract val objectFactory: ObjectFactory
+
+    @get:Inject
+    protected abstract val fsOperations: FileSystemOperations
+
+    @TaskAction
+    fun run() {
+        val sources = this.sources.get()
+        if (sources.isEmpty()) throw GradleException("Cannot have an empty list of sources")
+
+        val files = mutableMapOf<String, SharedFile>()
+        for (source in sources) {
+            source.input.visit(
+                object : FileVisitor {
+                    override fun visitDir(dirDetails: FileVisitDetails) = Unit
+                    override fun visitFile(fileDetails: FileVisitDetails) {
+                        val path = fileDetails.file.toRelativeString(source.input.dir)
+                        val hash = MoreFiles.computeSha1(fileDetails.file.toPath())
+
+                        val existing = files[path]
+                        if (existing == null) {
+                            files[path] = SharedFile(hash, 1)
+                        } else if (existing.hash == hash) {
+                            existing.found++
+                        }
+                    }
+                },
+            )
+        }
+
+        val sharedFiles = files.entries.asSequence().filter { (_, v) -> v.found == sources.size }.map { (k, _) -> k }.toList()
+
+        // Copy shared files to the common directory
+        fsOperations.sync {
+            from(sources[0].input)
+            into(output)
+            include(sharedFiles)
+        }
+
+        // And all other files to their per-source directory
+        for (source in sources) {
+            fsOperations.sync {
+                from(source.input)
+                into(source.output)
+                exclude(sharedFiles)
+            }
+        }
+    }
+
+    class SharedFile(val hash: String, var found: Int)
+}

buildSrc/src/main/kotlin/cc/tweaked/gradle/MinecraftConfigurations.kt

@@ -24,7 +24,6 @@ class MinecraftConfigurations private constructor(private val project: Project)
     private val java = project.extensions.getByType(JavaPluginExtension::class.java)
     private val sourceSets = java.sourceSets
     private val configurations = project.configurations
-    private val objects = project.objects
 
     private val main = sourceSets[SourceSet.MAIN_SOURCE_SET_NAME]
     private val test = sourceSets[SourceSet.TEST_SOURCE_SET_NAME]
@@ -37,13 +36,7 @@ class MinecraftConfigurations private constructor(private val project: Project)
         val client = sourceSets.maybeCreate("client")
 
         // Ensure the client classpaths behave the same as the main ones.
-        configurations.named(client.compileClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.compileClasspathConfigurationName])
-        }
-
-        configurations.named(client.runtimeClasspathConfigurationName) {
-            shouldResolveConsistentlyWith(configurations[main.runtimeClasspathConfigurationName])
-        }
+        consistentWithMain(client)
 
         // Set up an API configuration for clients (to ensure it's consistent with the main source set).
         val clientApi = configurations.maybeCreate(client.apiConfigurationName).apply {
@@ -85,6 +78,16 @@ class MinecraftConfigurations private constructor(private val project: Project)
         setupBasic()
     }
 
+    private fun consistentWithMain(sourceSet: SourceSet) {
+        configurations.named(sourceSet.compileClasspathConfigurationName) {
+            shouldResolveConsistentlyWith(configurations[main.compileClasspathConfigurationName])
+        }
+
+        configurations.named(sourceSet.runtimeClasspathConfigurationName) {
+            shouldResolveConsistentlyWith(configurations[main.runtimeClasspathConfigurationName])
+        }
+    }
+
     private fun setupBasic() {
         val client = sourceSets["client"]
 
@@ -96,13 +99,30 @@ class MinecraftConfigurations private constructor(private val project: Project)
         val checkDependencyConsistency =
             project.tasks.register("checkDependencyConsistency", DependencyCheck::class.java) {
                 // We need to check both the main and client classpath *configurations*, as the actual configuration
-                configuration.add(configurations.named(main.runtimeClasspathConfigurationName))
-                configuration.add(configurations.named(client.runtimeClasspathConfigurationName))
+                configuration(configurations.named(main.runtimeClasspathConfigurationName))
+                configuration(configurations.named(client.runtimeClasspathConfigurationName))
             }
         project.tasks.named("check") { dependsOn(checkDependencyConsistency) }
     }
 
+    /**
+     * Create a new configuration that pulls in the main and client classes from the mod.
+     */
+    private fun createDerivedConfiguration(name: String) {
+        val client = sourceSets["client"]
+        val sourceSet = sourceSets.create(name)
+        sourceSet.compileClasspath += main.compileClasspath + client.compileClasspath
+        sourceSet.runtimeClasspath += main.runtimeClasspath + client.runtimeClasspath
+        consistentWithMain(sourceSet)
+        project.dependencies.add(sourceSet.implementationConfigurationName, main.output)
+        project.dependencies.add(sourceSet.implementationConfigurationName, client.output)
+    }
+
     companion object {
+        const val DATAGEN = "datagen"
+        const val EXAMPLES = "examples"
+        const val TEST_MOD = "testMod"
+
         fun setupBasic(project: Project) {
             MinecraftConfigurations(project).setupBasic()
         }
@@ -110,6 +130,10 @@ class MinecraftConfigurations private constructor(private val project: Project)
         fun setup(project: Project) {
             MinecraftConfigurations(project).setup()
         }
+
+        fun createDerivedConfiguration(project: Project, name: String) {
+            MinecraftConfigurations(project).createDerivedConfiguration(name)
+        }
     }
 }
 

buildSrc/src/main/kotlin/cc/tweaked/gradle/MinecraftExec.kt

@@ -4,7 +4,7 @@
 
 package cc.tweaked.gradle
 
-import net.minecraftforge.gradle.common.util.RunConfig
+import net.neoforged.moddevgradle.internal.RunGameTask
 import org.gradle.api.GradleException
 import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.invocation.Gradle
@@ -19,6 +19,7 @@ import java.nio.file.Files
 import java.util.concurrent.TimeUnit
 import java.util.function.Supplier
 import javax.inject.Inject
+import kotlin.collections.set
 import kotlin.random.Random
 
 /**
@@ -65,11 +66,19 @@ abstract class ClientJavaExec : JavaExec() {
         setTestProperties()
     }
 
+    fun copyFromForge(path: String) = copyFromForge(project.tasks.getByName(path, RunGameTask::class))
+
     /**
-     * Set this task to run a given [RunConfig].
+     * Set this task to run a given [RunGameTask].
      */
-    fun setRunConfig(config: RunConfig) {
-        (this as JavaExec).setRunConfig(config)
+    fun copyFromForge(task: RunGameTask) {
+        copyFrom(task)
+
+        // Eagerly evaluate the behaviour of RunGameTask.exec
+        environment.putAll(task.environmentProperty.get())
+        classpath(task.classpathProvider)
+        workingDir = task.gameDirectory.get().asFile
+
         setTestProperties() // setRunConfig may clobber some properties, ensure everything is set.
     }
 
@@ -117,6 +126,23 @@ abstract class ClientJavaExec : JavaExec() {
         }
     }
 
+    /**
+     * Configure Iris to use Complementary Shaders.
+     */
+    fun withComplementaryShaders() {
+        val cct = project.extensions.getByType(CCTweakedExtension::class.java)
+
+        withFileFrom(workingDir.resolve("shaderpacks/ComplementaryShaders_v4.6.zip")) {
+            cct.downloadFile("Complementary Shaders", "https://edge.forgecdn.net/files/3951/170/ComplementaryShaders_v4.6.zip")
+        }
+        withFileContents(workingDir.resolve("config/iris.properties")) {
+            """
+            enableShaders=true
+            shaderPack=ComplementaryShaders_v4.6.zip
+            """.trimIndent()
+        }
+    }
+
     @TaskAction
     override fun exec() {
         Files.createDirectories(workingDir.toPath())

buildSrc/src/main/kotlin/cc/tweaked/gradle/Node.kt

@@ -11,7 +11,9 @@ import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
+import org.gradle.process.ExecOperations
 import java.io.File
+import javax.inject.Inject
 
 class NodePlugin : Plugin<Project> {
     override fun apply(project: Project) {
@@ -43,10 +45,13 @@ abstract class NpmInstall : DefaultTask() {
     @get:OutputDirectory
     val nodeModules: Provider<Directory> = projectRoot.dir("node_modules")
 
+    @get:Inject
+    protected abstract val execOperations: ExecOperations
+
     @TaskAction
     fun install() {
-        project.exec {
-            commandLine("npm", "ci")
+        execOperations.exec {
+            commandLine(ProcessHelpers.getExecutable("npm"), "ci")
             workingDir = projectRoot.get().asFile
         }
     }
@@ -59,6 +64,6 @@ abstract class NpmInstall : DefaultTask() {
 abstract class NpxExecToDir : ExecToDir() {
     init {
         dependsOn(NpmInstall.TASK_NAME)
-        executable = "npx"
+        executable = ProcessHelpers.getExecutable("npx")
     }
 }

buildSrc/src/main/kotlin/cc/tweaked/gradle/ProcessHelpers.kt

@@ -4,48 +4,36 @@
 
 package cc.tweaked.gradle
 
-import org.codehaus.groovy.runtime.ProcessGroovyMethods
 import org.gradle.api.GradleException
-import java.io.BufferedReader
 import java.io.File
-import java.io.InputStreamReader
 
 internal object ProcessHelpers {
-    fun startProcess(vararg command: String): Process {
-        // Something randomly passes in "GIT_DIR=" as an environment variable which clobbers everything else. Don't
-        // inherit the environment array!
-        return ProcessBuilder()
-            .command(*command)
-            .redirectError(ProcessBuilder.Redirect.INHERIT)
-            .also { it.environment().clear() }
-            .start()
-    }
-
-    fun captureOut(vararg command: String): String {
-        val process = startProcess(*command)
-        process.outputStream.close()
-
-        val result = ProcessGroovyMethods.getText(process)
-        process.waitForOrThrow("Failed to run command")
-        return result
-    }
-
-    fun captureLines(vararg command: String): List<String> {
-        val process = startProcess(*command)
-        process.outputStream.close()
-
-        val out = BufferedReader(InputStreamReader(process.inputStream)).use { reader ->
-            reader.lines().filter { it.isNotEmpty() }.toList()
-        }
-        ProcessGroovyMethods.closeStreams(process)
-        process.waitForOrThrow("Failed to run command")
-        return out
-    }
-
     fun onPath(name: String): Boolean {
         val path = System.getenv("PATH") ?: return false
         return path.splitToSequence(File.pathSeparator).any { File(it, name).exists() }
     }
+
+    /**
+     * Search for an executable on the `PATH` if required.
+     *
+     * [Process]/[ProcessBuilder] does not handle all executable file extensions on Windows (such as `.com). When on
+     * Windows, this function searches `PATH` and `PATHEXT` for an executable matching [name].
+     */
+    fun getExecutable(name: String): String {
+        if (!System.getProperty("os.name").lowercase().contains("windows")) return name
+
+        val path = (System.getenv("PATH") ?: return name).split(File.pathSeparator)
+        val pathExt = (System.getenv("PATHEXT") ?: return name).split(File.pathSeparator)
+
+        for (pathEntry in path) {
+            for (ext in pathExt) {
+                val resolved = File(pathEntry, name + ext)
+                if (resolved.exists()) return resolved.getAbsolutePath()
+            }
+        }
+
+        return name
+    }
 }
 
 internal fun Process.waitForOrThrow(message: String) {

buildSrc/src/main/kotlin/net/minecraftforge/gradle/common/util/runs/RunConfigSetup.kt

@@ -1,51 +0,0 @@
-// SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package net.minecraftforge.gradle.common.util.runs
-
-import net.minecraftforge.gradle.common.util.RunConfig
-import org.gradle.api.Project
-import org.gradle.process.CommandLineArgumentProvider
-import org.gradle.process.JavaExecSpec
-import java.io.File
-import java.util.function.Supplier
-import java.util.stream.Collectors
-import java.util.stream.Stream
-
-/**
- * Set up a [JavaExecSpec] to execute a [RunConfig].
- *
- * [MinecraftRunTask] sets up all its properties when the task is executed, rather than when configured. As such, it's
- * not possible to use [cc.tweaked.gradle.copyToFull] like we do for Fabric. Instead, we set up the task manually.
- *
- * Unfortunately most of the functionality we need is package-private, and so we have to put our code into the package.
- */
-internal fun setRunConfigInternal(project: Project, spec: JavaExecSpec, config: RunConfig) {
-    spec.workingDir = File(config.workingDirectory)
-
-    spec.mainClass.set(config.main)
-    for (source in config.allSources) spec.classpath(source.runtimeClasspath)
-
-    val originalTask = project.tasks.named(config.taskName, MinecraftRunTask::class.java)
-
-    // Add argument and JVM argument via providers, to be as lazy as possible with fetching artifacts.
-    val lazyTokens = RunConfigGenerator.configureTokensLazy(
-        project, config, RunConfigGenerator.mapModClassesToGradle(project, config),
-        originalTask.get().minecraftArtifacts,
-        originalTask.get().runtimeClasspathArtifacts,
-    )
-    spec.argumentProviders.add(
-        CommandLineArgumentProvider {
-            RunConfigGenerator.getArgsStream(config, lazyTokens, false).toList()
-        },
-    )
-    spec.jvmArgumentProviders.add(
-        CommandLineArgumentProvider {
-            (if (config.isClient) config.jvmArgs + originalTask.get().additionalClientArgs.get() else config.jvmArgs).map { config.replace(lazyTokens, it) } +
-                config.properties.map { (k, v) -> "-D${k}=${config.replace(lazyTokens, v)}" }
-        },
-    )
-
-    for ((key, value) in config.environment) spec.environment(key, config.replace(lazyTokens, value))
-}

config/checkstyle/checkstyle.xml

@@ -13,8 +13,21 @@ SPDX-License-Identifier: MPL-2.0
     <property name="tabWidth" value="4"/>
     <property name="charset" value="UTF-8" />
 
+    <module name="BeforeExecutionExclusionFileFilter">
+        <property name="fileNamePattern" value="module\-info\.java$"/>
+    </module>
+
     <module name="SuppressionFilter">
-	<property name="file" value="${config_loc}/suppressions.xml" />
+        <property name="file" value="${config_loc}/suppressions.xml" />
+    </module>
+
+    <!--
+        Checkstyle doesn't support @snippet (https://github.com/checkstyle/checkstyle/issues/11455),
+        so suppress warnings nearby
+    -->
+    <module name="SuppressWithNearbyTextFilter">
+        <property name="nearbyTextPattern" value="@snippet" />
+        <property name="lineRange" value="20" />
     </module>
 
     <module name="BeforeExecutionExclusionFileFilter">
@@ -120,7 +133,7 @@ SPDX-License-Identifier: MPL-2.0
         </module>
         <module name="MethodTypeParameterName" />
         <module name="PackageName">
-            <property name="format" value="^(dan200\.computercraft|cc\.tweaked)(\.[a-z][a-z0-9]*)*" />
+            <property name="format" value="^(dan200\.computercraft|cc\.tweaked|com\.example\.examplemod)(\.[a-z][a-z0-9]*)*" />
         </module>
         <module name="ParameterName" />
         <module name="StaticVariableName">

config/checkstyle/suppressions.xml

@@ -21,5 +21,8 @@ SPDX-License-Identifier: MPL-2.0
     <suppress checks="PackageName" files=".*[\\/]T[A-Za-z]+.java" />
 
     <!-- Allow underscores in our test classes. -->
-    <suppress checks="MethodName" files=".*Contract.java" />
+    <suppress checks="MethodName" files=".*(Contract|Test).java" />
+
+    <!-- Allow underscores in Mixin classes -->
+    <suppress checks="TypeName" files=".*[\\/]mixin[\\/].*.java" />
 </suppressions>

config/gitpod/Dockerfile

@@ -1,12 +0,0 @@
-# SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-#
-# SPDX-License-Identifier: MPL-2.0
-
-FROM gitpod/workspace-base
-
-USER gitpod
-
-RUN sudo apt-get -q update \
- && sudo apt-get install -yq openjdk-16-jdk python3-pip npm \
- && sudo pip3 install pre-commit \
- && sudo update-java-alternatives --set java-1.16.0-openjdk-amd64

crowdin.yml

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
+#
+# SPDX-License-Identifier: MPL-2.0
+
+files:
+  - source: projects/common/src/generated/resources/assets/computercraft/lang/en_us.json
+    translation: /projects/common/src/main/resources/assets/computercraft/lang/%locale_with_underscore%.json
+    languages_mapping:
+      locale_with_underscore:
+        cs: cs_cz    # Czech
+        da: da_dk    # Danish
+        de: de_de    # German
+        es-ES: es_es # Spanish
+        fr: fr_fr    # French
+        it: it_it    # Italian
+        ja: ja_jp    # Japanese
+        ko: ko_kr    # Korean
+        nb: nb_no    # Norwegian Bokmal
+        nl: nl_nl    # Dutch
+        pl: pl_pl    # Polish
+        pt-BR: pt_br # Portuguese, Brazilian
+        ru: ru_ru    # Russian
+        sv-SE: sv_se # Sweedish
+        tok: tok     # Toki Pona
+        tr: tr_tr    # Turkish
+        uk: uk_ua    # Ukraine
+        vi: vi_vn    # Vietnamese
+        zh-CN: zh_cn # Chinese Simplified

doc/events/monitor_resize.md

@@ -8,7 +8,7 @@ SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 SPDX-License-Identifier: MPL-2.0
 -->
 
-The [`monitor_resize`] event is fired when an adjacent or networked monitor's size is changed.
+The [`monitor_resize`] event is fired when an adjacent or networked [monitor's][`monitor`] size is changed.
 
 ## Return Values
 1. [`string`]: The event name.

doc/events/monitor_touch.md

@@ -8,7 +8,7 @@ SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 SPDX-License-Identifier: MPL-2.0
 -->
 
-The [`monitor_touch`] event is fired when an adjacent or networked Advanced Monitor is right-clicked.
+The [`monitor_touch`] event is fired when an adjacent or networked [Advanced Monitor][`monitor`] is right-clicked.
 
 ## Return Values
 1. [`string`]: The event name.

doc/events/redstone.md

@@ -8,7 +8,7 @@ SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
 SPDX-License-Identifier: MPL-2.0
 -->
 
-The [`event!redstone`] event is fired whenever any redstone inputs on the computer change.
+The [`event!redstone`] event is fired whenever any redstone inputs on the computer or [relay][`redstone_relay`] change.
 
 ## Return values
 1. [`string`]: The event name.
@@ -21,3 +21,7 @@ while true do
   print("A redstone input has changed!")
 end
 ```
+
+## See also
+ - [The `redstone` API on computers][`module!redstone`]
+ - [The `redstone_relay` peripheral][`redstone_relay`]

doc/guides/gps_setup.md

@@ -19,7 +19,7 @@ In order to give the best results, a GPS constellation needs at least four compu
 constellation is redundant, but it does not cause problems.
 
 ## Building a GPS constellation
-<img alt="An example GPS constellation." src="/images/gps-constellation-example.png" class="big-image" />
+<img alt="An example GPS constellation." src="../images/gps-constellation-example.png" class="big-image" />
 
 We are going to build our GPS constellation as shown in the image above. You will need 4 computers and either 4 wireless
 modems or 4 ender modems. Try not to mix ender and wireless modems together as you might get some odd behavior when your

doc/guides/speaker_audio.md

@@ -131,7 +131,7 @@ different.
 First, we require the dfpwm module and call [`cc.audio.dfpwm.make_decoder`] to construct a new decoder. This decoder
 accepts blocks of DFPWM data and converts it to a list of 8-bit amplitudes, which we can then play with our speaker.
 
-As mentioned above, [`speaker.playAudio`] accepts at most 128×1024 samples in one go. DFPMW uses a single bit for each
+As mentioned above, [`speaker.playAudio`] accepts at most 128×1024 samples in one go. DFPWM uses a single bit for each
 sample, which means we want to process our audio in chunks of 16×1024 bytes (16KiB). In order to do this, we use
 [`io.lines`], which provides a nice way to loop over chunks of a file. You can of course just use [`fs.open`] and
 [`fs.ReadHandle.read`] if you prefer.
@@ -191,7 +191,7 @@ end
 
 > [Confused?][!NOTE]
 > Don't worry if you don't understand this example. It's quite advanced, and does use some ideas that this guide doesn't
-> cover. That said, don't be afraid to ask on [GitHub Discussions] or [IRC] either!
+> cover. That said, don't be afraid to ask [the community for help][community].
 
 It's worth noting that the examples of audio processing we've mentioned here are about manipulating the _amplitude_ of
 the wave. If you wanted to modify the _frequency_ (for instance, shifting the pitch), things get rather more complex.
@@ -205,5 +205,4 @@ This is, I'm afraid, left as an exercise to the reader.
 [PCM]: https://en.wikipedia.org/wiki/Pulse-code_modulation "Pulse-code Modulation - Wikipedia"
 [Ring Buffer]: https://en.wikipedia.org/wiki/Circular_buffer "Circular buffer - Wikipedia"
 [Sine Wave]: https://en.wikipedia.org/wiki/Sine_wave "Sine wave - Wikipedia"
-[GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
+[Community]: /#community

doc/index.md

@@ -4,12 +4,19 @@ SPDX-FileCopyrightText: 2020 The CC: Tweaked Developers
 SPDX-License-Identifier: MPL-2.0
 -->
 
-# ![CC: Tweaked](logo.png)
+<h1>
+    <picture>
+        <source media="(prefers-color-scheme: dark)" srcset="logo-darkmode.png">
+        <source media="(prefers-color-scheme: light)" srcset="logo.png">
+        <img alt="CC: Tweaked" src="logo.png">
+    </picture>
+</h1>
+
 CC: Tweaked is a mod for Minecraft which adds programmable computers, turtles and more to the game. A fork of the
 much-beloved [ComputerCraft], it continues its legacy with improved performance and stability, along with a wealth of
 new features.
 
-CC: Tweaked can be installed from [CurseForge] or [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].
+CC: Tweaked can be installed from [Modrinth]. It runs on both [Minecraft Forge] and [Fabric].
 
 ## Features
 Controlled using the [Lua programming language][lua], CC: Tweaked's computers provides all the tools you need to start
@@ -38,12 +45,16 @@ little daunting getting started. Thankfully, there's several fantastic tutorials
 
  - [Direwolf20's ComputerCraft tutorials](https://www.youtube.com/watch?v=wrUHUhfCY5A "ComputerCraft Tutorial Episode 1 - HELP! and Hello World")
  - [Sethbling's ComputerCraft series](https://www.youtube.com/watch?v=DSsx4VSe-Uk "Programming Tutorial with Minecraft Turtles -- Ep. 1: Intro to Turtles and If-Then-Else_End")
- - [Lyqyd's Computer Basics 1](http://www.computercraft.info/forums2/index.php?/topic/15033-computer-basics-i/ "Computer Basics I")
+ - [Lyqyd's Computer Basics 1](https://ccf.squiddev.cc/forums2/index.php?/topic/15033-computer-basics-i/ "Computer Basics I")
 
 Once you're a little more familiar with the mod, the sidebar and links below provide more detailed documentation on the
 various APIs and peripherals provided by the mod.
 
-If you get stuck, do [ask a question on GitHub][GitHub Discussions] or pop in to the ComputerCraft's [IRC channel][IRC].
+<h2 id="community">Community</h2>
+If you need help getting started with CC: Tweaked, want to show off your latest project, or just want to chat about
+ComputerCraft, do check out our [GitHub discussions page][GitHub discussions]! There's also a fairly populated,
+albeit quiet IRC channel on [EsperNet], if that's more your cup of tea. You can join `#computercraft` through your
+desktop client, or online using [KiwiIRC].
 
 ## Get Involved
 CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please do [create an issue][bug].
@@ -51,11 +62,11 @@ CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please
 [github]: https://github.com/cc-tweaked/CC-Tweaked/ "CC: Tweaked on GitHub"
 [bug]: https://github.com/cc-tweaked/CC-Tweaked/issues/new/choose
 [computercraft]: https://github.com/dan200/ComputerCraft "ComputerCraft on GitHub"
-[curseforge]: https://minecraft.curseforge.com/projects/cc-tweaked "Download CC: Tweaked from CurseForge"
 [modrinth]: https://modrinth.com/mod/gu7yAYhd "Download CC: Tweaked from Modrinth"
 [forge]: https://files.minecraftforge.net/ "Download Minecraft Forge."
 [Minecraft Forge]: https://files.minecraftforge.net/ "Download Minecraft Forge."
 [Fabric]: https://fabricmc.net/use/installer/ "Download Fabric."
 [lua]: https://www.lua.org/ "Lua's main website"
 [GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[IRC]: https://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
+[EsperNet]: https://www.esper.net/
+[KiwiIRC]: https://kiwiirc.com/nextclient/#irc://irc.esper.net:+6697/#computercraft "#computercraft on EsperNet"

doc/mod-page.md

@@ -45,12 +45,16 @@ little daunting getting started. Thankfully, there's several fantastic tutorials
 
  - [Direwolf20's ComputerCraft tutorials](https://www.youtube.com/watch?v=wrUHUhfCY5A "ComputerCraft Tutorial Episode 1 - HELP! and Hello World")
  - [Sethbling's ComputerCraft series](https://www.youtube.com/watch?v=DSsx4VSe-Uk "Programming Tutorial with Minecraft Turtles -- Ep. 1: Intro to Turtles and If-Then-Else_End")
- - [Lyqyd's Computer Basics 1](http://www.computercraft.info/forums2/index.php?/topic/15033-computer-basics-i/ "Computer Basics I")
+ - [Lyqyd's Computer Basics 1](https://ccf.squiddev.cc/forums2/index.php?/topic/15033-computer-basics-i/ "Computer Basics I")
 
 Once you're a little more familiar with the mod, the [wiki](https://tweaked.cc/) provides more detailed documentation on the
 various APIs and peripherals provided by the mod.
 
-If you get stuck, do [ask a question on GitHub][GitHub Discussions] or pop in to the ComputerCraft's [IRC channel][IRC].
+## Community
+If you need help getting started with CC: Tweaked, want to show off your latest project, or just want to chat about
+ComputerCraft, do check out our [GitHub discussions page][GitHub discussions]! There's also a fairly populated,
+albeit quiet IRC channel on [EsperNet], if that's more your cup of tea. You can join `#computercraft` through your
+desktop client, or online using [KiwiIRC].
 
 ## Get Involved
 CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please do [create an issue][bug].
@@ -60,4 +64,5 @@ CC: Tweaked lives on [GitHub]. If you've got any ideas, feedback or bugs please
 [computercraft]: https://github.com/dan200/ComputerCraft "ComputerCraft on GitHub"
 [lua]: https://www.lua.org/ "Lua's main website"
 [GitHub Discussions]: https://github.com/cc-tweaked/CC-Tweaked/discussions
-[IRC]: http://webchat.esper.net/?channels=computercraft "#computercraft on EsperNet"
+[EsperNet]: https://www.esper.net/
+[KiwiIRC]: https://kiwiirc.com/nextclient/#irc://irc.esper.net:+6697/#computercraft "#computercraft on EsperNet"

doc/reference/breaking_changes.md

@@ -25,13 +25,13 @@ as documentation for breaking changes and "gotchas" one should look out for betw
 
  - Update to Lua 5.2:
    - Support for Lua 5.0's pseudo-argument `arg` has been removed. You should always use `...` for varargs.
-   - Environments are no longer baked into the runtime, and instead use the `_ENV` local or upvalue. `getfenv`/`setfenv`
-     now only work on Lua functions with an `_ENV` upvalue. `getfenv` will return the global environment when called
-     with other functions, and `setfenv` will have no effect.
-   - `load`/`loadstring` defaults to using the global environment (`_G`) rather than the current coroutine's
+   - Environments are no longer baked into the runtime, and instead use the `_ENV` local or upvalue. [`getfenv`]/[`setfenv`]
+     now only work on Lua functions with an `_ENV` upvalue. [`getfenv`] will return the global environment when called
+     with other functions, and [`setfenv`] will have no effect.
+   - [`load`]/[`loadstring`] defaults to using the global environment (`_G`) rather than the current coroutine's
      environment.
-   - Support for dumping functions (`string.dump`) and loading binary chunks has been removed.
-   - `math.random` now uses Lua 5.4's random number generator.
+   - Support for dumping functions ([`string.dump`]) and loading binary chunks has been removed.
+   - [`math.random`] now uses Lua 5.4's random number generator.
 
  - File handles, HTTP requests and websockets now always use the original bytes rather than encoding/decoding to UTF-8.
 
@@ -44,7 +44,7 @@ as documentation for breaking changes and "gotchas" one should look out for betw
    `keys.enter` constant was queued when the key was pressed)
 
  - Minecraft 1.13 removed the concept of item damage and block metadata (see ["The Flattening"][flattening]). As a
-   result `turtle.inspect` no longer provides block metadata, and `turtle.getItemDetail` no longer provides damage.
+   result [`turtle.inspect`] no longer provides block metadata, and [`turtle.getItemDetail`] no longer provides damage.
 
    - Block states (`turtle.inspect().state`) should provide all the same information as block metadata, but in a much
      more understandable format.
@@ -70,12 +70,12 @@ as documentation for breaking changes and "gotchas" one should look out for betw
  - Unlabelled computers and turtles now keep their ID when broken, meaning that unlabelled computers/items do not stack.
 
 ## ComputerCraft 1.80pr1 {#cc-1.80}
- - Programs run via `shell.run` are now started in their own isolated environment. This means globals set by programs
+ - Programs run via [`shell.run`] are now started in their own isolated environment. This means globals set by programs
    will not be accessible outside of this program.
 
  - Programs containing `/` are looked up in the current directory and are no longer looked up on the path. For instance,
    you can no longer type `turtle/excavate` to run `/rom/programs/turtle/excavate.lua`.
 
 [flattening]: https://minecraft.wiki/w/Java_Edition_1.13/Flattening
-[legal_data_pack]: https://minecraft.gamepedia.com/Tutorials/Creating_a_data_pack#Legal_characters
+[legal_data_pack]: https://minecraft.wiki/w/Tutorials/Creating_a_data_pack#Legal_characters
 [datapack-example]: https://github.com/cc-tweaked/datapack-example "An example datapack for CC: Tweaked"

doc/reference/command.md

@@ -0,0 +1,140 @@
+---
+module: [kind=reference] computercraft_command
+---
+
+<!--
+SPDX-FileCopyrightText: 2023 The CC: Tweaked Developers
+
+SPDX-License-Identifier: MPL-2.0
+-->
+
+# The `/computercraft` command
+CC: Tweaked provides a `/computercraft` command for server owners to manage running computers on a server.
+
+## Permissions {#permissions}
+As the `/computercraft` command is mostly intended for debugging and administrative purposes, its sub-commands typically
+require you to have op (or similar).
+
+ - All players have access to the [`queue`] sub-command.
+ - On a multi-player server, all other commands require op.
+ - On a single-player world, the player can run the [`dump`], [`turn-on`]/[`shutdown`], and [`track`] sub-commands, even
+   when cheats are not enabled. The [`tp`] and [`view`] commands require cheats.
+
+If a permission mod such as [LuckPerms] is installed[^permission], you can configure access to the individual
+sub-commands. Each sub-command creates a `computercraft.command.NAME` permission node to control which players can
+execute it.
+
+[LuckPerms]: https://github.com/LuckPerms/LuckPerms/ "A permissions plugin for Minecraft servers."
+[fabric-permission-api]: https://github.com/lucko/fabric-permissions-api "A simple permissions API for Fabric"
+
+[^permission]: This supports any mod which uses Forge's permission API or [fabric-permission-api].
+
+## Computer selectors {#computer-selectors}
+Some commands (such as [`tp`] or [`turn-on`]) target a specific computer, or a list of computers. To specify which
+computers to operate on, you must use "computer selectors".
+
+Computer selectors are similar to Minecraft's [entity target selectors], but targeting computers instead. They allow
+you to select one or more computers, based on a set of predicates.
+
+The following predicates are supported:
+ - `id=<id>`: Select computer(s) with a specific id.
+ - `instance=<id>`: Select the computer with the given instance id.
+ - `family=<normal|advanced|command>`: Select computers based on their type.
+ - `label=<label>`: Select computers with the given label.
+ - `distance=<distance>`: Select computers within a specific distance of the player executing the command. This uses
+   Minecraft's [float range] syntax.
+
+`#<id>` may also be used as a shorthand for `@c[id=<id>]`, to select computer(s) with a specific id.
+
+### Examples:
+ - `/computercraft turn-on #12`: Turn on the computer(s) with an id of 12.
+ - `/computercraft shutdown @c[distance=..100]`: Shut down all computers with 100 blocks of the player.
+
+[entity target selectors]: https://minecraft.wiki/w/Target_selectors "Target Selectors on the Minecraft wiki"
+[Float range]: https://minecraft.wiki/w/Argument_types#minecraft:float_range
+
+## Commands {#commands}
+### `/computercraft dump` {#dump}
+`/computercraft dump` prints a table of currently loaded computers, including their id, position, and whether they're
+running. It can also be run with a single computer argument to dump more detailed information about a computer.
+
+![A screenshot of a Minecraft world. In the chat box, there is a table listing 5 computers, with columns labelled
+"Computer", "On" and "Position". Below that, is a more detailed list of information about Computer 0, including its
+label ("My computer") and that it has a monitor on the right hand side](../images/computercraft-dump.png "An example of
+running '/computercraft dump'")
+
+Next to the computer id, there are several buttons to either [teleport][`tp`] to the computer, or [open its terminal
+][`view`].
+
+ Computers are sorted by distance to the player, so nearby computers will appear earlier.
+
+### `/computercraft turn-on [computers...]` {#turn-on}
+Turn on one or more computers or, if no run with no arguments, all loaded computers.
+
+#### Examples
+ - `/computercraft turn-on #0 #2`: Turn on computers with id 0 and 2.
+ - `/computercraft turn-on @c[family=command]`: Turn on all command computers.
+
+### `/computercraft shutdown [computers...]` {#shutdown}
+Shutdown one or more computers or, if no run with no arguments, all loaded computers.
+
+This is sometimes useful when dealing with lag, as a way to ensure that ComputerCraft is not causing problems.
+
+#### Examples
+ - `/computercraft shutdown`: Shut down all loaded computers.
+ - `/computercraft shutdown @c[distance=..10]`: Shut down all computers in a block radius.
+
+### `/computercraft tp [computer]` {#tp}
+Teleport to the given computer.
+
+This is normally used from via the [`dump`] command interface rather than being invoked directly.
+
+### `/computercraft view [computer]` {#view}
+Open a terminal for the specified computer. This allows remotely viewing computers without having to interact with the
+block.
+
+This is normally used from via the [`dump`] command interface rather than being invoked directly.
+
+### `/computercraft track` {#track}
+The `/computercraft track` command allows you to enable profiling of computers. When a computer runs code, or interacts
+with the Minecraft world, we time how long that takes. This timing information may then be queried, and used to find
+computers which may be causing lag.
+
+To enable the profiler, run `/computercraft track start`. Computers will then start recording metrics. Once enough data
+has been gathered, run `/computercraft track stop` to stop profiling and display the recorded data.
+
+![](../images/computercraft-track.png)
+
+The table by default shows the number of times each computer has run, and how long it ran for (in total, and on
+average). In the above screenshot, we can see one computer was particularly badly behaved, and ran for 7 seconds. The
+buttons may be used to [teleport][`tp`] to the computer, or [open its terminal ][`view`], and inspect it further.
+
+`/computercraft track dump` can be used to display this table at any point (including while profiling is still running).
+
+Computers also record other information, such as how much server-thread time they consume, or their HTTP bandwidth
+usage. The `dump` subcommand accepts a list of other fields to display, instead of the default timings.
+
+#### Examples
+ - `/computercraft track dump server_tasks_count server_tasks`: Print the number of server-thread tasks each computer
+   executed, and how long they took in total.
+ - `/computercraft track dump http_upload http_download`: Print the number of bytes uploaded and downloaded by each
+   computer.
+
+
+### `/computercraft queue` {#queue}
+The queue subcommand allows non-operator players to queue a `computer_command` event on *command* computers.
+
+This has a similar purpose to vanilla's [`/trigger`] command. Command computers may choose to listen to this event, and
+then perform some action.
+
+[`/trigger`]: https://minecraft.wiki/w/Commands/trigger "/trigger on the Minecraft wiki"
+
+
+[`dump`]: #dump "/computercraft dump"
+[`queue`]: #queue "/computercraft queue"
+[`shutdown`]: #shutdown "/computercraft shutdown"
+[`tp`]: #tp "/computercraft tp"
+[`track`]: #track "/computercraft track"
+[`turn-on`]: #turn-on "/computercraft turn-on"
+[`view`]: #view "/computercraft view"
+[computer selectors]: #computer-selectors "Computer selectors"

doc/reference/feature_compat.md

@@ -81,7 +81,7 @@ compatibility for these newer versions.
 | `string.dump` strip argument                                                          | ✔          |                           |
 | `string.pack`/`string.unpack`/`string.packsize`                                       | ✔          |                           |
 | `table.move`                                                                          | ✔          |                           |
-| `math.atan2` -> `math.atan`                                                           | ❌         |                           |
+| `math.atan2` -> `math.atan`                                                           | 🔶         | `math.atan` supports its two argument form. |
 | Removed `math.frexp`, `math.ldexp`, `math.pow`, `math.cosh`, `math.sinh`, `math.tanh` | ❌         |                           |
 | `math.maxinteger`/`math.mininteger`                                                   | ❌         |                           |
 | `math.tointeger`                                                                      | ❌         |                           |

gradle.properties

@@ -2,15 +2,17 @@
 #
 # SPDX-License-Identifier: MPL-2.0
 
-org.gradle.jvmargs=-Xmx3G
+org.gradle.jvmargs=-Xmx3G -Dfile.encoding=UTF-8
 org.gradle.parallel=true
 
 kotlin.stdlib.default.dependency=false
 kotlin.jvm.target.validation.mode=error
 
+neogradle.subsystems.conventions.runs.enabled=false
+
 # Mod properties
-isUnstable=false
-modVersion=1.109.6
+isUnstable=true
+modVersion=1.114.4
 
 # Minecraft properties: We want to configure this here so we can read it in settings.gradle
-mcVersion=1.20.1
+mcVersion=1.21.1

gradle/gradle-daemon-jvm.properties

@@ -0,0 +1,2 @@
+#This file is generated by updateDaemonJvm
+toolchainVersion=21

gradle/libs.versions.toml

@@ -6,73 +6,76 @@
 
 # Minecraft
 # MC version is specified in gradle.properties, as we need that in settings.gradle.
-# Remember to update corresponding versions in fabric.mod.json/mods.toml
-fabric-api = "0.86.1+1.20.1"
-fabric-loader = "0.14.21"
-forge = "47.1.0"
-forgeSpi = "7.0.1"
+# Remember to update corresponding versions in fabric.mod.json/neoforge.mods.toml
+fabric-api = "0.102.1+1.21.1"
+fabric-loader = "0.15.11"
+neoForge = "21.1.9"
+neoForgeSpi = "8.0.1"
 mixin = "0.8.5"
-parchment = "2023.08.20"
-parchmentMc = "1.20.1"
-yarn = "1.20.1+build.10"
+parchment = "2024.07.28"
+parchmentMc = "1.21"
+yarn = "1.21.1+build.1"
 
 # Core dependencies (these versions are tied to the version Minecraft uses)
-fastutil = "8.5.9"
-guava = "31.1-jre"
-netty = "4.1.82.Final"
-slf4j = "2.0.1"
+fastutil = "8.5.12"
+guava = "32.1.2-jre"
+netty = "4.1.97.Final"
+slf4j = "2.0.9"
 
 # Core dependencies (independent of Minecraft)
 asm = "9.6"
 autoService = "1.1.1"
 checkerFramework = "3.42.0"
-cobalt = "0.9.1"
+cobalt = { strictly = "0.9.5" }
 commonsCli = "1.6.0"
 jetbrainsAnnotations = "24.1.0"
 jsr305 = "3.0.2"
 jzlib = "1.1.3"
-kotlin = "1.9.21"
-kotlin-coroutines = "1.7.3"
-nightConfig = "3.6.7"
+kotlin = "2.1.0"
+kotlin-coroutines = "1.10.1"
+nightConfig = "3.8.1"
 
 # Minecraft mods
-emi = "1.0.8+1.20.1"
-fabricPermissions = "0.3.20230723"
-iris = "1.6.4+1.20"
-jei = "15.2.0.22"
-modmenu = "7.1.0"
+emi = "1.1.7+1.21"
+fabricPermissions = "0.3.1"
+iris-fabric = "1.8.0-beta.3+1.21-fabric"
+iris-forge = "1.8.0-beta.3+1.21-neoforge"
+jei = "19.8.2.99"
+modmenu = "11.0.0-rc.4"
 moreRed = "4.0.0.4"
-oculus = "1.2.5"
-rei = "12.0.626"
-rubidium = "0.6.1"
-sodium = "mc1.20-0.4.10"
+rei = "16.0.729"
+sodium-fabric = "mc1.21-0.6.0-beta.1-fabric"
+sodium-forge = "mc1.21-0.6.0-beta.1-neoforge"
+mixinExtra = "0.3.5"
+create-forge = "0.5.1.f-33"
+create-fabric = "0.5.1-f-build.1467+mc1.20.1"
 
 # Testing
 hamcrest = "2.2"
 jqwik = "1.8.2"
-junit = "5.10.1"
+junit = "5.11.4"
+junitPlatform = "1.11.4"
+jmh = "1.37"
 
 # Build tools
-cctJavadoc = "1.8.2"
-checkstyle = "10.12.6"
-curseForgeGradle = "1.0.14"
-errorProne-core = "2.23.0"
+cctJavadoc = "1.8.3"
+checkstyle = "10.20.1"
+errorProne-core = "2.27.0"
 errorProne-plugin = "3.1.0"
-fabric-loom = "1.5.7"
-forgeGradle = "6.0.20"
+fabric-loom = "1.9.2"
 githubRelease = "2.5.2"
 gradleVersions = "0.50.0"
 ideaExt = "1.1.7"
-illuaminate = "0.1.0-44-g9ee0055"
-librarian = "1.+"
+illuaminate = "0.1.0-74-gf1551d5"
 lwjgl = "3.3.3"
-minotaur = "2.+"
-mixinGradle = "0.7.38"
-nullAway = "0.9.9"
+minotaur = "2.8.7"
+modDevGradle = "2.0.74"
+nullAway = "0.10.25"
+shadow = "8.3.1"
 spotless = "6.23.3"
 taskTree = "2.1.1"
-teavm = "0.10.0-SQUID.2"
-vanillaExtract = "0.1.1"
+teavm = "0.11.0-SQUID.1"
+vanillaExtract = "0.2.0"
 versionCatalogUpdate = "0.8.1"
 
 [libraries]
@@ -84,7 +87,7 @@ checkerFramework = { module = "org.checkerframework:checker-qual", version.ref =
 cobalt = { module = "cc.tweaked:cobalt", version.ref = "cobalt" }
 commonsCli = { module = "commons-cli:commons-cli", version.ref = "commonsCli" }
 fastutil = { module = "it.unimi.dsi:fastutil", version.ref = "fastutil" }
-forgeSpi = { module = "net.minecraftforge:forgespi", version.ref = "forgeSpi" }
+neoForgeSpi = { module = "net.neoforged:neoforgespi", version.ref = "neoForgeSpi" }
 guava = { module = "com.google.guava:guava", version.ref = "guava" }
 jetbrainsAnnotations = { module = "org.jetbrains:annotations", version.ref = "jetbrainsAnnotations" }
 jsr305 = { module = "com.google.code.findbugs:jsr305", version.ref = "jsr305" }
@@ -92,32 +95,36 @@ jzlib = { module = "com.jcraft:jzlib", version.ref = "jzlib" }
 kotlin-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines" }
 kotlin-platform = { module = "org.jetbrains.kotlin:kotlin-bom", version.ref = "kotlin" }
 kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
+netty-codec = { module = "io.netty:netty-codec", version.ref = "netty" }
 netty-http = { module = "io.netty:netty-codec-http", version.ref = "netty" }
-netty-socks = { module = "io.netty:netty-codec-socks", version.ref = "netty" }
 netty-proxy = { module = "io.netty:netty-handler-proxy", version.ref = "netty" }
+netty-socks = { module = "io.netty:netty-codec-socks", version.ref = "netty" }
 nightConfig-core = { module = "com.electronwill.night-config:core", version.ref = "nightConfig" }
 nightConfig-toml = { module = "com.electronwill.night-config:toml", version.ref = "nightConfig" }
 slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
 
 # Minecraft mods
-fabric-api = { module = "net.fabricmc.fabric-api:fabric-api", version.ref = "fabric-api" }
-fabric-loader = { module = "net.fabricmc:fabric-loader", version.ref = "fabric-loader" }
-fabric-junit = { module = "net.fabricmc:fabric-loader-junit", version.ref = "fabric-loader" }
-fabricPermissions = { module = "me.lucko:fabric-permissions-api", version.ref = "fabricPermissions" }
+create-fabric = { module = "com.simibubi.create:create-fabric-1.20.1", version.ref = "create-fabric" }
+create-forge = { module = "com.simibubi.create:create-1.20.1", version.ref = "create-forge" }
 emi = { module = "dev.emi:emi-xplat-mojmap", version.ref = "emi" }
-iris = { module = "maven.modrinth:iris", version.ref = "iris" }
-jei-api = { module = "mezz.jei:jei-1.20.1-common-api", version.ref = "jei" }
-jei-fabric = { module = "mezz.jei:jei-1.20.1-fabric", version.ref = "jei" }
-jei-forge = { module = "mezz.jei:jei-1.20.1-forge", version.ref = "jei" }
+fabric-api = { module = "net.fabricmc.fabric-api:fabric-api", version.ref = "fabric-api" }
+fabric-junit = { module = "net.fabricmc:fabric-loader-junit", version.ref = "fabric-loader" }
+fabric-loader = { module = "net.fabricmc:fabric-loader", version.ref = "fabric-loader" }
+fabricPermissions = { module = "me.lucko:fabric-permissions-api", version.ref = "fabricPermissions" }
+iris-fabric = { module = "maven.modrinth:iris", version.ref = "iris-fabric" }
+iris-forge = { module = "maven.modrinth:iris", version.ref = "iris-forge" }
+jei-api = { module = "mezz.jei:jei-1.21-common-api", version.ref = "jei" }
+jei-fabric = { module = "mezz.jei:jei-1.21-fabric", version.ref = "jei" }
+jei-forge = { module = "mezz.jei:jei-1.21-neoforge", version.ref = "jei" }
 mixin = { module = "org.spongepowered:mixin", version.ref = "mixin" }
+mixinExtra = { module = "io.github.llamalad7:mixinextras-common", version.ref = "mixinExtra" }
 modmenu = { module = "com.terraformersmc:modmenu", version.ref = "modmenu" }
 moreRed = { module = "commoble.morered:morered-1.20.1", version.ref = "moreRed" }
-oculus = { module = "maven.modrinth:oculus", version.ref = "oculus" }
 rei-api = { module = "me.shedaniel:RoughlyEnoughItems-api", version.ref = "rei" }
 rei-builtin = { module = "me.shedaniel:RoughlyEnoughItems-default-plugin", version.ref = "rei" }
 rei-fabric = { module = "me.shedaniel:RoughlyEnoughItems-fabric", version.ref = "rei" }
-rubidium = { module = "maven.modrinth:rubidium", version.ref = "rubidium" }
-sodium = { module = "maven.modrinth:sodium", version.ref = "sodium" }
+sodium-fabric = { module = "maven.modrinth:sodium", version.ref = "sodium.fabric" }
+sodium-forge = { module = "maven.modrinth:sodium", version.ref = "sodium.forge" }
 
 # Testing
 hamcrest = { module = "org.hamcrest:hamcrest", version.ref = "hamcrest" }
@@ -126,7 +133,10 @@ jqwik-engine = { module = "net.jqwik:jqwik-engine", version.ref = "jqwik" }
 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-jupiter-params = { module = "org.junit.jupiter:junit-jupiter-params", version.ref = "junit" }
+junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher", version.ref = "junitPlatform" }
 slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
+jmh = { module = "org.openjdk.jmh:jmh-core", version.ref = "jmh" }
+jmh-processor = { module = "org.openjdk.jmh:jmh-generator-annprocess", version.ref = "jmh" }
 
 # LWJGL
 lwjgl-bom = { module = "org.lwjgl:lwjgl-bom", version.ref = "lwjgl" }
@@ -137,21 +147,20 @@ lwjgl-glfw = { module = "org.lwjgl:lwjgl-glfw" }
 # Build tools
 cctJavadoc = { module = "cc.tweaked:cct-javadoc", version.ref = "cctJavadoc" }
 checkstyle = { module = "com.puppycrawl.tools:checkstyle", version.ref = "checkstyle" }
-curseForgeGradle = { module = "net.darkhax.curseforgegradle:CurseForgeGradle", version.ref = "curseForgeGradle" }
 errorProne-annotations = { module = "com.google.errorprone:error_prone_annotations", version.ref = "errorProne-core" }
 errorProne-api = { module = "com.google.errorprone:error_prone_check_api", version.ref = "errorProne-core" }
 errorProne-core = { module = "com.google.errorprone:error_prone_core", version.ref = "errorProne-core" }
 errorProne-plugin = { module = "net.ltgt.gradle:gradle-errorprone-plugin", version.ref = "errorProne-plugin" }
 errorProne-testHelpers = { module = "com.google.errorprone:error_prone_test_helpers", version.ref = "errorProne-core" }
 fabric-loom = { module = "net.fabricmc:fabric-loom", version.ref = "fabric-loom" }
-forgeGradle = { module = "net.minecraftforge.gradle:ForgeGradle", version.ref = "forgeGradle" }
 ideaExt = { module = "gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext", version.ref = "ideaExt" }
 kotlin-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
-librarian = { module = "org.parchmentmc:librarian", version.ref = "librarian" }
 minotaur = { module = "com.modrinth.minotaur:Minotaur", version.ref = "minotaur" }
 nullAway = { module = "com.uber.nullaway:nullaway", version.ref = "nullAway" }
+modDevGradle = { module = "net.neoforged:moddev-gradle", version.ref = "modDevGradle" }
 spotless = { module = "com.diffplug.spotless:spotless-plugin-gradle", version.ref = "spotless" }
 teavm-classlib = { module = "org.teavm:teavm-classlib", version.ref = "teavm" }
+teavm-core = { module = "org.teavm:teavm-core", version.ref = "teavm" }
 teavm-jso = { module = "org.teavm:teavm-jso", version.ref = "teavm" }
 teavm-jso-apis = { module = "org.teavm:teavm-jso-apis", version.ref = "teavm" }
 teavm-jso-impl = { module = "org.teavm:teavm-jso-impl", version.ref = "teavm" }
@@ -163,12 +172,10 @@ vanillaExtract = { module = "cc.tweaked.vanilla-extract:plugin", version.ref = "
 yarn = { module = "net.fabricmc:yarn", version.ref = "yarn" }
 
 [plugins]
-forgeGradle = { id = "net.minecraftforge.gradle", version.ref = "forgeGradle" }
 githubRelease = { id = "com.github.breadmoirai.github-release", version.ref = "githubRelease" }
 gradleVersions = { id = "com.github.ben-manes.versions", version.ref = "gradleVersions" }
 kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
-librarian = { id = "org.parchmentmc.librarian.forgegradle", version.ref = "librarian" }
-mixinGradle = { id = "org.spongepowered.mixin", version.ref = "mixinGradle" }
+shadow = { id = "com.gradleup.shadow", version.ref = "shadow" }
 taskTree = { id = "com.dorongold.task-tree", version.ref = "taskTree" }
 versionCatalogUpdate = { id = "nl.littlerobots.version-catalog-update", version.ref = "versionCatalogUpdate" }
 
@@ -177,15 +184,15 @@ annotations = ["jsr305", "checkerFramework", "jetbrainsAnnotations"]
 kotlin = ["kotlin-stdlib", "kotlin-coroutines"]
 
 # Minecraft
-externalMods-common = ["jei-api", "nightConfig-core", "nightConfig-toml"]
-externalMods-forge-compile = ["moreRed", "oculus", "jei-api"]
+externalMods-common = ["iris-forge", "jei-api", "nightConfig-core", "nightConfig-toml"]
+externalMods-forge-compile = ["moreRed", "iris-forge", "jei-api"]
 externalMods-forge-runtime = ["jei-forge"]
-externalMods-fabric-compile = ["fabricPermissions", "iris", "jei-api", "rei-api", "rei-builtin"]
+externalMods-fabric-compile = ["fabricPermissions", "iris-fabric", "jei-api", "rei-api", "rei-builtin"]
 externalMods-fabric-runtime = ["jei-fabric", "modmenu"]
 
 # Testing
 test = ["junit-jupiter-api", "junit-jupiter-params", "hamcrest", "jqwik-api"]
-testRuntime = ["junit-jupiter-engine", "jqwik-engine"]
+testRuntime = ["junit-jupiter-engine", "junit-platform-launcher", "jqwik-engine"]
 
 # Build tools
 teavm-api = ["teavm-jso", "teavm-jso-apis", "teavm-platform", "teavm-classlib", "teavm-metaprogramming-api"]

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -84,7 +86,7 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum

gradlew.bat

@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -43,11 +45,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,11 +59,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 

package.json

@@ -13,10 +13,10 @@
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^15.2.1",
-    "@rollup/plugin-typescript": "^11.0.0",
+    "@rollup/plugin-typescript": "^12.0.0",
     "@rollup/plugin-url": "^8.0.1",
     "@swc/core": "^1.3.92",
-    "@types/node": "^20.8.3",
+    "@types/node": "^22.0.0",
     "lightningcss": "^1.22.0",
     "preact-render-to-string": "^6.2.1",
     "rehype": "^13.0.0",

projects/common-api/build.gradle.kts

@@ -8,6 +8,8 @@ plugins {
     id("cc-tweaked.vanilla")
 }
 
+val mcVersion: String by extra
+
 java {
     withJavadocJar()
 }
@@ -16,9 +18,70 @@ dependencies {
     api(project(":core-api"))
 }
 
+val javadocOverview by tasks.registering(Copy::class) {
+    from("src/overview.html")
+    into(layout.buildDirectory.dir(name))
+
+    expand(
+        mapOf(
+            "mcVersion" to mcVersion,
+            "modVersion" to version,
+        ),
+    )
+}
+
 tasks.javadoc {
+    title = "CC: Tweaked $version for Minecraft $mcVersion"
     include("dan200/computercraft/api/**/*.java")
 
+    options {
+        (this as StandardJavadocDocletOptions)
+
+        inputs.files(javadocOverview)
+        overview(javadocOverview.get().destinationDir.resolve("overview.html").absolutePath)
+
+        groups = mapOf(
+            "Common" to listOf(
+                "dan200.computercraft.api",
+                "dan200.computercraft.api.lua",
+                "dan200.computercraft.api.peripheral",
+            ),
+            "Upgrades" to listOf(
+                "dan200.computercraft.api.client.turtle",
+                "dan200.computercraft.api.pocket",
+                "dan200.computercraft.api.turtle",
+                "dan200.computercraft.api.upgrades",
+            ),
+        )
+
+        addBooleanOption("-allow-script-in-comments", true)
+        bottom(
+            """
+            <script src="https://cdn.jsdelivr.net/npm/prismjs@v1.29.0/components/prism-core.min.js"></script>
+            <script src="https://cdn.jsdelivr.net/npm/prismjs@v1.29.0/plugins/autoloader/prism-autoloader.min.js"></script>
+            <link href=" https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism.min.css " rel="stylesheet">
+            """.trimIndent(),
+        )
+
+        val snippetSources = listOf(":common", ":fabric", ":forge").flatMap {
+            project(it).sourceSets["examples"].allSource.sourceDirectories
+        }
+        inputs.files(snippetSources)
+        addPathOption("-snippet-path").value = snippetSources
+    }
+
     // Include the core-api in our javadoc export. This is wrong, but it means we can export a single javadoc dump.
     source(project(":core-api").sourceSets.main.map { it.allJava })
+
+    options {
+        this as StandardJavadocDocletOptions
+        addBooleanOption("-allow-script-in-comments", true)
+        bottom(
+            """
+            <script src="https://cdn.jsdelivr.net/npm/prismjs@v1.29.0/components/prism-core.min.js"></script>
+            <script src="https://cdn.jsdelivr.net/npm/prismjs@v1.29.0/plugins/autoloader/prism-autoloader.min.js"></script>
+            <link href=" https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism.min.css " rel="stylesheet">
+            """.trimIndent(),
+        )
+    }
 }

projects/common-api/src/client/java/dan200/computercraft/api/client/ComputerCraftAPIClient.java

@@ -1,43 +0,0 @@
-// SPDX-FileCopyrightText: 2022 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.client;
-
-import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
-import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import dan200.computercraft.impl.client.ComputerCraftAPIClientService;
-
-/**
- * The public API for client-only code.
- *
- * @see dan200.computercraft.api.ComputerCraftAPI The main API
- */
-public final class ComputerCraftAPIClient {
-    private ComputerCraftAPIClient() {
-    }
-
-    /**
-     * Register a {@link TurtleUpgradeModeller} for a class of turtle upgrades.
-     * <p>
-     * This may be called at any point after registry creation, though it is recommended to call it within your client
-     * setup step.
-     *
-     * @param serialiser The turtle upgrade serialiser.
-     * @param modeller   The upgrade modeller.
-     * @param <T>        The type of the turtle upgrade.
-     * @deprecated This method can lead to confusing load behaviour on Forge. Use
-     * {@code dan200.computercraft.api.client.FabricComputerCraftAPIClient#registerTurtleUpgradeModeller} on Fabric, or
-     * {@code dan200.computercraft.api.client.turtle.RegisterTurtleModellersEvent} on Forge.
-     */
-    @Deprecated(forRemoval = true)
-    public static <T extends ITurtleUpgrade> void registerTurtleUpgradeModeller(TurtleUpgradeSerialiser<T> serialiser, TurtleUpgradeModeller<T> modeller) {
-        // TODO(1.20.4): Remove this
-        getInstance().registerTurtleUpgradeModeller(serialiser, modeller);
-    }
-
-    private static ComputerCraftAPIClientService getInstance() {
-        return ComputerCraftAPIClientService.get();
-    }
-}

projects/common-api/src/client/java/dan200/computercraft/api/client/ModelLocation.java

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.client;
+
+import dan200.computercraft.api.client.turtle.TurtleUpgradeModeller;
+import dan200.computercraft.impl.client.ClientPlatformHelper;
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.client.resources.model.ModelManager;
+import net.minecraft.client.resources.model.ModelResourceLocation;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.stream.Stream;
+
+/**
+ * The location of a model to load. This may either be:
+ *
+ * <ul>
+ *     <li>A {@link ModelResourceLocation}, referencing an already baked model (such as {@code minecraft:dirt#inventory}).</li>
+ *     <li>
+ *         A {@link ResourceLocation}, referencing a path to a model resource (such as {@code minecraft:item/dirt}.
+ *         These models will be baked and stored in the {@link ModelManager} in a loader-specific way.
+ *     </li>
+ * </ul>
+ */
+public final class ModelLocation {
+    /**
+     * The location of the model.
+     * <p>
+     * When {@link #resourceLocation} is null, this is the location of the model to load. When {@link #resourceLocation}
+     * is non-null, this is the "standalone" variant of the model resource — this is used by NeoForge's implementation
+     * of {@link ClientPlatformHelper#getModel(ModelManager, ModelResourceLocation, ResourceLocation)} to fetch the
+     * model from the model manger. It is not used on Fabric.
+     */
+    private final ModelResourceLocation modelLocation;
+    private final @Nullable ResourceLocation resourceLocation;
+
+    private ModelLocation(ModelResourceLocation modelLocation, @Nullable ResourceLocation resourceLocation) {
+        this.modelLocation = modelLocation;
+        this.resourceLocation = resourceLocation;
+    }
+
+    /**
+     * Create a {@link ModelLocation} from model in the model manager.
+     *
+     * @param location The name of the model to load.
+     * @return The new {@link ModelLocation} instance.
+     */
+    public static ModelLocation ofModel(ModelResourceLocation location) {
+        return new ModelLocation(location, null);
+    }
+
+    /**
+     * Create a {@link ModelLocation} from a resource.
+     *
+     * @param location The location of the model resource, such as {@code minecraft:item/dirt}.
+     * @return The new {@link ModelLocation} instance.
+     */
+    public static ModelLocation ofResource(ResourceLocation location) {
+        return new ModelLocation(new ModelResourceLocation(location, "standalone"), location);
+    }
+
+    /**
+     * Get this model from the provided model manager.
+     *
+     * @param manager The model manger.
+     * @return This model, or the missing model if it could not be found.
+     */
+    public BakedModel getModel(ModelManager manager) {
+        return ClientPlatformHelper.get().getModel(manager, modelLocation, resourceLocation);
+    }
+
+    /**
+     * Get the models this model location depends on.
+     *
+     * @return A list of models that this model location depends on.
+     * @see TurtleUpgradeModeller#getDependencies()
+     */
+    public Stream<ResourceLocation> getDependencies() {
+        return resourceLocation == null ? Stream.empty() : Stream.of(resourceLocation);
+    }
+}

projects/common-api/src/client/java/dan200/computercraft/api/client/TransformedModel.java

@@ -13,30 +13,47 @@ import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.ItemStack;
 
-import java.util.Objects;
-
 /**
  * A model to render, combined with a transformation matrix to apply.
+ *
+ * @param model  The model.
+ * @param matrix The transformation matrix.
  */
-public final class TransformedModel {
-    private final BakedModel model;
-    private final Transformation matrix;
-
-    public TransformedModel(BakedModel model, Transformation matrix) {
-        this.model = Objects.requireNonNull(model);
-        this.matrix = Objects.requireNonNull(matrix);
-    }
-
+public record TransformedModel(BakedModel model, Transformation matrix) {
     public TransformedModel(BakedModel model) {
-        this.model = Objects.requireNonNull(model);
-        matrix = Transformation.identity();
+        this(model, Transformation.identity());
     }
 
+    /**
+     * Look up a model in the model bakery and construct a {@link TransformedModel} with no transformation.
+     *
+     * @param location The location of the model to load.
+     * @return The new {@link TransformedModel} instance.
+     */
+    public static TransformedModel of(ModelLocation location) {
+        var modelManager = Minecraft.getInstance().getModelManager();
+        return new TransformedModel(location.getModel(modelManager));
+    }
+
+    /**
+     * Look up a model in the model bakery and construct a {@link TransformedModel} with no transformation.
+     *
+     * @param location The location of the model to load.
+     * @return The new {@link TransformedModel} instance.
+     * @see ModelLocation#ofModel(ModelResourceLocation)
+     */
     public static TransformedModel of(ModelResourceLocation location) {
         var modelManager = Minecraft.getInstance().getModelManager();
         return new TransformedModel(modelManager.getModel(location));
     }
 
+    /**
+     * Look up a model in the model bakery and construct a {@link TransformedModel} with no transformation.
+     *
+     * @param location The location of the model to load.
+     * @return The new {@link TransformedModel} instance.
+     * @see ModelLocation#ofResource(ResourceLocation)
+     */
     public static TransformedModel of(ResourceLocation location) {
         var modelManager = Minecraft.getInstance().getModelManager();
         return new TransformedModel(ClientPlatformHelper.get().getModel(modelManager, location));
@@ -46,12 +63,4 @@ public final class TransformedModel {
         var model = Minecraft.getInstance().getItemRenderer().getItemModelShaper().getItemModel(item);
         return new TransformedModel(model, transform);
     }
-
-    public BakedModel getModel() {
-        return model;
-    }
-
-    public Transformation getMatrix() {
-        return matrix;
-    }
 }

projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/RegisterTurtleUpgradeModeller.java

@@ -5,7 +5,7 @@
 package dan200.computercraft.api.client.turtle;
 
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
+import dan200.computercraft.api.upgrades.UpgradeType;
 
 /**
  * A functional interface to register a {@link TurtleUpgradeModeller} for a class of turtle upgrades.
@@ -18,9 +18,9 @@ public interface RegisterTurtleUpgradeModeller {
     /**
      * Register a {@link TurtleUpgradeModeller}.
      *
-     * @param serialiser The turtle upgrade serialiser.
-     * @param modeller   The upgrade modeller.
-     * @param <T>        The type of the turtle upgrade.
+     * @param type     The turtle upgrade type.
+     * @param modeller The upgrade modeller.
+     * @param <T>      The type of the turtle upgrade.
      */
-    <T extends ITurtleUpgrade> void register(TurtleUpgradeSerialiser<T> serialiser, TurtleUpgradeModeller<T> modeller);
+    <T extends ITurtleUpgrade> void register(UpgradeType<T> type, TurtleUpgradeModeller<T> modeller);
 }

projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModeller.java

@@ -4,25 +4,31 @@
 
 package dan200.computercraft.api.client.turtle;
 
+import dan200.computercraft.api.client.ModelLocation;
 import dan200.computercraft.api.client.TransformedModel;
 import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
-import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.client.resources.model.UnbakedModel;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.resources.ResourceLocation;
 
 import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.List;
+import java.util.stream.Stream;
 
 /**
  * Provides models for a {@link ITurtleUpgrade}.
  * <p>
  * Use {@code dan200.computercraft.api.client.FabricComputerCraftAPIClient#registerTurtleUpgradeModeller} to register a
  * modeller on Fabric and {@code dan200.computercraft.api.client.turtle.RegisterTurtleModellersEvent} to register one
- * on Forge
+ * on Forge.
+ *
+ * <h2>Example</h2>
+ * <h3>Fabric</h3>
+ * {@snippet class=com.example.examplemod.FabricExampleModClient region=turtle_modellers}
+ *
+ * <h3>Forge</h3>
+ * {@snippet class=com.example.examplemod.FabricExampleModClient region=turtle_modellers}
  *
  * @param <T> The type of turtle upgrade this modeller applies to.
  * @see RegisterTurtleUpgradeModeller For multi-loader registration support.
@@ -31,47 +37,32 @@ public interface TurtleUpgradeModeller<T extends ITurtleUpgrade> {
     /**
      * Obtain the model to be used when rendering a turtle peripheral.
      * <p>
-     * When the current turtle is {@literal null}, this function should be constant for a given upgrade and side.
+     * When the current turtle is {@literal null}, this function should be constant for a given upgrade, side and data.
      *
      * @param upgrade The upgrade that you're getting the model for.
-     * @param turtle  Access to the turtle that the upgrade resides on. This will be null when getting item models, unless
-     *                {@link #getModel(ITurtleUpgrade, CompoundTag, TurtleSide)} is overriden.
+     * @param turtle  Access to the turtle that the upgrade resides on. This will be null when getting item models.
      * @param side    Which side of the turtle (left or right) the upgrade resides on.
-     * @return The model that you wish to be used to render your upgrade.
-     */
-    TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side);
-
-    /**
-     * Obtain the model to be used when rendering a turtle peripheral.
-     * <p>
-     * This is used when rendering the turtle's item model, and so no {@link ITurtleAccess} is available.
-     *
-     * @param upgrade The upgrade that you're getting the model for.
      * @param data    Upgrade data instance for current turtle side.
-     * @param side    Which side of the turtle (left or right) the upgrade resides on.
      * @return The model that you wish to be used to render your upgrade.
      */
-    default TransformedModel getModel(T upgrade, CompoundTag data, TurtleSide side) {
-        return getModel(upgrade, (ITurtleAccess) null, side);
-    }
-
+    TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data);
 
     /**
-     * Get a list of models that this turtle modeller depends on.
+     * Get the models that this turtle modeller depends on.
      * <p>
-     * Models included in this list will be loaded and baked alongside item and block models, and so may be referenced
+     * Models included in this stream will be loaded and baked alongside item and block models, and so may be referenced
      * by {@link TransformedModel#of(ResourceLocation)}. You do not need to override this method if you will load models
      * by other means.
      *
      * @return A list of models that this modeller depends on.
      * @see UnbakedModel#getDependencies()
      */
-    default Collection<ResourceLocation> getDependencies() {
-        return List.of();
+    default Stream<ResourceLocation> getDependencies() {
+        return Stream.of();
     }
 
     /**
-     * A basic {@link TurtleUpgradeModeller} which renders using the upgrade's {@linkplain ITurtleUpgrade#getUpgradeItem(CompoundTag)}
+     * A basic {@link TurtleUpgradeModeller} which renders using the upgrade's {@linkplain ITurtleUpgrade#getUpgradeItem(DataComponentPatch)}
      * upgrade item}.
      * <p>
      * This uses appropriate transformations for "flat" items, namely those extending the {@literal minecraft:item/generated}
@@ -93,9 +84,8 @@ public interface TurtleUpgradeModeller<T extends ITurtleUpgrade> {
      * @param <T>   The type of the turtle upgrade.
      * @return The constructed modeller.
      */
-    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ModelResourceLocation left, ModelResourceLocation right) {
-        // TODO(1.21.0): Remove this.
-        return sided((ResourceLocation) left, right);
+    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ResourceLocation left, ResourceLocation right) {
+        return sided(ModelLocation.ofResource(left), ModelLocation.ofResource(right));
     }
 
     /**
@@ -106,16 +96,16 @@ public interface TurtleUpgradeModeller<T extends ITurtleUpgrade> {
      * @param <T>   The type of the turtle upgrade.
      * @return The constructed modeller.
      */
-    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ResourceLocation left, ResourceLocation right) {
+    static <T extends ITurtleUpgrade> TurtleUpgradeModeller<T> sided(ModelLocation left, ModelLocation right) {
         return new TurtleUpgradeModeller<>() {
             @Override
-            public TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side) {
+            public TransformedModel getModel(T upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data) {
                 return TransformedModel.of(side == TurtleSide.LEFT ? left : right);
             }
 
             @Override
-            public Collection<ResourceLocation> getDependencies() {
-                return List.of(left, right);
+            public Stream<ResourceLocation> getDependencies() {
+                return Stream.of(left, right).flatMap(ModelLocation::getDependencies);
             }
         };
     }

projects/common-api/src/client/java/dan200/computercraft/api/client/turtle/TurtleUpgradeModellers.java

@@ -11,8 +11,7 @@ import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
 import dan200.computercraft.impl.client.ClientPlatformHelper;
 import net.minecraft.client.Minecraft;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.world.item.ItemStack;
+import net.minecraft.core.component.DataComponentPatch;
 import org.joml.Matrix4f;
 
 import javax.annotation.Nullable;
@@ -37,16 +36,8 @@ final class TurtleUpgradeModellers {
 
     private static final class UpgradeItemModeller implements TurtleUpgradeModeller<ITurtleUpgrade> {
         @Override
-        public TransformedModel getModel(ITurtleUpgrade upgrade, @Nullable ITurtleAccess turtle, TurtleSide side) {
-            return getModel(turtle == null ? upgrade.getCraftingItem() : upgrade.getUpgradeItem(turtle.getUpgradeNBTData(side)), side);
-        }
-
-        @Override
-        public TransformedModel getModel(ITurtleUpgrade upgrade, CompoundTag data, TurtleSide side) {
-            return getModel(upgrade.getUpgradeItem(data), side);
-        }
-
-        private TransformedModel getModel(ItemStack stack, TurtleSide side) {
+        public TransformedModel getModel(ITurtleUpgrade upgrade, @Nullable ITurtleAccess turtle, TurtleSide side, DataComponentPatch data) {
+            var stack = upgrade.getUpgradeItem(data);
             var model = Minecraft.getInstance().getItemRenderer().getItemModelShaper().getItemModel(stack);
             if (stack.hasFoil()) model = ClientPlatformHelper.get().createdFoiledModel(model);
             return new TransformedModel(model, side == TurtleSide.LEFT ? leftTransform : rightTransform);

projects/common-api/src/client/java/dan200/computercraft/impl/client/ClientPlatformHelper.java

@@ -4,6 +4,7 @@
 
 package dan200.computercraft.impl.client;
 
+import dan200.computercraft.api.client.ModelLocation;
 import dan200.computercraft.impl.Services;
 import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.resources.model.BakedModel;
@@ -17,13 +18,28 @@ import javax.annotation.Nullable;
 @ApiStatus.Internal
 public interface ClientPlatformHelper {
     /**
-     * Equivalent to {@link ModelManager#getModel(ModelResourceLocation)} but for arbitrary {@link ResourceLocation}s.
+     * Get a model from a resource.
      *
-     * @param manager  The model manager.
-     * @param location The model location.
+     * @param manager          The model manager.
+     * @param resourceLocation The model resourceLocation.
      * @return The baked model.
+     * @see ModelLocation
      */
-    BakedModel getModel(ModelManager manager, ResourceLocation location);
+    BakedModel getModel(ModelManager manager, ResourceLocation resourceLocation);
+
+    /**
+     * Set a model from a {@link ModelResourceLocation} or {@link ResourceLocation}.
+     * <p>
+     * This is largely equivalent to {@code resourceLocation == null ? manager.getModel(modelLocation) : getModel(manager, resourceLocation)},
+     * but allows pre-computing {@code modelLocation} (if needed).
+     *
+     * @param manager          The model manager.
+     * @param modelLocation    The location of the model to load.
+     * @param resourceLocation The location of the resource, if trying to load from a resource.
+     * @return The baked model.
+     * @see ModelLocation
+     */
+    BakedModel getModel(ModelManager manager, ModelResourceLocation modelLocation, @Nullable ResourceLocation resourceLocation);
 
     /**
      * Wrap this model in a version which renders a foil/enchantment glint.

projects/common-api/src/main/java/dan200/computercraft/api/ComputerCraftAPI.java

@@ -4,9 +4,11 @@
 
 package dan200.computercraft.api;
 
+import dan200.computercraft.api.component.ComputerComponent;
 import dan200.computercraft.api.filesystem.Mount;
 import dan200.computercraft.api.filesystem.WritableMount;
 import dan200.computercraft.api.lua.GenericSource;
+import dan200.computercraft.api.lua.IComputerSystem;
 import dan200.computercraft.api.lua.ILuaAPI;
 import dan200.computercraft.api.lua.ILuaAPIFactory;
 import dan200.computercraft.api.media.IMedia;
@@ -165,7 +167,13 @@ public final class ComputerCraftAPI {
      * Register a custom {@link ILuaAPI}, which may be added onto all computers without requiring a peripheral.
      * <p>
      * Before implementing this interface, consider alternative methods of providing methods. It is generally preferred
-     * to use peripherals to provide functionality to users.
+     * to use peripherals to provide functionality to users. If an API is <em>required</em>, you may want to consider
+     * using {@link ILuaAPI#getModuleName()} to expose this library as a module instead of as a global.
+     * <p>
+     * This may be used with {@link IComputerSystem#getComponent(ComputerComponent)} to only attach APIs to specific
+     * computers. For example, one can add a new API just to turtles with the following code:
+     *
+     * {@snippet class=com.example.examplemod.ExampleAPI region=register}
      *
      * @param factory The factory for your API subclass.
      * @see ILuaAPIFactory

projects/common-api/src/main/java/dan200/computercraft/api/ComputerCraftTags.java

@@ -6,10 +6,12 @@ package dan200.computercraft.api;
 
 import net.minecraft.core.registries.Registries;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.ItemTags;
 import net.minecraft.tags.TagKey;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.context.UseOnContext;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Block;
@@ -35,8 +37,16 @@ public class ComputerCraftTags {
          */
         public static final TagKey<Item> TURTLE_CAN_PLACE = make("turtle_can_place");
 
+        /**
+         * Items which can be dyed.
+         * <p>
+         * This is similar to {@link ItemTags#DYEABLE}, but allows cleaning the item with a sponge, rather than in a
+         * cauldron.
+         */
+        public static final TagKey<Item> DYEABLE = make("dyeable");
+
         private static TagKey<Item> make(String name) {
-            return TagKey.create(Registries.ITEM, new ResourceLocation(ComputerCraftAPI.MOD_ID, name));
+            return TagKey.create(Registries.ITEM, ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, name));
         }
     }
 
@@ -75,13 +85,13 @@ public class ComputerCraftTags {
         public static final TagKey<Block> TURTLE_HOE_BREAKABLE = make("turtle_hoe_harvestable");
 
         /**
-         * Block which can be {@linkplain BlockState#use(Level, Player, InteractionHand, BlockHitResult) used} when
-         * calling {@code turtle.place()}.
+         * Block which can be {@linkplain BlockState#useItemOn(ItemStack, Level, Player, InteractionHand, BlockHitResult) used}
+         * when calling {@code turtle.place()}.
          */
         public static final TagKey<Block> TURTLE_CAN_USE = make("turtle_can_use");
 
         private static TagKey<Block> make(String name) {
-            return TagKey.create(Registries.BLOCK, new ResourceLocation(ComputerCraftAPI.MOD_ID, name));
+            return TagKey.create(Registries.BLOCK, ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, name));
         }
     }
 }

projects/common-api/src/main/java/dan200/computercraft/api/component/AdminComputer.java

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.component;
+
+import net.minecraft.commands.CommandSourceStack;
+import org.jetbrains.annotations.ApiStatus;
+
+/**
+ * A computer which has permission to perform administrative/op commands, such as the command computer.
+ */
+@ApiStatus.NonExtendable
+public interface AdminComputer {
+    /**
+     * The permission level that this computer can operate at.
+     *
+     * @return The permission level for this computer.
+     * @see CommandSourceStack#hasPermission(int)
+     */
+    default int permissionLevel() {
+        return 2;
+    }
+}

projects/common-api/src/main/java/dan200/computercraft/api/component/ComputerComponent.java

@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.component;
+
+import dan200.computercraft.api.lua.IComputerSystem;
+import dan200.computercraft.api.lua.ILuaAPIFactory;
+
+/**
+ * A component attached to a computer.
+ * <p>
+ * Components provide a mechanism to attach additional data to a computer, that can then be queried with
+ * {@link IComputerSystem#getComponent(ComputerComponent)}.
+ * <p>
+ * This is largely designed for {@linkplain ILuaAPIFactory custom APIs}, allowing APIs to read additional properties
+ * of the computer, such as its position.
+ *
+ * @param <T> The type of this component.
+ * @see ComputerComponents The built-in components.
+ */
+@SuppressWarnings("UnusedTypeParameter")
+public final class ComputerComponent<T> {
+    private final String id;
+
+    private ComputerComponent(String id) {
+        this.id = id;
+    }
+
+    /**
+     * Create a new computer component.
+     * <p>
+     * Mods typically will not need to create their own components.
+     *
+     * @param namespace The namespace of this component. This should be the mod id.
+     * @param id        The unique id of this component.
+     * @param <T>       The component
+     * @return The newly created component.
+     */
+    public static <T> ComputerComponent<T> create(String namespace, String id) {
+        return new ComputerComponent<>(namespace + ":" + id);
+    }
+
+    @Override
+    public String toString() {
+        return "ComputerComponent(" + id + ")";
+    }
+}

projects/common-api/src/main/java/dan200/computercraft/api/component/ComputerComponents.java

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.component;
+
+import dan200.computercraft.api.ComputerCraftAPI;
+import dan200.computercraft.api.pocket.IPocketAccess;
+import dan200.computercraft.api.turtle.ITurtleAccess;
+
+/**
+ * The {@link ComputerComponent}s provided by ComputerCraft.
+ */
+public class ComputerComponents {
+    /**
+     * The {@link ITurtleAccess} associated with a turtle.
+     */
+    public static final ComputerComponent<ITurtleAccess> TURTLE = ComputerComponent.create(ComputerCraftAPI.MOD_ID, "turtle");
+
+    /**
+     * The {@link IPocketAccess} associated with a pocket computer.
+     */
+    public static final ComputerComponent<IPocketAccess> POCKET = ComputerComponent.create(ComputerCraftAPI.MOD_ID, "pocket");
+
+    /**
+     * This component is only present on "command computers", and other computers with admin capabilities.
+     */
+    public static final ComputerComponent<AdminComputer> ADMIN_COMPUTER = ComputerComponent.create(ComputerCraftAPI.MOD_ID, "admin_computer");
+}

projects/common-api/src/main/java/dan200/computercraft/api/detail/BasicItemDetailProvider.java

@@ -13,7 +13,7 @@ import java.util.Map;
 import java.util.Objects;
 
 /**
- * An item detail provider for {@link ItemStack}'s whose {@link Item} has a specific type.
+ * An item detail provider for {@link ItemStack}s whose {@link Item} has a specific type.
  *
  * @param <T> The type the stack's item must have.
  */
@@ -22,7 +22,7 @@ public abstract class BasicItemDetailProvider<T> implements DetailProvider<ItemS
     private final @Nullable String namespace;
 
     /**
-     * Create a new item detail provider. Meta will be inserted into a new sub-map named as per {@code namespace}.
+     * Create a new item detail provider. Details will be inserted into a new sub-map named as per {@code namespace}.
      *
      * @param itemType  The type the stack's item must have.
      * @param namespace The namespace to use for this provider.
@@ -34,7 +34,7 @@ public abstract class BasicItemDetailProvider<T> implements DetailProvider<ItemS
     }
 
     /**
-     * Create a new item detail provider. Meta will be inserted directly into the results.
+     * Create a new item detail provider. Details will be inserted directly into the results.
      *
      * @param itemType The type the stack's item must have.
      */
@@ -53,21 +53,18 @@ public abstract class BasicItemDetailProvider<T> implements DetailProvider<ItemS
      * @param stack The item stack to provide details for.
      * @param item  The item to provide details for.
      */
-    public abstract void provideDetails(
-        Map<? super String, Object> data, ItemStack stack, T item
-    );
+    public abstract void provideDetails(Map<? super String, Object> data, ItemStack stack, T item);
 
     @Override
-    public void provideDetails(Map<? super String, Object> data, ItemStack stack) {
+    public final void provideDetails(Map<? super String, Object> data, ItemStack stack) {
         var item = stack.getItem();
         if (!itemType.isInstance(item)) return;
 
-        // If `namespace` is specified, insert into a new data map instead of the existing one.
-        Map<? super String, Object> child = namespace == null ? data : new HashMap<>();
-
-        provideDetails(child, stack, itemType.cast(item));
-
-        if (namespace != null) {
+        if (namespace == null) {
+            provideDetails(data, stack, itemType.cast(item));
+        } else {
+            Map<? super String, Object> child = new HashMap<>();
+            provideDetails(child, stack, itemType.cast(item));
             data.put(namespace, child);
         }
     }

projects/common-api/src/main/java/dan200/computercraft/api/detail/ComponentDetailProvider.java

@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: 2024 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.detail;
+
+import net.minecraft.core.component.DataComponentHolder;
+import net.minecraft.core.component.DataComponentType;
+import net.minecraft.world.item.ItemStack;
+
+import javax.annotation.Nullable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * An item detail provider for a specific {@linkplain DataComponentType data component} on {@link ItemStack}s or
+ * other {@link DataComponentHolder}.
+ *
+ * @param <T> The type of the component's contents.
+ */
+public abstract class ComponentDetailProvider<T> implements DetailProvider<DataComponentHolder> {
+    private final DataComponentType<T> component;
+    private final @Nullable String namespace;
+
+    /**
+     * Create a new component detail provider. Details will be inserted into a new sub-map named as per {@code namespace}.
+     *
+     * @param component The data component to provide details for.
+     * @param namespace The namespace to use for this provider.
+     */
+    public ComponentDetailProvider(@Nullable String namespace, DataComponentType<T> component) {
+        Objects.requireNonNull(component);
+        this.component = component;
+        this.namespace = namespace;
+    }
+
+    /**
+     * Create a new component detail provider. Details will be inserted directly into the results.
+     *
+     * @param component The data component to provide details for.
+     */
+    public ComponentDetailProvider(DataComponentType<T> component) {
+        this(null, component);
+    }
+
+    /**
+     * Provide additional details for the given data component. This method is called by {@code turtle.getItemDetail()}.
+     * New properties should be added to the given {@link Map}, {@code data}.
+     * <p>
+     * This method is always called on the server thread, so it is safe to interact with the world here, but you should
+     * take care to avoid long blocking operations as this will stall the server and other computers.
+     *
+     * @param data The full details to be returned for this item stack. New properties should be added to this map.
+     * @param item The component to provide details for.
+     */
+    public abstract void provideComponentDetails(Map<? super String, Object> data, T item);
+
+    @Override
+    public final void provideDetails(Map<? super String, Object> data, DataComponentHolder holder) {
+        var value = holder.get(component);
+        if (value == null) return;
+
+        if (namespace == null) {
+            provideComponentDetails(data, value);
+        } else {
+            Map<? super String, Object> child = new HashMap<>();
+            provideComponentDetails(child, value);
+            data.put(namespace, child);
+        }
+    }
+}

projects/common-api/src/main/java/dan200/computercraft/api/detail/DetailRegistry.java

@@ -26,7 +26,7 @@ public interface DetailRegistry<T> {
      * @param provider The detail provider to register.
      * @see DetailProvider
      */
-    void addProvider(DetailProvider<T> provider);
+    void addProvider(DetailProvider<? super T> provider);
 
     /**
      * Compute basic details about an object. This is cheaper than computing all details operation, and so is suitable

projects/common-api/src/main/java/dan200/computercraft/api/lua/IComputerSystem.java

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.lua;
+
+import dan200.computercraft.api.component.ComputerComponent;
+import dan200.computercraft.api.peripheral.IComputerAccess;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import org.jetbrains.annotations.ApiStatus;
+
+import javax.annotation.Nullable;
+
+/**
+ * An interface passed to {@link ILuaAPIFactory} in order to provide additional information
+ * about a computer.
+ */
+@ApiStatus.NonExtendable
+public interface IComputerSystem extends IComputerAccess {
+    /**
+     * Get the level this computer is currently in.
+     * <p>
+     * This method is not guaranteed to remain the same (even for stationary computers).
+     *
+     * @return The computer's current level.
+     */
+    ServerLevel getLevel();
+
+    /**
+     * Get the position this computer is currently at.
+     * <p>
+     * This method is not guaranteed to remain the same (even for stationary computers).
+     *
+     * @return The computer's current position.
+     */
+    BlockPos getPosition();
+
+    /**
+     * Get the label for this computer.
+     *
+     * @return This computer's label, or {@code null} if it is not set.
+     */
+    @Nullable
+    String getLabel();
+
+    /**
+     * Get a component attached to this computer.
+     * <p>
+     * No component is guaranteed to be on a computer, and so this method should always be guarded with a null check.
+     * <p>
+     * This method will always return the same value for a given component, and so may be cached.
+     *
+     * @param component The component to query.
+     * @param <T>       The type of the component.
+     * @return The component, if present.
+     */
+    <T> @Nullable T getComponent(ComputerComponent<T> component);
+}

projects/common-api/src/main/java/dan200/computercraft/api/lua/ILuaAPIFactory.java

@@ -4,13 +4,15 @@
 
 package dan200.computercraft.api.lua;
 
+import dan200.computercraft.api.ComputerCraftAPI;
+
 import javax.annotation.Nullable;
 
 /**
- * Construct an {@link ILuaAPI} for a specific computer.
+ * Construct an {@link ILuaAPI} for a computer.
  *
  * @see ILuaAPI
- * @see dan200.computercraft.api.ComputerCraftAPI#registerAPIFactory(ILuaAPIFactory)
+ * @see ComputerCraftAPI#registerAPIFactory(ILuaAPIFactory)
  */
 @FunctionalInterface
 public interface ILuaAPIFactory {

projects/common-api/src/main/java/dan200/computercraft/api/media/IMedia.java

@@ -7,11 +7,13 @@ package dan200.computercraft.api.media;
 import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.filesystem.Mount;
 import dan200.computercraft.api.filesystem.WritableMount;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerLevel;
-import net.minecraft.sounds.SoundEvent;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.JukeboxSong;
 
 import javax.annotation.Nullable;
 
@@ -25,11 +27,12 @@ public interface IMedia {
     /**
      * Get a string representing the label of this item. Will be called via {@code disk.getLabel()} in lua.
      *
-     * @param stack The {@link ItemStack} to inspect.
+     * @param registries The currently loaded registries.
+     * @param stack      The {@link ItemStack} to inspect.
      * @return The label. ie: "Dan's Programs".
      */
     @Nullable
-    String getLabel(ItemStack stack);
+    String getLabel(HolderLookup.Provider registries, ItemStack stack);
 
     /**
      * Set a string representing the label of this item. Will be called vi {@code disk.setLabel()} in lua.
@@ -43,26 +46,15 @@ public interface IMedia {
     }
 
     /**
-     * If this disk represents an item with audio (like a record), get the readable name of the audio track. ie:
-     * "Jonathan Coulton - Still Alive"
+     * If this disk represents an item with audio (like a record), get the corresponding {@link JukeboxSong}.
      *
-     * @param stack The {@link ItemStack} to modify.
-     * @return The name, or null if this item does not represent an item with audio.
+     * @param registries The currently loaded registries.
+     * @param stack      The {@link ItemStack} to query.
+     * @return The song, or null if this item does not represent an item with audio.
      */
     @Nullable
-    default String getAudioTitle(ItemStack stack) {
-        return null;
-    }
-
-    /**
-     * If this disk represents an item with audio (like a record), get the resource name of the audio track to play.
-     *
-     * @param stack The {@link ItemStack} to modify.
-     * @return The name, or null if this item does not represent an item with audio.
-     */
-    @Nullable
-    default SoundEvent getAudio(ItemStack stack) {
-        return null;
+    default Holder<JukeboxSong> getAudio(HolderLookup.Provider registries, ItemStack stack) {
+        return JukeboxSong.fromStack(registries, stack).orElse(null);
     }
 
     /**

projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredElement.java

@@ -14,13 +14,13 @@ import dan200.computercraft.api.ComputerCraftAPI;
  * as a proxy for all network objects. Whilst the node may change networks, an element's node should remain constant
  * for its lifespan.
  * <p>
- * Elements are generally tied to a block or tile entity in world. In such as case, one should provide the
+ * Elements are generally tied to a block or block entity in world. In such as case, one should provide the
  * {@link WiredElement} capability for the appropriate sides.
  */
 public interface WiredElement extends WiredSender {
     /**
-     * Called when objects on the network change. This may occur when network nodes are added or removed, or when
-     * peripherals change.
+     * Called when peripherals on the network change. This may occur when network nodes are added or removed, or when
+     * peripherals are attached or detached from a modem.
      *
      * @param change The change which occurred.
      * @see WiredNetworkChange

projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredNetwork.java

@@ -1,82 +0,0 @@
-// SPDX-FileCopyrightText: 2018 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.network.wired;
-
-import dan200.computercraft.api.peripheral.IPeripheral;
-
-import java.util.Map;
-
-/**
- * A wired network is composed of one of more {@link WiredNode}s, a set of connections between them, and a series
- * of peripherals.
- * <p>
- * Networks from a connected graph. This means there is some path between all nodes on the network. Further more, if
- * there is some path between two nodes then they must be on the same network. {@link WiredNetwork} will automatically
- * handle the merging and splitting of networks (and thus changing of available nodes and peripherals) as connections
- * change.
- * <p>
- * This does mean one can not rely on the network remaining consistent between subsequent operations. Consequently,
- * it is generally preferred to use the methods provided by {@link WiredNode}.
- *
- * @see WiredNode#getNetwork()
- */
-public interface WiredNetwork {
-    /**
-     * Create a connection between two nodes.
-     * <p>
-     * This should only be used on the server thread.
-     *
-     * @param left  The first node to connect
-     * @param right The second node to connect
-     * @return {@code true} if a connection was created or {@code false} if the connection already exists.
-     * @throws IllegalStateException    If neither node is on the network.
-     * @throws IllegalArgumentException If {@code left} and {@code right} are equal.
-     * @see WiredNode#connectTo(WiredNode)
-     * @see WiredNetwork#connect(WiredNode, WiredNode)
-     */
-    boolean connect(WiredNode left, WiredNode right);
-
-    /**
-     * Destroy a connection between this node and another.
-     * <p>
-     * This should only be used on the server thread.
-     *
-     * @param left  The first node in the connection.
-     * @param right The second node in the connection.
-     * @return {@code true} if a connection was destroyed or {@code false} if no connection exists.
-     * @throws IllegalArgumentException If either node is not on the network.
-     * @throws IllegalArgumentException If {@code left} and {@code right} are equal.
-     * @see WiredNode#disconnectFrom(WiredNode)
-     * @see WiredNetwork#connect(WiredNode, WiredNode)
-     */
-    boolean disconnect(WiredNode left, WiredNode right);
-
-    /**
-     * Sever all connections this node has, removing it from this network.
-     * <p>
-     * This should only be used on the server thread. You should only call this on nodes
-     * that your network element owns.
-     *
-     * @param node The node to remove
-     * @return Whether this node was removed from the network. One cannot remove a node from a network where it is the
-     * only element.
-     * @throws IllegalArgumentException If the node is not in the network.
-     * @see WiredNode#remove()
-     */
-    boolean remove(WiredNode node);
-
-    /**
-     * Update the peripherals a node provides.
-     * <p>
-     * This should only be used on the server thread. You should only call this on nodes
-     * that your network element owns.
-     *
-     * @param node        The node to attach peripherals for.
-     * @param peripherals The new peripherals for this node.
-     * @throws IllegalArgumentException If the node is not in the network.
-     * @see WiredNode#updatePeripherals(Map)
-     */
-    void updatePeripherals(WiredNode node, Map<String, IPeripheral> peripherals);
-}

projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredNode.java

@@ -6,11 +6,12 @@ package dan200.computercraft.api.network.wired;
 
 import dan200.computercraft.api.network.PacketNetwork;
 import dan200.computercraft.api.peripheral.IPeripheral;
+import org.jetbrains.annotations.ApiStatus;
 
 import java.util.Map;
 
 /**
- * Wired nodes act as a layer between {@link WiredElement}s and {@link WiredNetwork}s.
+ * A single node on a wired network.
  * <p>
  * Firstly, a node acts as a packet network, capable of sending and receiving modem messages to connected nodes. These
  * methods may be safely used on any thread.
@@ -22,6 +23,7 @@ import java.util.Map;
  * Wired nodes also provide several convenience methods for interacting with a wired network. These should only ever
  * be used on the main server thread.
  */
+@ApiStatus.NonExtendable
 public interface WiredNode extends PacketNetwork {
     /**
      * The associated element for this network node.
@@ -30,16 +32,6 @@ public interface WiredNode extends PacketNetwork {
      */
     WiredElement getElement();
 
-    /**
-     * The network this node is currently connected to. Note that this may change
-     * after any network operation, so it should not be cached.
-     * <p>
-     * This should only be used on the server thread.
-     *
-     * @return This node's network.
-     */
-    WiredNetwork getNetwork();
-
     /**
      * Create a connection from this node to another.
      * <p>
@@ -47,12 +39,9 @@ public interface WiredNode extends PacketNetwork {
      *
      * @param node The other node to connect to.
      * @return {@code true} if a connection was created or {@code false} if the connection already exists.
-     * @see WiredNetwork#connect(WiredNode, WiredNode)
      * @see WiredNode#disconnectFrom(WiredNode)
      */
-    default boolean connectTo(WiredNode node) {
-        return getNetwork().connect(this, node);
-    }
+    boolean connectTo(WiredNode node);
 
     /**
      * Destroy a connection between this node and another.
@@ -61,13 +50,9 @@ public interface WiredNode extends PacketNetwork {
      *
      * @param node The other node to disconnect from.
      * @return {@code true} if a connection was destroyed or {@code false} if no connection exists.
-     * @throws IllegalArgumentException If {@code node} is not on the same network.
-     * @see WiredNetwork#disconnect(WiredNode, WiredNode)
      * @see WiredNode#connectTo(WiredNode)
      */
-    default boolean disconnectFrom(WiredNode node) {
-        return getNetwork().disconnect(this, node);
-    }
+    boolean disconnectFrom(WiredNode node);
 
     /**
      * Sever all connections this node has, removing it from this network.
@@ -78,11 +63,8 @@ public interface WiredNode extends PacketNetwork {
      * @return Whether this node was removed from the network. One cannot remove a node from a network where it is the
      * only element.
      * @throws IllegalArgumentException If the node is not in the network.
-     * @see WiredNetwork#remove(WiredNode)
      */
-    default boolean remove() {
-        return getNetwork().remove(this);
-    }
+    boolean remove();
 
     /**
      * Mark this node's peripherals as having changed.
@@ -91,9 +73,6 @@ public interface WiredNode extends PacketNetwork {
      * that your network element owns.
      *
      * @param peripherals The new peripherals for this node.
-     * @see WiredNetwork#updatePeripherals(WiredNode, Map)
      */
-    default void updatePeripherals(Map<String, IPeripheral> peripherals) {
-        getNetwork().updatePeripherals(this, peripherals);
-    }
+    void updatePeripherals(Map<String, IPeripheral> peripherals);
 }

projects/common-api/src/main/java/dan200/computercraft/api/network/wired/WiredSender.java

@@ -8,10 +8,12 @@ import dan200.computercraft.api.network.PacketSender;
 
 
 /**
- * An object on a {@link WiredNetwork} capable of sending packets.
+ * An object on a wired network capable of sending packets.
  * <p>
  * Unlike a regular {@link PacketSender}, this must be associated with the node you are attempting to
  * to send the packet from.
+ *
+ * @see WiredElement
  */
 public interface WiredSender extends PacketSender {
     /**

projects/common-api/src/main/java/dan200/computercraft/api/pocket/AbstractPocketUpgrade.java

@@ -4,8 +4,7 @@
 
 package dan200.computercraft.api.pocket;
 
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
 
 
@@ -15,27 +14,20 @@ import net.minecraft.world.item.ItemStack;
  * One does not have to use this, but it does provide a convenient template.
  */
 public abstract class AbstractPocketUpgrade implements IPocketUpgrade {
-    private final ResourceLocation id;
-    private final String adjective;
+    private final Component adjective;
     private final ItemStack stack;
 
-    protected AbstractPocketUpgrade(ResourceLocation id, String adjective, ItemStack stack) {
-        this.id = id;
+    protected AbstractPocketUpgrade(Component adjective, ItemStack stack) {
         this.adjective = adjective;
         this.stack = stack;
     }
 
-    protected AbstractPocketUpgrade(ResourceLocation id, ItemStack stack) {
-        this(id, UpgradeBase.getDefaultAdjective(id), stack);
+    protected AbstractPocketUpgrade(String adjective, ItemStack stack) {
+        this(Component.translatable(adjective), stack);
     }
 
     @Override
-    public final ResourceLocation getUpgradeID() {
-        return id;
-    }
-
-    @Override
-    public final String getUnlocalisedAdjective() {
+    public final Component getAdjective() {
         return adjective;
     }
 

projects/common-api/src/main/java/dan200/computercraft/api/pocket/IPocketAccess.java

@@ -4,20 +4,36 @@
 
 package dan200.computercraft.api.pocket;
 
-import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.UpgradeBase;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceLocation;
+import dan200.computercraft.api.upgrades.UpgradeData;
+import net.minecraft.core.component.DataComponentPatch;
+import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.ApiStatus;
 
 import javax.annotation.Nullable;
-import java.util.Map;
 
 /**
  * Wrapper class for pocket computers.
  */
+@ApiStatus.NonExtendable
 public interface IPocketAccess {
+    /**
+     * Get the level in which the pocket computer exists.
+     *
+     * @return The pocket computer's level.
+     */
+    ServerLevel getLevel();
+
+    /**
+     * Get the position of the pocket computer.
+     *
+     * @return The pocket computer's position.
+     */
+    Vec3 getPosition();
+
     /**
      * Gets the entity holding this item.
      * <p>
@@ -64,24 +80,46 @@ public interface IPocketAccess {
      */
     void setLight(int colour);
 
+    /**
+     * Get the currently equipped upgrade.
+     *
+     * @return The currently equipped upgrade.
+     * @see #getUpgradeData()
+     * @see #setUpgrade(UpgradeData)
+     */
+    @Nullable
+    UpgradeData<IPocketUpgrade> getUpgrade();
+
+    /**
+     * Set the upgrade for this pocket computer, also updating the item stack.
+     * <p>
+     * Note this method is not thread safe - it must be called from the server thread.
+     *
+     * @param upgrade The new upgrade to set it to, may be {@code null}.
+     * @see #getUpgrade()
+     */
+    void setUpgrade(@Nullable UpgradeData<IPocketUpgrade> upgrade);
+
     /**
      * Get the upgrade-specific NBT.
      * <p>
      * This is persisted between computer reboots and chunk loads.
      *
      * @return The upgrade's NBT.
-     * @see #updateUpgradeNBTData()
-     * @see UpgradeBase#getUpgradeItem(CompoundTag)
+     * @see #setUpgradeData(DataComponentPatch)
+     * @see UpgradeBase#getUpgradeItem(DataComponentPatch)
      * @see UpgradeBase#getUpgradeData(ItemStack)
+     * @see #getUpgrade()
      */
-    CompoundTag getUpgradeNBTData();
+    DataComponentPatch getUpgradeData();
 
     /**
-     * Mark the upgrade-specific NBT as dirty.
+     * Update the upgrade-specific data.
      *
-     * @see #getUpgradeNBTData()
+     * @param data The new upgrade data.
+     * @see #getUpgradeData()
      */
-    void updateUpgradeNBTData();
+    void setUpgradeData(DataComponentPatch data);
 
     /**
      * Remove the current peripheral and create a new one.
@@ -90,13 +128,4 @@ public interface IPocketAccess {
      * entity} changes.
      */
     void invalidatePeripheral();
-
-    /**
-     * Get a list of all upgrades for the pocket computer.
-     *
-     * @return A collection of all upgrade names.
-     * @deprecated This is a relic of a previous API, which no longer makes sense with newer versions of ComputerCraft.
-     */
-    @Deprecated(forRemoval = true)
-    Map<ResourceLocation, IPeripheral> getUpgrades();
 }

projects/common-api/src/main/java/dan200/computercraft/api/pocket/IPocketUpgrade.java

@@ -4,8 +4,14 @@
 
 package dan200.computercraft.api.pocket;
 
+import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.api.upgrades.UpgradeType;
+import dan200.computercraft.impl.ComputerCraftAPIService;
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.Level;
 
 import javax.annotation.Nullable;
@@ -13,16 +19,32 @@ import javax.annotation.Nullable;
 /**
  * A peripheral which can be equipped to the back side of a pocket computer.
  * <p>
- * Pocket upgrades are defined in two stages. First, on creates a {@link IPocketUpgrade} subclass and corresponding
- * {@link PocketUpgradeSerialiser} instance, which are then registered in a Forge registry.
+ * Pocket upgrades are defined in two stages. First, one creates a {@link IPocketUpgrade} subclass and corresponding
+ * {@link UpgradeType} instance, which are then registered in a Minecraft registry.
  * <p>
  * You then write a JSON file in your mod's {@literal data/} folder. This is then parsed when the world is loaded, and
- * the upgrade registered internally. See the documentation in {@link PocketUpgradeSerialiser} for details on this process
- * and where files should be located.
- *
- * @see PocketUpgradeSerialiser For how to register a pocket computer upgrade.
+ * the upgrade registered internally.
  */
 public interface IPocketUpgrade extends UpgradeBase {
+    ResourceKey<Registry<IPocketUpgrade>> REGISTRY = ResourceKey.createRegistryKey(ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "pocket_upgrade"));
+
+    /**
+     * The registry key for pocket upgrade types.
+     *
+     * @return The registry key.
+     */
+    static ResourceKey<Registry<UpgradeType<? extends IPocketUpgrade>>> typeRegistry() {
+        return ComputerCraftAPIService.get().pocketUpgradeRegistryId();
+    }
+
+    /**
+     * Get the type of this upgrade.
+     *
+     * @return The type of this upgrade.
+     */
+    @Override
+    UpgradeType<? extends IPocketUpgrade> getType();
+
     /**
      * Creates a peripheral for the pocket computer.
      * <p>

projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketUpgradeDataProvider.java

@@ -1,26 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.pocket;
-
-import dan200.computercraft.api.upgrades.UpgradeDataProvider;
-import net.minecraft.data.DataGenerator;
-import net.minecraft.data.PackOutput;
-
-import java.util.function.Consumer;
-
-/**
- * A data provider to generate pocket computer upgrades.
- * <p>
- * This should be subclassed and registered to a {@link DataGenerator.PackGenerator}. Override the
- * {@link #addUpgrades(Consumer)} function, construct each upgrade, and pass them off to the provided consumer to
- * generate them.
- *
- * @see PocketUpgradeSerialiser
- */
-public abstract class PocketUpgradeDataProvider extends UpgradeDataProvider<IPocketUpgrade, PocketUpgradeSerialiser<?>> {
-    public PocketUpgradeDataProvider(PackOutput output) {
-        super(output, "Pocket Computer Upgrades", "computercraft/pocket_upgrades", PocketUpgradeSerialiser.registryId());
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/pocket/PocketUpgradeSerialiser.java

@@ -1,79 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.pocket;
-
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeSerialiser;
-import dan200.computercraft.impl.ComputerCraftAPIService;
-import dan200.computercraft.impl.upgrades.SerialiserWithCraftingItem;
-import dan200.computercraft.impl.upgrades.SimpleSerialiser;
-import net.minecraft.core.Registry;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.crafting.SimpleCraftingRecipeSerializer;
-
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-/**
- * Reads a {@link IPocketUpgrade} from disk and reads/writes it to a network packet.
- * <p>
- * This follows the same format as {@link dan200.computercraft.api.turtle.TurtleUpgradeSerialiser} - consult the
- * documentation there for more information.
- *
- * @param <T> The type of pocket computer upgrade this is responsible for serialising.
- * @see IPocketUpgrade
- * @see PocketUpgradeDataProvider
- */
-public interface PocketUpgradeSerialiser<T extends IPocketUpgrade> extends UpgradeSerialiser<T> {
-    /**
-     * The ID for the associated registry.
-     *
-     * @return The registry key.
-     */
-    static ResourceKey<Registry<PocketUpgradeSerialiser<?>>> registryId() {
-        return ComputerCraftAPIService.get().pocketUpgradeRegistryId();
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade. This is similar to a {@link SimpleCraftingRecipeSerializer},
-     * but for upgrades.
-     * <p>
-     * If you might want to vary the item, it's suggested you use {@link #simpleWithCustomItem(BiFunction)} instead.
-     *
-     * @param factory Generate a new upgrade with a specific ID.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade
-     */
-    static <T extends IPocketUpgrade> PocketUpgradeSerialiser<T> simple(Function<ResourceLocation, T> factory) {
-        final class Impl extends SimpleSerialiser<T> implements PocketUpgradeSerialiser<T> {
-            private Impl(Function<ResourceLocation, T> constructor) {
-                super(constructor);
-            }
-        }
-
-        return new Impl(factory);
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade whose crafting item can be specified.
-     *
-     * @param factory Generate a new upgrade with a specific ID and crafting item. The returned upgrade's
-     *                {@link UpgradeBase#getCraftingItem()} <strong>MUST</strong> equal the provided item.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade.
-     * @see #simple(Function)  For upgrades whose crafting stack should not vary.
-     */
-    static <T extends IPocketUpgrade> PocketUpgradeSerialiser<T> simpleWithCustomItem(BiFunction<ResourceLocation, ItemStack, T> factory) {
-        final class Impl extends SerialiserWithCraftingItem<T> implements PocketUpgradeSerialiser<T> {
-            private Impl(BiFunction<ResourceLocation, ItemStack, T> factory) {
-                super(factory);
-            }
-        }
-
-        return new Impl(factory);
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/turtle/AbstractTurtleUpgrade.java

@@ -4,8 +4,7 @@
 
 package dan200.computercraft.api.turtle;
 
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.ItemStack;
 
 
@@ -15,34 +14,27 @@ import net.minecraft.world.item.ItemStack;
  * One does not have to use this, but it does provide a convenient template.
  */
 public abstract class AbstractTurtleUpgrade implements ITurtleUpgrade {
-    private final ResourceLocation id;
     private final TurtleUpgradeType type;
-    private final String adjective;
+    private final Component adjective;
     private final ItemStack stack;
 
-    protected AbstractTurtleUpgrade(ResourceLocation id, TurtleUpgradeType type, String adjective, ItemStack stack) {
-        this.id = id;
+    protected AbstractTurtleUpgrade(TurtleUpgradeType type, Component adjective, ItemStack stack) {
         this.type = type;
         this.adjective = adjective;
         this.stack = stack;
     }
 
-    protected AbstractTurtleUpgrade(ResourceLocation id, TurtleUpgradeType type, ItemStack stack) {
-        this(id, type, UpgradeBase.getDefaultAdjective(id), stack);
+    protected AbstractTurtleUpgrade(TurtleUpgradeType type, String adjective, ItemStack stack) {
+        this(type, Component.translatable(adjective), stack);
     }
 
     @Override
-    public final ResourceLocation getUpgradeID() {
-        return id;
-    }
-
-    @Override
-    public final String getUnlocalisedAdjective() {
+    public final Component getAdjective() {
         return adjective;
     }
 
     @Override
-    public final TurtleUpgradeType getType() {
+    public final TurtleUpgradeType getUpgradeType() {
         return type;
     }
 

projects/common-api/src/main/java/dan200/computercraft/api/turtle/ITurtleAccess.java

@@ -12,7 +12,7 @@ import dan200.computercraft.api.upgrades.UpgradeBase;
 import dan200.computercraft.api.upgrades.UpgradeData;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.world.Container;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
@@ -229,37 +229,22 @@ public interface ITurtleAccess {
      * @param side The side to get the upgrade from.
      * @return The upgrade on the specified side of the turtle, if there is one.
      * @see #getUpgradeWithData(TurtleSide)
-     * @see #setUpgradeWithData(TurtleSide, UpgradeData)
+     * @see #setUpgrade(TurtleSide, UpgradeData)
      */
     @Nullable
     ITurtleUpgrade getUpgrade(TurtleSide side);
 
     /**
-     * Returns the upgrade on the specified side of the turtle, along with its {@linkplain #getUpgradeNBTData(TurtleSide)
+     * Returns the upgrade on the specified side of the turtle, along with its {@linkplain #getUpgradeData(TurtleSide)
      * update data}.
      *
      * @param side The side to get the upgrade from.
      * @return The upgrade on the specified side of the turtle, along with its upgrade data, if there is one.
      * @see #getUpgradeWithData(TurtleSide)
-     * @see #setUpgradeWithData(TurtleSide, UpgradeData)
+     * @see #setUpgrade(TurtleSide, UpgradeData)
      */
-    default @Nullable UpgradeData<ITurtleUpgrade> getUpgradeWithData(TurtleSide side) {
-        var upgrade = getUpgrade(side);
-        return upgrade == null ? null : UpgradeData.of(upgrade, getUpgradeNBTData(side));
-    }
-
-    /**
-     * Set the upgrade for a given side, resetting peripherals and clearing upgrade specific data.
-     *
-     * @param side    The side to set the upgrade on.
-     * @param upgrade The upgrade to set, may be {@code null} to clear.
-     * @see #getUpgrade(TurtleSide)
-     * @deprecated Use {@link #setUpgradeWithData(TurtleSide, UpgradeData)}
-     */
-    @Deprecated
-    default void setUpgrade(TurtleSide side, @Nullable ITurtleUpgrade upgrade) {
-        setUpgradeWithData(side, upgrade == null ? null : UpgradeData.ofDefault(upgrade));
-    }
+    @Nullable
+    UpgradeData<ITurtleUpgrade> getUpgradeWithData(TurtleSide side);
 
     /**
      * Set the upgrade for a given side and its upgrade data.
@@ -268,7 +253,7 @@ public interface ITurtleAccess {
      * @param upgrade The upgrade to set, may be {@code null} to clear.
      * @see #getUpgradeWithData(TurtleSide)
      */
-    void setUpgradeWithData(TurtleSide side, @Nullable UpgradeData<ITurtleUpgrade> upgrade);
+    void setUpgrade(TurtleSide side, @Nullable UpgradeData<ITurtleUpgrade> upgrade);
 
     /**
      * Returns the peripheral created by the upgrade on the specified side of the turtle, if there is one.
@@ -282,23 +267,23 @@ public interface ITurtleAccess {
     /**
      * Get an upgrade-specific NBT compound, which can be used to store arbitrary data.
      * <p>
-     * This will be persisted across turtle restarts and chunk loads, as well as being synced to the client. You must
-     * call {@link #updateUpgradeNBTData(TurtleSide)} after modifying it.
+     * This will be persisted across turtle restarts and chunk loads, as well as being synced to the client. You can
+     * call {@link #setUpgrade(TurtleSide, UpgradeData)} to modify it.
      *
      * @param side The side to get the upgrade data for.
      * @return The upgrade-specific data.
-     * @see #updateUpgradeNBTData(TurtleSide)
-     * @see UpgradeBase#getUpgradeItem(CompoundTag)
+     * @see #setUpgradeData(TurtleSide, DataComponentPatch)
+     * @see UpgradeBase#getUpgradeItem(DataComponentPatch)
      * @see UpgradeBase#getUpgradeData(ItemStack)
      */
-    CompoundTag getUpgradeNBTData(TurtleSide side);
+    DataComponentPatch getUpgradeData(TurtleSide side);
 
     /**
-     * Mark the upgrade-specific data as dirty on a specific side. This is required for the data to be synced to the
-     * client and persisted.
+     * Update the upgrade-specific data.
      *
-     * @param side The side to mark dirty.
-     * @see #updateUpgradeNBTData(TurtleSide)
+     * @param side The side to set the upgrade data for.
+     * @param data The new upgrade data.
+     * @see #getUpgradeData(TurtleSide)
      */
-    void updateUpgradeNBTData(TurtleSide side);
+    void setUpgradeData(TurtleSide side, DataComponentPatch data);
 }

projects/common-api/src/main/java/dan200/computercraft/api/turtle/ITurtleUpgrade.java

@@ -4,34 +4,129 @@
 
 package dan200.computercraft.api.turtle;
 
+import dan200.computercraft.api.ComputerCraftAPI;
 import dan200.computercraft.api.peripheral.IPeripheral;
 import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.api.upgrades.UpgradeType;
+import dan200.computercraft.impl.ComputerCraftAPIService;
 import net.minecraft.core.Direction;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.Registry;
+import net.minecraft.core.RegistrySetBuilder.PatchedRegistries;
+import net.minecraft.core.component.DataComponentPatch;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.Items;
 
 import javax.annotation.Nullable;
+import java.util.function.Function;
 
 /**
  * The primary interface for defining an update for Turtles. A turtle update can either be a new tool, or a new
  * peripheral.
  * <p>
  * Turtle upgrades are defined in two stages. First, one creates a {@link ITurtleUpgrade} subclass and corresponding
- * {@link TurtleUpgradeSerialiser} instance, which are then registered in a Forge registry.
+ * {@link UpgradeType} instance, which are then registered in a Minecraft registry.
  * <p>
  * You then write a JSON file in your mod's {@literal data/} folder. This is then parsed when the world is loaded, and
- * the upgrade registered internally. See the documentation in {@link TurtleUpgradeSerialiser} for details on this process
- * and where files should be located.
+ * the upgrade automatically registered.
  *
- * @see TurtleUpgradeSerialiser For how to register a turtle upgrade.
+ * <h2>Example</h2>
+ * <h3>Registering the upgrade type</h3>
+ * First, let's create a new class that implements {@link ITurtleUpgrade}. It is recommended to subclass
+ * {@link AbstractTurtleUpgrade}, as that provides a default implementation of most methods.
+ *
+ * {@snippet class=com.example.examplemod.ExampleTurtleUpgrade region=body}
+ *
+ * Now we must construct a new upgrade type. In most cases, you can use one of the helper methods (e.g.
+ * {@link UpgradeType#simpleWithCustomItem(Function)}), rather than defining your own implementation.
+ *
+ * {@snippet class=com.example.examplemod.ExampleMod region=turtle_upgrades}
+ *
+ * We now must register this upgrade type. This is done the same way as you'd register blocks, items, or other
+ * Minecraft objects. The approach to do this will depend on mod-loader.
+ *
+ * <h4>Fabric</h4>
+ * {@snippet class=com.example.examplemod.FabricExampleMod region=turtle_upgrades}
+ *
+ * <h4>Forge</h4>
+ * {@snippet class=com.example.examplemod.ForgeExampleMod region=turtle_upgrades}
+ *
+ * <h3>Rendering the upgrade</h3>
+ * Next, we need to register a model for our upgrade. This is done by registering a
+ * {@link dan200.computercraft.api.client.turtle.TurtleUpgradeModeller} for your upgrade type.
+ *
+ * <h4>Fabric</h4>
+ * {@snippet class=com.example.examplemod.FabricExampleModClient region=turtle_modellers}
+ *
+ * <h4>Forge</h4>
+ * {@snippet class=com.example.examplemod.FabricExampleModClient region=turtle_modellers}
+ *
+ * <h3 id="datagen">Registering the upgrade itself</h3>
+ * Upgrades themselves are loaded from datapacks when a level is loaded. In order to register our new upgrade, we must
+ * create a new JSON file at {@code data/<my_mod>/computercraft/turtle_upgrade/<my_upgrade_id>.json}.
+ *
+ * {@snippet file=data/examplemod/computercraft/turtle_upgrade/example_turtle_upgrade.json}
+ *
+ * The {@code "type"} field points to the ID of the upgrade type we've just registered, while the other fields are read
+ * by the type itself. As our upgrade was defined with {@link UpgradeType#simpleWithCustomItem(Function)}, the
+ * {@code "item"} field will construct our upgrade with {@link Items#COMPASS}.
+ * <p>
+ * Rather than manually creating the file, it is recommended to use data-generators to generate this file. First, we
+ * register our new upgrades into a {@linkplain PatchedRegistries patched registry}.
+ *
+ * {@snippet class=com.example.examplemod.data.TurtleUpgradeProvider region=body}
+ *
+ * Next, we must write these upgrades to disk. Vanilla does not have complete support for this yet, so this must be done
+ * with mod-loader-specific APIs.
+ *
+ * <h4>Fabric</h4>
+ * {@snippet class=com.example.examplemod.FabricExampleModDataGenerator region=turtle_upgrades}
+ *
+ * <h4>Forge</h4>
+ * {@snippet class=com.example.examplemod.ForgeExampleModDataGenerator region=turtle_upgrades}
  */
 public interface ITurtleUpgrade extends UpgradeBase {
+    /**
+     * The registry in which turtle upgrades are stored.
+     */
+    ResourceKey<Registry<ITurtleUpgrade>> REGISTRY = ResourceKey.createRegistryKey(ResourceLocation.fromNamespaceAndPath(ComputerCraftAPI.MOD_ID, "turtle_upgrade"));
+
+    /**
+     * Create a {@link ResourceKey} for a turtle upgrade given a {@link ResourceLocation}.
+     * <p>
+     * This should only be called from within data generation code. Do not hard code references to your upgrades!
+     *
+     * @param id The id of the turtle upgrade.
+     * @return The upgrade registry key.
+     */
+    static ResourceKey<ITurtleUpgrade> createKey(ResourceLocation id) {
+        return ResourceKey.create(REGISTRY, id);
+    }
+
+    /**
+     * The registry key for turtle upgrade types.
+     *
+     * @return The registry key.
+     */
+    static ResourceKey<Registry<UpgradeType<? extends ITurtleUpgrade>>> typeRegistry() {
+        return ComputerCraftAPIService.get().turtleUpgradeRegistryId();
+    }
+
+    /**
+     * Get the type of this upgrade.
+     *
+     * @return The type of this upgrade.
+     */
+    @Override
+    UpgradeType<? extends ITurtleUpgrade> getType();
+
     /**
      * Return whether this turtle adds a tool or a peripheral to the turtle.
      *
      * @return The type of upgrade this is.
      * @see TurtleUpgradeType for the differences between them.
      */
-    TurtleUpgradeType getType();
+    TurtleUpgradeType getUpgradeType();
 
     /**
      * Will only be called for peripheral upgrades. Creates a peripheral for a turtle being placed using this upgrade.
@@ -90,7 +185,7 @@ public interface ITurtleUpgrade extends UpgradeBase {
      * @param upgradeData Data that currently stored for this upgrade
      * @return Filtered version of this data.
      */
-    default CompoundTag getPersistedData(CompoundTag upgradeData) {
+    default DataComponentPatch getPersistedData(DataComponentPatch upgradeData) {
         return upgradeData;
     }
 }

projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleSide.java

@@ -5,7 +5,7 @@
 package dan200.computercraft.api.turtle;
 
 /**
- * An enum representing the two sides of the turtle that a turtle turtle might reside.
+ * An enum representing the two sides of the turtle that a turtle upgrade might reside.
  */
 public enum TurtleSide {
     /**

projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleToolBuilder.java

@@ -0,0 +1,149 @@
+// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.turtle;
+
+import dan200.computercraft.api.ComputerCraftTags;
+import dan200.computercraft.api.upgrades.UpgradeBase;
+import dan200.computercraft.impl.ComputerCraftAPIService;
+import dan200.computercraft.impl.upgrades.TurtleToolSpec;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.data.worldgen.BootstrapContext;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Block;
+
+import javax.annotation.Nullable;
+import java.util.Optional;
+
+/**
+ * A builder for custom turtle tool upgrades.
+ * <p>
+ * This can be used from your <a href="./ITurtleUpgrade.html#datagen">data generator</a> code in order to
+ * register turtle tools for your mod's tools.
+ *
+ * <h2>Example</h2>
+ * {@snippet class=com.example.examplemod.data.TurtleToolProvider region=body}
+ */
+public final class TurtleToolBuilder {
+    private final ResourceKey<ITurtleUpgrade> id;
+    private final Item item;
+    private Component adjective;
+    private float damageMultiplier = TurtleToolSpec.DEFAULT_DAMAGE_MULTIPLIER;
+    private @Nullable TagKey<Block> breakable;
+    private boolean allowEnchantments = false;
+    private TurtleToolDurability consumeDurability = TurtleToolDurability.NEVER;
+
+    private TurtleToolBuilder(ResourceKey<ITurtleUpgrade> id, Item item) {
+        this.id = id;
+        adjective = Component.translatable(UpgradeBase.getDefaultAdjective(id.location()));
+        this.item = item;
+    }
+
+    public static TurtleToolBuilder tool(ResourceLocation id, Item item) {
+        return new TurtleToolBuilder(ITurtleUpgrade.createKey(id), item);
+    }
+
+    public static TurtleToolBuilder tool(ResourceKey<ITurtleUpgrade> id, Item item) {
+        return new TurtleToolBuilder(id, item);
+    }
+
+    /**
+     * Get the id for this turtle tool.
+     *
+     * @return The upgrade id.
+     */
+    public ResourceKey<ITurtleUpgrade> id() {
+        return id;
+    }
+
+    /**
+     * Specify a custom adjective for this tool. By default this takes its adjective from the upgrade id.
+     *
+     * @param adjective The new adjective to use.
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder adjective(Component adjective) {
+        this.adjective = adjective;
+        return this;
+    }
+
+    /**
+     * The amount of damage a swing of this tool will do. This is multiplied by {@link Attributes#ATTACK_DAMAGE} to
+     * get the final damage.
+     *
+     * @param damageMultiplier The damage multiplier.
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder damageMultiplier(float damageMultiplier) {
+        this.damageMultiplier = damageMultiplier;
+        return this;
+    }
+
+    /**
+     * Indicate that this upgrade allows items which have been {@linkplain ItemStack#isEnchanted() enchanted} or have
+     * {@linkplain DataComponents#ATTRIBUTE_MODIFIERS custom attribute modifiers}.
+     *
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder allowEnchantments() {
+        allowEnchantments = true;
+        return this;
+    }
+
+    /**
+     * Set when the tool will consume durability.
+     *
+     * @param durability The durability predicate.
+     * @return The tool builder, for further use.
+     */
+    public TurtleToolBuilder consumeDurability(TurtleToolDurability durability) {
+        consumeDurability = durability;
+        return this;
+    }
+
+    /**
+     * Provide a list of breakable blocks. If not given, the tool can break all blocks. If given, only blocks
+     * in this tag, those in {@link ComputerCraftTags.Blocks#TURTLE_ALWAYS_BREAKABLE} and "insta-mine" ones can
+     * be broken.
+     *
+     * @param breakable The tag containing all blocks breakable by this item.
+     * @return The tool builder, for further use.
+     * @see ComputerCraftTags.Blocks
+     */
+    public TurtleToolBuilder breakable(TagKey<Block> breakable) {
+        this.breakable = breakable;
+        return this;
+    }
+
+    /**
+     * Build the turtle tool upgrade.
+     *
+     * @return The constructed upgrade.
+     */
+    public ITurtleUpgrade build() {
+        return ComputerCraftAPIService.get().createTurtleTool(new TurtleToolSpec(
+            adjective,
+            item,
+            damageMultiplier,
+            allowEnchantments,
+            consumeDurability,
+            Optional.ofNullable(breakable)
+        ));
+    }
+
+    /**
+     * Build this upgrade and register it for datagen.
+     *
+     * @param upgrades The registry this upgrade should be added to.
+     */
+    public void register(BootstrapContext<ITurtleUpgrade> upgrades) {
+        upgrades.register(id(), build());
+    }
+}

projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleToolDurability.java

@@ -4,14 +4,14 @@
 
 package dan200.computercraft.api.turtle;
 
+import net.minecraft.core.component.DataComponents;
 import net.minecraft.util.StringRepresentable;
-import net.minecraft.world.entity.EquipmentSlot;
 import net.minecraft.world.item.ItemStack;
 
 /**
  * Indicates if an equipped turtle item will consume durability.
  *
- * @see TurtleUpgradeDataProvider.ToolBuilder#consumeDurability(TurtleToolDurability)
+ * @see TurtleToolBuilder#consumeDurability(TurtleToolDurability)
  */
 public enum TurtleToolDurability implements StringRepresentable {
     /**
@@ -21,7 +21,7 @@ public enum TurtleToolDurability implements StringRepresentable {
 
     /**
      * The equipped tool consumes durability if it is {@linkplain ItemStack#isEnchanted() enchanted} or has
-     * {@linkplain ItemStack#getAttributeModifiers(EquipmentSlot) custom attribute modifiers}.
+     * {@linkplain DataComponents#ATTRIBUTE_MODIFIERS custom attribute modifiers}.
      */
     WHEN_ENCHANTED("when_enchanted"),
 

projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeDataProvider.java

@@ -1,168 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.turtle;
-
-import dan200.computercraft.api.ComputerCraftAPI;
-import dan200.computercraft.api.ComputerCraftTags;
-import dan200.computercraft.api.upgrades.UpgradeDataProvider;
-import dan200.computercraft.impl.PlatformHelper;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.data.DataGenerator;
-import net.minecraft.data.PackOutput;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.tags.TagKey;
-import net.minecraft.world.entity.EquipmentSlot;
-import net.minecraft.world.entity.ai.attributes.Attributes;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.block.Block;
-
-import javax.annotation.Nullable;
-import java.util.function.Consumer;
-
-/**
- * A data provider to generate turtle upgrades.
- * <p>
- * This should be subclassed and registered to a {@link DataGenerator.PackGenerator}. Override the
- * {@link #addUpgrades(Consumer)} function, construct each upgrade, and pass them off to the provided consumer to
- * generate them.
- *
- * @see TurtleUpgradeSerialiser
- */
-public abstract class TurtleUpgradeDataProvider extends UpgradeDataProvider<ITurtleUpgrade, TurtleUpgradeSerialiser<?>> {
-    private static final ResourceLocation TOOL_ID = new ResourceLocation(ComputerCraftAPI.MOD_ID, "tool");
-
-    public TurtleUpgradeDataProvider(PackOutput output) {
-        super(output, "Turtle Upgrades", "computercraft/turtle_upgrades", TurtleUpgradeSerialiser.registryId());
-    }
-
-    /**
-     * Create a new turtle tool upgrade, such as a pickaxe or shovel.
-     *
-     * @param id   The ID of this tool.
-     * @param item The item used for tool actions. Note, this doesn't inherit all properties of the tool, you may need
-     *             to specify {@link ToolBuilder#damageMultiplier(float)} and {@link ToolBuilder#breakable(TagKey)}.
-     * @return A tool builder,
-     */
-    public final ToolBuilder tool(ResourceLocation id, Item item) {
-        return new ToolBuilder(id, existingSerialiser(TOOL_ID), item);
-    }
-
-    /**
-     * A builder for custom turtle tool upgrades.
-     *
-     * @see #tool(ResourceLocation, Item)
-     */
-    public static class ToolBuilder {
-        private final ResourceLocation id;
-        private final TurtleUpgradeSerialiser<?> serialiser;
-        private final Item toolItem;
-        private @Nullable String adjective;
-        private @Nullable Item craftingItem;
-        private @Nullable Float damageMultiplier = null;
-        private @Nullable TagKey<Block> breakable;
-        private boolean allowEnchantments = false;
-        private TurtleToolDurability consumeDurability = TurtleToolDurability.NEVER;
-
-        ToolBuilder(ResourceLocation id, TurtleUpgradeSerialiser<?> serialiser, Item toolItem) {
-            this.id = id;
-            this.serialiser = serialiser;
-            this.toolItem = toolItem;
-            craftingItem = null;
-        }
-
-        /**
-         * Specify a custom adjective for this tool. By default this takes its adjective from the tool item.
-         *
-         * @param adjective The new adjective to use.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder adjective(String adjective) {
-            this.adjective = adjective;
-            return this;
-        }
-
-        /**
-         * Specify a custom item which is used to craft this upgrade. By default this is the same as the provided tool
-         * item, but you may wish to override it.
-         *
-         * @param craftingItem The item used to craft this upgrade.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder craftingItem(Item craftingItem) {
-            this.craftingItem = craftingItem;
-            return this;
-        }
-
-        /**
-         * The amount of damage a swing of this tool will do. This is multiplied by {@link Attributes#ATTACK_DAMAGE} to
-         * get the final damage.
-         *
-         * @param damageMultiplier The damage multiplier.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder damageMultiplier(float damageMultiplier) {
-            this.damageMultiplier = damageMultiplier;
-            return this;
-        }
-
-        /**
-         * Indicate that this upgrade allows items which have been {@linkplain ItemStack#isEnchanted() enchanted} or have
-         * {@linkplain ItemStack#getAttributeModifiers(EquipmentSlot) custom attribute modifiers}.
-         *
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder allowEnchantments() {
-            allowEnchantments = true;
-            return this;
-        }
-
-        /**
-         * Set when the tool will consume durability.
-         *
-         * @param durability The durability predicate.
-         * @return The tool builder, for further use.
-         */
-        public ToolBuilder consumeDurability(TurtleToolDurability durability) {
-            consumeDurability = durability;
-            return this;
-        }
-
-        /**
-         * Provide a list of breakable blocks. If not given, the tool can break all blocks. If given, only blocks
-         * in this tag, those in {@link ComputerCraftTags.Blocks#TURTLE_ALWAYS_BREAKABLE} and "insta-mine" ones can
-         * be broken.
-         *
-         * @param breakable The tag containing all blocks breakable by this item.
-         * @return The tool builder, for further use.
-         * @see ComputerCraftTags.Blocks
-         */
-        public ToolBuilder breakable(TagKey<Block> breakable) {
-            this.breakable = breakable;
-            return this;
-        }
-
-        /**
-         * Register this as an upgrade.
-         *
-         * @param add The callback given to {@link #addUpgrades(Consumer)}.
-         */
-        public void add(Consumer<Upgrade<TurtleUpgradeSerialiser<?>>> add) {
-            add.accept(new Upgrade<>(id, serialiser, s -> {
-                s.addProperty("item", PlatformHelper.get().getRegistryKey(Registries.ITEM, toolItem).toString());
-                if (adjective != null) s.addProperty("adjective", adjective);
-                if (craftingItem != null) {
-                    s.addProperty("craftItem", PlatformHelper.get().getRegistryKey(Registries.ITEM, craftingItem).toString());
-                }
-                if (damageMultiplier != null) s.addProperty("damageMultiplier", damageMultiplier);
-                if (breakable != null) s.addProperty("breakable", breakable.location().toString());
-                if (allowEnchantments) s.addProperty("allowEnchantments", true);
-                if (consumeDurability != TurtleToolDurability.NEVER) {
-                    s.addProperty("consumeDurability", consumeDurability.getSerializedName());
-                }
-            }));
-        }
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/turtle/TurtleUpgradeSerialiser.java

@@ -1,109 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.turtle;
-
-import dan200.computercraft.api.upgrades.UpgradeBase;
-import dan200.computercraft.api.upgrades.UpgradeSerialiser;
-import dan200.computercraft.impl.ComputerCraftAPIService;
-import dan200.computercraft.impl.upgrades.SerialiserWithCraftingItem;
-import dan200.computercraft.impl.upgrades.SimpleSerialiser;
-import net.minecraft.core.Registry;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.crafting.RecipeSerializer;
-import net.minecraft.world.item.crafting.SimpleCraftingRecipeSerializer;
-
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-/**
- * Reads a {@link ITurtleUpgrade} from disk and reads/writes it to a network packet.
- * <p>
- * These should be registered in a {@link Registry} while the game is loading, much like {@link RecipeSerializer}s.
- * <p>
- * If your turtle upgrade doesn't have any associated configurable parameters (like most upgrades), you can use
- * {@link #simple(Function)} or {@link #simpleWithCustomItem(BiFunction)} to create a basic upgrade serialiser.
- *
- * <h2>Example (Forge)</h2>
- * <pre>{@code
- * static final DeferredRegister<TurtleUpgradeSerialiser<?>> SERIALISERS = DeferredRegister.create( TurtleUpgradeSerialiser.TYPE, "my_mod" );
- *
- * // Register a new upgrade serialiser called "my_upgrade".
- * public static final RegistryObject<TurtleUpgradeSerialiser<MyUpgrade>> MY_UPGRADE =
- *     SERIALISERS.register( "my_upgrade", () -> TurtleUpgradeSerialiser.simple( MyUpgrade::new ) );
- *
- * // Then in your constructor
- * SERIALISERS.register( bus );
- * }</pre>
- * <p>
- * We can then define a new upgrade using JSON by placing the following in
- * {@literal data/<my_mod>/computercraft/turtle_upgrades/<my_upgrade_id>.json}}.
- *
- * <pre>{@code
- * {
- *     "type": my_mod:my_upgrade",
- * }
- * }</pre>
- * <p>
- * Finally, we need to register a model for our upgrade. The way to do this varies on mod loader, see
- * {@link dan200.computercraft.api.client.turtle.TurtleUpgradeModeller} for more information.
- * <p>
- * {@link TurtleUpgradeDataProvider} provides a data provider to aid with generating these JSON files.
- *
- * @param <T> The type of turtle upgrade this is responsible for serialising.
- * @see ITurtleUpgrade
- * @see TurtleUpgradeDataProvider
- * @see dan200.computercraft.api.client.turtle.TurtleUpgradeModeller
- */
-public interface TurtleUpgradeSerialiser<T extends ITurtleUpgrade> extends UpgradeSerialiser<T> {
-    /**
-     * The ID for the associated registry.
-     *
-     * @return The registry key.
-     */
-    static ResourceKey<Registry<TurtleUpgradeSerialiser<?>>> registryId() {
-        return ComputerCraftAPIService.get().turtleUpgradeRegistryId();
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade. This is similar to a {@link SimpleCraftingRecipeSerializer},
-     * but for upgrades.
-     * <p>
-     * If you might want to vary the item, it's suggested you use {@link #simpleWithCustomItem(BiFunction)} instead.
-     *
-     * @param factory Generate a new upgrade with a specific ID.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade
-     */
-    static <T extends ITurtleUpgrade> TurtleUpgradeSerialiser<T> simple(Function<ResourceLocation, T> factory) {
-        final class Impl extends SimpleSerialiser<T> implements TurtleUpgradeSerialiser<T> {
-            private Impl(Function<ResourceLocation, T> constructor) {
-                super(constructor);
-            }
-        }
-
-        return new Impl(factory);
-    }
-
-    /**
-     * Create an upgrade serialiser for a simple upgrade whose crafting item can be specified.
-     *
-     * @param factory Generate a new upgrade with a specific ID and crafting item. The returned upgrade's
-     *                {@link UpgradeBase#getCraftingItem()} <strong>MUST</strong> equal the provided item.
-     * @param <T>     The type of the generated upgrade.
-     * @return The serialiser for this upgrade.
-     * @see #simple(Function)  For upgrades whose crafting stack should not vary.
-     */
-    static <T extends ITurtleUpgrade> TurtleUpgradeSerialiser<T> simpleWithCustomItem(BiFunction<ResourceLocation, ItemStack, T> factory) {
-        final class Impl extends SerialiserWithCraftingItem<T> implements TurtleUpgradeSerialiser<T> {
-            private Impl(BiFunction<ResourceLocation, ItemStack, T> factory) {
-                super(factory);
-            }
-        }
-
-        return new Impl(factory);
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeBase.java

@@ -9,37 +9,34 @@ import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.turtle.ITurtleAccess;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
 import dan200.computercraft.api.turtle.TurtleSide;
-import dan200.computercraft.impl.PlatformHelper;
 import net.minecraft.Util;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.component.DataComponentPatch;
+import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.ItemStack;
 
-import java.util.Objects;
-
 /**
  * Common functionality between {@link ITurtleUpgrade} and {@link IPocketUpgrade}.
  */
 public interface UpgradeBase {
     /**
-     * Gets a unique identifier representing this type of turtle upgrade. eg: "computercraft:wireless_modem"
-     * or "my_mod:my_upgrade".
-     * <p>
-     * You should use a unique resource domain to ensure this upgrade is uniquely identified.
-     * The upgrade will fail registration if an already used ID is specified.
+     * Get the type of this upgrade.
      *
-     * @return The unique ID for this upgrade.
+     * @return The type of this upgrade.
      */
-    ResourceLocation getUpgradeID();
+    UpgradeType<?> getType();
 
     /**
-     * Return an unlocalised string to describe this type of computer in item names.
+     * A description of this upgrade for use in item names.
+     * <p>
+     * This should typically be a {@linkplain Component#translatable(String) translation key}, rather than a hard coded
+     * string.
      * <p>
      * Examples of built-in adjectives are "Wireless", "Mining" and "Crafty".
      *
-     * @return The localisation key for this upgrade's adjective.
+     * @return The text component for this upgrade's adjective.
      */
-    String getUnlocalisedAdjective();
+    Component getAdjective();
 
     /**
      * Return an item stack representing the type of item that a computer must be crafted
@@ -57,8 +54,8 @@ public interface UpgradeBase {
     /**
      * Returns the item stack representing a currently equipped turtle upgrade.
      * <p>
-     * While upgrades can store upgrade data ({@link ITurtleAccess#getUpgradeNBTData(TurtleSide)} and
-     * {@link IPocketAccess#getUpgradeNBTData()}}, by default this data is discarded when an upgrade is unequipped,
+     * While upgrades can store upgrade data ({@link ITurtleAccess#getUpgradeData(TurtleSide)} and
+     * {@link IPocketAccess#getUpgradeData()}}, by default this data is discarded when an upgrade is unequipped,
      * and the original item stack is returned.
      * <p>
      * By overriding this method, you can create a new {@link ItemStack} which contains enough data to
@@ -70,24 +67,24 @@ public interface UpgradeBase {
      * @param upgradeData The current upgrade data. This should <strong>NOT</strong> be mutated.
      * @return The item stack returned when unequipping.
      */
-    default ItemStack getUpgradeItem(CompoundTag upgradeData) {
+    default ItemStack getUpgradeItem(DataComponentPatch upgradeData) {
         return getCraftingItem();
     }
 
     /**
      * Extract upgrade data from an {@link ItemStack}.
      * <p>
-     * This upgrade data will be available with {@link ITurtleAccess#getUpgradeNBTData(TurtleSide)} or
-     * {@link IPocketAccess#getUpgradeNBTData()}.
+     * This upgrade data will be available with {@link ITurtleAccess#getUpgradeData(TurtleSide)} or
+     * {@link IPocketAccess#getUpgradeData()}.
      * <p>
-     * This should be an inverse to {@link #getUpgradeItem(CompoundTag)}.
+     * This should be an inverse to {@link #getUpgradeItem(DataComponentPatch)}.
      *
      * @param stack The stack that was equipped by the turtle or pocket computer. This will have the same item as
      *              {@link #getCraftingItem()}.
      * @return The upgrade data that should be set on the turtle or pocket computer.
      */
-    default CompoundTag getUpgradeData(ItemStack stack) {
-        return new CompoundTag();
+    default DataComponentPatch getUpgradeData(ItemStack stack) {
+        return DataComponentPatch.EMPTY;
     }
 
     /**
@@ -97,26 +94,15 @@ public interface UpgradeBase {
      * the original stack. In order to prevent people losing items with enchantments (or
      * repairing items with non-0 damage), we impose additional checks on the item.
      * <p>
-     * The default check requires that any non-capability NBT is exactly the same as the
-     * crafting item, but this may be relaxed for your upgrade.
-     * <p>
-     * This is based on {@code net.minecraftforge.common.crafting.StrictNBTIngredient}'s check.
+     * The default check requires that any NBT is exactly the same as the crafting item,
+     * but this may be relaxed for your upgrade.
      *
      * @param stack The stack to check. This is guaranteed to be non-empty and have the same item as
      *              {@link #getCraftingItem()}.
      * @return If this stack may be used to equip this upgrade.
      */
     default boolean isItemSuitable(ItemStack stack) {
-        var crafting = getCraftingItem();
-
-        // A more expanded form of ItemStack.areShareTagsEqual, but allowing an empty tag to be equal to a
-        // null one.
-        var shareTag = PlatformHelper.get().getShareTag(stack);
-        var craftingShareTag = PlatformHelper.get().getShareTag(crafting);
-        if (shareTag == craftingShareTag) return true;
-        if (shareTag == null) return Objects.requireNonNull(craftingShareTag).isEmpty();
-        if (craftingShareTag == null) return shareTag.isEmpty();
-        return shareTag.equals(craftingShareTag);
+        return ItemStack.isSameItemSameComponents(getCraftingItem(), stack);
     }
 
     /**
@@ -125,7 +111,7 @@ public interface UpgradeBase {
      *
      * @param id The upgrade ID.
      * @return The  generated adjective.
-     * @see #getUnlocalisedAdjective()
+     * @see #getAdjective()
      */
     static String getDefaultAdjective(ResourceLocation id) {
         return Util.makeDescriptionId("upgrade", id) + ".adjective";

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeData.java

@@ -6,60 +6,57 @@ package dan200.computercraft.api.upgrades;
 
 import dan200.computercraft.api.pocket.IPocketUpgrade;
 import dan200.computercraft.api.turtle.ITurtleUpgrade;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.core.Holder;
+import net.minecraft.core.component.DataComponentPatch;
 import net.minecraft.world.item.ItemStack;
-import org.jetbrains.annotations.Contract;
-
-import javax.annotation.Nullable;
 
 /**
  * An upgrade (i.e. a {@link ITurtleUpgrade}) and its current upgrade data.
- * <p>
- * <strong>IMPORTANT:</strong> The {@link #data()} in an upgrade data is often a reference to the original upgrade data.
- * Be careful to take a {@linkplain #copy() defensive copy} if you plan to use the data in this upgrade.
  *
- * @param upgrade The current upgrade.
- * @param data    The upgrade's data.
- * @param <T>     The type of upgrade, either {@link ITurtleUpgrade} or {@link IPocketUpgrade}.
+ * @param holder The current upgrade holder.
+ * @param data   The upgrade's data.
+ * @param <T>    The type of upgrade, either {@link ITurtleUpgrade} or {@link IPocketUpgrade}.
  */
-public record UpgradeData<T extends UpgradeBase>(T upgrade, CompoundTag data) {
+public record UpgradeData<T extends UpgradeBase>(Holder.Reference<T> holder, DataComponentPatch data) {
     /**
      * A utility method to construct a new {@link UpgradeData} instance.
      *
-     * @param upgrade An upgrade.
-     * @param data    The upgrade's data.
-     * @param <T>     The type of upgrade.
+     * @param holder An upgrade.
+     * @param data   The upgrade's data.
+     * @param <T>    The type of upgrade.
      * @return The new {@link UpgradeData} instance.
      */
-    public static <T extends UpgradeBase> UpgradeData<T> of(T upgrade, CompoundTag data) {
-        return new UpgradeData<>(upgrade, data);
+    public static <T extends UpgradeBase> UpgradeData<T> of(Holder.Reference<T> holder, DataComponentPatch data) {
+        return new UpgradeData<>(holder, data);
     }
 
     /**
      * Create an {@link UpgradeData} containing the default {@linkplain #data() data} for an upgrade.
      *
-     * @param upgrade The upgrade instance.
-     * @param <T>     The type of upgrade.
+     * @param holder The upgrade instance.
+     * @param <T>    The type of upgrade.
      * @return The default upgrade data.
      */
-    public static <T extends UpgradeBase> UpgradeData<T> ofDefault(T upgrade) {
-        return of(upgrade, upgrade.getUpgradeData(upgrade.getCraftingItem()));
+    public static <T extends UpgradeBase> UpgradeData<T> ofDefault(Holder.Reference<T> holder) {
+        var upgrade = holder.value();
+        return of(holder, upgrade.getUpgradeData(upgrade.getCraftingItem()));
+    }
+
+    public UpgradeData {
+        if (!holder.isBound()) throw new IllegalArgumentException("Holder is not bound");
     }
 
     /**
-     * Take a copy of a (possibly {@code null}) {@link UpgradeData} instance.
+     * Get the current upgrade.
      *
-     * @param upgrade The copied upgrade data.
-     * @param <T>     The type of upgrade.
-     * @return The newly created upgrade data.
+     * @return The current upgrade.
      */
-    @Contract("!null -> !null; null -> null")
-    public static <T extends UpgradeBase> @Nullable UpgradeData<T> copyOf(@Nullable UpgradeData<T> upgrade) {
-        return upgrade == null ? null : upgrade.copy();
+    public T upgrade() {
+        return holder().value();
     }
 
     /**
-     * Get the {@linkplain UpgradeBase#getUpgradeItem(CompoundTag) upgrade item} for this upgrade.
+     * Get the {@linkplain UpgradeBase#getUpgradeItem(DataComponentPatch) upgrade item} for this upgrade.
      * <p>
      * This returns a defensive copy of the item, to prevent accidental mutation of the upgrade data or original
      * {@linkplain UpgradeBase#getCraftingItem() upgrade stack}.
@@ -67,16 +64,6 @@ public record UpgradeData<T extends UpgradeBase>(T upgrade, CompoundTag data) {
      * @return This upgrade's item.
      */
     public ItemStack getUpgradeItem() {
-        return upgrade.getUpgradeItem(data).copy();
-    }
-
-    /**
-     * Take a copy of this {@link UpgradeData}. This returns a new instance with the same upgrade and a fresh copy of
-     * the upgrade data.
-     *
-     * @return A copy of the current instance.
-     */
-    public UpgradeData<T> copy() {
-        return new UpgradeData<>(upgrade(), data().copy());
+        return upgrade().getUpgradeItem(data).copy();
     }
 }

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeDataProvider.java

@@ -1,179 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.upgrades;
-
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParseException;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import dan200.computercraft.impl.PlatformHelper;
-import dan200.computercraft.impl.upgrades.SerialiserWithCraftingItem;
-import dan200.computercraft.impl.upgrades.SimpleSerialiser;
-import net.minecraft.Util;
-import net.minecraft.core.Registry;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.data.CachedOutput;
-import net.minecraft.data.DataProvider;
-import net.minecraft.data.PackOutput;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.Item;
-
-import javax.annotation.Nullable;
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-/**
- * A data generator/provider for turtle and pocket computer upgrades. This should not be extended directly, instead see
- * the other subclasses.
- *
- * @param <T> The base class of upgrades.
- * @param <R> The upgrade serialiser to register for.
- */
-public abstract class UpgradeDataProvider<T extends UpgradeBase, R extends UpgradeSerialiser<? extends T>> implements DataProvider {
-    private final PackOutput output;
-    private final String name;
-    private final String folder;
-    private final ResourceKey<Registry<R>> registry;
-
-    private @Nullable List<T> upgrades;
-
-    protected UpgradeDataProvider(PackOutput output, String name, String folder, ResourceKey<Registry<R>> registry) {
-        this.output = output;
-        this.name = name;
-        this.folder = folder;
-        this.registry = registry;
-    }
-
-    /**
-     * Register an upgrade using a "simple" serialiser (e.g. {@link TurtleUpgradeSerialiser#simple(Function)}).
-     *
-     * @param id         The ID of the upgrade to create.
-     * @param serialiser The simple serialiser.
-     * @return The constructed upgrade, ready to be passed off to {@link #addUpgrades(Consumer)}'s consumer.
-     */
-    public final Upgrade<R> simple(ResourceLocation id, R serialiser) {
-        if (!(serialiser instanceof SimpleSerialiser)) {
-            throw new IllegalStateException(serialiser + " must be a simple() seriaiser.");
-        }
-
-        return new Upgrade<>(id, serialiser, s -> {
-        });
-    }
-
-    /**
-     * Register an upgrade using a "simple" serialiser (e.g. {@link TurtleUpgradeSerialiser#simple(Function)}).
-     *
-     * @param id         The ID of the upgrade to create.
-     * @param serialiser The simple serialiser.
-     * @param item       The crafting upgrade for this item.
-     * @return The constructed upgrade, ready to be passed off to {@link #addUpgrades(Consumer)}'s consumer.
-     */
-    public final Upgrade<R> simpleWithCustomItem(ResourceLocation id, R serialiser, Item item) {
-        if (!(serialiser instanceof SerialiserWithCraftingItem)) {
-            throw new IllegalStateException(serialiser + " must be a simpleWithCustomItem() serialiser.");
-        }
-
-        return new Upgrade<>(id, serialiser, s ->
-            s.addProperty("item", PlatformHelper.get().getRegistryKey(Registries.ITEM, item).toString())
-        );
-    }
-
-    /**
-     * Add all turtle or pocket computer upgrades.
-     * <p>
-     * <strong>Example usage:</strong>
-     * <pre>{@code
-     * protected void addUpgrades(Consumer<Upgrade<TurtleUpgradeSerialiser<?>>> addUpgrade) {
-     *     simple(new ResourceLocation("mymod", "speaker"), SPEAKER_SERIALISER.get()).add(addUpgrade);
-     * }
-     * }</pre>
-     *
-     * @param addUpgrade A callback used to register an upgrade.
-     */
-    protected abstract void addUpgrades(Consumer<Upgrade<R>> addUpgrade);
-
-    @Override
-    public CompletableFuture<?> run(CachedOutput cache) {
-        var base = output.getOutputFolder().resolve("data");
-
-        Set<ResourceLocation> seen = new HashSet<>();
-        List<T> upgrades = new ArrayList<>();
-        List<CompletableFuture<?>> futures = new ArrayList<>();
-        addUpgrades(upgrade -> {
-            if (!seen.add(upgrade.id())) throw new IllegalStateException("Duplicate upgrade " + upgrade.id());
-
-            var json = new JsonObject();
-            json.addProperty("type", PlatformHelper.get().getRegistryKey(registry, upgrade.serialiser()).toString());
-            upgrade.serialise().accept(json);
-
-            futures.add(DataProvider.saveStable(cache, json, base.resolve(upgrade.id().getNamespace() + "/" + folder + "/" + upgrade.id().getPath() + ".json")));
-
-            try {
-                var result = upgrade.serialiser().fromJson(upgrade.id(), json);
-                upgrades.add(result);
-            } catch (IllegalArgumentException | JsonParseException e) {
-                LOGGER.error("Failed to parse {} {}", name, upgrade.id(), e);
-            }
-        });
-
-        this.upgrades = Collections.unmodifiableList(upgrades);
-        return Util.sequenceFailFast(futures);
-    }
-
-    @Override
-    public final String getName() {
-        return name;
-    }
-
-    public final R existingSerialiser(ResourceLocation id) {
-        var result = PlatformHelper.get().getRegistryObject(registry, id);
-        if (result == null) throw new IllegalArgumentException("No such serialiser " + registry);
-        return result;
-    }
-
-    public List<T> getGeneratedUpgrades() {
-        if (upgrades == null) throw new IllegalStateException("Upgrades have not been generated yet");
-        return upgrades;
-    }
-
-    /**
-     * A constructed upgrade instance, produced {@link #addUpgrades(Consumer)}.
-     *
-     * @param id         The ID for this upgrade.
-     * @param serialiser The serialiser which reads and writes this upgrade.
-     * @param serialise  Augment the generated JSON with additional fields.
-     * @param <R>        The type of upgrade serialiser.
-     */
-    public record Upgrade<R extends UpgradeSerialiser<?>>(
-        ResourceLocation id, R serialiser, Consumer<JsonObject> serialise
-    ) {
-        /**
-         * Convenience method for registering an upgrade.
-         *
-         * @param add The callback given to {@link #addUpgrades(Consumer)}
-         */
-        public void add(Consumer<Upgrade<R>> add) {
-            add.accept(this);
-        }
-
-        /**
-         * Return a new {@link Upgrade} which requires the given mod to be present.
-         * <p>
-         * This uses mod-loader-specific hooks (Forge's crafting conditions and Fabric's resource conditions). If using
-         * this in a multi-loader setup, you must generate resources separately for the two loaders.
-         *
-         * @param modId The id of the mod.
-         * @return A new upgrade instance.
-         */
-        public Upgrade<R> requireMod(String modId) {
-            return new Upgrade<>(id, serialiser, json -> {
-                PlatformHelper.get().addRequiredModCondition(json, modId);
-                serialise.accept(json);
-            });
-        }
-    }
-}

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeSerialiser.java

@@ -1,52 +0,0 @@
-// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
-//
-// SPDX-License-Identifier: MPL-2.0
-
-package dan200.computercraft.api.upgrades;
-
-import com.google.gson.JsonObject;
-import dan200.computercraft.api.pocket.PocketUpgradeSerialiser;
-import dan200.computercraft.api.turtle.TurtleUpgradeSerialiser;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.resources.ResourceLocation;
-
-
-/**
- * Base interface for upgrade serialisers. This should generally not be implemented directly, instead implementing one
- * of {@link TurtleUpgradeSerialiser} or {@link PocketUpgradeSerialiser}.
- * <p>
- * However, it may sometimes be useful to implement this if you have some shared logic between upgrade types.
- *
- * @param <T> The upgrade that this class can serialise and deserialise.
- * @see TurtleUpgradeSerialiser
- * @see PocketUpgradeSerialiser
- */
-public interface UpgradeSerialiser<T extends UpgradeBase> {
-    /**
-     * Read this upgrade from a JSON file in a datapack.
-     *
-     * @param id     The ID of this upgrade.
-     * @param object The JSON object to load this upgrade from.
-     * @return The constructed upgrade, with a {@link UpgradeBase#getUpgradeID()} equal to {@code id}.
-     * @see net.minecraft.util.GsonHelper For additional JSON helper methods.
-     */
-    T fromJson(ResourceLocation id, JsonObject object);
-
-    /**
-     * Read this upgrade from a network packet, sent from the server.
-     *
-     * @param id     The ID of this upgrade.
-     * @param buffer The buffer object to read this upgrade from.
-     * @return The constructed upgrade, with a {@link UpgradeBase#getUpgradeID()} equal to {@code id}.
-     */
-    T fromNetwork(ResourceLocation id, FriendlyByteBuf buffer);
-
-    /**
-     * Write this upgrade to a network packet, to be sent to the client.
-     *
-     * @param buffer  The buffer object to write this upgrade to
-     * @param upgrade The upgrade to write.
-     */
-    void toNetwork(FriendlyByteBuf buffer, T upgrade);
-
-}

projects/common-api/src/main/java/dan200/computercraft/api/upgrades/UpgradeType.java

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: 2021 The CC: Tweaked Developers
+//
+// SPDX-License-Identifier: MPL-2.0
+
+package dan200.computercraft.api.upgrades;
+
+import com.mojang.serialization.MapCodec;
+import dan200.computercraft.api.pocket.IPocketUpgrade;
+import dan200.computercraft.api.turtle.ITurtleUpgrade;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.Recipe;
+import net.minecraft.world.level.storage.loot.functions.LootItemFunction;
+
+import java.util.function.Function;
+
+/**
+ * The type of a {@linkplain ITurtleUpgrade turtle} or {@linkplain IPocketUpgrade pocket} upgrade.
+ * <p>
+ * Turtle and pocket computer upgrades are registered using Minecraft's dynamic registry system. As a result, they
+ * follow a similar design to other dynamic content, such as {@linkplain Recipe recipes} or {@link LootItemFunction
+ * loot functions}.
+ * <p>
+ * While the {@link ITurtleUpgrade}/{@link IPocketUpgrade} class should contain the core logic of the upgrade, they are
+ * not registered directly. Instead, each upgrade class has a corresponding {@link UpgradeType}, which is responsible
+ * for loading the upgrade from a datapack. The upgrade type should then be registered in its appropriate registry
+ * ({@link ITurtleUpgrade#typeRegistry()}, {@link IPocketUpgrade#typeRegistry()}).
+ * <p>
+ * In order to register the actual upgrade, a JSON file referencing your upgrade type should be added to a datapack. It
+ * is recommended to do this via the data generators.
+ *
+ * <h2 id="datagen">Data Generation</h2>
+ * As turtle and pocket upgrades are just loaded using vanilla's dynamic loaders, one may use the same data generation
+ * tools as you would for any other dynamic registry.
+ * <p>
+ * See <a href="../turtle/ITurtleUpgrade.html#datagen">the turtle upgrade docs</a> for a concrete example.
+ *
+ * @param <T> The upgrade subclass that this upgrade type represents.
+ * @see ITurtleUpgrade
+ * @see IPocketUpgrade
+ */
+public interface UpgradeType<T extends UpgradeBase> {
+    /**
+     * The codec to read and write this upgrade from a datapack.
+     *
+     * @return The codec for this upgrade.
+     */
+    MapCodec<T> codec();
+
+    /**
+     * Create a new upgrade type.
+     *
+     * @param codec The codec
+     * @param <T>   The type of the generated upgrade.
+     * @return The newly created upgrade type.
+     */
+    static <T extends UpgradeBase> UpgradeType<T> create(MapCodec<T> codec) {
+        return new UpgradeTypeImpl<>(codec);
+    }
+
+    /**
+     * Create an upgrade type for an upgrade that takes no arguments.
+     * <p>
+     * If you might want to vary the item, it's suggested you use {@link #simpleWithCustomItem(Function)} instead.
+     *
+     * @param instance Generate a new upgrade with a specific ID.
+     * @param <T>      The type of the generated upgrade.
+     * @return A new upgrade type.
+     */
+    static <T extends UpgradeBase> UpgradeType<T> simple(T instance) {
+        return create(MapCodec.unit(instance));
+    }
+
+    /**
+     * Create an upgrade type for a simple upgrade whose crafting item can be specified.
+     *
+     * @param factory Generate a new upgrade with a specific ID and crafting item. The returned upgrade's
+     *                {@link UpgradeBase#getCraftingItem()} <strong>MUST</strong> equal the provided item.
+     * @param <T>     The type of the generated upgrade.
+     * @return A new upgrade type.
+     * @see #simple(UpgradeBase)  For upgrades whose crafting stack should not vary.
+     */
+    static <T extends UpgradeBase> UpgradeType<T> simpleWithCustomItem(Function<ItemStack, T> factory) {
+        return create(BuiltInRegistries.ITEM.byNameCodec()
+            .xmap(x -> factory.apply(new ItemStack(x)), x -> x.getCraftingItem().getItem())
+            .fieldOf("item"));
+    }
+}