rox_compiler: fix regex

v0.5.1
remove unused lints
2025-12-20 15:54:07 -08:00 · 2025-12-13 14:35:32 -08:00 · 2025-12-09 14:32:12 -08:00 · 2025-12-09 14:31:58 -08:00 · 2025-11-27 15:30:53 -08:00 · 2025-11-09 06:06:00 -08:00
16 changed files with 2614 additions and 808 deletions
--- a/.drone.yml
+++ b/.drone.yml
@@ -7,6 +7,17 @@ platform:
  arch: amd64

 steps:
+  - name: build
+    image: clux/muslrust:1.89.0-stable
+    commands:
+      - cargo build --release --target x86_64-unknown-linux-musl
+    when:
+      branch:
+        - master
+      event:
+        - push
+        - pull_request
+
  - name: image
    image: plugins/docker
    settings:
@@ -19,6 +30,15 @@ steps:
      password:
        from_secret: GIT_PASS
      dockerfile: Containerfile
+    depends_on:
+      - build
    when:
      branch:
-        - master
+        - master
+      event:
+        - push
+---
+kind: signature
+hmac: 52507904dfaada892c05a61422dc5e147c1438419ed841d0f1e3e3ec2b193540
+
+...
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 workspace = { members = ["rbx_asset", "rox_compiler"] }
 [package]
 name = "asset-tool"
-version = "0.4.7"
+version = "0.5.1"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -10,18 +10,20 @@ edition = "2021"
 anyhow = "1.0.75"
 clap = { version = "4.4.2", features = ["derive"] }
 futures = "0.3.30"
-git2 = "0.18.1"
-lazy-regex = "3.1.0"
-pollster = "0.3.0"
-rbx_asset = { path = "rbx_asset" }
-rbx_binary = "0.7.4"
-rbx_dom_weak = "2.7.0"
-rbx_reflection_database = "0.2.10"
-rbx_xml = "0.13.3"
+git2 = { version = "0.20.0", optional = true }
+rbx_asset = { path = "rbx_asset", features = ["gzip", "rustls-tls"], default-features = false }
+rbx_binary = "2.0.0"
+rbx_dom_weak = "4.0.0"
+rbx_reflection_database = "2.0.1"
+rbx_xml = "2.0.0"
 rox_compiler = { path = "rox_compiler" }
 serde_json = "1.0.111"
 tokio = { version = "1.35.1", features = ["macros", "rt-multi-thread", "fs"] }

+[features]
+default = []
+git = ["dep:git2"]
+
 [profile.release]
 #lto = true
 strip = true
--- a/26
+++ b/26
@@ -1,23 +1,3 @@
-# Using the `rust-musl-builder` as base image, instead of 
-# the official Rust toolchain
-FROM docker.io/clux/muslrust:stable AS chef
-USER root
-RUN cargo install cargo-chef
-WORKDIR /app
-
-FROM chef AS planner
-COPY . .
-RUN cargo chef prepare --recipe-path recipe.json
-
-FROM chef AS builder
-COPY --from=planner /app/recipe.json recipe.json
-# Notice that we are specifying the --target flag!
-RUN cargo chef cook --release --target x86_64-unknown-linux-musl --recipe-path recipe.json
-COPY . .
-RUN cargo build --release --target x86_64-unknown-linux-musl --bin asset-tool
-
-FROM docker.io/alpine:latest AS runtime
-RUN addgroup -S myuser && adduser -S myuser -G myuser
-COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/asset-tool /usr/local/bin/
-USER myuser
-ENTRYPOINT ["/usr/local/bin/asset-tool"]
+FROM alpine:3.22 AS runtime
+COPY /target/x86_64-unknown-linux-musl/release/asset-tool /usr/local/bin/
+ENTRYPOINT ["/usr/local/bin/asset-tool"]
--- a/rbx_asset/Cargo.toml
+++ b/rbx_asset/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rbx_asset"
-version = "0.2.3"
+version = "0.5.0"
 edition = "2021"
 publish = ["strafesnet"]
 repository = "https://git.itzana.me/StrafesNET/asset-tool"
@@ -10,10 +10,22 @@ 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"]
+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 = "1.0.29"
-reqwest = { version = "0.12.4", features = ["json","multipart"] }
+flate2 = { version = "1.0.29", optional = true }
+reqwest = { version = "0.12.4", features = [
+	"json", "multipart",
+	# default features
+	"charset", "http2", "system-proxy"
+], default-features = false }
 serde = { version = "1.0.199", features = ["derive"] }
 serde_json = "1.0.111"
 url = "2.5.0"
