From 1cdeb90beb0d04db5cd4c0f88906ab8a5585b11a Mon Sep 17 00:00:00 2001
From: rubensworks <rubensworks@gmail.com>
Date: Tue, 25 Aug 2026 18:33:29 +0000
Subject: [PATCH] Add performance benchmarking setup

Measures what Integrated Crafting adds on top of an Integrated Dynamics
network: crafting interfaces, crafting job scheduling and execution, and
the network's recipe index. Mirrors the setup of Integrated Dynamics and
Integrated Tunnels, and reuses ID's measurement infrastructure.

Adds eight benchmark presets on a shared cable grid: three idle presets
that isolate the standing cost of crafting interfaces and of crafting
writers that have nothing to do, three active presets that continuously
craft (flat, dependency-resolving, and with a 2.45x larger recipe index
at constant crafting work), and two topology churn presets.

All presets are also exposed through /integratedcrafting generatecrafting
<preset> <size> for manual profiling in a real world.

Every preset asserts after warmup that none of its parts is deactivated
or in an aspect error state, and that every filled recipe slot is valid,
so that a preset cannot silently degrade into an expensive no-op.

Storage chests are deliberately only filled two thirds: a crafting
interface buffers its results until it can push them into network
storage and stops ticking its jobs entirely while that buffer is
non-empty, so full chests jam every interface after a single craft.

Without PERFORMANCE_BENCHMARK_ENABLED, all benchmark game tests succeed
immediately without generating anything.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DF81jeWnWNR3ECHzNd9mRh
---
 .github/parse_benchmark_results.sh            |  74 ++
 .gitignore                                    |   3 +
 PERFORMANCE_BENCHMARKING.md                   | 278 ++++++
 .../IntegratedCrafting.java                   |  14 +
 .../command/CommandGenerateCrafting.java      | 818 ++++++++++++++++++
 .../gametest/GameTestsPerformance.java        | 260 ++++++
 6 files changed, 1447 insertions(+)
 create mode 100755 .github/parse_benchmark_results.sh
 create mode 100644 PERFORMANCE_BENCHMARKING.md
 create mode 100644 src/main/java/org/cyclops/integratedcrafting/command/CommandGenerateCrafting.java
 create mode 100644 src/main/java/org/cyclops/integratedcrafting/gametest/GameTestsPerformance.java

diff --git a/.github/parse_benchmark_results.sh b/.github/parse_benchmark_results.sh
new file mode 100755
index 000000000..23ef0bbc8
--- /dev/null
+++ b/.github/parse_benchmark_results.sh
@@ -0,0 +1,74 @@
+#!/bin/bash
+# Parse benchmark results from game tests and convert to JSON format
+# This script reads the benchmark results file and converts it to JSON format
+# for use with benchmark-action/github-action-benchmark
+
+set -e
+
+BENCH_FILE="benchmark_results.json"
+RESULTS_FILE="runs/gameTestServer/logs/benchmark_results.txt"
+
+echo "Parsing benchmark results..."
+
+# Initialize the JSON array
+echo "[" > "$BENCH_FILE"
+
+# Default values if file doesn't exist
+if [ ! -f "$RESULTS_FILE" ]; then
+    echo "Benchmark results file not found at $RESULTS_FILE"
+    exit 1;
+fi
+
+FIRST=true
+while IFS= read -r line; do
+    # Skip empty lines
+    if [ -z "$line" ]; then
+        continue
+    fi
+
+    # Parse the line: preset=<preset> size=<size> avgNetworkTickTime=<time> avgServerTickTime=<time>
+    # Using sed instead of grep -oP for macOS compatibility
+    preset=$(echo "$line" | sed -n 's/.*preset=\([^ ]*\).*/\1/p')
+    size=$(echo "$line" | sed -n 's/.*size=\([0-9]*\).*/\1/p')
+    networkTickTime=$(echo "$line" | sed -n 's/.*avgNetworkTickTime=\([0-9.]*\).*/\1/p')
+    serverTickTime=$(echo "$line" | sed -n 's/.*avgServerTickTime=\([0-9.]*\).*/\1/p')
+
+    if [ -n "$preset" ] && [ -n "$size" ] && [ -n "$networkTickTime" ]; then
+        # Output network tick time metric
+        if [ "$FIRST" = true ]; then
+            FIRST=false
+        else
+            echo "," >> "$BENCH_FILE"
+        fi
+
+        cat >> "$BENCH_FILE" << EOF
+  {
+    "name": "NETWORK LOAD: ${preset}_size_${size}",
+    "unit": "tick time (ms)",
+    "value": $networkTickTime
+  }
+EOF
+    fi
+
+    # Output server tick time metric if available
+    if [ -n "$serverTickTime" ]; then
+        echo "," >> "$BENCH_FILE"
+        cat >> "$BENCH_FILE" << EOF
+  {
+    "name": "SERVER LOAD: ${preset}_size_${size}",
+    "unit": "tick time (ms)",
+    "value": $serverTickTime
+  }
+EOF
+    fi
+done < "$RESULTS_FILE"
+
+# Close the JSON array
+echo "" >> "$BENCH_FILE"
+echo "]" >> "$BENCH_FILE"
+
+# Display the results
+echo "✓ Benchmark results parsed successfully:"
+echo ""
+cat "$BENCH_FILE"
+
diff --git a/.gitignore b/.gitignore
index bc7040e52..ad9c6b93f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,3 +28,6 @@ logs/
 secrets.properties
 build_number.properties
 changelog.txt
