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

package/dist/commands-HW6E5GIK.js

@@ -0,0 +1,3025 @@
+import {
+  logError
+} from "./chunk-7SEEAWAF.js";
+
+// src/commands/index.ts
+import { command as gasReport } from "@latticexyz/gas-report/internal";
+import { command as abiTs } from "@latticexyz/abi-ts/internal";
+
+// src/commands/build.ts
+import { loadConfig, resolveConfigPath } from "@latticexyz/config/node";
+
+// src/build.ts
+import { tablegen } from "@latticexyz/store/codegen";
+import { buildSystemsManifest, worldgen } from "@latticexyz/world/node";
+import { forge } from "@latticexyz/common/foundry";
+import { execa } from "execa";
+async function build({ rootDir, config, foundryProfile }) {
+  await Promise.all([tablegen({ rootDir, config }), worldgen({ rootDir, config })]);
+  await forge(["build"], { profile: foundryProfile });
+  await buildSystemsManifest({ rootDir, config });
+  await execa("mud", ["abi-ts"], { stdio: "inherit" });
+}
+
+// src/commands/build.ts
+import path from "node:path";
+var 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 resolveConfigPath(opts.configPath);
+    const config = await loadConfig(configPath);
+    await build({ rootDir: path.dirname(configPath), config, foundryProfile: opts.profile });
+    process.exit(0);
+  }
+};
+var build_default = commandModule;
+
+// src/commands/devnode.ts
+import { rmSync } from "fs";
+import { homedir } from "os";
+import path2 from "path";
+import { execa as execa2 } from "execa";
+var 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 = homedir();
+    rmSync(path2.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 = execa2("anvil", anvilArgs, {
+      stdio: ["inherit", "inherit", "inherit"]
+    });
+    process.on("SIGINT", () => {
+      console.log("\ngracefully shutting down from SIGINT (Crtl-C)");
+      child.kill();
+      process.exit();
+    });
+    await child;
+  }
+};
+var devnode_default = commandModule2;
+
+// src/commands/hello.ts
+var 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);
+  }
+};
+var hello_default = commandModule3;
+
+// src/commands/tablegen.ts
+import { loadConfig as loadConfig2, resolveConfigPath as resolveConfigPath2 } from "@latticexyz/config/node";
+import { tablegen as tablegen2 } from "@latticexyz/store/codegen";
+import path3 from "node:path";
+var 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 resolveConfigPath2(opts.configPath);
+    const config = await loadConfig2(configPath);
+    await tablegen2({ rootDir: path3.dirname(configPath), config });
+    process.exit(0);
+  }
+};
+var tablegen_default = commandModule4;
+
+// src/runDeploy.ts
+import path8 from "node:path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+
+// package.json
+var 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/deploy.ts
+import { stringToHex as stringToHex2 } from "viem";
+
+// src/deploy/deployWorld.ts
+import { waitForTransactionReceipt } from "viem/actions";
+
+// src/deploy/getWorldFactoryContracts.ts
+import worldFactoryBuild from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.json" assert { type: "json" };
+import worldFactoryAbi from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json" assert { type: "json" };
+import { encodeDeployData as encodeDeployData2, size as size2 } from "viem";
+
+// src/deploy/getWorldContracts.ts
+import accessManagementSystemBuild from "@latticexyz/world/out/AccessManagementSystem.sol/AccessManagementSystem.json" assert { type: "json" };
+import balanceTransferSystemBuild from "@latticexyz/world/out/BalanceTransferSystem.sol/BalanceTransferSystem.json" assert { type: "json" };
+import batchCallSystemBuild from "@latticexyz/world/out/BatchCallSystem.sol/BatchCallSystem.json" assert { type: "json" };
+import registrationSystemBuild from "@latticexyz/world/out/RegistrationSystem.sol/RegistrationSystem.json" assert { type: "json" };
+import initModuleBuild from "@latticexyz/world/out/InitModule.sol/InitModule.json" assert { type: "json" };
+import initModuleAbi from "@latticexyz/world/out/InitModule.sol/InitModule.abi.json" assert { type: "json" };
+import { encodeDeployData, size } from "viem";
+import { getContractAddress } from "@latticexyz/common/internal";
+function getWorldContracts(deployerAddress) {
+  const accessManagementSystemDeployedBytecodeSize = size(accessManagementSystemBuild.deployedBytecode.object);
+  const accessManagementSystemBytecode = accessManagementSystemBuild.bytecode.object;
+  const accessManagementSystem = getContractAddress({
+    deployerAddress,
+    bytecode: accessManagementSystemBytecode
+  });
+  const balanceTransferSystemDeployedBytecodeSize = size(balanceTransferSystemBuild.deployedBytecode.object);
+  const balanceTransferSystemBytecode = balanceTransferSystemBuild.bytecode.object;
+  const balanceTransferSystem = getContractAddress({
+    deployerAddress,
+    bytecode: balanceTransferSystemBytecode
+  });
+  const batchCallSystemDeployedBytecodeSize = size(batchCallSystemBuild.deployedBytecode.object);
+  const batchCallSystemBytecode = batchCallSystemBuild.bytecode.object;
+  const batchCallSystem = getContractAddress({ deployerAddress, bytecode: batchCallSystemBytecode });
+  const registrationDeployedBytecodeSize = size(registrationSystemBuild.deployedBytecode.object);
+  const registrationBytecode = registrationSystemBuild.bytecode.object;
+  const registration = getContractAddress({
+    deployerAddress,
+    bytecode: registrationBytecode
+  });
+  const initModuleDeployedBytecodeSize = size(initModuleBuild.deployedBytecode.object);
+  const initModuleBytecode = encodeDeployData({
+    bytecode: initModuleBuild.bytecode.object,
+    abi: initModuleAbi,
+    args: [accessManagementSystem, balanceTransferSystem, batchCallSystem, registration]
+  });
+  const initModule = 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
+    }
+  };
+}
+
+// src/deploy/getWorldFactoryContracts.ts
+import { getContractAddress as getContractAddress2 } from "@latticexyz/common/internal";
+function getWorldFactoryContracts(deployerAddress) {
+  const worldContracts = getWorldContracts(deployerAddress);
+  const worldFactoryDeployedBytecodeSize = size2(worldFactoryBuild.deployedBytecode.object);
+  const worldFactoryBytecode = encodeDeployData2({
+    bytecode: worldFactoryBuild.bytecode.object,
+    abi: worldFactoryAbi,
+    args: [worldContracts.InitModule.address]
+  });
+  const worldFactory = getContractAddress2({ deployerAddress, bytecode: worldFactoryBytecode });
+  return {
+    ...worldContracts,
+    WorldFactory: {
+      bytecode: worldFactoryBytecode,
+      deployedBytecodeSize: worldFactoryDeployedBytecodeSize,
+      debugLabel: "world factory",
+      address: worldFactory
+    }
+  };
+}
+
+// src/deploy/getWorldProxyFactoryContracts.ts
+import worldProxyFactoryBuild from "@latticexyz/world/out/WorldProxyFactory.sol/WorldProxyFactory.json" assert { type: "json" };
+import worldProxyFactoryAbi from "@latticexyz/world/out/WorldProxyFactory.sol/WorldProxyFactory.abi.json" assert { type: "json" };
+import { encodeDeployData as encodeDeployData3, size as size3 } from "viem";
+import { getContractAddress as getContractAddress3 } from "@latticexyz/common/internal";
+function getWorldProxyFactoryContracts(deployerAddress) {
+  const worldContracts = getWorldContracts(deployerAddress);
+  const worldProxyFactoryDeployedBytecodeSize = size3(worldProxyFactoryBuild.deployedBytecode.object);
+  const worldProxyFactoryBytecode = encodeDeployData3({
+    bytecode: worldProxyFactoryBuild.bytecode.object,
+    abi: worldProxyFactoryAbi,
+    args: [worldContracts.InitModule.address]
+  });
+  const worldProxyFactory = getContractAddress3({ deployerAddress, bytecode: worldProxyFactoryBytecode });
+  return {
+    ...worldContracts,
+    WorldProxyFactory: {
+      bytecode: worldProxyFactoryBytecode,
+      deployedBytecodeSize: worldProxyFactoryDeployedBytecodeSize,
+      debugLabel: "world proxy factory",
+      address: worldProxyFactory
+    }
+  };
+}
+
+// src/deploy/ensureWorldFactory.ts
+import { ensureContractsDeployed } from "@latticexyz/common/internal";
+async function ensureWorldFactory(client, deployerAddress, withWorldProxy) {
+  if (withWorldProxy) {
+    const contracts2 = getWorldProxyFactoryContracts(deployerAddress);
+    await ensureContractsDeployed({
+      client,
+      deployerAddress,
+      contracts: Object.values(contracts2)
+    });
+    return contracts2.WorldProxyFactory.address;
+  }
+  const contracts = getWorldFactoryContracts(deployerAddress);
+  await ensureContractsDeployed({
+    client,
+    deployerAddress,
+    contracts: Object.values(contracts)
+  });
+  return contracts.WorldFactory.address;
+}
+
+// src/deploy/deployWorld.ts
+import WorldFactoryAbi from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json" assert { type: "json" };
+import { writeContract } from "@latticexyz/common";
+
+// src/debug.ts
+import createDebug from "debug";
+var debug = createDebug("mud:cli");
+var error = createDebug("mud:cli");
+debug.log = console.debug.bind(console);
+error.log = console.error.bind(console);
+
+// src/deploy/debug.ts
+var debug2 = debug.extend("deploy");
+var error2 = debug.extend("deploy");
+debug2.log = console.debug.bind(console);
+error2.log = console.error.bind(console);
+
+// src/deploy/logsToWorldDeploy.ts
+import { AbiEventSignatureNotFoundError, decodeEventLog, hexToString, parseAbi, getAddress } from "viem";
+
+// src/deploy/common.ts
+import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
+import { helloStoreEvent } from "@latticexyz/store";
+import { helloWorldEvent } from "@latticexyz/world";
+var worldDeployEvents = [helloStoreEvent, helloWorldEvent];
+var worldAbi = IBaseWorldAbi;
+var supportedStoreVersions = ["2.0.0", "2.0.1", "2.0.2"];
+var supportedWorldVersions = ["2.0.0", "2.0.1", "2.0.2"];
+
+// src/deploy/logsToWorldDeploy.ts
+import { isDefined } from "@latticexyz/common/utils";
+function logsToWorldDeploy(logs) {
+  const deployLogs = logs.map((log) => {
+    try {
+      return {
+        ...log,
+        ...decodeEventLog({
+          strict: true,
+          abi: 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: getAddress(log.address)
+      };
+    } catch (error4) {
+      if (error4 instanceof AbiEventSignatureNotFoundError) {
+        return;
+      }
+      throw error4;
+    }
+  }).filter(isDefined);
+  const { address, deployBlock, worldVersion, storeVersion } = deployLogs.reduce(
+    (deploy2, log) => ({
+      ...deploy2,
+      address: log.address,
+      deployBlock: log.blockNumber,
+      ...log.eventName === "HelloWorld" ? { worldVersion: hexToString(log.args.worldVersion).replace(/\0+$/, "") } : null,
+      ...log.eventName === "HelloStore" ? { storeVersion: 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 };
+}
+
+// src/deploy/deployWorld.ts
+async function deployWorld(client, deployerAddress, salt, withWorldProxy) {
+  const worldFactory = await ensureWorldFactory(client, deployerAddress, withWorldProxy);
+  debug2("deploying world");
+  const tx = await writeContract(client, {
+    chain: client.chain ?? null,
+    address: worldFactory,
+    abi: WorldFactoryAbi,
+    functionName: "deployWorld",
+    args: [salt]
+  });
+  debug2("waiting for world deploy");
+  const receipt = await 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 };
+}
+
+// src/deploy/ensureTables.ts
+import { resourceToLabel, writeContract as writeContract2 } from "@latticexyz/common";
+import {
+  valueSchemaToFieldLayoutHex,
+  keySchemaToHex,
+  valueSchemaToHex,
+  getSchemaTypes,
+  getValueSchema,
+  getKeySchema
+} from "@latticexyz/protocol-parser/internal";
+
+// src/deploy/getTables.ts
+import { decodeAbiParameters, parseAbiParameters } from "viem";
+import { hexToResource } from "@latticexyz/common";
+import { hexToSchema } from "@latticexyz/protocol-parser/internal";
+import storeConfig from "@latticexyz/store/mud.config";
+import { getRecords } from "@latticexyz/store-sync";
+async function getTables({
+  client,
+  worldDeploy,
+  indexerUrl,
+  chainId
+}) {
+  debug2("looking up tables for", worldDeploy.address);
+  const { records } = await getRecords({
+    table: storeConfig.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 } = hexToResource(record.tableId);
+    const solidityKeySchema = hexToSchema(record.keySchema);
+    const solidityValueSchema = hexToSchema(record.valueSchema);
+    const keyNames = decodeAbiParameters(parseAbiParameters("string[]"), record.abiEncodedKeyNames)[0];
+    const fieldNames = decodeAbiParameters(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;
+}
+
+// src/deploy/ensureTables.ts
+import pRetry from "p-retry";
+import { isDefined as isDefined2 } from "@latticexyz/common/utils";
+async function ensureTables({
+  client,
+  worldDeploy,
+  tables,
+  indexerUrl,
+  chainId
+}) {
+  const configTables = new Map(
+    tables.map((table) => {
+      const keySchema = getSchemaTypes(getKeySchema(table));
+      const valueSchema = getSchemaTypes(getValueSchema(table));
+      const keySchemaHex = keySchemaToHex(keySchema);
+      const valueSchemaHex = 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(resourceToLabel).join(", "));
+    const schemaErrors = existingTables.map((table) => {
+      const configTable = configTables.get(table.tableId);
+      if (table.keySchemaHex !== configTable.keySchemaHex || table.valueSchemaHex !== configTable.valueSchemaHex) {
+        return [
+          `"${resourceToLabel(table)}" table:`,
+          `  Registered schema: ${JSON.stringify({ schema: getSchemaTypes(table.schema), key: table.key })}`,
+          `      Config schema: ${JSON.stringify({ schema: getSchemaTypes(configTable.schema), key: configTable.key })}`
+        ].join("\n");
+      }
+    }).filter(isDefined2);
+    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(resourceToLabel).join(", "));
+    return await Promise.all(
+      missingTables.map((table) => {
+        const keySchema = getSchemaTypes(getKeySchema(table));
+        const valueSchema = getSchemaTypes(getValueSchema(table));
+        return pRetry(
+          () => writeContract2(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,
+              valueSchemaToFieldLayoutHex(valueSchema),
+              keySchemaToHex(keySchema),
+              valueSchemaToHex(valueSchema),
+              Object.keys(keySchema),
+              Object.keys(valueSchema)
+            ]
+          }),
+          {
+            retries: 3,
+            onFailedAttempt: () => debug2(`failed to register table ${resourceToLabel(table)}, retrying...`)
+          }
+        );
+      })
+    );
+  }
+  return [];
+}
+
+// src/deploy/ensureSystems.ts
+import { getAddress as getAddress3 } from "viem";
+import { writeContract as writeContract3, resourceToLabel as resourceToLabel3 } from "@latticexyz/common";
+
+// src/deploy/getSystems.ts
+import { hexToResource as hexToResource2, resourceToLabel as resourceToLabel2 } from "@latticexyz/common";
+import { getFunctions } from "@latticexyz/store-sync/world";
+
+// src/deploy/getResourceIds.ts
+import storeConfig2 from "@latticexyz/store/mud.config";
+import { getRecords as getRecords2 } from "@latticexyz/store-sync";
+async function getResourceIds({
+  client,
+  worldDeploy,
+  indexerUrl,
+  chainId
+}) {
+  debug2("looking up resource IDs for", worldDeploy.address);
+  const { records } = await getRecords2({
+    table: storeConfig2.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;
+}
+
+// src/deploy/getTableValue.ts
+import {
+  decodeValueArgs,
+  encodeKey,
+  getKeySchema as getKeySchema2,
+  getSchemaTypes as getSchemaTypes2,
+  getValueSchema as getValueSchema2
+} from "@latticexyz/protocol-parser/internal";
+import { readContract } from "viem/actions";
+async function getTableValue({
+  client,
+  worldDeploy,
+  table,
+  key
+}) {
+  const [staticData, encodedLengths, dynamicData] = await readContract(client, {
+    blockNumber: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    abi: worldAbi,
+    functionName: "getRecord",
+    args: [table.tableId, encodeKey(getSchemaTypes2(getKeySchema2(table)), key)]
+    // TODO: remove cast once https://github.com/wevm/viem/issues/2125 is resolved
+  });
+  return decodeValueArgs(getSchemaTypes2(getValueSchema2(table)), {
+    staticData,
+    encodedLengths,
+    dynamicData
+  });
+}
+
+// src/deploy/getResourceAccess.ts
+import { getAddress as getAddress2 } from "viem";
+import worldConfig from "@latticexyz/world/mud.config";
+import { getRecords as getRecords3 } from "@latticexyz/store-sync";
+async function getResourceAccess({
+  client,
+  worldDeploy,
+  indexerUrl,
+  chainId
+}) {
+  debug2("looking up resource access for", worldDeploy.address);
+  const { records } = await getRecords3({
+    table: worldConfig.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: getAddress2(record.caller)
+  }));
+  debug2("found", access.length, "resource<>address access pairs");
+  return access;
+}
+
+// src/deploy/getSystems.ts
+import worldConfig2 from "@latticexyz/world/mud.config";
+async function getSystems({
+  client,
+  worldDeploy,
+  indexerUrl,
+  chainId
+}) {
+  const [resourceIds, functions, resourceAccess] = await Promise.all([
+    getResourceIds({ client, worldDeploy, indexerUrl, chainId }),
+    getFunctions({
+      client,
+      worldAddress: worldDeploy.address,
+      fromBlock: worldDeploy.deployBlock,
+      toBlock: worldDeploy.stateBlock,
+      indexerUrl,
+      chainId
+    }),
+    getResourceAccess({ client, worldDeploy, indexerUrl, chainId })
+  ]);
+  const systems = resourceIds.map(hexToResource2).filter((resource) => resource.type === "system");
+  debug2("looking up systems:", systems.map(resourceToLabel2).join(", "));
+  return await Promise.all(
+    systems.map(async (system) => {
+      const { system: address, publicAccess } = await getTableValue({
+        client,
+        worldDeploy,
+        table: worldConfig2.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
+      };
+    })
+  );
+}
+
+// src/deploy/ensureSystems.ts
+import pRetry2 from "p-retry";
+import { ensureContractsDeployed as ensureContractsDeployed2 } from "@latticexyz/common/internal";
+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 && getAddress3(worldSystem.address) === getAddress3(system.prepareDeploy(deployerAddress, libraryMap).address)
+    )
+  );
+  if (existingSystems.length) {
+    debug2("existing systems:", existingSystems.map(resourceToLabel3).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 && getAddress3(worldSystem.address) !== getAddress3(system.prepareDeploy(deployerAddress, libraryMap).address)
+    )
+  );
+  if (systemsToUpgrade.length) {
+    debug2("upgrading systems:", systemsToUpgrade.map(resourceToLabel3).join(", "));
+  }
+  const systemsToAdd = missingSystems.filter(
+    (system) => !worldSystems.some((worldSystem) => worldSystem.systemId === system.systemId)
+  );
+  if (systemsToAdd.length) {
+    debug2("registering new systems:", systemsToAdd.map(resourceToLabel3).join(", "));
+  }
+  await ensureContractsDeployed2({
+    client,
+    deployerAddress,
+    contracts: missingSystems.map((system) => ({
+      bytecode: system.prepareDeploy(deployerAddress, libraryMap).bytecode,
+      deployedBytecodeSize: system.deployedBytecodeSize,
+      debugLabel: `${resourceToLabel3(system)} system`
+    }))
+  });
+  const registerTxs = await Promise.all(
+    missingSystems.map(
+      (system) => pRetry2(
+        () => writeContract3(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 ${resourceToLabel3(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 && getAddress3(address) === getAddress3(access.address)
+    )
+  );
+  const accessToRemove = currentAccess.filter(
+    (access) => !desiredAccess.some(
+      ({ resourceId, address }) => resourceId === access.resourceId && getAddress3(address) === getAddress3(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) => pRetry2(
+        () => writeContract3(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) => pRetry2(
+        () => writeContract3(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];
+}
+
+// src/deploy/getWorldDeploy.ts
+import { getAddress as getAddress4, parseAbi as parseAbi2 } from "viem";
+import { getBlock } from "viem/actions";
+import { fetchBlockLogs } from "@latticexyz/block-logs-stream";
+var deploys = /* @__PURE__ */ new Map();
+async function getWorldDeploy(client, worldAddress, deployBlock) {
+  const address = getAddress4(worldAddress);
+  const stateBlock = await 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 getBlock(client, { blockTag: "earliest" }), stateBlock];
+  const blockLogs = await fetchBlockLogs({
+    publicClient: client,
+    address,
+    events: parseAbi2(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;
+}
+
+// src/deploy/ensureFunctions.ts
+import { hexToResource as hexToResource3, writeContract as writeContract4 } from "@latticexyz/common";
+import { getFunctions as getFunctions2 } from "@latticexyz/store-sync/world";
+import pRetry3 from "p-retry";
+async function ensureFunctions({
+  client,
+  worldDeploy,
+  functions,
+  indexerUrl,
+  chainId
+}) {
+  const worldFunctions = await getFunctions2({
+    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 } = hexToResource3(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 pRetry3(
+        () => writeContract4(client, {
+          chain: client.chain ?? null,
+          address: worldDeploy.address,
+          abi: worldAbi,
+          ...params
+        }),
+        {
+          retries: 3,
+          onFailedAttempt: () => debug2(`failed to register function ${func.signature}, retrying...`)
+        }
+      );
+    })
+  );
+}
+
+// src/deploy/ensureModules.ts
+import { BaseError } from "viem";
+import { writeContract as writeContract5 } from "@latticexyz/common";
+import { isDefined as isDefined3 } from "@latticexyz/common/utils";
+import pRetry4 from "p-retry";
+import { ensureContractsDeployed as ensureContractsDeployed3 } from "@latticexyz/common/internal";
+async function ensureModules({
+  client,
+  deployerAddress,
+  libraryMap,
+  worldDeploy,
+  modules
+}) {
+  if (!modules.length) return [];
+  await ensureContractsDeployed3({
+    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) => pRetry4(
+        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 writeContract5(client, {
+              chain: client.chain ?? null,
+              address: worldDeploy.address,
+              abi,
+              ...params
+            });
+          } catch (error4) {
+            if (error4 instanceof 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(isDefined3);
+}
+
+// src/deploy/ensureNamespaceOwner.ts
+import { getAddress as getAddress5 } from "viem";
+import { hexToResource as hexToResource4, resourceToHex, writeContract as writeContract6 } from "@latticexyz/common";
+import worldConfig3 from "@latticexyz/world/mud.config";
+async function ensureNamespaceOwner({
+  client,
+  worldDeploy,
+  resourceIds,
+  indexerUrl,
+  chainId
+}) {
+  const desiredNamespaces = Array.from(new Set(resourceIds.map((resourceId) => hexToResource4(resourceId).namespace)));
+  const existingResourceIds = await getResourceIds({ client, worldDeploy, indexerUrl, chainId });
+  const existingNamespaces = new Set(existingResourceIds.map((resourceId) => hexToResource4(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: worldConfig3.namespaces.world.tables.NamespaceOwner,
+        key: { namespaceId: resourceToHex({ type: "namespace", namespace, name: "" }) }
+      });
+      return [namespace, owner];
+    })
+  );
+  const unauthorizedNamespaces = namespaceOwners.filter(([, owner]) => getAddress5(owner) !== getAddress5(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) => writeContract6(client, {
+        chain: client.chain ?? null,
+        address: worldDeploy.address,
+        abi: worldAbi,
+        functionName: "registerNamespace",
+        args: [resourceToHex({ namespace, type: "namespace", name: "" })]
+      })
+    )
+  );
+  return registrationTxs;
+}
+
+// src/deploy/deploy.ts
+import { resourceToHex as resourceToHex3, resourceToLabel as resourceToLabel4 } from "@latticexyz/common";
+import { randomBytes } from "crypto";
+
+// src/deploy/ensureResourceTags.ts
+import { stringToHex, BaseError as BaseError2, concatHex } from "viem";
+import { hexToResource as hexToResource5, writeContract as writeContract7 } from "@latticexyz/common";
+import { identity, isDefined as isDefined4 } from "@latticexyz/common/utils";
+import metadataConfig from "@latticexyz/world-module-metadata/mud.config";
+import metadataAbi from "@latticexyz/world-module-metadata/out/IMetadataSystem.sol/IMetadataSystem.abi.json" assert { type: "json" };
+import metadataModule from "@latticexyz/world-module-metadata/out/MetadataModule.sol/MetadataModule.json" assert { type: "json" };
+
+// src/utils/getContractArtifact.ts
+import { isHex, size as size4 } from "viem";
+
+// 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
+        })
+      )
+    )
+  );
+}
+
+// src/utils/getContractArtifact.ts
+import { z } from "zod";
+import { Abi as abiSchema } from "abitype/zod";
+function isBytecode(value) {
+  return isHex(value, { strict: false });
+}
+var bytecodeSchema = z.object({
+  object: z.string().refine(isBytecode),
+  linkReferences: z.record(
+    z.record(
+      z.array(
+        z.object({
+          start: z.number(),
+          length: z.number()
+        })
+      )
+    )
+  ).optional()
+});
+var artifactSchema = z.object({
+  bytecode: bytecodeSchema,
+  deployedBytecode: bytecodeSchema,
+  abi: abiSchema
+});
+function getContractArtifact(artifactJson) {
+  const artifact = artifactSchema.parse(artifactJson);
+  const placeholders = findPlaceholders(artifact.bytecode.linkReferences ?? {});
+  return {
+    abi: artifact.abi,
+    bytecode: artifact.bytecode.object,
+    placeholders,
+    deployedBytecodeSize: size4(artifact.deployedBytecode.object)
+  };
+}
+
+// src/deploy/createPrepareDeploy.ts
+import { spliceHex } from "@latticexyz/common";
+import { getContractAddress as getContractAddress4 } from "@latticexyz/common/internal";
+function createPrepareDeploy(bytecodeWithPlaceholders, placeholders) {
+  return function prepareDeploy(deployerAddress, libraryMap) {
+    let bytecode = bytecodeWithPlaceholders;
+    if (placeholders.length === 0) {
+      return { bytecode, address: getContractAddress4({ 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 = spliceHex(bytecode, placeholder.start, placeholder.length, address);
+    }
+    return {
+      bytecode,
+      address: getContractAddress4({ deployerAddress, bytecode })
+    };
+  };
+}
+
+// src/deploy/ensureResourceTags.ts
+import { getKeyTuple } from "@latticexyz/protocol-parser/internal";
+import { getRecords as getRecords4 } from "@latticexyz/store-sync";
+import { waitForTransactions } from "@latticexyz/common/internal";
+var metadataModuleArtifact = getContractArtifact(metadataModule);
+async function ensureResourceTags({
+  client,
+  deployerAddress,
+  libraryMap,
+  worldDeploy,
+  tags,
+  valueToHex = identity,
+  indexerUrl,
+  chainId
+}) {
+  debug2("ensuring", tags.length, "resource tags");
+  debug2("looking up existing resource tags");
+  const { records } = await getRecords4({
+    table: metadataConfig.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 = concatHex(getKeyTuple(metadataConfig.tables.metadata__ResourceTag, tag));
+      return [key, tag.value];
+    })
+  );
+  const desiredTags = tags.map(
+    (tag) => ({
+      resource: tag.resourceId,
+      tag: stringToHex(tag.tag, { size: 32 }),
+      value: valueToHex(tag.value)
+    })
+  );
+  const pendingTags = desiredTags.filter((tag) => {
+    const key = concatHex(getKeyTuple(metadataConfig.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 waitForTransactions({
+    client,
+    hashes: moduleTxs,
+    debugLabel: "metadata module installation"
+  });
+  debug2("setting", pendingTags.length, "resource tags");
+  return (await Promise.all(
+    pendingTags.map(async (tag) => {
+      const resource = hexToResource5(tag.resource);
+      const resourceString = `${resource.type}:${resource.namespace}:${resource.name}`;
+      debug2(`tagging ${resourceString} with ${tag.tag}: ${JSON.stringify(tag.value)}`);
+      try {
+        return await writeContract7(client, {
+          chain: client.chain ?? null,
+          address: worldDeploy.address,
+          abi: metadataAbi,
+          // 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 BaseError2 ? error4.shortMessage : error4}`
+        );
+      }
+    })
+  )).filter(isDefined4);
+}
+
+// src/deploy/deployCustomWorld.ts
+import { concatHex as concatHex2, encodeDeployData as encodeDeployData4, isHex as isHex2 } from "viem";
+import { waitForTransactionReceipt as waitForTransactionReceipt2 } from "viem/actions";
+import { resourceToHex as resourceToHex2, sendTransaction, writeContract as writeContract8 } from "@latticexyz/common";
+import { ensureContractsDeployed as ensureContractsDeployed4, getContractAddress as getContractAddress5, waitForTransactions as waitForTransactions2 } from "@latticexyz/common/internal";
+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) => !isHex2(part)).flatMap((ref) => {
+    return getDependencies(findArtifact(ref, artifacts), artifacts);
+  });
+}
+function getDeployable(deployerAddress, artifact, artifacts) {
+  return concatHex2(
+    artifact.bytecode.map((ref) => {
+      if (isHex2(ref)) return ref;
+      return getContractAddress5({
+        deployerAddress,
+        bytecode: getDeployable(deployerAddress, findArtifact(ref, artifacts), artifacts)
+      });
+    })
+  );
+}
+async function deployCustomWorld({
+  client,
+  deployerAddress,
+  artifacts,
+  customWorld
+}) {
+  const contracts = getWorldContracts(deployerAddress);
+  await ensureContractsDeployed4({
+    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 ensureContractsDeployed4({
+      client,
+      deployerAddress,
+      contracts: deps.map((dep) => getDeployable(deployerAddress, dep, artifacts)).reverse().map((bytecode) => ({ bytecode }))
+    });
+  }
+  debug2("deploying custom world");
+  const deployTx = await sendTransaction(client, {
+    chain: client.chain ?? null,
+    data: encodeDeployData4({
+      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 waitForTransactionReceipt2(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 writeContract8(client, {
+    chain: client.chain ?? null,
+    address: deploy2.address,
+    abi: worldAbi,
+    functionName: "initialize",
+    args: [contracts.InitModule.address]
+  });
+  await waitForTransactions2({ client, hashes: [initTx], debugLabel: "world init" });
+  const transferOwnershipTx = await writeContract8(client, {
+    chain: client.chain ?? null,
+    address: deploy2.address,
+    abi: worldAbi,
+    functionName: "transferOwnership",
+    args: [resourceToHex2({ type: "namespace", namespace: "", name: "" }), client.account.address]
+  });
+  await waitForTransactions2({ client, hashes: [transferOwnershipTx], debugLabel: "world ownership transfer" });
+  return { ...deploy2, stateBlock: deploy2.deployBlock };
+}
+
+// src/deploy/deploy.ts
+import { uniqueBy } from "@latticexyz/common/utils";
+
+// 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;
+}
+
+// src/deploy/deploy.ts
+import { ensureContractsDeployed as ensureContractsDeployed5, ensureDeployer, waitForTransactions as waitForTransactions3 } from "@latticexyz/common/internal";
+async function deploy({
+  config,
+  client,
+  tables,
+  systems,
+  libraries,
+  modules = [],
+  artifacts,
+  salt,
+  worldAddress: existingWorldAddress,
+  worldDeployBlock,
+  deployerAddress: initialDeployerAddress,
+  indexerUrl,
+  chainId
+}) {
+  const deployerAddress = initialDeployerAddress ?? await ensureDeployer(client);
+  const worldDeploy = existingWorldAddress ? await getWorldDeploy(client, existingWorldAddress, worldDeployBlock) : config.deploy.customWorld ? await deployCustomWorld({
+    client,
+    deployerAddress,
+    artifacts,
+    customWorld: config.deploy.customWorld
+  }) : await deployWorld(
+    client,
+    deployerAddress,
+    salt ?? `0x${randomBytes(32).toString("hex")}`,
+    config.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 ensureContractsDeployed5({
+    ...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: `${resourceToLabel4(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 waitForTransactions3({ client, hashes: namespaceTxs, debugLabel: "namespace registrations" });
+  const tableTxs = await ensureTables({
+    ...commonDeployOptions,
+    tables
+  });
+  const systemTxs = await ensureSystems({
+    ...commonDeployOptions,
+    deployerAddress,
+    libraryMap,
+    systems
+  });
+  await waitForTransactions3({
+    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 = uniqueBy(
+    [...tables, ...systems].filter(({ namespace, namespaceLabel }) => namespaceLabel !== namespace).map(({ namespace, namespaceLabel }) => ({
+      resourceId: resourceToHex3({ 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: stringToHex2
+  });
+  await waitForTransactions3({
+    client,
+    hashes: [...functionTxs, ...moduleTxs, ...tagTxs],
+    debugLabel: "remaining transactions"
+  });
+  debug2("deploy complete");
+  return worldDeploy;
+}
+
+// src/runDeploy.ts
+import { createWalletClient, http, isHex as isHex4, stringToHex as stringToHex3 } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { loadConfig as loadConfig3, resolveConfigPath as resolveConfigPath3 } from "@latticexyz/config/node";
+import { getOutDirectory, getRpcUrl } from "@latticexyz/common/foundry";
+import chalk2 from "chalk";
+import { MUDError as MUDError2 } from "@latticexyz/common/errors";
+
+// src/deploy/resolveConfig.ts
+import path5 from "path";
+import { loadSystemsManifest, resolveSystems } from "@latticexyz/world/node";
+import { isHex as isHex3, toFunctionSelector, toFunctionSignature } from "viem";
+
+// src/utils/getContractData.ts
+import { readFileSync } from "fs";
+import path4 from "path";
+import { MUDError } from "@latticexyz/common/errors";
+import { size as size5 } from "viem";
+function getContractData(filename, contractName, forgeOutDirectory) {
+  let data;
+  const contractDataPath = path4.join(forgeOutDirectory, filename, contractName + ".json");
+  try {
+    data = JSON.parse(readFileSync(contractDataPath, "utf8"));
+  } catch (error4) {
+    throw new MUDError(`Error reading file at ${contractDataPath}`);
+  }
+  const bytecode = data?.bytecode?.object;
+  if (!bytecode) throw new MUDError(`No bytecode found in ${contractDataPath}`);
+  const deployedBytecode = data?.deployedBytecode?.object;
+  if (!deployedBytecode) throw new MUDError(`No deployed bytecode found in ${contractDataPath}`);
+  const abi = data?.abi;
+  if (!abi) throw new MUDError(`No ABI found in ${contractDataPath}`);
+  const placeholders = findPlaceholders(data?.bytecode?.linkReferences ?? {});
+  return { abi, bytecode, placeholders, deployedBytecodeSize: size5(deployedBytecode) };
+}
+
+// src/deploy/resolveConfig.ts
+import { groupBy } from "@latticexyz/common/utils";
+
+// src/deploy/findLibraries.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { globSync } from "glob";
+
+// src/deploy/orderByDependencies.ts
+import toposort from "toposort";
+function orderByDependencies(items, itemKey, dependencyKeys) {
+  const dependencyOrder = toposort(
+    items.flatMap((item) => dependencyKeys(item).map((dependency) => [itemKey(item), dependency]))
+  );
+  return [...items].sort((a, b) => dependencyOrder.indexOf(itemKey(a)) - dependencyOrder.indexOf(itemKey(b)));
+}
+
+// src/deploy/findLibraries.ts
+function findLibraries(forgeOutDir) {
+  const artifacts = globSync(`${forgeOutDir}/**/*.json`, { ignore: "**/*.abi.json" }).sort().map((path16) => JSON.parse(readFileSync2(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}`]
+  );
+}
+
+// src/deploy/resolveConfig.ts
+import { findUp } from "find-up";
+import { createRequire } from "node:module";
+
+// 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;
+}
+
+// src/deploy/resolveConfig.ts
+async function resolveConfig({
+  rootDir,
+  config,
+  forgeOutDir
+}) {
+  const requirePath = await findUp("package.json");
+  if (!requirePath) throw new Error("Could not find package.json to import relative to.");
+  const require2 = createRequire(requirePath);
+  const moduleOutDirs = config.modules.filter(excludeCallWithSignatureModule).flatMap((mod) => {
+    if (mod.artifactPath == void 0) {
+      return [];
+    }
+    const moduleOutDir = path5.join(require2.resolve(mod.artifactPath), "../../");
+    return [moduleOutDir];
+  });
+  const libraries = [forgeOutDir, ...moduleOutDirs].flatMap(
+    (outDir) => findLibraries(outDir).map((library) => {
+      const contractData = getContractData(path5.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(toFunctionSignature);
+  const configSystems = await resolveSystems({ rootDir, config });
+  const systemsManifest = await loadSystemsManifest({ rootDir, config });
+  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(toFunctionSignature).filter((sig) => !baseSystemFunctions.includes(sig)).map((sig) => {
+      const worldSignature = system.namespace === "" ? sig : `${system.namespace}__${sig}`;
+      return {
+        signature: worldSignature,
+        selector: toFunctionSelector(worldSignature),
+        systemId: system.systemId,
+        systemFunctionSignature: sig,
+        systemFunctionSelector: toFunctionSelector(sig)
+      };
+    }) : [];
+    const allowedAddresses = system.accessList.filter((target) => isHex3(target));
+    const allowedSystemIds = system.accessList.filter((target) => !isHex3(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 = 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
+  };
+}
+
+// src/runDeploy.ts
+import { getChainId } from "viem/actions";
+
+// src/utils/postDeploy.ts
+import { existsSync } from "fs";
+import path6 from "path";
+import chalk from "chalk";
+import { getScriptDirectory, forge as forge2 } from "@latticexyz/common/foundry";
+async function postDeploy(postDeployScript, worldAddress, rpc, profile, forgeOptions, kms) {
+  const userOptions = forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
+  const postDeployPath = path6.join(await getScriptDirectory(), postDeployScript + ".s.sol");
+  if (!existsSync(postDeployPath)) {
+    console.log(`No script at ${postDeployPath}, skipping post deploy hook`);
+    return;
+  }
+  console.log(chalk.blue(`Executing post deploy script at ${postDeployPath}`));
+  await forge2(
+    [
+      "script",
+      postDeployScript,
+      "--broadcast",
+      "--sig",
+      "run(address)",
+      worldAddress,
+      "--rpc-url",
+      rpc,
+      "-vvv",
+      kms ? "--aws" : "",
+      ...userOptions
+    ],
+    {
+      profile
+    }
+  );
+}
+
+// src/runDeploy.ts
+import { kmsKeyToAccount } from "@latticexyz/common/kms";
+
+// src/deploy/configToModules.ts
+import path7 from "node:path";
+import { encodeField } from "@latticexyz/protocol-parser/internal";
+import { bytesToHex } from "viem";
+
+// src/utils/importContractArtifact.ts
+import { createRequire as createRequire2 } from "node:module";
+import { findUp as findUp2 } from "find-up";
+async function importContractArtifact({
+  packageJsonPath,
+  artifactPath
+}) {
+  let artfactJson;
+  try {
+    const requirePath = packageJsonPath ?? await findUp2("package.json", { cwd: process.cwd() });
+    if (!requirePath) throw new Error("Could not find package.json to import relative to.");
+    const require2 = createRequire2(requirePath);
+    artfactJson = require2(artifactPath);
+  } catch (error4) {
+    console.error();
+    console.error("Could not import contract artifact at", artifactPath);
+    console.error();
+    throw error4;
+  }
+  return getContractArtifact(artfactJson);
+}
+
+// src/deploy/configToModules.ts
+import { resolveWithContext } from "@latticexyz/world/internal";
+import callWithSignatureModule from "@latticexyz/world-module-callwithsignature/out/CallWithSignatureModule.sol/CallWithSignatureModule.json" assert { type: "json" };
+var callWithSignatureModuleArtifact = getContractArtifact(callWithSignatureModule);
+var 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"
+};
+async function configToModules(config, 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(
+    config.modules.filter(excludeCallWithSignatureModule).map(async (mod) => {
+      let artifactPath = mod.artifactPath;
+      if (!artifactPath) {
+        if (mod.name) {
+          artifactPath = knownModuleArtifacts[mod.name] ?? path7.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 = path7.basename(artifactPath, ".json");
+      const artifact = await importContractArtifact({ artifactPath });
+      const installArgs = mod.args.map((arg) => resolveWithContext(arg, { config })).map((arg) => {
+        const value = arg.value instanceof Uint8Array ? bytesToHex(arg.value) : arg.value;
+        return 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];
+}
+
+// src/runDeploy.ts
+import { findContractArtifacts } from "@latticexyz/world/node";
+
+// src/utils/enableAutomine.ts
+import { getAutomine, getBlock as getBlock2, setAutomine, setIntervalMining } from "viem/actions";
+import { getAction } from "viem/utils";
+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 getAction(localClient, 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 getAction(client, setAutomine, "setAutomine")(true);
+  } else {
+    await getAction(client, setIntervalMining, "setIntervalMining")({ interval: miningMode.blockTime });
+  }
+}
+async function getBlockTime(client) {
+  const latestBlock = await getAction(client, getBlock2, "getBlock")({ blockTag: "latest" });
+  const previousBlock = await getAction(client, getBlock2, "getBlock")({ blockNumber: latestBlock.number - 1n });
+  const blockTime = latestBlock.timestamp - previousBlock.timestamp;
+  return Number(blockTime);
+}
+
+// src/defaultChains.ts
+import { redstone, garnet, rhodolite } from "@latticexyz/common/chains";
+var defaultChains = [redstone, garnet, rhodolite];
+
+// src/runDeploy.ts
+var 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
+  }
+};
+async function runDeploy(opts) {
+  const salt = opts.salt != null ? isHex4(opts.salt) ? opts.salt : stringToHex3(opts.salt) : void 0;
+  const profile = opts.profile;
+  const configPath = await resolveConfigPath3(opts.configPath);
+  const config = await loadConfig3(configPath);
+  const rootDir = path8.dirname(configPath);
+  console.log(chalk2.green(`
+Using ${package_default.name}@${package_default.version}`));
+  if (opts.printConfig) {
+    console.log(chalk2.green("\nResolved config:\n"), JSON.stringify(config, null, 2));
+  }
+  const outDir = await getOutDirectory(profile);
+  const rpc = opts.rpc ?? await getRpcUrl(profile);
+  console.log(
+    chalk2.bgBlue(
+      chalk2.whiteBright(`
+ Deploying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} 
+`)
+    )
+  );
+  if (!opts.skipBuild) {
+    await build({ rootDir, config, foundryProfile: profile });
+  }
+  const { systems, libraries } = await resolveConfig({
+    rootDir,
+    config,
+    forgeOutDir: outDir
+  });
+  const artifacts = await findContractArtifacts({ forgeOutDir: outDir });
+  const modules = await configToModules(config, outDir);
+  const tables = Object.values(config.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 MUDError2(
+          "Missing `AWS_KMS_KEY_ID` environment variable. This is required when using with `--kms` option."
+        );
+      }
+      return await kmsKeyToAccount({ keyId });
+    } else {
+      const privateKey = process.env.PRIVATE_KEY;
+      if (!privateKey) {
+        throw new MUDError2(
+          `Missing PRIVATE_KEY environment variable.
+  Run 'echo "PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" > .env'
+  in your contracts directory to use the default anvil private key.`
+        );
+      }
+      return privateKeyToAccount(privateKey);
+    }
+  })();
+  const client = createWalletClient({
+    transport: http(rpc, {
+      batch: opts.rpcBatch ? {
+        batchSize: 100,
+        wait: 1e3
+      } : void 0
+    }),
+    account
+  });
+  const chainId = await getChainId(client);
+  const indexerUrl = opts.indexerUrl ?? defaultChains.find((chain) => chain.id === chainId)?.indexerUrl;
+  const worldDeployBlock = opts.worldAddress ? getWorldDeployBlock({
+    worldAddress: opts.worldAddress,
+    worldsFile: config.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,
+    deployerAddress: opts.deployerAddress,
+    salt,
+    worldAddress: opts.worldAddress,
+    worldDeployBlock,
+    client,
+    tables,
+    systems,
+    libraries,
+    modules,
+    artifacts,
+    indexerUrl,
+    chainId
+  });
+  if (opts.worldAddress == null || opts.alwaysRunPostDeploy) {
+    await postDeploy(
+      config.deploy.postDeployScript,
+      worldDeploy.address,
+      rpc,
+      profile,
+      opts.forgeScriptOptions,
+      opts.kms ? true : false
+    );
+  }
+  await automine?.reset();
+  console.log(chalk2.green("Deployment completed in", (Date.now() - startTime) / 1e3, "seconds"));
+  const deploymentInfo = {
+    worldAddress: worldDeploy.address,
+    blockNumber: Number(worldDeploy.deployBlock)
+  };
+  if (opts.saveDeployment) {
+    const deploysDir = path8.join(config.deploy.deploysDirectory, chainId.toString());
+    mkdirSync(deploysDir, { recursive: true });
+    writeFileSync(path8.join(deploysDir, "latest.json"), JSON.stringify(deploymentInfo, null, 2) + "\n");
+    writeFileSync(path8.join(deploysDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2) + "\n");
+    const localChains = [1337, 31337];
+    const deploys2 = existsSync2(config.deploy.worldsFile) ? JSON.parse(readFileSync3(config.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
+    };
+    writeFileSync(config.deploy.worldsFile, JSON.stringify(deploys2, null, 2) + "\n");
+    console.log(
+      chalk2.bgGreen(
+        chalk2.whiteBright(`
+ Deployment result (written to ${config.deploy.worldsFile} and ${deploysDir}): 
+`)
+      )
+    );
+  }
+  console.log(deploymentInfo);
+  return worldDeploy;
+}
+function getWorldDeployBlock({
+  chainId,
+  worldAddress,
+  worldsFile
+}) {
+  const deploys2 = existsSync2(worldsFile) ? JSON.parse(readFileSync3(worldsFile, "utf-8")) : {};
+  const worldDeployBlock = deploys2[chainId]?.address === worldAddress ? deploys2[chainId].blockNumber : void 0;
+  return worldDeployBlock ? BigInt(worldDeployBlock) : void 0;
+}
+
+// src/commands/deploy.ts
+var 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);
+  }
+};
+var deploy_default = commandModule5;
+
+// src/commands/worldgen.ts
+import path9 from "node:path";
+import { loadConfig as loadConfig4, resolveConfigPath as resolveConfigPath4 } from "@latticexyz/config/node";
+import { worldgen as worldgen2 } from "@latticexyz/world/node";
+var 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);
+  }
+};
+async function worldgenHandler(args) {
+  const configPath = await resolveConfigPath4(args.configPath);
+  const config = await loadConfig4(configPath);
+  const rootDir = path9.dirname(configPath);
+  await worldgen2({ rootDir, config, clean: args.clean });
+}
+var worldgen_default = commandModule6;
+
+// src/commands/set-version.ts
+import chalk3 from "chalk";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import path10 from "path";
+import { MUDError as MUDError3 } from "@latticexyz/common/errors";
+import { globSync as globSync2 } from "glob";
+
+// src/mudPackages.ts
+import { ZodError, z as z2 } from "zod";
+var envSchema = z2.object({
+  MUD_PACKAGES: z2.string().transform((value) => JSON.parse(value))
+});
+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 ZodError) {
+      const { ...invalidEnvVars } = error4.format();
+      console.error(`
+Missing or invalid environment variables:
+
+  ${Object.keys(invalidEnvVars).join("\n  ")}
+`);
+      process.exit(1);
+    }
+    throw error4;
+  }
+}
+var mudPackages = parseEnv().MUD_PACKAGES;
+
+// src/commands/set-version.ts
+var 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 MUDError3(`You need to provide one these options: ${mutuallyExclusiveOptions.join(", ")}`);
+      }
+      if (numMutuallyExclusiveOptions > 1) {
+        throw new MUDError3(`These options are mutually exclusive: ${mutuallyExclusiveOptions.join(", ")}`);
+      }
+      if (!options2.link) {
+        options2.mudVersion = await resolveVersion(options2);
+      }
+      const packageJsons = globSync2("**/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);
+    }
+  }
+};
+async function resolveVersion(options2) {
+  if (options2.mudVersion === "canary") options2.tag = "main";
+  let npmResult;
+  try {
+    console.log(chalk3.blue(`Fetching available versions`));
+    npmResult = await (await fetch(`https://registry.npmjs.org/${package_default.name}`)).json();
+  } catch (e) {
+    throw new MUDError3(`Could not fetch available MUD versions`);
+  }
+  if (options2.tag) {
+    const version = npmResult["dist-tags"][options2.tag];
+    if (!version) {
+      throw new MUDError3(`Could not find npm version with tag "${options2.tag}"`);
+    }
+    console.log(chalk3.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 MUDError3(`Could not find npm version based on commit "${options2.commit}"`);
+    }
+    console.log(chalk3.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");
+    }
+  }
+  writeFileSync2(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 = readFileSync4(path16, "utf8");
+    return JSON.parse(jsonString);
+  } catch {
+    throw new MUDError3("Could not read JSON at " + path16);
+  }
+}
+function logComparison(prev, curr) {
+  for (const key in prev) {
+    if (prev[key] !== curr[key]) {
+      console.log(`${key}: ${chalk3.red(prev[key])} -> ${chalk3.green(curr[key])}`);
+    }
+  }
+}
+function resolveLinkPath(packageJsonPath, mudLinkPath, packageName) {
+  const packageJsonToRootPath = path10.relative(path10.dirname(packageJsonPath), process.cwd());
+  const linkPath = path10.join(packageJsonToRootPath, mudLinkPath, mudPackages[packageName].localPath);
+  return "link:" + linkPath;
+}
+var set_version_default = commandModule7;
+
+// src/commands/test.ts
+import { anvil, forge as forge3, getRpcUrl as getRpcUrl2 } from "@latticexyz/common/foundry";
+import chalk4 from "chalk";
+var 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" }
+};
+var 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)];
+      anvil(anvilArgs);
+    }
+    const forkRpc = opts.worldAddress ? await getRpcUrl2(opts.profile) : `http://127.0.0.1:${opts.port}`;
+    const worldAddress = opts.worldAddress ?? (await runDeploy({
+      ...opts,
+      saveDeployment: false,
+      rpc: forkRpc
+    })).address;
+    console.log(chalk4.blue("World address", worldAddress));
+    const userOptions = opts.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
+    try {
+      await forge3(["test", "--fork-url", forkRpc, ...userOptions], {
+        profile: opts.profile,
+        env: {
+          WORLD_ADDRESS: worldAddress
+        }
+      });
+      process.exit(0);
+    } catch (e) {
+      console.error(e);
+      process.exit(1);
+    }
+  }
+};
+var test_default = commandModule8;
+
+// src/commands/trace.ts
+import path11 from "node:path";
+import fs from "node:fs";
+import { loadConfig as loadConfig5, resolveConfigPath as resolveConfigPath5 } from "@latticexyz/config/node";
+import { MUDError as MUDError4 } from "@latticexyz/common/errors";
+import { cast, getRpcUrl as getRpcUrl3 } from "@latticexyz/common/foundry";
+import worldConfig4 from "@latticexyz/world/mud.config";
+import { createClient, http as http2 } from "viem";
+import { getChainId as getChainId2, readContract as readContract2 } from "viem/actions";
+import { resolveSystems as resolveSystems2 } from "@latticexyz/world/node";
+var systemsTableId = worldConfig4.namespaces.world.tables.Systems.tableId;
+function getWorldAddress(worldsFile, chainId) {
+  if (!fs.existsSync(worldsFile)) {
+    throw new MUDError4(`Missing expected worlds.json file at "${worldsFile}"`);
+  }
+  const deploys2 = JSON.parse(fs.readFileSync(worldsFile, "utf-8"));
+  if (!deploys2[chainId]) {
+    throw new MUDError4(`Missing chain ID ${chainId} in "${worldsFile}"`);
+  }
+  return deploys2[chainId].address;
+}
+var 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 resolveConfigPath5(args.configPath);
+    const rootDir = path11.dirname(configPath);
+    const profile = args.profile;
+    const rpc = args.rpc ?? await getRpcUrl3(profile);
+    const config = await loadConfig5(configPath);
+    const client = createClient({ transport: http2(rpc) });
+    const chainId = await getChainId2(client);
+    const worldAddress = args.worldAddress ?? getWorldAddress(config.deploy.worldsFile, chainId);
+    const systems = await resolveSystems2({ rootDir, config });
+    const labels = await Promise.all(
+      systems.map(async (system) => ({
+        label: system.label,
+        address: await readContract2(client, {
+          abi: worldAbi,
+          address: worldAddress,
+          functionName: "getField",
+          args: [systemsTableId, [system.systemId], 0]
+        })
+      }))
+    );
+    const result = await cast([
+      "run",
+      "--label",
+      `${worldAddress}:World`,
+      ...labels.map(({ label, address }) => ["--label", `${address}:${label}`]).flat(),
+      `${args.tx}`
+    ]);
+    console.log(result);
+    process.exit(0);
+  }
+};
+var trace_default = commandModule9;
+
+// src/commands/dev-contracts.ts
+import { anvil as anvil2, getScriptDirectory as getScriptDirectory2, getSrcDirectory } from "@latticexyz/common/foundry";
+import chalk5 from "chalk";
+import chokidar from "chokidar";
+import { loadConfig as loadConfig6, resolveConfigPath as resolveConfigPath6 } from "@latticexyz/config/node";
+import path12 from "path";
+import { homedir as homedir2 } from "os";
+import { rmSync as rmSync2 } from "fs";
+import { BehaviorSubject, debounceTime, exhaustMap, filter } from "rxjs";
+import { isDefined as isDefined5 } from "@latticexyz/common/utils";
+var devOptions = {
+  rpc: deployOptions.rpc,
+  configPath: deployOptions.configPath,
+  alwaysRunPostDeploy: deployOptions.alwaysRunPostDeploy,
+  forgeScriptOptions: deployOptions.forgeScriptOptions,
+  worldAddress: deployOptions.worldAddress
+};
+var 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 resolveConfigPath6(opts.configPath);
+    const srcDir = await getSrcDirectory();
+    const scriptDir = await getScriptDirectory2();
+    const initialConfig = await loadConfig6(configPath);
+    if (!opts.rpc) {
+      console.log(chalk5.gray("Cleaning devnode cache"));
+      const userHomeDir = homedir2();
+      rmSync2(path12.join(userHomeDir, ".foundry", "anvil", "tmp"), { recursive: true, force: true });
+      const anvilArgs = ["--block-time", "1", "--block-base-fee-per-gas", "0"];
+      anvil2(anvilArgs);
+      rpc = "http://127.0.0.1:8545";
+    }
+    const lastChange$ = new BehaviorSubject(Date.now());
+    chokidar.watch([configPath, srcDir, scriptDir], { ignoreInitial: true }).on("all", async (_, updatePath) => {
+      if (updatePath.includes(configPath)) {
+        console.log(chalk5.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(chalk5.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)
+      debounceTime(200),
+      exhaustMap(async (lastChange) => {
+        if (worldAddress) {
+          console.log(chalk5.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(chalk5.gray("\nWaiting for file changes\u2026\n"));
+          }
+          return deploy2;
+        } catch (error4) {
+          console.error(chalk5.bgRed(chalk5.whiteBright("\n Error while attempting deploy \n")));
+          console.error(error4);
+          console.log(chalk5.gray("\nWaiting for file changes\u2026\n"));
+        }
+      }),
+      filter(isDefined5)
+    );
+    deploys$.subscribe();
+  }
+};
+var dev_contracts_default = commandModule10;
+
+// src/verify.ts
+import { sliceHex, zeroHash } from "viem";
+
+// src/verify/verifyContract.ts
+import { forge as forge4 } from "@latticexyz/common/foundry";
+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 forge4(args, { cwd: options2.cwd });
+}
+
+// src/verify.ts
+import PQueue from "p-queue";
+import { MUDError as MUDError5 } from "@latticexyz/common/errors";
+import { getStorageAt } from "viem/actions";
+import { execa as execa3 } from "execa";
+import { getContractAddress as getContractAddress6, getDeployer } from "@latticexyz/common/internal";
+var ERC1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+async function verify({
+  client,
+  rpc,
+  systems,
+  libraries,
+  modules,
+  worldAddress,
+  deployerAddress: initialDeployerAddress,
+  verifier,
+  verifierUrl
+}) {
+  const deployerAddress = initialDeployerAddress ?? await getDeployer(client);
+  if (!deployerAddress) {
+    throw new MUDError5("No deployer address provided or found.");
+  }
+  const implementationStorage = await getStorageAt(client, {
+    address: worldAddress,
+    slot: ERC1967_IMPLEMENTATION_SLOT
+  });
+  const usesProxy = implementationStorage && implementationStorage !== zeroHash;
+  const verifyQueue = new PQueue({ concurrency: 4 });
+  const libraryMap = getLibraryMap(libraries);
+  systems.map(
+    (system) => verifyQueue.add(() => {
+      const address = getContractAddress6({
+        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 execa3("npm", ["install"], {
+      cwd: "node_modules/@latticexyz/store"
+    });
+    await execa3("npm", ["install"], {
+      cwd: "node_modules/@latticexyz/world"
+    });
+    await execa3("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: getContractAddress6({
+            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 = 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("");
+  }
+}
+
+// src/commands/verify.ts
+import { loadConfig as loadConfig7, resolveConfigPath as resolveConfigPath7 } from "@latticexyz/config/node";
+import { getOutDirectory as getOutDirectory2, getRpcUrl as getRpcUrl4 } from "@latticexyz/common/foundry";
+import { createWalletClient as createWalletClient2, http as http3 } from "viem";
+import chalk6 from "chalk";
+import path13 from "node:path";
+var 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."
+  }
+};
+var commandModule11 = {
+  command: "verify",
+  describe: "Verify contracts",
+  builder(yargs) {
+    return yargs.options(verifyOptions);
+  },
+  async handler(opts) {
+    const profile = opts.profile;
+    const configPath = await resolveConfigPath7(opts.configPath);
+    const rootDir = path13.dirname(configPath);
+    const config = await loadConfig7(configPath);
+    const outDir = await getOutDirectory2(profile);
+    const modules = await configToModules(config, outDir);
+    const { systems, libraries } = await resolveConfig({
+      rootDir,
+      config,
+      forgeOutDir: outDir
+    });
+    const rpc = opts.rpc ?? await getRpcUrl4(profile);
+    console.log(
+      chalk6.bgBlue(
+        chalk6.whiteBright(`
+ Verifying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} 
+`)
+      )
+    );
+    const client = createWalletClient2({
+      transport: http3(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
+    });
+  }
+};
+var verify_default = commandModule11;
+
+// src/commands/pull.ts
+import { getRpcUrl as getRpcUrl5 } from "@latticexyz/common/foundry";
+import { createClient as createClient2, http as http4 } from "viem";
+import chalk7 from "chalk";
+
+// src/pull/pull.ts
+import { hexToString as hexToString2, parseAbiItem, stringToHex as stringToHex4 } from "viem";
+import { getSchemaTypes as getSchemaTypes4 } from "@latticexyz/protocol-parser/internal";
+import { hexToResource as hexToResource6, resourceToHex as resourceToHex4 } from "@latticexyz/common";
+import metadataConfig2 from "@latticexyz/world-module-metadata/mud.config";
+
+// src/deploy/getRecord.ts
+import {
+  decodeValueArgs as decodeValueArgs2,
+  getKeyTuple as getKeyTuple2,
+  getSchemaTypes as getSchemaTypes3,
+  getValueSchema as getValueSchema3
+} from "@latticexyz/protocol-parser/internal";
+import { readContract as readContract3 } from "viem/actions";
+import { mapObject } from "@latticexyz/common/utils";
+async function getRecord({
+  client,
+  worldDeploy,
+  table,
+  key
+}) {
+  const [staticData, encodedLengths, dynamicData] = await readContract3(client, {
+    blockNumber: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    abi: worldAbi,
+    functionName: "getRecord",
+    args: [table.tableId, getKeyTuple2(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,
+    ...decodeValueArgs2(getSchemaTypes3(getValueSchema3(table)), {
+      staticData,
+      encodedLengths,
+      dynamicData
+    })
+  };
+  return mapObject(table.schema, (value, key2) => record[key2]);
+}
+
+// src/pull/pull.ts
+import path14 from "node:path";
+import fs2 from "node:fs/promises";
+import { getFunctions as getFunctions3 } from "@latticexyz/store-sync/world";
+import { abiToInterface, formatSolidity, formatTypescript } from "@latticexyz/common/codegen";
+
+// src/pull/debug.ts
+var debug3 = debug.extend("pull");
+var error3 = debug.extend("pull");
+debug3.log = console.debug.bind(console);
+error3.log = console.error.bind(console);
+
+// src/pull/pull.ts
+import { defineWorld } from "@latticexyz/world";
+import { findUp as findUp3 } from "find-up";
+import { isDefined as isDefined6 } from "@latticexyz/common/utils";
+var ignoredNamespaces = /* @__PURE__ */ new Set(["store", "world", "metadata"]);
+function namespaceToHex(namespace) {
+  return resourceToHex4({ type: "namespace", namespace, name: "" });
+}
+var WriteFileExistsError = class extends Error {
+  constructor(filename) {
+    super(`Attempted to write file at "${filename}", but it already exists.`);
+    this.filename = filename;
+    this.name = "WriteFileExistsError";
+  }
+};
+async function pull({ rootDir, client, worldAddress, replace, indexerUrl, chainId }) {
+  const replaceFiles = replace ?? await findUp3(".git", { cwd: rootDir }) != null;
+  const worldDeploy = await getWorldDeploy(client, worldAddress);
+  const resourceIds = await getResourceIds({ client, worldDeploy, indexerUrl, chainId });
+  const resources = resourceIds.map(hexToResource6).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: metadataConfig2.tables.metadata__ResourceTag,
+          key: { resource: resourceId, tag: stringToHex4("label", { size: 32 }) }
+        });
+        const value = hexToString2(bytesValue);
+        return [resourceId, value === "" ? null : value];
+      })
+    )).filter(([, label]) => label != null)
+  );
+  labels[namespaceToHex("")] ??= "root";
+  const worldFunctions = await getFunctions3({
+    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: metadataConfig2.tables.metadata__ResourceTag,
+          key: { resource: systemId, tag: stringToHex4("abi", { size: 32 }) }
+        }).then((record) => hexToString2(record.value)).then((value) => value !== "" ? value.split("\n") : []),
+        getRecord({
+          client,
+          worldDeploy,
+          table: metadataConfig2.tables.metadata__ResourceTag,
+          key: { resource: systemId, tag: stringToHex4("worldAbi", { size: 32 }) }
+        }).then((record) => hexToString2(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 parseAbiItem(sig);
+        } catch {
+          debug3(`Skipping invalid system signature: ${sig}`);
+        }
+      }).filter(isDefined6);
+      const worldAbi3 = (metadataWorldAbi.length ? metadataWorldAbi : functions.map((func) => `function ${func.signature}`)).map((sig) => {
+        try {
+          return parseAbiItem(sig);
+        } catch {
+          debug3(`Skipping invalid world signature: ${sig}`);
+        }
+      }).filter(isDefined6);
+      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: getSchemaTypes4(table.schema),
+                    key: table.key,
+                    deploy: { disabled: true }
+                  }
+                ];
+              })
+            )
+          }
+        ];
+      })
+    )
+  };
+  debug3("validating config");
+  const config = defineWorld(configInput);
+  debug3("writing config");
+  await writeFile(
+    path14.join(rootDir, "mud.config.ts"),
+    await formatTypescript(`
+      import { defineWorld } from "@latticexyz/world";
+
+      export default defineWorld(${JSON.stringify(configInput)});
+    `),
+    { overwrite: replaceFiles }
+  );
+  const remoteDir = path14.join(config.sourceDirectory, "remote");
+  if (replaceFiles) {
+    await fs2.rm(remoteDir, { recursive: true, force: true });
+  }
+  for (const system of systems.filter((system2) => system2.abi.length)) {
+    const interfaceName = `I${system.label}`;
+    const interfaceFile = path14.join(remoteDir, "namespaces", system.namespaceLabel, `${interfaceName}.sol`);
+    debug3("writing system interface", interfaceName, "to", interfaceFile);
+    const source = abiToInterface({ name: interfaceName, systemId: system.systemId, abi: system.abi });
+    await writeFile(path14.join(rootDir, interfaceFile), await formatSolidity(source), { overwrite: replaceFiles });
+  }
+  const worldAbi2 = systems.flatMap((system) => system.worldAbi);
+  if (worldAbi2.length) {
+    const interfaceName = "IWorldSystems";
+    const interfaceFile = path14.join(remoteDir, `${interfaceName}.sol`);
+    debug3("writing world systems interface to", interfaceFile);
+    const source = abiToInterface({ name: interfaceName, abi: worldAbi2 });
+    await writeFile(path14.join(rootDir, interfaceFile), await formatSolidity(source), { overwrite: replaceFiles });
+  }
+  return { config };
+}
+async function exists(filename) {
+  return fs2.access(filename).then(
+    () => true,
+    () => false
+  );
+}
+async function writeFile(filename, contents, opts = {}) {
+  if (!opts.overwrite && await exists(filename)) {
+    throw new WriteFileExistsError(filename);
+  }
+  await fs2.mkdir(path14.dirname(filename), { recursive: true });
+  await fs2.writeFile(filename, contents);
+}
+
+// src/commands/pull.ts
+import path15 from "node:path";
+import { getChainId as getChainId3 } from "viem/actions";
+var 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
+  }
+};
+var 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 getRpcUrl5(profile);
+    const client = createClient2({
+      transport: http4(rpc, {
+        batch: opts.rpcBatch ? {
+          batchSize: 100,
+          wait: 1e3
+        } : void 0
+      })
+    });
+    const chainId = await getChainId3(client);
+    const indexerUrl = opts.indexerUrl ?? defaultChains.find((chain) => chain.id === chainId)?.indexerUrl;
+    console.log(chalk7.bgBlue(chalk7.whiteBright(`
+ Pulling MUD config from world at ${opts.worldAddress} 
+`)));
+    const rootDir = process.cwd();
+    try {
+      const { config } = await pull({
+        rootDir,
+        client,
+        worldAddress: opts.worldAddress,
+        indexerUrl,
+        chainId,
+        replace: opts.replace
+      });
+      await build({ rootDir, config, foundryProfile: profile });
+    } catch (error4) {
+      if (error4 instanceof WriteFileExistsError) {
+        console.log();
+        console.log(chalk7.bgRed(chalk7.whiteBright(" Error ")));
+        console.log(`  Attempted to write file at "${path15.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;
+    }
+  }
+};
+var pull_default = commandModule12;
+
+// src/commands/index.ts
+var commands = [
+  build_default,
+  deploy_default,
+  devnode_default,
+  gasReport,
+  hello_default,
+  tablegen_default,
+  worldgen_default,
+  set_version_default,
+  test_default,
+  trace_default,
+  dev_contracts_default,
+  abiTs,
+  verify_default,
+  pull_default
+];
+export {
+  commands
+};
+//# sourceMappingURL=commands-HW6E5GIK.js.map