@latticexyz/cli 1.41.0 → 2.0.0-alpha.0

package/src/config/parseStoreConfig.ts

@@ -1,32 +1,89 @@
-import { SchemaType } from "@latticexyz/schema-type";
+import { AbiType, AbiTypes, StaticAbiType, StaticAbiTypes } from "@latticexyz/schema-type";
 import { RefinementCtx, z, ZodIssueCode } from "zod";
-import { BaseRoute, ObjectName, OrdinaryRoute, StaticSchemaType, UserEnum, ValueName } from "./commonSchemas.js";
-import { getDuplicates } from "./validation.js";
+import { AsDependent, ExtractUserTypes, RequireKeys, StaticArray, StringForUnion } from "../utils/typeUtils.js";
+import { zObjectName, zSelector, zUserEnum, zValueName } from "./commonSchemas.js";
+import { getDuplicates, parseStaticArray } from "./validation.js";
 
-const TableName = ObjectName;
-const KeyName = ValueName;
-const ColumnName = ValueName;
-const UserEnumName = ObjectName;
+const zTableName = zObjectName;
+const zKeyName = zValueName;
+const zColumnName = zValueName;
+const zUserEnumName = zObjectName;
 
-// Fields can use SchemaType or one of user defined wrapper types
-const FieldData = z.union([z.nativeEnum(SchemaType), UserEnumName]);
+// Fields can use AbiType or one of user-defined wrapper types
+// (user types are refined later, based on the appropriate config options)
+const zFieldData = z.string();
 
-// Primary keys allow only static types, but allow static user defined types
-const PrimaryKey = z.union([StaticSchemaType, UserEnumName]);
-const PrimaryKeys = z.record(KeyName, PrimaryKey).default({ key: SchemaType.BYTES32 });
+type FieldData<UserTypes extends StringForUnion> = AbiType | StaticArray | UserTypes;
 
-const Schema = z
-  .record(ColumnName, FieldData)
+// Primary keys allow only static types
+// (user types are refined later, based on the appropriate config options)
+const zPrimaryKey = z.string();
+const zPrimaryKeys = z.record(zKeyName, zPrimaryKey).default({ key: "bytes32" });
+
+type PrimaryKey<StaticUserTypes extends StringForUnion> = StaticAbiType | StaticUserTypes;
+
+/************************************************************************
+ *
+ *    TABLE SCHEMA
+ *
+ ************************************************************************/
+
+export type FullSchemaConfig<UserTypes extends StringForUnion = StringForUnion> = Record<string, FieldData<UserTypes>>;
+export type ShorthandSchemaConfig<UserTypes extends StringForUnion = StringForUnion> = FieldData<UserTypes>;
+export type SchemaConfig<UserTypes extends StringForUnion = StringForUnion> =
+  | FullSchemaConfig<UserTypes>
+  | ShorthandSchemaConfig<UserTypes>;
+
+const zFullSchemaConfig = z
+  .record(zColumnName, zFieldData)
   .refine((arg) => Object.keys(arg).length > 0, "Table schema may not be empty");
 
