diff

Cargo.toml

@@ -10,7 +10,7 @@ edition = "2021"
 anyhow = "1.0.75"
 clap = { version = "4.4.2", features = ["derive"] }
 futures = "0.3.30"
-git2 = "0.20.0"
+gix = "0.72.1"
 lazy-regex = "3.1.0"
 rbx_asset = { path = "rbx_asset" }
 rbx_binary = "1.0.0"

rbx_asset/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rbx_asset"
-version = "0.4.10"
+version = "0.4.8"
 edition = "2021"
 publish = ["strafesnet"]
 repository = "https://git.itzana.me/StrafesNET/asset-tool"
@@ -11,21 +11,14 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-default = ["gzip", "default-tls"]
+default = ["gzip"]
 gzip = ["dep:flate2"]
 
-default-tls = ["reqwest/default-tls"]
-rustls-tls = ["reqwest/rustls-tls"]
-
 [dependencies]
 bytes = "1.10.1"
 chrono = { version = "0.4.38", features = ["serde"] }
 flate2 = { version = "1.0.29", optional = true }
-reqwest = { version = "0.12.4", features = [
-	"json", "multipart",
-	# default features
-	"charset", "http2", "system-proxy"
-], default-features = false }
+reqwest = { version = "0.12.4", features = ["json","multipart"] }
 serde = { version = "1.0.199", features = ["derive"] }
 serde_json = "1.0.111"
 url = "2.5.0"

rbx_asset/src/cloud.rs

@@ -1,4 +1,3 @@
-use crate::body::{Binary,ContentType,Json};
 use crate::util::{serialize_u64,deserialize_u64,response_ok};
 use crate::types::{ResponseError,MaybeGzippedBytes};
 
@@ -118,8 +117,8 @@ impl std::fmt::Display for UpdateError{
 }
 impl std::error::Error for UpdateError{}
 
