@pkmn/engine 0.1.0-dev.8b83af6b → 0.1.0-dev.8c935a85

package/package.json

@@ -1,19 +1,31 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.8b83af6b",
+  "version": "0.1.0-dev.8c935a85",
   "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,33 +39,53 @@
     "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",
-    "src/bin/install-pkmn-engine",
-    "src/lib/binding/node.zig",
-    "src/lib/binding/wasm.zig",
+    "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/optional.zig",
     "src/lib/common/options.zig",
     "src/lib/common/protocol.zig",
+    "src/lib/common/rational.zig",
     "src/lib/common/rng.zig",
+    "src/lib/common/util.zig",
+    "src/lib/gen1/calc.zig",
+    "src/lib/gen1/chance.zig",
     "src/lib/gen1/data.zig",
     "src/lib/gen1/data/moves.zig",
     "src/lib/gen1/data/species.zig",
     "src/lib/gen1/data/types.zig",
     "src/lib/gen1/helpers.zig",
     "src/lib/gen1/mechanics.zig",
+    "src/lib/gen2/calc.zig",
+    "src/lib/gen2/chance.zig",
     "src/lib/gen2/data.zig",
     "src/lib/gen2/data/items.zig",
     "src/lib/gen2/data/moves.zig",
     "src/lib/gen2/data/species.zig",
     "src/lib/gen2/data/types.zig",
+    "src/lib/gen2/generated.zig",
     "src/lib/gen2/helpers.zig",
     "src/lib/gen2/mechanics.zig",
+    "src/lib/node.zig",
     "src/lib/pkmn.zig",
