@latticexyz/cli 2.0.0-next.11 → 2.0.0-next.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latticexyz/cli",
-  "version": "2.0.0-next.11",
+  "version": "2.0.0-next.12",
   "description": "Command line interface for mud",
   "repository": {
     "type": "git",
@@ -23,6 +23,7 @@
     "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
     "chalk": "^5.0.1",
     "chokidar": "^3.5.3",
+    "debug": "^4.3.4",
     "dotenv": "^16.0.3",
     "ejs": "^3.1.8",
     "ethers": "^5.7.2",
@@ -30,26 +31,29 @@
     "glob": "^8.0.3",
     "nice-grpc-web": "^2.0.1",
     "openurl": "^1.1.1",
+    "p-retry": "^5.1.2",
     "path": "^0.12.7",
+    "rxjs": "7.5.5",
     "throttle-debounce": "^5.0.0",
     "typescript": "5.1.6",
     "viem": "1.14.0",
     "yargs": "^17.7.1",
     "zod": "^3.21.4",
     "zod-validation-error": "^1.3.0",
-    "@latticexyz/abi-ts": "2.0.0-next.11",
-    "@latticexyz/common": "2.0.0-next.11",
-    "@latticexyz/config": "2.0.0-next.11",
-    "@latticexyz/gas-report": "2.0.0-next.11",
-    "@latticexyz/protocol-parser": "2.0.0-next.11",
-    "@latticexyz/schema-type": "2.0.0-next.11",
-    "@latticexyz/services": "2.0.0-next.11",
-    "@latticexyz/store": "2.0.0-next.11",
-    "@latticexyz/utils": "2.0.0-next.11",
-    "@latticexyz/world": "2.0.0-next.11",
-    "@latticexyz/world-modules": "2.0.0-next.11"
+    "@latticexyz/abi-ts": "2.0.0-next.12",
+    "@latticexyz/common": "2.0.0-next.12",
+    "@latticexyz/config": "2.0.0-next.12",
+    "@latticexyz/gas-report": "2.0.0-next.12",
+    "@latticexyz/protocol-parser": "2.0.0-next.12",
+    "@latticexyz/schema-type": "2.0.0-next.12",
+    "@latticexyz/services": "2.0.0-next.12",
+    "@latticexyz/store": "2.0.0-next.12",
+    "@latticexyz/utils": "2.0.0-next.12",
+    "@latticexyz/world": "2.0.0-next.12",
+    "@latticexyz/world-modules": "2.0.0-next.12"
   },
   "devDependencies": {
+    "@types/debug": "^4.1.7",
     "@types/ejs": "^3.1.1",
     "@types/glob": "^7.2.0",
     "@types/node": "^18.15.11",

package/src/commands/deploy.ts

@@ -1,43 +1,20 @@
-import type { CommandModule, Options } from "yargs";
+import type { CommandModule } from "yargs";
 import { logError } from "../utils/errors";
-import { DeployOptions, deployHandler } from "../utils/deployHandler";
+import { DeployOptions, deployOptions, runDeploy } from "../runDeploy";
 
-export const yDeployOptions = {
-  configPath: { type: "string", desc: "Path to the config file" },
-  clean: { type: "boolean", desc: "Remove the build forge artifacts and cache directories before building" },
-  printConfig: { type: "boolean", desc: "Print the resolved config" },
-  profile: { type: "string", desc: "The foundry profile to use" },
-  debug: { type: "boolean", desc: "Print debug logs, like full error messages" },
-  priorityFeeMultiplier: {
-    type: "number",
-    desc: "Multiply the estimated priority fee by the provided factor",
-    default: 1,
-  },
-  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" },
-  worldAddress: { type: "string", desc: "Deploy to an existing World at the given address" },
-  srcDir: { type: "string", desc: "Source directory. Defaults to foundry src directory." },
-  disableTxWait: { type: "boolean", desc: "Disable waiting for transactions to be confirmed.", default: false },
-  pollInterval: {
-    type: "number",
-    desc: "Interval in miliseconds to use to poll for transaction receipts / block inclusion",
-    default: 1000,
-  },
-  skipBuild: { type: "boolean", desc: "Skip rebuilding the contracts before deploying" },
-} satisfies Record<keyof DeployOptions, Options>;
-
-const commandModule: CommandModule<DeployOptions, DeployOptions> = {
+const commandModule: CommandModule<typeof deployOptions, DeployOptions> = {
   command: "deploy",
 
   describe: "Deploy MUD contracts",
 
   builder(yargs) {
-    return yargs.options(yDeployOptions);
+    return yargs.options(deployOptions);
   },
 
-  async handler(args) {
+  async handler(opts) {
+    // Wrap in try/catch, because yargs seems to swallow errors
     try {
-      await deployHandler(args);
+      await runDeploy(opts);
     } catch (error: any) {
       logError(error);
       process.exit(1);

package/src/commands/dev-contracts.ts

@@ -1,176 +1,112 @@
-import type { CommandModule } from "yargs";
-import {
-  anvil,
-  forge,
-  getRemappings,
-  getRpcUrl,
-  getScriptDirectory,
-  getSrcDirectory,
-} from "@latticexyz/common/foundry";
+import type { CommandModule, InferredOptionTypes } from "yargs";
+import { anvil, getScriptDirectory, getSrcDirectory } from "@latticexyz/common/foundry";
 import chalk from "chalk";
 import chokidar from "chokidar";
 import { loadConfig, resolveConfigPath } from "@latticexyz/config/node";
 import { StoreConfig } from "@latticexyz/store";
-import { tablegen } from "@latticexyz/store/codegen";
 import path from "path";
-import { debounce } from "throttle-debounce";
-import { worldgenHandler } from "./worldgen";
 import { WorldConfig } from "@latticexyz/world";
 import { homedir } from "os";
 import { rmSync } from "fs";
-import { execa } from "execa";
-import { logError } from "../utils/errors";
-import { deployHandler } from "../utils/deployHandler";
-import { printMUD } from "../utils/printMUD";
-
-type Options = {
-  rpc?: string;
-  configPath?: string;
+import { deployOptions, runDeploy } from "../runDeploy";
+import { BehaviorSubject, debounceTime, exhaustMap, filter } from "rxjs";
+import { Address } from "viem";
+import { isDefined } from "@latticexyz/common/utils";
+
+const devOptions = {
+  rpc: deployOptions.rpc,
+  configPath: deployOptions.configPath,
+  alwaysRunPostDeploy: deployOptions.alwaysRunPostDeploy,
 };
 
-const commandModule: CommandModule<Options, Options> = {
+const commandModule: CommandModule<typeof devOptions, InferredOptionTypes<typeof devOptions>> = {
   command: "dev-contracts",
 
   describe: "Start a development server for MUD contracts",
 
   builder(yargs) {
-    return yargs.options({
-      rpc: {
-        type: "string",
-        decs: "RPC endpoint of the development node. If none is provided, an anvil instance is spawned in the background on port 8545.",
-      },
-      configPath: {
-        type: "string",
-        decs: "Path to MUD config",
-      },
-    });
+    return yargs.options(devOptions);
   },
 
-  async handler(args) {
-    // Initial cleanup
-    await forge(["clean"]);
-
-    const rpc = args.rpc ?? (await getRpcUrl());
-    const configPath = args.configPath ?? (await resolveConfigPath(args.configPath));
-    const srcDirectory = await getSrcDirectory();
-    const scriptDirectory = await getScriptDirectory();
-    const remappings = await getRemappings();
+  async handler(opts) {
+    let rpc = opts.rpc;
+    const configPath = opts.configPath ?? (await resolveConfigPath(opts.configPath));
+    const srcDir = await getSrcDirectory();
+    const scriptDir = await getScriptDirectory();
     const initialConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
 
-    // Initial run of all codegen steps before starting anvil
-    // (so clients can wait for everything to be ready before starting)
-    await handleConfigChange(initialConfig);
-    await handleContractsChange(initialConfig);
-
     // Start an anvil instance in the background if no RPC url is provided
-    if (!args.rpc) {
+    if (!opts.rpc) {
+      // Clean anvil cache as 1s block times can fill up the disk
+      // - https://github.com/foundry-rs/foundry/issues/3623
+      // - https://github.com/foundry-rs/foundry/issues/4989
+      // - https://github.com/foundry-rs/foundry/issues/3699
+      // - https://github.com/foundry-rs/foundry/issues/3512
       console.log(chalk.gray("Cleaning devnode cache"));
       const userHomeDir = homedir();
       rmSync(path.join(userHomeDir, ".foundry", "anvil", "tmp"), { recursive: true, force: true });
 
       const anvilArgs = ["--block-time", "1", "--block-base-fee-per-gas", "0"];
       anvil(anvilArgs);
+      rpc = "http://127.0.0.1:8545";
     }
 
-    const changedSinceLastHandled = {
-      config: false,
-      contracts: false,
-    };
-
-    const changeInProgress = {
-      current: false,
-    };
-
     // Watch for changes
-    const configWatcher = chokidar.watch([configPath, srcDirectory]);
-    configWatcher.on("all", async (_, updatePath) => {
+    const lastChange$ = new BehaviorSubject<number>(Date.now());
+    chokidar.watch([configPath, srcDir, scriptDir], { ignoreInitial: true }).on("all", async (_, updatePath) => {
       if (updatePath.includes(configPath)) {
-        changedSinceLastHandled.config = true;
-        // We trigger contract changes if the config changed here instead of
-        // listening to changes in the codegen directory to avoid an infinite loop
-        changedSinceLastHandled.contracts = true;
+        console.log(chalk.blue("Config changed, queuing deploy…"));
+        lastChange$.next(Date.now());
       }
-
-      if (updatePath.includes(srcDirectory) || updatePath.includes(scriptDirectory)) {
+      if (updatePath.includes(srcDir) || updatePath.includes(scriptDir)) {
         // Ignore changes to codegen files to avoid an infinite loop
-        if (updatePath.includes(initialConfig.codegenDirectory)) return;
-        changedSinceLastHandled.contracts = true;
-      }
-
-      // Trigger debounced onChange
-      handleChange();
-    });
-
-    const handleChange = debounce(100, async () => {
-      // Avoid handling changes multiple times in parallel
-      if (changeInProgress.current) return;
-      changeInProgress.current = true;
-
-      // Reset dirty flags
-      const { config, contracts } = changedSinceLastHandled;
-      changedSinceLastHandled.config = false;
-      changedSinceLastHandled.contracts = false;
-
-      try {
-        // Load latest config
-        const mudConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
-
-        // Handle changes
-        if (config) await handleConfigChange(mudConfig);
-        if (contracts) await handleContractsChange(mudConfig);
-
-        await deploy();
-      } catch (error) {
-        console.error(chalk.red("MUD dev-contracts watcher failed to deploy config or contracts changes\n"));
-        logError(error);
-      }
-
-      changeInProgress.current = false;
-      if (changedSinceLastHandled.config || changedSinceLastHandled.contracts) {
-        console.log("Detected change while handling the previous change");
-        handleChange();
+        if (!updatePath.includes(initialConfig.codegenDirectory)) {
+          console.log(chalk.blue("Contracts changed, queuing deploy…"));
+          lastChange$.next(Date.now());
+        }
       }
-
-      printMUD();
-      console.log("MUD watching for changes...");
     });
 
-    /** Codegen to run if config changes */
-    async function handleConfigChange(config: StoreConfig & WorldConfig) {
-      console.log(chalk.blue("mud.config.ts changed - regenerating tables and recs types"));
-      // Run tablegen to generate tables based on the config
-      const outPath = path.join(srcDirectory, config.codegenDirectory);
-      await tablegen(config, outPath, remappings);
-    }
-
-    /** Codegen to run if contracts changed */
-    async function handleContractsChange(config: StoreConfig & WorldConfig) {
-      console.log(chalk.blue("contracts changed - regenerating interfaces and contract types"));
-
-      // Run worldgen to generate interfaces based on the systems
-      await worldgenHandler({ config, clean: true, srcDir: srcDirectory });
-
-      // Build the contracts
-      await forge(["build", "--skip", "test", "script"]);
-
-      // Generate TS type definitions for ABIs
-      await execa("mud", ["abi-ts"], { stdio: "inherit" });
-    }
-
-    /** Run after codegen if either mud config or contracts changed */
-    async function deploy() {
-      console.log(chalk.blue("redeploying World"));
-      await deployHandler({
-        configPath,
-        skipBuild: true,
-        priorityFeeMultiplier: 1,
-        disableTxWait: true,
-        pollInterval: 1000,
-        saveDeployment: true,
-        srcDir: srcDirectory,
-        rpc,
-      });
-    }
+    let worldAddress: Address | undefined;
+
+    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(chalk.blue("Rebuilding and upgrading world…"));
+        }
+
+        try {
+          const deploy = await runDeploy({
+            ...opts,
+            configPath,
+            rpc,
+            skipBuild: false,
+            printConfig: false,
+            profile: undefined,
+            saveDeployment: true,
+            worldAddress,
+            srcDir,
+          });
+          worldAddress = deploy.address;
+          // if there were changes while we were deploying, trigger it again
+          if (lastChange < lastChange$.value) {
+            lastChange$.next(lastChange$.value);
+          } else {
+            console.log(chalk.gray("\nWaiting for file changes…\n"));
+          }
+          return deploy;
+        } catch (error) {
+          console.error(chalk.bgRed(chalk.whiteBright("\n Error while attempting deploy \n")));
+          console.error(error);
+          console.log(chalk.gray("\nWaiting for file changes…\n"));
+        }
+      }),
+      filter(isDefined)
+    );
+
+    deploys$.subscribe();
   },
 };
 

package/src/commands/test.ts

@@ -1,70 +1,64 @@
-import type { CommandModule } from "yargs";
+import type { CommandModule, InferredOptionTypes, Options } from "yargs";
 import { anvil, forge, getRpcUrl } from "@latticexyz/common/foundry";
 import chalk from "chalk";
-import { rmSync, writeFileSync } from "fs";
-import { yDeployOptions } from "./deploy";
-import { DeployOptions, deployHandler } from "../utils/deployHandler";
+import { deployOptions, runDeploy } from "../runDeploy";
 
-type Options = DeployOptions & { port?: number; worldAddress?: string; forgeOptions?: string };
+const 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" },
+} as const satisfies Record<string, Options>;
 
-const WORLD_ADDRESS_FILE = ".mudtest";
+type TestOptions = InferredOptionTypes<typeof testOptions>;
 
-const commandModule: CommandModule<Options, Options> = {
+const commandModule: CommandModule<typeof testOptions, TestOptions> = {
   command: "test",
 
   describe: "Run tests in MUD contracts",
 
   builder(yargs) {
-    return yargs.options({
-      ...yDeployOptions,
-      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" },
-    });
+    return yargs.options(testOptions);
   },
 
-  async handler(args) {
+  async handler(opts) {
     // Start an internal anvil process if no world address is provided
-    if (!args.worldAddress) {
-      const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(args.port)];
+    if (!opts.worldAddress) {
+      const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(opts.port)];
       anvil(anvilArgs);
     }
 
-    const forkRpc = args.worldAddress ? await getRpcUrl(args.profile) : `http://127.0.0.1:${args.port}`;
+    const forkRpc = opts.worldAddress ? await getRpcUrl(opts.profile) : `http://127.0.0.1:${opts.port}`;
 
     const worldAddress =
-      args.worldAddress ??
+      opts.worldAddress ??
       (
-        await deployHandler({
-          ...args,
+        await runDeploy({
+          ...opts,
           saveDeployment: false,
           rpc: forkRpc,
         })
-      ).worldAddress;
+      ).address;
 
     console.log(chalk.blue("World address", worldAddress));
 
-    // Create a temporary file to pass the world address to the tests
-    writeFileSync(WORLD_ADDRESS_FILE, worldAddress);
-
-    const userOptions = args.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
+    const userOptions = opts.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
     try {
-      const testResult = await forge(["test", "--fork-url", forkRpc, ...userOptions], {
-        profile: args.profile,
+      await forge(["test", "--fork-url", forkRpc, ...userOptions], {
+        profile: opts.profile,
+        env: {
+          WORLD_ADDRESS: worldAddress,
+        },
       });
-      console.log(testResult);
+      process.exit(0);
     } catch (e) {
       console.error(e);
-      rmSync(WORLD_ADDRESS_FILE);
       process.exit(1);
     }
-
-    rmSync(WORLD_ADDRESS_FILE);
-    process.exit(0);
   },
 };
 

package/src/commands/trace.ts

@@ -9,12 +9,13 @@ import { StoreConfig } from "@latticexyz/store";
 import { resolveWorldConfig, WorldConfig } from "@latticexyz/world";
 import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
 import worldConfig from "@latticexyz/world/mud.config.js";
-import { resourceIdToHex } from "@latticexyz/common";
+import { resourceToHex } from "@latticexyz/common";
 import { getExistingContracts } from "../utils/getExistingContracts";
-import { getChainId } from "../utils/utils/getChainId";
+import { createClient, http } from "viem";
+import { getChainId } from "viem/actions";
 
 // TODO account for multiple namespaces (https://github.com/latticexyz/mud/issues/994)
-const systemsTableId = resourceIdToHex({
+const systemsTableId = resourceToHex({
   type: "system",
   namespace: worldConfig.namespace,
   name: worldConfig.tables.Systems.name,
@@ -80,7 +81,7 @@ const commandModule: CommandModule<Options, Options> = {
     const systemTableFieldLayout = await WorldContract.getFieldLayout(systemsTableId);
     const labels: { name: string; address: string }[] = [];
     for (const name of names) {
-      const systemSelector = resourceIdToHex({ type: "system", namespace, name });
+      const systemSelector = resourceToHex({ type: "system", namespace, name });
       // Get the first field of `Systems` table (the table maps system name to its address and other data)
       const address = await WorldContract.getField(systemsTableId, [systemSelector], 0, systemTableFieldLayout);
       labels.push({ name, address });
@@ -103,7 +104,8 @@ export default commandModule;
 
 async function getWorldAddress(worldsFile: string, rpc: string) {
   if (existsSync(worldsFile)) {
-    const chainId = await getChainId(rpc);
+    const client = createClient({ transport: http(rpc) });
+    const chainId = await getChainId(client);
     const deploys = JSON.parse(readFileSync(worldsFile, "utf-8"));
 
     if (!deploys[chainId]) {

package/src/debug.ts

@@ -0,0 +1,3 @@
+import createDebug from "debug";
+
+export const debug = createDebug("mud:cli");

package/src/deploy/assertNamespaceOwner.ts

@@ -0,0 +1,42 @@
+import { Account, Chain, Client, Hex, Transport, getAddress } from "viem";
+import { WorldDeploy, worldTables } from "./common";
+import { hexToResource, resourceToHex } from "@latticexyz/common";
+import { getResourceIds } from "./getResourceIds";
+import { getTableValue } from "./getTableValue";
+
+export async function assertNamespaceOwner({
+  client,
+  worldDeploy,
+  resourceIds,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly resourceIds: readonly Hex[];
+}): Promise<void> {
+  const desiredNamespaces = Array.from(new Set(resourceIds.map((resourceId) => hexToResource(resourceId).namespace)));
+  const existingResourceIds = await getResourceIds({ client, worldDeploy });
+  const existingNamespaces = Array.from(
+    new Set(existingResourceIds.map((resourceId) => hexToResource(resourceId).namespace))
+  );
+
+  const namespaces = desiredNamespaces.filter((namespace) => existingNamespaces.includes(namespace));
+  const namespaceOwners = await Promise.all(
+    namespaces.map(async (namespace) => {
+      const { owner } = await getTableValue({
+        client,
+        worldDeploy,
+        table: worldTables.world_NamespaceOwner,
+        key: { namespaceId: resourceToHex({ type: "namespace", namespace, name: "" }) },
+      });
+      return [namespace, owner];
+    })
+  );
+
+  const unauthorizedNamespaces = namespaceOwners
+    .filter(([, owner]) => getAddress(owner) !== getAddress(client.account.address))
+    .map(([namespace]) => namespace);
+
+  if (unauthorizedNamespaces.length) {
+    throw new Error(`You are attempting to deploy to namespaces you do not own: ${unauthorizedNamespaces.join(", ")}`);
+  }
+}

package/src/deploy/common.ts

@@ -0,0 +1,72 @@
+import { Abi, Address, Hex, padHex } from "viem";
+import storeConfig from "@latticexyz/store/mud.config.js";
+import worldConfig from "@latticexyz/world/mud.config.js";
+import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
+import IModuleAbi from "@latticexyz/world-modules/out/IModule.sol/IModule.abi.json" assert { type: "json" };
+import { Tables, configToTables } from "./configToTables";
+import { StoreConfig, helloStoreEvent } from "@latticexyz/store";
+import { WorldConfig, helloWorldEvent } from "@latticexyz/world";
+
+export const salt = padHex("0x", { size: 32 });
+
+// TODO: add `as const` to mud config so these get more strongly typed (blocked by current config parsing not using readonly)
+export const storeTables = configToTables(storeConfig);
+export const worldTables = configToTables(worldConfig);
+
+export const worldDeployEvents = [helloStoreEvent, helloWorldEvent] as const;
+
+export const worldAbi = [...IBaseWorldAbi, ...IModuleAbi] as const;
+
+// Ideally, this should be an append-only list. Before adding more versions here, be sure to add backwards-compatible support for old Store/World versions.
+export const supportedStoreVersions = ["1.0.0-unaudited"];
+export const supportedWorldVersions = ["1.0.0-unaudited"];
+
+export type WorldDeploy = {
+  readonly address: Address;
+  readonly worldVersion: string;
+  readonly storeVersion: string;
+  /** Block number where the world was deployed */
+  readonly deployBlock: bigint;
+  /**
+   * Block number at the time of fetching world deploy.
+   * We use this block number when requesting data from the chain to align chain state
+   * with the same block during the introspection steps of the deploy.
+   */
+  readonly stateBlock: bigint;
+};
+
+export type WorldFunction = {
+  readonly signature: string;
+  readonly selector: Hex;
+  readonly systemId: Hex;
+  readonly systemFunctionSignature: string;
+  readonly systemFunctionSelector: Hex;
+};
+
+export type DeterministicContract = {
+  readonly address: Address;
+  readonly bytecode: Hex;
+  readonly abi: Abi;
+};
+
+export type System = DeterministicContract & {
+  readonly namespace: string;
+  readonly name: string;
+  readonly systemId: Hex;
+  readonly allowAll: boolean;
+  readonly allowedAddresses: readonly Hex[];
+  readonly functions: readonly WorldFunction[];
+};
+
+export type Module = DeterministicContract & {
+  readonly name: string;
+  readonly installAsRoot: boolean;
+  readonly installData: Hex; // TODO: figure out better naming for this
+};
+
+export type ConfigInput = StoreConfig & WorldConfig;
+export type Config<config extends ConfigInput> = {
+  readonly tables: Tables<config>;
+  readonly systems: readonly System[];
+  readonly modules: readonly Module[];
+};