-struct GetAssetOperationRequest<'a>{
-	operation_id:&'a str,
+struct GetAssetOperationRequest{
+	operation_id:String,
 }
 pub struct GetAssetLatestRequest{
 	pub asset_id:u64,
@@ -173,7 +172,7 @@ pub struct GetAssetVersionRequest{
 }
 #[derive(Debug)]
 pub enum GetError{
-	Parse(url::ParseError),
+	ParseError(url::ParseError),
 	Response(ResponseError),
 	Reqwest(reqwest::Error),
 }
@@ -321,119 +320,13 @@ impl RobloxOperation{
 	pub async fn try_get_reponse(&self,context:&Context)->Result<serde_json::Value,OperationError>{
 		context.get_asset_operation(GetAssetOperationRequest{
 			operation_id:self.operation_id()
-				.ok_or(OperationError::NoOperationId)?,
+				.ok_or(OperationError::NoOperationId)?
+				.to_owned(),
 		}).await.map_err(OperationError::Get)?
 		.response.ok_or(OperationError::NotDone)
 	}
 }
 
-#[derive(Debug)]
-pub enum LuauSessionError{
-	Get(GetError),
-	Unspecified,
-	NotDone,
-	NoOutput,
-	NoError,
-}
-impl std::fmt::Display for LuauSessionError{
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for LuauSessionError{}
-#[derive(Debug,serde::Serialize)]
-#[expect(nonstandard_style)]
-pub struct LuauSessionCreate<'a>{
-	pub script:&'a str,
-	#[serde(skip_serializing_if="Option::is_none")]
-	pub user:Option<&'a str>,
-	#[serde(skip_serializing_if="Option::is_none")]
-	pub timeout:Option<&'a str>,
-	#[serde(skip_serializing_if="Option::is_none")]
-	pub binaryInput:Option<&'a str>,
-	#[serde(skip_serializing_if="Option::is_none")]
-	pub enableBinaryOutput:Option<bool>,
-	#[serde(skip_serializing_if="Option::is_none")]
-	pub binaryOutputUri:Option<&'a str>,
-}
-#[derive(Debug,serde::Deserialize)]
-#[expect(nonstandard_style)]
-pub enum LuauSessionState{
-	STATE_UNSPECIFIED,
-	PROCESSING,
-	COMPLETE,
-	FAILED,
-}
-#[derive(Debug,serde::Deserialize)]
-pub struct LuauError{
-	pub code:String,
-	pub message:String,
-}
-#[derive(Debug,serde::Deserialize)]
-pub struct LuauResults{
-	pub results:Vec<serde_json::Value>,
-}
-#[derive(Debug,serde::Deserialize)]
-#[expect(nonstandard_style)]
-pub struct LuauSessionResponse{
-	path:String,
-	#[serde(deserialize_with="deserialize_u64")]
-	pub user:u64,
-	pub state:LuauSessionState,
-	pub script:String,
-	pub error:Option<LuauError>,
-	pub output:Option<LuauResults>,
-	pub binaryInput:String,
-	pub enableBinaryOutput:bool,
-	pub binaryOutputUri:String,
-}
-impl LuauSessionResponse{
-	pub fn path(&self)->&str{
-		&self.path
-	}
-	pub async fn try_get_result(&self,context:&Context)->Result<Result<LuauResults,LuauError>,LuauSessionError>{
-		let response=context.get_luau_session(self).await.map_err(LuauSessionError::Get)?;
-		match response.state{
-			LuauSessionState::STATE_UNSPECIFIED=>Err(LuauSessionError::Unspecified),
-			LuauSessionState::PROCESSING=>Err(LuauSessionError::NotDone),
-			LuauSessionState::COMPLETE=>Ok(Ok(response.output.ok_or(LuauSessionError::NoOutput)?)),
-			LuauSessionState::FAILED=>Ok(Err(response.error.ok_or(LuauSessionError::NoError)?)),
-		}
-	}
-}
-pub trait AsSessionPath{
-	fn into_session_path(&self)->impl AsRef<str>;
-}
-impl AsSessionPath for LuauSessionResponse{
-	fn into_session_path(&self)->impl AsRef<str>{
-		&self.path
-	}
-}
-pub struct LuauSessionLatestRequest{
-	pub universe_id:u64,
-	pub place_id:u64,
-}
-impl AsSessionPath for LuauSessionLatestRequest{
-	fn into_session_path(&self)->impl AsRef<str>{
-		let universe_id=self.universe_id;
-		let place_id=self.place_id;
-		format!("universes/{universe_id}/places/{place_id}/luau-execution-session-tasks")
-	}
-}
-pub struct LuauSessionVersionRequest{
-	pub universe_id:u64,
-	pub place_id:u64,
-	pub version_id:u64,
-}
-impl AsSessionPath for LuauSessionVersionRequest{
-	fn into_session_path(&self)->impl AsRef<str>{
-		let universe_id=self.universe_id;
-		let place_id=self.place_id;
-		let version_id=self.version_id;
-		format!("universes/{universe_id}/places/{place_id}/versions/{version_id}/luau-execution-session-tasks")
-	}
-}
-
 #[derive(Clone)]
 pub struct ApiKey(String);
 impl ApiKey{
@@ -463,10 +356,9 @@ impl Context{
 		.header("x-api-key",self.api_key.as_str())
 		.send().await
 	}
-	async fn post(&self,url:url::Url,body:impl ContentType)->Result<reqwest::Response,reqwest::Error>{
+	async fn post(&self,url:url::Url,body:impl Into<reqwest::Body>+Clone)->Result<reqwest::Response,reqwest::Error>{
 		self.client.post(url)
 		.header("x-api-key",self.api_key.as_str())
-		.header("Content-Type",body.content_type())
 		.body(body)
 		.send().await
 	}
@@ -523,38 +415,18 @@ impl Context{
 			operation,
 		})
 	}
-	async fn get_asset_operation(&self,config:GetAssetOperationRequest<'_>)->Result<RobloxOperation,GetError>{
+	async fn get_asset_operation(&self,config:GetAssetOperationRequest)->Result<RobloxOperation,GetError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/operations/{}",config.operation_id);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
 		).await.map_err(GetError::Response)?
 		.json::<RobloxOperation>().await.map_err(GetError::Reqwest)
 	}
