@latticexyz/cli 2.0.0-alpha.94 → 2.0.0-main-0d434816

package/src/commands/set-version.ts

@@ -2,8 +2,8 @@ import chalk from "chalk";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
 import path from "path";
 import type { CommandModule } from "yargs";
-import { MUDError } from "@latticexyz/config";
-import { logError } from "../utils/errors.js";
+import { MUDError } from "@latticexyz/common/errors";
+import { logError } from "../utils/errors";
 import localPackageJson from "../../package.json" assert { type: "json" };
 
 type Options = {
@@ -11,6 +11,7 @@ type Options = {
   force?: boolean;
   restore?: boolean;
   mudVersion?: string;
+  link?: string;
 };
 
 const BACKUP_FILE = ".mudbackup";
@@ -30,13 +31,19 @@ const commandModule: CommandModule<Options, Options> = {
       },
       restore: { type: "boolean", description: `Restore the previous MUD versions from "${BACKUP_FILE}"` },
       mudVersion: { alias: "v", type: "string", description: "The MUD version to install" },
+      link: { alias: "l", type: "string", description: "Relative path to the local MUD root directory to link" },
     });
   },
 
   async handler(options) {
     try {
-      if (!options.mudVersion && !options.restore) {
-        throw new MUDError(`Version parameter is required unless --restore is provided.`);
+      if (!options.mudVersion && !options.link && !options.restore) {
+        throw new MUDError("`--mudVersion` or `--link` is required unless --restore is provided.");
+      }
+
+      // `link` and `mudVersion` are mutually exclusive
+      if (options.link && options.mudVersion) {
+        throw new MUDError("Options `--link` and `--mudVersion` are mutually exclusive");
       }
 
       // Resolve the `canary` version number if needed
@@ -63,11 +70,17 @@ const commandModule: CommandModule<Options, Options> = {
 };
 
 function updatePackageJson(filePath: string, options: Options): { workspaces?: string[] } {
-  const { backup, restore, force, mudVersion } = options;
+  const { restore, force, link } = options;
+  let { backup, mudVersion } = options;
+
   const backupFilePath = path.join(path.dirname(filePath), BACKUP_FILE);
+  const backupFileExists = existsSync(backupFilePath);
+
+  // Create a backup file for previous MUD versions by default if linking to local MUD
+  if (link && !backupFileExists) backup = true;
 
   // If `backup` is true and force not set, check if a backup file already exists and throw an error if it does
-  if (backup && !force && existsSync(backupFilePath)) {
+  if (backup && !force && backupFileExists) {
     throw new MUDError(
       `A backup file already exists at ${backupFilePath}.\nUse --force to overwrite it or --restore to restore it.`
     );
@@ -106,16 +119,14 @@ function updatePackageJson(filePath: string, options: Options): { workspaces?: s
   // Update the dependencies
   for (const key in packageJson.dependencies) {
     if (key.startsWith(MUD_PREFIX)) {
-      packageJson.dependencies[key] =
-        restore && backupJson ? backupJson.dependencies[key] : mudVersion || packageJson.dependencies[key];
+      packageJson.dependencies[key] = resolveMudVersion(key, "dependencies");
     }
   }
 
   // Update the devDependencies
   for (const key in packageJson.devDependencies) {
     if (key.startsWith(MUD_PREFIX)) {
-      packageJson.devDependencies[key] =
-        restore && backupJson ? backupJson.devDependencies[key] : mudVersion || packageJson.devDependencies[key];
+      packageJson.devDependencies[key] = resolveMudVersion(key, "devDependencies");
     }
   }
 
@@ -134,6 +145,13 @@ function updatePackageJson(filePath: string, options: Options): { workspaces?: s
   }
 
   return packageJson;
+
+  function resolveMudVersion(key: string, type: "dependencies" | "devDependencies") {
+    if (restore && backupJson) return backupJson[type][key];
+    if (link) mudVersion = resolveLinkPath(filePath, link, key);
+    if (!mudVersion) return packageJson[type][key];
+    return mudVersion;
+  }
 }
 
 function readPackageJson(path: string): {
@@ -169,4 +187,14 @@ function logComparison(prev: Record<string, string>, curr: Record<string, string
   }
 }
 
+/**
+ * Returns path of the package to link, given a path to a local MUD clone and a package
+ */
+function resolveLinkPath(packageJsonPath: string, mudLinkPath: string, pkg: string) {
+  const pkgName = pkg.replace(MUD_PREFIX, "");
+  const packageJsonToRootPath = path.relative(path.dirname(packageJsonPath), process.cwd());
+  const linkPath = path.join(packageJsonToRootPath, mudLinkPath, "packages", pkgName);
+  return "link:" + linkPath;
+}
+
 export default commandModule;

package/src/commands/tablegen.ts

@@ -1,8 +1,9 @@
 import path from "path";
 import type { CommandModule } from "yargs";
-import { loadStoreConfig } from "@latticexyz/config";
-import { tablegen } from "../render-solidity/tablegen.js";
-import { getSrcDirectory } from "../utils/index.js";
+import { loadConfig } from "@latticexyz/config/node";
+import { StoreConfig } from "@latticexyz/store";
+import { tablegen } from "@latticexyz/store/codegen";
+import { getSrcDirectory } from "@latticexyz/common/foundry";
 
 type Options = {
   configPath?: string;
@@ -20,7 +21,7 @@ const commandModule: CommandModule<Options, Options> = {
   },
 
   async handler({ configPath }) {
-    const config = await loadStoreConfig(configPath);
+    const config = (await loadConfig(configPath)) as StoreConfig;
     const srcDir = await getSrcDirectory();
 
     await tablegen(config, path.join(srcDir, config.codegenDirectory));

package/src/commands/{test-v2.ts → test.ts}

@@ -1,19 +1,18 @@
 import type { CommandModule } from "yargs";
-import { deployHandler, DeployOptions } from "./deploy-v2.js";
-import { yDeployOptions } from "./deploy-v2.js";
-import { anvil, forge, getRpcUrl, getTestDirectory } from "../utils/foundry.js";
+import { anvil, forge, getRpcUrl } from "@latticexyz/common/foundry";
 import chalk from "chalk";
 import { rmSync, writeFileSync } from "fs";
-import path from "path";
+import { yDeployOptions } from "./deploy";
+import { deployHandler, DeployOptions } from "../utils";
 
 type Options = DeployOptions & { port?: number; worldAddress?: string; forgeOptions?: string };
 
 const WORLD_ADDRESS_FILE = ".mudtest";
 
 const commandModule: CommandModule<Options, Options> = {
-  command: "test-v2",
+  command: "test",
 
-  describe: "Run tests in MUD v2 contracts",
+  describe: "Run tests in MUD contracts",
 
   builder(yargs) {
     return yargs.options({

package/src/commands/trace.ts

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync } from "fs";
+import type { CommandModule } from "yargs";
+import { ethers } from "ethers";
+
+import { loadConfig } from "@latticexyz/config/node";
+import { MUDError } from "@latticexyz/common/errors";
+import { cast, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
+import { TableId } from "@latticexyz/common";
+import { StoreConfig } from "@latticexyz/store";
+import { resolveWorldConfig, WorldConfig } from "@latticexyz/world";
+import { IBaseWorld } from "@latticexyz/world/types/ethers-contracts/IBaseWorld";
+import IBaseWorldData from "@latticexyz/world/abi/IBaseWorld.sol/IBaseWorld.json" assert { type: "json" };
+import { getChainId, getExistingContracts } from "../utils";
+
+const systemsTableId = new TableId("", "Systems");
+
+type Options = {
+  tx: string;
+  worldAddress?: string;
+  configPath?: string;
+  profile?: string;
+  srcDir?: string;
+  rpc?: string;
+};
+
+const commandModule: CommandModule<Options, Options> = {
+  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 config file" },
+      profile: { type: "string", description: "The foundry profile to use" },
+      srcDir: { type: "string", description: "Source directory. Defaults to foundry src directory." },
+      rpc: { type: "string", description: "json rpc endpoint. Defaults to foundry's configured eth_rpc_url" },
+    });
+  },
+
+  async handler(args) {
+    args.profile ??= process.env.FOUNDRY_PROFILE;
+    const { profile } = args;
+    args.srcDir ??= await getSrcDirectory(profile);
+    args.rpc ??= await getRpcUrl(profile);
+    const { tx, configPath, srcDir, rpc } = args;
+
+    const existingContracts = getExistingContracts(srcDir);
+
+    // Load the config
+    const mudConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
+
+    const resolvedConfig = resolveWorldConfig(
+      mudConfig,
+      existingContracts.map(({ basename }) => basename)
+    );
+
+    // Get worldAddress either from args or from worldsFile
+    const worldAddress = args.worldAddress ?? (await getWorldAddress(mudConfig.worldsFile, rpc));
+
+    // Create World contract instance from deployed address
+    const provider = new ethers.providers.StaticJsonRpcProvider(rpc);
+    const WorldContract = new ethers.Contract(worldAddress, IBaseWorldData.abi, provider) as IBaseWorld;
+
+    // TODO account for multiple namespaces (https://github.com/latticexyz/mud/issues/994)
+    const namespace = mudConfig.namespace;
+    const names = Object.values(resolvedConfig.systems).map(({ name }) => name);
+
+    const labels: { name: string; address: string }[] = [];
+    for (const name of names) {
+      const systemSelector = new TableId(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.toHex(), [systemSelector.toHex()], 0);
+      labels.push({ name, address });
+    }
+
+    const result = await cast([
+      "run",
+      "--label",
+      `${worldAddress}:World`,
+      ...labels.map(({ name, address }) => ["--label", `${address}:${name}`]).flat(),
+      `${tx}`,
+    ]);
+    console.log(result);
+
+    process.exit(0);
+  },
+};
+
+export default commandModule;
+
+async function getWorldAddress(worldsFile: string, rpc: string) {
+  if (existsSync(worldsFile)) {
+    const chainId = await getChainId(rpc);
+    const deploys = JSON.parse(readFileSync(worldsFile, "utf-8"));
+
+    if (!deploys[chainId]) {
+      throw new MUDError(`chainId ${chainId} is missing in worldsFile "${worldsFile}"`);
+    }
+    return deploys[chainId].address as string;
+  } else {
+    throw new MUDError("worldAddress is not specified and worldsFile is missing");
+  }
+}

package/src/commands/tsgen.ts

@@ -1,6 +1,7 @@
 import type { CommandModule } from "yargs";
-import { loadStoreConfig } from "@latticexyz/config";
-import { tsgen } from "../render-ts/tsgen.js";
+import { loadConfig } from "@latticexyz/config/node";
+import { StoreConfig } from "@latticexyz/store";
+import { tsgen } from "../render-ts/tsgen";
 
 type Options = {
   configPath: string;
@@ -22,7 +23,7 @@ const commandModule: CommandModule<Options, Options> = {
   async handler(args) {
     const { configPath, out } = args;
 
-    const config = await loadStoreConfig(configPath);
+    const config = (await loadConfig(configPath)) as StoreConfig;
 
     await tsgen(config, out);
 

package/src/commands/worldgen.ts

@@ -1,14 +1,18 @@
 import type { CommandModule } from "yargs";
-import { loadStoreConfig, loadWorldConfig } from "@latticexyz/config";
-import { getSrcDirectory } from "../utils/foundry.js";
-import glob from "glob";
-import path, { basename } from "path";
-import { worldgen } from "../render-solidity/worldgen.js";
+import { loadConfig } from "@latticexyz/config/node";
+import { StoreConfig } from "@latticexyz/store";
+import { WorldConfig } from "@latticexyz/world";
+import { worldgen } from "@latticexyz/world/node";
+import { getSrcDirectory } from "@latticexyz/common/foundry";
+import path from "path";
 import { rmSync } from "fs";
+import { getExistingContracts } from "../utils";
 
 type Options = {
   configPath?: string;
   clean?: boolean;
+  srcDir?: string;
+  config?: StoreConfig & WorldConfig;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -19,38 +23,35 @@ const commandModule: CommandModule<Options, Options> = {
   builder(yargs) {
     return yargs.options({
       configPath: { type: "string", desc: "Path to the config file" },
-      clean: { type: "boolean", desc: "Clear the worldgen directory before generating new interfaces" },
+      clean: {
+        type: "boolean",
+        desc: "Clear the worldgen directory before generating new interfaces (defaults to true)",
+        default: true,
+      },
     });
   },
 
   async handler(args) {
-    const { configPath, clean } = args;
-    const srcDir = await getSrcDirectory();
+    await worldgenHandler(args);
+    process.exit(0);
+  },
+};
 
-    // Get a list of all contract names
-    const existingContracts = glob.sync(`${srcDir}/**/*.sol`).map((path) => ({
-      path,
-      basename: basename(path, ".sol"),
-    }));
+export async function worldgenHandler(args: Options) {
+  const srcDir = args.srcDir ?? (await getSrcDirectory());
 
-    // Load and resolve the config
-    const worldConfig = await loadWorldConfig(
-      configPath,
-      existingContracts.map(({ basename }) => basename)
-    );
-    const storeConfig = await loadStoreConfig(configPath);
-    const mudConfig = { ...worldConfig, ...storeConfig };
+  const existingContracts = getExistingContracts(srcDir);
 
-    const outputBaseDirectory = path.join(srcDir, mudConfig.codegenDirectory);
+  // Load the config
+  const mudConfig = args.config ?? ((await loadConfig(args.configPath)) as StoreConfig & WorldConfig);
 
-    // clear the worldgen directory
-    if (clean) rmSync(path.join(outputBaseDirectory, mudConfig.worldgenDirectory), { recursive: true, force: true });
+  const outputBaseDirectory = path.join(srcDir, mudConfig.codegenDirectory);
 
-    // generate new interfaces
-    await worldgen(mudConfig, existingContracts, outputBaseDirectory);
+  // clear the worldgen directory
+  if (args.clean) rmSync(path.join(outputBaseDirectory, mudConfig.worldgenDirectory), { recursive: true, force: true });
 
-    process.exit(0);
-  },
-};
+  // generate new interfaces
+  await worldgen(mudConfig, existingContracts, outputBaseDirectory);
+}
 
 export default commandModule;

package/src/index.ts

@@ -1 +1,2 @@
-export {};
+export * from "./render-ts";
+export * from "./utils/deployHandler";

package/src/modules.d.ts

@@ -0,0 +1,11 @@
+// adding .js to minimal would break clients down the line because it probably won't get a synthetic default import
+/* eslint-disable @typescript-eslint/no-explicit-any */
+declare module "protobufjs/minimal" {
+  export const configure: any;
+  export const util: any;
+  export const Reader: any;
+  export type Reader = any;
+  export const Writer: any;
+  export type Writer = any;
+}
+declare module "rollup-plugin-preserve-shebang";

package/src/mud.ts

@@ -2,12 +2,12 @@
 
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { commands as v2 } from "./commands/index.js";
-import { commands as v1 } from "./commands/deprecated/index.js";
-import { logError } from "./utils/errors.js";
+import { commands } from "./commands";
+import { logError } from "./utils/errors";
 
 // Load .env file into process.env
 import * as dotenv from "dotenv";
+import chalk from "chalk";
 dotenv.config();
 
 yargs(hideBin(process.argv))
@@ -15,11 +15,17 @@ yargs(hideBin(process.argv))
   .scriptName("mud")
   // Use the commands directory to scaffold
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
-  .command([...v1, ...v2] as any)
+  .command(commands as any)
   // Enable strict mode.
   .strict()
   // Custom error handler
   .fail((msg, err) => {
+    console.error(chalk.red(msg));
+    if (msg.includes("Missing required argument")) {
+      console.log(
+        chalk.yellow(`Run 'pnpm mud ${process.argv[2]} --help' for a list of available and required arguments.`)
+      );
+    }
     console.log("");
     logError(err);
     console.log("");

package/src/render-ts/recsV1TableOptions.ts

@@ -1,7 +1,7 @@
-import { StoreConfig } from "@latticexyz/config";
-import { resolveAbiOrUserType } from "../render-solidity/userType.js";
-import { schemaTypesToRecsTypeStrings } from "./schemaTypesToRecsTypeStrings.js";
-import { RecsV1TableOptions } from "./types.js";
+import { StoreConfig } from "@latticexyz/store";
+import { resolveAbiOrUserType } from "@latticexyz/store/codegen";
+import { schemaTypesToRecsTypeStrings } from "./schemaTypesToRecsTypeStrings";
+import { RecsV1TableOptions } from "./types";
 
 export function getRecsV1TableOptions(config: StoreConfig): RecsV1TableOptions {
   const tableOptions = [];

package/src/render-ts/renderRecsV1Tables.ts

@@ -1,11 +1,11 @@
-import { RecsV1TableOptions } from "./types.js";
+import { RecsV1TableOptions } from "./types";
 
 export function renderRecsV1Tables(options: RecsV1TableOptions) {
   const { tables } = options;
 
   return `/* Autogenerated file. Do not edit manually. */
 
-import { TableId } from "@latticexyz/utils";
+import { TableId } from "@latticexyz/common";
 import { defineComponent, Type as RecsType, World } from "@latticexyz/recs";
 
 export function defineContractComponents(world: World) {
@@ -24,7 +24,7 @@ function renderDefineComponent(table: RecsV1TableOptions["tables"][number]) {
       return defineComponent(world, {
         ${table.fields.map(({ name, recsTypeString }) => `${name}: ${recsTypeString},`).join("")}
       }, {
-        metadata: { contractId: tableId.toHexString(), tableId: tableId.toString() },
+        metadata: { contractId: tableId.toHex(), tableId: tableId.toString() },
       });
     })()
   `;

package/src/render-ts/schemaTypesToRecsTypeStrings.ts

@@ -1,4 +1,4 @@
-import { SchemaType } from "@latticexyz/schema-type";
+import { SchemaType } from "@latticexyz/schema-type/deprecated";
 
 export const schemaTypesToRecsTypeStrings: Record<SchemaType, string> = {
   [SchemaType.UINT8]: "RecsType.Number",
@@ -163,38 +163,38 @@ export const schemaTypesToRecsTypeStrings: Record<SchemaType, string> = {
   [SchemaType.INT240_ARRAY]: "RecsType.BigIntArray",
   [SchemaType.INT248_ARRAY]: "RecsType.BigIntArray",
   [SchemaType.INT256_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES1_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES2_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES3_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES4_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES5_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES6_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES7_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES8_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES9_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES10_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES11_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES12_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES13_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES14_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES15_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES16_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES17_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES18_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES19_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES20_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES21_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES22_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES23_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES24_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES25_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES26_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES27_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES28_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES29_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES30_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES31_ARRAY]: "RecsType.BigIntArray",
-  [SchemaType.BYTES32_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES1_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES2_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES3_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES4_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES5_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES6_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES7_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES8_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES9_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES10_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES11_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES12_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES13_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES14_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES15_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES16_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES17_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES18_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES19_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES20_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES21_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES22_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES23_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES24_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES25_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES26_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES27_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES28_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES29_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES30_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES31_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES32_ARRAY]: "RecsType.StringArray",
   [SchemaType.BOOL_ARRAY]: "RecsType.T", // no boolean array
   [SchemaType.ADDRESS_ARRAY]: "RecsType.StringArray",
   [SchemaType.BYTES]: "RecsType.String",

package/src/render-ts/tsgen.ts

@@ -1,8 +1,8 @@
 import path from "path";
-import { StoreConfig } from "@latticexyz/config";
-import { getRecsV1TableOptions } from "../render-ts/recsV1TableOptions.js";
-import { renderRecsV1Tables } from "../render-ts/renderRecsV1Tables.js";
-import { formatAndWriteTypescript } from "../utils/formatAndWrite.js";
+import { StoreConfig } from "@latticexyz/store";
+import { formatAndWriteTypescript } from "@latticexyz/common/codegen";
+import { getRecsV1TableOptions } from "../render-ts/recsV1TableOptions";
+import { renderRecsV1Tables } from "../render-ts/renderRecsV1Tables";
 
 export async function tsgen(config: StoreConfig, outDirectory: string) {
   const fullOutputPath = path.join(outDirectory, `contractComponents.ts`);