-const TableDataFull = z
+const zShorthandSchemaConfig = zFieldData.transform((fieldData) => {
+  return zFullSchemaConfig.parse({
+    value: fieldData,
+  });
+});
+
+export const zSchemaConfig = zFullSchemaConfig.or(zShorthandSchemaConfig);
+
+/************************************************************************
+ *
+ *    TABLE
+ *
+ ************************************************************************/
+
+export interface TableConfig<
+  UserTypes extends StringForUnion = StringForUnion,
+  StaticUserTypes extends StringForUnion = StringForUnion
+> {
+  /** Output directory path for the file. Default is "tables" */
+  directory?: string;
+  /**
+   * The fileSelector is used with the namespace to register the table and construct its id.
+   * The table id will be uint256(bytes32(abi.encodePacked(bytes16(namespace), bytes16(fileSelector)))).
+   * Default is "<tableName>"
+   * */
+  fileSelector?: string;
+  /** Make methods accept `tableId` argument instead of it being a hardcoded constant. Default is false */
+  tableIdArgument?: boolean;
+  /** Include methods that accept a manual `IStore` argument. Default is false. */
+  storeArgument?: boolean;
+  /** Include a data struct and methods for it. Default is false for 1-column tables; true for multi-column tables. */
+  dataStruct?: boolean;
+  /** Table's primary key names mapped to their types. Default is `{ key: "bytes32" }` */
+  primaryKeys?: Record<string, PrimaryKey<StaticUserTypes>>;
+  /** Table's column names mapped to their types. Table name's 1st letter should be lowercase. */
+  schema: SchemaConfig<UserTypes>;
+}
+
+const zFullTableConfig = z
   .object({
-    directory: OrdinaryRoute.default("/tables"),
-    route: BaseRoute.optional(),
+    directory: z.string().default("tables"),
+    fileSelector: zSelector.optional(),
     tableIdArgument: z.boolean().default(false),
     storeArgument: z.boolean().default(false),
-    primaryKeys: PrimaryKeys,
-    schema: Schema,
+    primaryKeys: zPrimaryKeys,
+    schema: zSchemaConfig,
     dataStruct: z.boolean().optional(),
   })
   .transform((arg) => {
@@ -39,43 +96,88 @@ const TableDataFull = z
     return arg as RequireKeys<typeof arg, "dataStruct">;
   });
 
