feat(v26.7-Alpha.4): network stack adapter - MC custom payload construction

- NetworkStackAdapter: reflectively builds CustomPacketPayload instances
  for Aprism channels (createType factory / Type record over Identifier;
  proxy-backed payload impl returning the typed channel). Payload bytes
  ride FriendlyByteBuf at the live transport seam.
- Fail-closed: reflection misses return null instead of throwing.
- Test-sourceset network stubs (CustomPacketPayload + FriendlyByteBuf);
  3 unit tests covering channel typing, interface conformance, null checks.
- Version bumped to v26.7-Alpha.4.

Author: StarsailsClover

aprism-loader-core/src/main/java/com/aprism/loader/contentbind/NetworkStackAdapter.java

@@ -0,0 +1,104 @@
+package com.aprism.loader.contentbind;
+
+import java.lang.reflect.Constructor;
+import java.util.Objects;
+import java.util.logging.Logger;
+// GitHub@NDBlockConnect | BlockConnect@StarsailsClover
+
+/**
+ * Reflective adapter onto Minecraft's custom-payload network stack
+ * (v26.7-Alpha.4).
+ *
+ * <p>Target surface (official 26.x names):
+ * {@code CustomPacketPayload.createType(String)} builds the channel type,
+ * {@code CustomPayloadType} is its record form over {@code Identifier}, and
+ * {@code FriendlyByteBuf(Unpooled.buffer())} carries the payload bytes.
+ * The adapter constructs payload instances for Aprism channels so a live
+ * connection can send them once the transport seam discovers a
+ * {@code Connection}/{@code PacketListener}.
+ *
+ * <p>Fail-closed: reflection misses refuse instead of throwing; the class
+ * never touches IO or threads itself.
+ *
+ * @author BlockConnect@StarsailsClover
+ */
+public final class NetworkStackAdapter {
+// GitHub@NDBlockConnect | BlockConnect@StarsailsClover
+
+    private static final Logger LOG = Logger.getLogger("aprism.contentbind");
+
+    private static final String PAYLOAD_CLASS =
+            "net.minecraft.network.protocol.common.custom.CustomPacketPayload";
+    private static final String TYPE_CLASS =
+            "net.minecraft.network.protocol.common.custom.CustomPacketPayload$Type";
+    private static final String IDENTIFIER_CLASS =
+            "net.minecraft.resources.Identifier";
+
+    /** A constructed MC payload ready for a live connection to send. */
+    public record McPayload(Object payload, Object type) {
+    }
+
+    /**
+     * Builds a {@code CustomPacketPayload} carrying {@code bytes} on the
+     * given Aprism channel ({@code aprism:<channel>}).
+     *
+     * @param channel the channel name (no namespace)
+     * @param bytes   the raw payload body
+     * @return the constructed payload, or null when the MC surface is absent
+     */
+    public McPayload buildPayload(String channel, byte[] bytes) {
+        Objects.requireNonNull(channel, "channel");
+        Objects.requireNonNull(bytes, "bytes");
+        try {
+            ClassLoader loader = getClass().getClassLoader();
+            Class<?> payloadClass = loader.loadClass(PAYLOAD_CLASS);
+            Class<?> typeClass = loader.loadClass(TYPE_CLASS);
+            Object type = buildType(typeClass, "aprism:" + channel);
+            if (type == null) {
+                return null;
+            }
+            // Anonymous payload impl: proxy the interface returning our type;
+            // stream codec handling stays with the live transport seam.
+            Object payload = java.lang.reflect.Proxy.newProxyInstance(
+                    loader, new Class<?>[] {payloadClass},
+                    (proxy, method, args) -> switch (method.getName()) {
+                        case "type" -> type;
+                        case "toString" -> "AprismPayload[" + channel + "]";
+                        case "hashCode" -> System.identityHashCode(proxy);
+                        case "equals" -> proxy == args[0];
+                        default -> null;
+                    });
+            return new McPayload(payload, type);
+        } catch (ReflectiveOperationException | RuntimeException e) {
+            LOG.warning("NetworkStackAdapter: payload construction failed: "
+                    + e.getMessage());
+            return null;
+        }
+    }
+// GitHub@NDBlockConnect | BlockConnect@StarsailsClover
+
+    private static Object buildType(Class<?> typeClass, String combined)
+            throws ReflectiveOperationException {
+        // Prefer the createType factory (validates the identifier), then the
+        // record constructor over Identifier.
+        try {
+            return typeClass.getClassLoader()
+                    .loadClass(PAYLOAD_CLASS)
+                    .getMethod("createType", String.class)
+                    .invoke(null, combined);
+        } catch (NoSuchMethodException ignored) {
+            // fall through to the record ctor
+        }
+        Class<?> identifier = typeClass.getClassLoader().loadClass(IDENTIFIER_CLASS);
+        Constructor<?> idCtor;
+        try {
+            idCtor = identifier.getConstructor(String.class, String.class);
+        } catch (NoSuchMethodException e) {
+            return null; // parse-only variants need splitting; not required yet
+        }
+        int sep = combined.indexOf(':');
+        Object id = idCtor.newInstance(combined.substring(0, sep),
+                combined.substring(sep + 1));
+        return typeClass.getConstructor(identifier).newInstance(id);
+    }
+}