-    "src/test/display/pkmn.html.tmpl"
+    "src/lib/wasm.zig",
+    "src/tools/display/dom.ts",
+    "src/tools/display/ui.css"
   ],
   "engines": {
     "node": ">=16.0.0"
@@ -66,138 +98,54 @@
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.7.44",
-    "@pkmn/protocol": "^0.6.12"
+    "@pkmn/data": "^0.9.28",
+    "@pkmn/protocol": "^0.6.30"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^3.2.0",
-    "@pkmn/img": "^0.2.12",
-    "@pkmn/sets": "^5.0.4",
-    "@pkmn/sim": "0.7.44",
-    "@types/html-minifier": "^4.0.2",
-    "@types/jest": "^29.5.2",
-    "@types/minimist": "^1.2.2",
-    "@types/mustache": "^4.2.2",
-    "@types/node": "^20.3.1",
-    "@vitest/coverage-c8": "^0.32.2",
-    "binaryen": "^113.0.0",
-    "eslint": "^8.43.0",
+    "@pkmn/eslint-config": "^9.6.0",
+    "@pkmn/img": "^0.2.34",
+    "@pkmn/sets": "^5.1.2",
+    "@pkmn/sim": "0.9.28",
+    "@pkmn/smogon": "^0.5.18",
+    "@types/html-minifier": "^4.0.5",
+    "@types/jest": "^29.5.14",
+    "@types/minimist": "^1.2.5",
+    "@types/mustache": "^4.2.5",
+    "@types/node": "^22.13.0",
+    "@types/react": "<=18",
+    "@types/semver": "^7.5.8",
+    "@types/vscode": "^1.96.0",
+    "@vitest/coverage-v8": "^3.0.5",
+    "@vscode/vsce": "^3.2.2",
+    "binaryen": "^122.0.0",
+    "esbuild": "^0.24.2",
+    "eslint": "^9.19.0",
     "html-minifier": "^4.0.0",
     "json-stringify-pretty-compact": "3.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
+    "semver": "^7.7.0",
     "source-map-support": "^0.5.21",
+    "table": "^6.9.0",
     "trakr": "^0.2.0",
-    "typescript": "^5.1.3",
-    "vitest": "^0.32.2"
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.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/",
-      "src/examples/zig",
-      "build/"
-    ],
-    "env": {
-      "es6": true,
-      "node": true,
-      "browser": true
-    },
-    "overrides": [
-      {
-        "files": [
-          "**/*.ts"
-        ],
-        "parserOptions": {
-          "project": [
-            "./tsconfig.json",
-            "./src/examples/js/tsconfig.json"
-          ]
-        }
-      },
-      {
-        "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"
-        }
-      },
-      {
-        "files": [
-          "src/pkg/addon.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/no-var-requires": "off"
-        }
-      },
-      {
-        "files": [
-          "src/test/benchmark*.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/no-unused-vars": "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

@@ -10,7 +10,7 @@ const path = require('path');
 const {pipeline} = require('stream/promises');
 const tty = require('tty');
 
-const ZIG_VERSION = {major: 0, minor: 11, patch: 0, dev: 3859};
+const ZIG_VERSION = {major: 0, minor: 11, patch: 0};
 const DEV = ZIG_VERSION.dev ? `-dev.${ZIG_VERSION.dev}` : '';
 const VERSION = `${ZIG_VERSION.major}.${ZIG_VERSION.minor}.${ZIG_VERSION.patch}${DEV}`;
 const INDEX = 'https://ziglang.org/download/index.json';
@@ -163,8 +163,10 @@ const install = async () => {
   }
 
   const index = JSON.parse(await fetch(INDEX));
-  const version = Object.keys(index)[+!ZIG_VERSION.dev];
-  const release = index[version][`${arch}-${platform}`];
+  // TODO: ziglang/zig#17768
+  // const version = Object.keys(index)[+!ZIG_VERSION.dev];
+  const version = VERSION;
+  const release = index[VERSION][`${arch}-${platform}`];
   const url = release.tarball;
 
   let base = path.basename(url);
@@ -255,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);
@@ -283,19 +285,19 @@ const downloadImportLib = async () => {
   let error = false;
   for (let i = 2; i < process.argv.length; i++) {
     switch (process.argv[i]) {
-    case "--silent": {
-      SILENT = true;
-      break;
-    }
-    case "--zig": {
-      if (options || only) error = true;
-      only = true;
-      break;
-    }
-    default: {
-      if (options || only || !process.argv[i].startsWith('--options=')) error = true;
-      options = process.argv[i].slice(10).split(' ');
-    }
+      case "--silent": {
+        SILENT = true;
+        break;
+      }
+      case "--zig": {
+        if (options || only) error = true;
+        only = true;
+        break;
+      }
+      default: {
+        if (options || only || !process.argv[i].startsWith('--options=')) error = true;
+        options = process.argv[i].slice(10).split(' ');
+      }
     }
   }
   if (error) {
@@ -323,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
@@ -336,14 +339,18 @@ const downloadImportLib = async () => {
         node = true;
         if (!options) {
           const addon = require(copy);
-          if (addon.options.showdown) opts.push('-Dshowdown');
-          if (addon.options.log) opts.push('-Dlog');
+          if (addon.engine.options.showdown) opts.push('-Dshowdown');
+          if (addon.engine.options.log) opts.push('-Dlog');
+          if (addon.engine.options.chance) opts.push('-Dchance');
+          if (addon.engine.options.calc) opts.push('-Dcalc');
         }
       } else if (!options) {
         const addon = await WebAssembly.instantiate(fs.readFileSync(copy));
         const values = new Uint8Array(addon.instance.exports.memory.buffer);
         if (values[addon.instance.exports.SHOWDOWN.value]) opts.push('-Dshowdown');
         if (values[addon.instance.exports.LOG.value]) opts.push('-Dlog');
+        if (values[addon.instance.exports.CHANCE.value]) opts.push('-Dchance');
+        if (values[addon.instance.exports.CALC.value]) opts.push('-Dcalc');
       }
       const key = `${type} ${opts.sort().join(' ')}`;
       if (!configs.has(key)) configs.set(key, {type, options: opts});
@@ -354,8 +361,9 @@ const downloadImportLib = async () => {
   // either the default options or whatever was passed in
   if (!configs.size) {
     node = true;
-    configs.set('node', {type: 'node', options: options || ['-Dshowdown']});
-    configs.set('wasm', {type: 'wasm', options: options || ['-Dshowdown']});
+    const DEFAULT = ['-Dshowdown'];
+    configs.set('node', {type: 'node', options: options || DEFAULT});
+    configs.set('wasm', {type: 'wasm', options: options || DEFAULT});
   }
 
   const headers = node ? await downloadHeaders() : undefined;
@@ -365,8 +373,10 @@ const downloadImportLib = async () => {
     const args = ['build', '-p', 'build', ...opts];
     if (!process.env.DEBUG_PKMN_ENGINE) args.push('-Doptimize=ReleaseFast', '-Dstrip');
     if (config.type === 'node') {
-      args.push(`-Dnode-headers=${headers}`);
-      if (process.platform === 'win32') args.push(`-Dnode-import-library=${lib}`);
+      args.push(`-Dnode-headers=${path.relative(ROOT, headers)}`);
+      if (process.platform === 'win32') {
+        args.push(`-Dnode-import-library=${path.relative(ROOT, lib)}`);
+      }
     } else {
       args.push('-Dwasm');
     }
@@ -381,8 +391,14 @@ const downloadImportLib = async () => {
       const prefix = process.platform === 'win32' ? '' : 'lib';
       const ext = process.platform === 'darwin'
         ? 'dylib' : process.platform === 'win32' ? 'dll' : 'so';
-      const actual = path.join('build', 'lib', `${prefix}pkmn${suffix}.node.${ext}`);
-      fs.renameSync(path.join(ROOT, actual), path.join(ROOT, artifact));
+      try {
+        const actual = path.join(ROOT, 'build', 'lib', `${prefix}pkmn${suffix}.node.${ext}`);
+        fs.renameSync(actual, artifact);
+      } catch {
+        // ziglang/zig#19743 changed this path
+        const actual = path.join(ROOT, 'build', 'bin', `${prefix}pkmn${suffix}.node.${ext}`);
+        fs.renameSync(actual, artifact);
+      }
     }
   }
 })().catch(e => {

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) {

package/src/lib/bindings/c.zig

@@ -0,0 +1,255 @@
+const pkmn = @import("../pkmn.zig");
+const std = @import("std");
+
+const assert = std.debug.assert;
+
+const ERROR: u8 = 0b1100;
+
+const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
+const Strong = if (@hasField(std.builtin.GlobalLinkage, "strong")) .strong else .Strong;
+
+pub const OPTIONS: extern struct {
+    showdown: bool,
+    log: bool,
+    chance: bool,
+    calc: bool,
+} = .{
+    .showdown = pkmn.options.showdown,
+    .log = pkmn.options.log,
+    .chance = pkmn.options.chance,
+    .calc = pkmn.options.calc,
+};
+
+pub const MAX_CHOICES = pkmn.MAX_CHOICES;
+pub const CHOICES_SIZE = pkmn.CHOICES_SIZE;
+pub const MAX_LOGS = pkmn.MAX_LOGS;
+pub const LOGS_SIZE = pkmn.LOGS_SIZE;
+
+pub fn choice_init(choice: u8, data: u8) callconv(.C) u8 {
+    assert(choice <= @field(@typeInfo(pkmn.Choice.Type), @tagName(Enum)).fields.len);
+    assert(data <= 6);
+    return @bitCast(pkmn.Choice{ .type = @enumFromInt(choice), .data = @intCast(data) });
+}
+
+pub fn choice_type(choice: u8) callconv(.C) u8 {
+    return @intFromEnum(@as(pkmn.Choice, @bitCast(choice)).type);
+}
+
+pub fn choice_data(choice: u8) callconv(.C) u8 {
+    return @as(u8, @as(pkmn.Choice, @bitCast(choice)).data);
+}
+
+pub fn result_type(result: u8) callconv(.C) u8 {
+    return @intFromEnum(@as(pkmn.Result, @bitCast(result)).type);
+}
+
+pub fn result_p1(result: u8) callconv(.C) u8 {
+    assert(!err(result));
+    return @intFromEnum(@as(pkmn.Result, @bitCast(result)).p1);
+}
+
+pub fn result_p2(result: u8) callconv(.C) u8 {
+    assert(!err(result));
+    return @intFromEnum(@as(pkmn.Result, @bitCast(result)).p2);
+}
+
+pub fn err(result: u8) callconv(.C) bool {
+    return result == ERROR;
+}
+
+pub fn psrng_init(prng: *pkmn.PSRNG, seed: u64) callconv(.C) void {
+    prng.src = .{ .seed = seed };
+}
+
+pub fn psrng_next(prng: *pkmn.PSRNG) callconv(.C) u32 {
+    return prng.next();
+}
+
+pub fn rational_init(rational: *pkmn.Rational(f64)) callconv(.C) void {
+    rational.reset();
+}
+
+pub fn rational_reduce(rational: *pkmn.Rational(f64)) callconv(.C) void {
+    rational.reduce();
+}
+
+pub fn rational_numerator(rational: *const pkmn.Rational(f64)) callconv(.C) f64 {
+    return rational.p;
+}
+
+pub fn rational_denominator(rational: *const pkmn.Rational(f64)) callconv(.C) f64 {
+    return rational.q;
+}
+
+const log_options = extern struct {
+    buf: [*]u8,
+    len: usize,
+};
+
+pub fn gen(comptime num: comptime_int) type {
+    const g = @field(pkmn, "gen" ++ std.fmt.comptimePrint("{d}", .{num}));
+
+    return struct {
+        pub const MAX_CHOICES = g.MAX_CHOICES;
+        pub const CHOICES_SIZE = g.CHOICES_SIZE;
+        pub const MAX_LOGS = g.MAX_LOGS;
+        pub const LOGS_SIZE = g.LOGS_SIZE;
+
+        const chance_options = extern struct {
+            probability: pkmn.Rational(f64),
+            actions: g.chance.Actions,
+            durations: g.chance.Durations,
+        };
+
+        const calc_options = extern struct {
+            overrides: g.chance.Actions,
+        };
+
+        const battle_options = struct {
+            stream: pkmn.protocol.ByteStream,
+            log: pkmn.protocol.FixedLog,
+            chance: g.Chance(pkmn.Rational(f64)),
+            calc: g.Calc,
+
+            comptime {
+                assert(@sizeOf(battle_options) <= 128);
+            }
+        };
+
+        pub fn battle_options_set(
+            options: *battle_options,
+            log: ?*const log_options,
+            chance: ?*const chance_options,
+            calc: ?*const calc_options,
+        ) callconv(.C) void {
+            if (pkmn.options.log) {
+                if (log) |l| {
+                    options.stream = .{ .buffer = l.buf[0..l.len] };
+                    options.log = .{ .writer = options.stream.writer() };
+                } else {
+                    options.stream.reset();
+                }
+            }
+            if (pkmn.options.chance) {
+                if (chance) |c| {
+                    options.chance = .{
+                        .probability = c.probability,
+                        .actions = c.actions,
+                        .durations = c.durations,
+                    };
+                } else {
+                    options.chance.reset();
+                }
+            }
+            if (pkmn.options.calc) {
+                if (calc) |c| {
+                    options.calc = .{ .overrides = c.overrides };
+                } else {
+                    options.calc = .{};
+                }
+            }
+        }
+
+        pub fn battle_options_chance_probability(
+            options: *battle_options,
+        ) callconv(.C) *pkmn.Rational(f64) {
+            return &options.chance.probability;
+        }
+
+        pub fn battle_options_chance_actions(
+            options: *battle_options,
+        ) callconv(.C) *g.chance.Actions {
+            return &options.chance.actions;
+        }
+
+        pub fn battle_options_chance_durations(
+            options: *battle_options,
+        ) callconv(.C) *g.chance.Durations {
+            return &options.chance.durations;
+        }
+
+        pub fn battle_options_calc_summaries(
+            options: *battle_options,
+        ) callconv(.C) *g.calc.Summaries {
+            return &options.calc.summaries;
+        }
+
+        pub fn battle_update(
+            battle: *g.Battle(g.PRNG),
+            c1: pkmn.Choice,
+            c2: pkmn.Choice,
+            opts: ?*battle_options,
+        ) callconv(.C) pkmn.Result {
+            if ((pkmn.options.log or pkmn.options.chance or pkmn.options.calc) and opts != null) {
+                return battle.update(c1, c2, opts.?) catch return @bitCast(ERROR);
+            }
+            return battle.update(c1, c2, &g.NULL) catch unreachable;
+        }
+
+        pub fn battle_choices(
+            battle: *const g.Battle(g.PRNG),
+            player: u8,
+            request: u8,
+            out: [*]u8,
+            n: usize,
+        ) callconv(.C) u8 {
+            assert(player <= @field(@typeInfo(pkmn.Player), @tagName(Enum)).fields.len);
+            assert(request <= @field(@typeInfo(pkmn.Choice.Type), @tagName(Enum)).fields.len);
+
+            assert(!pkmn.options.showdown or n > 0);
+            return battle.choices(@enumFromInt(player), @enumFromInt(request), @ptrCast(out[0..n]));
+        }
+    };
+}
+
+pub fn exports() type {
+    @export(choice_init, .{ .name = "pkmn_choice_init", .linkage = Strong });
+    @export(choice_type, .{ .name = "pkmn_choice_type", .linkage = Strong });
+    @export(choice_data, .{ .name = "pkmn_choice_data", .linkage = Strong });
+
+    @export(result_type, .{ .name = "pkmn_result_type", .linkage = Strong });
+    @export(result_p1, .{ .name = "pkmn_result_p1", .linkage = Strong });
+    @export(result_p2, .{ .name = "pkmn_result_p2", .linkage = Strong });
+
+    @export(err, .{ .name = "pkmn_error", .linkage = Strong });
+
+    @export(psrng_init, .{ .name = "pkmn_psrng_init", .linkage = Strong });
+    @export(psrng_next, .{ .name = "pkmn_psrng_next", .linkage = Strong });
+
+    @export(rational_init, .{ .name = "pkmn_rational_init", .linkage = Strong });
+    @export(rational_reduce, .{ .name = "pkmn_rational_reduce", .linkage = Strong });
+    @export(rational_numerator, .{ .name = "pkmn_rational_numerator", .linkage = Strong });
+    @export(rational_denominator, .{ .name = "pkmn_rational_denominator", .linkage = Strong });
+
+    @export(
+        gen(1).battle_options_set,
+        .{ .name = "pkmn_gen1_battle_options_set", .linkage = Strong },
+    );
+    @export(
+        gen(1).battle_options_chance_probability,
+        .{ .name = "pkmn_gen1_battle_options_chance_probability", .linkage = Strong },
+    );
+    @export(
+        gen(1).battle_options_chance_actions,
+        .{ .name = "pkmn_gen1_battle_options_chance_actions", .linkage = Strong },
+    );
+    @export(
+        gen(1).battle_options_chance_durations,
+        .{ .name = "pkmn_gen1_battle_options_chance_durations", .linkage = Strong },
+    );
+    @export(
+        gen(1).battle_options_calc_summaries,
+        .{ .name = "pkmn_gen1_battle_options_calc_summaries", .linkage = Strong },
+    );
+
+    @export(
+        gen(1).battle_update,
+        .{ .name = "pkmn_gen1_battle_update", .linkage = Strong },
+    );
+    @export(
+        gen(1).battle_choices,
+        .{ .name = "pkmn_gen1_battle_choices", .linkage = Strong },
+    );
+
+    return struct {};
+}