-const TableDataShorthand = FieldData.transform((fieldData) => {
-  return TableDataFull.parse({
+const zShorthandTableConfig = zFieldData.transform((fieldData) => {
+  return zFullTableConfig.parse({
     schema: {
       value: fieldData,
     },
   });
 });
 
-const TablesRecord = z.record(TableName, z.union([TableDataShorthand, TableDataFull])).transform((tables) => {
-  // default route depends on tableName
+export const zTableConfig = zFullTableConfig.or(zShorthandTableConfig);
+
+/************************************************************************
+ *
+ *    TABLES
+ *
+ ************************************************************************/
+
+export type TablesConfig<
+  UserTypes extends StringForUnion = StringForUnion,
+  StaticUserTypes extends StringForUnion = StringForUnion
+> = Record<string, TableConfig<UserTypes, StaticUserTypes> | FieldData<UserTypes>>;
+
+export const zTablesConfig = z.record(zTableName, zTableConfig).transform((tables) => {
+  // default fileSelector depends on tableName
   for (const tableName of Object.keys(tables)) {
     const table = tables[tableName];
-    table.route ??= `/${tableName}`;
+    table.fileSelector ??= tableName;
 
     tables[tableName] = table;
   }
-  return tables as Record<string, RequireKeys<typeof tables[string], "route">>;
+  return tables as Record<string, RequireKeys<(typeof tables)[string], "fileSelector">>;
 });
 
-const StoreConfigUnrefined = z.object({
-  baseRoute: BaseRoute.default(""),
-  storeImportPath: z.string().default("@latticexyz/store/src/"),
-  tables: TablesRecord,
-  userTypes: z
-    .object({
-      path: OrdinaryRoute.default("/types"),
-      enums: z.record(UserEnumName, UserEnum).default({}),
-    })
-    .default({}),
+/************************************************************************
+ *
+ *    USER TYPES
+ *
+ ************************************************************************/
+
+export type EnumsConfig<EnumNames extends StringForUnion> = never extends EnumNames
+  ? {
+      /**
+       * Enum names mapped to lists of their member names
+       *
+       * (enums are inferred to be absent)
+       */
+      enums?: Record<EnumNames, string[]>;
+    }
+  : StringForUnion extends EnumNames
+  ? {
+      /**
+       * Enum names mapped to lists of their member names
+       *
+       * (enums aren't inferred - use `mudConfig` or `storeConfig` helper, and `as const` for variables)
+       */
+      enums?: Record<EnumNames, string[]>;
+    }
+  : {
+      /**
+       * Enum names mapped to lists of their member names
+       *
+       * Enums defined here can be used as types in table schemas/keys
+       */
+      enums: Record<EnumNames, string[]>;
+    };
+
+export const zEnumsConfig = z.object({
+  enums: z.record(zUserEnumName, zUserEnum).default({}),
 });
-// finally validate global conditions
-export const StoreConfig = StoreConfigUnrefined.superRefine(validateStoreConfig);
+
+/************************************************************************
+ *
+ *    FINAL
+ *
+ ************************************************************************/
 
 // zod doesn't preserve doc comments
-export interface StoreUserConfig {
-  /** The base route prefix for table ids. Default is "" (empty string) */
-  baseRoute?: string;
+export type StoreUserConfig<
+  EnumNames extends StringForUnion = StringForUnion,
+  StaticUserTypes extends ExtractUserTypes<EnumNames> = ExtractUserTypes<EnumNames>
+> = EnumsConfig<EnumNames> & {
+  /** The namespace for table ids. Default is "" (empty string) */
+  namespace?: string;
   /** Path for store package imports. Default is "@latticexyz/store/src/" */
   storeImportPath?: string;
   /**
@@ -84,44 +186,47 @@ export interface StoreUserConfig {
    * The key is the table name (capitalized).
    *
    * The value:
-   *  - `SchemaType | userType` for a single-value table (aka ECS component).
+   *  - abi or user type for a single-value table.
    *  - FullTableConfig object for multi-value tables (or for customizable options).
    */
-  tables: Record<string, z.input<typeof FieldData> | FullTableConfig>;
-  /** User-defined types that will be generated and may be used in table schemas instead of `SchemaType` */
-  userTypes?: UserTypesConfig;
-}
+  tables: TablesConfig<AsDependent<StaticUserTypes>, AsDependent<StaticUserTypes>>;
+  /** Path to the file where common user types will be generated and imported from. Default is "Types" */
+  userTypesPath?: string;
+};
 
-interface FullTableConfig {
-  /** Output directory path for the file. Default is "/tables" */
-  directory?: string;
-  /** Route is used to register the table and construct its id. The table id will be keccak256(concat(baseRoute,route)). Default is "/<tableName>" */
-  route?: string;
-  /** Make methods accept `tableId` argument instead of it being a hardcoded constant. Default is false */
-  tableIdArgument?: boolean;
-  /** Include methods that accept a manual `IStore` argument. Default is false. */
-  storeArgument?: boolean;
-  /** Include a data struct and methods for it. Default is false for 1-column tables; true for multi-column tables. */
-  dataStruct?: boolean;
-  /** Table's primary key names mapped to their types. Default is `{ key: SchemaType.BYTES32 }` */
-  primaryKeys?: Record<string, z.input<typeof PrimaryKey>>;
-  /** Table's column names mapped to their types. Table name's 1st letter should be lowercase. */
-  schema: Record<string, z.input<typeof FieldData>>;
+/** Type helper for defining StoreUserConfig */
+export function storeConfig<
+  // (`never` is overridden by inference, so only the defined enums can be used by default)
+  EnumNames extends StringForUnion = never,
+  StaticUserTypes extends ExtractUserTypes<EnumNames> = ExtractUserTypes<EnumNames>
+>(config: StoreUserConfig<EnumNames, StaticUserTypes>) {
+  return config;
 }
 
-interface UserTypesConfig {
-  /** Path to the file where common types will be generated and imported from. Default is "/types" */
-  path?: string;
-  /** Enum names mapped to lists of their member names */
-  enums?: Record<string, string[]>;
-}
+export type StoreConfig = z.output<typeof zStoreConfig>;
+
+const StoreConfigUnrefined = z
+  .object({
+    namespace: zSelector.default(""),
+    storeImportPath: z.string().default("@latticexyz/store/src/"),
+    tables: zTablesConfig,
+    userTypesPath: z.string().default("Types"),
+  })
+  .merge(zEnumsConfig);
 
-export type StoreConfig = z.output<typeof StoreConfig>;
+// finally validate global conditions
+export const zStoreConfig = StoreConfigUnrefined.superRefine(validateStoreConfig);
 
-export async function parseStoreConfig(config: unknown) {
-  return StoreConfig.parse(config);
+export function parseStoreConfig(config: unknown) {
+  return zStoreConfig.parse(config);
 }
 
+/************************************************************************
+ *
+ *    HELPERS
+ *
+ ************************************************************************/
+
 // Validate conditions that check multiple different config options simultaneously
 function validateStoreConfig(config: z.output<typeof StoreConfigUnrefined>, ctx: RefinementCtx) {
   // Local table variables must be unique within the table
@@ -138,37 +243,72 @@ function validateStoreConfig(config: z.output<typeof StoreConfigUnrefined>, ctx:
   }
   // Global names must be unique
   const tableNames = Object.keys(config.tables);
-  const userTypeNames = Object.keys(config.userTypes.enums);
+  const staticUserTypeNames = Object.keys(config.enums);
+  const userTypeNames = staticUserTypeNames;
   const globalNames = [...tableNames, ...userTypeNames];
   const duplicateGlobalNames = getDuplicates(globalNames);
   if (duplicateGlobalNames.length > 0) {
     ctx.addIssue({
       code: ZodIssueCode.custom,
-      message: `Table and enum names must be globally unique: ${duplicateGlobalNames.join(", ")}`,
+      message: `Table, enum names must be globally unique: ${duplicateGlobalNames.join(", ")}`,
     });
   }
   // User types must exist
   for (const table of Object.values(config.tables)) {
     for (const primaryKeyType of Object.values(table.primaryKeys)) {
-      validateIfUserType(userTypeNames, primaryKeyType, ctx);
+      validateStaticAbiOrUserType(staticUserTypeNames, primaryKeyType, ctx);
     }
     for (const fieldType of Object.values(table.schema)) {
-      validateIfUserType(userTypeNames, fieldType, ctx);
+      validateAbiOrUserType(userTypeNames, staticUserTypeNames, fieldType, ctx);
     }
   }
 }
 
-function validateIfUserType(
+function validateAbiOrUserType(
   userTypeNames: string[],
-  type: z.output<typeof FieldData> | z.output<typeof PrimaryKey>,
+  staticUserTypeNames: string[],
+  type: string,
   ctx: RefinementCtx
 ) {
-  if (typeof type === "string" && !userTypeNames.includes(type)) {
+  if (!(AbiTypes as string[]).includes(type) && !userTypeNames.includes(type)) {
+    const staticArray = parseStaticArray(type);
+    if (staticArray) {
+      validateStaticArray(staticUserTypeNames, staticArray.elementType, staticArray.staticLength, ctx);
+    } else {
+      ctx.addIssue({
+        code: ZodIssueCode.custom,
+        message: `${type} is not a valid abi type, and is not defined in userTypes`,
+      });
+    }
+  }
+}
+
+function validateStaticAbiOrUserType(staticUserTypeNames: string[], type: string, ctx: RefinementCtx) {
+  if (!(StaticAbiTypes as string[]).includes(type) && !staticUserTypeNames.includes(type)) {
     ctx.addIssue({
       code: ZodIssueCode.custom,
-      message: `User type ${type} is not defined in userTypes`,
+      message: `${type} is not a static type`,
     });
   }
 }
 
-type RequireKeys<T extends Record<string, unknown>, P extends string> = T & Required<Pick<T, P>>;
+function validateStaticArray(
+  staticUserTypeNames: string[],
+  elementType: string,
+  staticLength: number,
+  ctx: RefinementCtx
+) {
+  validateStaticAbiOrUserType(staticUserTypeNames, elementType, ctx);
+
+  if (staticLength === 0) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Static array length must not be 0`,
+    });
+  } else if (staticLength >= 2 ** 16) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Static array length must be less than 2**16`,
+    });
+  }
+}

package/src/config/validation.ts

@@ -136,3 +136,28 @@ export function getDuplicates<T>(array: T[]) {
   }
   return [...duplicates];
 }
+
+export function validateSelector(name: string, ctx: RefinementCtx) {
+  if (name.length > 16) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Selector must be <= 16 characters`,
+    });
+  }
+  if (!/^\w*$/.test(name)) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Selector must contain only alphanumeric & underscore characters`,
+    });
+  }
+}
+
+/** Returns null if the type does not look like a static array, otherwise element and length data */
+export function parseStaticArray(abiType: string) {
+  const matches = abiType.match(/^(\w+)\[(\d+)\]$/);
+  if (!matches) return null;
+  return {
+    elementType: matches[1],
+    staticLength: Number.parseInt(matches[2]),
+  };
+}

package/src/config/world/index.ts

@@ -0,0 +1,4 @@
+export * from "./loadWorldConfig.js";
+export * from "./parseWorldConfig.js";
+export * from "./resolveWorldConfig.js";
+export * from "./userTypes.js";

package/src/config/{loadWorldConfig.test-d.ts → world/loadWorldConfig.test-d.ts}

@@ -1,11 +1,11 @@
 import { describe, expectTypeOf } from "vitest";
 import { z } from "zod";
-import { WorldConfig, WorldUserConfig } from "./loadWorldConfig.js";
+import { zWorldConfig, WorldUserConfig } from "./index.js";
 
 describe("loadWorldConfig", () => {
   // Typecheck manual interfaces against zod
-  expectTypeOf<WorldUserConfig>().toEqualTypeOf<z.input<typeof WorldConfig>>();
+  expectTypeOf<WorldUserConfig>().toEqualTypeOf<z.input<typeof zWorldConfig>>();
   // type equality isn't deep for optionals
-  expectTypeOf<WorldUserConfig["overrideSystems"]>().toEqualTypeOf<z.input<typeof WorldConfig>["overrideSystems"]>();
+  expectTypeOf<WorldUserConfig["overrideSystems"]>().toEqualTypeOf<z.input<typeof zWorldConfig>["overrideSystems"]>();
   // TODO If more nested schemas are added, provide separate tests for them
 });

package/src/config/world/loadWorldConfig.ts

@@ -0,0 +1,26 @@
+import { ZodError } from "zod";
+import { fromZodErrorCustom } from "../../utils/errors.js";
+import { loadConfig } from "../loadConfig.js";
+import { zWorldConfig } from "./parseWorldConfig.js";
+import { resolveWorldConfig } from "./resolveWorldConfig.js";
+
+/**
+ * Loads and resolves the world config.
+ * @param configPath Path to load the config from. Defaults to "mud.config.mts" or "mud.config.ts"
+ * @param existingContracts Optional list of existing contract names to validate system names against. If not provided, no validation is performed. Contract names ending in `System` will be added to the config with default values.
+ * @returns Promise of ResolvedWorldConfig object
+ */
+export async function loadWorldConfig(configPath?: string, existingContracts?: string[]) {
+  const config = await loadConfig(configPath);
+
+  try {
+    const parsedConfig = zWorldConfig.parse(config);
+    return resolveWorldConfig(parsedConfig, existingContracts);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw fromZodErrorCustom(error, "WorldConfig Validation Error");
+    } else {
+      throw error;
+    }
+  }
+}

package/src/config/world/parseWorldConfig.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { zEthereumAddress, zObjectName, zSelector } from "../commonSchemas.js";
+import { DynamicResolutionType } from "../dynamicResolution.js";
+
+const zSystemName = zObjectName;
+const zModuleName = zObjectName;
+const zSystemAccessList = z.array(zSystemName.or(zEthereumAddress)).default([]);
+
+// The system config is a combination of a fileSelector config and access config
+const zSystemConfig = z.intersection(
+  z.object({
+    fileSelector: zSelector,
+    registerFunctionSelectors: z.boolean().default(true),
+  }),
+  z.discriminatedUnion("openAccess", [
+    z.object({
+      openAccess: z.literal(true),
+    }),
+    z.object({
+      openAccess: z.literal(false),
+      accessList: zSystemAccessList,
+    }),
+  ])
+);
+
+const zValueWithType = z.object({
+  value: z.union([z.string(), z.number(), z.instanceof(Uint8Array)]),
+  type: z.string(),
+});
+const zDynamicResolution = z.object({ type: z.nativeEnum(DynamicResolutionType), input: z.string() });
+
+const zModuleConfig = z.object({
+  name: zModuleName,
+  root: z.boolean().default(false),
+  args: z.array(z.union([zValueWithType, zDynamicResolution])).default([]),
+});
+
+// The parsed world config is the result of parsing the user config
+export const zWorldConfig = z.object({
+  namespace: zSelector.default(""),
+  worldContractName: z.string().optional(),
+  overrideSystems: z.record(zSystemName, zSystemConfig).default({}),
+  excludeSystems: z.array(zSystemName).default([]),
+  postDeployScript: z.string().default("PostDeploy"),
+  deploysDirectory: z.string().default("./deploys"),
+  worldgenDirectory: z.string().default("world"),
+  worldImportPath: z.string().default("@latticexyz/world/src/"),
+  modules: z.array(zModuleConfig).default([]),
+});
+
+export async function parseWorldConfig(config: unknown) {
+  return zWorldConfig.parse(config);
+}
+
+export type ParsedWorldConfig = z.output<typeof zWorldConfig>;

package/src/config/world/resolveWorldConfig.ts

@@ -0,0 +1,80 @@
+import { UnrecognizedSystemErrorFactory } from "../../utils/errors.js";
+import { ParsedWorldConfig } from "./parseWorldConfig.js";
+import { SystemUserConfig } from "./userTypes.js";
+
+export type ResolvedSystemConfig = ReturnType<typeof resolveSystemConfig>;
+
+export type ResolvedWorldConfig = ReturnType<typeof resolveWorldConfig>;
+
+/**
+ * Resolves the world config by combining the default and overridden system configs,
+ * filtering out excluded systems, validate system names refer to existing contracts, and
+ * splitting the access list into addresses and system names.
+ */
+export function resolveWorldConfig(config: ParsedWorldConfig, existingContracts?: string[]) {
+  // Include contract names ending in "System", but not the base "System" contract, and not Interfaces
+  const defaultSystemNames =
+    existingContracts?.filter((name) => name.endsWith("System") && name !== "System" && !name.match(/^I[A-Z]/)) ?? [];
+  const overriddenSystemNames = Object.keys(config.overrideSystems);
+
+  // Validate every key in overrideSystems refers to an existing system contract (and is not called "World")
+  if (existingContracts) {
+    for (const systemName of overriddenSystemNames) {
+      if (!existingContracts.includes(systemName) || systemName === "World") {
+        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName], systemName);
+      }
+    }
+  }
+
+  // Combine the default and overridden system names and filter out excluded systems
+  const systemNames = [...new Set([...defaultSystemNames, ...overriddenSystemNames])].filter(
+    (name) => !config.excludeSystems.includes(name)
+  );
+
+  // Resolve the config
+  const resolvedSystems: Record<string, ResolvedSystemConfig> = systemNames.reduce((acc, systemName) => {
+    return {
+      ...acc,
+      [systemName]: resolveSystemConfig(systemName, config.overrideSystems[systemName], existingContracts),
+    };
+  }, {});
+
+  const { overrideSystems, excludeSystems, ...otherConfig } = config;
+  return { ...otherConfig, systems: resolvedSystems };
+}
+
+/**
+ * Resolves the system config by combining the default and overridden system configs,
+ * @param systemName name of the system
+ * @param config optional SystemConfig object, if none is provided the default config is used
+ * @param existingContracts optional list of existing contract names, used to validate system names in the access list. If not provided, no validation is performed.
+ * @returns ResolvedSystemConfig object
+ * Default value for fileSelector is `systemName`
+ * Default value for registerFunctionSelectors is true
+ * Default value for openAccess is true
+ * Default value for accessListAddresses is []
+ * Default value for accessListSystems is []
+ */
+export function resolveSystemConfig(systemName: string, config?: SystemUserConfig, existingContracts?: string[]) {
+  const fileSelector = config?.fileSelector ?? systemName;
+  const registerFunctionSelectors = config?.registerFunctionSelectors ?? true;
+  const openAccess = config?.openAccess ?? true;
+  const accessListAddresses: string[] = [];
+  const accessListSystems: string[] = [];
+  const accessList = config && !config.openAccess ? config.accessList : [];
+
+  // Split the access list into addresses and system names
+  for (const accessListItem of accessList) {
+    if (accessListItem.startsWith("0x")) {
+      accessListAddresses.push(accessListItem);
+    } else {
+      // Validate every system refers to an existing system contract
+      if (existingContracts && !existingContracts.includes(accessListItem)) {
+        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName, "accessList"], accessListItem);
+      }
+      accessListSystems.push(accessListItem);
+    }
+  }
+
+  return { fileSelector, registerFunctionSelectors, openAccess, accessListAddresses, accessListSystems };
+}