+
+# Ignore generated performance benchmark results
+benchmark_results.json
diff --git a/PERFORMANCE_BENCHMARKING.md b/PERFORMANCE_BENCHMARKING.md
new file mode 100644
index 000000000..d8f462ffd
--- /dev/null
+++ b/PERFORMANCE_BENCHMARKING.md
@@ -0,0 +1,278 @@
+# Performance Benchmarking Setup
+
+This document describes the performance benchmarking infrastructure for Integrated Crafting,
+which measures the continuous performance of auto-crafting on Integrated Dynamics networks.
+Performance results are tracked in https://github.com/CyclopsMC/cyclops-performance-results
+
+This setup mirrors the one of [Integrated Dynamics](https://github.com/CyclopsMC/IntegratedDynamics/blob/master-1.21-lts/PERFORMANCE_BENCHMARKING.md)
+and [Integrated Tunnels](https://github.com/CyclopsMC/IntegratedTunnels/blob/master-1.21-lts/PERFORMANCE_BENCHMARKING.md),
+and reuses the measurement infrastructure of Integrated Dynamics.
+Where Integrated Dynamics measures the cost of the network graph and variable evaluation,
+and Integrated Tunnels measures the cost of moving ingredients in and out of a network,
+these benchmarks measure the cost of what Integrated Crafting adds on top of that:
+crafting interfaces, crafting job scheduling and execution, and the network's recipe index.
+
+## Overview
+
+The performance benchmarking system consists of three main components:
+
+1. **GitHub Workflow** (`.github/workflows/performance.yml`)
+   - Executes on the same triggers as CI (push and pull_request)
+   - Runs game tests to measure network performance
+   - Uses `benchmark-action/github-action-benchmark` to track performance evolution
+
+2. **Game Tests** (`src/main/java/org/cyclops/integratedcrafting/gametest/GameTestsPerformance.java`)
+   - Generates networks with different presets for benchmarking
+   - Measures performance metrics for each preset
+   - Writes results to `runs/gameTestServer/logs/benchmark_results.txt`
+
+3. **Network Generation Command** (`src/main/java/org/cyclops/integratedcrafting/command/CommandGenerateCrafting.java`)
+   - Provides `/integratedcrafting generatecrafting <preset> <size>` for manual testing
+   - Supports all presets that the benchmarks use, plus `clear`
+   - Can be used in both single-player and multiplayer environments
+
+## Grid Layout
+
+All presets are built on top of the same grid layout, so that their results are comparable:
+
+- Even Y levels are fully filled with logic cables.
+- Odd Y levels alternate between logic cables and free **cells**.
+
+Every cell is a free position that is fully surrounded by cables of a single network,
+so it can hold a container or a crafter that is targeted by a part on the cable below it,
+and by a second part on a cable next to it.
+A grid of size 9 (the size used in the benchmarks, which is the largest that fits in the `empty10`
+game test template) contains 569 cables and 160 cells.
+
+Every cell takes one of three roles:
+
+| Role | Contents |
+| --- | --- |
+| Storage | A chest holding crafting inputs, exposed to the network by an Integrated Tunnels item interface on the cable below it |
+| Crafter | A crafting table, with a crafting interface on the cable below it holding one or nine recipes |
+| Writer | An empty cell, with a crafting writer on the cable below it. The crafting writer aspect only operates on the network, so it does not need a target block |
+
+The active crafting presets repeat a **four-cell unit** over the 160 cells, giving 40 units:
+
+| Preset family | Cell 0 | Cell 1 | Cell 2 | Cell 3 |
+| --- | --- | --- | --- | --- |
+| Simple / recipe index / satisfied | Storage | Storage | Crafter | Writer |
+| Nested | Storage | Crafter (planks recipe) | Crafter (result recipe) | Writer |
+
+### Crafting chains
+
+Every unit drives its own independent **crafting chain**: a wooden item that is crafted purely out of
+planks of a single wood species, where those planks are in turn crafted out of a single log.
+
+Independent chains are required, not cosmetic: the crafting writer aspect refuses to schedule a job for
+an item that the network is already crafting, so if every writer requested the same item, only one of
+them would ever cause load and the benchmark would collapse to a single crafting chain.
+
+The chain pool covers 10 wood species (oak, spruce, birch, jungle, acacia, dark oak, mangrove, cherry,
+crimson, warped) times the `_stairs`, `_trapdoor`, `_boat`, `_slab`, `_pressure_plate` and `_button`
+recipes, for **58 chains** in total (crimson and warped have no boat).
+
+Only recipes that are shapeless, at most 2x2, or exactly 3 wide are usable:
+`CraftingGrid` fills a 3x3 grid row by row, so a recipe that is 2 wide and 3 tall (such as doors)
+would end up misaligned and would never be found by the crafting table process override.
+
+A separate pool of **40 filler recipes** (`_planks`, `_fence`, `_fence_gate` and `_sign` per species)
+is used to fill the remaining recipe slots of crafting interfaces. These are never requested;
+their only purpose is to grow the network's recipe index. Together this gives **98 distinct recipes**.
+
+### Numbers that were chosen
+
+| Constant | Value | Why |
+| --- | --- | --- |
+| `SIZE` | 9 | The largest grid that fits in the 10x10x10 `empty10` game test template |
+| `WARMUP_TICKS` | 200 | Lets the JIT warm up and the network settle before measuring |
+| `EXECUTION_SECONDS` | 30 | 600 game ticks of measurement. Long enough that run-to-run variance on the network tick time stays within a few percent, while the whole suite still finishes in about a minute locally |
+| `TIMEOUT_TICKS` | 1000 | Warmup plus measurement plus headroom |
+| `CHURN_CELLS` | 50 | Number of crafting interfaces added or removed, one per tick, by the churn presets |
+| `RECIPES_PER_INTERFACE` | 9 | The size of a crafting interface's recipe inventory |
+| `STORAGE_STACKS` | 12 (of 27 chest slots) | A crafting interface buffers its results until it can push them into network storage, and stops ticking its jobs entirely while that buffer is non-empty. Completely filled chests therefore jam every crafting interface after a single craft, so every storage chest deliberately keeps 15 slots free |
+
+## Network Presets
+
+### Idle crafting interfaces
+
+These presets never request a craft. They isolate the standing cost of having crafting interfaces
+attached to a network: their part ticks, their recipe variable evaluation, and their recipe registrations.
+
+| Preset | Description |
+| --- | --- |
+| `interfaces_crafting_idle` | Every one of the 160 cells holds a crafting table with a crafting interface holding a single recipe. Recipe index: 98 recipes |
+| `interfaces_crafting_idle_recipes` | The same 160 crafting interfaces, but each one completely filled with 9 recipes, for 1440 recipe registrations instead of 160. The set of distinct recipes is the same, so this isolates the per-interface cost of holding many recipes |
+| `craft_satisfied_idle` | The `craft_simple` layout, but the 40 crafting writers request an item that is already in network storage. No crafting job is ever scheduled, so this isolates what a crafting writer pays per tick just to determine that there is nothing to do |
+
+### Active crafting
+
+These presets continuously schedule and execute crafting jobs.
+
+| Preset | Description |
+| --- | --- |
+| `craft_simple` | 80 storage cells holding planks, 40 crafting interfaces and 40 crafting writers. Every writer requests its own item, with "ignore storage" enabled so that it keeps requesting instead of stopping once the item exists. Sustains 4.0 crafts per tick. Recipe index: 40 recipes |
+| `craft_nested` | 40 storage cells holding only logs, 80 crafting interfaces (one for the planks recipe, one for the result recipe) and 40 crafting writers. Every requested item needs at least 4 planks per craft, and a planks recipe yields 4 planks at a time, so leftovers can never satisfy a request and every request has to resolve and schedule a dependency graph. Sustains 5.5 crafts per tick across roughly 40 concurrent jobs, of which about 35 to 45 are pending on a dependency at any moment. Recipe index: 38 recipes |
+| `craft_recipe_index` | Exactly the same layout and the same crafting work as `craft_simple`, but with every crafting interface filled with 9 recipes instead of 1. This grows the recipe index that every crafting job calculation searches from 40 to 98 recipes while holding the amount of crafting constant |
+
+Note that `craft_nested` drives 28 distinct chains rather than 40, because only 28 of the 58 chains
+consume at least 4 planks per craft. The remaining 12 writers request a chain that another writer is
+already crafting, and therefore idle at the cost of a `craft_satisfied_idle` writer.
+The part counts stay identical to the other presets, which keeps them comparable.
+
+### Topology churn
+
+| Preset | Description |
+| --- | --- |
+| `interfaces_crafting_append` | Starts from a cable-only grid, and adds one crafting table with a crafting interface per tick after warming up, growing from 1 to 50 interfaces. Measures the cost of registering crafting interfaces and their recipes in the crafting network |
+| `interfaces_crafting_remove` | Starts from a fully populated grid of 160 crafting interfaces, and removes one per tick after warming up, shrinking to 110. Measures the cost of unregistering crafting interfaces and splitting networks |
+
+For both churn presets the server tick time is captured immediately after the churn finishes, so it
+deliberately includes the block updates and network re-initialisations that the churn causes.
+This is why `interfaces_crafting_remove` reports a much higher server tick time than every other preset.
+
+## Performance Metrics
+
+The benchmarking system measures two key metrics:
+
+- **Average Network Tick Time (ms)**: The average time the Integrated Dynamics network subsystem takes
+  to process one game tick. This is the sum of the time spent in the network's parts
+  (which for these benchmarks are crafting interfaces, crafting writers and item interfaces)
+  and the time spent in the ingredient observers of the item channel.
+- **Average Server Tick Time (ms)**: The average time the entire Minecraft server takes per game tick.
+  This measures the overall server performance impact, including both the network and all other
+  server operations.
+- **Network Size**: The edge length of the generated grid.
+
+These metrics are tracked separately in the benchmark results to distinguish between network-specific
+performance and overall server performance impact.
+
+### A note on the idle presets
+
+Integrated Dynamics' ingredient observers are change-driven, and an idle crafting interface does very
+little per tick. The idle presets therefore legitimately report a network tick time close to zero
+(around 0.2 to 0.6 ms on a development machine), and `interfaces_crafting_idle_recipes` can even report
+*less* than `interfaces_crafting_idle`. That is not a broken preset, but it does mean that these
+presets are a weak signal for the benchmark action's relative 250% alert threshold: a small absolute
+regression can trip the threshold, and a small absolute regression can also hide below it.
+The active crafting presets are the ones to watch for real regressions.
+
+## Game Test Execution
+
+The game tests are automatically executed as part of the GitHub workflow:
+
+```bash
+PERFORMANCE_BENCHMARK_ENABLED=true ./gradlew runGameTestServer
+```
+
+This command:
+1. Starts a game test server
+2. Runs `GameTestsPerformance` game tests
+3. Generates networks with different presets
+4. Measures performance metrics
+5. Writes results to `runs/gameTestServer/logs/benchmark_results.txt`
+
+When `PERFORMANCE_BENCHMARK_ENABLED` is not set, all of these game tests succeed immediately without
+generating or measuring anything, so that regular `./gradlew runGameTestServer` runs are not slowed down.
+On a development machine, the full game test suite takes about 18 seconds without benchmarking and
+about 65 seconds with benchmarking enabled.
+
+Every preset additionally asserts, right after the warmup, that none of the parts it generated is
+deactivated or has an aspect error, and that every filled recipe slot of every crafting interface is
+valid. A part that silently failed to activate would still cost tick time, which would quietly turn a
+benchmark preset into an expensive no-op.
+
+## Result Format
+
+Results are written in the following format:
+```
+preset=craft_simple size=9 avgNetworkTickTime=3.13 avgServerTickTime=2.58
+preset=craft_nested size=9 avgNetworkTickTime=5.18 avgServerTickTime=1.91
+```
+
+Results are then converted to JSON format for the benchmark action.
+Each preset generates two metrics - one for network tick time and one for server tick time:
+```json
+[
+  {
+    "name": "NETWORK LOAD: craft_simple_size_9",
+    "unit": "tick time (ms)",
+    "value": 3.13
+  },
+  {
+    "name": "SERVER LOAD: craft_simple_size_9",
+    "unit": "tick time (ms)",
+    "value": 2.58
+  }
+]
+```
+
+## Benchmark Tracking
+
+The `benchmark-action/github-action-benchmark` GitHub action automatically:
+- Stores benchmark results in the `CyclopsMC/IntegratedCrafting/<branch>/benchmarks` directory
+  of the `CyclopsMC/cyclops-performance-results` repository
+  (note the extra repository name segment compared to Integrated Dynamics,
+  which is needed because all Cyclops mods share branch names)
+- Generates historical performance charts
+- Alerts when performance degrades beyond 250% of baseline
+- Creates comments on commits and PRs when alerts are triggered
+
+## Manual Testing
+
+To manually test crafting performance in a Minecraft world:
+
+1. **Generate a network of idle crafting interfaces**:
+   ```
+   /integratedcrafting generatecrafting interfacesidle 9
+   ```
+
+2. **Generate a network that continuously crafts**:
+   ```
+   /integratedcrafting generatecrafting craftsimple 9
+   ```
+
+3. **Generate a network that continuously crafts with dependencies**:
+   ```
+   /integratedcrafting generatecrafting craftnested 9
+   ```
+
+4. **Measure network performance** (provided by Integrated Dynamics):
+   ```
+   /integrateddynamics networkdiagnostics measure 10
+   ```
+
+5. **Clear generated networks**:
+   ```
+   /integratedcrafting generatecrafting clear 50
+   ```
+
+Note that the generation is `O(size^3)`, and that every cell adds a part to the network,
+so sizes much larger than 9 will quickly become very heavy.
+
+## Integration with CI/CD
+
+The performance workflow runs on:
+- Every push to any `master*` or `feature*` branch
+- Every pull request
+
+Performance degradation is tracked across commits and branches, helping to identify performance
+regressions early in the development cycle.
+
+## Adding New Benchmarks
+
+To add new network presets or benchmarks:
+
+1. Add a new preset enum value in `CommandGenerateCrafting.CraftingPreset`
+2. Add a corresponding generation method in `CommandGenerateCrafting.CraftingGenerationHelper`,
+   and dispatch to it from `CraftingGenerationHelper.generate`
+3. Add a new `@GameTest` method in `GameTestsPerformance`, with a unique `batch` name,
+   so that the benchmark runs in isolation from the other benchmarks
+4. The workflow will automatically execute and track the new benchmark
+
+When adding a preset that is supposed to do work, verify that it actually does, by temporarily
+instrumenting the site that performs the work - `CraftingJobHandler.consumeAndInsertCrafting` for
+crafting execution, and `CraftingHelpers.calculateAndScheduleCraftingJob` for job scheduling - with a
+counter, and sampling it several times across the measurement window. The rate has to be non-zero
+*and* linear: a preset that does a burst of work during the warmup and then stalls still produces a
+plausible-looking number. Use the idle presets as a control, since they must read exactly zero.
diff --git a/src/main/java/org/cyclops/integratedcrafting/IntegratedCrafting.java b/src/main/java/org/cyclops/integratedcrafting/IntegratedCrafting.java
index a39630aaa..a979077ef 100644
--- a/src/main/java/org/cyclops/integratedcrafting/IntegratedCrafting.java
+++ b/src/main/java/org/cyclops/integratedcrafting/IntegratedCrafting.java
@@ -1,6 +1,10 @@
 package org.cyclops.integratedcrafting;
 
 import com.google.common.collect.Lists;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import net.minecraft.commands.CommandBuildContext;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
 import net.minecraft.world.item.CreativeModeTab;
 import net.minecraft.world.item.ItemStack;
 import net.neoforged.api.distmarker.Dist;
@@ -18,6 +22,7 @@
 import org.cyclops.cyclopscore.proxy.ICommonProxy;
 import org.cyclops.integratedcrafting.api.crafting.ICraftingProcessOverrideRegistry;
 import org.cyclops.integratedcrafting.capability.network.CraftingNetworkCapabilityConstructors;
+import org.cyclops.integratedcrafting.command.CommandGenerateCrafting;
 import org.cyclops.integratedcrafting.capability.network.NetworkCraftingHandlerCraftingNetwork;
 import org.cyclops.integratedcrafting.core.CraftingProcessOverrideRegistry;
 import org.cyclops.integratedcrafting.core.CraftingProcessOverrides;
@@ -66,6 +71,15 @@ public void onRegistriesCreate(NewRegistryEvent event) {
         CraftingProcessOverrides.load();
     }
 
+    @Override
+    protected LiteralArgumentBuilder<CommandSourceStack> constructBaseCommand(Commands.CommandSelection selection, CommandBuildContext context) {
+        LiteralArgumentBuilder<CommandSourceStack> root = super.constructBaseCommand(selection, context);
+
+        root.then(CommandGenerateCrafting.make());
+
+        return root;
+    }
+
     @Override
     protected void setup(FMLCommonSetupEvent event) {
         super.setup(event);
diff --git a/src/main/java/org/cyclops/integratedcrafting/command/CommandGenerateCrafting.java b/src/main/java/org/cyclops/integratedcrafting/command/CommandGenerateCrafting.java
new file mode 100644
index 000000000..9b937f70b
--- /dev/null
+++ b/src/main/java/org/cyclops/integratedcrafting/command/CommandGenerateCrafting.java
@@ -0,0 +1,818 @@
+package org.cyclops.integratedcrafting.command;
+
+import com.google.common.collect.Lists;
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import net.minecraft.ChatFormatting;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.Container;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.item.crafting.RecipeType;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.entity.ChestBlockEntity;
+import org.cyclops.cyclopscore.command.argument.ArgumentTypeEnum;
+import org.cyclops.integratedcrafting.core.part.PartTypeInterfaceCraftingBase;
+import org.cyclops.integratedcrafting.gametest.GameTestHelpersIntegratedCrafting;
+import org.cyclops.integratedcrafting.part.PartTypeInterfaceCrafting;
+import org.cyclops.integratedcrafting.part.PartTypes;
+import org.cyclops.integratedcrafting.part.aspect.CraftingAspectWriteBuilders;
+import org.cyclops.integratedcrafting.part.aspect.CraftingAspects;
+import org.cyclops.integrateddynamics.RegistryEntries;
+import org.cyclops.integrateddynamics.api.part.IPartType;
+import org.cyclops.integrateddynamics.api.part.PartPos;
+import org.cyclops.integrateddynamics.api.part.write.IPartStateWriter;
+import org.cyclops.integrateddynamics.block.BlockCable;
+import org.cyclops.integrateddynamics.core.evaluate.variable.ValueObjectTypeItemStack;
+import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypeBoolean;
+import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
+import org.cyclops.integrateddynamics.core.helper.CableHelpers;
+import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
+import org.cyclops.integrateddynamics.core.helper.PartHelpers;
+import org.cyclops.integrateddynamics.gametest.GameTestHelpersIntegratedDynamics;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+/**
+ * Command for generating crafting networks with different presets.
+ *
+ * These presets are used for performance benchmarking,
+ * both from within game tests, and for manual profiling inside a real world.
+ *
+ * @author rubensworks
+ */
+public class CommandGenerateCrafting implements Command<CommandSourceStack> {
+
+    public static LiteralArgumentBuilder<CommandSourceStack> make() {
+        LiteralArgumentBuilder<CommandSourceStack> builder = Commands.literal("generatecrafting")
+                .requires((commandSource) -> commandSource.hasPermission(2));
+
+        // Add the preset subcommand with optional size argument
+        builder.then(Commands.argument("preset", new ArgumentTypeEnum(CraftingPreset.class))
+                .executes(new CommandGenerateCraftingExecutor(true, false))
+                .then(Commands.argument("size", IntegerArgumentType.integer(1, 100))
+                        .executes(new CommandGenerateCraftingExecutor(true, true))));
+
+        return builder;
+    }
+
+    @Override
+    public int run(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+        context.getSource().sendFailure(Component.literal("Please specify one of the presets: " + joinPresets())
+                .withStyle(ChatFormatting.RED));
+        return 0;
+    }
+
+    /**
+     * @return All preset names, joined by a comma.
+     */
+    public static String joinPresets() {
+        StringBuilder sb = new StringBuilder();
+        for (CraftingPreset preset : CraftingPreset.values()) {
+            if (sb.length() > 0) {
+                sb.append(", ");
+            }
+            sb.append(preset.name().toLowerCase());
+        }
+        return sb.toString();
+    }
+
+    /**
+     * The available network presets.
+     */
+    public enum CraftingPreset {
+        /** Only cables, no parts: the baseline that the append benchmark grows from. */
+        EMPTY,
+        /** Idle crafting interfaces in front of crafting tables, each holding a single recipe. */
+        INTERFACESIDLE,
+        /** Idle crafting interfaces in front of crafting tables, each holding nine recipes. */
+        INTERFACESIDLERECIPES,
+        /** Crafting writers continuously requesting items that are crafted from stored planks. */
+        CRAFTSIMPLE,
+        /** Crafting writers requesting items whose ingredients must themselves be crafted first. */
+        CRAFTNESTED,
+        /** As {@link #CRAFTSIMPLE}, but with every crafting interface loaded with nine recipes. */
+        CRAFTRECIPEINDEX,
+        /** Crafting writers requesting items that are already in storage, so no job is ever scheduled. */
+        CRAFTSATISFIEDIDLE,
+        /** Remove everything that the other presets generate. */
+        CLEAR,
+    }
+
+    /**
+     * Executor for the generatecrafting command.
+     */
+    public static class CommandGenerateCraftingExecutor implements Command<CommandSourceStack> {
+        private final boolean hasPreset;
+        private final boolean hasSize;
+
+        public CommandGenerateCraftingExecutor(boolean hasPreset, boolean hasSize) {
+            this.hasPreset = hasPreset;
+            this.hasSize = hasSize;
+        }
+
+        @Override
+        public int run(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+            if (!hasPreset) {
+                context.getSource().sendFailure(Component.literal("Please specify one of the presets: " + joinPresets())
+                        .withStyle(ChatFormatting.RED));
+                return 0;
+            }
+
+            CraftingPreset preset = ArgumentTypeEnum.getValue(context, "preset", CraftingPreset.class);
+            ServerLevel level = context.getSource().getLevel();
+            BlockPos playerPos = BlockPos.containing(context.getSource().getPosition());
+            int size = hasSize ? IntegerArgumentType.getInteger(context, "size") : getDefaultSize(preset);
+
+            if (preset == CraftingPreset.CLEAR) {
+                context.getSource().sendSuccess(
+                        () -> Component.literal("Clearing generated crafting networks within radius: " + size)
+                                .withStyle(ChatFormatting.GREEN),
+                        true);
+                CraftingGenerationHelper.clearGrid(level, playerPos, size);
+                return 1;
+            }
+
+            context.getSource().sendSuccess(
+                    () -> Component.literal("Generating crafting preset: " + preset.name().toLowerCase()
+                                    + " (size: " + size + "x" + size + "x" + size + ")")
+                            .withStyle(ChatFormatting.GREEN),
+                    true);
+            CraftingGenerationHelper.generate(preset, level, playerPos.above(2), size);
+
+            return 1;
+        }
+
+        /**
+         * Get the default size for the given preset.
+         */
+        private int getDefaultSize(CraftingPreset preset) {
+            return preset == CraftingPreset.CLEAR ? 50 : 9;
+        }
+    }
+
+    /**
+     * Helper class for crafting network generation logic, shared between command and game tests.
+     *
+     * All presets are built on top of the same grid layout:
+     * cable planes at even Y levels, and a checkerboard of cables and free "cells" at odd Y levels.
+     * Every cell is a free position that is surrounded by cables of a single network,
+     * so it can hold a container or a crafter that is observed or targeted by parts on the surrounding cables.
+     *
+     * Every cell can carry up to two parts: one on the cable below it (pointing up),
+     * and one on a horizontally neighbouring cable (pointing sideways).
+     */
+    public static class CraftingGenerationHelper {
+
+        /**
+         * The number of distinct recipes that fit in a single crafting interface.
+         */
+        public static final int RECIPES_PER_INTERFACE = 9;
+
+        /**
+         * The number of full stacks of crafting inputs that is placed in every storage chest.
+         *
+         * This deliberately leaves slots free in every chest.
+         * A crafting interface buffers its results until it can push them into network storage,
+         * and it stops ticking its jobs entirely while that buffer is non-empty.
+         * Completely filled chests would therefore jam every crafting interface after a single craft.
+         */
+        public static final int STORAGE_STACKS = 12;
+
+        /**
+         * All crafting chains that the presets can request.
+         *
+         * Every chain is a wooden item that is crafted purely out of planks of a single wood species,
+         * where those planks are in turn crafted out of a single log of that species.
+         * This gives us a large pool of independent chains:
+         * the crafting writer aspect refuses to schedule a job for an item that is already being crafted,
+         * so every writer in a preset needs its own distinct output item to actually cause load.
+         *
+         * Only recipes that are shapeless, at most 2x2, or exactly 3 wide are usable here:
+         * {@link org.cyclops.integratedcrafting.core.crafting.processoverride.CraftingGrid} fills a 3x3 grid
+         * row by row, so a recipe that is 2 wide and 3 tall (such as doors) would end up misaligned.
+         */
+        public static final List<CraftingChain> CHAINS = Lists.newArrayList();
+
+        /**
+         * Extra recipes that are only used to fill up the recipe slots of crafting interfaces.
+         *
+         * These are never requested by a crafting writer: their only purpose is to grow the number of
+         * recipes that the network's recipe index holds, and that every crafting interface has to
+         * evaluate and validate.
+         */
+        public static final List<ResourceLocation> FILLER_RECIPES = Lists.newArrayList();
+
+        /**
+         * All recipes that a crafting interface can be filled up with,
+         * which is every chain recipe followed by every filler recipe.
+         */
+        public static final List<ResourceLocation> ALL_RECIPES = Lists.newArrayList();
+
+        /**
+         * The subset of {@link #CHAINS} that requires at least 4 planks per craft.
+         *
+         * A planks recipe yields 4 planks at a time, so a request for at least 4 planks can never be
+         * fully satisfied by the leftovers of a previous craft, which means such a chain keeps
+         * requiring a nested planks job for as long as the benchmark runs.
+         */
+        public static final List<CraftingChain> CHAINS_NESTED = Lists.newArrayList();
+
+        static {
+            // Wood species that have a boat variant
+            registerSpecies("oak", Items.OAK_LOG, Items.OAK_PLANKS, true);
+            registerSpecies("spruce", Items.SPRUCE_LOG, Items.SPRUCE_PLANKS, true);
+            registerSpecies("birch", Items.BIRCH_LOG, Items.BIRCH_PLANKS, true);
+            registerSpecies("jungle", Items.JUNGLE_LOG, Items.JUNGLE_PLANKS, true);
+            registerSpecies("acacia", Items.ACACIA_LOG, Items.ACACIA_PLANKS, true);
+            registerSpecies("dark_oak", Items.DARK_OAK_LOG, Items.DARK_OAK_PLANKS, true);
+            registerSpecies("mangrove", Items.MANGROVE_LOG, Items.MANGROVE_PLANKS, true);
+            registerSpecies("cherry", Items.CHERRY_LOG, Items.CHERRY_PLANKS, true);
+            // Nether wood species, which have no boat variant
+            registerSpecies("crimson", Items.CRIMSON_STEM, Items.CRIMSON_PLANKS, false);
+            registerSpecies("warped", Items.WARPED_STEM, Items.WARPED_PLANKS, false);
+
+            for (CraftingChain chain : CHAINS) {
+                if (!ALL_RECIPES.contains(chain.resultRecipe())) {
+                    ALL_RECIPES.add(chain.resultRecipe());
+                }
+            }
+            ALL_RECIPES.addAll(FILLER_RECIPES);
+        }
+
+        private static void registerSpecies(String species, Item log, Item planks, boolean hasBoat) {
+            // Deep chains: at least 4 planks per craft, so a nested planks job is always required
+            registerChain(species, log, planks, species + "_stairs", true);
+            registerChain(species, log, planks, species + "_trapdoor", true);
+            if (hasBoat) {
+                registerChain(species, log, planks, species + "_boat", true);
+            }
+            // Shallow chains: fewer than 4 planks per craft
+            registerChain(species, log, planks, species + "_slab", false);
+            registerChain(species, log, planks, species + "_pressure_plate", false);
+            registerChain(species, log, planks, species + "_button", false);
+            // Filler recipes, which are never requested, and only grow the recipe index
+            FILLER_RECIPES.add(ResourceLocation.withDefaultNamespace(species + "_planks"));
+            FILLER_RECIPES.add(ResourceLocation.withDefaultNamespace(species + "_fence"));
+            FILLER_RECIPES.add(ResourceLocation.withDefaultNamespace(species + "_fence_gate"));
+            FILLER_RECIPES.add(ResourceLocation.withDefaultNamespace(species + "_sign"));
+        }
+
+        private static void registerChain(String species, Item log, Item planks, String resultName, boolean nested) {
+            CraftingChain chain = new CraftingChain(
+                    ResourceLocation.withDefaultNamespace(resultName),
+                    ResourceLocation.withDefaultNamespace(species + "_planks"),
+                    log,
+                    planks
+            );
+            CHAINS.add(chain);
+            if (nested) {
+                CHAINS_NESTED.add(chain);
+            }
+        }
+
+        /**
+         * A single crafting chain: a wooden item that is crafted out of planks,
+         * which are in turn crafted out of a log.
+         *
+         * @param resultRecipe The recipe of the requested item, which only consumes planks.
+         * @param planksRecipe The recipe of the planks that the result recipe consumes.
+         * @param log The log that the planks recipe consumes.
+         * @param planks The planks that the planks recipe produces.
+         */
+        public record CraftingChain(ResourceLocation resultRecipe, ResourceLocation planksRecipe,
+                                    Item log, Item planks) {
+            /**
+             * @return The item that the result recipe produces.
+             */
+            public Item getResultItem() {
+                return net.minecraft.core.registries.BuiltInRegistries.ITEM.get(resultRecipe());
+            }
+        }
+
+        /**
+         * Generate the given preset.
+         * @param preset The preset to generate.
+         * @param level The level to generate in.
+         * @param startPos The lowest corner of the generated grid.
+         * @param size The edge length of the generated grid.
+         */
+        public static void generate(CraftingPreset preset, ServerLevel level, BlockPos startPos, int size) {
+            switch (preset) {
+                case EMPTY -> generateEmptyGrid(level, startPos, size);
+                case INTERFACESIDLE -> generateInterfacesIdle(level, startPos, size);
+                case INTERFACESIDLERECIPES -> generateInterfacesIdleRecipes(level, startPos, size);
+                case CRAFTSIMPLE -> generateCraftSimple(level, startPos, size);
+                case CRAFTNESTED -> generateCraftNested(level, startPos, size);
+                case CRAFTRECIPEINDEX -> generateCraftRecipeIndex(level, startPos, size);
+                case CRAFTSATISFIEDIDLE -> generateCraftSatisfiedIdle(level, startPos, size);
+                case CLEAR -> clearGrid(level, startPos, size);
+            }
+        }
+
+        /*
+         * Grid construction
+         */
+
+        /**
+         * Generate a grid of cables without any parts or containers.
+         * @param level The level to generate in.
+         * @param startPos The lowest corner of the generated grid.
+         * @param size The edge length of the generated grid.
+         */
+        public static void generateEmptyGrid(ServerLevel level, BlockPos startPos, int size) {
+            List<BlockPos> placedPositions = Lists.newArrayList();
+
+            // Place all cables at once without triggering a network init for each of them,
+            // as that would make generation unusably slow for larger sizes.
+            BlockCable.SKIP_NETWORK_INIT = true;
+            try {
+                for (int x = 0; x < size; x++) {
+                    for (int y = 0; y < size; y++) {
+                        for (int z = 0; z < size; z++) {
+                            if (isCablePosition(x, y, z)) {
+                                BlockPos pos = startPos.offset(x, y, z);
+                                level.setBlock(pos, RegistryEntries.BLOCK_CABLE.value().defaultBlockState(), 2);
+                                placedPositions.add(pos);
+                            }
+                        }
+                    }
+                }
+            } finally {
+                BlockCable.SKIP_NETWORK_INIT = false;
+            }
+
+            for (BlockPos pos : placedPositions) {
+                CableHelpers.updateConnectionsNeighbours(level, pos, CableHelpers.ALL_SIDES);
+            }
+
+            NetworkHelpers.initNetwork(level, startPos, null);
+        }
+
+        /**
+         * @param x The local X coordinate within the grid.
+         * @param y The local Y coordinate within the grid.
+         * @param z The local Z coordinate within the grid.
+         * @return If a cable should be placed at the given local grid coordinate.
+         */
+        private static boolean isCablePosition(int x, int y, int z) {
+            // Even Y levels are fully filled with cables,
+            // odd Y levels alternate between cables and free cells.
+            return y % 2 == 0 || (x + z) % 2 == 0;
+        }
+
+        /**
+         * Get all cell positions of the grid, in a deterministic order.
+         *
+         * A cell is a free position at an odd Y level that is surrounded by cables,
+         * so that it can hold a container or crafter that is targeted by the surrounding parts.
+         *
+         * @param startPos The lowest corner of the grid.
+         * @param size The edge length of the grid.
+         * @return The absolute cell positions.
+         */
+        public static List<BlockPos> getCells(BlockPos startPos, int size) {
+            List<BlockPos> cells = Lists.newArrayList();
+            for (int y = 1; y < size; y += 2) {
+                for (int x = 0; x < size; x++) {
+                    for (int z = 0; z < size; z++) {
+                        if (!isCablePosition(x, y, z)) {
+                            cells.add(startPos.offset(x, y, z));
+                        }
+                    }
+                }
+            }
+            return cells;
+        }
+
+        /**
+         * Get the direction from the given cell towards a horizontally neighbouring cable.
+         * @param level The level.
+         * @param cell A cell position.
+         * @return The direction, or null if the cell has no horizontally neighbouring cable.
+         */
+        @Nullable
+        public static Direction getSideCableDirection(ServerLevel level, BlockPos cell) {
+            for (Direction direction : Direction.Plane.HORIZONTAL) {
+                if (level.getBlockState(cell.relative(direction)).getBlock() == RegistryEntries.BLOCK_CABLE.value()) {
+                    return direction;
+                }
+            }
+            return null;
+        }
+
+        /**
+         * Add a part on the cable below the given cell, targeting the cell.
+         */
+        private static PartPos addPartBelow(ServerLevel level, BlockPos cell, IPartType partType) {
+            BlockPos cablePos = cell.below();
+            PartHelpers.addPart(level, cablePos, Direction.UP, partType, new ItemStack(partType.getItem()));
+            return PartPos.of(level, cablePos, Direction.UP);
+        }
+
+        /**
+         * Add a part on a cable next to the given cell, targeting the cell.
+         * @return The position of the added part, or null if the cell has no horizontal cable neighbour.
+         */
+        @Nullable
+        private static PartPos addPartBeside(ServerLevel level, BlockPos cell, IPartType partType) {
+            Direction sideDirection = getSideCableDirection(level, cell);
+            if (sideDirection == null) {
+                return null;
+            }
+            BlockPos cablePos = cell.relative(sideDirection);
+            Direction side = sideDirection.getOpposite();
+            PartHelpers.addPart(level, cablePos, side, partType, new ItemStack(partType.getItem()));
+            return PartPos.of(level, cablePos, side);
+        }
+
+        /**
+         * Notify all cables around the given cells that their neighbours have changed,
+         * so that newly added parts and containers are picked up by the network.
+         */
+        private static void updateCells(ServerLevel level, List<BlockPos> cells) {
+            for (BlockPos cell : cells) {
+                for (Direction direction : Direction.values()) {
+                    BlockPos pos = cell.relative(direction);
+                    if (level.getBlockState(pos).getBlock() == RegistryEntries.BLOCK_CABLE.value()) {
+                        level.updateNeighborsAt(pos, RegistryEntries.BLOCK_CABLE.value());
+                    }
+                }
+            }
+        }
+
+        /*
+         * Cell roles
+         */
+
+        /**
+         * Turn the given cell into network storage: a chest filled with crafting inputs,
+         * exposed to the network by an item interface.
+         * @param level The level.
+         * @param cell The cell position.
+         * @param item The item to fill the chest with.
+         */
+        public static void placeStorageCell(ServerLevel level, BlockPos cell, Item item) {
+            level.setBlock(cell, Blocks.CHEST.defaultBlockState(), 2);
+            if (level.getBlockEntity(cell) instanceof ChestBlockEntity chest) {
+                // Only fill part of the chest: the remaining slots are needed to hold the crafting outputs.
+                for (int slot = 0; slot < Math.min(STORAGE_STACKS, chest.getContainerSize()); slot++) {
+                    ItemStack itemStack = new ItemStack(item);
+                    itemStack.setCount(itemStack.getMaxStackSize());
+                    chest.setItem(slot, itemStack);
+                }
+            }
+            addPartBelow(level, cell, org.cyclops.integratedtunnels.part.PartTypes.INTERFACE_ITEM);
+        }
+
+        /**
+         * Turn the given cell into a crafter: a crafting table with a crafting interface pointing at it,
+         * holding the given recipes.
+         * @param level The level.
+         * @param cell The cell position.
+         * @param recipes The recipes to place in the crafting interface, at most {@link #RECIPES_PER_INTERFACE}.
+         * @return The position of the crafting interface.
+         */
+        public static PartPos placeCrafterCell(ServerLevel level, BlockPos cell, List<ResourceLocation> recipes) {
+            level.setBlock(cell, Blocks.CRAFTING_TABLE.defaultBlockState(), 2);
+            PartPos interfacePos = addPartBelow(level, cell, PartTypes.INTERFACE_CRAFTING);
+
+            PartTypeInterfaceCraftingBase.State<?, ?> state = (PartTypeInterfaceCraftingBase.State<?, ?>)
+                    PartHelpers.getPart(interfacePos).getState();
+            if (state instanceof PartTypeInterfaceCrafting.State craftingState) {
+                for (int slot = 0; slot < Math.min(recipes.size(), RECIPES_PER_INTERFACE); slot++) {
+                    ItemStack variableRecipe = createRecipeVariable(level, recipes.get(slot));
+                    if (!variableRecipe.isEmpty()) {
+                        craftingState.getInventoryVariables().setItem(slot, variableRecipe);
+                    }
+                }
+            }
+            return interfacePos;
+        }
+
+        /**
+         * Turn the given cell into a crafting writer that continuously requests the given item.
+         *
+         * The cell itself is left empty: the crafting writer aspect only operates on the network,
+         * so it does not need a target block.
+         *
+         * @param level The level.
+         * @param cell The cell position.
+         * @param item The item to request.
+         * @param ignoreStorage If the writer should request the item even when it is already in storage.
+         *                      This is what turns a single craft into a continuous stream of crafting jobs.
+         * @return The position of the crafting writer.
+         */
+        public static PartPos placeWriterCell(ServerLevel level, BlockPos cell, Item item, boolean ignoreStorage) {
+            PartPos writerPos = addPartBelow(level, cell, PartTypes.CRAFTING_WRITER);
+            GameTestHelpersIntegratedDynamics.placeVariableInWriter(level, writerPos, CraftingAspects.Write.ITEMSTACK_CRAFT,
+                    GameTestHelpersIntegratedDynamics.createVariableForValue(level, ValueTypes.OBJECT_ITEMSTACK,
+                            ValueObjectTypeItemStack.ValueItemStack.of(new ItemStack(item))));
+            if (ignoreStorage) {
+                GameTestHelpersIntegratedCrafting.setWriterAspectProperty(writerPos, CraftingAspects.Write.ITEMSTACK_CRAFT,
+                        CraftingAspectWriteBuilders.PROP_IGNORE_STORAGE, ValueTypeBoolean.ValueBoolean.of(true));
+            }
+            return writerPos;
+        }
+
+        /**
+         * Create a variable itemstack holding the given crafting recipe.
+         * @param level The level.
+         * @param recipe The name of a vanilla crafting recipe.
+         * @return The variable itemstack, or an empty itemstack if the recipe does not exist.
+         */
+        public static ItemStack createRecipeVariable(ServerLevel level, ResourceLocation recipe) {
+            try {
+                return GameTestHelpersIntegratedCrafting.createVariableForRecipe(level, RecipeType.CRAFTING, recipe);
+            } catch (RuntimeException e) {
+                org.cyclops.integratedcrafting.IntegratedCrafting.clog(org.apache.logging.log4j.Level.WARN,
+                        "Skipping unknown crafting recipe " + recipe + " in benchmark preset generation");
+                return ItemStack.EMPTY;
+            }
+        }
+
+        /*
+         * Presets
+         */
+
+        /**
+         * Generate a grid where every cell holds a crafting table with an idle crafting interface in front of it,
+         * each holding a single recipe.
+         * Nothing ever requests a craft here, so this isolates the standing cost of crafting interfaces:
+         * their part ticks, their recipe registrations, and their presence in the crafting network.
+         */
+        public static void generateInterfacesIdle(ServerLevel level, BlockPos startPos, int size) {
+            generateInterfacesIdle(level, startPos, size, 1);
+        }
+
+        /**
+         * As {@link #generateInterfacesIdle}, but with every crafting interface completely filled with recipes.
+         * Compared to {@link #generateInterfacesIdle}, this scales up the network's recipe index
+         * without changing the number of parts.
+         */
+        public static void generateInterfacesIdleRecipes(ServerLevel level, BlockPos startPos, int size) {
+            generateInterfacesIdle(level, startPos, size, RECIPES_PER_INTERFACE);
+        }
+
+        private static void generateInterfacesIdle(ServerLevel level, BlockPos startPos, int size, int recipesPerInterface) {
+            generateEmptyGrid(level, startPos, size);
+
+            List<BlockPos> cells = getCells(startPos, size);
+            for (int i = 0; i < cells.size(); i++) {
+                placeCrafterCell(level, cells.get(i), getRecipes(i, recipesPerInterface));
+            }
+
+            updateCells(level, cells);
+        }
+
+        /**
+         * @param offset The offset within {@link #ALL_RECIPES} to start from.
+         * @param count The number of recipes to collect.
+         * @return The recipes at the given offset.
+         */
+        private static List<ResourceLocation> getRecipes(int offset, int count) {
+            List<ResourceLocation> recipes = Lists.newArrayList();
+            for (int i = 0; i < count; i++) {
+                recipes.add(ALL_RECIPES.get(Math.floorMod(offset * count + i, ALL_RECIPES.size())));
+            }
+            return recipes;
+        }
+
+        /**
+         * Generate a grid where crafting writers continuously request items
+         * that are crafted out of planks that are already present in network storage.
+         * This isolates the cost of scheduling and executing a stream of single-step crafting jobs.
+         */
+        public static void generateCraftSimple(ServerLevel level, BlockPos startPos, int size) {
+            generateCrafting(level, startPos, size, CHAINS, false, 1, false);
+        }
+
+        /**
+         * Generate a grid where crafting writers continuously request items whose ingredients
+         * are themselves not in storage, and must first be crafted out of logs.
+         * Compared to {@link #generateCraftSimple}, every request additionally has to resolve
+         * and schedule a dependency graph of crafting jobs.
+         */
+        public static void generateCraftNested(ServerLevel level, BlockPos startPos, int size) {
+            generateCrafting(level, startPos, size, CHAINS_NESTED, true, 1, false);
+        }
+
+        /**
+         * As {@link #generateCraftSimple}, but with every crafting interface completely filled with recipes.
+         * This scales up the network's recipe index, which every crafting job calculation has to search.
+         */
+        public static void generateCraftRecipeIndex(ServerLevel level, BlockPos startPos, int size) {
+            generateCrafting(level, startPos, size, CHAINS, false, RECIPES_PER_INTERFACE, false);
+        }
+
+        /**
+         * As {@link #generateCraftSimple}, but with writers that request an item that is already in storage.
+         * No crafting job is ever scheduled, so this isolates the cost that a crafting writer pays
+         * per tick just to determine that there is nothing to do.
+         */
+        public static void generateCraftSatisfiedIdle(ServerLevel level, BlockPos startPos, int size) {
+            generateCrafting(level, startPos, size, CHAINS, false, 1, true);
+        }
+
+        /**
+         * Generate a grid of repeating four-cell units.
+         *
+         * Every unit is an independent crafting chain, because the crafting writer aspect refuses to
+         * schedule a job for an item that the network is already crafting: if all units requested the
+         * same item, only one of them would ever cause load.
+         *
+         * A non-nested unit is laid out as two storage cells, one crafter cell and one writer cell.
+         * A nested unit trades one storage cell for a second crafter cell, which holds the planks recipe
+         * that the requested recipe depends on.
+         *
+         * @param level The level.
+         * @param startPos The lowest corner of the grid.
+         * @param size The edge length of the grid.
+         * @param chains The crafting chains to distribute over the units.
+         * @param nested If the ingredients of the requested item must themselves be crafted.
+         * @param recipesPerInterface The number of recipes to place in every crafting interface.
+         * @param satisfied If the writers should request an item that is already in storage,
+         *                  so that no crafting job is ever scheduled.
+         */
+        private static void generateCrafting(ServerLevel level, BlockPos startPos, int size,
+                                             List<CraftingChain> chains, boolean nested,
+                                             int recipesPerInterface, boolean satisfied) {
+            generateEmptyGrid(level, startPos, size);
+
+            List<BlockPos> cells = getCells(startPos, size);
+            for (int i = 0; i < cells.size(); i++) {
+                BlockPos cell = cells.get(i);
+                int unit = i / 4;
+                CraftingChain chain = chains.get(Math.floorMod(unit, chains.size()));
+                switch (i % 4) {
+                    case 0 -> placeStorageCell(level, cell, nested ? chain.log() : chain.planks());
+                    case 1 -> {
+                        if (nested) {
+                            placeCrafterCell(level, cell, Lists.newArrayList(chain.planksRecipe()));
+                        } else {
+                            placeStorageCell(level, cell, chain.planks());
+                        }
+                    }
+                    case 2 -> placeCrafterCell(level, cell, getUnitRecipes(chain, unit, recipesPerInterface));
+                    case 3 -> placeWriterCell(level, cell,
+                            satisfied ? chain.planks() : chain.getResultItem(), !satisfied);
+                }
+            }
+
+            updateCells(level, cells);
+        }
+
+        /**
+         * @param chain The crafting chain of the unit.
+         * @param unit The index of the unit.
+         * @param count The number of recipes to collect.
+         * @return The recipes of a unit's crafter, always starting with the recipe of the unit's own chain.
+         */
+        private static List<ResourceLocation> getUnitRecipes(CraftingChain chain, int unit, int count) {
+            List<ResourceLocation> recipes = Lists.newArrayList(chain.resultRecipe());
+            for (int i = 1; i < count; i++) {
+                recipes.add(ALL_RECIPES.get(Math.floorMod(unit * count + i, ALL_RECIPES.size())));
+            }
+            return recipes;
+        }
+
+        /*
+         * Validation
+         */
+
+        /**
+         * Collect everything that is wrong with the parts of a generated grid.
+         *
+         * A part that failed to activate, or whose active aspect is in an error state,
+         * silently does nothing while still costing tick time,
+         * which would turn a benchmark preset into an expensive no-op.
+         *
+         * @param level The level.
+         * @param startPos The lowest corner of the grid.
+         * @param size The edge length of the grid.
+         * @return A description of every broken part, empty if all parts are healthy.
+         */
+        public static List<String> getPartProblems(ServerLevel level, BlockPos startPos, int size) {
+            List<String> problems = Lists.newArrayList();
+            for (BlockPos cell : getCells(startPos, size)) {
+                collectPartProblems(level, PartPos.of(level, cell.below(), Direction.UP), problems);
+                Direction sideDirection = getSideCableDirection(level, cell);
+                if (sideDirection != null) {
+                    collectPartProblems(level, PartPos.of(level, cell.relative(sideDirection),
+                            sideDirection.getOpposite()), problems);
+                }
+            }
+            return problems;
+        }
+
+        private static void collectPartProblems(ServerLevel level, PartPos partPos, List<String> problems) {
+            PartHelpers.PartStateHolder<?, ?> partStateHolder = PartHelpers.getPart(partPos);
+            if (partStateHolder == null) {
+                return;
+            }
+            if (partStateHolder.getState() instanceof IPartStateWriter<?> writerState) {
+                if (writerState.isDeactivated()) {
+                    problems.add("Writer part at " + partPos + " is deactivated");
+                } else if (writerState.getActiveAspect() == null) {
+                    problems.add("Writer part at " + partPos + " has no active aspect");
+                } else if (!writerState.getErrors(writerState.getActiveAspect()).isEmpty()) {
+                    problems.add("Writer part at " + partPos + " has aspect errors: "
+                            + writerState.getErrors(writerState.getActiveAspect()).get(0).getString());
+                }
+            }
+            if (partStateHolder.getState() instanceof PartTypeInterfaceCrafting.State craftingState) {
+                for (int slot = 0; slot < craftingState.getInventoryVariables().getContainerSize(); slot++) {
+                    if (!craftingState.getInventoryVariables().getItem(slot).isEmpty()
+                            && !craftingState.isRecipeSlotValid(slot)) {
+                        problems.add("Crafting interface at " + partPos + " has an invalid recipe in slot " + slot
+                                + ": " + craftingState.getRecipeSlotUnlocalizedMessage(slot).getString());
+                    }
+                }
+            }
+        }
+
+        /*
+         * Topology churn
+         */
+
+        /**
+         * Add a crafting table with a crafting interface at the given cell.
+         * This is used to measure the cost of growing a crafting network at runtime.
+         * @param level The level.
+         * @param cell The cell to add a crafting interface for.
+         * @param index The index of the cell, which determines the recipe that the interface receives.
+         */
+        public static void addCraftingInterfaceCell(ServerLevel level, BlockPos cell, int index) {
+            placeCrafterCell(level, cell, getRecipes(index, 1));
+            updateCells(level, Lists.newArrayList(cell));
+        }
+
+        /**
+         * Remove the crafter of the given cell, together with the cable that holds its crafting interface.
+         * This is used to measure the cost of shrinking a crafting network at runtime.
+         * @param level The level.
+         * @param cell The cell to remove.
+         */
+        public static void removeCell(ServerLevel level, BlockPos cell) {
+            // Empty the container before removing it. Even without block drops, a container block
+            // spills its contents as item entities when it is removed, and ticking those entities
+            // would dominate the measurement instead of the network shrinking itself.
+            if (level.getBlockEntity(cell) instanceof Container container) {
+                container.clearContent();
+            }
+            level.destroyBlock(cell, false);
+            level.destroyBlock(cell.below(), false);
+        }
+
+        /**
+         * Remove all blocks that the presets of this command can generate,
+         * within the given radius of the given position.
+         * @param level The level.
+         * @param centerPos The center position.
+         * @param radius The radius to clear.
+         */
+        public static void clearGrid(ServerLevel level, BlockPos centerPos, int radius) {
+            BlockCable.SKIP_NETWORK_INIT = true;
+
+            try {
+                for (int x = centerPos.getX() - radius; x <= centerPos.getX() + radius; x++) {
+                    for (int y = centerPos.getY() - radius; y <= centerPos.getY() + radius; y++) {
+                        for (int z = centerPos.getZ() - radius; z <= centerPos.getZ() + radius; z++) {
+                            BlockPos pos = new BlockPos(x, y, z);
+                            if (isGeneratedBlock(level.getBlockState(pos).getBlock())) {
+                                if (level.getBlockEntity(pos) instanceof Container container) {
+                                    container.clearContent();
+                                }
+                                level.destroyBlock(pos, false);
+                            }
+                        }
+                    }
+                }
+            } finally {
+                BlockCable.SKIP_NETWORK_INIT = false;
+            }
+        }
+
+        /**
+         * @param block A block.
+         * @return If the given block is one that the presets of this command can generate.
+         */
+        private static boolean isGeneratedBlock(Block block) {
+            return block == RegistryEntries.BLOCK_CABLE.value()
+                    || block == Blocks.CHEST
+                    || block == Blocks.CRAFTING_TABLE;
+        }
+    }
+}
diff --git a/src/main/java/org/cyclops/integratedcrafting/gametest/GameTestsPerformance.java b/src/main/java/org/cyclops/integratedcrafting/gametest/GameTestsPerformance.java
new file mode 100644
index 000000000..241572caa
--- /dev/null
+++ b/src/main/java/org/cyclops/integratedcrafting/gametest/GameTestsPerformance.java
@@ -0,0 +1,260 @@
+package org.cyclops.integratedcrafting.gametest;
+
+import com.google.common.math.Stats;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestAssertException;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.util.TimeUtil;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+import org.apache.logging.log4j.Level;
+import org.cyclops.cyclopscore.datastructure.Wrapper;
+import org.cyclops.integratedcrafting.IntegratedCrafting;
+import org.cyclops.integratedcrafting.Reference;
+import org.cyclops.integratedcrafting.command.CommandGenerateCrafting;
+import org.cyclops.integrateddynamics.core.network.diagnostics.NetworkDiagnostics;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+/**
+ * Game tests for performance benchmarking of crafting operations.
+ * These tests generate networks with different presets and measure their performance.
+ * Results are written to runs/gameTestServer/logs/benchmark_results.txt for CI processing.
+ *
+ * These tests only do actual work when the PERFORMANCE_BENCHMARK_ENABLED environment variable is set,
+ * so that regular game test runs are not slowed down by them.
+ *
+ * @author rubensworks
+ */
+@GameTestHolder(Reference.MOD_ID)
+@PrefixGameTestTemplate(false)
+public class GameTestsPerformance {
+
+    public static final int EXECUTION_SECONDS = 30;
+    public static final int WARMUP_TICKS = 200;
+    public static final int TIMEOUT_TICKS = (EXECUTION_SECONDS + 20) * 20;
+    public static final int SIZE = 9; // Max 9, as the grid would otherwise leak out of the template.
+    public static final String TEMPLATE_EMPTY = "empty10";
+    public static final BlockPos START_POS = BlockPos.ZERO;
+
+    /**
+     * The number of cells that are added or removed after warming up, for the churn benchmarks.
+     */
+    public static final int CHURN_CELLS = 50;
+
+    private static final String RESULTS_FILE = "logs/benchmark_results.txt";
+
+    /**
+     * Check if performance benchmarking is enabled via environment variable.
+     *
+     * @return true if PERFORMANCE_BENCHMARK_ENABLED environment variable is set to "true"
+     */
+    private static boolean isBenchmarkingEnabled() {
+        // Check environment variable first
+        String envVar = System.getenv("PERFORMANCE_BENCHMARK_ENABLED");
+        if (envVar != null && "true".equalsIgnoreCase(envVar)) {
+            return true;
+        }
+
+        // Check system property as fallback
+        String sysProp = System.getProperty("PERFORMANCE_BENCHMARK_ENABLED");
+        return sysProp != null && "true".equalsIgnoreCase(sysProp);
+    }
+
+    static {
+        if (isBenchmarkingEnabled()) {
+            // Initialize empty file
+            writeResults(new ArrayList<>(), false);
+        }
+    }
+
+    /*
+     * Crafting interface observation: the standing cost of having crafting interfaces in a network,
+     * without anything ever requesting a craft.
+     */
+
+    @GameTest(template = TEMPLATE_EMPTY, timeoutTicks = TIMEOUT_TICKS, batch = "performance_interfaces_crafting_idle")
+    public void testPerformanceCraftingInterfacesIdle(GameTestHelper helper) {
+        testPerformance(helper, "interfaces_crafting_idle", (measureServerTickTimeNow) ->
+                CommandGenerateCrafting.CraftingGenerationHelper.generateInterfacesIdle(helper.getLevel(), helper.absolutePos(START_POS), SIZE));
+    }
+
+    @GameTest(template = TEMPLATE_EMPTY, timeoutTicks = TIMEOUT_TICKS, batch = "performance_interfaces_crafting_idle_recipes")
+    public void testPerformanceCraftingInterfacesIdleRecipes(GameTestHelper helper) {
+        testPerformance(helper, "interfaces_crafting_idle_recipes", (measureServerTickTimeNow) ->
+                CommandGenerateCrafting.CraftingGenerationHelper.generateInterfacesIdleRecipes(helper.getLevel(), helper.absolutePos(START_POS), SIZE));
+    }
+
+    @GameTest(template = TEMPLATE_EMPTY, timeoutTicks = TIMEOUT_TICKS, batch = "performance_craft_satisfied_idle")
+    public void testPerformanceCraftSatisfiedIdle(GameTestHelper helper) {
+        testPerformance(helper, "craft_satisfied_idle", (measureServerTickTimeNow) ->
+                CommandGenerateCrafting.CraftingGenerationHelper.generateCraftSatisfiedIdle(helper.getLevel(), helper.absolutePos(START_POS), SIZE));
+    }
+
+    /*
+     * Active crafting: the cost of continuously scheduling and executing crafting jobs.
+     */
+
+    @GameTest(template = TEMPLATE_EMPTY, timeoutTicks = TIMEOUT_TICKS, batch = "performance_craft_simple")
+    public void testPerformanceCraftSimple(GameTestHelper helper) {
+        testPerformance(helper, "craft_simple", (measureServerTickTimeNow) ->
+                CommandGenerateCrafting.CraftingGenerationHelper.generateCraftSimple(helper.getLevel(), helper.absolutePos(START_POS), SIZE));
+    }
+
+    @GameTest(template = TEMPLATE_EMPTY, timeoutTicks = TIMEOUT_TICKS, batch = "performance_craft_nested")
+    public void testPerformanceCraftNested(GameTestHelper helper) {
+        testPerformance(helper, "craft_nested", (measureServerTickTimeNow) ->
+                CommandGenerateCrafting.CraftingGenerationHelper.generateCraftNested(helper.getLevel(), helper.absolutePos(START_POS), SIZE));
+    }
+
+    /*
+     * Recipe index scaling: the cost of crafting while the network's recipe index is large.
+     */
+
+    @GameTest(template = TEMPLATE_EMPTY, timeoutTicks = TIMEOUT_TICKS, batch = "performance_craft_recipe_index")
+    public void testPerformanceCraftRecipeIndex(GameTestHelper helper) {
+        testPerformance(helper, "craft_recipe_index", (measureServerTickTimeNow) ->
+                CommandGenerateCrafting.CraftingGenerationHelper.generateCraftRecipeIndex(helper.getLevel(), helper.absolutePos(START_POS), SIZE));
+    }
+
+    /*
+     * Topology churn: the cost of registering and unregistering crafting interfaces in the crafting network.
+     */
+
+    @GameTest(template = TEMPLATE_EMPTY, timeoutTicks = TIMEOUT_TICKS, batch = "performance_interfaces_crafting_append")
+    public void testPerformanceCraftingInterfacesAppend(GameTestHelper helper) {
+        testPerformance(helper, "interfaces_crafting_append", (measureServerTickTimeNow) -> {
+            CommandGenerateCrafting.CraftingGenerationHelper.generateEmptyGrid(helper.getLevel(), helper.absolutePos(START_POS), SIZE);
+            addInterfacesPostWarmup(helper, CHURN_CELLS, WARMUP_TICKS);
+            // Measure server tick time right after the interfaces have been added
+            helper.runAfterDelay(WARMUP_TICKS + CHURN_CELLS, measureServerTickTimeNow);
+        });
+    }
+
+    @GameTest(template = TEMPLATE_EMPTY, timeoutTicks = TIMEOUT_TICKS, batch = "performance_interfaces_crafting_remove")
+    public void testPerformanceCraftingInterfacesRemove(GameTestHelper helper) {
+        testPerformance(helper, "interfaces_crafting_remove", (measureServerTickTimeNow) -> {
+            CommandGenerateCrafting.CraftingGenerationHelper.generateInterfacesIdle(helper.getLevel(), helper.absolutePos(START_POS), SIZE);
+            removeInterfacesPostWarmup(helper, CHURN_CELLS, WARMUP_TICKS);
+            // Measure server tick time right after the interfaces have been removed
+            helper.runAfterDelay(WARMUP_TICKS + CHURN_CELLS, measureServerTickTimeNow);
+        });
+    }
+
+    /**
+     * Construct the given network, let it warm up, and measure its performance for {@link #EXECUTION_SECONDS}.
+     * @param helper The game test helper.
+     * @param networkName The name of the network preset, used as benchmark identifier.
+     * @param networkConstructor Constructs the network.
+     *                           It is passed a runnable that captures the server tick time at the moment it is called,
+     *                           which is useful for presets that only cause load during a part of the measurement.
+     */
+    public static void testPerformance(GameTestHelper helper, String networkName, Consumer<Runnable> networkConstructor) {
+        if (!isBenchmarkingEnabled()) {
+            IntegratedCrafting.clog(Level.INFO, "Performance benchmarking disabled (PERFORMANCE_BENCHMARK_ENABLED not set)");
+            helper.succeed();
+            return;
+        }
+
+        ensureResultsDirectory();
+
+        // Calculate average server-wide tick time
+        Wrapper<Double> avgServerTickTime = new Wrapper<>(0D);
+        Runnable measureServerTickTimeNow = () -> avgServerTickTime.set(Stats.meanOf(helper.getLevel().getServer().getTickTimesNanos()) / TimeUtil.NANOSECONDS_PER_MILLISECOND);
+        networkConstructor.accept(measureServerTickTimeNow);
+
+        // Measure the network performance
+        String measurementId = networkName + "_" + System.currentTimeMillis();
+        Wrapper<UUID> measurementUUID = new Wrapper<>();
+        helper.runAfterDelay(WARMUP_TICKS, () -> {
+            // Wait a few seconds to warm up the code before starting measurement
+            measurementUUID.set(NetworkDiagnostics.getInstance().startMeasurementWithoutPlayer(measurementId, EXECUTION_SECONDS));
+        });
+
+        // Assert that all generated parts actually activated, right after the warmup.
+        // A part that silently failed to activate would still cost tick time,
+        // which would turn this benchmark into an expensive no-op.
+        helper.runAfterDelay(WARMUP_TICKS, () -> {
+            List<String> problems = CommandGenerateCrafting.CraftingGenerationHelper
+                    .getPartProblems(helper.getLevel(), helper.absolutePos(START_POS), SIZE);
+            if (!problems.isEmpty()) {
+                throw new GameTestAssertException("Preset " + networkName + " generated " + problems.size()
+                        + " broken parts, first: " + problems.get(0));
+            }
+        });
+
+        // Wait for measurement to complete, then retrieve results
+        helper.succeedWhen(() -> {
+            if (measurementUUID.get() == null || !NetworkDiagnostics.getInstance().isMeasurementComplete(measurementUUID.get())) {
+                throw new GameTestAssertException("Measurement did not complete in time: " + measurementId);
+            }
+
+            double avgTickTime = NetworkDiagnostics.getInstance().getMeasurementAverageTickTime(measurementUUID.get());
+            NetworkDiagnostics.getInstance().clearMeasurement(measurementUUID.get());
+
+            // Calculate average server-wide tick time
+            if (avgServerTickTime.get() == 0D) {
+                measureServerTickTimeNow.run();
+            }
+
+            List<String> results = new ArrayList<>();
+            results.add(String.format("preset=%s size=%d avgNetworkTickTime=%.2f avgServerTickTime=%.2f", networkName, SIZE, avgTickTime, avgServerTickTime.get()));
+            writeResults(results, true);
+
+            CommandGenerateCrafting.CraftingGenerationHelper.clearGrid(helper.getLevel(), helper.absolutePos(START_POS), SIZE);
+        });
+    }
+
+    private static void ensureResultsDirectory() {
+        try {
+            Files.createDirectories(Paths.get("logs"));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static synchronized void writeResults(List<String> results, boolean append) {
+        try {
+            String content = String.join("\n", results);
+            if (append && Files.exists(Paths.get(RESULTS_FILE))) {
+                String existingString = Files.readString(Paths.get(RESULTS_FILE));
+                content = (existingString.isEmpty() ? content : existingString + content) + "\n";
+            }
+            Files.write(Paths.get(RESULTS_FILE), content.getBytes());
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Add one crafting table with a crafting interface per tick, starting at the given delay.
+     */
+    private static void addInterfacesPostWarmup(GameTestHelper helper, int count, int delayOffset) {
+        List<BlockPos> cells = CommandGenerateCrafting.CraftingGenerationHelper.getCells(helper.absolutePos(START_POS), SIZE);
+        for (int i = 0; i < Math.min(count, cells.size()); i++) {
+            final BlockPos cell = cells.get(i);
+            final int index = i;
+            helper.runAfterDelay(delayOffset + i, () -> CommandGenerateCrafting.CraftingGenerationHelper
+                    .addCraftingInterfaceCell(helper.getLevel(), cell, index));
+        }
+    }
+
+    /**
+     * Remove one crafting table with its crafting interface per tick, starting at the given delay.
+     */
+    private static void removeInterfacesPostWarmup(GameTestHelper helper, int count, int delayOffset) {
+        List<BlockPos> cells = CommandGenerateCrafting.CraftingGenerationHelper.getCells(helper.absolutePos(START_POS), SIZE);
+        for (int i = 0; i < Math.min(count, cells.size()); i++) {
+            final BlockPos cell = cells.get(i);
+            helper.runAfterDelay(delayOffset + i, () -> CommandGenerateCrafting.CraftingGenerationHelper
+                    .removeCell(helper.getLevel(), cell));
+        }
+    }
+}