@latticexyz/cli 2.2.18-8d0ce55e964e646a1c804c401df01c4deb866f30 → 2.2.18-9fa07c8489f1fbf167d0db01cd9aaa645a29c8e2

package/dist/mud.cjs

@@ -0,0 +1,3566 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/tsup@8.3.0_@microsoft+api-extractor@7.47.7_@types+node@20.17.16__jiti@1.21.6_postcss@8.5.1_ts_rihtmhm6tp3cagz6w7ivhbdyn4/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.3.0_@microsoft+api-extractor@7.47.7_@types+node@20.17.16__jiti@1.21.6_postcss@8.5.1_ts_rihtmhm6tp3cagz6w7ivhbdyn4/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  logError: () => logError
+});
+function logError(error4) {
+  if (error4 instanceof import_zod_validation_error.ValidationError) {
+    console.log(import_chalk.default.redBright(error4.message));
+  } else if (error4 instanceof import_zod.ZodError) {
+    const validationError = (0, import_zod_validation_error.fromZodError)(error4, {
+      prefixSeparator: "\n- ",
+      issueSeparator: "\n- "
+    });
+    console.log(import_chalk.default.redBright(validationError.message));
+  } else if (error4 instanceof import_errors.MUDError) {
+    console.log(import_chalk.default.red(error4));
+  } else {
+    console.log(error4);
+  }
+}
+var import_chalk, import_zod, import_zod_validation_error, import_errors;
+var init_errors = __esm({
+  "src/utils/errors.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_chalk = __toESM(require("chalk"), 1);
+    import_zod = require("zod");
+    import_zod_validation_error = require("zod-validation-error");
+    import_errors = require("@latticexyz/common/errors");
+  }
+});
+
+// src/build.ts
+async function build({ rootDir, config: config2, foundryProfile }) {
+  await Promise.all([(0, import_codegen.tablegen)({ rootDir, config: config2 }), (0, import_node.worldgen)({ rootDir, config: config2 })]);
+  await (0, import_foundry.forge)(["build"], { profile: foundryProfile });
+  await (0, import_node.buildSystemsManifest)({ rootDir, config: config2 });
+  await (0, import_execa.execa)("mud", ["abi-ts"], { stdio: "inherit" });
+}
+var import_codegen, import_node, import_foundry, import_execa;
+var init_build = __esm({
+  "src/build.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_codegen = require("@latticexyz/store/codegen");
+    import_node = require("@latticexyz/world/node");
+    import_foundry = require("@latticexyz/common/foundry");
+    import_execa = require("execa");
+  }
+});
+
+// src/commands/build.ts
+var import_node2, import_node_path, commandModule, build_default;
+var init_build2 = __esm({
+  "src/commands/build.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node2 = require("@latticexyz/config/node");
+    init_build();
+    import_node_path = __toESM(require("path"), 1);
+    commandModule = {
+      command: "build",
+      describe: "Build contracts and generate MUD artifacts (table libraries, world interface, ABI)",
+      builder(yargs) {
+        return yargs.options({
+          configPath: { type: "string", desc: "Path to the MUD config file" },
+          profile: { type: "string", desc: "The foundry profile to use" }
+        });
+      },
+      async handler(opts) {
+        const configPath = await (0, import_node2.resolveConfigPath)(opts.configPath);
+        const config2 = await (0, import_node2.loadConfig)(configPath);
+        await build({ rootDir: import_node_path.default.dirname(configPath), config: config2, foundryProfile: opts.profile });
+        process.exit(0);
+      }
+    };
+    build_default = commandModule;
+  }
+});
+
+// src/commands/devnode.ts
+var import_fs, import_os, import_path, import_execa2, commandModule2, devnode_default;
+var init_devnode = __esm({
+  "src/commands/devnode.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs = require("fs");
+    import_os = require("os");
+    import_path = __toESM(require("path"), 1);
+    import_execa2 = require("execa");
+    commandModule2 = {
+      command: "devnode",
+      describe: "Start a local Ethereum node for development",
+      builder(yargs) {
+        return yargs.options({
+          blocktime: { type: "number", default: 1, decs: "Interval in which new blocks are produced" }
+        });
+      },
+      async handler({ blocktime }) {
+        console.log("Clearing devnode history");
+        const userHomeDir = (0, import_os.homedir)();
+        (0, import_fs.rmSync)(import_path.default.join(userHomeDir, ".foundry", "anvil", "tmp"), { recursive: true, force: true });
+        const anvilArgs = ["-b", String(blocktime), "--block-base-fee-per-gas", "0"];
+        console.log(`Running: anvil ${anvilArgs.join(" ")}`);
+        const child = (0, import_execa2.execa)("anvil", anvilArgs, {
+          stdio: ["inherit", "inherit", "inherit"]
+        });
+        process.on("SIGINT", () => {
+          console.log("\ngracefully shutting down from SIGINT (Crtl-C)");
+          child.kill();
+          process.exit();
+        });
+        await child;
+      }
+    };
+    devnode_default = commandModule2;
+  }
+});
+
+// src/commands/hello.ts
+var commandModule3, hello_default;
+var init_hello = __esm({
+  "src/commands/hello.ts"() {
+    "use strict";
+    init_cjs_shims();
+    commandModule3 = {
+      command: "hello <name>",
+      describe: "Greet <name> with Hello",
+      builder(yargs) {
+        return yargs.options({
+          upper: { type: "boolean" }
+        }).positional("name", { type: "string", demandOption: true });
+      },
+      handler({ name }) {
+        const greeting = `Gm, ${name}!`;
+        console.log(greeting);
+        process.exit(0);
+      }
+    };
+    hello_default = commandModule3;
+  }
+});
+
+// src/commands/tablegen.ts
+var import_node3, import_codegen2, import_node_path2, commandModule4, tablegen_default;
+var init_tablegen = __esm({
+  "src/commands/tablegen.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node3 = require("@latticexyz/config/node");
+    import_codegen2 = require("@latticexyz/store/codegen");
+    import_node_path2 = __toESM(require("path"), 1);
+    commandModule4 = {
+      command: "tablegen",
+      describe: "Autogenerate MUD Store table libraries based on the config file",
+      builder(yargs) {
+        return yargs.options({
+          configPath: { type: "string", desc: "Path to the MUD config file" }
+        });
+      },
+      async handler(opts) {
+        const configPath = await (0, import_node3.resolveConfigPath)(opts.configPath);
+        const config2 = await (0, import_node3.loadConfig)(configPath);
+        await (0, import_codegen2.tablegen)({ rootDir: import_node_path2.default.dirname(configPath), config: config2 });
+        process.exit(0);
+      }
+    };
+    tablegen_default = commandModule4;
+  }
+});
+
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "@latticexyz/cli",
+      version: "2.2.17",
+      description: "Command line interface for mud",
+      repository: {
+        type: "git",
+        url: "https://github.com/latticexyz/mud.git",
+        directory: "packages/cli"
+      },
+      license: "MIT",
+      type: "module",
+      exports: {
+        ".": {
+          import: {
+            import: "./dist/index.js",
+            types: "./dist/index.d.ts"
+          },
+          require: {
+            require: "./dist/index.cjs",
+            types: "./dist/index.d.cts"
+          }
+        }
+      },
+      typesVersions: {
+        "*": {
+          index: [
+            "./dist/index.d.ts"
+          ]
+        }
+      },
+      bin: {
+        mud: "./bin/mud.js"
+      },
+      files: [
+        "bin",
+        "dist"
+      ],
+      scripts: {
+        build: "pnpm run build:js && pnpm run build:test-tables",
+        "build:js": "tsup",
+        "build:test-tables": "tsx ./scripts/generate-test-tables.ts",
+        clean: "pnpm run clean:js && pnpm run clean:test-tables",
+        "clean:js": "shx rm -rf dist",
+        "clean:test-tables": "shx rm -rf src/**/codegen",
+        dev: "tsup --watch",
+        lint: "eslint . --ext .ts",
+        test: "tsc --noEmit && forge test",
+        "test:ci": "pnpm run test"
+      },
+      dependencies: {
+        "@ark/util": "0.2.2",
+        "@aws-sdk/client-kms": "^3.556.0",
+        "@latticexyz/abi-ts": "workspace:*",
+        "@latticexyz/block-logs-stream": "workspace:*",
+        "@latticexyz/common": "workspace:*",
+        "@latticexyz/config": "workspace:*",
+        "@latticexyz/gas-report": "workspace:*",
+        "@latticexyz/protocol-parser": "workspace:*",
+        "@latticexyz/schema-type": "workspace:*",
+        "@latticexyz/store": "workspace:*",
+        "@latticexyz/store-sync": "workspace:*",
+        "@latticexyz/utils": "workspace:*",
+        "@latticexyz/world": "workspace:*",
+        "@latticexyz/world-module-callwithsignature": "workspace:*",
+        "@latticexyz/world-module-metadata": "workspace:*",
+        abitype: "1.0.6",
+        "asn1.js": "^5.4.1",
+        chalk: "^5.0.1",
+        chokidar: "^3.5.3",
+        debug: "^4.3.4",
+        dotenv: "^16.0.3",
+        execa: "^9.5.2",
+        "find-up": "^6.3.0",
+        glob: "^10.4.2",
+        openurl: "^1.1.1",
+        "p-queue": "^7.4.1",
+        "p-retry": "^5.1.2",
+        path: "^0.12.7",
+        rxjs: "7.5.5",
+        "throttle-debounce": "^5.0.0",
+        toposort: "^2.0.2",
+        viem: "2.21.19",
+        yargs: "^17.7.1",
+        zod: "3.23.8",
+        "zod-validation-error": "^1.3.0"
+      },
+      devDependencies: {
+        "@types/debug": "^4.1.7",
+        "@types/ejs": "^3.1.1",
+        "@types/openurl": "^1.0.0",
+        "@types/throttle-debounce": "^5.0.0",
+        "@types/toposort": "^2.0.6",
+        "@types/yargs": "^17.0.10",
+        "ds-test": "https://github.com/dapphub/ds-test.git#e282159d5170298eb2455a6c05280ab5a73a4ef0",
+        "forge-std": "https://github.com/foundry-rs/forge-std.git#74cfb77e308dd188d2f58864aaf44963ae6b88b1"
+      }
+    };
+  }
+});
+
+// src/deploy/getWorldContracts.ts
+function getWorldContracts(deployerAddress) {
+  const accessManagementSystemDeployedBytecodeSize = (0, import_viem.size)(import_AccessManagementSystem.default.deployedBytecode.object);
+  const accessManagementSystemBytecode = import_AccessManagementSystem.default.bytecode.object;
+  const accessManagementSystem = (0, import_internal.getContractAddress)({
+    deployerAddress,
+    bytecode: accessManagementSystemBytecode
+  });
+  const balanceTransferSystemDeployedBytecodeSize = (0, import_viem.size)(import_BalanceTransferSystem.default.deployedBytecode.object);
+  const balanceTransferSystemBytecode = import_BalanceTransferSystem.default.bytecode.object;
+  const balanceTransferSystem = (0, import_internal.getContractAddress)({
+    deployerAddress,
+    bytecode: balanceTransferSystemBytecode
+  });
+  const batchCallSystemDeployedBytecodeSize = (0, import_viem.size)(import_BatchCallSystem.default.deployedBytecode.object);
+  const batchCallSystemBytecode = import_BatchCallSystem.default.bytecode.object;
+  const batchCallSystem = (0, import_internal.getContractAddress)({ deployerAddress, bytecode: batchCallSystemBytecode });
+  const registrationDeployedBytecodeSize = (0, import_viem.size)(import_RegistrationSystem.default.deployedBytecode.object);
+  const registrationBytecode = import_RegistrationSystem.default.bytecode.object;
+  const registration = (0, import_internal.getContractAddress)({
+    deployerAddress,
+    bytecode: registrationBytecode
+  });
+  const initModuleDeployedBytecodeSize = (0, import_viem.size)(import_InitModule.default.deployedBytecode.object);
+  const initModuleBytecode = (0, import_viem.encodeDeployData)({
+    bytecode: import_InitModule.default.bytecode.object,
+    abi: import_InitModule_abi.default,
+    args: [accessManagementSystem, balanceTransferSystem, batchCallSystem, registration]
+  });
+  const initModule = (0, import_internal.getContractAddress)({ deployerAddress, bytecode: initModuleBytecode });
+  return {
+    AccessManagementSystem: {
+      bytecode: accessManagementSystemBytecode,
+      deployedBytecodeSize: accessManagementSystemDeployedBytecodeSize,
+      debugLabel: "access management system",
+      address: accessManagementSystem
+    },
+    BalanceTransferSystem: {
+      bytecode: balanceTransferSystemBytecode,
+      deployedBytecodeSize: balanceTransferSystemDeployedBytecodeSize,
+      debugLabel: "balance transfer system",
+      address: balanceTransferSystem
+    },
+    BatchCallSystem: {
+      bytecode: batchCallSystemBytecode,
+      deployedBytecodeSize: batchCallSystemDeployedBytecodeSize,
+      debugLabel: "batch call system",
+      address: batchCallSystem
+    },
+    RegistrationSystem: {
+      bytecode: registrationBytecode,
+      deployedBytecodeSize: registrationDeployedBytecodeSize,
+      debugLabel: "core registration system",
+      address: registration
+    },
+    InitModule: {
+      bytecode: initModuleBytecode,
+      deployedBytecodeSize: initModuleDeployedBytecodeSize,
+      debugLabel: "core module",
+      address: initModule
+    }
+  };
+}
+var import_AccessManagementSystem, import_BalanceTransferSystem, import_BatchCallSystem, import_RegistrationSystem, import_InitModule, import_InitModule_abi, import_viem, import_internal;
+var init_getWorldContracts = __esm({
+  "src/deploy/getWorldContracts.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_AccessManagementSystem = __toESM(require("@latticexyz/world/out/AccessManagementSystem.sol/AccessManagementSystem.json"), 1);
+    import_BalanceTransferSystem = __toESM(require("@latticexyz/world/out/BalanceTransferSystem.sol/BalanceTransferSystem.json"), 1);
+    import_BatchCallSystem = __toESM(require("@latticexyz/world/out/BatchCallSystem.sol/BatchCallSystem.json"), 1);
+    import_RegistrationSystem = __toESM(require("@latticexyz/world/out/RegistrationSystem.sol/RegistrationSystem.json"), 1);
+    import_InitModule = __toESM(require("@latticexyz/world/out/InitModule.sol/InitModule.json"), 1);
+    import_InitModule_abi = __toESM(require("@latticexyz/world/out/InitModule.sol/InitModule.abi.json"), 1);
+    import_viem = require("viem");
+    import_internal = require("@latticexyz/common/internal");
+  }
+});
+
+// src/deploy/getWorldFactoryContracts.ts
+function getWorldFactoryContracts(deployerAddress) {
+  const worldContracts = getWorldContracts(deployerAddress);
+  const worldFactoryDeployedBytecodeSize = (0, import_viem2.size)(import_WorldFactory.default.deployedBytecode.object);
+  const worldFactoryBytecode = (0, import_viem2.encodeDeployData)({
+    bytecode: import_WorldFactory.default.bytecode.object,
+    abi: import_WorldFactory_abi.default,
+    args: [worldContracts.InitModule.address]
+  });
+  const worldFactory = (0, import_internal2.getContractAddress)({ deployerAddress, bytecode: worldFactoryBytecode });
+  return {
+    ...worldContracts,
+    WorldFactory: {
+      bytecode: worldFactoryBytecode,
+      deployedBytecodeSize: worldFactoryDeployedBytecodeSize,
+      debugLabel: "world factory",
+      address: worldFactory
+    }
+  };
+}
+var import_WorldFactory, import_WorldFactory_abi, import_viem2, import_internal2;
+var init_getWorldFactoryContracts = __esm({
+  "src/deploy/getWorldFactoryContracts.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_WorldFactory = __toESM(require("@latticexyz/world/out/WorldFactory.sol/WorldFactory.json"), 1);
+    import_WorldFactory_abi = __toESM(require("@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json"), 1);
+    import_viem2 = require("viem");
+    init_getWorldContracts();
+    import_internal2 = require("@latticexyz/common/internal");
+  }
+});
+
+// src/deploy/getWorldProxyFactoryContracts.ts
+function getWorldProxyFactoryContracts(deployerAddress) {
+  const worldContracts = getWorldContracts(deployerAddress);
+  const worldProxyFactoryDeployedBytecodeSize = (0, import_viem3.size)(import_WorldProxyFactory.default.deployedBytecode.object);
+  const worldProxyFactoryBytecode = (0, import_viem3.encodeDeployData)({
+    bytecode: import_WorldProxyFactory.default.bytecode.object,
+    abi: import_WorldProxyFactory_abi.default,
+    args: [worldContracts.InitModule.address]
+  });
+  const worldProxyFactory = (0, import_internal3.getContractAddress)({ deployerAddress, bytecode: worldProxyFactoryBytecode });
+  return {
+    ...worldContracts,
+    WorldProxyFactory: {
+      bytecode: worldProxyFactoryBytecode,
+      deployedBytecodeSize: worldProxyFactoryDeployedBytecodeSize,
+      debugLabel: "world proxy factory",
+      address: worldProxyFactory
+    }
+  };
+}
+var import_WorldProxyFactory, import_WorldProxyFactory_abi, import_viem3, import_internal3;
+var init_getWorldProxyFactoryContracts = __esm({
+  "src/deploy/getWorldProxyFactoryContracts.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_WorldProxyFactory = __toESM(require("@latticexyz/world/out/WorldProxyFactory.sol/WorldProxyFactory.json"), 1);
+    import_WorldProxyFactory_abi = __toESM(require("@latticexyz/world/out/WorldProxyFactory.sol/WorldProxyFactory.abi.json"), 1);
+    import_viem3 = require("viem");
+    init_getWorldContracts();
+    import_internal3 = require("@latticexyz/common/internal");
+  }
+});
+
+// src/deploy/ensureWorldFactory.ts
+async function ensureWorldFactory(client, deployerAddress, withWorldProxy) {
+  if (withWorldProxy) {
+    const contracts2 = getWorldProxyFactoryContracts(deployerAddress);
+    await (0, import_internal4.ensureContractsDeployed)({
+      client,
+      deployerAddress,
+      contracts: Object.values(contracts2)
+    });
+    return contracts2.WorldProxyFactory.address;
+  }
+  const contracts = getWorldFactoryContracts(deployerAddress);
+  await (0, import_internal4.ensureContractsDeployed)({
+    client,
+    deployerAddress,
+    contracts: Object.values(contracts)
+  });
+  return contracts.WorldFactory.address;
+}
+var import_internal4;
+var init_ensureWorldFactory = __esm({
+  "src/deploy/ensureWorldFactory.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_getWorldFactoryContracts();
+    init_getWorldProxyFactoryContracts();
+    import_internal4 = require("@latticexyz/common/internal");
+  }
+});
+
+// src/debug.ts
+var import_debug, debug, error;
+var init_debug = __esm({
+  "src/debug.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_debug = __toESM(require("debug"), 1);
+    debug = (0, import_debug.default)("mud:cli");
+    error = (0, import_debug.default)("mud:cli");
+    debug.log = console.debug.bind(console);
+    error.log = console.error.bind(console);
+  }
+});
+
+// src/deploy/debug.ts
+var debug2, error2;
+var init_debug2 = __esm({
+  "src/deploy/debug.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_debug();
+    debug2 = debug.extend("deploy");
+    error2 = debug.extend("deploy");
+    debug2.log = console.debug.bind(console);
+    error2.log = console.error.bind(console);
+  }
+});
+
+// src/deploy/common.ts
+var import_IBaseWorld_abi, import_store, import_world, worldDeployEvents, worldAbi, supportedStoreVersions, supportedWorldVersions;
+var init_common = __esm({
+  "src/deploy/common.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_IBaseWorld_abi = __toESM(require("@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json"), 1);
+    import_store = require("@latticexyz/store");
+    import_world = require("@latticexyz/world");
+    worldDeployEvents = [import_store.helloStoreEvent, import_world.helloWorldEvent];
+    worldAbi = import_IBaseWorld_abi.default;
+    supportedStoreVersions = ["2.0.0", "2.0.1", "2.0.2"];
+    supportedWorldVersions = ["2.0.0", "2.0.1", "2.0.2"];
+  }
+});
+
+// src/deploy/logsToWorldDeploy.ts
+function logsToWorldDeploy(logs) {
+  const deployLogs = logs.map((log) => {
+    try {
+      return {
+        ...log,
+        ...(0, import_viem4.decodeEventLog)({
+          strict: true,
+          abi: (0, import_viem4.parseAbi)(worldDeployEvents),
+          topics: log.topics,
+          data: log.data
+        }),
+        // Log addresses are not checksummed, but we want them checksummed before writing to disk.
+        // https://github.com/wevm/viem/issues/2207
+        address: (0, import_viem4.getAddress)(log.address)
+      };
+    } catch (error4) {
+      if (error4 instanceof import_viem4.AbiEventSignatureNotFoundError) {
+        return;
+      }
+      throw error4;
+    }
+  }).filter(import_utils.isDefined);
+  const { address, deployBlock, worldVersion, storeVersion } = deployLogs.reduce(
+    (deploy2, log) => ({
+      ...deploy2,
+      address: log.address,
+      deployBlock: log.blockNumber,
+      ...log.eventName === "HelloWorld" ? { worldVersion: (0, import_viem4.hexToString)(log.args.worldVersion).replace(/\0+$/, "") } : null,
+      ...log.eventName === "HelloStore" ? { storeVersion: (0, import_viem4.hexToString)(log.args.storeVersion).replace(/\0+$/, "") } : null
+    }),
+    {}
+  );
+  if (address == null) throw new Error("could not find world address");
+  if (deployBlock == null) throw new Error("could not find world deploy block number");
+  if (worldVersion == null) throw new Error("could not find world version");
+  if (storeVersion == null) throw new Error("could not find store version");
+  return { address, deployBlock, worldVersion, storeVersion };
+}
+var import_viem4, import_utils;
+var init_logsToWorldDeploy = __esm({
+  "src/deploy/logsToWorldDeploy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem4 = require("viem");
+    init_common();
+    import_utils = require("@latticexyz/common/utils");
+  }
+});
+
+// src/deploy/deployWorld.ts
+async function deployWorld(client, deployerAddress, salt, withWorldProxy) {
+  const worldFactory = await ensureWorldFactory(client, deployerAddress, withWorldProxy);
+  debug2("deploying world");
+  const tx = await (0, import_common2.writeContract)(client, {
+    chain: client.chain ?? null,
+    address: worldFactory,
+    abi: import_WorldFactory_abi2.default,
+    functionName: "deployWorld",
+    args: [salt]
+  });
+  debug2("waiting for world deploy");
+  const receipt = await (0, import_actions.waitForTransactionReceipt)(client, { hash: tx });
+  if (receipt.status !== "success") {
+    console.error("world deploy failed", receipt);
+    throw new Error("world deploy failed");
+  }
+  const deploy2 = logsToWorldDeploy(receipt.logs);
+  debug2("deployed world to", deploy2.address, "at block", deploy2.deployBlock);
+  return { ...deploy2, stateBlock: deploy2.deployBlock };
+}
+var import_actions, import_WorldFactory_abi2, import_common2;
+var init_deployWorld = __esm({
+  "src/deploy/deployWorld.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_actions = require("viem/actions");
+    init_ensureWorldFactory();
+    import_WorldFactory_abi2 = __toESM(require("@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json"), 1);
+    import_common2 = require("@latticexyz/common");
+    init_debug2();
+    init_logsToWorldDeploy();
+  }
+});
+
+// src/deploy/getTables.ts
+async function getTables({
+  client,
+  worldDeploy,
+  indexerUrl,
+  chainId
+}) {
+  debug2("looking up tables for", worldDeploy.address);
+  const { records } = await (0, import_store_sync.getRecords)({
+    table: import_mud.default.namespaces.store.tables.Tables,
+    worldAddress: worldDeploy.address,
+    indexerUrl,
+    chainId,
+    client,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock
+  });
+  const tables = records.map((record) => {
+    const { type, namespace, name } = (0, import_common3.hexToResource)(record.tableId);
+    const solidityKeySchema = (0, import_internal5.hexToSchema)(record.keySchema);
+    const solidityValueSchema = (0, import_internal5.hexToSchema)(record.valueSchema);
+    const keyNames = (0, import_viem5.decodeAbiParameters)((0, import_viem5.parseAbiParameters)("string[]"), record.abiEncodedKeyNames)[0];
+    const fieldNames = (0, import_viem5.decodeAbiParameters)((0, import_viem5.parseAbiParameters)("string[]"), record.abiEncodedFieldNames)[0];
+    const valueAbiTypes = [...solidityValueSchema.staticFields, ...solidityValueSchema.dynamicFields];
+    const keySchema = Object.fromEntries(
+      solidityKeySchema.staticFields.map((abiType, i) => [keyNames[i], { type: abiType, internalType: abiType }])
+    );
+    const valueSchema = Object.fromEntries(
+      valueAbiTypes.map((abiType, i) => [fieldNames[i], { type: abiType, internalType: abiType }])
+    );
+    return {
+      type,
+      namespace,
+      name,
+      tableId: record.tableId,
+      schema: { ...keySchema, ...valueSchema },
+      key: Object.keys(keySchema),
+      keySchema,
+      keySchemaHex: record.keySchema,
+      valueSchema,
+      valueSchemaHex: record.valueSchema
+    };
+  });
+  debug2("found", tables.length, "tables for", worldDeploy.address);
+  return tables;
+}
+var import_viem5, import_common3, import_internal5, import_mud, import_store_sync;
+var init_getTables = __esm({
+  "src/deploy/getTables.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem5 = require("viem");
+    import_common3 = require("@latticexyz/common");
+    init_debug2();
+    import_internal5 = require("@latticexyz/protocol-parser/internal");
+    import_mud = __toESM(require("@latticexyz/store/mud.config"), 1);
+    import_store_sync = require("@latticexyz/store-sync");
+  }
+});
+
+// src/deploy/ensureTables.ts
+async function ensureTables({
+  client,
+  worldDeploy,
+  tables,
+  indexerUrl,
+  chainId
+}) {
+  const configTables = new Map(
+    tables.map((table) => {
+      const keySchema = (0, import_internal6.getSchemaTypes)((0, import_internal6.getKeySchema)(table));
+      const valueSchema = (0, import_internal6.getSchemaTypes)((0, import_internal6.getValueSchema)(table));
+      const keySchemaHex = (0, import_internal6.keySchemaToHex)(keySchema);
+      const valueSchemaHex = (0, import_internal6.valueSchemaToHex)(valueSchema);
+      return [
+        table.tableId,
+        {
+          ...table,
+          keySchema,
+          keySchemaHex,
+          valueSchema,
+          valueSchemaHex
+        }
+      ];
+    })
+  );
+  const worldTables = await getTables({ client, worldDeploy, indexerUrl, chainId });
+  const existingTables = worldTables.filter(({ tableId }) => configTables.has(tableId));
+  if (existingTables.length) {
+    debug2("existing tables:", existingTables.map(import_common4.resourceToLabel).join(", "));
+    const schemaErrors = existingTables.map((table) => {
+      const configTable = configTables.get(table.tableId);
+      if (table.keySchemaHex !== configTable.keySchemaHex || table.valueSchemaHex !== configTable.valueSchemaHex) {
+        return [
+          `"${(0, import_common4.resourceToLabel)(table)}" table:`,
+          `  Registered schema: ${JSON.stringify({ schema: (0, import_internal6.getSchemaTypes)(table.schema), key: table.key })}`,
+          `      Config schema: ${JSON.stringify({ schema: (0, import_internal6.getSchemaTypes)(configTable.schema), key: configTable.key })}`
+        ].join("\n");
+      }
+    }).filter(import_utils2.isDefined);
+    if (schemaErrors.length) {
+      throw new Error(
+        [
+          "Table schemas are immutable, but found registered tables with a different schema than what you have configured.",
+          ...schemaErrors,
+          "You can either update your config with the registered schema or change the table name to register a new table."
+        ].join("\n\n") + "\n"
+      );
+    }
+  }
+  const existingTableIds = new Set(existingTables.map(({ tableId }) => tableId));
+  const missingTables = tables.filter((table) => !existingTableIds.has(table.tableId));
+  if (missingTables.length) {
+    debug2("registering tables:", missingTables.map(import_common4.resourceToLabel).join(", "));
+    return await Promise.all(
+      missingTables.map((table) => {
+        const keySchema = (0, import_internal6.getSchemaTypes)((0, import_internal6.getKeySchema)(table));
+        const valueSchema = (0, import_internal6.getSchemaTypes)((0, import_internal6.getValueSchema)(table));
+        return (0, import_p_retry.default)(
+          () => (0, import_common4.writeContract)(client, {
+            chain: client.chain ?? null,
+            address: worldDeploy.address,
+            abi: worldAbi,
+            // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+            functionName: "registerTable",
+            args: [
+              table.tableId,
+              (0, import_internal6.valueSchemaToFieldLayoutHex)(valueSchema),
+              (0, import_internal6.keySchemaToHex)(keySchema),
+              (0, import_internal6.valueSchemaToHex)(valueSchema),
+              Object.keys(keySchema),
+              Object.keys(valueSchema)
+            ]
+          }),
+          {
+            retries: 3,
+            onFailedAttempt: () => debug2(`failed to register table ${(0, import_common4.resourceToLabel)(table)}, retrying...`)
+          }
+        );
+      })
+    );
+  }
+  return [];
+}
+var import_common4, import_internal6, import_p_retry, import_utils2;
+var init_ensureTables = __esm({
+  "src/deploy/ensureTables.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_common4 = require("@latticexyz/common");
+    init_common();
+    import_internal6 = require("@latticexyz/protocol-parser/internal");
+    init_debug2();
+    init_getTables();
+    import_p_retry = __toESM(require("p-retry"), 1);
+    import_utils2 = require("@latticexyz/common/utils");
+  }
+});
+
+// src/deploy/getResourceIds.ts
+async function getResourceIds({
+  client,
+  worldDeploy,
+  indexerUrl,
+  chainId
+}) {
+  debug2("looking up resource IDs for", worldDeploy.address);
+  const { records } = await (0, import_store_sync2.getRecords)({
+    table: import_mud2.default.namespaces.store.tables.ResourceIds,
+    worldAddress: worldDeploy.address,
+    indexerUrl,
+    chainId,
+    client,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock
+  });
+  const resourceIds = records.map((record) => record.resourceId);
+  debug2("found", resourceIds.length, "resource IDs for", worldDeploy.address);
+  return resourceIds;
+}
+var import_mud2, import_store_sync2;
+var init_getResourceIds = __esm({
+  "src/deploy/getResourceIds.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_debug2();
+    import_mud2 = __toESM(require("@latticexyz/store/mud.config"), 1);
+    import_store_sync2 = require("@latticexyz/store-sync");
+  }
+});
+
+// src/deploy/getTableValue.ts
+async function getTableValue({
+  client,
+  worldDeploy,
+  table,
+  key
+}) {
+  const [staticData, encodedLengths, dynamicData] = await (0, import_actions2.readContract)(client, {
+    blockNumber: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    abi: worldAbi,
+    functionName: "getRecord",
+    args: [table.tableId, (0, import_internal7.encodeKey)((0, import_internal7.getSchemaTypes)((0, import_internal7.getKeySchema)(table)), key)]
+    // TODO: remove cast once https://github.com/wevm/viem/issues/2125 is resolved
+  });
+  return (0, import_internal7.decodeValueArgs)((0, import_internal7.getSchemaTypes)((0, import_internal7.getValueSchema)(table)), {
+    staticData,
+    encodedLengths,
+    dynamicData
+  });
+}
+var import_internal7, import_actions2;
+var init_getTableValue = __esm({
+  "src/deploy/getTableValue.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_internal7 = require("@latticexyz/protocol-parser/internal");
+    init_common();
+    import_actions2 = require("viem/actions");
+  }
+});
+
+// src/deploy/getResourceAccess.ts
+async function getResourceAccess({
+  client,
+  worldDeploy,
+  indexerUrl,
+  chainId
+}) {
+  debug2("looking up resource access for", worldDeploy.address);
+  const { records } = await (0, import_store_sync3.getRecords)({
+    table: import_mud3.default.namespaces.world.tables.ResourceAccess,
+    worldAddress: worldDeploy.address,
+    indexerUrl,
+    chainId,
+    client,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock
+  });
+  const access = records.filter((record) => record.access).map((record) => ({
+    resourceId: record.resourceId,
+    address: (0, import_viem6.getAddress)(record.caller)
+  }));
+  debug2("found", access.length, "resource<>address access pairs");
+  return access;
+}
+var import_viem6, import_mud3, import_store_sync3;
+var init_getResourceAccess = __esm({
+  "src/deploy/getResourceAccess.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem6 = require("viem");
+    init_debug2();
+    import_mud3 = __toESM(require("@latticexyz/world/mud.config"), 1);
+    import_store_sync3 = require("@latticexyz/store-sync");
+  }
+});
+
+// src/deploy/getSystems.ts
+async function getSystems({
+  client,
+  worldDeploy,
+  indexerUrl,
+  chainId
+}) {
+  const [resourceIds, functions, resourceAccess] = await Promise.all([
+    getResourceIds({ client, worldDeploy, indexerUrl, chainId }),
+    (0, import_world2.getFunctions)({
+      client,
+      worldAddress: worldDeploy.address,
+      fromBlock: worldDeploy.deployBlock,
+      toBlock: worldDeploy.stateBlock,
+      indexerUrl,
+      chainId
+    }),
+    getResourceAccess({ client, worldDeploy, indexerUrl, chainId })
+  ]);
+  const systems = resourceIds.map(import_common7.hexToResource).filter((resource) => resource.type === "system");
+  debug2("looking up systems:", systems.map(import_common7.resourceToLabel).join(", "));
+  return await Promise.all(
+    systems.map(async (system) => {
+      const { system: address, publicAccess } = await getTableValue({
+        client,
+        worldDeploy,
+        table: import_mud4.default.namespaces.world.tables.Systems,
+        key: { systemId: system.resourceId }
+      });
+      const worldFunctions = functions.filter((func) => func.systemId === system.resourceId);
+      return {
+        address,
+        namespace: system.namespace,
+        name: system.name,
+        systemId: system.resourceId,
+        allowAll: publicAccess,
+        allowedAddresses: resourceAccess.filter(({ resourceId }) => resourceId === system.resourceId).map(({ address: address2 }) => address2),
+        worldFunctions
+      };
+    })
+  );
+}
+var import_common7, import_world2, import_mud4;
+var init_getSystems = __esm({
+  "src/deploy/getSystems.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_common7 = require("@latticexyz/common");
+    import_world2 = require("@latticexyz/store-sync/world");
+    init_getResourceIds();
+    init_getTableValue();
+    init_debug2();
+    init_getResourceAccess();
+    import_mud4 = __toESM(require("@latticexyz/world/mud.config"), 1);
+  }
+});
+
+// src/deploy/ensureSystems.ts
+async function ensureSystems({
+  client,
+  deployerAddress,
+  libraryMap,
+  worldDeploy,
+  systems,
+  indexerUrl,
+  chainId
+}) {
+  const [worldSystems, worldAccess] = await Promise.all([
+    getSystems({ client, worldDeploy, indexerUrl, chainId }),
+    getResourceAccess({ client, worldDeploy, indexerUrl, chainId })
+  ]);
+  const existingSystems = systems.filter(
+    (system) => worldSystems.some(
+      (worldSystem) => worldSystem.systemId === system.systemId && (0, import_viem7.getAddress)(worldSystem.address) === (0, import_viem7.getAddress)(system.prepareDeploy(deployerAddress, libraryMap).address)
+    )
+  );
+  if (existingSystems.length) {
+    debug2("existing systems:", existingSystems.map(import_common8.resourceToLabel).join(", "));
+  }
+  const existingSystemIds = existingSystems.map((system) => system.systemId);
+  const missingSystems = systems.filter((system) => !existingSystemIds.includes(system.systemId));
+  if (!missingSystems.length) return [];
+  const systemsToUpgrade = missingSystems.filter(
+    (system) => worldSystems.some(
+      (worldSystem) => worldSystem.systemId === system.systemId && (0, import_viem7.getAddress)(worldSystem.address) !== (0, import_viem7.getAddress)(system.prepareDeploy(deployerAddress, libraryMap).address)
+    )
+  );
+  if (systemsToUpgrade.length) {
+    debug2("upgrading systems:", systemsToUpgrade.map(import_common8.resourceToLabel).join(", "));
+  }
+  const systemsToAdd = missingSystems.filter(
+    (system) => !worldSystems.some((worldSystem) => worldSystem.systemId === system.systemId)
+  );
+  if (systemsToAdd.length) {
+    debug2("registering new systems:", systemsToAdd.map(import_common8.resourceToLabel).join(", "));
+  }
+  await (0, import_internal8.ensureContractsDeployed)({
+    client,
+    deployerAddress,
+    contracts: missingSystems.map((system) => ({
+      bytecode: system.prepareDeploy(deployerAddress, libraryMap).bytecode,
+      deployedBytecodeSize: system.deployedBytecodeSize,
+      debugLabel: `${(0, import_common8.resourceToLabel)(system)} system`
+    }))
+  });
+  const registerTxs = await Promise.all(
+    missingSystems.map(
+      (system) => (0, import_p_retry2.default)(
+        () => (0, import_common8.writeContract)(client, {
+          chain: client.chain ?? null,
+          address: worldDeploy.address,
+          abi: worldAbi,
+          // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+          functionName: "registerSystem",
+          args: [system.systemId, system.prepareDeploy(deployerAddress, libraryMap).address, system.allowAll]
+        }),
+        {
+          retries: 3,
+          onFailedAttempt: () => debug2(`failed to register system ${(0, import_common8.resourceToLabel)(system)}, retrying...`)
+        }
+      )
+    )
+  );
+  const systemIds = systems.map((system) => system.systemId);
+  const currentAccess = worldAccess.filter(({ resourceId }) => systemIds.includes(resourceId));
+  const desiredAccess = [
+    ...systems.flatMap(
+      (system) => system.allowedAddresses.map((address) => ({ resourceId: system.systemId, address }))
+    ),
+    ...systems.flatMap(
+      (system) => system.allowedSystemIds.map((systemId) => ({
+        resourceId: system.systemId,
+        address: worldSystems.find((s) => s.systemId === systemId)?.address ?? systems.find((s) => s.systemId === systemId)?.prepareDeploy(deployerAddress, libraryMap).address
+      })).filter((access) => access.address != null)
+    )
+  ];
+  const accessToAdd = desiredAccess.filter(
+    (access) => !currentAccess.some(
+      ({ resourceId, address }) => resourceId === access.resourceId && (0, import_viem7.getAddress)(address) === (0, import_viem7.getAddress)(access.address)
+    )
+  );
+  const accessToRemove = currentAccess.filter(
+    (access) => !desiredAccess.some(
+      ({ resourceId, address }) => resourceId === access.resourceId && (0, import_viem7.getAddress)(address) === (0, import_viem7.getAddress)(access.address)
+    )
+  );
+  if (accessToRemove.length) {
+    debug2("revoking", accessToRemove.length, "access grants");
+  }
+  if (accessToAdd.length) {
+    debug2("adding", accessToAdd.length, "access grants");
+  }
+  const accessTxs = await Promise.all([
+    ...accessToRemove.map(
+      (access) => (0, import_p_retry2.default)(
+        () => (0, import_common8.writeContract)(client, {
+          chain: client.chain ?? null,
+          address: worldDeploy.address,
+          abi: worldAbi,
+          functionName: "revokeAccess",
+          args: [access.resourceId, access.address]
+        }),
+        {
+          retries: 3,
+          onFailedAttempt: () => debug2("failed to revoke access, retrying...")
+        }
+      )
+    ),
+    ...accessToAdd.map(
+      (access) => (0, import_p_retry2.default)(
+        () => (0, import_common8.writeContract)(client, {
+          chain: client.chain ?? null,
+          address: worldDeploy.address,
+          abi: worldAbi,
+          functionName: "grantAccess",
+          args: [access.resourceId, access.address]
+        }),
+        {
+          retries: 3,
+          onFailedAttempt: () => debug2("failed to grant access, retrying...")
+        }
+      )
+    )
+  ]);
+  return [...registerTxs, ...accessTxs];
+}
+var import_viem7, import_common8, import_p_retry2, import_internal8;
+var init_ensureSystems = __esm({
+  "src/deploy/ensureSystems.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem7 = require("viem");
+    import_common8 = require("@latticexyz/common");
+    init_common();
+    init_debug2();
+    init_getSystems();
+    init_getResourceAccess();
+    import_p_retry2 = __toESM(require("p-retry"), 1);
+    import_internal8 = require("@latticexyz/common/internal");
+  }
+});
+
+// src/deploy/getWorldDeploy.ts
+async function getWorldDeploy(client, worldAddress, deployBlock) {
+  const address = (0, import_viem8.getAddress)(worldAddress);
+  const stateBlock = await (0, import_actions3.getBlock)(client, { blockTag: "latest" });
+  let deploy2 = deploys.get(address);
+  if (deploy2 != null) {
+    return {
+      ...deploy2,
+      stateBlock: stateBlock.number
+    };
+  }
+  debug2("looking up world deploy for", address);
+  const [fromBlock, toBlock] = deployBlock ? [{ number: deployBlock }, { number: deployBlock }] : [await (0, import_actions3.getBlock)(client, { blockTag: "earliest" }), stateBlock];
+  const blockLogs = await (0, import_block_logs_stream.fetchBlockLogs)({
+    publicClient: client,
+    address,
+    events: (0, import_viem8.parseAbi)(worldDeployEvents),
+    fromBlock: fromBlock.number,
+    toBlock: toBlock.number,
+    maxBlockRange: 100000n
+  });
+  if (blockLogs.length === 0) {
+    throw new Error("could not find `HelloWorld` or `HelloStore` event");
+  }
+  deploy2 = {
+    ...logsToWorldDeploy(blockLogs.flatMap((block) => block.logs)),
+    stateBlock: stateBlock.number
+  };
+  deploys.set(address, deploy2);
+  debug2("found world deploy for", address, "at block", deploy2.deployBlock);
+  return deploy2;
+}
+var import_viem8, import_actions3, import_block_logs_stream, deploys;
+var init_getWorldDeploy = __esm({
+  "src/deploy/getWorldDeploy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem8 = require("viem");
+    import_actions3 = require("viem/actions");
+    import_block_logs_stream = require("@latticexyz/block-logs-stream");
+    init_common();
+    init_debug2();
+    init_logsToWorldDeploy();
+    deploys = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/deploy/ensureFunctions.ts
+async function ensureFunctions({
+  client,
+  worldDeploy,
+  functions,
+  indexerUrl,
+  chainId
+}) {
+  const worldFunctions = await (0, import_world3.getFunctions)({
+    client,
+    worldAddress: worldDeploy.address,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    indexerUrl,
+    chainId
+  });
+  const worldSelectorToFunction = Object.fromEntries(worldFunctions.map((func) => [func.selector, func]));
+  const toSkip = functions.filter((func) => worldSelectorToFunction[func.selector]);
+  const toAdd = functions.filter((func) => !toSkip.includes(func));
+  if (toSkip.length) {
+    debug2("functions already registered:", toSkip.map((func) => func.signature).join(", "));
+    const wrongSystem = toSkip.filter((func) => func.systemId !== worldSelectorToFunction[func.selector]?.systemId);
+    if (wrongSystem.length) {
+      console.warn(
+        "found",
+        wrongSystem.length,
+        "functions already registered but pointing at a different system ID:",
+        wrongSystem.map((func) => func.signature).join(", ")
+      );
+    }
+  }
+  if (!toAdd.length) return [];
+  debug2("registering functions:", toAdd.map((func) => func.signature).join(", "));
+  return Promise.all(
+    toAdd.map((func) => {
+      const { namespace } = (0, import_common11.hexToResource)(func.systemId);
+      const params = namespace === "" ? {
+        functionName: "registerRootFunctionSelector",
+        args: [
+          func.systemId,
+          // use system function signature as world signature
+          func.systemFunctionSignature,
+          func.systemFunctionSignature
+        ]
+      } : {
+        functionName: "registerFunctionSelector",
+        args: [func.systemId, func.systemFunctionSignature]
+      };
+      return (0, import_p_retry3.default)(
+        () => (0, import_common11.writeContract)(client, {
+          chain: client.chain ?? null,
+          address: worldDeploy.address,
+          abi: worldAbi,
+          ...params
+        }),
+        {
+          retries: 3,
+          onFailedAttempt: () => debug2(`failed to register function ${func.signature}, retrying...`)
+        }
+      );
+    })
+  );
+}
+var import_common11, import_world3, import_p_retry3;
+var init_ensureFunctions = __esm({
+  "src/deploy/ensureFunctions.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_common11 = require("@latticexyz/common");
+    import_world3 = require("@latticexyz/store-sync/world");
+    init_common();
+    init_debug2();
+    import_p_retry3 = __toESM(require("p-retry"), 1);
+  }
+});
+
+// src/deploy/ensureModules.ts
+async function ensureModules({
+  client,
+  deployerAddress,
+  libraryMap,
+  worldDeploy,
+  modules
+}) {
+  if (!modules.length) return [];
+  await (0, import_internal9.ensureContractsDeployed)({
+    client,
+    deployerAddress,
+    contracts: modules.map((mod) => ({
+      bytecode: mod.prepareDeploy(deployerAddress, libraryMap).bytecode,
+      deployedBytecodeSize: mod.deployedBytecodeSize,
+      debugLabel: `${mod.name} module`
+    }))
+  });
+  debug2("installing modules:", modules.map((mod) => mod.name).join(", "));
+  return (await Promise.all(
+    modules.map(
+      (mod) => (0, import_p_retry4.default)(
+        async () => {
+          try {
+            const abi = [...worldAbi, ...mod.abi];
+            const moduleAddress = mod.prepareDeploy(deployerAddress, libraryMap).address;
+            const params = mod.installAsRoot ? { functionName: "installRootModule", args: [moduleAddress, mod.installData] } : { functionName: "installModule", args: [moduleAddress, mod.installData] };
+            return await (0, import_common13.writeContract)(client, {
+              chain: client.chain ?? null,
+              address: worldDeploy.address,
+              abi,
+              ...params
+            });
+          } catch (error4) {
+            if (error4 instanceof import_viem9.BaseError && error4.message.includes("Module_AlreadyInstalled")) {
+              debug2(`module ${mod.name} already installed`);
+              return;
+            }
+            if (mod.optional) {
+              debug2(`optional module ${mod.name} install failed, skipping`);
+              debug2(error4);
+              return;
+            }
+            throw error4;
+          }
+        },
+        {
+          retries: 3,
+          onFailedAttempt: () => debug2(`failed to install module ${mod.name}, retrying...`)
+        }
+      )
+    )
+  )).filter(import_utils3.isDefined);
+}
+var import_viem9, import_common13, import_utils3, import_p_retry4, import_internal9;
+var init_ensureModules = __esm({
+  "src/deploy/ensureModules.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem9 = require("viem");
+    import_common13 = require("@latticexyz/common");
+    init_common();
+    init_debug2();
+    import_utils3 = require("@latticexyz/common/utils");
+    import_p_retry4 = __toESM(require("p-retry"), 1);
+    import_internal9 = require("@latticexyz/common/internal");
+  }
+});
+
+// src/deploy/ensureNamespaceOwner.ts
+async function ensureNamespaceOwner({
+  client,
+  worldDeploy,
+  resourceIds,
+  indexerUrl,
+  chainId
+}) {
+  const desiredNamespaces = Array.from(new Set(resourceIds.map((resourceId) => (0, import_common16.hexToResource)(resourceId).namespace)));
+  const existingResourceIds = await getResourceIds({ client, worldDeploy, indexerUrl, chainId });
+  const existingNamespaces = new Set(existingResourceIds.map((resourceId) => (0, import_common16.hexToResource)(resourceId).namespace));
+  if (existingNamespaces.size) {
+    debug2(
+      "found",
+      existingNamespaces.size,
+      "existing namespaces:",
+      Array.from(existingNamespaces).map((namespace) => namespace === "" ? "<root>" : namespace).join(", ")
+    );
+  }
+  const existingDesiredNamespaces = desiredNamespaces.filter((namespace) => existingNamespaces.has(namespace));
+  const namespaceOwners = await Promise.all(
+    existingDesiredNamespaces.map(async (namespace) => {
+      const { owner } = await getTableValue({
+        client,
+        worldDeploy,
+        table: import_mud5.default.namespaces.world.tables.NamespaceOwner,
+        key: { namespaceId: (0, import_common16.resourceToHex)({ type: "namespace", namespace, name: "" }) }
+      });
+      return [namespace, owner];
+    })
+  );
+  const unauthorizedNamespaces = namespaceOwners.filter(([, owner]) => (0, import_viem10.getAddress)(owner) !== (0, import_viem10.getAddress)(client.account.address)).map(([namespace]) => namespace);
+  if (unauthorizedNamespaces.length) {
+    throw new Error(`You are attempting to deploy to namespaces you do not own: ${unauthorizedNamespaces.join(", ")}`);
+  }
+  const missingNamespaces = desiredNamespaces.filter((namespace) => !existingNamespaces.has(namespace));
+  if (missingNamespaces.length > 0) {
+    debug2("registering namespaces:", Array.from(missingNamespaces).join(", "));
+  }
+  const registrationTxs = Promise.all(
+    missingNamespaces.map(
+      (namespace) => (0, import_common16.writeContract)(client, {
+        chain: client.chain ?? null,
+        address: worldDeploy.address,
+        abi: worldAbi,
+        functionName: "registerNamespace",
+        args: [(0, import_common16.resourceToHex)({ namespace, type: "namespace", name: "" })]
+      })
+    )
+  );
+  return registrationTxs;
+}
+var import_viem10, import_common16, import_mud5;
+var init_ensureNamespaceOwner = __esm({
+  "src/deploy/ensureNamespaceOwner.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem10 = require("viem");
+    init_common();
+    import_common16 = require("@latticexyz/common");
+    init_getResourceIds();
+    init_getTableValue();
+    init_debug2();
+    import_mud5 = __toESM(require("@latticexyz/world/mud.config"), 1);
+  }
+});
+
+// src/utils/findPlaceholders.ts
+function findPlaceholders(linkReferences) {
+  return Object.entries(linkReferences).flatMap(
+    ([path16, contracts]) => Object.entries(contracts).flatMap(
+      ([contractName, locations]) => locations.map(
+        (location) => ({
+          path: path16,
+          name: contractName,
+          start: location.start,
+          length: location.length
+        })
+      )
+    )
+  );
+}
+var init_findPlaceholders = __esm({
+  "src/utils/findPlaceholders.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/utils/getContractArtifact.ts
+function isBytecode(value) {
+  return (0, import_viem11.isHex)(value, { strict: false });
+}
+function getContractArtifact(artifactJson) {
+  const artifact = artifactSchema.parse(artifactJson);
+  const placeholders = findPlaceholders(artifact.bytecode.linkReferences ?? {});
+  return {
+    abi: artifact.abi,
+    bytecode: artifact.bytecode.object,
+    placeholders,
+    deployedBytecodeSize: (0, import_viem11.size)(artifact.deployedBytecode.object)
+  };
+}
+var import_viem11, import_zod2, import_zod3, bytecodeSchema, artifactSchema;
+var init_getContractArtifact = __esm({
+  "src/utils/getContractArtifact.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem11 = require("viem");
+    init_findPlaceholders();
+    import_zod2 = require("zod");
+    import_zod3 = require("abitype/zod");
+    bytecodeSchema = import_zod2.z.object({
+      object: import_zod2.z.string().refine(isBytecode),
+      linkReferences: import_zod2.z.record(
+        import_zod2.z.record(
+          import_zod2.z.array(
+            import_zod2.z.object({
+              start: import_zod2.z.number(),
+              length: import_zod2.z.number()
+            })
+          )
+        )
+      ).optional()
+    });
+    artifactSchema = import_zod2.z.object({
+      bytecode: bytecodeSchema,
+      deployedBytecode: bytecodeSchema,
+      abi: import_zod3.Abi
+    });
+  }
+});
+
+// src/deploy/createPrepareDeploy.ts
+function createPrepareDeploy(bytecodeWithPlaceholders, placeholders) {
+  return function prepareDeploy(deployerAddress, libraryMap) {
+    let bytecode = bytecodeWithPlaceholders;
+    if (placeholders.length === 0) {
+      return { bytecode, address: (0, import_internal10.getContractAddress)({ deployerAddress, bytecode }) };
+    }
+    if (!libraryMap) {
+      throw new Error("Libraries must be provided if there are placeholders");
+    }
+    for (const placeholder of placeholders) {
+      const address = libraryMap.getAddress({
+        name: placeholder.name,
+        path: placeholder.path,
+        deployer: deployerAddress
+      });
+      bytecode = (0, import_common17.spliceHex)(bytecode, placeholder.start, placeholder.length, address);
+    }
+    return {
+      bytecode,
+      address: (0, import_internal10.getContractAddress)({ deployerAddress, bytecode })
+    };
+  };
+}
+var import_common17, import_internal10;
+var init_createPrepareDeploy = __esm({
+  "src/deploy/createPrepareDeploy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_common17 = require("@latticexyz/common");
+    import_internal10 = require("@latticexyz/common/internal");
+  }
+});
+
+// src/deploy/ensureResourceTags.ts
+async function ensureResourceTags({
+  client,
+  deployerAddress,
+  libraryMap,
+  worldDeploy,
+  tags,
+  valueToHex = import_utils4.identity,
+  indexerUrl,
+  chainId
+}) {
+  debug2("ensuring", tags.length, "resource tags");
+  debug2("looking up existing resource tags");
+  const { records } = await (0, import_store_sync4.getRecords)({
+    table: import_mud6.default.tables.metadata__ResourceTag,
+    worldAddress: worldDeploy.address,
+    chainId,
+    indexerUrl,
+    client,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock
+  });
+  debug2("found", records.length, "resource tags");
+  const existingTags = new Map(
+    records.map((tag) => {
+      const key = (0, import_viem12.concatHex)((0, import_internal11.getKeyTuple)(import_mud6.default.tables.metadata__ResourceTag, tag));
+      return [key, tag.value];
+    })
+  );
+  const desiredTags = tags.map(
+    (tag) => ({
+      resource: tag.resourceId,
+      tag: (0, import_viem12.stringToHex)(tag.tag, { size: 32 }),
+      value: valueToHex(tag.value)
+    })
+  );
+  const pendingTags = desiredTags.filter((tag) => {
+    const key = (0, import_viem12.concatHex)((0, import_internal11.getKeyTuple)(import_mud6.default.tables.metadata__ResourceTag, tag));
+    return existingTags.get(key) !== tag.value;
+  });
+  if (pendingTags.length === 0) return [];
+  const moduleTxs = await ensureModules({
+    client,
+    deployerAddress,
+    worldDeploy,
+    libraryMap,
+    modules: [
+      {
+        optional: true,
+        name: "MetadataModule",
+        installAsRoot: false,
+        installData: "0x",
+        prepareDeploy: createPrepareDeploy(metadataModuleArtifact.bytecode, metadataModuleArtifact.placeholders),
+        deployedBytecodeSize: metadataModuleArtifact.deployedBytecodeSize,
+        abi: metadataModuleArtifact.abi
+      }
+    ]
+  });
+  await (0, import_internal12.waitForTransactions)({
+    client,
+    hashes: moduleTxs,
+    debugLabel: "metadata module installation"
+  });
+  debug2("setting", pendingTags.length, "resource tags");
+  return (await Promise.all(
+    pendingTags.map(async (tag) => {
+      const resource = (0, import_common18.hexToResource)(tag.resource);
+      const resourceString = `${resource.type}:${resource.namespace}:${resource.name}`;
+      debug2(`tagging ${resourceString} with ${tag.tag}: ${JSON.stringify(tag.value)}`);
+      try {
+        return await (0, import_common18.writeContract)(client, {
+          chain: client.chain ?? null,
+          address: worldDeploy.address,
+          abi: import_IMetadataSystem_abi.default,
+          // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+          functionName: "metadata__setResourceTag",
+          args: [tag.resource, tag.tag, tag.value]
+        });
+      } catch (error4) {
+        debug2(
+          `failed to set resource tag for ${resourceString}, skipping
+  ${error4 instanceof import_viem12.BaseError ? error4.shortMessage : error4}`
+        );
+      }
+    })
+  )).filter(import_utils4.isDefined);
+}
+var import_viem12, import_common18, import_utils4, import_mud6, import_IMetadataSystem_abi, import_MetadataModule, import_internal11, import_store_sync4, import_internal12, metadataModuleArtifact;
+var init_ensureResourceTags = __esm({
+  "src/deploy/ensureResourceTags.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem12 = require("viem");
+    init_debug2();
+    import_common18 = require("@latticexyz/common");
+    import_utils4 = require("@latticexyz/common/utils");
+    import_mud6 = __toESM(require("@latticexyz/world-module-metadata/mud.config"), 1);
+    import_IMetadataSystem_abi = __toESM(require("@latticexyz/world-module-metadata/out/IMetadataSystem.sol/IMetadataSystem.abi.json"), 1);
+    init_ensureModules();
+    import_MetadataModule = __toESM(require("@latticexyz/world-module-metadata/out/MetadataModule.sol/MetadataModule.json"), 1);
+    init_getContractArtifact();
+    init_createPrepareDeploy();
+    import_internal11 = require("@latticexyz/protocol-parser/internal");
+    import_store_sync4 = require("@latticexyz/store-sync");
+    import_internal12 = require("@latticexyz/common/internal");
+    metadataModuleArtifact = getContractArtifact(import_MetadataModule.default);
+  }
+});
+
+// src/deploy/deployCustomWorld.ts
+function findArtifact(ref, artifacts) {
+  const artifact = artifacts.find((a) => a.sourcePath === ref.sourcePath && a.name === ref.name);
+  if (!artifact) throw new Error(`Could not find referenced artifact at "${ref.sourcePath}:${ref.name}".`);
+  return artifact;
+}
+function getDependencies(artifact, artifacts) {
+  return artifact.bytecode.filter((part) => !(0, import_viem13.isHex)(part)).flatMap((ref) => {
+    return getDependencies(findArtifact(ref, artifacts), artifacts);
+  });
+}
+function getDeployable(deployerAddress, artifact, artifacts) {
+  return (0, import_viem13.concatHex)(
+    artifact.bytecode.map((ref) => {
+      if ((0, import_viem13.isHex)(ref)) return ref;
+      return (0, import_internal13.getContractAddress)({
+        deployerAddress,
+        bytecode: getDeployable(deployerAddress, findArtifact(ref, artifacts), artifacts)
+      });
+    })
+  );
+}
+async function deployCustomWorld({
+  client,
+  deployerAddress,
+  artifacts,
+  customWorld
+}) {
+  const contracts = getWorldContracts(deployerAddress);
+  await (0, import_internal13.ensureContractsDeployed)({
+    client,
+    deployerAddress,
+    contracts: Object.values(contracts)
+  });
+  const worldArtifact = findArtifact(customWorld, artifacts);
+  const deps = getDependencies(worldArtifact, artifacts);
+  if (deps.length) {
+    debug2(`deploying ${deps.length} world dependencies`);
+    await (0, import_internal13.ensureContractsDeployed)({
+      client,
+      deployerAddress,
+      contracts: deps.map((dep) => getDeployable(deployerAddress, dep, artifacts)).reverse().map((bytecode) => ({ bytecode }))
+    });
+  }
+  debug2("deploying custom world");
+  const deployTx = await (0, import_common19.sendTransaction)(client, {
+    chain: client.chain ?? null,
+    data: (0, import_viem13.encodeDeployData)({
+      abi: worldArtifact.abi,
+      args: [],
+      // TODO (https://github.com/latticexyz/mud/issues/3150)
+      bytecode: getDeployable(deployerAddress, worldArtifact, artifacts)
+    })
+  });
+  debug2("waiting for custom world deploy");
+  const receipt = await (0, import_actions4.waitForTransactionReceipt)(client, { hash: deployTx });
+  if (receipt.status !== "success") {
+    console.error("world deploy failed", receipt);
+    throw new Error("world deploy failed");
+  }
+  const deploy2 = logsToWorldDeploy(receipt.logs);
+  debug2("deployed custom world to", deploy2.address, "at block", deploy2.deployBlock);
+  const initTx = await (0, import_common19.writeContract)(client, {
+    chain: client.chain ?? null,
+    address: deploy2.address,
+    abi: worldAbi,
+    functionName: "initialize",
+    args: [contracts.InitModule.address]
+  });
+  await (0, import_internal13.waitForTransactions)({ client, hashes: [initTx], debugLabel: "world init" });
+  const transferOwnershipTx = await (0, import_common19.writeContract)(client, {
+    chain: client.chain ?? null,
+    address: deploy2.address,
+    abi: worldAbi,
+    functionName: "transferOwnership",
+    args: [(0, import_common19.resourceToHex)({ type: "namespace", namespace: "", name: "" }), client.account.address]
+  });
+  await (0, import_internal13.waitForTransactions)({ client, hashes: [transferOwnershipTx], debugLabel: "world ownership transfer" });
+  return { ...deploy2, stateBlock: deploy2.deployBlock };
+}
+var import_viem13, import_actions4, import_common19, import_internal13;
+var init_deployCustomWorld = __esm({
+  "src/deploy/deployCustomWorld.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem13 = require("viem");
+    import_actions4 = require("viem/actions");
+    import_common19 = require("@latticexyz/common");
+    init_debug2();
+    init_logsToWorldDeploy();
+    init_common();
+    init_getWorldContracts();
+    import_internal13 = require("@latticexyz/common/internal");
+  }
+});
+
+// src/deploy/getLibraryMap.ts
+function getLibraryKey({ path: path16, name }) {
+  return `${path16}:${name}`;
+}
+function getLibraryMap(libraries) {
+  const cache = Object.fromEntries(libraries.map((library) => [getLibraryKey(library), library]));
+  const libraryMap = {
+    getAddress: ({ path: path16, name, deployer }) => {
+      const library = cache[getLibraryKey({ path: path16, name })];
+      if (!library) {
+        throw new Error(`Could not find library for bytecode placeholder ${path16}:${name}`);
+      }
+      library.address ??= {};
+      library.address[deployer] ??= library.prepareDeploy(deployer, libraryMap).address;
+      return library.address[deployer];
+    }
+  };
+  return libraryMap;
+}
+var init_getLibraryMap = __esm({
+  "src/deploy/getLibraryMap.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/deploy/deploy.ts
+async function deploy({
+  config: config2,
+  client,
+  tables,
+  systems,
+  libraries,
+  modules = [],
+  artifacts,
+  salt,
+  worldAddress: existingWorldAddress,
+  worldDeployBlock,
+  deployerAddress: initialDeployerAddress,
+  indexerUrl,
+  chainId
+}) {
+  const deployerAddress = initialDeployerAddress ?? await (0, import_internal14.ensureDeployer)(client);
+  const worldDeploy = existingWorldAddress ? await getWorldDeploy(client, existingWorldAddress, worldDeployBlock) : config2.deploy.customWorld ? await deployCustomWorld({
+    client,
+    deployerAddress,
+    artifacts,
+    customWorld: config2.deploy.customWorld
+  }) : await deployWorld(
+    client,
+    deployerAddress,
+    salt ?? `0x${(0, import_crypto.randomBytes)(32).toString("hex")}`,
+    config2.deploy.upgradeableWorldImplementation
+  );
+  const commonDeployOptions = {
+    client,
+    indexerUrl,
+    chainId,
+    worldDeploy
+  };
+  if (!supportedStoreVersions.includes(worldDeploy.storeVersion)) {
+    throw new Error(`Unsupported Store version: ${worldDeploy.storeVersion}`);
+  }
+  if (!supportedWorldVersions.includes(worldDeploy.worldVersion)) {
+    throw new Error(`Unsupported World version: ${worldDeploy.worldVersion}`);
+  }
+  const libraryMap = getLibraryMap(libraries);
+  await (0, import_internal14.ensureContractsDeployed)({
+    ...commonDeployOptions,
+    deployerAddress,
+    contracts: [
+      ...libraries.map((library) => ({
+        bytecode: library.prepareDeploy(deployerAddress, libraryMap).bytecode,
+        deployedBytecodeSize: library.deployedBytecodeSize,
+        debugLabel: `${library.path}:${library.name} library`
+      })),
+      ...systems.map((system) => ({
+        bytecode: system.prepareDeploy(deployerAddress, libraryMap).bytecode,
+        deployedBytecodeSize: system.deployedBytecodeSize,
+        debugLabel: `${(0, import_common22.resourceToLabel)(system)} system`
+      })),
+      ...modules.map((mod) => ({
+        bytecode: mod.prepareDeploy(deployerAddress, libraryMap).bytecode,
+        deployedBytecodeSize: mod.deployedBytecodeSize,
+        debugLabel: `${mod.name} module`
+      }))
+    ]
+  });
+  const namespaceTxs = await ensureNamespaceOwner({
+    ...commonDeployOptions,
+    resourceIds: [...tables.map(({ tableId }) => tableId), ...systems.map(({ systemId }) => systemId)]
+  });
+  await (0, import_internal14.waitForTransactions)({ client, hashes: namespaceTxs, debugLabel: "namespace registrations" });
+  const tableTxs = await ensureTables({
+    ...commonDeployOptions,
+    tables
+  });
+  const systemTxs = await ensureSystems({
+    ...commonDeployOptions,
+    deployerAddress,
+    libraryMap,
+    systems
+  });
+  await (0, import_internal14.waitForTransactions)({
+    client,
+    hashes: [...tableTxs, ...systemTxs],
+    debugLabel: "table and system registrations"
+  });
+  const functionTxs = await ensureFunctions({
+    ...commonDeployOptions,
+    functions: systems.flatMap((system) => system.worldFunctions)
+  });
+  const moduleTxs = await ensureModules({
+    ...commonDeployOptions,
+    deployerAddress,
+    libraryMap,
+    modules
+  });
+  const namespaceTags = (0, import_utils5.uniqueBy)(
+    [...tables, ...systems].filter(({ namespace, namespaceLabel }) => namespaceLabel !== namespace).map(({ namespace, namespaceLabel }) => ({
+      resourceId: (0, import_common22.resourceToHex)({ type: "namespace", namespace, name: "" }),
+      tag: "label",
+      value: namespaceLabel
+    })),
+    (tag) => tag.resourceId
+  );
+  const tableTags = tables.filter((table) => table.label !== table.name).map(({ tableId: resourceId, label }) => ({ resourceId, tag: "label", value: label }));
+  const systemTags = systems.flatMap(({ name, systemId: resourceId, label, metadata }) => [
+    // only register labels if they differ from the resource ID
+    ...label !== name ? [{ resourceId, tag: "label", value: label }] : [],
+    { resourceId, tag: "abi", value: metadata.abi.join("\n") },
+    { resourceId, tag: "worldAbi", value: metadata.worldAbi.join("\n") }
+  ]);
+  const tagTxs = await ensureResourceTags({
+    ...commonDeployOptions,
+    deployerAddress,
+    libraryMap,
+    tags: [...namespaceTags, ...tableTags, ...systemTags],
+    valueToHex: import_viem14.stringToHex
+  });
+  await (0, import_internal14.waitForTransactions)({
+    client,
+    hashes: [...functionTxs, ...moduleTxs, ...tagTxs],
+    debugLabel: "remaining transactions"
+  });
+  debug2("deploy complete");
+  return worldDeploy;
+}
+var import_viem14, import_common22, import_crypto, import_utils5, import_internal14;
+var init_deploy = __esm({
+  "src/deploy/deploy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem14 = require("viem");
+    init_deployWorld();
+    init_ensureTables();
+    init_common();
+    init_ensureSystems();
+    init_getWorldDeploy();
+    init_ensureFunctions();
+    init_ensureModules();
+    init_ensureNamespaceOwner();
+    init_debug2();
+    import_common22 = require("@latticexyz/common");
+    import_crypto = require("crypto");
+    init_ensureResourceTags();
+    init_deployCustomWorld();
+    import_utils5 = require("@latticexyz/common/utils");
+    init_getLibraryMap();
+    import_internal14 = require("@latticexyz/common/internal");
+  }
+});
+
+// src/utils/getContractData.ts
+function getContractData(filename, contractName, forgeOutDirectory) {
+  let data;
+  const contractDataPath = import_path2.default.join(forgeOutDirectory, filename, contractName + ".json");
+  try {
+    data = JSON.parse((0, import_fs2.readFileSync)(contractDataPath, "utf8"));
+  } catch (error4) {
+    throw new import_errors2.MUDError(`Error reading file at ${contractDataPath}`);
+  }
+  const bytecode = data?.bytecode?.object;
+  if (!bytecode) throw new import_errors2.MUDError(`No bytecode found in ${contractDataPath}`);
+  const deployedBytecode = data?.deployedBytecode?.object;
+  if (!deployedBytecode) throw new import_errors2.MUDError(`No deployed bytecode found in ${contractDataPath}`);
+  const abi = data?.abi;
+  if (!abi) throw new import_errors2.MUDError(`No ABI found in ${contractDataPath}`);
+  const placeholders = findPlaceholders(data?.bytecode?.linkReferences ?? {});
+  return { abi, bytecode, placeholders, deployedBytecodeSize: (0, import_viem15.size)(deployedBytecode) };
+}
+var import_fs2, import_path2, import_errors2, import_viem15;
+var init_getContractData = __esm({
+  "src/utils/getContractData.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs2 = require("fs");
+    import_path2 = __toESM(require("path"), 1);
+    import_errors2 = require("@latticexyz/common/errors");
+    import_viem15 = require("viem");
+    init_findPlaceholders();
+  }
+});
+
+// src/deploy/orderByDependencies.ts
+function orderByDependencies(items, itemKey, dependencyKeys) {
+  const dependencyOrder = (0, import_toposort.default)(
+    items.flatMap((item) => dependencyKeys(item).map((dependency) => [itemKey(item), dependency]))
+  );
+  return [...items].sort((a, b) => dependencyOrder.indexOf(itemKey(a)) - dependencyOrder.indexOf(itemKey(b)));
+}
+var import_toposort;
+var init_orderByDependencies = __esm({
+  "src/deploy/orderByDependencies.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_toposort = __toESM(require("toposort"), 1);
+  }
+});
+
+// src/deploy/findLibraries.ts
+function findLibraries(forgeOutDir) {
+  const artifacts = (0, import_glob.globSync)(`${forgeOutDir}/**/*.json`, { ignore: "**/*.abi.json" }).sort().map((path16) => JSON.parse((0, import_fs3.readFileSync)(path16, "utf8")));
+  const libraries = artifacts.flatMap((artifact) => {
+    if (!artifact.metadata) return [];
+    const contractPath = Object.keys(artifact.metadata.settings.compilationTarget)[0];
+    const contractName = artifact.metadata.settings.compilationTarget[contractPath];
+    const linkReferences = artifact.bytecode.linkReferences;
+    return Object.entries(linkReferences).flatMap(
+      ([libraryPath, reference]) => Object.keys(reference).map((libraryName) => ({
+        path: libraryPath,
+        name: libraryName,
+        dependentPath: contractPath,
+        dependentName: contractName
+      }))
+    );
+  });
+  return orderByDependencies(
+    libraries,
+    (lib) => `${lib.path}:${lib.name}`,
+    (lib) => [`${lib.dependentPath}:${lib.dependentName}`]
+  );
+}
+var import_fs3, import_glob;
+var init_findLibraries = __esm({
+  "src/deploy/findLibraries.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs3 = require("fs");
+    import_glob = require("glob");
+    init_orderByDependencies();
+  }
+});
+
+// src/deploy/compat/excludeUnstableCallWithSignatureModule.ts
+function excludeCallWithSignatureModule(mod) {
+  if (mod.artifactPath === "@latticexyz/world-modules/out/Unstable_CallWithSignatureModule.sol/Unstable_CallWithSignatureModule.json") {
+    console.warn(
+      [
+        "",
+        `\u26A0\uFE0F Your \`mud.config.ts\` is using \`Unstable_CallWithSignatureModule\`. This module can be removed from your config as it is now installed by default during deploy.`,
+        ""
+      ].join("\n")
+    );
+    return false;
+  }
+  return true;
+}
+var init_excludeUnstableCallWithSignatureModule = __esm({
+  "src/deploy/compat/excludeUnstableCallWithSignatureModule.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/deploy/resolveConfig.ts
+async function resolveConfig({
+  rootDir,
+  config: config2,
+  forgeOutDir
+}) {
+  const requirePath = await (0, import_find_up.findUp)("package.json");
+  if (!requirePath) throw new Error("Could not find package.json to import relative to.");
+  const require2 = (0, import_node_module.createRequire)(requirePath);
+  const moduleOutDirs = config2.modules.filter(excludeCallWithSignatureModule).flatMap((mod) => {
+    if (mod.artifactPath == void 0) {
+      return [];
+    }
+    const moduleOutDir = import_path3.default.join(require2.resolve(mod.artifactPath), "../../");
+    return [moduleOutDir];
+  });
+  const libraries = [forgeOutDir, ...moduleOutDirs].flatMap(
+    (outDir) => findLibraries(outDir).map((library) => {
+      const contractData = getContractData(import_path3.default.basename(library.path), library.name, outDir);
+      return {
+        path: library.path,
+        name: library.name,
+        abi: contractData.abi,
+        prepareDeploy: createPrepareDeploy(contractData.bytecode, contractData.placeholders),
+        deployedBytecodeSize: contractData.deployedBytecodeSize
+      };
+    })
+  );
+  const baseSystemContractData = getContractData("System.sol", "System", forgeOutDir);
+  const baseSystemFunctions = baseSystemContractData.abi.filter((item) => item.type === "function").map(import_viem16.toFunctionSignature);
+  const configSystems = await (0, import_node4.resolveSystems)({ rootDir, config: config2 });
+  const systemsManifest = await (0, import_node4.loadSystemsManifest)({ rootDir, config: config2 });
+  const systems = configSystems.filter((system) => !system.deploy.disabled).map((system) => {
+    const manifest = systemsManifest.systems.find(({ systemId }) => systemId === system.systemId);
+    if (!manifest) {
+      throw new Error(
+        `System "${system.label}" not found in systems manifest. Run \`mud build\` before trying again.`
+      );
+    }
+    const contractData = getContractData(`${system.label}.sol`, system.label, forgeOutDir);
+    const worldFunctions = system.deploy.registerWorldFunctions ? contractData.abi.filter((item) => item.type === "function").map(import_viem16.toFunctionSignature).filter((sig) => !baseSystemFunctions.includes(sig)).map((sig) => {
+      const worldSignature = system.namespace === "" ? sig : `${system.namespace}__${sig}`;
+      return {
+        signature: worldSignature,
+        selector: (0, import_viem16.toFunctionSelector)(worldSignature),
+        systemId: system.systemId,
+        systemFunctionSignature: sig,
+        systemFunctionSelector: (0, import_viem16.toFunctionSelector)(sig)
+      };
+    }) : [];
+    const allowedAddresses = system.accessList.filter((target) => (0, import_viem16.isHex)(target));
+    const allowedSystemIds = system.accessList.filter((target) => !(0, import_viem16.isHex)(target)).map((label) => {
+      const system2 = configSystems.find((s) => s.label === label);
+      return system2.systemId;
+    });
+    return {
+      ...system,
+      allowAll: system.openAccess,
+      allowedAddresses,
+      allowedSystemIds,
+      prepareDeploy: createPrepareDeploy(contractData.bytecode, contractData.placeholders),
+      deployedBytecodeSize: contractData.deployedBytecodeSize,
+      worldFunctions,
+      abi: contractData.abi,
+      metadata: {
+        abi: manifest.abi,
+        worldAbi: manifest.worldAbi
+      }
+    };
+  });
+  const systemsById = (0, import_utils6.groupBy)(systems, (system) => system.systemId);
+  const overlappingSystems = Array.from(systemsById.values()).filter((matches) => matches.length > 1).flat();
+  if (overlappingSystems.length) {
+    const names = overlappingSystems.map((system) => system.name);
+    throw new Error(
+      `Found systems with overlapping system ID: ${names.join(
+        ", "
+      )}.
+
+System IDs are generated from the first 16 bytes of the name, so you may need to rename them to avoid the overlap.`
+    );
+  }
+  return {
+    systems,
+    libraries
+  };
+}
+var import_path3, import_node4, import_viem16, import_utils6, import_find_up, import_node_module;
+var init_resolveConfig = __esm({
+  "src/deploy/resolveConfig.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_path3 = __toESM(require("path"), 1);
+    import_node4 = require("@latticexyz/world/node");
+    import_viem16 = require("viem");
+    init_getContractData();
+    import_utils6 = require("@latticexyz/common/utils");
+    init_findLibraries();
+    init_createPrepareDeploy();
+    import_find_up = require("find-up");
+    import_node_module = require("module");
+    init_excludeUnstableCallWithSignatureModule();
+  }
+});
+
+// src/utils/postDeploy.ts
+async function postDeploy(postDeployScript, worldAddress, rpc, profile, forgeOptions, kms) {
+  const userOptions = forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
+  const postDeployPath = import_path4.default.join(await (0, import_foundry2.getScriptDirectory)(), postDeployScript + ".s.sol");
+  if (!(0, import_fs4.existsSync)(postDeployPath)) {
+    console.log(`No script at ${postDeployPath}, skipping post deploy hook`);
+    return;
+  }
+  console.log(import_chalk2.default.blue(`Executing post deploy script at ${postDeployPath}`));
+  await (0, import_foundry2.forge)(
+    [
+      "script",
+      postDeployScript,
+      "--broadcast",
+      "--sig",
+      "run(address)",
+      worldAddress,
+      "--rpc-url",
+      rpc,
+      "-vvv",
+      kms ? "--aws" : "",
+      ...userOptions
+    ],
+    {
+      profile
+    }
+  );
+}
+var import_fs4, import_path4, import_chalk2, import_foundry2;
+var init_postDeploy = __esm({
+  "src/utils/postDeploy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs4 = require("fs");
+    import_path4 = __toESM(require("path"), 1);
+    import_chalk2 = __toESM(require("chalk"), 1);
+    import_foundry2 = require("@latticexyz/common/foundry");
+  }
+});
+
+// src/utils/importContractArtifact.ts
+async function importContractArtifact({
+  packageJsonPath,
+  artifactPath
+}) {
+  let artfactJson;
+  try {
+    const requirePath = packageJsonPath ?? await (0, import_find_up2.findUp)("package.json", { cwd: process.cwd() });
+    if (!requirePath) throw new Error("Could not find package.json to import relative to.");
+    const require2 = (0, import_node_module2.createRequire)(requirePath);
+    artfactJson = require2(artifactPath);
+  } catch (error4) {
+    console.error();
+    console.error("Could not import contract artifact at", artifactPath);
+    console.error();
+    throw error4;
+  }
+  return getContractArtifact(artfactJson);
+}
+var import_node_module2, import_find_up2;
+var init_importContractArtifact = __esm({
+  "src/utils/importContractArtifact.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_module2 = require("module");
+    import_find_up2 = require("find-up");
+    init_getContractArtifact();
+  }
+});
+
+// src/deploy/configToModules.ts
+async function configToModules(config2, forgeOutDir) {
+  const defaultModules = [
+    {
+      // optional for now
+      // TODO: figure out approach to install on existing worlds where deployer may not own root namespace
+      optional: true,
+      name: "CallWithSignatureModule",
+      installAsRoot: true,
+      installData: "0x",
+      prepareDeploy: createPrepareDeploy(
+        callWithSignatureModuleArtifact.bytecode,
+        callWithSignatureModuleArtifact.placeholders
+      ),
+      deployedBytecodeSize: callWithSignatureModuleArtifact.deployedBytecodeSize,
+      abi: callWithSignatureModuleArtifact.abi
+    }
+  ];
+  const modules = await Promise.all(
+    config2.modules.filter(excludeCallWithSignatureModule).map(async (mod) => {
+      let artifactPath = mod.artifactPath;
+      if (!artifactPath) {
+        if (mod.name) {
+          artifactPath = knownModuleArtifacts[mod.name] ?? import_node_path3.default.join(forgeOutDir, `${mod.name}.sol`, `${mod.name}.json`);
+          console.warn(
+            [
+              "",
+              `\u26A0\uFE0F Your \`mud.config.ts\` is using a module with a \`name\`, but this option is deprecated.`,
+              "",
+              "To resolve this, you can replace this:",
+              "",
+              `  name: ${JSON.stringify(mod.name)}`,
+              "",
+              "with this:",
+              "",
+              `  artifactPath: ${JSON.stringify(artifactPath)}`,
+              ""
+            ].join("\n")
+          );
+        } else {
+          throw new Error("No `artifactPath` provided for module.");
+        }
+      }
+      const name = import_node_path3.default.basename(artifactPath, ".json");
+      const artifact = await importContractArtifact({ artifactPath });
+      const installArgs = mod.args.map((arg) => (0, import_internal16.resolveWithContext)(arg, { config: config2 })).map((arg) => {
+        const value = arg.value instanceof Uint8Array ? (0, import_viem17.bytesToHex)(arg.value) : arg.value;
+        return (0, import_internal15.encodeField)(arg.type, value);
+      });
+      if (installArgs.length > 1) {
+        throw new Error(`${name} module should only have 0-1 args, but had ${installArgs.length} args.`);
+      }
+      return {
+        name,
+        installAsRoot: mod.root,
+        installData: installArgs.length === 0 ? "0x" : installArgs[0],
+        prepareDeploy: createPrepareDeploy(artifact.bytecode, artifact.placeholders),
+        deployedBytecodeSize: artifact.deployedBytecodeSize,
+        abi: artifact.abi
+      };
+    })
+  );
+  return [...defaultModules, ...modules];
+}
+var import_node_path3, import_internal15, import_viem17, import_internal16, import_CallWithSignatureModule, callWithSignatureModuleArtifact, knownModuleArtifacts;
+var init_configToModules = __esm({
+  "src/deploy/configToModules.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_path3 = __toESM(require("path"), 1);
+    import_internal15 = require("@latticexyz/protocol-parser/internal");
+    import_viem17 = require("viem");
+    init_createPrepareDeploy();
+    init_importContractArtifact();
+    import_internal16 = require("@latticexyz/world/internal");
+    import_CallWithSignatureModule = __toESM(require("@latticexyz/world-module-callwithsignature/out/CallWithSignatureModule.sol/CallWithSignatureModule.json"), 1);
+    init_getContractArtifact();
+    init_excludeUnstableCallWithSignatureModule();
+    callWithSignatureModuleArtifact = getContractArtifact(import_CallWithSignatureModule.default);
+    knownModuleArtifacts = {
+      KeysWithValueModule: "@latticexyz/world-modules/out/KeysWithValueModule.sol/KeysWithValueModule.json",
+      KeysInTableModule: "@latticexyz/world-modules/out/KeysInTableModule.sol/KeysInTableModule.json",
+      UniqueEntityModule: "@latticexyz/world-modules/out/UniqueEntityModule.sol/UniqueEntityModule.json"
+    };
+  }
+});
+
+// src/utils/enableAutomine.ts
+async function enableAutomine(client) {
+  const miningMode = await getMiningMode(client).catch(() => void 0);
+  if (!miningMode || miningMode.type === "automine") return;
+  debug("Enabling automine");
+  await setMiningMode(client, { type: "automine" });
+  return {
+    reset: () => {
+      debug("Disabling automine");
+      return setMiningMode(client, miningMode);
+    }
+  };
+}
+async function getMiningMode(client) {
+  const localClient = { mode: "anvil", ...client };
+  const isAutomine = await (0, import_utils7.getAction)(localClient, import_actions5.getAutomine, "getAutomine")({});
+  if (isAutomine) {
+    return { type: "automine" };
+  }
+  const blockTime = await getBlockTime(client);
+  return { type: "interval", blockTime };
+}
+async function setMiningMode(client, miningMode) {
+  if (miningMode.type === "automine") {
+    await (0, import_utils7.getAction)(client, import_actions5.setAutomine, "setAutomine")(true);
+  } else {
+    await (0, import_utils7.getAction)(client, import_actions5.setIntervalMining, "setIntervalMining")({ interval: miningMode.blockTime });
+  }
+}
+async function getBlockTime(client) {
+  const latestBlock = await (0, import_utils7.getAction)(client, import_actions5.getBlock, "getBlock")({ blockTag: "latest" });
+  const previousBlock = await (0, import_utils7.getAction)(client, import_actions5.getBlock, "getBlock")({ blockNumber: latestBlock.number - 1n });
+  const blockTime = latestBlock.timestamp - previousBlock.timestamp;
+  return Number(blockTime);
+}
+var import_actions5, import_utils7;
+var init_enableAutomine = __esm({
+  "src/utils/enableAutomine.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_actions5 = require("viem/actions");
+    init_debug();
+    import_utils7 = require("viem/utils");
+  }
+});
+
+// src/defaultChains.ts
+var import_chains, defaultChains;
+var init_defaultChains = __esm({
+  "src/defaultChains.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_chains = require("@latticexyz/common/chains");
+    defaultChains = [import_chains.redstone, import_chains.garnet, import_chains.rhodolite];
+  }
+});
+
+// src/runDeploy.ts
+async function runDeploy(opts) {
+  const salt = opts.salt != null ? (0, import_viem18.isHex)(opts.salt) ? opts.salt : (0, import_viem18.stringToHex)(opts.salt) : void 0;
+  const profile = opts.profile;
+  const configPath = await (0, import_node5.resolveConfigPath)(opts.configPath);
+  const config2 = await (0, import_node5.loadConfig)(configPath);
+  const rootDir = import_node_path4.default.dirname(configPath);
+  console.log(import_chalk3.default.green(`
+Using ${package_default.name}@${package_default.version}`));
+  if (opts.printConfig) {
+    console.log(import_chalk3.default.green("\nResolved config:\n"), JSON.stringify(config2, null, 2));
+  }
+  const outDir = await (0, import_foundry3.getOutDirectory)(profile);
+  const rpc = opts.rpc ?? await (0, import_foundry3.getRpcUrl)(profile);
+  console.log(
+    import_chalk3.default.bgBlue(
+      import_chalk3.default.whiteBright(`
+ Deploying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} 
+`)
+    )
+  );
+  if (!opts.skipBuild) {
+    await build({ rootDir, config: config2, foundryProfile: profile });
+  }
+  const { systems, libraries } = await resolveConfig({
+    rootDir,
+    config: config2,
+    forgeOutDir: outDir
+  });
+  const artifacts = await (0, import_node6.findContractArtifacts)({ forgeOutDir: outDir });
+  const modules = await configToModules(config2, outDir);
+  const tables = Object.values(config2.namespaces).flatMap((namespace) => Object.values(namespace.tables)).filter((table) => !table.deploy.disabled);
+  const account = await (async () => {
+    if (opts.kms) {
+      const keyId = process.env.AWS_KMS_KEY_ID;
+      if (!keyId) {
+        throw new import_errors3.MUDError(
+          "Missing `AWS_KMS_KEY_ID` environment variable. This is required when using with `--kms` option."
+        );
+      }
+      return await (0, import_kms.kmsKeyToAccount)({ keyId });
+    } else {
+      const privateKey = process.env.PRIVATE_KEY;
+      if (!privateKey) {
+        throw new import_errors3.MUDError(
+          `Missing PRIVATE_KEY environment variable.
+  Run 'echo "PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" > .env'
+  in your contracts directory to use the default anvil private key.`
+        );
+      }
+      return (0, import_accounts.privateKeyToAccount)(privateKey);
+    }
+  })();
+  const client = (0, import_viem18.createWalletClient)({
+    transport: (0, import_viem18.http)(rpc, {
+      batch: opts.rpcBatch ? {
+        batchSize: 100,
+        wait: 1e3
+      } : void 0
+    }),
+    account
+  });
+  const chainId = await (0, import_actions6.getChainId)(client);
+  const indexerUrl = opts.indexerUrl ?? defaultChains.find((chain) => chain.id === chainId)?.indexerUrl;
+  const worldDeployBlock = opts.worldAddress ? getWorldDeployBlock({
+    worldAddress: opts.worldAddress,
+    worldsFile: config2.deploy.worldsFile,
+    chainId
+  }) : void 0;
+  console.log("Deploying from", client.account.address);
+  const automine = await enableAutomine(client);
+  const startTime = Date.now();
+  const worldDeploy = await deploy({
+    config: config2,
+    deployerAddress: opts.deployerAddress,
+    salt,
+    worldAddress: opts.worldAddress,
+    worldDeployBlock,
+    client,
+    tables,
+    systems,
+    libraries,
+    modules,
+    artifacts,
+    indexerUrl,
+    chainId
+  });
+  if (opts.worldAddress == null || opts.alwaysRunPostDeploy) {
+    await postDeploy(
+      config2.deploy.postDeployScript,
+      worldDeploy.address,
+      rpc,
+      profile,
+      opts.forgeScriptOptions,
+      opts.kms ? true : false
+    );
+  }
+  await automine?.reset();
+  console.log(import_chalk3.default.green("Deployment completed in", (Date.now() - startTime) / 1e3, "seconds"));
+  const deploymentInfo = {
+    worldAddress: worldDeploy.address,
+    blockNumber: Number(worldDeploy.deployBlock)
+  };
+  if (opts.saveDeployment) {
+    const deploysDir = import_node_path4.default.join(config2.deploy.deploysDirectory, chainId.toString());
+    (0, import_node_fs.mkdirSync)(deploysDir, { recursive: true });
+    (0, import_node_fs.writeFileSync)(import_node_path4.default.join(deploysDir, "latest.json"), JSON.stringify(deploymentInfo, null, 2) + "\n");
+    (0, import_node_fs.writeFileSync)(import_node_path4.default.join(deploysDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2) + "\n");
+    const localChains = [1337, 31337];
+    const deploys2 = (0, import_node_fs.existsSync)(config2.deploy.worldsFile) ? JSON.parse((0, import_node_fs.readFileSync)(config2.deploy.worldsFile, "utf-8")) : {};
+    deploys2[chainId] = {
+      address: deploymentInfo.worldAddress,
+      // We expect the worlds file to be committed and since local deployments are often
+      // a consistent address but different block number, we'll ignore the block number.
+      blockNumber: localChains.includes(chainId) ? void 0 : deploymentInfo.blockNumber
+    };
+    (0, import_node_fs.writeFileSync)(config2.deploy.worldsFile, JSON.stringify(deploys2, null, 2) + "\n");
+    console.log(
+      import_chalk3.default.bgGreen(
+        import_chalk3.default.whiteBright(`
+ Deployment result (written to ${config2.deploy.worldsFile} and ${deploysDir}): 
+`)
+      )
+    );
+  }
+  console.log(deploymentInfo);
+  return worldDeploy;
+}
+function getWorldDeployBlock({
+  chainId,
+  worldAddress,
+  worldsFile
+}) {
+  const deploys2 = (0, import_node_fs.existsSync)(worldsFile) ? JSON.parse((0, import_node_fs.readFileSync)(worldsFile, "utf-8")) : {};
+  const worldDeployBlock = deploys2[chainId]?.address === worldAddress ? deploys2[chainId].blockNumber : void 0;
+  return worldDeployBlock ? BigInt(worldDeployBlock) : void 0;
+}
+var import_node_path4, import_node_fs, import_viem18, import_accounts, import_node5, import_foundry3, import_chalk3, import_errors3, import_actions6, import_kms, import_node6, deployOptions;
+var init_runDeploy = __esm({
+  "src/runDeploy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_path4 = __toESM(require("path"), 1);
+    import_node_fs = require("fs");
+    init_package();
+    init_deploy();
+    import_viem18 = require("viem");
+    import_accounts = require("viem/accounts");
+    import_node5 = require("@latticexyz/config/node");
+    import_foundry3 = require("@latticexyz/common/foundry");
+    import_chalk3 = __toESM(require("chalk"), 1);
+    import_errors3 = require("@latticexyz/common/errors");
+    init_resolveConfig();
+    import_actions6 = require("viem/actions");
+    init_postDeploy();
+    init_build();
+    import_kms = require("@latticexyz/common/kms");
+    init_configToModules();
+    import_node6 = require("@latticexyz/world/node");
+    init_enableAutomine();
+    init_defaultChains();
+    deployOptions = {
+      configPath: { type: "string", desc: "Path to the MUD config file" },
+      printConfig: { type: "boolean", desc: "Print the resolved config" },
+      profile: { type: "string", desc: "The foundry profile to use" },
+      saveDeployment: { type: "boolean", desc: "Save the deployment info to a file", default: true },
+      rpc: { type: "string", desc: "The RPC URL to use. Defaults to the RPC url from the local foundry.toml" },
+      rpcBatch: {
+        type: "boolean",
+        desc: "Enable batch processing of RPC requests in viem client (defaults to batch size of 100 and wait of 1s)"
+      },
+      deployerAddress: {
+        type: "string",
+        desc: "Deploy using an existing deterministic deployer (https://github.com/Arachnid/deterministic-deployment-proxy)"
+      },
+      worldAddress: { type: "string", desc: "Deploy to an existing World at the given address" },
+      skipBuild: { type: "boolean", desc: "Skip rebuilding the contracts before deploying" },
+      alwaysRunPostDeploy: {
+        type: "boolean",
+        desc: "Always run PostDeploy.s.sol after each deploy (including during upgrades). By default, PostDeploy.s.sol is only run once after a new world is deployed."
+      },
+      forgeScriptOptions: { type: "string", description: "Options to pass to forge script PostDeploy.s.sol" },
+      salt: {
+        type: "string",
+        desc: "The deployment salt to use. Defaults to a random salt."
+      },
+      kms: {
+        type: "boolean",
+        desc: "Deploy the World with an AWS KMS key instead of local private key."
+      },
+      indexerUrl: {
+        type: "string",
+        desc: "The indexer URL to use.",
+        required: false
+      }
+    };
+  }
+});
+
+// src/commands/deploy.ts
+var commandModule5, deploy_default;
+var init_deploy2 = __esm({
+  "src/commands/deploy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_errors();
+    init_runDeploy();
+    commandModule5 = {
+      command: "deploy",
+      describe: "Deploy MUD contracts",
+      builder(yargs) {
+        return yargs.options(deployOptions);
+      },
+      async handler(opts) {
+        try {
+          await runDeploy(opts);
+        } catch (error4) {
+          logError(error4);
+          process.exit(1);
+        }
+        process.exit(0);
+      }
+    };
+    deploy_default = commandModule5;
+  }
+});
+
+// src/commands/worldgen.ts
+async function worldgenHandler(args) {
+  const configPath = await (0, import_node7.resolveConfigPath)(args.configPath);
+  const config2 = await (0, import_node7.loadConfig)(configPath);
+  const rootDir = import_node_path5.default.dirname(configPath);
+  await (0, import_node8.worldgen)({ rootDir, config: config2, clean: args.clean });
+}
+var import_node_path5, import_node7, import_node8, commandModule6, worldgen_default;
+var init_worldgen = __esm({
+  "src/commands/worldgen.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_path5 = __toESM(require("path"), 1);
+    import_node7 = require("@latticexyz/config/node");
+    import_node8 = require("@latticexyz/world/node");
+    commandModule6 = {
+      command: "worldgen",
+      describe: "Autogenerate interfaces for Systems and World based on existing contracts and the config file",
+      builder(yargs) {
+        return yargs.options({
+          configPath: { type: "string", desc: "Path to the MUD config file" },
+          clean: {
+            type: "boolean",
+            desc: "Clear the worldgen directory before generating new interfaces (defaults to true)",
+            default: true
+          }
+        });
+      },
+      async handler(args) {
+        await worldgenHandler(args);
+        process.exit(0);
+      }
+    };
+    worldgen_default = commandModule6;
+  }
+});
+
+// src/mudPackages.ts
+function parseEnv() {
+  try {
+    return envSchema.parse({
+      // tsup replaces the env vars with their values at compile time
+      MUD_PACKAGES: '{"@latticexyz/abi-ts":{"localPath":"packages/abi-ts"},"@latticexyz/block-logs-stream":{"localPath":"packages/block-logs-stream"},"@latticexyz/cli":{"localPath":"packages/cli"},"@latticexyz/common":{"localPath":"packages/common"},"@latticexyz/config":{"localPath":"packages/config"},"create-mud":{"localPath":"packages/create-mud"},"@latticexyz/dev-tools":{"localPath":"packages/dev-tools"},"@latticexyz/entrykit":{"localPath":"packages/entrykit"},"@latticexyz/explorer":{"localPath":"packages/explorer"},"@latticexyz/faucet":{"localPath":"packages/faucet"},"@latticexyz/gas-report":{"localPath":"packages/gas-report"},"@latticexyz/paymaster":{"localPath":"packages/paymaster"},"@latticexyz/protocol-parser":{"localPath":"packages/protocol-parser"},"@latticexyz/react":{"localPath":"packages/react"},"@latticexyz/recs":{"localPath":"packages/recs"},"@latticexyz/schema-type":{"localPath":"packages/schema-type"},"solhint-config-mud":{"localPath":"packages/solhint-config-mud"},"solhint-plugin-mud":{"localPath":"packages/solhint-plugin-mud"},"@latticexyz/stash":{"localPath":"packages/stash"},"@latticexyz/store-consumer":{"localPath":"packages/store-consumer"},"@latticexyz/store-indexer":{"localPath":"packages/store-indexer"},"@latticexyz/store-sync":{"localPath":"packages/store-sync"},"@latticexyz/store":{"localPath":"packages/store"},"@latticexyz/utils":{"localPath":"packages/utils"},"vite-plugin-mud":{"localPath":"packages/vite-plugin-mud"},"@latticexyz/world-module-callwithsignature":{"localPath":"packages/world-module-callwithsignature"},"@latticexyz/world-module-erc20":{"localPath":"packages/world-module-erc20"},"@latticexyz/world-module-metadata":{"localPath":"packages/world-module-metadata"},"@latticexyz/world-modules":{"localPath":"packages/world-modules"},"@latticexyz/world":{"localPath":"packages/world"}}'
+    });
+  } catch (error4) {
+    if (error4 instanceof import_zod4.ZodError) {
+      const { ...invalidEnvVars } = error4.format();
+      console.error(`
+Missing or invalid environment variables:
+
+  ${Object.keys(invalidEnvVars).join("\n  ")}
+`);
+      process.exit(1);
+    }
+    throw error4;
+  }
+}
+var import_zod4, envSchema, mudPackages;
+var init_mudPackages = __esm({
+  "src/mudPackages.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod4 = require("zod");
+    envSchema = import_zod4.z.object({
+      MUD_PACKAGES: import_zod4.z.string().transform((value) => JSON.parse(value))
+    });
+    mudPackages = parseEnv().MUD_PACKAGES;
+  }
+});
+
+// src/commands/set-version.ts
+async function resolveVersion(options2) {
+  if (options2.mudVersion === "canary") options2.tag = "main";
+  let npmResult;
+  try {
+    console.log(import_chalk4.default.blue(`Fetching available versions`));
+    npmResult = await (await fetch(`https://registry.npmjs.org/${package_default.name}`)).json();
+  } catch (e) {
+    throw new import_errors5.MUDError(`Could not fetch available MUD versions`);
+  }
+  if (options2.tag) {
+    const version = npmResult["dist-tags"][options2.tag];
+    if (!version) {
+      throw new import_errors5.MUDError(`Could not find npm version with tag "${options2.tag}"`);
+    }
+    console.log(import_chalk4.default.green(`Latest version with tag ${options2.tag}: ${version}`));
+    return version;
+  }
+  if (options2.commit) {
+    const commit = options2.commit.substring(0, 8);
+    const version = Object.keys(npmResult["versions"]).find((v) => v.includes(commit));
+    if (!version) {
+      throw new import_errors5.MUDError(`Could not find npm version based on commit "${options2.commit}"`);
+    }
+    console.log(import_chalk4.default.green(`Version from commit ${options2.commit}: ${version}`));
+    return version;
+  }
+  return options2.mudVersion;
+}
+function updatePackageJson(filePath, options2) {
+  const { link } = options2;
+  let { mudVersion } = options2;
+  const packageJson = readPackageJson(filePath);
+  const mudPackageNames = Object.keys(mudPackages);
+  const mudDependencies = {};
+  for (const packageName in packageJson.dependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      mudDependencies[packageName] = packageJson.dependencies[packageName];
+    }
+  }
+  const mudDevDependencies = {};
+  for (const packageName in packageJson.devDependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      mudDevDependencies[packageName] = packageJson.devDependencies[packageName];
+    }
+  }
+  for (const packageName in packageJson.dependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      packageJson.dependencies[packageName] = resolveMudVersion(packageName, "dependencies");
+    }
+  }
+  for (const packageName in packageJson.devDependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      packageJson.devDependencies[packageName] = resolveMudVersion(packageName, "devDependencies");
+    }
+  }
+  (0, import_fs5.writeFileSync)(filePath, JSON.stringify(packageJson, null, 2) + "\n");
+  console.log(`Updating ${filePath}`);
+  logComparison(mudDependencies, packageJson.dependencies);
+  logComparison(mudDevDependencies, packageJson.devDependencies);
+  return packageJson;
+  function resolveMudVersion(key, type) {
+    if (link) mudVersion = resolveLinkPath(filePath, link, key);
+    if (!mudVersion) return packageJson[type][key];
+    return mudVersion;
+  }
+}
+function readPackageJson(path16) {
+  try {
+    const jsonString = (0, import_fs5.readFileSync)(path16, "utf8");
+    return JSON.parse(jsonString);
+  } catch {
+    throw new import_errors5.MUDError("Could not read JSON at " + path16);
+  }
+}
+function logComparison(prev, curr) {
+  for (const key in prev) {
+    if (prev[key] !== curr[key]) {
+      console.log(`${key}: ${import_chalk4.default.red(prev[key])} -> ${import_chalk4.default.green(curr[key])}`);
+    }
+  }
+}
+function resolveLinkPath(packageJsonPath, mudLinkPath, packageName) {
+  const packageJsonToRootPath = import_path5.default.relative(import_path5.default.dirname(packageJsonPath), process.cwd());
+  const linkPath = import_path5.default.join(packageJsonToRootPath, mudLinkPath, mudPackages[packageName].localPath);
+  return "link:" + linkPath;
+}
+var import_chalk4, import_fs5, import_path5, import_errors5, import_glob2, commandModule7, set_version_default;
+var init_set_version = __esm({
+  "src/commands/set-version.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_chalk4 = __toESM(require("chalk"), 1);
+    import_fs5 = require("fs");
+    import_path5 = __toESM(require("path"), 1);
+    import_errors5 = require("@latticexyz/common/errors");
+    init_errors();
+    init_package();
+    import_glob2 = require("glob");
+    init_mudPackages();
+    commandModule7 = {
+      command: "set-version",
+      describe: "Set MUD version in all package.json files and optionally backup the previously installed version",
+      builder(yargs) {
+        return yargs.options({
+          mudVersion: { alias: "v", type: "string", description: "Set MUD to the given version" },
+          tag: {
+            alias: "t",
+            type: "string",
+            description: "Set MUD to the latest version with the given tag from npm"
+          },
+          commit: {
+            alias: "c",
+            type: "string",
+            description: "Set MUD to the version based on a given git commit hash from npm"
+          },
+          link: { alias: "l", type: "string", description: "Relative path to the local MUD root directory to link" }
+        });
+      },
+      async handler(options2) {
+        try {
+          const mutuallyExclusiveOptions = ["mudVersion", "link", "tag", "commit", "restore"];
+          const numMutuallyExclusiveOptions = mutuallyExclusiveOptions.reduce(
+            (acc, opt) => options2[opt] ? acc + 1 : acc,
+            0
+          );
+          if (numMutuallyExclusiveOptions === 0) {
+            throw new import_errors5.MUDError(`You need to provide one these options: ${mutuallyExclusiveOptions.join(", ")}`);
+          }
+          if (numMutuallyExclusiveOptions > 1) {
+            throw new import_errors5.MUDError(`These options are mutually exclusive: ${mutuallyExclusiveOptions.join(", ")}`);
+          }
+          if (!options2.link) {
+            options2.mudVersion = await resolveVersion(options2);
+          }
+          const packageJsons = (0, import_glob2.globSync)("**/package.json").sort().filter((p) => !p.includes("node_modules"));
+          for (const packageJson of packageJsons) {
+            updatePackageJson(packageJson, options2);
+          }
+        } catch (e) {
+          logError(e);
+        } finally {
+          process.exit(0);
+        }
+      }
+    };
+    set_version_default = commandModule7;
+  }
+});
+
+// src/commands/test.ts
+var import_foundry4, import_chalk5, testOptions, commandModule8, test_default;
+var init_test = __esm({
+  "src/commands/test.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_foundry4 = require("@latticexyz/common/foundry");
+    import_chalk5 = __toESM(require("chalk"), 1);
+    init_runDeploy();
+    testOptions = {
+      ...deployOptions,
+      port: { type: "number", description: "Port to run internal node for fork testing on", default: 4242 },
+      worldAddress: {
+        type: "string",
+        description: "Address of an existing world contract. If provided, deployment is skipped and the RPC provided in the foundry.toml is used for fork testing."
+      },
+      forgeOptions: { type: "string", description: "Options to pass to forge test" }
+    };
+    commandModule8 = {
+      command: "test",
+      describe: "Run tests in MUD contracts",
+      builder(yargs) {
+        return yargs.options(testOptions);
+      },
+      async handler(opts) {
+        if (!opts.worldAddress) {
+          const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(opts.port)];
+          (0, import_foundry4.anvil)(anvilArgs);
+        }
+        const forkRpc = opts.worldAddress ? await (0, import_foundry4.getRpcUrl)(opts.profile) : `http://127.0.0.1:${opts.port}`;
+        const worldAddress = opts.worldAddress ?? (await runDeploy({
+          ...opts,
+          saveDeployment: false,
+          rpc: forkRpc
+        })).address;
+        console.log(import_chalk5.default.blue("World address", worldAddress));
+        const userOptions = opts.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
+        try {
+          await (0, import_foundry4.forge)(["test", "--fork-url", forkRpc, ...userOptions], {
+            profile: opts.profile,
+            env: {
+              WORLD_ADDRESS: worldAddress
+            }
+          });
+          process.exit(0);
+        } catch (e) {
+          console.error(e);
+          process.exit(1);
+        }
+      }
+    };
+    test_default = commandModule8;
+  }
+});
+
+// src/commands/trace.ts
+function getWorldAddress(worldsFile, chainId) {
+  if (!import_node_fs2.default.existsSync(worldsFile)) {
+    throw new import_errors7.MUDError(`Missing expected worlds.json file at "${worldsFile}"`);
+  }
+  const deploys2 = JSON.parse(import_node_fs2.default.readFileSync(worldsFile, "utf-8"));
+  if (!deploys2[chainId]) {
+    throw new import_errors7.MUDError(`Missing chain ID ${chainId} in "${worldsFile}"`);
+  }
+  return deploys2[chainId].address;
+}
+var import_node_path6, import_node_fs2, import_node9, import_errors7, import_foundry5, import_mud7, import_viem19, import_actions7, import_node10, systemsTableId, commandModule9, trace_default;
+var init_trace = __esm({
+  "src/commands/trace.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_path6 = __toESM(require("path"), 1);
+    import_node_fs2 = __toESM(require("fs"), 1);
+    import_node9 = require("@latticexyz/config/node");
+    import_errors7 = require("@latticexyz/common/errors");
+    import_foundry5 = require("@latticexyz/common/foundry");
+    import_mud7 = __toESM(require("@latticexyz/world/mud.config"), 1);
+    import_viem19 = require("viem");
+    import_actions7 = require("viem/actions");
+    import_node10 = require("@latticexyz/world/node");
+    init_common();
+    systemsTableId = import_mud7.default.namespaces.world.tables.Systems.tableId;
+    commandModule9 = {
+      command: "trace",
+      describe: "Display the trace of a transaction",
+      builder(yargs) {
+        return yargs.options({
+          tx: { type: "string", required: true, description: "Transaction hash to replay" },
+          worldAddress: {
+            type: "string",
+            description: "World contract address. Defaults to the value from worlds.json, based on rpc's chainId"
+          },
+          configPath: { type: "string", description: "Path to the MUD config file" },
+          profile: { type: "string", description: "The foundry profile to use" },
+          rpc: { type: "string", description: "json rpc endpoint. Defaults to foundry's configured eth_rpc_url" }
+        });
+      },
+      async handler(args) {
+        const configPath = await (0, import_node9.resolveConfigPath)(args.configPath);
+        const rootDir = import_node_path6.default.dirname(configPath);
+        const profile = args.profile;
+        const rpc = args.rpc ?? await (0, import_foundry5.getRpcUrl)(profile);
+        const config2 = await (0, import_node9.loadConfig)(configPath);
+        const client = (0, import_viem19.createClient)({ transport: (0, import_viem19.http)(rpc) });
+        const chainId = await (0, import_actions7.getChainId)(client);
+        const worldAddress = args.worldAddress ?? getWorldAddress(config2.deploy.worldsFile, chainId);
+        const systems = await (0, import_node10.resolveSystems)({ rootDir, config: config2 });
+        const labels = await Promise.all(
+          systems.map(async (system) => ({
+            label: system.label,
+            address: await (0, import_actions7.readContract)(client, {
+              abi: worldAbi,
+              address: worldAddress,
+              functionName: "getField",
+              args: [systemsTableId, [system.systemId], 0]
+            })
+          }))
+        );
+        const result = await (0, import_foundry5.cast)([
+          "run",
+          "--label",
+          `${worldAddress}:World`,
+          ...labels.map(({ label, address }) => ["--label", `${address}:${label}`]).flat(),
+          `${args.tx}`
+        ]);
+        console.log(result);
+        process.exit(0);
+      }
+    };
+    trace_default = commandModule9;
+  }
+});
+
+// src/commands/dev-contracts.ts
+var import_foundry6, import_chalk6, import_chokidar, import_node11, import_path6, import_os2, import_fs6, import_rxjs, import_utils8, devOptions, commandModule10, dev_contracts_default;
+var init_dev_contracts = __esm({
+  "src/commands/dev-contracts.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_foundry6 = require("@latticexyz/common/foundry");
+    import_chalk6 = __toESM(require("chalk"), 1);
+    import_chokidar = __toESM(require("chokidar"), 1);
+    import_node11 = require("@latticexyz/config/node");
+    import_path6 = __toESM(require("path"), 1);
+    import_os2 = require("os");
+    import_fs6 = require("fs");
+    init_runDeploy();
+    import_rxjs = require("rxjs");
+    import_utils8 = require("@latticexyz/common/utils");
+    devOptions = {
+      rpc: deployOptions.rpc,
+      configPath: deployOptions.configPath,
+      alwaysRunPostDeploy: deployOptions.alwaysRunPostDeploy,
+      forgeScriptOptions: deployOptions.forgeScriptOptions,
+      worldAddress: deployOptions.worldAddress
+    };
+    commandModule10 = {
+      command: "dev-contracts",
+      describe: "Start a development server for MUD contracts",
+      builder(yargs) {
+        return yargs.options(devOptions);
+      },
+      async handler(opts) {
+        let rpc = opts.rpc;
+        const configPath = opts.configPath ?? await (0, import_node11.resolveConfigPath)(opts.configPath);
+        const srcDir = await (0, import_foundry6.getSrcDirectory)();
+        const scriptDir = await (0, import_foundry6.getScriptDirectory)();
+        const initialConfig = await (0, import_node11.loadConfig)(configPath);
+        if (!opts.rpc) {
+          console.log(import_chalk6.default.gray("Cleaning devnode cache"));
+          const userHomeDir = (0, import_os2.homedir)();
+          (0, import_fs6.rmSync)(import_path6.default.join(userHomeDir, ".foundry", "anvil", "tmp"), { recursive: true, force: true });
+          const anvilArgs = ["--block-time", "1", "--block-base-fee-per-gas", "0"];
+          (0, import_foundry6.anvil)(anvilArgs);
+          rpc = "http://127.0.0.1:8545";
+        }
+        const lastChange$ = new import_rxjs.BehaviorSubject(Date.now());
+        import_chokidar.default.watch([configPath, srcDir, scriptDir], { ignoreInitial: true }).on("all", async (_, updatePath) => {
+          if (updatePath.includes(configPath)) {
+            console.log(import_chalk6.default.blue("Config changed, queuing deploy\u2026"));
+            lastChange$.next(Date.now());
+          }
+          if (updatePath.includes(srcDir) || updatePath.includes(scriptDir)) {
+            if (!updatePath.includes(initialConfig.codegen.outputDirectory)) {
+              console.log(import_chalk6.default.blue("Contracts changed, queuing deploy\u2026"));
+              lastChange$.next(Date.now());
+            }
+          }
+        });
+        let worldAddress = opts.worldAddress;
+        const deploys$ = lastChange$.pipe(
+          // debounce so that a large batch of file changes only triggers a deploy after it settles down, rather than the first change it sees (and then redeploying immediately after)
+          (0, import_rxjs.debounceTime)(200),
+          (0, import_rxjs.exhaustMap)(async (lastChange) => {
+            if (worldAddress) {
+              console.log(import_chalk6.default.blue("Rebuilding and upgrading world\u2026"));
+            }
+            try {
+              const deploy2 = await runDeploy({
+                ...opts,
+                configPath,
+                rpc,
+                rpcBatch: false,
+                skipBuild: false,
+                printConfig: false,
+                profile: void 0,
+                saveDeployment: true,
+                deployerAddress: void 0,
+                worldAddress,
+                salt: "0x",
+                kms: void 0,
+                indexerUrl: void 0
+              });
+              worldAddress = deploy2.address;
+              if (lastChange < lastChange$.value) {
+                lastChange$.next(lastChange$.value);
+              } else {
+                console.log(import_chalk6.default.gray("\nWaiting for file changes\u2026\n"));
+              }
+              return deploy2;
+            } catch (error4) {
+              console.error(import_chalk6.default.bgRed(import_chalk6.default.whiteBright("\n Error while attempting deploy \n")));
+              console.error(error4);
+              console.log(import_chalk6.default.gray("\nWaiting for file changes\u2026\n"));
+            }
+          }),
+          (0, import_rxjs.filter)(import_utils8.isDefined)
+        );
+        deploys$.subscribe();
+      }
+    };
+    dev_contracts_default = commandModule10;
+  }
+});
+
+// src/verify/verifyContract.ts
+async function verifyContract(options2) {
+  const args = ["verify-contract", options2.address, options2.name, "--rpc-url", options2.rpc];
+  if (options2.verifier) {
+    args.push("--verifier", options2.verifier);
+  }
+  if (options2.verifierUrl) {
+    args.push("--verifier-url", options2.verifierUrl);
+  }
+  await (0, import_foundry7.forge)(args, { cwd: options2.cwd });
+}
+var import_foundry7;
+var init_verifyContract = __esm({
+  "src/verify/verifyContract.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_foundry7 = require("@latticexyz/common/foundry");
+  }
+});
+
+// src/verify.ts
+async function verify({
+  client,
+  rpc,
+  systems,
+  libraries,
+  modules,
+  worldAddress,
+  deployerAddress: initialDeployerAddress,
+  verifier,
+  verifierUrl
+}) {
+  const deployerAddress = initialDeployerAddress ?? await (0, import_internal17.getDeployer)(client);
+  if (!deployerAddress) {
+    throw new import_errors8.MUDError("No deployer address provided or found.");
+  }
+  const implementationStorage = await (0, import_actions8.getStorageAt)(client, {
+    address: worldAddress,
+    slot: ERC1967_IMPLEMENTATION_SLOT
+  });
+  const usesProxy = implementationStorage && implementationStorage !== import_viem20.zeroHash;
+  const verifyQueue = new import_p_queue.default({ concurrency: 4 });
+  const libraryMap = getLibraryMap(libraries);
+  systems.map(
+    (system) => verifyQueue.add(() => {
+      const address = (0, import_internal17.getContractAddress)({
+        deployerAddress,
+        bytecode: system.prepareDeploy(deployerAddress, libraryMap).bytecode
+      });
+      return verifyContract({
+        name: system.label,
+        rpc,
+        verifier,
+        verifierUrl,
+        address
+      }).catch((error4) => {
+        console.error(`Error verifying system contract ${system.label}:`, error4);
+      });
+    })
+  );
+  if (verifier === "sourcify") {
+    await (0, import_execa3.execa)("npm", ["install"], {
+      cwd: "node_modules/@latticexyz/store"
+    });
+    await (0, import_execa3.execa)("npm", ["install"], {
+      cwd: "node_modules/@latticexyz/world"
+    });
+    await (0, import_execa3.execa)("npm", ["install"], {
+      cwd: "node_modules/@latticexyz/world-modules"
+    });
+    Object.entries(
+      usesProxy ? getWorldProxyFactoryContracts(deployerAddress) : getWorldFactoryContracts(deployerAddress)
+    ).map(
+      ([name, { bytecode }]) => verifyQueue.add(
+        () => verifyContract({
+          cwd: "node_modules/@latticexyz/world",
+          name,
+          rpc,
+          verifier,
+          verifierUrl,
+          address: (0, import_internal17.getContractAddress)({
+            deployerAddress,
+            bytecode
+          })
+        }).catch((error4) => {
+          console.error(`Error verifying world factory contract ${name}:`, error4);
+        })
+      )
+    );
+    modules.map(({ name, prepareDeploy }) => {
+      const { address } = prepareDeploy(deployerAddress);
+      return verifyQueue.add(
+        () => verifyContract({
+          // TODO: figure out dir from artifactPath via import.meta.resolve?
+          cwd: "node_modules/@latticexyz/world-modules",
+          name,
+          rpc,
+          verifier,
+          verifierUrl,
+          address
+        }).catch((error4) => {
+          console.error(`Error verifying module contract ${name}:`, error4);
+        })
+      );
+    });
+    if (usesProxy) {
+      const implementationAddress = (0, import_viem20.sliceHex)(implementationStorage, -20);
+      verifyQueue.add(
+        () => verifyContract({
+          cwd: "node_modules/@latticexyz/world",
+          name: "WorldProxy",
+          rpc,
+          verifier,
+          verifierUrl,
+          address: worldAddress
+        }).catch((error4) => {
+          console.error(`Error verifying WorldProxy contract:`, error4);
+        })
+      );
+      verifyQueue.add(
+        () => verifyContract({
+          cwd: "node_modules/@latticexyz/world",
+          name: "World",
+          rpc,
+          verifier,
+          verifierUrl,
+          address: implementationAddress
+        }).catch((error4) => {
+          console.error(`Error verifying World contract:`, error4);
+        })
+      );
+    } else {
+      verifyQueue.add(
+        () => verifyContract({
+          cwd: "node_modules/@latticexyz/world",
+          name: "World",
+          rpc,
+          verifier,
+          verifierUrl,
+          address: worldAddress
+        }).catch((error4) => {
+          console.error(`Error verifying World contract:`, error4);
+        })
+      );
+    }
+  } else {
+    console.log("");
+    console.log(
+      `Note: MUD is currently unable to verify store, world, and world-modules contracts with ${verifier}. We are planning to expand support in a future version.`
+    );
+    console.log("");
+  }
+}
+var import_viem20, import_p_queue, import_errors8, import_actions8, import_execa3, import_internal17, ERC1967_IMPLEMENTATION_SLOT;
+var init_verify = __esm({
+  "src/verify.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem20 = require("viem");
+    init_getWorldFactoryContracts();
+    init_verifyContract();
+    import_p_queue = __toESM(require("p-queue"), 1);
+    init_getWorldProxyFactoryContracts();
+    import_errors8 = require("@latticexyz/common/errors");
+    import_actions8 = require("viem/actions");
+    import_execa3 = require("execa");
+    import_internal17 = require("@latticexyz/common/internal");
+    init_getLibraryMap();
+    ERC1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+  }
+});
+
+// src/commands/verify.ts
+var import_node12, import_foundry8, import_viem21, import_chalk7, import_node_path7, verifyOptions, commandModule11, verify_default;
+var init_verify2 = __esm({
+  "src/commands/verify.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_verify();
+    import_node12 = require("@latticexyz/config/node");
+    import_foundry8 = require("@latticexyz/common/foundry");
+    import_viem21 = require("viem");
+    import_chalk7 = __toESM(require("chalk"), 1);
+    init_configToModules();
+    import_node_path7 = __toESM(require("path"), 1);
+    init_resolveConfig();
+    verifyOptions = {
+      deployerAddress: {
+        type: "string",
+        desc: "Deploy using an existing deterministic deployer (https://github.com/Arachnid/deterministic-deployment-proxy)"
+      },
+      worldAddress: { type: "string", required: true, desc: "Verify an existing World at the given address" },
+      configPath: { type: "string", desc: "Path to the MUD config file" },
+      profile: { type: "string", desc: "The foundry profile to use" },
+      rpc: { type: "string", desc: "The RPC URL to use. Defaults to the RPC url from the local foundry.toml" },
+      rpcBatch: {
+        type: "boolean",
+        desc: "Enable batch processing of RPC requests in viem client (defaults to batch size of 100 and wait of 1s)"
+      },
+      verifier: { type: "string", desc: "The verifier to use. Defaults to blockscout", default: "blockscout" },
+      verifierUrl: {
+        type: "string",
+        desc: "The verification provider."
+      }
+    };
+    commandModule11 = {
+      command: "verify",
+      describe: "Verify contracts",
+      builder(yargs) {
+        return yargs.options(verifyOptions);
+      },
+      async handler(opts) {
+        const profile = opts.profile;
+        const configPath = await (0, import_node12.resolveConfigPath)(opts.configPath);
+        const rootDir = import_node_path7.default.dirname(configPath);
+        const config2 = await (0, import_node12.loadConfig)(configPath);
+        const outDir = await (0, import_foundry8.getOutDirectory)(profile);
+        const modules = await configToModules(config2, outDir);
+        const { systems, libraries } = await resolveConfig({
+          rootDir,
+          config: config2,
+          forgeOutDir: outDir
+        });
+        const rpc = opts.rpc ?? await (0, import_foundry8.getRpcUrl)(profile);
+        console.log(
+          import_chalk7.default.bgBlue(
+            import_chalk7.default.whiteBright(`
+ Verifying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} 
+`)
+          )
+        );
+        const client = (0, import_viem21.createWalletClient)({
+          transport: (0, import_viem21.http)(rpc, {
+            batch: opts.rpcBatch ? {
+              batchSize: 100,
+              wait: 1e3
+            } : void 0
+          })
+        });
+        await verify({
+          client,
+          rpc,
+          systems,
+          libraries,
+          modules,
+          deployerAddress: opts.deployerAddress,
+          worldAddress: opts.worldAddress,
+          verifier: opts.verifier,
+          verifierUrl: opts.verifierUrl
+        });
+      }
+    };
+    verify_default = commandModule11;
+  }
+});
+
+// src/deploy/getRecord.ts
+async function getRecord({
+  client,
+  worldDeploy,
+  table,
+  key
+}) {
+  const [staticData, encodedLengths, dynamicData] = await (0, import_actions9.readContract)(client, {
+    blockNumber: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    abi: worldAbi,
+    functionName: "getRecord",
+    args: [table.tableId, (0, import_internal18.getKeyTuple)(table, key)]
+    // TODO: remove cast once https://github.com/wevm/viem/issues/2125 is resolved
+    //       has something to do function overloads and TS having a hard time inferring which args to use
+  });
+  const record = {
+    ...key,
+    ...(0, import_internal18.decodeValueArgs)((0, import_internal18.getSchemaTypes)((0, import_internal18.getValueSchema)(table)), {
+      staticData,
+      encodedLengths,
+      dynamicData
+    })
+  };
+  return (0, import_utils9.mapObject)(table.schema, (value, key2) => record[key2]);
+}
+var import_internal18, import_actions9, import_utils9;
+var init_getRecord = __esm({
+  "src/deploy/getRecord.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_internal18 = require("@latticexyz/protocol-parser/internal");
+    init_common();
+    import_actions9 = require("viem/actions");
+    import_utils9 = require("@latticexyz/common/utils");
+  }
+});
+
+// src/pull/debug.ts
+var debug3, error3;
+var init_debug3 = __esm({
+  "src/pull/debug.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_debug();
+    debug3 = debug.extend("pull");
+    error3 = debug.extend("pull");
+    debug3.log = console.debug.bind(console);
+    error3.log = console.error.bind(console);
+  }
+});
+
+// src/pull/pull.ts
+function namespaceToHex(namespace) {
+  return (0, import_common25.resourceToHex)({ type: "namespace", namespace, name: "" });
+}
+async function pull({ rootDir, client, worldAddress, replace, indexerUrl, chainId }) {
+  const replaceFiles = replace ?? await (0, import_find_up3.findUp)(".git", { cwd: rootDir }) != null;
+  const worldDeploy = await getWorldDeploy(client, worldAddress);
+  const resourceIds = await getResourceIds({ client, worldDeploy, indexerUrl, chainId });
+  const resources = resourceIds.map(import_common25.hexToResource).filter((resource) => !ignoredNamespaces.has(resource.namespace));
+  const tables = await getTables({ client, worldDeploy, indexerUrl, chainId });
+  const labels = Object.fromEntries(
+    (await Promise.all(
+      resourceIds.map(async (resourceId) => {
+        const { value: bytesValue } = await getRecord({
+          client,
+          worldDeploy,
+          table: import_mud8.default.tables.metadata__ResourceTag,
+          key: { resource: resourceId, tag: (0, import_viem22.stringToHex)("label", { size: 32 }) }
+        });
+        const value = (0, import_viem22.hexToString)(bytesValue);
+        return [resourceId, value === "" ? null : value];
+      })
+    )).filter(([, label]) => label != null)
+  );
+  labels[namespaceToHex("")] ??= "root";
+  const worldFunctions = await (0, import_world4.getFunctions)({
+    client,
+    worldAddress: worldDeploy.address,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    indexerUrl,
+    chainId
+  });
+  const namespaces = resources.filter((resource) => resource.type === "namespace");
+  const systems = await Promise.all(
+    resources.filter((resource) => resource.type === "system").map(async ({ namespace, name, resourceId: systemId }) => {
+      const namespaceId = namespaceToHex(namespace);
+      const systemLabel = labels[systemId] ?? name.replace(/(S(y(s(t(e(m)?)?)?)?)?)?$/, "System");
+      const [metadataAbi2, metadataWorldAbi] = await Promise.all([
+        getRecord({
+          client,
+          worldDeploy,
+          table: import_mud8.default.tables.metadata__ResourceTag,
+          key: { resource: systemId, tag: (0, import_viem22.stringToHex)("abi", { size: 32 }) }
+        }).then((record) => (0, import_viem22.hexToString)(record.value)).then((value) => value !== "" ? value.split("\n") : []),
+        getRecord({
+          client,
+          worldDeploy,
+          table: import_mud8.default.tables.metadata__ResourceTag,
+          key: { resource: systemId, tag: (0, import_viem22.stringToHex)("worldAbi", { size: 32 }) }
+        }).then((record) => (0, import_viem22.hexToString)(record.value)).then((value) => value !== "" ? value.split("\n") : [])
+      ]);
+      const functions = worldFunctions.filter((func) => func.systemId === systemId);
+      const abi = (metadataAbi2.length ? metadataAbi2 : functions.map((func) => `function ${func.systemFunctionSignature}`)).map((sig) => {
+        try {
+          return (0, import_viem22.parseAbiItem)(sig);
+        } catch {
+          debug3(`Skipping invalid system signature: ${sig}`);
+        }
+      }).filter(import_utils10.isDefined);
+      const worldAbi3 = (metadataWorldAbi.length ? metadataWorldAbi : functions.map((func) => `function ${func.signature}`)).map((sig) => {
+        try {
+          return (0, import_viem22.parseAbiItem)(sig);
+        } catch {
+          debug3(`Skipping invalid world signature: ${sig}`);
+        }
+      }).filter(import_utils10.isDefined);
+      return {
+        namespaceId,
+        namespaceLabel: labels[namespaceId] ?? namespace,
+        label: systemLabel,
+        systemId,
+        namespace,
+        name,
+        abi,
+        worldAbi: worldAbi3
+      };
+    })
+  );
+  debug3("generating config");
+  const configInput = {
+    namespaces: Object.fromEntries(
+      namespaces.map(({ namespace, resourceId: namespaceId }) => {
+        const namespaceLabel = labels[namespaceId] ?? namespace;
+        return [
+          namespaceLabel,
+          {
+            ...namespaceLabel !== namespace ? { namespace } : null,
+            tables: Object.fromEntries(
+              tables.filter((table) => table.namespace === namespace).map((table) => {
+                const tableLabel = labels[table.tableId] ?? table.name;
+                return [
+                  tableLabel,
+                  {
+                    ...tableLabel !== table.name ? { name: table.name } : null,
+                    ...table.type !== "table" ? { type: table.type } : null,
+                    schema: (0, import_internal19.getSchemaTypes)(table.schema),
+                    key: table.key,
+                    deploy: { disabled: true }
+                  }
+                ];
+              })
+            )
+          }
+        ];
+      })
+    )
+  };
+  debug3("validating config");
+  const config2 = (0, import_world5.defineWorld)(configInput);
+  debug3("writing config");
+  await writeFile(
+    import_node_path8.default.join(rootDir, "mud.config.ts"),
+    await (0, import_codegen3.formatTypescript)(`
+      import { defineWorld } from "@latticexyz/world";
+
+      export default defineWorld(${JSON.stringify(configInput)});
+    `),
+    { overwrite: replaceFiles }
+  );
+  const remoteDir = import_node_path8.default.join(config2.sourceDirectory, "remote");
+  if (replaceFiles) {
+    await import_promises.default.rm(remoteDir, { recursive: true, force: true });
+  }
+  for (const system of systems.filter((system2) => system2.abi.length)) {
+    const interfaceName = `I${system.label}`;
+    const interfaceFile = import_node_path8.default.join(remoteDir, "namespaces", system.namespaceLabel, `${interfaceName}.sol`);
+    debug3("writing system interface", interfaceName, "to", interfaceFile);
+    const source = (0, import_codegen3.abiToInterface)({ name: interfaceName, systemId: system.systemId, abi: system.abi });
+    await writeFile(import_node_path8.default.join(rootDir, interfaceFile), await (0, import_codegen3.formatSolidity)(source), { overwrite: replaceFiles });
+  }
+  const worldAbi2 = systems.flatMap((system) => system.worldAbi);
+  if (worldAbi2.length) {
+    const interfaceName = "IWorldSystems";
+    const interfaceFile = import_node_path8.default.join(remoteDir, `${interfaceName}.sol`);
+    debug3("writing world systems interface to", interfaceFile);
+    const source = (0, import_codegen3.abiToInterface)({ name: interfaceName, abi: worldAbi2 });
+    await writeFile(import_node_path8.default.join(rootDir, interfaceFile), await (0, import_codegen3.formatSolidity)(source), { overwrite: replaceFiles });
+  }
+  return { config: config2 };
+}
+async function exists(filename) {
+  return import_promises.default.access(filename).then(
+    () => true,
+    () => false
+  );
+}
+async function writeFile(filename, contents, opts = {}) {
+  if (!opts.overwrite && await exists(filename)) {
+    throw new WriteFileExistsError(filename);
+  }
+  await import_promises.default.mkdir(import_node_path8.default.dirname(filename), { recursive: true });
+  await import_promises.default.writeFile(filename, contents);
+}
+var import_viem22, import_internal19, import_common25, import_mud8, import_node_path8, import_promises, import_world4, import_codegen3, import_world5, import_find_up3, import_utils10, ignoredNamespaces, WriteFileExistsError;
+var init_pull = __esm({
+  "src/pull/pull.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_viem22 = require("viem");
+    init_getTables();
+    init_getWorldDeploy();
+    import_internal19 = require("@latticexyz/protocol-parser/internal");
+    import_common25 = require("@latticexyz/common");
+    import_mud8 = __toESM(require("@latticexyz/world-module-metadata/mud.config"), 1);
+    init_getRecord();
+    import_node_path8 = __toESM(require("path"), 1);
+    import_promises = __toESM(require("fs/promises"), 1);
+    init_getResourceIds();
+    import_world4 = require("@latticexyz/store-sync/world");
+    import_codegen3 = require("@latticexyz/common/codegen");
+    init_debug3();
+    import_world5 = require("@latticexyz/world");
+    import_find_up3 = require("find-up");
+    import_utils10 = require("@latticexyz/common/utils");
+    ignoredNamespaces = /* @__PURE__ */ new Set(["store", "world", "metadata"]);
+    WriteFileExistsError = class extends Error {
+      constructor(filename) {
+        super(`Attempted to write file at "${filename}", but it already exists.`);
+        this.filename = filename;
+        this.name = "WriteFileExistsError";
+      }
+    };
+  }
+});
+
+// src/commands/pull.ts
+var import_foundry9, import_viem23, import_chalk8, import_node_path9, import_actions10, options, commandModule12, pull_default;
+var init_pull2 = __esm({
+  "src/commands/pull.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_foundry9 = require("@latticexyz/common/foundry");
+    import_viem23 = require("viem");
+    import_chalk8 = __toESM(require("chalk"), 1);
+    init_pull();
+    import_node_path9 = __toESM(require("path"), 1);
+    init_build();
+    import_actions10 = require("viem/actions");
+    init_defaultChains();
+    options = {
+      worldAddress: { type: "string", required: true, desc: "Remote world address" },
+      profile: { type: "string", desc: "The foundry profile to use" },
+      rpc: { type: "string", desc: "The RPC URL to use. Defaults to the RPC url from the local foundry.toml" },
+      rpcBatch: {
+        type: "boolean",
+        desc: "Enable batch processing of RPC requests in viem client (defaults to batch size of 100 and wait of 1s)"
+      },
+      replace: {
+        type: "boolean",
+        desc: "Replace existing files and directories with data from remote world."
+      },
+      indexerUrl: {
+        type: "string",
+        desc: "The indexer URL to pull from.",
+        required: false
+      }
+    };
+    commandModule12 = {
+      command: "pull",
+      describe: "Pull mud.config.ts and interfaces from an existing world.",
+      builder(yargs) {
+        return yargs.options(options);
+      },
+      async handler(opts) {
+        const profile = opts.profile;
+        const rpc = opts.rpc ?? await (0, import_foundry9.getRpcUrl)(profile);
+        const client = (0, import_viem23.createClient)({
+          transport: (0, import_viem23.http)(rpc, {
+            batch: opts.rpcBatch ? {
+              batchSize: 100,
+              wait: 1e3
+            } : void 0
+          })
+        });
+        const chainId = await (0, import_actions10.getChainId)(client);
+        const indexerUrl = opts.indexerUrl ?? defaultChains.find((chain) => chain.id === chainId)?.indexerUrl;
+        console.log(import_chalk8.default.bgBlue(import_chalk8.default.whiteBright(`
+ Pulling MUD config from world at ${opts.worldAddress} 
+`)));
+        const rootDir = process.cwd();
+        try {
+          const { config: config2 } = await pull({
+            rootDir,
+            client,
+            worldAddress: opts.worldAddress,
+            indexerUrl,
+            chainId,
+            replace: opts.replace
+          });
+          await build({ rootDir, config: config2, foundryProfile: profile });
+        } catch (error4) {
+          if (error4 instanceof WriteFileExistsError) {
+            console.log();
+            console.log(import_chalk8.default.bgRed(import_chalk8.default.whiteBright(" Error ")));
+            console.log(`  Attempted to write file at "${import_node_path9.default.relative(rootDir, error4.filename)}", but it already exists.`);
+            console.log();
+            console.log("  To overwrite files, use `--replace` when running this command.");
+            console.log();
+            return;
+          }
+          throw error4;
+        }
+      }
+    };
+    pull_default = commandModule12;
+  }
+});
+
+// src/commands/index.ts
+var commands_exports = {};
+__export(commands_exports, {
+  commands: () => commands
+});
+var import_internal20, import_internal21, commands;
+var init_commands = __esm({
+  "src/commands/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_internal20 = require("@latticexyz/gas-report/internal");
+    import_internal21 = require("@latticexyz/abi-ts/internal");
+    init_build2();
+    init_devnode();
+    init_hello();
+    init_tablegen();
+    init_deploy2();
+    init_worldgen();
+    init_set_version();
+    init_test();
+    init_trace();
+    init_dev_contracts();
+    init_verify2();
+    init_pull2();
+    commands = [
+      build_default,
+      deploy_default,
+      devnode_default,
+      import_internal20.command,
+      hello_default,
+      tablegen_default,
+      worldgen_default,
+      set_version_default,
+      test_default,
+      trace_default,
+      dev_contracts_default,
+      import_internal21.command,
+      verify_default,
+      pull_default
+    ];
+  }
+});
+
+// src/mud.ts
+init_cjs_shims();
+var dotenv = __toESM(require("dotenv"), 1);
+dotenv.config();
+async function run() {
+  const { default: yargs } = await import("yargs");
+  const { default: chalk9 } = await import("chalk");
+  const { hideBin } = await import("yargs/helpers");
+  const { logError: logError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+  const { commands: commands2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+  yargs(hideBin(process.argv)).scriptName("mud").command(commands2).strict().fail((msg, err) => {
+    console.error(chalk9.red(msg));
+    if (msg.includes("Missing required argument")) {
+      console.log(
+        chalk9.yellow(`Run 'pnpm mud ${process.argv[2]} --help' for a list of available and required arguments.`)
+      );
+    }
+    console.log("");
+    if (err != null) {
+      logError2(err);
+      console.log("");
+    }
+    process.exit(1);
+  }).alias({ h: "help" }).argv;
+}
+run();
+//# sourceMappingURL=mud.cjs.map