package/src/config/world/userTypes.ts

@@ -0,0 +1,72 @@
+import { DynamicResolution } from "../dynamicResolution.js";
+
+// zod doesn't preserve doc comments
+export type SystemUserConfig =
+  | {
+      /** The full resource selector consists of namespace and fileSelector */
+      fileSelector?: string;
+      /**
+       * Register function selectors for the system in the World.
+       * Defaults to true.
+       * Note:
+       * - For root systems all World function selectors will correspond to the system's function selectors.
+       * - For non-root systems, the World function selectors will be <namespace>_<system>_<function>.
+       */
+      registerFunctionSelectors?: boolean;
+    } & (
+      | {
+          /** If openAccess is true, any address can call the system */
+          openAccess: true;
+        }
+      | {
+          /** If openAccess is false, only the addresses or systems in `access` can call the system */
+          openAccess: false;
+          /** An array of addresses or system names that can access the system */
+          accessList: string[];
+        }
+    );
+
+export type ValueWithType = {
+  value: string | number | Uint8Array;
+  type: string;
+};
+
+export type ModuleConfig = {
+  /** The name of the module */
+  name: string;
+  /** Should this module be installed as a root module? */
+  root?: boolean;
+  /** Arguments to be passed to the module's install method */
+  args?: (ValueWithType | DynamicResolution)[];
+};
+
+// zod doesn't preserve doc comments
+export interface WorldUserConfig {
+  /** The namespace to register tables and systems at. Defaults to the root namespace (empty string) */
+  namespace?: string;
+  /** The name of the World contract to deploy. If no name is provided, a vanilla World is deployed */
+  worldContractName?: string;
+  /**
+   * Contracts named *System will be deployed by default
+   * as public systems at `namespace/ContractName`, unless overridden
+   *
+   * The key is the system name (capitalized).
+   * The value is a SystemConfig object.
+   */
+  overrideSystems?: Record<string, SystemUserConfig>;
+  /** Systems to exclude from automatic deployment */
+  excludeSystems?: string[];
+  /**
+   * Script to execute after the deployment is complete (Default "PostDeploy").
+   * Script must be placed in the forge scripts directory (see foundry.toml) and have a ".s.sol" extension.
+   */
+  postDeployScript?: string;
+  /** Directory to write the deployment info to (Default "./deploys") */
+  deploysDirectory?: string;
+  /** Directory to output system and world interfaces of `worldgen` (Default "world") */
+  worldgenDirectory?: string;
+  /** Path for world package imports. Default is "@latticexyz/world/src/" */
+  worldImportPath?: string;
+  /** Modules to in the World */
+  modules?: ModuleConfig[];
+}