@pkmn/engine 0.1.0-dev.f4ba6ebd → 0.1.0-dev.f6545544

package/build.zig

@@ -1,5 +1,5 @@
-const std = @import("std");
 const builtin = @import("builtin");
+const std = @import("std");
 
 pub const Options = struct {
     showdown: ?bool = null,
@@ -27,8 +27,14 @@ pub fn module(b: *std.Build, options: Options) *std.Build.Module {
     build_options.addOption(?bool, "chance", options.chance);
     build_options.addOption(?bool, "calc", options.calc);
 
-    const root_source_file = .{ .cwd_relative = dirname ++ "/src/lib/pkmn.zig" };
-    const imports = &.{.{ .name = "build_options", .module = build_options.createModule() }};
+    const root_source_file: std.Build.LazyPath =
+        .{ .cwd_relative = dirname ++ "/src/lib/pkmn.zig" };
+    const Import = if (@hasDecl(std.Build.Module, "Import"))
+        std.Build.Module.Import
+    else
+        std.Build.ModuleDependency;
+    const imports: []const Import =
+        &.{.{ .name = "build_options", .module = build_options.createModule() }};
     return b.createModule(if (@hasDecl(std.Build, "CreateModuleOptions"))
         .{ .source_file = root_source_file, .dependencies = imports }
     else
@@ -43,6 +49,10 @@ pub fn build(b: *std.Build) !void {
     const node_headers = b.option([]const u8, "node-headers", "Path to node-headers");
     const node_import_lib =
         b.option([]const u8, "node-import-library", "Path to node import library (Windows)");
+    const demo = if (try exists("src/tools/demo.zig"))
+        b.option(bool, "demo", "Build the demo library") orelse false
+    else
+        false;
     const wasm = b.option(bool, "wasm", "Build a WASM library") orelse false;
     const wasm_stack_size =
         b.option(u64, "wasm-stack-size", "The size of WASM stack") orelse std.wasm.page_size;
@@ -73,6 +83,7 @@ pub fn build(b: *std.Build) !void {
     const log = b.option(bool, "log", "Enable protocol message logging") orelse false;
     const chance = b.option(bool, "chance", "Enable update probability tracking") orelse false;
     const calc = b.option(bool, "calc", "Enable damage calculator support") orelse false;
+    const extra = b.option([]const []const u8, "option", "Enable extra option");
 
     const options = b.addOptions();
     options.addOption(?bool, "showdown", showdown);
@@ -80,17 +91,37 @@ pub fn build(b: *std.Build) !void {
     options.addOption(?bool, "chance", chance);
     options.addOption(?bool, "calc", calc);
 
+    if (extra) |opts| {
+        for (opts) |opt| {
+            if (std.mem.indexOfScalar(u8, opt, '=')) |i| {
+                options.addOption(?bool, opt[0..i], if (std.mem.eql(u8, opt[i + 1 ..], "true"))
+                    true
+                else if (std.mem.eql(u8, opt[i + 1 ..], "false"))
+                    false
+                else {
+                    std.log.err("Invalid option: {s}\n", .{opt});
+                    return error.InvalidOption;
+                });
+            } else {
+                options.addOption(?bool, opt, true);
+            }
+        }
+    }
+
     const name = if (showdown) "pkmn-showdown" else "pkmn";
 
-    const pkmn = if (@hasDecl(std.Build, "CreateModuleOptions")) null else b.addModule("pkmn", .{
-        .root_source_file = if (has_path)
-            .{ .path = "src/lib/pkmn.zig" }
-        else
-            b.path("src/lib/pkmn.zig"),
-        .optimize = optimize,
-        .target = target,
-        .imports = &.{.{ .name = "build_options", .module = options.createModule() }},
-    });
+    const pkmn: ?*std.Build.Module = if (@hasDecl(std.Build, "CreateModuleOptions"))
+        null
+    else
+        b.addModule("pkmn", .{
+            .root_source_file = if (has_path)
+                .{ .path = "src/lib/pkmn.zig" }
+            else
+                b.path("src/lib/pkmn.zig"),
+            .optimize = optimize,
+            .target = target,
+            .imports = &.{.{ .name = "build_options", .module = options.createModule() }},
+        });
 
     var c = false;
     if (node_headers) |headers| {
@@ -131,73 +162,18 @@ pub fn build(b: *std.Build) !void {
         // rename the file ourself in install-pkmn-engine
         b.installArtifact(lib);
     } else if (wasm) {
-        const entry = @hasDecl(Step.Compile, "Entry");
-        const mode = switch (optimize) {
-            .ReleaseFast, .ReleaseSafe => .ReleaseSmall,
-            else => optimize,
-        };
-        const freestanding = if (@hasDecl(std.Build, "resolveTargetQuery"))
-            b.resolveTargetQuery(.{ .cpu_arch = .wasm32, .os_tag = .freestanding })
-        else
-            ResolvedTarget{ .cpu_arch = .wasm32, .os_tag = .freestanding };
-        const path = if (has_path) .{ .path = "src/lib/wasm.zig" } else b.path("src/lib/wasm.zig");
-        const bin = if (entry) bin: {
-            const exe = b.addExecutable(if (force_pic) .{
-                .name = name,
-                .root_source_file = path,
-                .optimize = mode,
-                .target = freestanding,
-            } else .{
-                .name = name,
-                .root_source_file = path,
-                .optimize = mode,
-                .target = freestanding,
-                .strip = strip,
-                .pic = pic,
-            });
-            (if (root_module) exe.root_module else exe).export_symbol_names = &[_][]const u8{
-                "SHOWDOWN",
-                "LOG",
-                "CHANCE",
-                "CALC",
-                "GEN1_CHOICES_SIZE",
-                "GEN1_LOGS_SIZE",
-            };
-            exe.entry = .disabled;
-            break :bin exe;
-        } else bin: {
-            const lib = b.addSharedLibrary(.{
-                .name = name,
-                .root_source_file = path,
-                .optimize = mode,
-                .target = freestanding,
-            });
-            lib.rdynamic = true;
-            break :bin lib;
-        };
-        bin.stack_size = wasm_stack_size;
-        if (@hasDecl(@TypeOf(bin.*), "strip")) bin.strip = strip orelse false;
-        if (force_pic and pic orelse false) bin.force_pic = pic;
-        (if (root_module) bin.root_module else bin).addOptions("build_options", options);
-
-        const opt = b.findProgram(&.{"wasm-opt"}, &.{"./node_modules/.bin"}) catch null;
-        if (optimize != .Debug and opt != null) {
-            const out = b.fmt("build/lib/{s}.wasm", .{name});
-            const sh = b.addSystemCommand(&.{ opt.?, "-O4" });
-            sh.addArtifactArg(bin);
-            sh.addArg("-o");
-            if (@hasDecl(@TypeOf(sh.*), "addFileSourceArg")) {
-                sh.addFileSourceArg(if (has_path) .{ .path = out } else b.path(out));
-            } else {
-                sh.addFileArg(if (has_path) .{ .path = out } else b.path(out));
-            }
-            b.getInstallStep().dependOn(&sh.step);
-            if (!entry) b.installArtifact(bin);
-        } else if (entry) {
-            b.getInstallStep().dependOn(&b.addInstallArtifact(bin, .{
-                .dest_dir = .{ .override = std.Build.InstallDir{ .lib = {} } },
-            }).step);
-        }
+        const path = "src/lib/wasm.zig";
+        try buildWasm(b, name, path, optimize, strip, pic, wasm_stack_size, null, options);
+    } else if (demo) {
+        const path = "src/tools/demo.zig";
+        const n = if (showdown) "demo-showdown" else "demo";
+        const mod = pkmn orelse module(b, .{
+            .showdown = showdown,
+            .log = log,
+            .chance = chance,
+            .calc = calc,
+        });
+        try buildWasm(b, n, path, optimize, strip, pic, wasm_stack_size, mod, options);
     } else if (dynamic) {
         const path = if (has_path) .{ .path = "src/lib/c.zig" } else b.path("src/lib/c.zig");
         const lib = b.addSharedLibrary(if (force_pic) .{
@@ -292,7 +268,7 @@ pub fn build(b: *std.Build) !void {
         b.installFile(file, b.fmt("share/pkgconfig/{s}", .{pc}));
     }
 
-    const config = .{
+    const config: Config = .{
         .target = target,
         .optimize = optimize,
         .pic = pic,
@@ -350,6 +326,119 @@ pub fn build(b: *std.Build) !void {
     }
 }
 
+fn buildWasm(
+    b: *std.Build,
+    name: []const u8,
+    root_src_file: []const u8,
+    optimize: std.builtin.OptimizeMode,
+    strip: ?bool,
+    pic: ?bool,
+    wasm_stack_size: u64,
+    import: ?*std.Build.Module,
+    options: anytype,
+) !void {
+    const entry = @hasDecl(Step.Compile, "Entry");
+    const mode = switch (optimize) {
+        .ReleaseFast, .ReleaseSafe => .ReleaseSmall,
+        else => optimize,
+    };
+    // https://webassembly.org/features/
+    var features = std.Target.wasm.featureSet(&.{
+        .atomics,
+        .bulk_memory,
+        // .exception_handling,
+        .extended_const,
+        // .half_precision,
+        // .multimemory,
+        .mutable_globals,
+        .nontrapping_fptoint,
+        .reference_types,
+        // .relaxed_simd,
+        .sign_ext,
+        .simd128,
+        // .tail_call,
+    });
+    if (builtin.zig_version.order(try std.SemanticVersion.parse("0.12.0")) != .lt) {
+        features.addFeature(@intFromEnum(std.Target.wasm.Feature.multivalue));
+    }
+    const freestanding = if (@hasDecl(std.Build, "resolveTargetQuery"))
+        b.resolveTargetQuery(.{
+            .cpu_arch = .wasm32,
+            .os_tag = .freestanding,
+            .cpu_features_add = features,
+        })
+    else
+        ResolvedTarget{
+            .cpu_arch = .wasm32,
+            .os_tag = .freestanding,
+            .cpu_features_add = features,
+        };
+    const path = if (has_path) .{ .path = root_src_file } else b.path(root_src_file);
+    const bin = if (entry) bin: {
+        const exe = b.addExecutable(if (force_pic) .{
+            .name = name,
+            .root_source_file = path,
+            .optimize = mode,
+            .target = freestanding,
+        } else .{
+            .name = name,
+            .root_source_file = path,
+            .optimize = mode,
+            .target = freestanding,
+            .strip = strip,
+            .pic = pic,
+        });
+
+        var file = try std.fs.cwd().openFile(root_src_file, .{});
+        defer file.close();
+        const bytes = try file.readToEndAlloc(b.allocator, std.math.maxInt(usize));
+        (if (root_module) exe.root_module else exe).export_symbol_names = try exports(b, bytes);
+        exe.entry = .disabled;
+        break :bin exe;
+    } else bin: {
+        const lib = b.addSharedLibrary(.{
+            .name = name,
+            .root_source_file = path,
+            .optimize = mode,
+            .target = freestanding,
+        });
+        lib.rdynamic = true;
+        break :bin lib;
+    };
+    if (import) |i| {
+        if (root_module) {
+            bin.root_module.addImport("pkmn", i);
+        } else {
+            bin.addModule("pkmn", i);
+        }
+    }
+    bin.stack_size = wasm_stack_size;
+    if (@hasDecl(@TypeOf(bin.*), "strip")) bin.strip = strip orelse false;
+    if (force_pic and pic orelse false) bin.force_pic = pic;
+    (if (root_module) bin.root_module else bin).addOptions("build_options", options);
+
+    const opt = b.findProgram(&.{"wasm-opt"}, &.{"./node_modules/.bin"}) catch null;
+    if (optimize != .Debug and opt != null) {
+        const out = b.fmt("build/lib/{s}.wasm", .{name});
+        const sh = b.addSystemCommand(&.{ opt.?, "--enable-bulk-memory", "--enable-simd", "-O4" });
+        sh.addArtifactArg(bin);
+        sh.addArg("-o");
+        if (@hasDecl(@TypeOf(sh.*), "addFileSourceArg")) {
+            sh.addFileSourceArg(if (has_path) .{ .path = out } else b.path(out));
+        } else {
+            sh.addFileArg(if (has_path) .{ .path = out } else b.path(out));
+        }
+        b.getInstallStep().dependOn(&sh.step);
+        if (!entry) b.installArtifact(bin);
+    } else if (entry) {
+        b.getInstallStep().dependOn(&b.addInstallArtifact(bin, .{
+            .dest_dir = .{ .override = std.Build.InstallDir{ .lib = {} } },
+        }).step);
+    } else {
+        b.installArtifact(bin);
+    }
+}
+
 fn maybeStrip(
     b: *std.Build,
     artifact: *Step.Compile,
@@ -433,10 +522,7 @@ const ToolConfig = struct {
 };
 
 fn tool(b: *std.Build, path: []const u8, config: ToolConfig) !?*Step.Run {
-    std.fs.cwd().access(path, .{}) catch |err| switch (err) {
-        error.FileNotFound => return null,
-        else => |e| return e,
-    };
+    if (!try exists(path)) return null;
     var name = config.tool.name orelse std.fs.path.basename(path);
     const index = std.mem.lastIndexOfScalar(u8, name, '.');
     if (index) |i| name = name[0..i];
@@ -478,6 +564,14 @@ fn tool(b: *std.Build, path: []const u8, config: ToolConfig) !?*Step.Run {
     return run;
 }
 
+fn exists(path: []const u8) !bool {
+    std.fs.cwd().access(path, .{}) catch |err| switch (err) {
+        error.FileNotFound => return false,
+        else => |e| return e,
+    };
+    return true;
+}
+
 const ToolsStep = struct {
     step: std.Build.Step,
 
@@ -494,3 +588,21 @@ fn detect(target: anytype) std.Target {
     if (@hasField(@TypeOf(target), "result")) return target.result;
     return (std.zig.system.NativeTargetInfo.detect(target) catch unreachable).target;
 }
+
+pub fn exports(b: *std.Build, bytes: []const u8) ![][]const u8 {
+    var symbols = std.ArrayList([]const u8).init(b.allocator);
+
+    var it = std.mem.splitSequence(u8, bytes, "export ");
+    _ = it.next();
+    while (it.next()) |s| {
+        if (std.mem.startsWith(u8, s, "const ")) {
+            const i = std.mem.indexOf(u8, s[6..], " ").?;
+            try symbols.append(s[6 .. 6 + i]);
+        } else { // "fn "
+            const i = std.mem.indexOf(u8, s[3..], "(").?;
+            try symbols.append(s[3 .. 3 + i]);
+        }
+    }
+
+    return symbols.items;
+}

package/package.json

@@ -1,19 +1,31 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.f4ba6ebd",
+  "version": "0.1.0-dev.f6545544",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
   "sideEffects": false,
   "main": "build/pkg/index.js",
   "types": "build/pkg/index.d.ts",
+  "browser": {
+    "./build/pkg/addon/node.js": "./build/pkg/addon/browser.js"
+  },
   "files": [
     "build.zig",
-    "build/pkg/data.d.ts",
-    "build/pkg/data.js.map",
     "build/pkg/addon.d.ts",
     "build/pkg/addon.js.map",
     "build/pkg/addon.js",
+    "build/pkg/addon/browser.d.ts",
+    "build/pkg/addon/browser.js.map",
+    "build/pkg/addon/browser.js",
+    "build/pkg/addon/node.d.ts",
+    "build/pkg/addon/node.js.map",
+    "build/pkg/addon/node.js",
+    "build/pkg/addon/wasm.d.ts",
+    "build/pkg/addon/wasm.js.map",
+    "build/pkg/addon/wasm.js",
+    "build/pkg/data.d.ts",
+    "build/pkg/data.js.map",
     "build/pkg/data.js",
     "build/pkg/data/ids.json",
     "build/pkg/data/layout.json",
@@ -27,15 +39,24 @@
     "build/pkg/protocol.d.ts",
     "build/pkg/protocol.js.map",
     "build/pkg/protocol.js",
-    "build/test/display.js.map",
-    "build/test/display.js",
     "build/tools/debug.js.map",
     "build/tools/debug.js",
+    "build/tools/display/index.js.map",
+    "build/tools/display/index.js",
+    "build/tools/display/debug.jsx.map",
+    "build/tools/display/debug.jsx",
+    "build/tools/display/ui.jsx.map",
+    "build/tools/display/ui.jsx",
+    "build/tools/display/util.js.map",
+    "build/tools/display/util.js",
+    "src/lib/bindings/c.zig",
+    "src/lib/bindings/node.zig",
+    "src/lib/bindings/wasm.zig",
+    "src/lib/common/array.zig",
     "src/lib/common/battle.zig",
     "src/lib/common/data.zig",
     "src/lib/common/debug.zig",
     "src/lib/common/js.zig",
-    "src/lib/common/array.zig",
     "src/lib/common/optional.zig",
     "src/lib/common/options.zig",
     "src/lib/common/protocol.zig",
@@ -63,7 +84,8 @@
     "src/lib/node.zig",
     "src/lib/pkmn.zig",
     "src/lib/wasm.zig",
-    "src/test/display/pkmn.html.tmpl"
+    "src/tools/display/dom.ts",
+    "src/tools/display/ui.css"
   ],
   "engines": {
     "node": ">=16.0.0"
@@ -76,160 +98,54 @@
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.9.11",
-    "@pkmn/protocol": "^0.6.25"
+    "@pkmn/data": "^0.9.23",
+    "@pkmn/protocol": "^0.6.29"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^8.1.0",
-    "@pkmn/img": "^0.2.31",
+    "@pkmn/eslint-config": "^9.3.0",
+    "@pkmn/img": "^0.2.33",
     "@pkmn/sets": "^5.1.2",
-    "@pkmn/sim": "0.9.11",
+    "@pkmn/sim": "0.9.23",
+    "@pkmn/smogon": "^0.5.15",
     "@types/html-minifier": "^4.0.5",
-    "@types/jest": "^29.5.12",
+    "@types/jest": "^29.5.14",
     "@types/minimist": "^1.2.5",
     "@types/mustache": "^4.2.5",
-    "@types/node": "^22.0.2",
+    "@types/node": "^22.9.3",
+    "@types/react": "^18.3.12",
     "@types/semver": "^7.5.8",
-    "@vitest/coverage-v8": "^2.0.5",
-    "binaryen": "^118.0.0",
-    "eslint": "<=8",
+    "@types/vscode": "^1.95.0",
+    "@vitest/coverage-v8": "^2.1.5",
+    "@vscode/vsce": "^3.2.1",
+    "binaryen": "^120.0.0",
+    "esbuild": "^0.24.0",
+    "eslint": "^9.15.0",
     "html-minifier": "^4.0.0",
-    "json-stringify-pretty-compact": "4.0.0",
+    "json-stringify-pretty-compact": "3.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
     "semver": "^7.6.3",
     "source-map-support": "^0.5.21",
     "table": "^6.8.2",
     "trakr": "^0.2.0",
-    "typescript": "^5.5.4",
-    "vitest": "^2.0.5"
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.5"
   },
   "scripts": {
-    "lint": "eslint --cache src --ext ts,js && eslint src/bin/*",
-    "fix": "eslint --fix src --ext ts,js && eslint --fix src/bin/*",
+    "lint": "eslint --cache src",
+    "fix": "eslint --fix src",
     "compile": "tsc -p .",
     "build": "npm run compile",
     "test": "vitest src/pkg",
     "test:integration": "vitest src/test",
     "debug": "npm run compile && node build/tools/debug",
+    "demo": "npm run compile && node build/tools/demo",
     "fuzz": "npm run compile && node build/test/fuzz",
     "generate": "npm run compile && node build/tools/generate",
     "release": "npm run compile && node build/tools/release",
     "benchmark": "npm run compile && node build/test/benchmark",
     "integration": "npm run compile && node build/test/integration",
+    "extension": "npm -C src/tools/vscode run build",
     "postinstall": "node src/bin/install-pkmn-engine"
-  },
-  "eslintConfig": {
-    "extends": "@pkmn",
-    "ignorePatterns": [
-      "dist/",
-      "node_modules/",
-      "examples/zig",
-      "build/"
-    ],
-    "env": {
-      "es6": true,
-      "node": true,
-      "browser": true
-    },
-    "overrides": [
-      {
-        "files": [
-          "**/*.ts"
-        ],
-        "parserOptions": {
-          "project": [
-            "./tsconfig.json",
-            "./examples/js/tsconfig.json"
-          ]
-        }
-      },
-      {
-        "files": [
-          "src/test/display.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/no-unnecessary-type-assertion": "off"
-        }
-      },
-      {
-        "files": [
-          "src/pkg/index.ts",
-          "src/test/display.ts",
-          "src/test/integration.ts"
-        ],
-        "rules": {
-          "no-control-regex": "off",
-          "@typescript-eslint/no-empty-interface": "off",
-          "@typescript-eslint/no-shadow": "off",
-          "@typescript-eslint/no-unsafe-declaration-merging": "off"
-        }
-      },
-      {
-        "files": [
-          "src/pkg/addon.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/no-var-requires": "off"
-        }
-      },
-      {
-        "files": [
-          "src/test/benchmark*.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/no-unused-vars": "off",
-          "@typescript-eslint/no-redundant-type-constituents": "off"
-        }
-      },
-      {
-        "files": [
-          "src/pkg/protocol.test.ts"
-        ],
-        "rules": {
-          "jest/no-standalone-expect": "off",
-          "jest/no-conditional-expect": "off"
-        }
-      },
-      {
-        "files": [
-          "src/test/*.test.ts",
-          "src/test/regression/*.test.ts"
-        ],
-        "rules": {
-          "jest/no-standalone-expect": "off"
-        }
-      },
-      {
-        "files": [
-          "src/test/showdown/**"
-        ],
-        "rules": {
-          "jest/expect-expect": [
-            "warn",
-            {
-              "assertFunctionNames": [
-                "expect",
-                "expectLog",
-                "verify"
-              ]
-            }
-          ]
-        }
-      },
-      {
-        "files": [
-          "src/tools/generate.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/restrict-template-expressions": [
-            "error",
-            {
-              "allowBoolean": true
-            }
-          ]
-        }
-      }
-    ]
   }
 }

package/src/bin/install-pkmn-engine

@@ -257,7 +257,7 @@ const downloadImportLib = async () => {
   }
 
   const dir = path.join(ROOT, 'build', 'lib');
-  const url = new URL('./win-x64/node.lib', process.release.headersUrl).href;
+  const url = process.release.libUrl;
   const dest = path.join(dir, path.basename(url));
   if (fs.existsSync(path.join(dest))) {
     log('Node import library:', dest);
@@ -325,6 +325,7 @@ const downloadImportLib = async () => {
   const libs = path.join(ROOT, 'build', 'lib');
   if (fs.existsSync(libs)) {
     for (const file of fs.readdirSync(libs)) {
+      if (!file.startsWith('pkmn')) continue;
       const type = path.extname(file).slice(1);
       if (type !== 'node' && type !== 'wasm') continue;
       // If we don't copy the addon before loading it Windows will return an
@@ -393,7 +394,7 @@ const downloadImportLib = async () => {
       try {
         const actual = path.join(ROOT, 'build', 'lib', `${prefix}pkmn${suffix}.node.${ext}`);
         fs.renameSync(actual, artifact);
-      } catch (err) {
+      } catch {
         // ziglang/zig#19743 changed this path
         const actual = path.join(ROOT, 'build', 'bin', `${prefix}pkmn${suffix}.node.${ext}`);
         fs.renameSync(actual, artifact);

package/src/bin/pkmn-debug

@@ -15,7 +15,7 @@ const ROOT = resolve(__dirname, '..', '..');
 const packageJSON = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'));
 
 const missing = [];
-for (const dep of ['@pkmn/img', 'html-minifier', 'mustache']) {
+for (const dep of ['@pkmn/img', 'html-minifier', 'esbuild']) {
   try {
     require.resolve(dep);
   } catch (e) {