--- a/rbx_asset/src/body.rs
+++ b/rbx_asset/src/body.rs
@@ -0,0 +1,44 @@
+use reqwest::Body;
+
+pub trait ContentType:Into<Body>{
+	fn content_type(&self)->&'static str;
+}
+
+#[derive(Clone,Copy,Debug)]
+pub struct Json<T>(pub(crate)T);
+impl<T:Into<Body>> From<Json<T>> for Body{
+	fn from(Json(value):Json<T>)->Self{
+		value.into()
+	}
+}
+impl<T:Into<Body>> ContentType for Json<T>{
+	fn content_type(&self)->&'static str{
+		"application/json"
+	}
+}
+
+#[derive(Clone,Copy,Debug)]
+pub struct Text<T>(pub(crate)T);
+impl<T:Into<Body>> From<Text<T>> for Body{
+	fn from(Text(value):Text<T>)->Self{
+		value.into()
+	}
+}
+impl<T:Into<Body>> ContentType for Text<T>{
+	fn content_type(&self)->&'static str{
+		"text/plain"
+	}
+}
+
+#[derive(Clone,Copy,Debug)]
+pub struct Binary<T>(pub(crate)T);
+impl<T:Into<Body>> From<Binary<T>> for Body{
+	fn from(Binary(value):Binary<T>)->Self{
+		value.into()
+	}
+}
+impl<T:Into<Body>> ContentType for Binary<T>{
+	fn content_type(&self)->&'static str{
+		"application/octet-stream"
+	}
+}
--- a/rbx_asset/src/cloud.rs
+++ b/rbx_asset/src/cloud.rs
@@ -1,12 +1,15 @@
+use crate::body::{Binary,ContentType,Json};
+use crate::util::{serialize_u64,deserialize_u64,response_ok};
+use crate::types::{ResponseError,MaybeGzippedBytes};
+
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
 pub enum AssetType{
 	Audio,
 	Decal,
 	Model,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct CreateAssetRequest{
 	pub assetType:AssetType,
 	pub creationContext:CreationContext,
@@ -29,7 +32,7 @@ pub struct AssetOperation{
 	operation:RobloxOperation,
 }
 impl AssetOperation{
-	pub async fn try_get_asset(&self,context:&CloudContext)->Result<AssetResponse,AssetOperationError>{
+	pub async fn try_get_asset(&self,context:&Context)->Result<AssetResponse,AssetOperationError>{
 		serde_json::from_value(
 			self.operation
 				.try_get_reponse(context).await
@@ -40,6 +43,7 @@ impl AssetOperation{
 #[derive(Debug)]
 pub enum CreateError{
 	Parse(url::ParseError),
+	Response(ResponseError),
 	Serialize(serde_json::Error),
 	Reqwest(reqwest::Error),
 }
@@ -51,7 +55,7 @@ impl std::fmt::Display for CreateError{
 impl std::error::Error for CreateError{}

 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct UpdateAssetRequest{
 	pub assetId:u64,
 	pub displayName:Option<String>,
@@ -60,48 +64,48 @@ pub struct UpdateAssetRequest{

 //woo nested roblox stuff
 #[derive(Clone,Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub enum Creator{
-	userId(String),//u64 string
-	groupId(String),//u64 string
+	userId(#[serde(deserialize_with="deserialize_u64",serialize_with="serialize_u64")]u64),
+	groupId(#[serde(deserialize_with="deserialize_u64",serialize_with="serialize_u64")]u64),
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct CreationContext{
 	pub creator:Creator,
 	pub expectedPrice:Option<u64>,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
 pub enum ModerationState{
 	Reviewing,
 	Rejected,
 	Approved,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct ModerationResult{
 	pub moderationState:ModerationState,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct Preview{
 	pub asset:String,
 	pub altText:String,
 }
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct UpdatePlaceRequest{
 	pub universeId:u64,
 	pub placeId:u64,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct UpdatePlaceResponse{
 	pub versionNumber:u64,
 }
 #[derive(Debug)]
 pub enum UpdateError{
 	ParseError(url::ParseError),
+	Response(ResponseError),
 	SerializeError(serde_json::Error),
 	Reqwest(reqwest::Error),
 }
@@ -112,10 +116,10 @@ impl std::fmt::Display for UpdateError{
 }
 impl std::error::Error for UpdateError{}

-struct GetAssetOperationRequest{
-	operation_id:String,
+struct GetAssetOperationRequest<'a>{
+	operation_id:&'a str,
 }
-pub struct GetAssetInfoRequest{
+pub struct GetAssetLatestRequest{
 	pub asset_id:u64,
 }
 /*
@@ -140,35 +144,35 @@ pub struct GetAssetInfoRequest{
 }
 */
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct AssetResponse{
-	pub assetId:String,//u64 wrapped in quotes wohoo!!
+	//u64 wrapped in quotes wohoo!!
+	#[serde(deserialize_with="deserialize_u64")]
+	#[serde(serialize_with="serialize_u64")]
+	pub assetId:u64,
 	pub assetType:AssetType,
 	pub creationContext:CreationContext,
-	pub description:String,
+	pub description:Option<String>,
 	pub displayName:String,
 	pub path:String,
 	pub revisionCreateTime:chrono::DateTime<chrono::Utc>,
-	pub revisionId:String,//u64
+	#[serde(deserialize_with="deserialize_u64")]
+	#[serde(serialize_with="serialize_u64")]
+	pub revisionId:u64,
 	pub moderationResult:ModerationResult,
 	pub icon:Option<String>,
-	pub previews:Option<Vec<Preview>>,
+	#[serde(default)]
+	pub previews:Vec<Preview>,
 }
-#[allow(nonstandard_style,dead_code)]
 pub struct GetAssetVersionRequest{
 	pub asset_id:u64,
 	pub version:u64,
 }
-#[allow(nonstandard_style,dead_code)]
-pub struct GetAssetRequest{
-	pub asset_id:u64,
-	pub version:Option<u64>,
-}
 #[derive(Debug)]
 pub enum GetError{
-	ParseError(url::ParseError),
+	Parse(url::ParseError),
+	Response(ResponseError),
 	Reqwest(reqwest::Error),
-	IO(std::io::Error)
 }
 impl std::fmt::Display for GetError{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
@@ -177,12 +181,42 @@ impl std::fmt::Display for GetError{
 }
 impl std::error::Error for GetError{}

+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+pub struct AssetLocation(
+	// the location is private so users cannot mutate it
+	String
+);
+impl AssetLocation{
+	pub fn location(&self)->&str{
+		let Self(location)=self;
+		location
+	}
+}
+
+#[derive(Debug,serde::Deserialize)]
+#[expect(nonstandard_style)]
+pub struct AssetMetadata{
+	pub metadataType:u32,
+	pub value:String,
+}
+#[derive(Debug,serde::Deserialize)]
+#[expect(nonstandard_style)]
+pub struct AssetLocationInfo{
+	pub location:Option<AssetLocation>,
+	pub requestId:String,
+	pub isArchived:bool,
+	pub assetTypeId:u32,
+	#[serde(default)]
+	pub assetMetadatas:Vec<AssetMetadata>,
+	pub isRecordable:bool,
+}
+
 pub struct AssetVersionsRequest{
 	pub asset_id:u64,
 	pub cursor:Option<String>,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct AssetVersion{
 	pub Id:u64,
 	pub assetId:u64,
@@ -194,7 +228,7 @@ pub struct AssetVersion{
 	pub isPublished:bool,
 }
 #[derive(Debug,serde::Deserialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct AssetVersionsResponse{
 	pub previousPageCursor:Option<String>,
 	pub nextPageCursor:Option<String>,
@@ -203,6 +237,7 @@ pub struct AssetVersionsResponse{
 #[derive(Debug)]
 pub enum AssetVersionsError{
 	ParseError(url::ParseError),
+	Response(ResponseError),
 	Reqwest(reqwest::Error),
 }
 impl std::fmt::Display for AssetVersionsError{
@@ -217,13 +252,12 @@ pub struct InventoryPageRequest{
 	pub cursor:Option<String>,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
 pub struct InventoryItem{
 	pub id:u64,
 	pub name:String,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct InventoryPageResponse{
 	pub totalResults:u64,//up to 50
 	pub filteredKeyword:Option<String>,//""
@@ -238,6 +272,7 @@ pub struct InventoryPageResponse{
 #[derive(Debug)]
 pub enum InventoryPageError{
 	ParseError(url::ParseError),
+	Response(ResponseError),
 	Reqwest(reqwest::Error),
 }
 impl std::fmt::Display for InventoryPageError{
@@ -260,7 +295,7 @@ impl std::fmt::Display for OperationError{
 }
 impl std::error::Error for OperationError{}
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 struct RobloxOperation{
 	pub path:Option<String>,
 	pub metadata:Option<String>,
@@ -279,33 +314,120 @@ impl RobloxOperation{
 			None=>self.path.as_deref()?.get(11..),
 		}
 	}
-	pub async fn try_get_reponse(&self,context:&CloudContext)->Result<serde_json::Value,OperationError>{
+	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)?
-				.to_owned(),
+				.ok_or(OperationError::NoOperationId)?,
 		}).await.map_err(OperationError::Get)?
 		.response.ok_or(OperationError::NotDone)
 	}
 }

-//idk how to do this better
-enum ReaderType<R:std::io::Read>{
-	GZip(flate2::read::GzDecoder<std::io::BufReader<R>>),
-	Raw(std::io::BufReader<R>),
+#[derive(Debug)]
+pub enum LuauSessionError{
+	Get(GetError),
+	Unspecified,
+	NotDone,
+	NoOutput,
+	NoError,
 }
-fn maybe_gzip_decode<R:std::io::Read>(input:R)->std::io::Result<ReaderType<R>>{
-	let mut buf=std::io::BufReader::new(input);
-	let peek=std::io::BufRead::fill_buf(&mut buf)?;
-	match &peek[0..2]{
-		b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(buf))),
-		_=>Ok(ReaderType::Raw(buf)),
+impl std::fmt::Display for LuauSessionError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
 	}
 }
-fn read_readable(mut readable:impl std::io::Read)->std::io::Result<Vec<u8>>{
-	let mut contents=Vec::new();
-	readable.read_to_end(&mut contents)?;
-	Ok(contents)
+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)]
@@ -320,12 +442,12 @@ impl ApiKey{
 }

 #[derive(Clone)]
-pub struct CloudContext{
-	pub api_key:String,
-	pub client:reqwest::Client,
+pub struct Context{
+	api_key:String,
+	client:reqwest::Client,
 }

-impl CloudContext{
+impl Context{
 	pub fn new(api_key:ApiKey)->Self{
 		Self{
 			api_key:api_key.get(),
@@ -337,9 +459,10 @@ impl CloudContext{
 		.header("x-api-key",self.api_key.as_str())
 		.send().await
 	}
-	async fn post(&self,url:url::Url,body:impl Into<reqwest::Body>+Clone)->Result<reqwest::Response,reqwest::Error>{
+	async fn post(&self,url:url::Url,body:impl ContentType)->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
 	}
@@ -368,9 +491,9 @@ impl CloudContext{
 		.text("request",request_config)
 		.part("fileContent",part);

-		let operation=self.post_form(url,form).await
-		.map_err(CreateError::Reqwest)?
-		.error_for_status().map_err(CreateError::Reqwest)?
+		let operation=response_ok(
+			self.post_form(url,form).await.map_err(CreateError::Reqwest)?
+		).await.map_err(CreateError::Response)?
 		.json::<RobloxOperation>().await.map_err(CreateError::Reqwest)?;

 		Ok(AssetOperation{
@@ -387,62 +510,97 @@ impl CloudContext{
 		.text("request",request_config)
 		.part("fileContent",reqwest::multipart::Part::bytes(body));

-		let operation=self.patch_form(url,form).await
-		.map_err(UpdateError::Reqwest)?
-		//roblox api documentation is very poor, just give the status code and drop the json
-		.error_for_status().map_err(UpdateError::Reqwest)?
+		let operation=response_ok(
+			self.patch_form(url,form).await.map_err(UpdateError::Reqwest)?
+		).await.map_err(UpdateError::Response)?
 		.json::<RobloxOperation>().await.map_err(UpdateError::Reqwest)?;

 		Ok(AssetOperation{
 			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::ParseError)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;

-		self.get(url).await.map_err(GetError::Reqwest)?
-		.error_for_status().map_err(GetError::Reqwest)?
+		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 get_asset_info(&self,config:GetAssetInfoRequest)->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::ParseError)?;
+	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)?;

-		self.get(url).await.map_err(GetError::Reqwest)?
-		.error_for_status().map_err(GetError::Reqwest)?
+		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)?;
+
+		response_ok(
+			self.get(url).await.map_err(GetError::Reqwest)?
+		).await.map_err(GetError::Response)?
 		.json::<AssetResponse>().await.map_err(GetError::Reqwest)
 	}
-	pub async fn get_asset_version(&self,config:GetAssetVersionRequest)->Result<Vec<u8>,GetError>{
+	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::ParseError)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;

-		let body=self.get(url).await.map_err(GetError::Reqwest)?
-		.error_for_status().map_err(GetError::Reqwest)?
+		response_ok(
+			self.get(url).await.map_err(GetError::Reqwest)?
+		).await.map_err(GetError::Response)?
+		.json::<AssetResponse>().await.map_err(GetError::Reqwest)
+	}
+	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)?;
+
+		response_ok(
+			self.get(url).await.map_err(GetError::Reqwest)?
+		).await.map_err(GetError::Response)?
+		.json().await.map_err(GetError::Reqwest)
+	}
+	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)?;
+
+		response_ok(
+			self.get(url).await.map_err(GetError::Reqwest)?
+		).await.map_err(GetError::Response)?
+		.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 bytes=response_ok(
+			self.get(url).await.map_err(GetError::Reqwest)?
+		).await.map_err(GetError::Response)?
 		.bytes().await.map_err(GetError::Reqwest)?;

-		match maybe_gzip_decode(&mut std::io::Cursor::new(body)){
-			Ok(ReaderType::GZip(readable))=>read_readable(readable),
-			Ok(ReaderType::Raw(readable))=>read_readable(readable),
-			Err(e)=>Err(e),
-		}.map_err(GetError::IO)
-	}
-	pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{
-		let version=match config.version{
-			Some(version)=>version,
-			None=>self.get_asset_info(GetAssetInfoRequest{asset_id:config.asset_id}).await?.revisionId.parse().unwrap(),
-		};
-		self.get_asset_version(GetAssetVersionRequest{
-			asset_id:config.asset_id,
-			version,
-		}).await
+		Ok(MaybeGzippedBytes::new(bytes))
 	}
 	pub async fn get_asset_versions(&self,config:AssetVersionsRequest)->Result<AssetVersionsResponse,AssetVersionsError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions",config.asset_id);
 		let url=reqwest::Url::parse(raw_url.as_str()).map_err(AssetVersionsError::ParseError)?;

-		self.get(url).await.map_err(AssetVersionsError::Reqwest)?
-		.error_for_status().map_err(AssetVersionsError::Reqwest)?
+		response_ok(
+			self.get(url).await.map_err(AssetVersionsError::Reqwest)?
+		).await.map_err(AssetVersionsError::Response)?
 		.json::<AssetVersionsResponse>().await.map_err(AssetVersionsError::Reqwest)
 	}
 	pub async fn inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{
@@ -455,8 +613,9 @@ impl CloudContext{
 			}
 		}

-		self.get(url).await.map_err(InventoryPageError::Reqwest)?
-		.error_for_status().map_err(InventoryPageError::Reqwest)?
+		response_ok(
+			self.get(url).await.map_err(InventoryPageError::Reqwest)?
+		).await.map_err(InventoryPageError::Response)?
 		.json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)
 	}
 	pub async fn update_place(&self,config:UpdatePlaceRequest,body:impl Into<reqwest::Body>+Clone)->Result<UpdatePlaceResponse,UpdateError>{
@@ -468,8 +627,9 @@ impl CloudContext{
 			query.append_pair("versionType","Published");
 		}

-		self.post(url,body).await.map_err(UpdateError::Reqwest)?
-		.error_for_status().map_err(UpdateError::Reqwest)?
+		response_ok(
+			self.post(url,Binary(body)).await.map_err(UpdateError::Reqwest)?
+		).await.map_err(UpdateError::Response)?
 		.json::<UpdatePlaceResponse>().await.map_err(UpdateError::Reqwest)
 	}
 }
--- a/rbx_asset/src/cookie.rs
+++ b/rbx_asset/src/cookie.rs
@@ -1,3 +1,7 @@
+use crate::body::{ContentType,Json};
+use crate::util::response_ok;
+use crate::types::{ResponseError,MaybeGzippedBytes};
+
 #[derive(Debug)]
 pub enum PostError{
 	Reqwest(reqwest::Error),
@@ -11,7 +15,7 @@ impl std::fmt::Display for PostError{
 impl std::error::Error for PostError{}

 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct CreateRequest{
 	pub name:String,
 	pub description:String,
@@ -23,7 +27,14 @@ pub struct CreateRequest{
 pub enum CreateError{
 	ParseError(url::ParseError),
 	PostError(PostError),
+	Response(ResponseError),
 	Reqwest(reqwest::Error),
+	ParseInt{
+		response:String,
+		err:std::num::ParseIntError,
+	},
+	VersionHeaderMissing,
+	ToStr(reqwest::header::ToStrError),
 }
 impl std::fmt::Display for CreateError{
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -32,7 +43,7 @@ impl std::fmt::Display for CreateError{
 }
 impl std::error::Error for CreateError{}

-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct UploadRequest{
 	pub assetid:u64,
 	pub name:Option<String>,
@@ -46,7 +57,14 @@ pub enum UploadError{
 	ParseError(url::ParseError),
 	PostError(PostError),
 	Reqwest(reqwest::Error),
+	Response(ResponseError),
 	AssetIdIsZero,
+	ParseInt{
+		response:String,
+		err:std::num::ParseIntError,
+	},
+	VersionHeaderMissing,
+	ToStr(reqwest::header::ToStrError),
 }
 impl std::fmt::Display for UploadError{
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -55,13 +73,15 @@ impl std::fmt::Display for UploadError{
 }
 impl std::error::Error for UploadError{}
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct UploadResponse{
 	pub AssetId:u64,
-	pub AssetVersionId:u64,
+	pub AssetVersion:u64,
 }

-#[allow(nonstandard_style,dead_code)]
+pub struct GetAssetDetailsRequest{
+	pub asset_id:u64,
+}
 pub struct GetAssetRequest{
 	pub asset_id:u64,
 	pub version:Option<u64>,
@@ -69,8 +89,8 @@ pub struct GetAssetRequest{
 #[derive(Debug)]
 pub enum GetError{
 	ParseError(url::ParseError),
+	Response(ResponseError),
 	Reqwest(reqwest::Error),
-	IO(std::io::Error)
 }
 impl std::fmt::Display for GetError{
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -79,24 +99,127 @@ impl std::fmt::Display for GetError{
 }
 impl std::error::Error for GetError{}

+#[derive(Debug)]
+pub enum GetAssetV2Error{
+	ParseError(url::ParseError),
+	Response(ResponseError),
+	VersionHeaderMissing,
+	ToStr(reqwest::header::ToStrError),
+	ParseInt(std::num::ParseIntError),
+	Reqwest(reqwest::Error),
+}
+impl std::fmt::Display for GetAssetV2Error{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for GetAssetV2Error{}
+
+#[derive(serde::Deserialize)]
+#[expect(nonstandard_style)]
+pub struct GetAssetV2AssetMetadata{
+	pub metadataType:u32,
+	pub value:String,
+}
+#[derive(serde::Deserialize)]
+#[expect(nonstandard_style)]
+pub struct GetAssetV2Location{
+	pub assetFormat:String,// "source"
+	location:String,// this value is private so users cannot mutate it
+	#[serde(default)]
+	pub assetMetadatas:Vec<GetAssetV2AssetMetadata>,
+}
+impl GetAssetV2Location{
+	pub fn location(&self)->&str{
+		&self.location
+	}
+}
+#[derive(serde::Deserialize)]
+#[expect(nonstandard_style)]
+pub struct GetAssetV2Info{
+	pub locations:Vec<GetAssetV2Location>,
+	pub requestId:String,
+	pub isArchived:bool,
+	pub assetTypeId:u32,
+	pub isRecordable:Option<bool>,
+	pub IsHashDynamic:Option<bool>,
+	pub IsCopyrightProtected:Option<bool>,
+}
+
+pub struct GetAssetV2{
+	pub version:u64,
+	pub info:GetAssetV2Info,
+}
+
+#[derive(Clone,Copy,Debug,Eq,PartialEq,Hash)]
+#[derive(serde::Deserialize,serde::Serialize)]
+pub enum CreatorType{
+	User,
+	Group,
+}
+
+#[derive(Debug)]
+#[derive(serde::Deserialize)]
+#[expect(nonstandard_style)]
+pub struct Creator{
+	pub Id:u64,
+	pub Name:String,
+	pub CreatorType:CreatorType,
+	pub CreatorTargetId:u64,
+	pub HasVerifiedBadge:bool,
+}
+
+#[derive(Debug)]
+#[derive(serde::Deserialize)]
+#[expect(nonstandard_style)]
+pub struct AssetDetails{
+	pub TargetId:u64,
+	pub ProductType:Option<String>,
+	pub AssetId:u64,
+	pub ProductId:u64,
+	pub Name:String,
+	pub Description:String,
+	pub AssetTypeId:u32,
+	pub Creator:Creator,
+	pub IconImageAssetId:u64,
+	pub Created:chrono::DateTime<chrono::Utc>,
+	pub Updated:chrono::DateTime<chrono::Utc>,
+	pub PriceInRobux:Option<u32>,
+	pub PriceInTickets:Option<u32>,
+	pub Sales:u32,
+	pub IsNew:bool,
+	pub IsForSale:bool,
+	pub IsPublicDomain:bool,
+	pub IsLimited:bool,
+	pub IsLimitedUnique:bool,
+	pub Remaining:Option<u32>,
+	pub MinimumMembershipLevel:u32,
+	pub ContentRatingTypeId:u32,
+	pub SaleAvailabilityLocations:Option<String>,
+	pub SaleLocation:Option<String>,
+	pub CollectibleItemId:Option<u64>,
+	pub CollectibleProductId:Option<u64>,
+	pub CollectiblesItemDetails:Option<String>,
+}
+
 pub struct AssetVersionsPageRequest{
 	pub asset_id:u64,
 	pub cursor:Option<String>,
 }
 #[derive(serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct AssetVersion{
 	pub Id:u64,
 	pub assetId:u64,
 	pub assetVersionNumber:u64,
-	pub creatorType:String,
+	pub creatorType:CreatorType,
 	pub creatorTargetId:u64,
 	pub creatingUniverseId:Option<u64>,
 	pub created:chrono::DateTime<chrono::Utc>,
 	pub isPublished:bool,
 }
 #[derive(serde::Deserialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct AssetVersionsPageResponse{
 	pub previousPageCursor:Option<String>,
 	pub nextPageCursor:Option<String>,
@@ -105,6 +228,7 @@ pub struct AssetVersionsPageResponse{
 #[derive(Debug)]
 pub enum PageError{
 	ParseError(url::ParseError),
+	Response(ResponseError),
 	Reqwest(reqwest::Error),
 }
 impl std::fmt::Display for PageError{
@@ -131,13 +255,12 @@ pub struct CreationsPageRequest{
 	pub cursor:Option<String>,
 }
 #[derive(serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
 pub struct CreationsItem{
 	pub id:u64,
 	pub name:String,
 }
 #[derive(serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct CreationsPageResponse{
 	pub totalResults:u64,//up to 50
 	pub filteredKeyword:Option<String>,//""
@@ -156,68 +279,102 @@ pub struct UserInventoryPageRequest{
 }

 #[derive(serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct UserInventoryItemOwner{
-	userId:u64,
-	username:String,
-	buildersClubMembershipType:u64,
+	pub userId:u64,
+	pub username:String,
+	pub buildersClubMembershipType:String,
 }
 #[derive(serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct UserInventoryItem{
-	userAssetId:u64,
-	assetId:u64,
-	assetName:String,
-	collectibleItemId:Option<String>,
-	collectibleItemInstanceId:Option<String>,
-	owner:UserInventoryItemOwner,
-	created:chrono::DateTime<chrono::Utc>,
-	updated:chrono::DateTime<chrono::Utc>,
+	pub userAssetId:u64,
+	pub assetId:u64,
+	pub assetName:String,
+	pub collectibleItemId:Option<String>,
+	pub collectibleItemInstanceId:Option<String>,
+	pub owner:UserInventoryItemOwner,
+	pub created:chrono::DateTime<chrono::Utc>,
+	pub updated:chrono::DateTime<chrono::Utc>,
 }
 #[derive(serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
+#[expect(nonstandard_style)]
 pub struct UserInventoryPageResponse{
 	pub previousPageCursor:Option<String>,
 	pub nextPageCursor:Option<String>,
 	pub data:Vec<UserInventoryItem>,
 }

-//idk how to do this better
-enum ReaderType<R:std::io::Read>{
-	GZip(flate2::read::GzDecoder<std::io::BufReader<R>>),
-	Raw(std::io::BufReader<R>),
+#[derive(Debug)]
+pub enum SetAssetsPermissionsError{
+	Parse(url::ParseError),
+	JSONEncode(serde_json::Error),
+	Patch(PostError),
+	Response(ResponseError),
+	Reqwest(reqwest::Error),
 }
-fn maybe_gzip_decode<R:std::io::Read>(input:R)->std::io::Result<ReaderType<R>>{
-	let mut buf=std::io::BufReader::new(input);
-	let peek=std::io::BufRead::fill_buf(&mut buf)?;
-	match &peek[0..2]{
-		b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(buf))),
-		_=>Ok(ReaderType::Raw(buf)),
+impl std::fmt::Display for SetAssetsPermissionsError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
 	}
 }
-fn read_readable(mut readable:impl std::io::Read)->std::io::Result<Vec<u8>>{
-	let mut contents=Vec::new();
-	readable.read_to_end(&mut contents)?;
-	Ok(contents)
+impl std::error::Error for SetAssetsPermissionsError{}
+
+#[derive(serde::Serialize)]
+#[expect(nonstandard_style)]
+struct AssetPermissions{
+	assetId:u64,
+	grantToDependencies:bool,//true
+}
+#[derive(serde::Serialize)]
+#[expect(nonstandard_style)]
+struct SetAssetsPermissions<'a>{
+	subjectType:&'a str,// "Universe"
+	subjectId:&'a str,// "4422715291"
+	action:&'a str,// "Use",
+	enableDeepAccessCheck:bool,//true,
+	requests:&'a [AssetPermissions],
+}
+pub struct SetAssetsPermissionsRequest<'a>{
+	pub universe_id:u64,
+	pub asset_ids:&'a [u64],
+}
+impl SetAssetsPermissionsRequest<'_>{
+	fn serialize(&self)->Result<String,serde_json::Error>{
+		let ref requests:Vec<_>=self.asset_ids.iter().map(|&asset_id|AssetPermissions{
+			assetId:asset_id,
+			grantToDependencies:true,
+		}).collect();
+		let ref subject_id=self.universe_id.to_string();
+		let ref permissions=SetAssetsPermissions{
+			subjectType:"Universe",
+			subjectId:subject_id,
+			action:"Use",
+			enableDeepAccessCheck:true,
+			requests,
+		};
+		serde_json::to_string(permissions)
+	}
 }

 #[derive(Clone)]
 pub struct Cookie(String);
 impl Cookie{
+	/// cookie is prepended with ".ROBLOSECURITY=" by this function
 	pub fn new(cookie:String)->Self{
-		Self(cookie)
+		Self(format!(".ROBLOSECURITY={cookie}"))
 	}
 	pub fn get(self)->String{
 		self.0
 	}
 }
 #[derive(Clone)]
-pub struct CookieContext{
-	pub cookie:String,
-	pub client:reqwest::Client,
+pub struct Context{
+	cookie:String,
+	client:reqwest::Client,
 }

-impl CookieContext{
+impl Context{
 	pub fn new(cookie:Cookie)->Self{
 		Self{
 			cookie:cookie.get(),
@@ -250,6 +407,29 @@ impl CookieContext{

 		Ok(resp)
 	}
+	async fn patch(&self,url:url::Url,body:impl ContentType+Clone)->Result<reqwest::Response,PostError>{
+		let mut resp=self.client.patch(url.clone())
+		.header("Cookie",self.cookie.as_str())
+		.header("Content-Type",body.content_type())
+		.body(body.clone())
+		.send().await.map_err(PostError::Reqwest)?;
+
+		//This is called a CSRF challenge apparently
+		if resp.status()==reqwest::StatusCode::FORBIDDEN{
+			if let Some(csrf_token)=resp.headers().get("X-CSRF-Token"){
+				resp=self.client.patch(url)
+				.header("X-CSRF-Token",csrf_token)
+				.header("Cookie",self.cookie.as_str())
+				.header("Content-Type",body.content_type())
+				.body(body)
+				.send().await.map_err(PostError::Reqwest)?;
+			}else{
+				Err(PostError::CSRF)?;
+			}
+		}
+
+		Ok(resp)
+	}
 	pub async fn create(&self,config:CreateRequest,body:impl Into<reqwest::Body>+Clone)->Result<UploadResponse,CreateError>{
 		let mut url=reqwest::Url::parse("https://data.roblox.com/Data/Upload.ashx?json=1&type=Model&genreTypeId=1").map_err(CreateError::ParseError)?;
 		//url borrow scope
@@ -265,10 +445,31 @@ impl CookieContext{
 				query.append_pair("groupId",group_id.to_string().as_str());
 			}
 		}
+		let response=response_ok(
+			self.post(url,body).await.map_err(CreateError::PostError)?
+		).await.map_err(CreateError::Response)?;

-		self.post(url,body).await.map_err(CreateError::PostError)?
-		.error_for_status().map_err(CreateError::Reqwest)?
-		.json::<UploadResponse>().await.map_err(CreateError::Reqwest)
+		let version_str=response
+			.headers()
+			.get("roblox-assetversionnumber")
+			.ok_or(CreateError::VersionHeaderMissing)?
+			.to_str()
+			.map_err(CreateError::ToStr)?;
+		let version=version_str.parse()
+			.map_err(|err|CreateError::ParseInt{err,response:version_str.to_owned()})?;
+
+		let response=response.text().await.map_err(CreateError::Reqwest)?;
+
+		match response.parse(){
+			Ok(asset_id)=>Ok(UploadResponse{
+				AssetId:asset_id,
+				AssetVersion:version,
+			}),
+			Err(err)=>Err(CreateError::ParseInt{
+				response,
+				err,
+			})
+		}
 	}
 	pub async fn upload(&self,config:UploadRequest,body:impl Into<reqwest::Body>+Clone)->Result<UploadResponse,UploadError>{
 		let mut url=reqwest::Url::parse("https://data.roblox.com/Data/Upload.ashx?json=1&type=Model&genreTypeId=1").map_err(UploadError::ParseError)?;
@@ -296,12 +497,33 @@ impl CookieContext{
 				query.append_pair("groupId",group_id.to_string().as_str());
 			}
 		}
+		let response=response_ok(
+			self.post(url,body).await.map_err(UploadError::PostError)?
+		).await.map_err(UploadError::Response)?;

-		self.post(url,body).await.map_err(UploadError::PostError)?
-		.error_for_status().map_err(UploadError::Reqwest)?
-		.json::<UploadResponse>().await.map_err(UploadError::Reqwest)
+		let version_str=response
+			.headers()
+			.get("roblox-assetversionnumber")
+			.ok_or(UploadError::VersionHeaderMissing)?
+			.to_str()
+			.map_err(UploadError::ToStr)?;
+		let version=version_str.parse()
+			.map_err(|err|UploadError::ParseInt{err,response:version_str.to_owned()})?;
+
+		let response=response.text().await.map_err(UploadError::Reqwest)?;
+
+		match response.parse(){
+			Ok(asset_id)=>Ok(UploadResponse{
+				AssetId:asset_id,
+				AssetVersion:version,
+			}),
+			Err(err)=>Err(UploadError::ParseInt{
+				response,
+				err,
+			})
+		}
 	}
-	pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{
+	pub async fn get_asset(&self,config:GetAssetRequest)->Result<MaybeGzippedBytes,GetError>{
 		let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(GetError::ParseError)?;
 		//url borrow scope
 		{
@@ -311,17 +533,62 @@ impl CookieContext{
 				query.append_pair("version",version.to_string().as_str());
 			}
 		}
-		let body=self.get(url).await.map_err(GetError::Reqwest)?
-		.error_for_status().map_err(GetError::Reqwest)?
+
+		let bytes=response_ok(
+			self.get(url).await.map_err(GetError::Reqwest)?
+		).await.map_err(GetError::Response)?
 		.bytes().await.map_err(GetError::Reqwest)?;

-		match maybe_gzip_decode(&mut std::io::Cursor::new(body)){
-			Ok(ReaderType::GZip(readable))=>read_readable(readable),
-			Ok(ReaderType::Raw(readable))=>read_readable(readable),
-			Err(e)=>Err(e),
-		}.map_err(GetError::IO)
+		Ok(MaybeGzippedBytes::new(bytes))
 	}
-	pub async fn get_asset_versions_page(&self,config:AssetVersionsPageRequest)->Result<AssetVersionsPageResponse,PageError>{
+	pub async fn get_asset_v2(&self,config:GetAssetRequest)->Result<GetAssetV2,GetAssetV2Error>{
+		let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v2/asset").map_err(GetAssetV2Error::ParseError)?;
+		//url borrow scope
+		{
+			let mut query=url.query_pairs_mut();//borrow here
+			query.append_pair("ID",config.asset_id.to_string().as_str());
+			if let Some(version)=config.version{
+				query.append_pair("version",version.to_string().as_str());
+			}
+		}
+		let response=response_ok(
+			self.get(url).await.map_err(GetAssetV2Error::Reqwest)?
+		).await.map_err(GetAssetV2Error::Response)?;
+
+		let version=response
+			.headers()
+			.get("roblox-assetversionnumber")
+			.ok_or(GetAssetV2Error::VersionHeaderMissing)?
+			.to_str()
+			.map_err(GetAssetV2Error::ToStr)?
+			.parse()
+			.map_err(GetAssetV2Error::ParseInt)?;
+
+		let info=response.json().await.map_err(GetAssetV2Error::Reqwest)?;
+
+		Ok(GetAssetV2{
+			version,
+			info,
+		})
+	}
+	pub async fn get_asset_v2_download(&self,config:&GetAssetV2Location)->Result<MaybeGzippedBytes,GetError>{
+		let url=reqwest::Url::parse(config.location.as_str()).map_err(GetError::ParseError)?;
+
+		let bytes=response_ok(
+			self.get(url).await.map_err(GetError::Reqwest)?
+		).await.map_err(GetError::Response)?
+		.bytes().await.map_err(GetError::Reqwest)?;
+
+		Ok(MaybeGzippedBytes::new(bytes))
+	}
+	pub async fn get_asset_details(&self,config:GetAssetDetailsRequest)->Result<AssetDetails,GetError>{
+		let url=reqwest::Url::parse(format!("https://economy.roblox.com/v2/assets/{}/details",config.asset_id).as_str()).map_err(GetError::ParseError)?;
+		response_ok(
+			self.get(url).await.map_err(GetError::Reqwest)?
+		).await.map_err(GetError::Response)?
+		.json().await.map_err(GetError::Reqwest)
+	}
+	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
 		{
@@ -333,9 +600,9 @@ impl CookieContext{
 				query.append_pair("cursor",cursor);
 			}
 		}
-
-		self.get(url).await.map_err(PageError::Reqwest)?
-		.error_for_status().map_err(PageError::Reqwest)?
+		response_ok(
+			self.get(url).await.map_err(PageError::Reqwest)?
+		).await.map_err(PageError::Response)?
 		.json::<AssetVersionsPageResponse>().await.map_err(PageError::Reqwest)
 	}
 	pub async fn get_creations_page(&self,config:&CreationsPageRequest)->Result<CreationsPageResponse,PageError>{
@@ -348,9 +615,9 @@ impl CookieContext{
 				query.append_pair("cursor",cursor);
 			}
 		}
-
-		self.get(url).await.map_err(PageError::Reqwest)?
-		.error_for_status().map_err(PageError::Reqwest)?
+		response_ok(
+			self.get(url).await.map_err(PageError::Reqwest)?
+		).await.map_err(PageError::Response)?
 		.json::<CreationsPageResponse>().await.map_err(PageError::Reqwest)
 	}
 	pub async fn get_user_inventory_page(&self,config:&UserInventoryPageRequest)->Result<UserInventoryPageResponse,PageError>{
@@ -362,9 +629,21 @@ impl CookieContext{
 				query.append_pair("cursor",cursor);
 			}
 		}
-
-		self.get(url).await.map_err(PageError::Reqwest)?
-		.error_for_status().map_err(PageError::Reqwest)?
+		response_ok(
+			self.get(url).await.map_err(PageError::Reqwest)?
+		).await.map_err(PageError::Response)?
 		.json::<UserInventoryPageResponse>().await.map_err(PageError::Reqwest)
 	}
+	/// Used to enable an asset to be loaded onto a group game.
+	pub async fn set_assets_permissions(&self,config:SetAssetsPermissionsRequest<'_>)->Result<(),SetAssetsPermissionsError>{
+		let url=reqwest::Url::parse("https://apis.roblox.com/asset-permissions-api/v1/assets/permissions").map_err(SetAssetsPermissionsError::Parse)?;
+
+		let body=config.serialize().map_err(SetAssetsPermissionsError::JSONEncode)?;
+
+		response_ok(
+			self.patch(url,Json(body)).await.map_err(SetAssetsPermissionsError::Patch)?
+		).await.map_err(SetAssetsPermissionsError::Response)?;
+
+		Ok(())
+	}
 }
--- a/rbx_asset/src/lib.rs
+++ b/rbx_asset/src/lib.rs
@@ -1,2 +1,5 @@
 pub mod cloud;
 pub mod cookie;
+pub mod types;
+mod body;
+mod util;
--- a/rbx_asset/src/types.rs
+++ b/rbx_asset/src/types.rs
@@ -0,0 +1,67 @@
+#[derive(Debug)]
+pub struct UrlAndBody{
+	pub url:url::Url,
+	pub body:String,
+}
+#[derive(Debug)]
+pub enum ResponseError{
+	Reqwest(reqwest::Error),
+	Details{
+		status_code:reqwest::StatusCode,
+		url_and_body:Box<UrlAndBody>,
+	},
+}
+impl std::fmt::Display for ResponseError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for ResponseError{}
+
+#[cfg(feature="gzip")]
+use flate2::read::GzDecoder;
+
+/// Some bytes that might be gzipped.  Use the read_with or to_vec methods to transparently decode gzip.
+pub struct MaybeGzippedBytes{
+	bytes:bytes::Bytes,
+}
+impl MaybeGzippedBytes{
+	pub(crate) fn new(bytes:bytes::Bytes)->Self{
+		Self{bytes}
+	}
+	pub fn into_inner(self)->bytes::Bytes{
+		self.bytes
+	}
+	/// get a reference to the bytes, ignoring gzip decoding
+	pub fn as_raw_ref(&self)->&[u8]{
+		self.bytes.as_ref()
+	}
+	/// Transparently decode gzip data, if present (intermediate allocation)
+	#[cfg(feature="gzip")]
+	pub fn to_vec(&self)->std::io::Result<Vec<u8>>{
+		use std::io::Read;
+		match self.bytes.get(0..2){
+			Some(b"\x1f\x8b")=>{
+				let mut buf=Vec::new();
+				GzDecoder::new(self.bytes.as_ref()).read_to_end(&mut buf)?;
+				Ok(buf)
+			},
+			_=>Ok(self.bytes.to_vec())
+		}
+	}
+	/// Read the bytes with the provided decoders.
+	/// The idea is to make a function that is generic over std::io::Read
+	/// and pass the same function to both closures.
+	/// This two closure hack must be done because of the different concrete types.
+	#[cfg(feature="gzip")]
+	pub fn read_with<'a,ReadGzip,ReadRaw,T>(&'a self,read_gzip:ReadGzip,read_raw:ReadRaw)->T
+		where
+			ReadGzip:Fn(GzDecoder<&'a [u8]>)->T,
+			ReadRaw:Fn(&'a [u8])->T,
+	{
+		match self.bytes.get(0..2){
+			Some(b"\x1f\x8b")=>read_gzip(GzDecoder::new(self.bytes.as_ref())),
+			_=>read_raw(self.bytes.as_ref())
+		}
+	}
+}
--- a/rbx_asset/src/util.rs
+++ b/rbx_asset/src/util.rs
@@ -0,0 +1,39 @@
+use crate::types::{ResponseError,UrlAndBody};
+
+// lazy function to draw out meaningful info from http response on failure
+pub(crate) async fn response_ok(response:reqwest::Response)->Result<reqwest::Response,ResponseError>{
+	let status_code=response.status();
+	if status_code.is_success(){
+		Ok(response)
+	}else{
+		let url=response.url().to_owned();
+		let bytes=response.bytes().await.map_err(ResponseError::Reqwest)?;
+		let body=String::from_utf8_lossy(&bytes).to_string();
+		Err(ResponseError::Details{
+			status_code,
+			url_and_body:Box::new(UrlAndBody{url,body})
+		})
+	}
+}
+
+use serde::de::{Error,Unexpected};
+use serde::{Deserializer,Serializer};
+
+struct U64StringVisitor;
+impl serde::de::Visitor<'_> for U64StringVisitor{
+	type Value=u64;
+	fn expecting(&self,formatter:&mut std::fmt::Formatter)->std::fmt::Result{
+		write!(formatter,"string value with int")
+	}
+	fn visit_str<E:Error>(self,v:&str)->Result<Self::Value,E>{
+		v.parse().map_err(|_|E::invalid_value(Unexpected::Str(v),&"u64"))
+	}
+}
+
+pub(crate) fn deserialize_u64<'de,D:Deserializer<'de>>(deserializer:D)->Result<u64,D::Error>{
+	deserializer.deserialize_any(U64StringVisitor)
+}
+
+pub(crate) fn serialize_u64<S:Serializer>(v:&u64,serializer:S)->Result<S::Ok,S::Error>{
+	serializer.serialize_str(v.to_string().as_str())
+}
--- a/rox_compiler/Cargo.toml
+++ b/rox_compiler/Cargo.toml
@@ -10,8 +10,8 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]

 [dependencies]
 futures = "0.3.30"
-lazy-regex = "3.1.0"
+regex = { version = "1.11.3", default-features = false, features = ["unicode-perl"] }
 rayon = "1.8.0"
-rbx_dom_weak = "2.7.0"
-rbx_xml = "0.13.3"
+rbx_dom_weak = "4.0.0"
+rbx_xml = "2.0.0"
 tokio = { version = "1.35.1", features = ["fs"] }
--- a/rox_compiler/src/common.rs
+++ b/rox_compiler/src/common.rs
@@ -28,6 +28,16 @@ impl std::fmt::Display for PropertiesOverride{
 	}
 }

-pub(crate) fn sanitize(s:&str)->std::borrow::Cow<'_,str>{
-	lazy_regex::regex!(r"[^A-Za-z0-9.-]").replace_all(s,"_")
+#[macro_export]
+macro_rules! lazy_regex{
+	($r:literal)=>{{
+		use regex::Regex;
+		use std::sync::LazyLock;
+		static RE:LazyLock<Regex>=LazyLock::new(||Regex::new($r).unwrap());
+		&RE
+	}};
+}
+
+pub(crate) fn sanitize(s:&str)->std::borrow::Cow<'_,str>{
+	lazy_regex!(r"[^A-Za-z0-9.-]").replace_all(s,"_")
 }
--- a/rox_compiler/src/compile.rs
+++ b/rox_compiler/src/compile.rs
@@ -2,6 +2,7 @@ use std::path::{Path,PathBuf};
 use futures::{StreamExt, TryStreamExt};
 use tokio::io::AsyncReadExt;

+use crate::lazy_regex;
 use crate::common::{sanitize,Style,PropertiesOverride};

 //holy smokes what am I doing lmao
@@ -16,7 +17,6 @@ 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
@@ -203,7 +203,7 @@ impl ScriptWithOverrides{
 		let mut count=0;
 		for line in source.lines(){
 			//only string type properties are supported atm
-			if let Some(captures)=lazy_regex::regex!(r#"^\-\-\s*Properties\.([A-Za-z]\w*)\s*\=\s*"(\w+)"$"#)
+			if let Some(captures)=lazy_regex!(r#"^\-\-\s*Properties\.([A-Za-z]\w*)\s*\=\s*"(\w+)"$"#)
 			.captures(line){
 				count+=line.len();
 				match &captures[1]{
@@ -340,7 +340,7 @@ impl CompileNode{
 		//reject goobers
 		let is_goober=matches!(style,Some(Style::Rojo));
 		let (ext_len,file_discernment)={
-			if let Some(captures)=lazy_regex::regex!(r"^.*(\.module\.lua|\.client\.lua|\.server\.lua)$")
+			if let Some(captures)=lazy_regex!(r"^.*(\.module\.lua|\.client\.lua|\.server\.lua)$")
 			.captures(file_name.as_str()){
 				let ext=&captures[1];
 				(ext.len(),match ext{
@@ -354,7 +354,7 @@ impl CompileNode{
 					".server.lua"=>FileDiscernment::Script(ScriptHint::Script),
 					_=>panic!("Regex failed"),
 				})
-			}else if let Some(captures)=lazy_regex::regex!(r"^.*(\.rbxmx|\.lua)$")
+			}else if let Some(captures)=lazy_regex!(r"^.*(\.rbxmx|\.lua)$")
 			.captures(file_name.as_str()){
 				let ext=&captures[1];
 				(ext.len(),match ext{
--- a/rox_compiler/src/decompile.rs
+++ b/rox_compiler/src/decompile.rs
@@ -1,4 +1,5 @@
 use std::path::PathBuf;
+use rbx_dom_weak::ustr;
 use rbx_dom_weak::types::Ref;
 use crate::common::{sanitize,Style,PropertiesOverride};

@@ -90,7 +91,7 @@ fn write_item(dom:&rbx_dom_weak::WeakDom,mut file:PathBuf,node:&TreeNode,node_na

 			if let Some(item)=dom.get_by_ref(node.referent){
 				//TODO: delete disabled scripts
-				if let Some(rbx_dom_weak::types::Variant::String(source))=item.properties.get("Source"){
+				if let Some(rbx_dom_weak::types::Variant::String(source))=item.properties.get(&ustr("Source")){
 					if properties.is_some(){
 						//rox style
 						let source=properties.to_string()+source.as_str();
--- a/src/main.rs
+++ b/src/main.rs
Author	SHA1	Message	Date
Rhys Lloyd	e10cfcfcb5	rox_compiler: fix regex	2025-12-20 15:54:07 -08:00
Rhys Lloyd	3ec2b659f3	v0.5.1	2025-12-13 14:35:32 -08:00
Rhys Lloyd	5a95ccc633	remove unused lints	2025-12-09 14:32:12 -08:00
Rhys Lloyd	68a0c7113e	use expect instead of allow	2025-12-09 14:31:58 -08:00
Rhys Lloyd	2088256e29	update deps	2025-11-27 15:30:53 -08:00
Rhys Lloyd	d50e86f809	update deps	2025-11-09 06:06:00 -08:00
Rhys Lloyd	b37b08d564	drop lazy_regex dep	2025-11-09 06:04:36 -08:00
Rhys Lloyd	d66f786aca	fix deploy	2025-08-28 04:06:18 -07:00
Rhys Lloyd	e05c1ddabf	put git behind feature flag to prevent openssl woes	2025-08-25 21:03:38 -07:00
Rhys Lloyd	a2b4980bf3	asset-tool: use rustls	2025-08-25 20:59:05 -07:00
Rhys Lloyd	ad3c446b43	fix deploy	2025-08-25 20:54:56 -07:00
Rhys Lloyd	6cc9ded572	fix deploy	2025-08-25 20:53:04 -07:00
Rhys Lloyd	2faddb741f	asset-tool v0.5.0 new commands + minor breaking changes	2025-08-25 20:43:10 -07:00
Rhys Lloyd	f59a2e0b6a	rbx_asset v0.5.0 minor braking changes	2025-08-25 20:41:29 -07:00
Rhys Lloyd	e5e75ef3cb	DownloadCreationsHistory	2025-08-25 19:47:16 -07:00
Rhys Lloyd	fdf0c14309	detect resume files correctly in download_creations_pages_from_checkpoint	2025-08-25 19:47:16 -07:00
Rhys Lloyd	8885eb744b	propagate error in download_creations_pages_from_checkpoint	2025-08-25 19:47:14 -07:00
Rhys Lloyd	c0ded31a6a	delete cursor when completed	2025-08-25 19:47:12 -07:00
Rhys Lloyd	d9bf50e1c4	fix get_creations_pages	2025-08-25 19:47:10 -07:00
Rhys Lloyd	55d5f97f0b	rbx_asset: update GetAssetV2Info	2025-08-25 17:41:58 -07:00
Rhys Lloyd	7665ccc5d1	rbx_asset: accept reference in get_asset_versions_page	2025-08-25 16:04:56 -07:00
Rhys Lloyd	24f50de2ae	use sort_by_key	2025-08-25 15:47:26 -07:00
Rhys Lloyd	afd8a74e34	add continue from cursor option to DownloadCreationsJson	2025-08-25 15:47:26 -07:00
Rhys Lloyd	ddf294c6f9	rename cursor.json to just cursor	2025-08-25 15:35:25 -07:00
Rhys Lloyd	a9a8c01cb1	do creations pages like user	2025-08-25 15:35:13 -07:00
Rhys Lloyd	287969b7d5	update UserInventoryItemOwner.buildersClubMembershipType type	2025-08-23 21:34:50 -07:00
Rhys Lloyd	b80868e722	v0.4.10 Luau Execution API	2025-08-09 00:06:13 -07:00
Rhys Lloyd	e1503ba898	v0.4.10-pre2	2025-08-08 20:35:33 -07:00
Rhys Lloyd	97086e351f	rbx_asset: rename LuauSessionLatestRequest	2025-08-08 20:35:33 -07:00
Rhys Lloyd	89d96db03c	rbx_asset: unversioned request	2025-08-08 20:32:52 -07:00
Rhys Lloyd	6b9ae59e7f	v0.4.10-pre1 Luau Execution API	2025-08-08 20:27:46 -07:00
Rhys Lloyd	dd4344f514	Luau Execution API (#18 ) Tested to some extent Reviewed-on: StrafesNET/asset-tool#18 Co-authored-by: Rhys Lloyd <krakow20@gmail.com> Co-committed-by: Rhys Lloyd <krakow20@gmail.com>	2025-08-09 03:26:03 +00:00
Rhys Lloyd	8a400faae2	rbx_asset: rename GetError variant	2025-08-08 17:33:26 -07:00
Rhys Lloyd	6dff5f5145	rbx_asset: relax operation allocation requirement	2025-08-08 16:59:24 -07:00
Rhys Lloyd	f3f048e293	v0.4.9 rustls passthru	2025-08-05 21:20:31 -07:00
Rhys Lloyd	10c9ddd696	goofy feature stuff	2025-08-05 21:17:01 -07:00
Rhys Lloyd	d73567050c	update deps	2025-08-05 21:14:30 -07:00
Rhys Lloyd	c1e53e42bc	remove attributes OBE	2025-08-05 21:09:47 -07:00
Rhys Lloyd	b3defd31fc	replace allow with expect	2025-08-05 21:08:23 -07:00
Quaternions	bf3b429c66	rbx_asset v0.4.8 default field	2025-07-01 04:56:23 -07:00
Quaternions	20899a3fae	rbx_asset: default field	2025-07-01 04:55:56 -07:00
Quaternions	d60cedf430	rbx_asset: v0.4.7 roblox api changed	2025-07-01 01:12:43 -07:00
Quaternions	ad435fb8c9	update deps	2025-07-01 01:12:43 -07:00
Quaternions	9f1bdd6a1f	rbx_asset: roblox api changed	2025-07-01 01:08:51 -07:00
Quaternions	0bf0b92efb	asset location commands	2025-06-13 20:04:18 -07:00
Quaternions	41cd60c459	untab	2025-06-13 20:04:07 -07:00
Quaternions	52a0bf221b	rbx_asset: visibility mistake	2025-06-11 23:34:21 -07:00
Quaternions	f2bd298cd1	rbx_asset: try out ref for funsies	2025-06-11 23:34:21 -07:00
Quaternions	89bbe00e3d	Set Universe Asset Permissions (#17 ) This implements an endpoint to set universe asset permissions. Reviewed-on: StrafesNET/asset-tool#17 Co-authored-by: Quaternions <krakow20@gmail.com> Co-committed-by: Quaternions <krakow20@gmail.com>	2025-06-12 02:33:12 +00:00
Quaternions	369f19452c	rbx_asset: omit Cursor	2025-05-13 23:44:11 -07:00
Quaternions	9e78be3d09	rbx_asset v0.4.5 fix error type	2025-05-13 23:28:00 -07:00
Quaternions	70414d94ae	clippy fixes	2025-05-13 23:26:15 -07:00
Quaternions	819eea1b4a	rbx_asset: error type is too damn big	2025-05-13 23:23:58 -07:00
Quaternions	9eabb0197c	asset-tool v0.4.12 update rbx-dom	2025-04-30 17:23:36 -07:00
Quaternions	fa9d42fc1f	update deps	2025-04-30 17:13:02 -07:00
Quaternions	8f754f0bca	update rbx-dom	2025-04-30 17:12:49 -07:00
Quaternions	450b6a0829	update deps	2025-04-10 17:26:47 -07:00
Quaternions	091a2a92f1	rbx_asset: v0.4.4 parse string ints + save intermediate allocation	2025-04-10 17:24:49 -07:00
Quaternions	31aae80cc5	rbx_asset: change api to save intermediate allocation	2025-04-10 17:24:49 -07:00
Quaternions	041cc75015	rbx_asset: move code into util, types	2025-04-10 17:24:49 -07:00
Quaternions	d77312309f	rbx_asset: helpers for integers within a string	2025-04-10 17:24:49 -07:00
Quaternions	50145460b9	rbx_asset: simplify gzip logic	2025-04-10 00:25:34 -07:00
Quaternions	df2a5bb9ce	rbx_asset: v0.4.3 optional AssetLocation	2025-04-08 16:54:59 -07:00
Quaternions	e40041a894	rbx_asset: change api for asset location again	2025-04-08 16:54:14 -07:00
Quaternions	45c1e52c0f	rbx_asset: v0.4.2	2025-04-05 14:53:47 -07:00
Quaternions	0196f47374	rbx_asset: description is optional	2025-04-05 14:53:32 -07:00
Quaternions	a8163014ad	rbx_asset: v0.4.1	2025-04-05 14:23:26 -07:00
Quaternions	4d26e7ad19	rbx_asset: discover asset location	2025-04-05 14:21:57 -07:00
Quaternions	99077cf467	rbx_asset: v0.4.0	2025-04-05 13:51:16 -07:00
Quaternions	302603998e	rbx_asset: cloud: implement new asset-delivery-api	2025-04-05 13:09:59 -07:00
Quaternions	71cae5c089	rbx_asset: cloud: tweak asset info requests, remove get_asset	2025-04-05 13:09:25 -07:00
Quaternions	fb9dd8660d	rbx_asset: deduplicate common code	2025-04-05 12:59:44 -07:00
Quaternions	64e4887b83	rbx_asset: use #[serde(default)] instead of Option<Vec<_>>	2025-04-05 12:59:24 -07:00
Quaternions	d125829a00	rbx_asset: rename CloudContext & CookieContext to Context	2025-04-05 12:23:39 -07:00
Quaternions	5509fd2166	rbx_asset: context fields should be private	2025-04-05 12:23:13 -07:00
Quaternions	e17db96e86	asset-tool v0.4.11 continue feature for DownloadUserInventoryJson	2025-04-04 13:53:19 -07:00
Quaternions	875b059074	asset-tool: tweak get_user_inventory_pages	2025-04-04 13:53:19 -07:00
Quaternions	9b1c709e7c	asset-tool: add continue to DownloadUserInventoryJson	2025-04-04 13:36:18 -07:00
Quaternions	ebd48269b8	rbx_asset: v0.3.4 UploadResponse.AssetVersion	2025-04-03 16:14:33 -07:00
Quaternions	5a4ac0e7f2	rbx_asset: include asset version in UploadResponse	2025-04-03 16:13:45 -07:00
Quaternions	68ebbad7a7	rbx_asset: v0.3.3 optional field	2025-04-03 13:56:10 -07:00
Quaternions	c99b752738	rbx_asset: optional field on AssetDetails	2025-04-03 13:56:02 -07:00
Quaternions	4f798e5f07	rbx_asset: v0.3.1 fix missing field	2025-04-03 13:55:56 -07:00
Quaternions	39fa74d44a	rbx_asset: fix missing field on GetAssetV2Location	2025-04-03 13:55:56 -07:00
Quaternions	edb5ea7648	rbx_asset: v0.3.1 CreatorType traits	2025-04-03 12:57:17 -07:00
Quaternions	504ff40385	rbx_asset: derive additional traits for CreatorType	2025-04-03 12:56:42 -07:00
Quaternions	89c0ee2cc2	update deps	2025-04-03 12:53:09 -07:00
Quaternions	f7e565bd0b	asset-tool: v0.4.10	2025-04-03 12:47:02 -07:00
Quaternions	fe8062d8e0	rbx_asset: v0.3.0 add CreatorType + get_asset_details + get_asset_v2	2025-04-03 12:47:02 -07:00
Quaternions	e6fe04aa73	asset-tool: add AssetDetails	2025-04-03 12:47:02 -07:00
Quaternions	656de62bdc	asset-tool: add DownloadVersionV2	2025-04-03 12:47:02 -07:00
Quaternions	4d90a74a82	rbx_asset: get_asset_v2	2025-04-03 12:47:02 -07:00
Quaternions	fb6fb67954	rbx_asset: tweak get_asset	2025-04-03 12:45:18 -07:00
Quaternions	b0f1e964a6	rbx_asset: add get_asset_details	2025-04-03 12:45:18 -07:00
Quaternions	aea777ecd3	rbx_asset: add CreatorType	2025-04-03 12:43:16 -07:00
Quaternions	6eca84a08a	DownloadVersion command	2025-02-12 14:55:19 -08:00
Quaternions	b7bab46e04	v0.4.9 roblox error message in body	2025-02-11 13:53:16 -08:00
Quaternions	0413767ef9	v0.2.6 roblox error message in body	2025-02-11 13:50:31 -08:00
Quaternions	b69698fd8e	rbx_asset: special error for special roblox	2025-02-11 13:43:11 -08:00
Quaternions	309fc2494d	update deps	2025-02-11 13:31:14 -08:00
Quaternions	b352707b99	rbx_asset v0.2.5 better error info	2024-12-13 19:55:45 -08:00
Quaternions	81f411272f	rbx_asset keep typed UploadResponse	2024-12-13 19:55:19 -08:00
Quaternions	e45f3c2cf9	cloud: use response_ok helper function	2024-12-13 19:35:31 -08:00
Quaternions	3cd65158a0	update deps	2024-12-13 19:19:04 -08:00
Quaternions	38d78ff2c5	cookie: refactor http errors to include more useful information	2024-12-13 19:18:35 -08:00
Quaternions	c49f9e4dd3	cookie: prepend in library	2024-12-13 19:01:37 -08:00
Quaternions	a99b5a2666	update Roblox API	2024-10-23 10:43:59 -07:00
Quaternions	a693da9cb2	asset-tool v0.4.7 user inventory + git fix	2024-10-01 13:08:35 -07:00
9382	a572d10447	support output-folder option for git-related features Repository-based logic seems to automatically be made relative to the top-level path the repo was initialised with, so we can actually support an output folder with no issues here	2024-10-01 13:08:26 -07:00
9382	1b2e13b4c7	fix decompiling history into git Why does this work and the version with the directory doesn't? yeah idk. But hey, this one successfully stages the files, so ill take it	2024-10-01 13:08:23 -07:00