chore: update to 1.20.5

build.gradle.kts

@@ -1,16 +1,35 @@
-import io.gitlab.jfronny.scripts.*
-
 plugins {
-    id("jfmod") version "1.3-SNAPSHOT"
+    id("jfmod") version "1.6-SNAPSHOT"
+}
+
+allprojects { group = "io.gitlab.jfronny" }
+base.archivesName = "better-whitelist"
+
+val muscriptVersion = "1.7-SNAPSHOT"
+jfMod {
+    minecraftVersion = "1.20.5"
+    yarn("build.1")
+    loaderVersion = "0.15.10"
+    libJfVersion = "3.15.5"
+    fabricApiVersion = "0.97.6+1.20.5"
+
+    modrinth {
+        projectId = "better-whitelist"
+        requiredDependencies.addAll("fabric-api", "libjf")
+    }
 }
 
 dependencies {
-    modImplementation(fabricApi.module("fabric-networking-api-v1", prop("fabric_version")))
-    modImplementation(fabricApi.module("fabric-command-api-v2", prop("fabric_version")))
-    include(modImplementation("io.gitlab.jfronny:muscript:${prop("muscript_version")}")!!)
-    modImplementation("io.gitlab.jfronny.libjf:libjf-base:${prop("libjf_version")}")
+    modImplementation("net.fabricmc.fabric-api:fabric-networking-api-v1")
+    modImplementation("net.fabricmc.fabric-api:fabric-command-api-v2")
+    include(modImplementation("io.gitlab.jfronny:muscript-all:$muscriptVersion")!!)
+    modImplementation("io.gitlab.jfronny.libjf:libjf-base")
 
     // Dev env
-    modLocalRuntime("io.gitlab.jfronny.libjf:libjf-devutil:${prop("libjf_version")}")
-    modLocalRuntime("com.terraformersmc:modmenu:${prop("modmenu_version")}")
+    modLocalRuntime("io.gitlab.jfronny.libjf:libjf-devutil")
+    modLocalRuntime("com.terraformersmc:modmenu:10.0.0-beta.1")
+    // for modmenu
+    modLocalRuntime("net.fabricmc.fabric-api:fabric-resource-loader-v0")
+    modLocalRuntime("net.fabricmc.fabric-api:fabric-screen-api-v1")
+    modLocalRuntime("net.fabricmc.fabric-api:fabric-key-binding-api-v1")
 }

gradle.properties

@@ -1,15 +0,0 @@
-# https://fabricmc.net/develop/
-minecraft_version=1.19.4
-yarn_mappings=build.1
-loader_version=0.14.17
-
-maven_group=io.gitlab.jfronny
-archives_base_name=better-whitelist
-
-modrinth_id=better-whitelist
-modrinth_required_dependencies=libjf, fabric-api
-
-libjf_version=3.6.0
-fabric_version=0.75.3+1.19.4
-modmenu_version=6.1.0-rc.1
-muscript_version=1.2-SNAPSHOT

src/client/java/io/gitlab/jfronny/betterwhitelist/client/BetterWhitelistClient.java

@@ -1,11 +1,16 @@
 package io.gitlab.jfronny.betterwhitelist.client;
 
 import io.gitlab.jfronny.betterwhitelist.BetterWhitelist;
-import io.gitlab.jfronny.muscript.compiler.Parser;
-import io.gitlab.jfronny.muscript.data.Scope;
+import io.gitlab.jfronny.betterwhitelist.DSerializer;
+import io.gitlab.jfronny.betterwhitelist.packet.ChallengePacket;
+import io.gitlab.jfronny.betterwhitelist.packet.HandshakePacket;
+import io.gitlab.jfronny.muscript.core.MuScriptVersion;
+import io.gitlab.jfronny.muscript.data.additional.DFinal;
+import io.gitlab.jfronny.muscript.data.additional.context.Scope;
 import io.gitlab.jfronny.muscript.data.dynamic.DCallable;
 import io.gitlab.jfronny.muscript.data.dynamic.Dynamic;
