@latticexyz/cli 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/{chunk-J4DJQNIC.js → chunk-SKNB74MT.js}

@@ -1,259 +1,3 @@
-// src/config/commonSchemas.ts
-import { z } from "zod";
-
-// src/config/validation.ts
-import { ethers } from "ethers";
-import { ZodIssueCode } from "zod";
-function validateName(name, ctx) {
-  if (!/^\w+$/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must contain only alphanumeric & underscore characters`
-    });
-  }
-}
-function validateCapitalizedName(name, ctx) {
-  validateName(name, ctx);
-  if (!/^[A-Z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a capital letter`
-    });
-  }
-}
-function validateUncapitalizedName(name, ctx) {
-  validateName(name, ctx);
-  if (!/^[a-z]/.test(name)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Name must start with a lowercase letter`
-    });
-  }
-}
-function validateEnum(members, ctx) {
-  if (members.length === 0) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Enum must not be empty`
-    });
-  }
-  if (members.length >= 256) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Length of enum must be < 256`
-    });
-  }
-  const duplicates = getDuplicates(members);
-  if (duplicates.length > 0) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Enum must not have duplicate names for: ${duplicates.join(", ")}`
-    });
-  }
-}
-function _factoryForValidateRoute(requireNonEmpty, requireSingleLevel) {
-  return (route, ctx) => {
-    if (route === "") {
-      if (requireNonEmpty) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not be empty`
-        });
-      }
-      return;
-    }
-    if (route[0] !== "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must start with "/"`
-      });
-    }
-    if (route[route.length - 1] === "/") {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must not end with "/"`
-      });
-    }
-    const parts = route.split("/");
-    if (requireSingleLevel && parts.length > 2) {
-      ctx.addIssue({
-        code: ZodIssueCode.custom,
-        message: `Route must only have one level (e.g. "/foo")`
-      });
-    }
-    for (let i = 1; i < parts.length; i++) {
-      if (parts[i] === "") {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must not contain empty route fragments (e.g. "//")`
-        });
-      }
-      if (!/^\w+$/.test(parts[i])) {
-        ctx.addIssue({
-          code: ZodIssueCode.custom,
-          message: `Route must contain only alphanumeric & underscore characters`
-        });
-      }
-    }
-  };
-}
-var validateRoute = _factoryForValidateRoute(true, false);
-var validateBaseRoute = _factoryForValidateRoute(false, false);
-var validateSingleLevelRoute = _factoryForValidateRoute(true, true);
-function validateEthereumAddress(address, ctx) {
-  if (!ethers.utils.isAddress(address)) {
-    ctx.addIssue({
-      code: ZodIssueCode.custom,
-      message: `Address must be a valid Ethereum address`
-    });
-  }
-}
-function getDuplicates(array) {
-  const checked = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const element of array) {
-    if (checked.has(element)) {
-      duplicates.add(element);
-    }
-    checked.add(element);
-  }
-  return [...duplicates];
-}
-function validateSelector(name, ctx) {
-  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`
-    });
-  }
-}
-function parseStaticArray(abiType) {
-  const matches = abiType.match(/^(\w+)\[(\d+)\]$/);
-  if (!matches)
-    return null;
-  return {
-    elementType: matches[1],
-    staticLength: Number.parseInt(matches[2])
-  };
-}
-
-// src/config/commonSchemas.ts
-var zObjectName = z.string().superRefine(validateCapitalizedName);
-var zValueName = z.string().superRefine(validateUncapitalizedName);
-var zAnyCaseName = z.string().superRefine(validateName);
-var zUserEnum = z.array(zObjectName).superRefine(validateEnum);
-var zOrdinaryRoute = z.string().superRefine(validateRoute);
-var zSingleLevelRoute = z.string().superRefine(validateSingleLevelRoute);
-var zBaseRoute = z.string().superRefine(validateBaseRoute);
-var zEthereumAddress = z.string().superRefine(validateEthereumAddress);
-var zSelector = z.string().superRefine(validateSelector);
-
-// src/config/loadConfig.ts
-import { findUp } from "find-up";
-import path from "path";
-
-// src/utils/errors.ts
-import chalk from "chalk";
-import { z as z2, ZodError, ZodIssueCode as ZodIssueCode2 } from "zod";
-import { fromZodError, ValidationError } from "zod-validation-error";
-function fromZodErrorCustom(error, prefix) {
-  return fromZodError(error, {
-    prefix: chalk.red(prefix),
-    prefixSeparator: "\n- ",
-    issueSeparator: "\n- "
-  });
-}
-var NotInsideProjectError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "NotInsideProjectError";
-    this.message = "You are not inside a MUD project";
-  }
-};
-var NotESMConfigError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "NotESMConfigError";
-    this.message = "MUD config must be an ES module";
-  }
-};
-var MUDError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "MUDError";
-  }
-};
-function UnrecognizedSystemErrorFactory(path2, systemName) {
-  return new z2.ZodError([{ code: ZodIssueCode2.custom, path: path2, message: `Unrecognized system: "${systemName}"` }]);
-}
-function logError(error) {
-  if (error instanceof ValidationError) {
-    console.log(chalk.redBright(error.message));
-  } else if (error instanceof ZodError) {
-    const validationError = fromZodError(error, {
-      prefixSeparator: "\n- ",
-      issueSeparator: "\n- "
-    });
-    console.log(chalk.redBright(validationError.message));
-  } else if (error instanceof NotInsideProjectError) {
-    console.log(chalk.red(error.message));
-    console.log("");
-    console.log(chalk.blue(`To learn more about MUD's configuration, please go to https://mud.dev/packages/cli/`));
-  } else if (error instanceof NotESMConfigError) {
-    console.log(chalk.red(error.message));
-    console.log("");
-    console.log(
-      chalk.blue(`Please name your config file \`mud.config.mts\`, or use \`type: "module"\` in package.json`)
-    );
-  } else if (error instanceof MUDError) {
-    console.log(chalk.red(error));
-  } else {
-    console.log(error);
-  }
-}
-
-// src/config/loadConfig.ts
-var configFiles = ["mud.config.ts", "mud.config.mts"];
-async function loadConfig(configPath) {
-  configPath = await resolveConfigPath(configPath);
-  try {
-    return (await import(configPath)).default;
-  } catch (error) {
-    if (error instanceof SyntaxError && error.message === "Cannot use import statement outside a module") {
-      throw new NotESMConfigError();
-    } else {
-      throw error;
-    }
-  }
-}
-async function resolveConfigPath(configPath) {
-  if (configPath === void 0) {
-    configPath = await getUserConfigPath();
-  } else {
-    if (!path.isAbsolute(configPath)) {
-      configPath = path.join(process.cwd(), configPath);
-      configPath = path.normalize(configPath);
-    }
-  }
-  return configPath;
-}
-async function getUserConfigPath() {
-  const tsConfigPath = await findUp(configFiles);
-  if (tsConfigPath === void 0) {
-    throw new NotInsideProjectError();
-  }
-  return tsConfigPath;
-}
-
-// src/config/loadStoreConfig.ts
-import { ZodError as ZodError2 } from "zod";
-
 // ../schema-type/src/typescript/SchemaType.ts
 var SchemaType = /* @__PURE__ */ ((SchemaType2) => {
   SchemaType2[SchemaType2["UINT8"] = 0] = "UINT8";
@@ -821,345 +565,162 @@ var StaticAbiTypes = AbiTypes.filter(
   (abiType) => getStaticByteLength(AbiTypeToSchemaType[abiType]) > 0
 );
 
-// src/config/parseStoreConfig.ts
-import { z as z3, ZodIssueCode as ZodIssueCode3 } from "zod";
-var zTableName = zObjectName;
-var zKeyName = zValueName;
-var zColumnName = zValueName;
-var zUserEnumName = zObjectName;
-var zFieldData = z3.string();
-var zPrimaryKey = z3.string();
-var zPrimaryKeys = z3.record(zKeyName, zPrimaryKey).default({ key: "bytes32" });
-var zFullSchemaConfig = z3.record(zColumnName, zFieldData).refine((arg) => Object.keys(arg).length > 0, "Table schema may not be empty");
-var zShorthandSchemaConfig = zFieldData.transform((fieldData) => {
-  return zFullSchemaConfig.parse({
-    value: fieldData
-  });
-});
-var zSchemaConfig = zFullSchemaConfig.or(zShorthandSchemaConfig);
-var zFullTableConfig = z3.object({
-  directory: z3.string().default("tables"),
-  fileSelector: zSelector.optional(),
-  tableIdArgument: z3.boolean().default(false),
-  storeArgument: z3.boolean().default(false),
-  primaryKeys: zPrimaryKeys,
-  schema: zSchemaConfig,
-  dataStruct: z3.boolean().optional()
-}).transform((arg) => {
-  if (Object.keys(arg.schema).length === 1) {
-    arg.dataStruct ??= false;
-  } else {
-    arg.dataStruct ??= true;
-  }
-  return arg;
-});
-var zShorthandTableConfig = zFieldData.transform((fieldData) => {
-  return zFullTableConfig.parse({
-    schema: {
-      value: fieldData
-    }
-  });
-});
-var zTableConfig = zFullTableConfig.or(zShorthandTableConfig);
-var zTablesConfig = z3.record(zTableName, zTableConfig).transform((tables) => {
-  for (const tableName of Object.keys(tables)) {
-    const table = tables[tableName];
-    table.fileSelector ??= tableName;
-    tables[tableName] = table;
-  }
-  return tables;
-});
-var zEnumsConfig = z3.object({
-  enums: z3.record(zUserEnumName, zUserEnum).default({})
-});
-function storeConfig(config) {
-  return config;
-}
-var StoreConfigUnrefined = z3.object({
-  namespace: zSelector.default(""),
-  storeImportPath: z3.string().default("@latticexyz/store/src/"),
-  tables: zTablesConfig,
-  userTypesPath: z3.string().default("Types")
-}).merge(zEnumsConfig);
-var zStoreConfig = StoreConfigUnrefined.superRefine(validateStoreConfig);
-function parseStoreConfig(config) {
-  return zStoreConfig.parse(config);
-}
-function validateStoreConfig(config, ctx) {
-  for (const table of Object.values(config.tables)) {
-    const primaryKeyNames = Object.keys(table.primaryKeys);
-    const fieldNames = Object.keys(table.schema);
-    const duplicateVariableNames = getDuplicates([...primaryKeyNames, ...fieldNames]);
-    if (duplicateVariableNames.length > 0) {
-      ctx.addIssue({
-        code: ZodIssueCode3.custom,
-        message: `Field and primary key names within one table must be unique: ${duplicateVariableNames.join(", ")}`
-      });
-    }
-  }
-  const tableNames = Object.keys(config.tables);
-  const staticUserTypeNames = Object.keys(config.enums);
-  const userTypeNames = staticUserTypeNames;
-  const globalNames = [...tableNames, ...userTypeNames];
-  const duplicateGlobalNames = getDuplicates(globalNames);
-  if (duplicateGlobalNames.length > 0) {
-    ctx.addIssue({
-      code: ZodIssueCode3.custom,
-      message: `Table, enum names must be globally unique: ${duplicateGlobalNames.join(", ")}`
-    });
-  }
-  for (const table of Object.values(config.tables)) {
-    for (const primaryKeyType of Object.values(table.primaryKeys)) {
-      validateStaticAbiOrUserType(staticUserTypeNames, primaryKeyType, ctx);
-    }
-    for (const fieldType of Object.values(table.schema)) {
-      validateAbiOrUserType(userTypeNames, staticUserTypeNames, fieldType, ctx);
-    }
+// src/render-solidity/userType.ts
+import { parseStaticArray } from "@latticexyz/config";
+function resolveAbiOrUserType(abiOrUserType, config) {
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    const schemaType = AbiTypeToSchemaType[abiOrUserType];
+    return {
+      schemaType,
+      renderTableType: getSchemaTypeInfo(schemaType)
+    };
   }
-}
-function validateAbiOrUserType(userTypeNames, staticUserTypeNames, type, ctx) {
-  if (!AbiTypes.includes(type) && !userTypeNames.includes(type)) {
-    const staticArray = parseStaticArray(type);
-    if (staticArray) {
-      validateStaticArray(staticUserTypeNames, staticArray.elementType, staticArray.staticLength, ctx);
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    if (staticArray.elementType in AbiTypeToSchemaType) {
+      return getStaticArrayTypeInfo(abiOrUserType, staticArray.elementType, staticArray.staticLength);
     } else {
-      ctx.addIssue({
-        code: ZodIssueCode3.custom,
-        message: `${type} is not a valid abi type, and is not defined in userTypes`
-      });
+      throw new Error("Static arrays of user types are not supported");
     }
   }
+  return getUserTypeInfo(abiOrUserType, config);
 }
-function validateStaticAbiOrUserType(staticUserTypeNames, type, ctx) {
-  if (!StaticAbiTypes.includes(type) && !staticUserTypeNames.includes(type)) {
-    ctx.addIssue({
-      code: ZodIssueCode3.custom,
-      message: `${type} is not a static type`
-    });
+function importForAbiOrUserType(abiOrUserType, usedInDirectory, config) {
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    return void 0;
   }
-}
-function validateStaticArray(staticUserTypeNames, elementType, staticLength, ctx) {
-  validateStaticAbiOrUserType(staticUserTypeNames, elementType, ctx);
-  if (staticLength === 0) {
-    ctx.addIssue({
-      code: ZodIssueCode3.custom,
-      message: `Static array length must not be 0`
-    });
-  } else if (staticLength >= 2 ** 16) {
-    ctx.addIssue({
-      code: ZodIssueCode3.custom,
-      message: `Static array length must be less than 2**16`
-    });
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    return void 0;
   }
-}
-
-// src/config/loadStoreConfig.ts
-async function loadStoreConfig(configPath) {
-  const config = await loadConfig(configPath);
-  try {
-    return parseStoreConfig(config);
-  } catch (error) {
-    if (error instanceof ZodError2) {
-      throw fromZodErrorCustom(error, "StoreConfig Validation Error");
-    } else {
-      throw error;
-    }
-  }
-}
-
-// src/config/world/loadWorldConfig.ts
-import { ZodError as ZodError3 } from "zod";
-
-// src/config/world/parseWorldConfig.ts
-import { z as z4 } from "zod";
-
-// src/config/dynamicResolution.ts
-var DynamicResolutionType = /* @__PURE__ */ ((DynamicResolutionType2) => {
-  DynamicResolutionType2[DynamicResolutionType2["TABLE_ID"] = 0] = "TABLE_ID";
-  DynamicResolutionType2[DynamicResolutionType2["SYSTEM_ADDRESS"] = 1] = "SYSTEM_ADDRESS";
-  return DynamicResolutionType2;
-})(DynamicResolutionType || {});
-function resolveTableId(tableName) {
   return {
-    type: 0 /* TABLE_ID */,
-    input: tableName
+    symbol: abiOrUserType,
+    fromPath: config.userTypesPath + ".sol",
+    usedInPath: usedInDirectory
   };
 }
-function isDynamicResolution(value) {
-  return typeof value === "object" && value !== null && "type" in value && "input" in value;
-}
-async function resolveWithContext(unresolved, context) {
-  if (!isDynamicResolution(unresolved))
-    return unresolved;
-  let resolved = void 0;
-  if (unresolved.type === 0 /* TABLE_ID */) {
-    const tableId = context.tableIds?.[unresolved.input];
-    resolved = tableId && { value: tableId, type: "bytes32" };
-  }
-  if (resolved === void 0) {
-    throw new MUDError(`Could not resolve dynamic resolution: 
-${JSON.stringify(unresolved, null, 2)}`);
-  }
-  return resolved;
-}
-
-// src/config/world/parseWorldConfig.ts
-var zSystemName = zObjectName;
-var zModuleName = zObjectName;
-var zSystemAccessList = z4.array(zSystemName.or(zEthereumAddress)).default([]);
-var zSystemConfig = z4.intersection(
-  z4.object({
-    fileSelector: zSelector,
-    registerFunctionSelectors: z4.boolean().default(true)
-  }),
-  z4.discriminatedUnion("openAccess", [
-    z4.object({
-      openAccess: z4.literal(true)
-    }),
-    z4.object({
-      openAccess: z4.literal(false),
-      accessList: zSystemAccessList
-    })
-  ])
-);
-var zValueWithType = z4.object({
-  value: z4.union([z4.string(), z4.number(), z4.instanceof(Uint8Array)]),
-  type: z4.string()
-});
-var zDynamicResolution = z4.object({ type: z4.nativeEnum(DynamicResolutionType), input: z4.string() });
-var zModuleConfig = z4.object({
-  name: zModuleName,
-  root: z4.boolean().default(false),
-  args: z4.array(z4.union([zValueWithType, zDynamicResolution])).default([])
-});
-var zWorldConfig = z4.object({
-  namespace: zSelector.default(""),
-  worldContractName: z4.string().optional(),
-  overrideSystems: z4.record(zSystemName, zSystemConfig).default({}),
-  excludeSystems: z4.array(zSystemName).default([]),
-  postDeployScript: z4.string().default("PostDeploy"),
-  deploysDirectory: z4.string().default("./deploys"),
-  worldgenDirectory: z4.string().default("world"),
-  worldImportPath: z4.string().default("@latticexyz/world/src/"),
-  modules: z4.array(zModuleConfig).default([])
-});
-async function parseWorldConfig(config) {
-  return zWorldConfig.parse(config);
+function getSchemaTypeInfo(schemaType) {
+  const staticByteLength = getStaticByteLength(schemaType);
+  const isDynamic = staticByteLength === 0;
+  const typeId = SchemaTypeToAbiType[schemaType];
+  return {
+    typeId,
+    typeWithLocation: isDynamic ? typeId + " memory" : typeId,
+    enumName: SchemaType[schemaType],
+    staticByteLength,
+    isDynamic,
+    typeWrap: "",
+    typeUnwrap: "",
+    internalTypeId: typeId
+  };
 }
-
-// src/config/world/resolveWorldConfig.ts
-function resolveWorldConfig(config, existingContracts) {
-  const defaultSystemNames = existingContracts?.filter((name) => name.endsWith("System") && name !== "System" && !name.match(/^I[A-Z]/)) ?? [];
-  const overriddenSystemNames = Object.keys(config.overrideSystems);
-  if (existingContracts) {
-    for (const systemName of overriddenSystemNames) {
-      if (!existingContracts.includes(systemName) || systemName === "World") {
-        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName], systemName);
-      }
-    }
-  }
-  const systemNames = [.../* @__PURE__ */ new Set([...defaultSystemNames, ...overriddenSystemNames])].filter(
-    (name) => !config.excludeSystems.includes(name)
-  );
-  const resolvedSystems = systemNames.reduce((acc, systemName) => {
+function getUserTypeInfo(userType, config) {
+  if (userType in config.enums) {
+    const schemaType = 0 /* UINT8 */;
+    const staticByteLength = getStaticByteLength(schemaType);
+    const isDynamic = staticByteLength === 0;
+    const typeId = userType;
     return {
-      ...acc,
-      [systemName]: resolveSystemConfig(systemName, config.overrideSystems[systemName], existingContracts)
+      schemaType,
+      renderTableType: {
+        typeId,
+        typeWithLocation: typeId,
+        enumName: SchemaType[schemaType],
+        staticByteLength,
+        isDynamic,
+        typeWrap: `${userType}`,
+        typeUnwrap: `uint8`,
+        internalTypeId: `${SchemaTypeToAbiType[schemaType]}`
+      }
     };
-  }, {});
-  const { overrideSystems, excludeSystems, ...otherConfig } = config;
-  return { ...otherConfig, systems: resolvedSystems };
+  }
+  throw new Error(`User type "${userType}" does not exist`);
 }
-function resolveSystemConfig(systemName, config, existingContracts) {
-  const fileSelector = config?.fileSelector ?? systemName;
-  const registerFunctionSelectors = config?.registerFunctionSelectors ?? true;
-  const openAccess = config?.openAccess ?? true;
-  const accessListAddresses = [];
-  const accessListSystems = [];
-  const accessList = config && !config.openAccess ? config.accessList : [];
-  for (const accessListItem of accessList) {
-    if (accessListItem.startsWith("0x")) {
-      accessListAddresses.push(accessListItem);
-    } else {
-      if (existingContracts && !existingContracts.includes(accessListItem)) {
-        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName, "accessList"], accessListItem);
-      }
-      accessListSystems.push(accessListItem);
+function getStaticArrayTypeInfo(abiType, elementType, staticLength) {
+  const internalTypeId = elementType + "[]";
+  const schemaType = AbiTypeToSchemaType[internalTypeId];
+  return {
+    schemaType,
+    renderTableType: {
+      typeId: abiType,
+      typeWithLocation: `${abiType} memory`,
+      enumName: SchemaType[schemaType],
+      staticByteLength: 0,
+      isDynamic: true,
+      typeWrap: `toStaticArray_${elementType}_${staticLength}`,
+      typeUnwrap: `fromStaticArray_${elementType}_${staticLength}`,
+      typeWrappingData: {
+        kind: "staticArray",
+        elementType,
+        staticLength
+      },
+      internalTypeId
     }
-  }
-  return { fileSelector, registerFunctionSelectors, openAccess, accessListAddresses, accessListSystems };
+  };
 }
 
-// src/config/world/loadWorldConfig.ts
-async function loadWorldConfig(configPath, existingContracts) {
-  const config = await loadConfig(configPath);
+// src/utils/format.ts
+import chalk from "chalk";
+import prettier from "prettier";
+import prettierPluginSolidity from "prettier-plugin-solidity";
+async function formatSolidity(content, prettierConfigPath) {
+  let config;
+  if (prettierConfigPath) {
+    config = await prettier.resolveConfig(prettierConfigPath);
+  }
   try {
-    const parsedConfig = zWorldConfig.parse(config);
-    return resolveWorldConfig(parsedConfig, existingContracts);
+    return prettier.format(content, {
+      plugins: [prettierPluginSolidity],
+      parser: "solidity-parse",
+      printWidth: 120,
+      semi: true,
+      tabWidth: 2,
+      useTabs: false,
+      bracketSpacing: true,
+      ...config
+    });
   } catch (error) {
-    if (error instanceof ZodError3) {
-      throw fromZodErrorCustom(error, "WorldConfig Validation Error");
+    let message;
+    if (error instanceof Error) {
+      message = error.message;
     } else {
-      throw error;
+      message = error;
     }
+    console.log(chalk.yellow(`Error during output formatting: ${message}`));
+    return content;
   }
 }
+async function formatTypescript(content) {
+  return prettier.format(content, {
+    parser: "typescript"
+  });
+}
 
-// src/config/index.ts
-function mudConfig(config) {
-  return config;
+// src/utils/formatAndWrite.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+async function formatAndWriteSolidity(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatSolidity(output);
+  mkdirSync(dirname(fullOutputPath), { recursive: true });
+  writeFileSync(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
+}
+async function formatAndWriteTypescript(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatTypescript(output);
+  mkdirSync(dirname(fullOutputPath), { recursive: true });
+  writeFileSync(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
 }
 
 export {
-  fromZodErrorCustom,
-  NotInsideProjectError,
-  NotESMConfigError,
-  MUDError,
-  UnrecognizedSystemErrorFactory,
-  logError,
-  loadConfig,
-  SchemaType,
-  getStaticByteLength,
   encodeSchema,
   SchemaTypeArrayToElement,
-  SchemaTypeToAbiType,
-  AbiTypeToSchemaType,
-  validateName,
-  validateCapitalizedName,
-  validateUncapitalizedName,
-  validateEnum,
-  validateRoute,
-  validateBaseRoute,
-  validateSingleLevelRoute,
-  validateEthereumAddress,
-  getDuplicates,
-  validateSelector,
-  parseStaticArray,
-  zObjectName,
-  zValueName,
-  zAnyCaseName,
-  zUserEnum,
-  zOrdinaryRoute,
-  zSingleLevelRoute,
-  zBaseRoute,
-  zEthereumAddress,
-  zSelector,
-  zSchemaConfig,
-  zTableConfig,
-  zTablesConfig,
-  zEnumsConfig,
-  storeConfig,
-  zStoreConfig,
-  parseStoreConfig,
-  loadStoreConfig,
-  DynamicResolutionType,
-  resolveTableId,
-  isDynamicResolution,
-  resolveWithContext,
-  zWorldConfig,
-  parseWorldConfig,
-  resolveWorldConfig,
-  resolveSystemConfig,
-  loadWorldConfig,
-  mudConfig
+  resolveAbiOrUserType,
+  importForAbiOrUserType,
+  getSchemaTypeInfo,
+  getUserTypeInfo,
+  formatSolidity,
+  formatTypescript,
+  formatAndWriteSolidity,
+  formatAndWriteTypescript
 };