-	pub async fn create_luau_session(&self,config:&impl AsSessionPath,session:LuauSessionCreate<'_>)->Result<LuauSessionResponse,CreateError>{
-		let raw_url=format!("https://apis.roblox.com/cloud/v2/{}",config.into_session_path().as_ref());
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(CreateError::Parse)?;
-
-		let body=serde_json::to_string(&session).map_err(CreateError::Serialize)?;
-
-		response_ok(
-			self.post(url,Json(body)).await.map_err(CreateError::Reqwest)?
-		).await.map_err(CreateError::Response)?
-		.json::<LuauSessionResponse>().await.map_err(CreateError::Reqwest)
-	}
-	pub async fn get_luau_session(&self,config:&impl AsSessionPath)->Result<LuauSessionResponse,GetError>{
-		let raw_url=format!("https://apis.roblox.com/cloud/v2/{}",config.into_session_path().as_ref());
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
-
-		response_ok(
-			self.get(url).await.map_err(GetError::Reqwest)?
-		).await.map_err(GetError::Response)?
-		.json::<LuauSessionResponse>().await.map_err(GetError::Reqwest)
-	}
 	pub async fn get_asset_info(&self,config:GetAssetLatestRequest)->Result<AssetResponse,GetError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.asset_id);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -563,7 +435,7 @@ impl Context{
 	}
 	pub async fn get_asset_version_info(&self,config:GetAssetVersionRequest)->Result<AssetResponse,GetError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions/{}",config.asset_id,config.version);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -572,7 +444,7 @@ impl Context{
 	}
 	pub async fn get_asset_location(&self,config:GetAssetLatestRequest)->Result<AssetLocationInfo,GetError>{
 		let raw_url=format!("https://apis.roblox.com/asset-delivery-api/v1/assetId/{}",config.asset_id);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -581,7 +453,7 @@ impl Context{
 	}
 	pub async fn get_asset_version_location(&self,config:GetAssetVersionRequest)->Result<AssetLocationInfo,GetError>{
 		let raw_url=format!("https://apis.roblox.com/asset-delivery-api/v1/assetId/{}/version/{}",config.asset_id,config.version);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -589,7 +461,7 @@ impl Context{
 		.json().await.map_err(GetError::Reqwest)
 	}
 	pub async fn get_asset(&self,config:&AssetLocation)->Result<MaybeGzippedBytes,GetError>{
-		let url=reqwest::Url::parse(config.location()).map_err(GetError::Parse)?;
+		let url=reqwest::Url::parse(config.location()).map_err(GetError::ParseError)?;
 
 		let bytes=response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -632,7 +504,7 @@ impl Context{
 		}
 
 		response_ok(
-			self.post(url,Binary(body)).await.map_err(UpdateError::Reqwest)?
+			self.post(url,body).await.map_err(UpdateError::Reqwest)?
 		).await.map_err(UpdateError::Response)?
 		.json::<UpdatePlaceResponse>().await.map_err(UpdateError::Reqwest)
 	}

rbx_asset/src/cookie.rs

@@ -141,11 +141,10 @@ impl GetAssetV2Location{
 pub struct GetAssetV2Info{
 	pub locations:Vec<GetAssetV2Location>,
 	pub requestId:String,
+	pub IsHashDynamic:bool,
+	pub IsCopyrightProtected:bool,
 	pub isArchived:bool,
 	pub assetTypeId:u32,
-	pub isRecordable:Option<bool>,
-	pub IsHashDynamic:Option<bool>,
-	pub IsCopyrightProtected:Option<bool>,
 }
 
 pub struct GetAssetV2{
@@ -286,7 +285,7 @@ pub struct UserInventoryPageRequest{
 pub struct UserInventoryItemOwner{
 	pub userId:u64,
 	pub username:String,
-	pub buildersClubMembershipType:String,
+	pub buildersClubMembershipType:u64,
 }
 #[derive(serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
@@ -591,7 +590,7 @@ impl Context{
 		).await.map_err(GetError::Response)?
 		.json().await.map_err(GetError::Reqwest)
 	}
-	pub async fn get_asset_versions_page(&self,config:&AssetVersionsPageRequest)->Result<AssetVersionsPageResponse,PageError>{
+	pub async fn get_asset_versions_page(&self,config:AssetVersionsPageRequest)->Result<AssetVersionsPageResponse,PageError>{
 		let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",config.asset_id).as_str()).map_err(PageError::ParseError)?;
 		//url borrow scope
 		{

rbx_asset/src/types.rs

@@ -1,3 +1,4 @@
+#[allow(dead_code)]
 #[derive(Debug)]
 pub struct UrlAndBody{
 	pub url:url::Url,

rox_compiler/src/compile.rs

@@ -16,6 +16,7 @@ use crate::common::{sanitize,Style,PropertiesOverride};
 //I could use a function!
 //eventually:
 #[derive(Debug)]
+#[allow(dead_code)]//idk why this thinks it's dead code, the errors are printed out in various places
 pub enum QueryResolveError{
 	NotFound,//0 results
 	Ambiguous,//>1 results

src/main.rs

@@ -1,8 +1,7 @@
-use std::io::Read;
-use std::path::{Path,PathBuf};
+use std::{io::Read,path::PathBuf};
 use clap::{Args,Parser,Subcommand};
 use anyhow::{anyhow,Result as AResult};
-use futures::{StreamExt,TryStreamExt};
+use futures::StreamExt;
 use rbx_asset::cloud::{ApiKey,Context as CloudContext};
 use rbx_asset::cookie::{Cookie,Context as CookieContext,AssetVersion,CreationsItem};
 
@@ -10,7 +9,6 @@ type AssetID=u64;
 type AssetIDFileMap=Vec<(AssetID,PathBuf)>;
 const CONCURRENT_DECODE:usize=8;
 const CONCURRENT_REQUESTS:usize=32;
-const CONCURRENT_FS:usize=64;
 
 #[derive(Parser)]
 #[command(author,version,about,long_about=None)]
@@ -31,7 +29,6 @@ enum Commands{
 	DownloadVersionV2(DownloadVersionSubcommand),
 	DownloadDecompile(DownloadDecompileSubcommand),
 	DownloadCreationsJson(DownloadCreationsJsonSubcommand),
-	DownloadCreationsHistory(DownloadCreationsHistorySubcommand),
 	DownloadUserInventoryJson(DownloadUserInventoryJsonSubcommand),
 	CreateAsset(CreateAssetSubcommand),
 	CreateAssetMedia(CreateAssetMediaSubcommand),
@@ -45,7 +42,6 @@ enum Commands{
 	Decompile(DecompileSubcommand),
 	DecompileHistoryIntoGit(DecompileHistoryIntoGitSubcommand),
 	DownloadAndDecompileHistoryIntoGit(DownloadAndDecompileHistoryIntoGitSubcommand),
-	RunLuau(RunLuauSubcommand),
 }
 
 /// Download a range of assets from the asset version history.  Download summary is saved to `output_folder/versions.json`, and can be optionally used to download only new versions the next time.
@@ -151,8 +147,6 @@ struct DownloadCreationsJsonSubcommand{
 	group_id:Option<u64>,
 	#[arg(long,group="owner",required=true)]
 	user_id:Option<u64>,
-	#[arg(long)]
-	continue_from_cursor:Option<bool>,
 }
 /// Download the list of asset ids (not the assets themselves) in a user's inventory.  The output is written to `output_folder/versions.json`
 #[derive(Args)]
@@ -433,24 +427,6 @@ struct DownloadAndDecompileHistoryIntoGitSubcommand{
 	#[arg(long)]
 	write_scripts:Option<bool>,
 }
-/// Run a Luau script.
-#[derive(Args)]
-struct RunLuauSubcommand{
-	#[arg(long,group="api_key",required=true)]
-	api_key_literal:Option<String>,
-	#[arg(long,group="api_key",required=true)]
-	api_key_envvar:Option<String>,
-	#[arg(long,group="api_key",required=true)]
-	api_key_file:Option<PathBuf>,
-	#[arg(long,group="script",required=true)]
-	script_literal:Option<String>,
-	#[arg(long,group="script",required=true)]
-	script_file:Option<PathBuf>,
-	#[arg(long)]
-	universe_id:u64,
-	#[arg(long)]
-	place_id:u64,
-}
 
 #[derive(Clone,Copy,Debug,clap::ValueEnum)]
 enum Style{
@@ -605,9 +581,7 @@ async fn main()->AResult<()>{
 				subcommand.group_id,
 			)?,
 			subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
-			subcommand.continue_from_cursor.unwrap_or(false),
 		).await,
-		Commands::DownloadCreationsHistory(subcommand)=>subcommand.run().await,
 		Commands::DownloadUserInventoryJson(subcommand)=>download_user_inventory_json(
 			cookie_from_args(
 				subcommand.cookie_literal,
@@ -764,21 +738,6 @@ async fn main()->AResult<()>{
 			write_models:subcommand.write_models.unwrap_or(false),
 			write_scripts:subcommand.write_scripts.unwrap_or(true),
 		 }).await,
-		Commands::RunLuau(subcommand)=>run_luau(RunLuauConfig{
-			api_key:api_key_from_args(
-				subcommand.api_key_literal,
-				subcommand.api_key_envvar,
-				subcommand.api_key_file,
-			).await?,
-			script:match subcommand.script_literal{
-				Some(script)=>script,
-				None=>std::fs::read_to_string(subcommand.script_file.unwrap())?,
-			},
-			request:rbx_asset::cloud::LuauSessionLatestRequest{
-				place_id:subcommand.place_id,
-				universe_id:subcommand.universe_id,
-			},
-		}).await,
 	}
 }
 
@@ -892,7 +851,7 @@ struct CreateAssetMediasConfig{
 }
 
 #[derive(Debug)]
-#[expect(dead_code)]
+#[allow(dead_code)]
 enum CreateAssetMediasError{
 	NoFileStem(PathBuf),
 	IO(std::io::Error),
@@ -907,7 +866,7 @@ impl std::fmt::Display for CreateAssetMediasError{
 impl std::error::Error for CreateAssetMediasError{}
 
 #[derive(Debug)]
-#[expect(dead_code)]
+#[allow(dead_code)]
 enum PollOperationError{
 	CreateAssetMedias(CreateAssetMediasError),
 	AssetOperation(rbx_asset::cloud::AssetOperationError),
@@ -920,7 +879,7 @@ impl std::fmt::Display for PollOperationError{
 impl std::error::Error for PollOperationError{}
 
 #[derive(Debug)]
-#[expect(dead_code)]
+#[allow(dead_code)]
 enum DownloadDecalError{
 	PollOperation(PollOperationError),
 	ParseInt(std::num::ParseIntError),
@@ -1161,100 +1120,30 @@ async fn download_location(api_key:ApiKey,asset_id:AssetID,version:Option<u64>)-
 	Ok(())
 }
 
-async fn get_creations_pages(
-	context:&CookieContext,
-	asset_list:&mut Vec<rbx_asset::cookie::CreationsItem>,
-	config:&mut rbx_asset::cookie::CreationsPageRequest,
-)->AResult<()>{
+async fn get_creations_pages(context:&CookieContext,owner:rbx_asset::cookie::Owner)->AResult<Vec<CreationsItem>>{
+	let mut config=rbx_asset::cookie::CreationsPageRequest{
+		owner,
+		cursor:None,
+	};
+	let mut asset_list=Vec::new();
 	loop{
 		let mut page=context.get_creations_page(&config).await?;
 		asset_list.append(&mut page.data);
-		config.cursor=page.nextPageCursor;
-		if config.cursor.is_none(){
+		if page.nextPageCursor.is_none(){
 			break;
 		}
+		config.cursor=page.nextPageCursor;
 	}
-	Ok(())
-}
-
-async fn download_creations_pages_from_checkpoint(context:&CookieContext,owner:rbx_asset::cookie::Owner,output_folder:&Path,continue_from_cursor:bool)->AResult<Vec<CreationsItem>>{
-	let mut versions_path=output_folder.to_owned();
-	versions_path.set_file_name("versions.json");
-	let mut cursor_path=output_folder.to_owned();
-	cursor_path.set_file_name("cursor");
-
-	let (mut asset_list,mut config)=if continue_from_cursor{
-		// load state from files
-		let (versions,cursor)=tokio::join!(
-			tokio::fs::read(versions_path.as_path()),
-			tokio::fs::read_to_string(cursor_path.as_path()),
-		);
-		// allow versions to not exist
-		let (versions,cursor)=match (versions,cursor){
-			// continue downloading
-			(Ok(versions),Ok(cursor))=>(serde_json::from_slice(&versions)?,Some(cursor)),
-			// already downloaded
-			(Ok(versions),Err(e)) if matches!(e.kind(),std::io::ErrorKind::NotFound)=>return Ok(serde_json::from_slice(&versions)?),
-			// not downloaded
-			(Err(e),result) if matches!(e.kind(),std::io::ErrorKind::NotFound)=>{
-				match result{
-					Ok(_)=>{},
-					Err(e) if matches!(e.kind(),std::io::ErrorKind::NotFound)=>{},
-					Err(e)=>Err(e)?,
-				}
-				(Vec::new(),None)
-			},
-			// other errors
-			(Ok(_),Err(e))=>Err(e)?,
-			(Err(e),_)=>Err(e)?,
-		};
-		(
-			versions,
-			rbx_asset::cookie::CreationsPageRequest{
-				owner,
-				cursor,
-			}
-		)
-	}else{
-		// create new state
-		(
-			Vec::new(),
-			rbx_asset::cookie::CreationsPageRequest{
-				owner,
-				cursor:None,
-			}
-		)
-	};
-
-	get_creations_pages(&context,&mut asset_list,&mut config).await?;
-
-	let cursor_fut=async{
-		if let Some(cursor)=config.cursor{
-			println!("writing cursor state...");
-			// there was a problem, write out cursor
-			tokio::fs::write(cursor_path,cursor).await?;
-		}else{
-			// no cursor
-			if let Err(e)=tokio::fs::remove_file(cursor_path).await{
-				match e.kind(){
-					std::io::ErrorKind::NotFound=>println!("Cannot delete cursor: file not found"),
-					_=>Err(e)?,
-				}
-			}
-		}
-		Ok(())
-	};
-	let versions_fut=tokio::fs::write(versions_path,serde_json::to_string(&asset_list)?);
-
-	tokio::try_join!(versions_fut,cursor_fut)?;
-
 	Ok(asset_list)
 }
 
-async fn download_creations_json(cookie:Cookie,owner:rbx_asset::cookie::Owner,output_folder:PathBuf,continue_from_cursor:bool)->AResult<()>{
+async fn download_creations_json(cookie:Cookie,owner:rbx_asset::cookie::Owner,output_folder:PathBuf)->AResult<()>{
 	let context=CookieContext::new(cookie);
+	let item_list=get_creations_pages(&context,owner).await?;
 
-	download_creations_pages_from_checkpoint(&context,owner,output_folder.as_path(),continue_from_cursor).await?;
+	let mut path=output_folder.clone();
+	path.set_file_name("versions.json");
+	tokio::fs::write(path,serde_json::to_string(&item_list)?).await?;
 
 	Ok(())
 }
@@ -1279,7 +1168,7 @@ async fn download_user_inventory_json(cookie:Cookie,user_id:u64,output_folder:Pa
 	let mut versions_path=output_folder.clone();
 	versions_path.set_file_name("versions.json");
 	let mut cursor_path=output_folder.clone();
-	cursor_path.set_file_name("cursor");
+	cursor_path.set_file_name("cursor.json");
 
 	let context=CookieContext::new(cookie);
 
@@ -1327,163 +1216,18 @@ async fn download_user_inventory_json(cookie:Cookie,user_id:u64,output_folder:Pa
 	Ok(())
 }
 
-/// Download all versions of all assets created by a group or user.  The output is written to a folder structure in the output directory.
-#[derive(Args)]
-struct DownloadCreationsHistorySubcommand{
-	#[arg(long,group="cookie",required=true)]
-	cookie_literal:Option<String>,
-	#[arg(long,group="cookie",required=true)]
-	cookie_envvar:Option<String>,
-	#[arg(long,group="cookie",required=true)]
-	cookie_file:Option<PathBuf>,
-	#[arg(long,group="api_key",required=true)]
-	api_key_literal:Option<String>,
-	#[arg(long,group="api_key",required=true)]
-	api_key_envvar:Option<String>,
-	#[arg(long,group="api_key",required=true)]
-	api_key_file:Option<PathBuf>,
-	#[arg(long)]
-	output_folder:Option<PathBuf>,
-	#[arg(long,group="owner",required=true)]
-	group_id:Option<u64>,
-	#[arg(long,group="owner",required=true)]
-	user_id:Option<u64>,
-	#[arg(long)]
-	r#continue:Option<bool>,
-}
-impl DownloadCreationsHistorySubcommand{
-	async fn run(self)->AResult<()>{
-		download_creations_history(
-			cookie_from_args(
-				self.cookie_literal,
-				self.cookie_envvar,
-				self.cookie_file,
-			).await?,
-			api_key_from_args(
-				self.api_key_literal,
-				self.api_key_envvar,
-				self.api_key_file,
-			).await?,
-			owner_from_args(
-				self.user_id,
-				self.group_id,
-			)?,
-			self.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
-			self.r#continue.unwrap_or(false),
-		).await
-	}
-}
-async fn download_creations_history(cookie:Cookie,api_key:ApiKey,owner:rbx_asset::cookie::Owner,output_folder:PathBuf,r#continue:bool)->AResult<()>{
-
-	let cookie_context=CookieContext::new(cookie);
-	let cloud_context=CloudContext::new(api_key);
-
-	// get list of all assets in inventory
-	let asset_list=download_creations_pages_from_checkpoint(&cookie_context,owner,output_folder.as_path(),r#continue).await?;
-
-	// create folder directories
-	let asset_folders:Vec<PathBuf> ={
-		futures::stream::iter(asset_list.iter().map(|asset|async{
-			// create asset folder
-			let mut asset_folder=output_folder.clone();
-			asset_folder.push(asset.id.to_string());
-			tokio::fs::create_dir_all(asset_folder.as_path()).await?;
-			Ok::<_,anyhow::Error>(asset_folder)
-		}))
-		.buffered(CONCURRENT_FS)
-		.try_collect().await?
-	};
-
-	#[expect(dead_code)]
-	#[derive(Debug)]
-	enum Error<'a>{
-		NoLocations(Job<'a>),
-		GetVersionLocationError(rbx_asset::cloud::GetError),
-		GetError(rbx_asset::cloud::GetError),
-		Io(std::io::Error),
-	}
-	#[derive(Clone,Copy,Debug)]
-	struct Job<'a>{
-		path:&'a PathBuf,
-		asset_id:u64,
-		asset_version:u64,
-	}
-	let mut job_list=Vec::new();
-
-	// create flattened futures stream to parallel download all asset versions
-	for (path,asset) in asset_folders.iter().zip(asset_list){
-
-		// save versions file
-		let mut versions_path=path.to_owned();
-		versions_path.push("versions.json");
-
-		let version_history=if r#continue{
-			let file=tokio::fs::read(versions_path.as_path()).await?;
-			serde_json::from_slice(&file)?
-		}else{
-			println!("Downloading history for {} - {}",asset.id,asset.name);
-			let version_history=get_version_history(&cookie_context,asset.id).await?;
-			println!("Found {} versions",version_history.len());
-			tokio::fs::write(versions_path,serde_json::to_string(&version_history)?).await?;
-			version_history
-		};
-
-		job_list.extend(version_history.into_iter().map(|asset_version|
-			Job{
-				path,
-				asset_id:asset.id,
-				asset_version:asset_version.assetVersionNumber,
-			}
-		));
-	}
-
-	println!("Completed jobs list. Number of jobs: {}",job_list.len());
-
-	futures::stream::iter(job_list).map(async|job|{
-		let mut dest=job.path.to_owned();
-		dest.push(format!("{}_v{}.rbxl",job.asset_id,job.asset_version));
-		//if the file already exists, don't try downloading it again
-		if tokio::fs::try_exists(dest.as_path()).await.map_err(Error::Io)?{
-			return Ok(());
-		}
-		let location=cloud_context.get_asset_version_location(rbx_asset::cloud::GetAssetVersionRequest{
-			asset_id:job.asset_id,
-			version:job.asset_version,
-		}).await.map_err(Error::GetVersionLocationError)?;
-		let location=location.location.ok_or(Error::NoLocations(job))?;
-		let downloaded=cloud_context.get_asset(&location).await.map_err(Error::GetError)?;
-		tokio::fs::write(dest,downloaded.to_vec().map_err(Error::Io)?).await.map_err(Error::Io)?;
-		Ok(())
-	})
-	.buffer_unordered(CONCURRENT_REQUESTS)
-	.for_each(async|result|{
-		match result{
-			Ok(())=>{},
-			Err(Error::NoLocations(job))=>println!("Job failed due to no locations: asset_id={} version={}",job.asset_id,job.asset_version),
-			Err(e)=>println!("Error: {e:?}"),
-		}
-	}).await;
-
-	println!("All jobs complete.");
-
-	Ok(())
-}
-
 async fn get_version_history(context:&CookieContext,asset_id:AssetID)->AResult<Vec<AssetVersion>>{
-	let mut page_request=rbx_asset::cookie::AssetVersionsPageRequest{
-		asset_id,
-		cursor:None,
-	};
+	let mut cursor:Option<String>=None;
 	let mut asset_list=Vec::new();
 	loop{
-		let mut page=context.get_asset_versions_page(&page_request).await?;
+		let mut page=context.get_asset_versions_page(rbx_asset::cookie::AssetVersionsPageRequest{asset_id,cursor}).await?;
 		asset_list.append(&mut page.data);
 		if page.nextPageCursor.is_none(){
 			break;
 		}
-		page_request.cursor=page.nextPageCursor;
+		cursor=page.nextPageCursor;
 	}
-	asset_list.sort_by_key(|a|a.assetVersionNumber);
+	asset_list.sort_by(|a,b|a.assetVersionNumber.cmp(&b.assetVersionNumber));
 	Ok(asset_list)
 }
 
@@ -1539,12 +1283,9 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 	let mut join_set=tokio::task::JoinSet::new();
 
 	//poll paged list of all asset versions
-	let mut page_request=rbx_asset::cookie::AssetVersionsPageRequest{
-		asset_id:config.asset_id,
-		cursor:None,
-	};
+	let mut cursor:Option<String>=None;
 	loop{
-		let mut page=context.get_asset_versions_page(&page_request).await?;
+		let mut page=context.get_asset_versions_page(rbx_asset::cookie::AssetVersionsPageRequest{asset_id:config.asset_id,cursor}).await?;
 		let context=&context;
 		let output_folder=config.output_folder.clone();
 		let data=&page.data;
@@ -1603,10 +1344,10 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 		}else{
 			asset_list.append(&mut page.data);
 		}
-		page_request.cursor=page.nextPageCursor;
+		cursor=page.nextPageCursor;
 	}
 
-	asset_list.sort_by_key(|a|a.assetVersionNumber);
+	asset_list.sort_by(|a,b|a.assetVersionNumber.cmp(&b.assetVersionNumber));
 
 	let mut path=config.output_folder.clone();
 	path.set_file_name("versions.json");
@@ -1620,7 +1361,7 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 }
 
 #[derive(Debug)]
-#[expect(dead_code)]
+#[allow(dead_code)]
 enum LoadDomError{
 	IO(std::io::Error),
 	RbxBinary(rbx_binary::DecodeError),
@@ -1722,7 +1463,7 @@ struct WriteCommitConfig{
 	write_scripts:bool,
 }
 
-async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,rox_compiler::DecompiledContext)>,tokio::task::JoinError>,repo:&git2::Repository)->AResult<()>{
+async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,rox_compiler::DecompiledContext)>,tokio::task::JoinError>,repo:&gix::Repository)->AResult<()>{
 	let (asset_version,context)=b??;
 	println!("writing files for version {}",asset_version.assetVersionNumber);
 
@@ -1753,12 +1494,17 @@ async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,ro
 		write_scripts:config.write_scripts,
 	}).await?;
 
-	let date=asset_version.created;
-	//let sig=repo.signature()?; //this pulls default name and email
-	let sig=git2::Signature::new(config.git_committer_name.as_str(),config.git_committer_email.as_str(),&git2::Time::new(date.timestamp(),0)).unwrap();
+	let time=gix::date::Time::new(asset_version.created.timestamp(),0);
+	let sig=gix::actor::Signature{
+		name:config.git_committer_name.into(),
+		email:config.git_committer_email.into(),
+		time,
+	};
 	let tree_id={
 		let mut tree_index = repo.index()?;
-		match tree_index.add_all(std::iter::once("*"),git2::IndexAddOption::DEFAULT,None){
+		tree.index()?.
+		tree.peel_to_entry(path);
+		match tree_index.add_all(std::iter::once("*"),gix::IndexAddOption::DEFAULT,None){
 			Ok(_)=>(),
 			Err(e)=>println!("tree_index.add_all error: {}",e),
 		}
@@ -1769,34 +1515,38 @@ async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,ro
 		tree_index.write()?;
 		tree_index.write_tree()?
 	};
-	let tree=repo.find_tree(tree_id)?;
+	let tree=repo.tree(tree_id)?;
 
 	let mut parents=Vec::new();
 
-	match repo.head(){
-		Ok(reference)=>{
-			let commit=reference.peel_to_commit()?;
-
+	match repo.head_commit(){
+		Ok(commit)=>{
 			//test tree against commit tree to see if there is any changes
 			let commit_tree=commit.tree()?;
 			let diff=repo.diff_tree_to_tree(Some(&commit_tree),Some(&tree),None)?;
-			if diff.get_delta(0).is_none(){
+			if diff.is_empty(){
 				println!("no changes");
 				return Ok(());
 			}
 
-			parents.push(commit);
+			parents.push(commit.id());
 		},
-		Err(e)=>println!("repo head error {:?}",e),
+		//If the repo head is not found, great, continue and make the first commit
+		Err(gix::reference::head_commit::Error::Head(gix::reference::find::existing::Error::NotFound{..}))=>(),
+		//for other errors
+		Err(e)=>Err(e)?,
 	};
 
-	repo.commit(
-		Some("HEAD"),//update_ref
-		&sig,//author
-		&sig,//commiter
-		&format!("v{}", asset_version.assetVersionNumber),//message
+	let mut timebuf=gix::date::parse::TimeBuf::default();
+	let sig_ref=sig.to_ref(&mut timebuf);
+
+	repo.commit_as(
+		sig_ref,//commiter
+		sig_ref,//author
+		"HEAD",
+		&format!("v{}",asset_version.assetVersionNumber),//message
 		&tree,//tree (basically files)
-		parents.iter().collect::<Vec<&git2::Commit<'_>>>().as_slice(),//parents
+		parents,//parents
 	)?;
 
 	//commit
@@ -1820,7 +1570,14 @@ async fn decompile_history_into_git(config:DecompileHistoryConfig)->AResult<()>{
 	versions_path.push("versions.json");
 	let asset_list:Vec<AssetVersion>=serde_json::from_reader(std::fs::File::open(versions_path)?)?;
 
-	let repo=git2::Repository::init(config.output_folder.as_path())?;
+	let repo=gix::discover(gix::create::into(
+		config.output_folder.as_path(),
+		gix::create::Kind::Bare,
+		gix::create::Options{
+			destination_must_be_empty:true,
+			fs_capabilities:None
+		}
+	)?)?;
 
 	//decompile all versions
 	futures::stream::iter(asset_list.into_iter()
@@ -1870,7 +1627,14 @@ async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHist
 	//poll paged list of all asset versions
 	let asset_list=get_version_history(&context,config.asset_id).await?;
 
-	let repo=git2::Repository::init(config.output_folder.clone())?;
+	let repo=gix::discover(gix::create::into(
+		config.output_folder.as_path(),
+		gix::create::Kind::Bare,
+		gix::create::Options{
+			destination_must_be_empty:true,
+			fs_capabilities:None
+		}
+	)?)?;
 
 	//download all versions
 	let asset_id=config.asset_id;
@@ -2003,43 +1767,3 @@ async fn compile_upload_place(config:CompileUploadPlaceConfig)->AResult<()>{
 	println!("UploadResponse={:?}",resp);
 	Ok(())
 }
-
-async fn get_luau_result_exp_backoff(
-	context:&CloudContext,
-	luau_session:&rbx_asset::cloud::LuauSessionResponse
-)->Result<Result<rbx_asset::cloud::LuauResults,rbx_asset::cloud::LuauError>,rbx_asset::cloud::LuauSessionError>{
-	const BACKOFF_MUL:f32=1.395_612_5;//exp(1/3)
-	let mut backoff=1000f32;
-	loop{
-		match luau_session.try_get_result(context).await{
-			//try again when the operation is not done
-			Err(rbx_asset::cloud::LuauSessionError::NotDone)=>(),
-			//return all other results
-			other_result=>return other_result,
-		}
-		println!("Operation not complete; waiting {:.0}ms...",backoff);
-		tokio::time::sleep(std::time::Duration::from_millis(backoff as u64)).await;
-		backoff*=BACKOFF_MUL;
-	}
-}
-struct RunLuauConfig{
-	api_key:ApiKey,
-	script:String,
-	request:rbx_asset::cloud::LuauSessionLatestRequest,
-}
-async fn run_luau(config:RunLuauConfig)->AResult<()>{
-	let context=CloudContext::new(config.api_key);
-	let session=rbx_asset::cloud::LuauSessionCreate{
-		script:&config.script,
-		user:None,
-		timeout:None,
-		binaryInput:None,
-		enableBinaryOutput:None,
-		binaryOutputUri:None,
-	};
-	let response=context.create_luau_session(&config.request,session).await?;
-	dbg!(&response);
-	let result=get_luau_result_exp_backoff(&context,&response).await?;
-	dbg!(&result);
-	Ok(())
-}