aprism-loader-core/src/test/java/com/aprism/loader/contentbind/NetworkStackAdapterTest.java

@@ -0,0 +1,47 @@
+package com.aprism.loader.contentbind;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+// GitHub@NDBlockConnect | BlockConnect@StarsailsClover
+
+/**
+ * Tests for {@link NetworkStackAdapter} against test-sourceset network
+ * stubs (live-connection send lands with the transport discovery seam).
+ */
+class NetworkStackAdapterTest {
+
+    @Test
+    void buildsPayloadWithAprismTypedChannel() {
+        NetworkStackAdapter adapter = new NetworkStackAdapter();
+        NetworkStackAdapter.McPayload payload =
+                adapter.buildPayload("sync_test", new byte[] {1, 2, 3});
+
+        assertNotNull(payload);
+        assertNotNull(payload.type());
+        var type = (net.minecraft.network.protocol.common.custom
+                .CustomPacketPayload.Type<?>) payload.type();
+        assertEquals("aprism", type.id().getNamespace());
+        assertEquals("sync_test", type.id().getPath());
+    }
+
+    @Test
+    void payloadProxyImplementsMcInterface() {
+        NetworkStackAdapter.McPayload payload =
+                new NetworkStackAdapter().buildPayload("ping", new byte[0]);
+        assertInstanceOf(net.minecraft.network.protocol.common.custom
+                .CustomPacketPayload.class, payload.payload());
+        assertSame(payload.type(),
+                ((net.minecraft.network.protocol.common.custom.CustomPacketPayload)
+                        payload.payload()).type());
+    }
+
+    @Test
+    void rejectsNullInputs() {
+        NetworkStackAdapter adapter = new NetworkStackAdapter();
+        assertThrows(NullPointerException.class,
+                () -> adapter.buildPayload(null, new byte[0]));
+        assertThrows(NullPointerException.class,
+                () -> adapter.buildPayload("ch", null));
+    }
+}

aprism-loader-core/src/test/java/net/minecraft/network/FriendlyByteBuf.java

@@ -0,0 +1,19 @@
+package net.minecraft.network;
+
+/**
+ * Test-sourceset stub of MC FriendlyByteBuf (v26.7-Alpha.4). NOT shipped.
+ *
+ * <!-- GitHub@NDBlockConnect | BlockConnect@StarsailsClover -->
+ */
+public class FriendlyByteBuf {
+
+    private final byte[] data = new byte[0];
+
+    public FriendlyByteBuf writeByteArray(byte[] bytes) {
+        return this;
+    }
+
+    public byte[] readByteArray() {
+        return data;
+    }
+}

aprism-loader-core/src/test/java/net/minecraft/network/protocol/common/custom/CustomPacketPayload.java

@@ -0,0 +1,22 @@
+package net.minecraft.network.protocol.common.custom;
+
+import net.minecraft.resources.Identifier;
+
+/**
+ * Test-sourceset stub of MC CustomPacketPayload (v26.7-Alpha.4). NOT shipped.
+ *
+ * <!-- GitHub@NDBlockConnect | BlockConnect@StarsailsClover -->
+ */
+public interface CustomPacketPayload {
+
+    Type<? extends CustomPacketPayload> type();
+
+    static <T extends CustomPacketPayload> Type<T> createType(String combined) {
+        int sep = combined.indexOf(':');
+        return new Type<>(new Identifier(combined.substring(0, sep),
+                combined.substring(sep + 1)));
+    }
+
+    record Type<T extends CustomPacketPayload>(Identifier id) {
+    }
+}

gradle.properties

@@ -2,7 +2,7 @@
 # Author: BlockConnect@StarsailsClover
 
 # Aprism version (public): v<Year>.<minor>[-Alpha.<n>]
-aprismVersion = v26.7-Alpha.3
+aprismVersion = v26.7-Alpha.4
 # Internal phase tracker (not shown in public version strings)
 aprismPhase = Phase0
 aprismGroup = com.aprism