-import io.gitlab.jfronny.muscript.data.dynamic.additional.DFinal;
+import io.gitlab.jfronny.muscript.parser.Parser;
+import io.gitlab.jfronny.muscript.runtime.Runtime;
 import net.fabricmc.api.*;
 import net.fabricmc.fabric.api.client.networking.v1.ClientLoginNetworking;
 import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
@@ -16,38 +21,41 @@ import net.minecraft.text.TextContent;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
+import static io.gitlab.jfronny.muscript.ast.context.ExprUtils.asDynamic;
+
 @Environment(EnvType.CLIENT)
 public class BetterWhitelistClient implements ClientModInitializer {
     @Override
     public void onInitializeClient() {
+        BetterWhitelist.initialize();
+
         ClientLoginNetworking.registerGlobalReceiver(BetterWhitelist.HANDSHAKE_CHANNEL, (client, handler, buf, listenerAdder) -> {
             // buf also contains the server version
             PacketByteBuf resultBuf = PacketByteBufs.create();
-            resultBuf.writeInt(BetterWhitelist.PROTOCOL_VERSION);
+            HandshakePacket.CODEC.encode(resultBuf, new HandshakePacket(BetterWhitelist.PROTOCOL_VERSION));
             return CompletableFuture.completedFuture(resultBuf);
         });
 
         ClientLoginNetworking.registerGlobalReceiver(BetterWhitelist.CHALLENGE_CHANNEL, (client, handler, buf, listenerAdder) -> {
+            ChallengePacket packet = ChallengePacket.CODEC.decode(buf);
             Scope fork = BetterWhitelist.SCOPE.fork();
             fork.set("resourcePacks", MinecraftClient.getInstance()
                     .getResourcePackManager()
                     .getEnabledProfiles()
                     .stream()
                     .map(s -> DFinal.of(Map.of(
-                            "name", DFinal.of(s.getName()),
+                            "name", DFinal.of(s.getId()),
                             "displayName", DFinal.of(toString(s.getDisplayName().getContent())),
                             "description", DFinal.of(toString(s.getDescription().getContent()))
                     )))
                     .toList());
-            String scriptSource = buf.readString();
-            BetterWhitelist.LOG.info("Received challenge: " + scriptSource);
-            DCallable script = Parser.parse(scriptSource).asDynamicExpr().get(fork).asCallable();
-            int paramSize = buf.readInt();
-            List<Dynamic<?>> params = new LinkedList<>();
-            for (int i = 0; i < paramSize; i++) {
-                params.add(Parser.parse(buf.readString()).asDynamicExpr().get(fork));
+            BetterWhitelist.LOG.info("Received challenge: " + packet.challenge());
+            DCallable script = Runtime.evaluate(asDynamic(Parser.parse(MuScriptVersion.DEFAULT, packet.challenge())), fork).asCallable();
+            List<Dynamic> params = new LinkedList<>();
+            for (String param : packet.params()) {
+                params.add(Runtime.evaluate(asDynamic(Parser.parse(MuScriptVersion.DEFAULT, param)), fork));
             }
-            String resultString = Dynamic.serialize(script.call(DFinal.of(params)));
+            String resultString = DSerializer.serialize(script.call(DFinal.of(params)));
             BetterWhitelist.LOG.info("Sending result: " + resultString);
             PacketByteBuf resultBuf = PacketByteBufs.create();
             resultBuf.writeString(resultString);

src/main/java/io/gitlab/jfronny/betterwhitelist/BetterWhitelist.java

@@ -1,10 +1,15 @@
 package io.gitlab.jfronny.betterwhitelist;
 
-import io.gitlab.jfronny.commons.log.Logger;
-import io.gitlab.jfronny.muscript.StandardLib;
-import io.gitlab.jfronny.muscript.data.Scope;
+import io.gitlab.jfronny.betterwhitelist.packet.ChallengePacket;
+import io.gitlab.jfronny.betterwhitelist.packet.ChallengeResponsePacket;
+import io.gitlab.jfronny.betterwhitelist.packet.HandshakePacket;
+import io.gitlab.jfronny.commons.logger.SystemLoggerPlus;
+import io.gitlab.jfronny.muscript.core.MuScriptVersion;
+import io.gitlab.jfronny.muscript.data.additional.DFinal;
+import io.gitlab.jfronny.muscript.data.additional.context.Scope;
+import io.gitlab.jfronny.muscript.data.additional.libs.StandardLib;
 import io.gitlab.jfronny.muscript.data.dynamic.*;
-import io.gitlab.jfronny.muscript.data.dynamic.additional.DFinal;
+import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
 import net.fabricmc.loader.api.FabricLoader;
 import net.fabricmc.loader.api.ModContainer;
 import net.fabricmc.loader.api.metadata.ModDependency;
@@ -14,16 +19,16 @@ import net.minecraft.util.Identifier;
 import java.util.Map;
 import java.util.stream.Collectors;
 
-import static io.gitlab.jfronny.muscript.data.dynamic.additional.DFinal.of;
+import static io.gitlab.jfronny.muscript.data.additional.DFinal.of;
 
 public class BetterWhitelist {
     public static final String MOD_ID = "better-whitelist";
-    public static final Logger LOG = Logger.forName(MOD_ID);
+    public static final SystemLoggerPlus LOG = SystemLoggerPlus.forName(MOD_ID);
     public static final Identifier HANDSHAKE_CHANNEL = new Identifier(MOD_ID, "handshake");
     public static final Identifier CHALLENGE_CHANNEL = new Identifier(MOD_ID, "challenge");
     public static final int PROTOCOL_VERSION = 1;
     public static final ModMetadata MOD_METADATA = FabricLoader.getInstance().getModContainer(MOD_ID).orElseThrow().getMetadata();
-    public static final Scope SCOPE = StandardLib.createScope();
+    public static final Scope SCOPE = StandardLib.createScope(MuScriptVersion.DEFAULT);
 
     static {
         SCOPE.set("mods", FabricLoader.getInstance()
@@ -37,31 +42,35 @@ public class BetterWhitelist {
             if (args.size() != 1) throw new IllegalArgumentException("Invalid number of arguments for mod: expected 1 but got " + args.size());
             return FabricLoader.getInstance()
                     .getModContainer(args.get(0).asString().getValue())
-                    .<Dynamic<?>>map(BetterWhitelist::wrap)
+                    .<Dynamic>map(BetterWhitelist::wrap)
                     .orElse(new DNull());
         }).set("println", args -> {
-            String s = args.size() == 0 ? "" : args.size() == 1 ? args.get(0).asString().getValue() : args.toString();
+            String s = args.isEmpty() ? "" : args.size() == 1 ? args.get(0).asString().getValue() : args.toString();
             System.out.println(s);
             return of(s);
         });
     }
 
+    public static void initialize() {
+        // Initialization for things like registering packet types would go here
+    }
+
     private static DObject wrap(ModContainer mod) {
         return of(Map.of(
                 "id", of(mod.getMetadata().getId()),
                 "name", of(mod.getMetadata().getName()),
                 "description", of(mod.getMetadata().getDescription()),
-                "authors", of(mod.getMetadata().getAuthors().stream().<Dynamic<?>>map(s -> of(s.getName())).toList()),
-                "contributors", of(mod.getMetadata().getContributors().stream().<Dynamic<?>>map(s -> of(s.getName())).toList()),
+                "authors", of(mod.getMetadata().getAuthors().stream().map(s -> of(s.getName())).toList()),
+                "contributors", of(mod.getMetadata().getContributors().stream().map(s -> of(s.getName())).toList()),
                 "version", of(mod.getMetadata().getVersion().getFriendlyString()),
                 "environment", of(switch (mod.getMetadata().getEnvironment()) {
                     case CLIENT -> "client";
                     case SERVER -> "server";
                     case UNIVERSAL -> "*";
                 }),
-                "license", of(mod.getMetadata().getLicense().stream().<Dynamic<?>>map(DFinal::of).toList()),
+                "license", of(mod.getMetadata().getLicense().stream().map(DFinal::of).toList()),
                 "contact", of(mod.getMetadata().getContact().asMap().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, a -> of(a.getValue())))),
-                "depends", of(mod.getMetadata().getDependencies().stream().filter(v -> v.getKind() == ModDependency.Kind.DEPENDS).<Dynamic<?>>map(s -> of(s.getModId())).toList())
+                "depends", of(mod.getMetadata().getDependencies().stream().filter(v -> v.getKind() == ModDependency.Kind.DEPENDS).map(s -> of(s.getModId())).toList())
         ));
     }
 }

src/main/java/io/gitlab/jfronny/betterwhitelist/DSerializer.java

@@ -0,0 +1,25 @@
+package io.gitlab.jfronny.betterwhitelist;
+
+import io.gitlab.jfronny.muscript.ast.DynamicExpr;
+import io.gitlab.jfronny.muscript.ast.context.ExprUtils;
+import io.gitlab.jfronny.muscript.core.MuScriptVersion;
+import io.gitlab.jfronny.muscript.data.additional.DataExprMapper;
+import io.gitlab.jfronny.muscript.data.additional.libs.StandardLib;
+import io.gitlab.jfronny.muscript.data.dynamic.Dynamic;
+import io.gitlab.jfronny.muscript.parser.Parser;
+import io.gitlab.jfronny.muscript.runtime.Runtime;
+import io.gitlab.jfronny.muscript.serialize.Decompiler;
+
+import static io.gitlab.jfronny.muscript.ast.context.ExprUtils.asDynamic;
+
+public class DSerializer {
+    public static String serialize(Dynamic d) {
+        return Decompiler.decompile(DataExprMapper.map(d));
+    }
+
+    public static Dynamic deserialize(String s) {
+        DynamicExpr dynamicExpr = asDynamic(Parser.parse(MuScriptVersion.DEFAULT, s));
+        if (!ExprUtils.isDirect(dynamicExpr)) throw new RuntimeException("Invalid dynamic");
+        return Runtime.evaluate(dynamicExpr, StandardLib.createScope(MuScriptVersion.DEFAULT));
+    }
+}

src/main/java/io/gitlab/jfronny/betterwhitelist/packet/ChallengePacket.java

@@ -0,0 +1,23 @@
+package io.gitlab.jfronny.betterwhitelist.packet;
+
+import io.gitlab.jfronny.betterwhitelist.BetterWhitelist;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.network.PacketByteBuf;
+import net.minecraft.network.codec.PacketCodec;
+import net.minecraft.network.codec.PacketCodecs;
+import net.minecraft.network.packet.CustomPayload;
+
+import java.util.List;
+
+public record ChallengePacket(String challenge, List<String> params) implements CustomPayload {
+    public static final Id<ChallengePacket> ID = new CustomPayload.Id<>(BetterWhitelist.CHALLENGE_CHANNEL);
+    public static final PacketCodec<PacketByteBuf, ChallengePacket> CODEC = PacketCodec.tuple(
+            PacketCodecs.STRING, ChallengePacket::challenge,
+            PacketCodecs.<ByteBuf, String>toList().apply(PacketCodecs.STRING), ChallengePacket::params,
+            ChallengePacket::new);
+
+    @Override
+    public Id<? extends CustomPayload> getId() {
+        return ID;
+    }
+}

src/main/java/io/gitlab/jfronny/betterwhitelist/packet/ChallengeResponsePacket.java

@@ -0,0 +1,17 @@
+package io.gitlab.jfronny.betterwhitelist.packet;
+
+import io.gitlab.jfronny.betterwhitelist.BetterWhitelist;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.network.codec.PacketCodec;
+import net.minecraft.network.codec.PacketCodecs;
+import net.minecraft.network.packet.CustomPayload;
+
+public record ChallengeResponsePacket(String message) implements CustomPayload {
+    public static final CustomPayload.Id<ChallengeResponsePacket> ID = new CustomPayload.Id<>(BetterWhitelist.CHALLENGE_CHANNEL);
+    public static final PacketCodec<ByteBuf, ChallengeResponsePacket> CODEC = PacketCodecs.STRING.xmap(ChallengeResponsePacket::new, ChallengeResponsePacket::message);
+
+    @Override
+    public Id<? extends CustomPayload> getId() {
+        return ID;
+    }
+}

src/main/java/io/gitlab/jfronny/betterwhitelist/packet/HandshakePacket.java

@@ -0,0 +1,17 @@
+package io.gitlab.jfronny.betterwhitelist.packet;
+
+import io.gitlab.jfronny.betterwhitelist.BetterWhitelist;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.network.codec.PacketCodec;
+import net.minecraft.network.codec.PacketCodecs;
+import net.minecraft.network.packet.CustomPayload;
+
+public record HandshakePacket(int version) implements CustomPayload {
+    public static final CustomPayload.Id<HandshakePacket> ID = new CustomPayload.Id<>(BetterWhitelist.HANDSHAKE_CHANNEL);
+    public static final PacketCodec<ByteBuf, HandshakePacket> CODEC = PacketCodecs.INTEGER.xmap(HandshakePacket::new, HandshakePacket::version);
+
+    @Override
+    public Id<? extends CustomPayload> getId() {
+        return ID;
+    }
+}

src/main/java/io/gitlab/jfronny/betterwhitelist/server/BetterWhitelistServer.java

@@ -3,17 +3,21 @@ package io.gitlab.jfronny.betterwhitelist.server;
 import com.mojang.authlib.GameProfile;
 import com.mojang.brigadier.context.CommandContext;
 import io.gitlab.jfronny.betterwhitelist.BetterWhitelist;
+import io.gitlab.jfronny.betterwhitelist.DSerializer;
+import io.gitlab.jfronny.betterwhitelist.packet.ChallengeResponsePacket;
+import io.gitlab.jfronny.betterwhitelist.packet.HandshakePacket;
 import io.gitlab.jfronny.betterwhitelist.server.mixin.ServerLoginNetworkHandlerAccessor;
 import io.gitlab.jfronny.commons.StringFormatter;
-import io.gitlab.jfronny.muscript.compiler.Parser;
-import io.gitlab.jfronny.muscript.data.Script;
-import io.gitlab.jfronny.muscript.data.dynamic.Dynamic;
-import io.gitlab.jfronny.muscript.error.LocationalException;
+import io.gitlab.jfronny.muscript.ast.context.Script;
+import io.gitlab.jfronny.muscript.core.LocationalException;
+import io.gitlab.jfronny.muscript.core.MuScriptVersion;
+import io.gitlab.jfronny.muscript.parser.Parser;
 import net.fabricmc.api.DedicatedServerModInitializer;
 import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
 import net.fabricmc.fabric.api.networking.v1.*;
 import net.fabricmc.loader.api.FabricLoader;
 import net.minecraft.network.PacketByteBuf;
+import net.minecraft.network.packet.c2s.handshake.HandshakeC2SPacket;
 import net.minecraft.server.command.ServerCommandSource;
 import net.minecraft.server.network.ServerLoginNetworkHandler;
 import net.minecraft.text.Text;
@@ -34,6 +38,8 @@ public class BetterWhitelistServer implements DedicatedServerModInitializer {
 
     @Override
     public void onInitializeServer() {
+        BetterWhitelist.initialize();
+
         CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
             dispatcher.register(
                     literal(BetterWhitelist.MOD_ID)
@@ -47,9 +53,9 @@ public class BetterWhitelistServer implements DedicatedServerModInitializer {
             GameProfile gp = profile(handler);
             Challenge challenge = new Challenge(gp, sender);
             challenges.put(gp, challenge);
-            PacketByteBuf handshake = PacketByteBufs.create();
-            handshake.writeInt(BetterWhitelist.PROTOCOL_VERSION);
-            challenge.sender.sendPacket(BetterWhitelist.HANDSHAKE_CHANNEL, handshake);
+            PacketByteBuf buf = PacketByteBufs.create();
+            HandshakePacket.CODEC.encode(buf, new HandshakePacket(BetterWhitelist.PROTOCOL_VERSION));
+            challenge.sender.sendPacket(BetterWhitelist.HANDSHAKE_CHANNEL, buf);
             synchronizer.waitFor(challenge.challengeCompleted);
         });
 
@@ -58,13 +64,15 @@ public class BetterWhitelistServer implements DedicatedServerModInitializer {
                 handler.disconnect(Text.literal("This server requires better-whitelist to be installed"));
                 return;
             }
+            LoginPacketSender rns = (LoginPacketSender) responseSender;
+            HandshakePacket packet = HandshakePacket.CODEC.decode(buf);
             try {
-                if (buf.readInt() != BetterWhitelist.PROTOCOL_VERSION) {
+                if (packet.version() != BetterWhitelist.PROTOCOL_VERSION) {
                     handler.disconnect(Text.literal("This server requires a version of better-whitelist supporting the protocol version " + BetterWhitelist.PROTOCOL_VERSION));
                     return;
                 }
                 Challenge challenge = challenges.get(profile(handler));
-                challenge.sender = responseSender;
+                challenge.sender = rns;
                 Util.getMainWorkerExecutor().execute(new FutureTask<>(() -> {
                     try {
                         ServerScope.run(script, challenge);
@@ -78,7 +86,7 @@ public class BetterWhitelistServer implements DedicatedServerModInitializer {
                         BetterWhitelist.LOG.error("Something went wrong while trying to execute a challenge\n"
                                 + StringFormatter.toString(t, e ->
                                 e instanceof LocationalException le
-                                        ? le.asPrintable(scriptSource).toString()
+                                        ? le.asPrintable().toString()
                                         : e.toString()
                         ));
                         if (handler.isConnectionOpen()) handler.disconnect(Text.literal("Something went wrong"));
@@ -97,12 +105,13 @@ public class BetterWhitelistServer implements DedicatedServerModInitializer {
                 handler.disconnect(Text.literal("This server requires better-whitelist to be installed"));
                 return;
             }
+            LoginPacketSender rns = (LoginPacketSender) responseSender;
+            ChallengeResponsePacket packet = ChallengeResponsePacket.CODEC.decode(buf);
             try {
                 Challenge ch = challenges.get(profile(handler));
-                ch.sender = responseSender;
-                String response = buf.readString();
-                BetterWhitelist.LOG.info("Got response from " + ch.profile.getName() + ": " + response);
-                ch.response.complete(Dynamic.deserialize(response));
+                ch.sender = rns;
+                BetterWhitelist.LOG.info("Got response from " + ch.profile.getName() + ": " + packet.message());
+                ch.response.complete(DSerializer.deserialize(packet.message()));
             } catch (Throwable t) {
                 BetterWhitelist.LOG.error("Failed login", t);
                 handler.disconnect(Text.literal("Invalid dynamic"));
@@ -162,7 +171,7 @@ public class BetterWhitelistServer implements DedicatedServerModInitializer {
                 }, mods::values()::filter({ v -> v.environment != 'server' })::map({ v -> { id = v.id, version = v.version } })))
                 """);
         String s = Files.readString(scriptPath);
-        this.script = Parser.parseScript(s);
+        this.script = Parser.parseScript(MuScriptVersion.DEFAULT, s);
         this.scriptSource = s;
     }
 }

src/main/java/io/gitlab/jfronny/betterwhitelist/server/Challenge.java

@@ -2,15 +2,16 @@ package io.gitlab.jfronny.betterwhitelist.server;
 
 import com.mojang.authlib.GameProfile;
 import io.gitlab.jfronny.muscript.data.dynamic.Dynamic;
+import net.fabricmc.fabric.api.networking.v1.LoginPacketSender;
 import net.fabricmc.fabric.api.networking.v1.PacketSender;
 
 class Challenge {
     public final ManualFuture<?> challengeCompleted = new ManualFuture<>();
-    public final ManualFuture<Dynamic<?>> response = new ManualFuture<>();
+    public final ManualFuture<Dynamic> response = new ManualFuture<>();
     public final GameProfile profile;
-    public PacketSender sender;
+    public LoginPacketSender sender;
 
-    public Challenge(GameProfile profile, PacketSender sender) {
+    public Challenge(GameProfile profile, LoginPacketSender sender) {
         this.profile = profile;
         this.sender = sender;
     }

src/main/java/io/gitlab/jfronny/betterwhitelist/server/ServerScope.java

@@ -1,12 +1,15 @@
 package io.gitlab.jfronny.betterwhitelist.server;
 
 import io.gitlab.jfronny.betterwhitelist.BetterWhitelist;
-import io.gitlab.jfronny.muscript.data.Scope;
-import io.gitlab.jfronny.muscript.data.Script;
+import io.gitlab.jfronny.betterwhitelist.DSerializer;
+import io.gitlab.jfronny.betterwhitelist.packet.ChallengePacket;
+import io.gitlab.jfronny.muscript.ast.context.Script;
+import io.gitlab.jfronny.muscript.core.LocationalException;
+import io.gitlab.jfronny.muscript.data.additional.DFinal;
+import io.gitlab.jfronny.muscript.data.additional.context.Scope;
 import io.gitlab.jfronny.muscript.data.dynamic.DNull;
 import io.gitlab.jfronny.muscript.data.dynamic.Dynamic;
-import io.gitlab.jfronny.muscript.data.dynamic.additional.DFinal;
-import io.gitlab.jfronny.muscript.error.LocationalException;
+import io.gitlab.jfronny.muscript.runtime.Runtime;
 import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
 import net.minecraft.network.PacketByteBuf;
 
@@ -16,9 +19,9 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
 public class ServerScope {
-    public static Dynamic<?> run(Script script, Challenge challenge) {
+    public static Dynamic run(Script script, Challenge challenge) {
         try {
-            return script.run(fork(challenge));
+            return Runtime.run(script, fork(challenge));
         } catch (LocationalException le) {
             for (Throwable t = le; t != null; t = t.getCause()) {
                 if (t instanceof ServerScope.AssertFail af) throw af;
@@ -33,15 +36,13 @@ public class ServerScope {
             if (!args.get(0).asBool().getValue()) throw new AssertFail(args.size() > 1 ? args.get(1).asString().getValue() : "Failed Whitelist Check");
             return new DNull();
         }).set("challenge", args -> {
-            if (args.size() == 0) throw new IllegalArgumentException("Invalid number of arguments for challenge: expected 1 or more but got 0");
-            PacketByteBuf buf = PacketByteBufs.create();
-            String challengeString = Dynamic.serialize(args.get(0).asCallable());
+            if (args.isEmpty()) throw new IllegalArgumentException("Invalid number of arguments for challenge: expected 1 or more but got 0");
+            String challengeString = DSerializer.serialize(args.get(0).asCallable());
             BetterWhitelist.LOG.info("Sending challenge to " + challenge.profile.getName() + ": " + challengeString);
-            buf.writeString(challengeString);
-            List<Dynamic<?>> params = args.getValue().subList(1, args.size());
-            buf.writeInt(params.size());
-            params.forEach(p -> buf.writeString(Dynamic.serialize(p)));
+            List<String> params = args.getValue().subList(1, args.size()).stream().map(DSerializer::serialize).toList();
             challenge.response.reset();
+            PacketByteBuf buf = PacketByteBufs.create();
+            ChallengePacket.CODEC.encode(buf, new ChallengePacket(challengeString, params));
             challenge.sender.sendPacket(BetterWhitelist.CHALLENGE_CHANNEL, buf);
             try {
                 return challenge.response.get(1, TimeUnit.SECONDS);