@pkmn/engine 0.1.0-dev.26a79a0e → 0.1.0-dev.2916f414

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2021-2024 pkmn contributors
+Copyright (c) 2021-2025 pkmn contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

package/README.md

@@ -61,7 +61,10 @@ walk through how to install Zig on each platform - the engine code should work o
 though tracks Zig's master branch so this may change in the future if breaking language changes are
 introduced. Note that **due to a [bug in the Zig
 compiler](https://github.com/ziglang/zig/issues/17768), compiling with a version of Zig before
-`0.12.0-dev.876+aaf46187a` is recommended for performance**.
+`0.12.0-dev.876+aaf46187a` is recommended for performance**. Alternatively, building a version of
+[Zig from source](https://github.com/ziglang/zig/wiki/Building-Zig-From-Source) after having applied
+a [patch](zig.patch) to revert [ziglang/zig#17391](ziglang/zig/pull/17391) will restore performance
+while allowing modern Zig features to be used.
 
 `libpkmn` can be built with `-Dshowdown` to instead produce the Pokémon Showdown compatible
 `libpkmn-showdown` library. Furthermore, protocol message logging can be enabled through `-Dlog`.
@@ -115,6 +118,48 @@ error: dependency is missing hash field
 note: expected .hash = "122056b93b403033cb7d9bed96a02c2eb8cc1275515976167726ada6eb4207e8ef8a",
 ```
 
+You must add `build.zig.zon` to the engine package to be able to import it in your `build.zig`:
+
+<details><summary>Before v0.14.0</summary>
+
+```zig
+.{
+    .name = "pkmn",
+    .version = "0.1.0-dev",
+    .minimum_zig_version = "0.11.0",
+    .paths = .{
+        "build.zig",
+        "docs",
+        "LICENSE",
+        "README.md",
+        "src/include",
+        "src/lib",
+    },
+}
+```
+</details>
+
+
+<details><summary>After v0.14.0</summary>
+
+```zig
+.{
+    .name = .pkmn,
+    .version = "0.1.0-dev",
+    .minimum_zig_version = "0.14.0",
+    .paths = .{
+        "build.zig",
+        "docs",
+        "LICENSE",
+        "README.md",
+        "src/include",
+        "src/lib",
+    },
+    .fingerprint = 0x74a002f44f200a47,
+}
+```
+</details>
+
 Note that this hash is **not** going to be the same as the commit hash. After adding the hash to
 your `build.zig.zon` you will be able to import the `pkmn` package's build helpers into your
 `build.zig`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.26a79a0e",
+  "version": "0.1.0-dev.2916f414",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
@@ -98,38 +98,38 @@
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.9.27",
-    "@pkmn/protocol": "^0.6.30"
+    "@pkmn/data": "^0.9.31",
+    "@pkmn/protocol": "^0.6.31"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^9.5.0",
-    "@pkmn/img": "^0.2.34",
+    "@pkmn/eslint-config": "^9.7.0",
+    "@pkmn/img": "^0.2.36",
     "@pkmn/sets": "^5.1.2",
-    "@pkmn/sim": "0.9.27",
-    "@pkmn/smogon": "^0.5.17",
+    "@pkmn/sim": "0.9.31",
+    "@pkmn/smogon": "^0.5.19",
     "@types/html-minifier": "^4.0.5",
     "@types/jest": "^29.5.14",
     "@types/minimist": "^1.2.5",
     "@types/mustache": "^4.2.5",
-    "@types/node": "^22.10.6",
-    "@types/react": "^18.3.12",
+    "@types/node": "^22.13.9",
+    "@types/react": "<=18",
     "@types/semver": "^7.5.8",
-    "@types/vscode": "^1.96.0",
-    "@vitest/coverage-v8": "^2.1.8",
-    "@vscode/vsce": "^3.2.1",
-    "binaryen": "^121.0.0",
-    "esbuild": "^0.24.2",
-    "eslint": "^9.18.0",
+    "@types/vscode": "^1.97.0",
+    "@vitest/coverage-v8": "^3.0.7",
+    "@vscode/vsce": "^3.2.2",
+    "binaryen": "^122.0.0",
+    "esbuild": "^0.25.0",
+    "eslint": "^9.21.0",
     "html-minifier": "^4.0.0",
     "json-stringify-pretty-compact": "3.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
-    "semver": "^7.6.3",
+    "semver": "^7.7.1",
     "source-map-support": "^0.5.21",
     "table": "^6.9.0",
     "trakr": "^0.2.0",
-    "typescript": "^5.7.3",
-    "vitest": "^2.1.8"
+    "typescript": "^5.8.2",
+    "vitest": "^3.0.7"
   },
   "scripts": {
     "lint": "eslint --cache src",

package/src/lib/common/rational.zig

@@ -19,7 +19,23 @@ const ComptimeFloat =
 /// sometimes overflows in places where an eager reduced implementation would not - to achieve
 /// the same behavior as an eager implementation simply call `reduce` after each operation.
 pub fn Rational(comptime T: type) type {
-    return extern struct {
+    // With floats we can't rely on an overflow bit to let us know when to reduce, so we
+    // instead start reducing when we get sufficiently close to the limit of the mantissa
+    // (in our domain we expect updates to involve numbers < 2**10, so we should be safe
+    // not reducing before we are 2**10 away from "overflowing" the mantissa)
+    const o = if (@typeInfo(T) == Float)
+        std.math.pow(T, 2, std.math.floatMantissaBits(T) - 10)
+    else
+        0;
+
+    const Err = switch (@typeInfo(T)) {
+        Int => error{Overflow},
+        Float => error{},
+        else => unreachable,
+    };
+
+    // Zig doesn't allow integers > u128 in an extern struct...
+    return if (@sizeOf(T) <= 16) extern struct {
         const Self = @This();
 
         /// Numerator. Must always be >= 1. Not guaranteed to be reduced in all cases.
@@ -27,21 +43,8 @@ pub fn Rational(comptime T: type) type {
         /// Denominator. Must always be >= 1. Not guaranteed to be reduced in all cases.
         q: T = 1,
 
-        // With floats we can't rely on an overflow bit to let us know when to reduce, so we
-        // instead start reducing when we get sufficiently close to the limit of the mantissa
-        // (in our domain we expect updates to involve numbers < 2**10, so we should be safe
-        // not reducing before we are 2**10 away from "overflowing" the mantissa)
-        const REDUCE = if (@typeInfo(T) == Float)
-            std.math.pow(T, 2, std.math.floatMantissaBits(T) - 10)
-        else
-            0;
-
         /// Possible error returned by operations on the Rational.
-        pub const Error = switch (@typeInfo(T)) {
-            Int => error{Overflow},
-            Float => error{},
-            else => unreachable,
-        };
+        pub const Error = Err;
 
         /// Resets the rational back to 1.
         pub fn reset(r: *Self) void {
@@ -52,135 +55,69 @@ pub fn Rational(comptime T: type) type {
         /// Update the rational by multiplying its numerator by p and its denominator by q.
         /// Both p and q must be >= 1, and if computable at comptime must have no common factors.
         pub fn update(r: *Self, p: anytype, q: anytype) Error!void {
-            // std.debug.print("({d}/{d}) * ", .{ p, q }); // DEBUG
-            assert(p >= 1);
-            assert(q >= 1);
-
-            // If our parameters are not fully reduced they may prematurely
-            // cause overflow/loss of precision after the multiplication below
-            assert(switch (@typeInfo(@TypeOf(p, q))) {
-                ComptimeInt, ComptimeFloat => comptime gcd(p, q),
-                else => 1,
-            } == 1);
-
-            switch (@typeInfo(T)) {
-                Int => {
-                    // Greedily attempt to multiply and if it fails, reduce and try again
-                    r.multiplication(p, q) catch |err| switch (err) {
-                        error.Overflow => {
-                            r.reduce();
-                            try r.multiplication(p, q);
-                        },
-                        else => unreachable,
-                    };
-                },
-                Float => {
-                    // Reduce in situations where we're likely to start losing precision
-                    if (r.q > REDUCE or r.p > REDUCE) r.reduce();
-
-                    r.p *= switch (@typeInfo(@TypeOf(p))) {
-                        Float, ComptimeFloat => p,
-                        else => @floatFromInt(p),
-                    };
-                    r.q *= switch (@typeInfo(@TypeOf(q))) {
-                        Float, ComptimeFloat => q,
-                        else => @floatFromInt(q),
-                    };
-
-                    // We should always be dealing with whole numbers
-                    assert(std.math.modf(r.p).fpart == 0);
-                    assert(std.math.modf(r.q).fpart == 0);
-                },
-                else => unreachable,
-            }
+            return update_(T, o, r, p, q);
         }
 
         /// Add two rationals using the identity (a/b) + (c/d) = (ad+bc)/(bd).
-        pub fn add(r: *Self, s: *Self) Error!void {
-            switch (@typeInfo(T)) {
-                Int => {
-                    if (r.q == s.q) {
-                        r.p = std.math.add(T, r.p, s.p) catch |err| switch (err) {
-                            error.Overflow => val: {
-                                r.reduce();
-                                s.reduce();
-                                break :val try std.math.add(T, r.p, s.p);
-                            },
-                            else => unreachable,
-                        };
-                    } else {
-                        r.addition(s.p, s.q) catch |err| switch (err) {
-                            error.Overflow => {
-                                r.reduce();
-                                s.reduce();
-                                try r.addition(s.p, s.q);
-                            },
-                            else => unreachable,
-                        };
-                    }
-                },
-                Float => {
-                    if (r.q == s.q) {
-                        if (r.p > REDUCE) r.reduce();
-                        if (s.p > REDUCE) s.reduce();
-
-                        r.p += s.p;
-                    } else {
-                        // Always reduce to minimize loss of precision from the multiplications
-                        r.reduce();
-                        s.reduce();
+        pub fn add(r: *Self, s: anytype) Error!void {
+            return add_(T, o, r, s);
+        }
 
-                        r.p = (r.p * s.q) + (r.q * s.p);
-                        r.q *= s.q;
-                    }
+        /// Multiplies two rationals.
+        pub fn mul(r: *Self, s: anytype) Error!void {
+            return mul_(T, o, r, s);
+        }
 
-                    assert(std.math.modf(r.p).fpart == 0);
-                    assert(std.math.modf(r.q).fpart == 0);
-                },
-                else => unreachable,
-            }
+        /// Normalize the rational by reducing by the greatest common divisor.
+        pub fn reduce(r: *Self) void {
+            reduce_(r);
         }
 
-        /// Multiplies two rationals.
-        pub fn mul(r: *Self, s: *Self) Error!void {
-            switch (@typeInfo(T)) {
-                Int => {
-                    r.multiplication(s.p, s.q) catch |err| switch (err) {
-                        error.Overflow => {
-                            r.reduce();
-                            s.reduce();
-                            try r.multiplication(s.p, s.q);
-                        },
-                        else => unreachable,
-                    };
-                },
-                Float => {
-                    if (r.q > REDUCE or r.p > REDUCE) r.reduce();
-                    if (s.q > REDUCE or s.p > REDUCE) s.reduce();
+        pub fn format(
+            self: Self,
+            comptime fmt: []const u8,
+            opts: std.fmt.FormatOptions,
+            writer: anytype,
+        ) !void {
+            _ = .{ fmt, opts };
+            try writer.print("{d}/{d}", .{ self.p, self.q });
+        }
+    } else struct {
+        const Self = @This();
 
-                    r.p *= s.p;
-                    r.q *= s.q;
+        /// Numerator. Must always be >= 1. Not guaranteed to be reduced in all cases.
+        p: T = 1,
+        /// Denominator. Must always be >= 1. Not guaranteed to be reduced in all cases.
+        q: T = 1,
 
-                    assert(std.math.modf(r.p).fpart == 0);
-                    assert(std.math.modf(r.q).fpart == 0);
-                },
-                else => unreachable,
-            }
+        /// Possible error returned by operations on the Rational.
+        pub const Error = Err;
+
+        /// Resets the rational back to 1.
+        pub fn reset(r: *Self) void {
+            r.p = 1;
+            r.q = 1;
         }
 
-        /// Normalize the rational by reducing by the greatest common divisor.
-        pub fn reduce(r: *Self) void {
-            const d = gcd(r.p, r.q);
-            if (d == 1) return;
+        /// Update the rational by multiplying its numerator by p and its denominator by q.
+        /// Both p and q must be >= 1, and if computable at comptime must have no common factors.
+        pub fn update(r: *Self, p: anytype, q: anytype) Error!void {
+            return update_(T, o, r, p, q);
+        }
 
-            assert(@mod(r.p, d) == 0);
-            assert(@mod(r.q, d) == 0);
+        /// Add two rationals using the identity (a/b) + (c/d) = (ad+bc)/(bd).
+        pub fn add(r: *Self, s: anytype) Error!void {
+            return add_(T, o, r, s);
+        }
 
-            r.p /= d;
-            r.q /= d;
+        /// Multiplies two rationals.
+        pub fn mul(r: *Self, s: anytype) Error!void {
+            return mul_(T, o, r, s);
+        }
 
-            assert(r.p >= 1);
-            assert(r.q >= 1);
+        /// Normalize the rational by reducing by the greatest common divisor.
+        pub fn reduce(r: *Self) void {
+            reduce_(r);
         }
 
         pub fn format(
@@ -192,22 +129,151 @@ pub fn Rational(comptime T: type) type {
             _ = .{ fmt, opts };
             try writer.print("{d}/{d}", .{ self.p, self.q });
         }
+    };
+}
 
-        fn multiplication(r: *Self, p: anytype, q: anytype) !void {
-            r.p = try std.math.mul(T, r.p, p);
-            r.q = try std.math.mul(T, r.q, q);
-        }
+fn update_(comptime T: type, comptime o: comptime_int, r: anytype, p: anytype, q: anytype) !void {
+    // std.debug.print("({d}/{d}) * ", .{ p, q }); // DEBUG
+    assert(p >= 1);
+    assert(q >= 1);
 
-        fn addition(r: *Self, p: anytype, q: anytype) !void {
-            // (a/b) + (c/d) = (ad+bc)/(bd)
-            const d = try std.math.mul(T, r.q, q);
-            const n1 = try std.math.mul(T, r.p, q);
-            const n2 = try std.math.mul(T, r.q, p);
+    // If our parameters are not fully reduced they may prematurely
+    // cause overflow/loss of precision after the multiplication below
+    assert(switch (@typeInfo(@TypeOf(p, q))) {
+        ComptimeInt, ComptimeFloat => comptime gcd(p, q),
+        else => 1,
+    } == 1);
 
-            r.p = try std.math.add(T, n1, n2);
-            r.q = d;
-        }
-    };
+    switch (@typeInfo(T)) {
+        Int => {
+            // Greedily attempt to multiply and if it fails, reduce and try again
+            multiplication(T, r, p, q) catch |err| switch (err) {
+                error.Overflow => {
+                    r.reduce();
+                    try multiplication(T, r, p, q);
+                },
+                else => unreachable,
+            };
+        },
+        Float => {
+            // Reduce in situations where we're likely to start losing precision
+            if (r.q > o or r.p > o) r.reduce();
+
+            r.p *= switch (@typeInfo(@TypeOf(p))) {
+                Float, ComptimeFloat => p,
+                else => @floatFromInt(p),
+            };
+            r.q *= switch (@typeInfo(@TypeOf(q))) {
+                Float, ComptimeFloat => q,
+                else => @floatFromInt(q),
+            };
+
+            // We should always be dealing with whole numbers
+            assert(std.math.modf(r.p).fpart == 0);
+            assert(std.math.modf(r.q).fpart == 0);
+        },
+        else => unreachable,
+    }
+}
+
+fn add_(comptime T: type, comptime o: comptime_int, r: anytype, s: anytype) !void {
+    switch (@typeInfo(T)) {
+        Int => {
+            if (r.q == s.q) {
+                r.p = std.math.add(T, r.p, s.p) catch |err| switch (err) {
+                    error.Overflow => val: {
+                        r.reduce();
+                        s.reduce();
+                        break :val try std.math.add(T, r.p, s.p);
+                    },
+                    else => unreachable,
+                };
+            } else {
+                addition(T, r, s.p, s.q) catch |err| switch (err) {
+                    error.Overflow => {
+                        r.reduce();
+                        s.reduce();
+                        try addition(T, r, s.p, s.q);
+                    },
+                    else => unreachable,
+                };
+            }
+        },
+        Float => {
+            if (r.q == s.q) {
+                if (r.p > o) r.reduce();
+                if (s.p > o) s.reduce();
+
+                r.p += s.p;
+            } else {
+                // Always reduce to minimize loss of precision from the multiplications
+                r.reduce();
+                s.reduce();
+
+                r.p = (r.p * s.q) + (r.q * s.p);
+                r.q *= s.q;
+            }
+
+            assert(std.math.modf(r.p).fpart == 0);
+            assert(std.math.modf(r.q).fpart == 0);
+        },
+        else => unreachable,
+    }
+}
+
+fn mul_(comptime T: type, comptime o: comptime_int, r: anytype, s: anytype) !void {
+    switch (@typeInfo(T)) {
+        Int => {
+            multiplication(T, r, s.p, s.q) catch |err| switch (err) {
+                error.Overflow => {
+                    r.reduce();
+                    s.reduce();
+                    try multiplication(T, r, s.p, s.q);
+                },
+                else => unreachable,
+            };
+        },
+        Float => {
+            if (r.q > o or r.p > o) r.reduce();
+            if (s.q > o or s.p > o) s.reduce();
+
+            r.p *= s.p;
+            r.q *= s.q;
+
+            assert(std.math.modf(r.p).fpart == 0);
+            assert(std.math.modf(r.q).fpart == 0);
+        },
+        else => unreachable,
+    }
+}
+
+fn reduce_(r: anytype) void {
+    const d = gcd(r.p, r.q);
+    if (d == 1) return;
+
+    assert(@mod(r.p, d) == 0);
+    assert(@mod(r.q, d) == 0);
+
+    r.p /= d;
+    r.q /= d;
+
+    assert(r.p >= 1);
+    assert(r.q >= 1);
+}
+
+fn multiplication(comptime T: type, r: anytype, p: anytype, q: anytype) !void {
+    r.p = try std.math.mul(T, r.p, p);
+    r.q = try std.math.mul(T, r.q, q);
+}
+
+fn addition(comptime T: type, r: anytype, p: anytype, q: anytype) !void {
+    // (a/b) + (c/d) = (ad+bc)/(bd)
+    const d = try std.math.mul(T, r.q, q);
+    const n1 = try std.math.mul(T, r.p, q);
+    const n2 = try std.math.mul(T, r.q, p);
+
+    r.p = try std.math.add(T, n1, n2);
+    r.q = d;
 }
 
 fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
@@ -289,7 +355,7 @@ fn doTurn(r: anytype) !void {
 }
 
 test Rational {
-    inline for (.{ u64, u128, f64 }) |t| {
+    inline for (.{ u64, u128, u256, f64 }) |t| {
         var r: Rational(t) = .{};
 
         var c: t = 128;

package/src/lib/common/util.zig

@@ -69,3 +69,8 @@ fn CopyPtrAttrs(
     else
         .{ .Pointer = args });
 }
+
+// NOTE: std.meta.FieldType replaced by @FieldType in 0.14.0
+pub fn FieldType(comptime T: type, comptime field: std.meta.FieldEnum(T)) type {
+    return std.meta.fieldInfo(T, field).type;
+}

package/src/lib/gen1/calc.zig

@@ -14,7 +14,6 @@ const util = @import("../common/util.zig");
 const Action = chance.Action;
 const Actions = chance.Actions;
 const assert = std.debug.assert;
-const BigRational = rational.BigRational;
 const Chance = chance.Chance;
 const Choice = common.Choice;
 const Confusion = chance.Confusion;
@@ -100,7 +99,7 @@ pub const Calc = struct {
         self: Calc,
         player: Player,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
+    ) ?util.FieldType(Action, field) {
         if (!enabled) return null;
 
         const val = @field(self.overrides.get(player), @tagName(field));
@@ -147,7 +146,7 @@ const Null = struct {
         self: Null,
         player: Player,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
+    ) ?util.FieldType(Action, field) {
         _ = .{ self, player };
         return null;
     }
@@ -217,10 +216,7 @@ pub fn transitions(
     const p1 = b.side(.P1);
     const p2 = b.side(.P2);
 
-    var p = try BigRational.init(allocator);
-    defer p.deinit();
-    try p.val.p.set(0);
-    try p.val.q.set(1);
+    var p: Rational(u256) = .{ .p = 0, .q = 1 };
     try frontier.append(opts.chance.actions);
 
     // zig fmt: off
@@ -235,10 +231,7 @@ pub fn transitions(
         const f = frontier.items[i];
         const saved = stats.saved;
 
-        var r = try BigRational.init(allocator);
-        defer r.deinit();
-        try r.val.p.set(0);
-        try r.val.q.set(1);
+        var r: Rational(u256) = .{ .p = 0, .q = 1 };
 
         try debug(writer, f, .{
             .shape = true,
@@ -351,11 +344,13 @@ pub fn transitions(
 
                     q.reduce();
                     try p.add(q);
+                    p.reduce();
                     try r.add(q);
+                    r.reduce();
 
                     stats.saved += 1;
 
-                    if (p.val.q.order(p.val.p) == .lt) {
+                    if (p.q < p.p) {
                         err("improper fraction {}", .{p}, options.seed);
                         return error.TestUnexpectedResult;
                     }
@@ -393,13 +388,15 @@ pub fn transitions(
         }}}}}}}}}}}}}}}}}}}}}}}}}}}}
 
         assert(stats.saved > saved);
-        const old = @hasDecl(std.fmt, "formatFloatDecimal");
-        if (!old and @TypeOf(writer) != @TypeOf(std.io.null_writer)) {
-            try writer.print(
-                "    {} ({d:.2}%)\n  = ──────────\n    {} ({d:.2}%)\n\n",
-                .{r.val, percent(r.val), p.val, percent(p.val)},
-            );
-        }
+        // TODO: ziglang/zig#22667
+        // const old = @hasDecl(std.fmt, "formatFloatDecimal");
+        // if (!old and @TypeOf(writer) != @TypeOf(std.io.null_writer)) {
+        //     try writer.print(
+        //         "    {} ({d:.2}%)\n  = ──────────\n    {} ({d:.2}%)\n\n",
+        //         .{r, 100 * @as(f128, @floatFromInt(r.p)) / @as(f128, @floatFromInt(r.q)),
+        //           p, 100 * @as(f128, @floatFromInt(p.p)) / @as(f128, @floatFromInt(p.q))},
+        //     );
+        // }
 
     }
 
@@ -412,7 +409,8 @@ pub fn transitions(
 
     stats.seen = seen.count();
 
-    if (try p.val.p.to(u128) != 1 or try p.val.q.to(u128) != 1) {
+    p.reduce();
+    if (p.p != 1 or p.q != 1) {
         err("expected 1, found {}", .{p}, options.seed);
         return error.TestExpectedEqual;
     }
@@ -420,11 +418,6 @@ pub fn transitions(
     return stats;
 }
 
-fn percent(r: anytype) f128 {
-    return 100 * @as(f128, @floatFromInt(r.p.to(u128) catch unreachable)) /
-        @as(f128, @floatFromInt(r.q.to(u128) catch unreachable));
-}
-
 pub fn update(
     battle: anytype,
     c1: Choice,

package/src/lib/gen1/mechanics.zig

@@ -1297,7 +1297,7 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
     }
 
     // NOTE: llvm/llvm-project#58557
-    battle.last_damage = if (comptime builtin.target.isWasm())
+    battle.last_damage = if (comptime builtin.target.cpu.arch.isWasm())
         @max(battle.last_damage *% 2, std.math.maxInt(u16))
     else
         battle.last_damage *| 2;

package/src/lib/gen2/calc.zig

@@ -148,6 +148,6 @@ fn ReturnType(comptime field: Action.Field) type {
     return ?(switch (field) {
         .damages => u8,
         .critical_hits => Optional(bool),
-        else => std.meta.FieldType(Action, field),
+        else => util.FieldType(Action, field),
     });
 }

package/src/lib/gen2/mechanics.zig

@@ -2841,7 +2841,7 @@ fn convertible(active: ActivePokemon, m: Move) bool {
 
 // NOTE: llvm/llvm-project#58557
 fn smul(a: anytype, b: @TypeOf(a)) @TypeOf(a) {
-    if (!comptime builtin.target.isWasm()) return a *| b;
+    if (!comptime builtin.target.cpu.arch.isWasm()) return a *| b;
     return @max(a *% b, std.math.maxInt(@TypeOf(a)));
 }