Export Rust core types to TypeScript with ts-rs and update CI

[HsiangNianian]

Summary by Sourcery

Export backend data structures to TypeScript for the new React-based UI and update CI to build additional targets.

New Features:

• Generate TypeScript definitions for core backend structs and enums used by the UI.
• Now use our own Azure app(DropOut) to finish the authorize process.

Enhancements:

• Annotate existing Rust models with ts-rs metadata to control exported TypeScript shapes, including tagged enums and opaque JSON fields.

Build:

• Add ts-rs as a dependency for generating TypeScript bindings from Rust types.

CI:

• Extend the Semifold CI workflow to run on the dev branch and build additional Linux musl and Windows GNU targets using cross where needed.

[sourcery-ai]

Reviewer's Guide

Adds TypeScript type generation for Tauri backend structs/enums using ts-rs, updates CI to build on additional targets (musl & Windows GNU) with cross support, switches the Microsoft auth client ID, and tweaks a few serialization details for TS/serde interoperability.

Class diagram for auth and account TypeScript-backed models

classDiagram
    class Account {
    }
    <<enumeration>> Account
    Account : Offline(OfflineAccount)
    Account : Microsoft(MicrosoftAccount)

    class OfflineAccount {
        String username
        String uuid
    }

    class MicrosoftAccount {
        String username
        String uuid
        String access_token
        String refresh_token
        u64 expires_at
    }

    class DeviceCodeResponse {
        String user_code
        String device_code
        String verification_uri
        u64 expires_in
        u64 interval
        Option~String~ message
    }

    class TokenResponse {
        String access_token
        Option~String~ refresh_token
        Option~u64~ expires_in
        String token_type
        Option~String~ scope
    }

    class MinecraftAuthResponse {
        String username
        String access_token
        String token_type
        u64 expires_in
    }

    class MinecraftProfile {
        String id
        String name
    }

    Account *-- OfflineAccount
    Account *-- MicrosoftAccount

Loading

Class diagram for download and Java management models exported to TypeScript

classDiagram
    class DownloadTask {
        String url
        PathBuf path
        u64 total_size
        bool resumable
        u32 segments
    }

    class DownloadMetadata {
        String url
        String file_name
        u64 total_size
        u64 downloaded
        u32 segments
        bool resumable
    }

    class DownloadSegment {
        u64 start
        u64 end
        u64 downloaded
        u32 index
    }

    class JavaDownloadProgress {
        String file_name
        u64 downloaded_bytes
        u64 total_bytes
        f32 progress
        bool done
    }

    class PendingJavaDownload {
        u32 major_version
        String image_type
        String jvm_impl
        String os
        String arch
    }

    class DownloadQueue {
        Vec~PendingJavaDownload~ pending_downloads
    }

    class ProgressEvent {
        String file
        u64 downloaded
        u64 total
        f32 progress
        bool done
    }

    class JavaInstallation {
        String path
        String version
        String vendor
        String image_type
    }

    class ImageType {
    }
    <<enumeration>> ImageType
    ImageType : Jre
    ImageType : Jdk

    class JavaReleaseInfo {
        u32 major_version
        String image_type
        String jvm_impl
        String os
        String arch
        String version
        String release_name
        String download_url
        String checksum
        u64 size
        bool lts
    }

    class JavaCatalog {
        Vec~JavaReleaseInfo~ releases
        Vec~u32~ available_major_versions
        Vec~String~ available_image_types
        Vec~String~ available_jvm_impls
    }

    class JavaDownloadInfo {
        String version
        String release_name
        String download_url
        String checksum
        u64 size
    }

    DownloadQueue *-- PendingJavaDownload
    JavaCatalog *-- JavaReleaseInfo

Loading

File-Level Changes

Change	Details	Files
Generate TypeScript definitions from Rust backend models using ts-rs for the new React UI	Add ts-rs as a dependency in Cargo.toml Import ts_rs::TS in core modules that define API-facing structs/enums Derive TS for many existing data structs/enums (game versions, Fabric/Forge metadata, downloader/auth/java/config/instance/assistant types, etc.) Configure #[ts(export, export_to = ...)] paths to write generated .ts files into packages/ui/src/types/generated Override some TS field types (e.g. serde_json::Value mapped to Record<string, unknown>, PathBuf mapped to string, enum naming/tagging tweaks) to better match frontend expectations	src-tauri/Cargo.toml src-tauri/src/core/game_version.rs src-tauri/src/core/fabric.rs src-tauri/src/core/downloader.rs src-tauri/src/core/auth.rs src-tauri/src/main.rs src-tauri/src/core/java.rs src-tauri/src/core/assistant.rs src-tauri/src/core/config.rs src-tauri/src/core/instance.rs src-tauri/src/core/forge.rs src-tauri/src/core/manifest.rs
Adjust authentication configuration and exported auth-related types	Change CLIENT_ID constant back to the app’s own Azure AD client ID and comment out the previous ATLauncher client ID Export DeviceCodeResponse, TokenResponse, MinecraftProfile and account-related types via ts-rs for frontend consumption	src-tauri/src/core/auth.rs
Expose additional backend view models for UI via ts-rs	Export VersionMetadata, InstalledVersion, GithubRelease, PastebinResponse, MigrationResult, FileInfo, Java-related info structs, and other UI view models used by Tauri commands	src-tauri/src/main.rs src-tauri/src/core/java.rs
Expand CI matrix to support musl and Windows GNU builds using cross where needed	Trigger Semifold CI on both main and dev branches Re-enable Linux x86_64 musl build and configure it to use cross Re-enable Windows x86_64 GNU build with additional rustflags for ws2_32 linking Plumb optional matrix fields (use-cross, rustflags) into the tauri-action step, including switching between cargo and cross based on the matrix Install cross conditionally when required by the matrix	.github/workflows/semifold-ci.yaml

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[HsiangNianian]

@SourceryAI title

[github-actions]

Workspace change through: c46d6c5

2 changesets found

Planned changes to release

Package	Bump Level	Current Version	Next Version
dropout	patch	0.2.0-alpha.1	0.2.0-alpha.2
dropout-macros	patch	0.1.0	0.1.0-alpha.0

[sourcery-ai]

Hey - I've found 2 issues, and left some high level feedback:

• The ts_rs usage is very repetitive, especially the long export_to paths; consider centralizing the base output directory (e.g., via a macro, helper attribute, or build script) so new types and path changes are less error‑prone.
• Several fields containing arbitrary JSON are exported as Record<string, unknown> (e.g., natives, features, classifiers, Arguments fields); if the frontend relies on particular keys or shapes, it may be worth tightening these TypeScript types to catch UI-side misuse earlier.

Prompt for AI Agents

Please address the comments from this code review:

## Overall Comments
- The `ts_rs` usage is very repetitive, especially the long `export_to` paths; consider centralizing the base output directory (e.g., via a macro, helper attribute, or build script) so new types and path changes are less error‑prone.
- Several fields containing arbitrary JSON are exported as `Record<string, unknown>` (e.g., `natives`, `features`, `classifiers`, `Arguments` fields); if the frontend relies on particular keys or shapes, it may be worth tightening these TypeScript types to catch UI-side misuse earlier.

## Individual Comments

### Comment 1
<location> `src-tauri/src/core/game_version.rs:6-13` </location>
<code_context>

 /// Represents a Fabric loader version from the Meta API.
-#[derive(Debug, Deserialize, Serialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone, TS)]
+#[ts(
+    export,
</code_context>

<issue_to_address>
**issue (bug_risk):** Serde-renamed fields (e.g. `majorVersion`) will be mismatched in generated TS without `ts` renames or `serde-compat`.

For types like `JavaVersion`, `serde(rename = "majorVersion")` changes the JSON field, but `ts-rs` will still emit `major_version` unless configured otherwise. This makes the generated TS types disagree with the actual API. Please either:

1) Enable `ts-rs`’s `serde-compat` feature so serde renames are mirrored automatically, or
2) Add `#[ts(rename = "majorVersion")]` (and similar `ts` renames wherever `serde(rename = ...)` is used).

Otherwise the frontend will receive `majorVersion` while the TS types expect `major_version`.
</issue_to_address>

### Comment 2
<location> `src-tauri/src/main.rs:1753-1760` </location>
<code_context>

 /// Version metadata for display in the UI
-#[derive(serde::Serialize)]
+#[derive(serde::Serialize, TS)]
+#[ts(
+    export,
+    export_to = "../../packages/ui/src/types/generated/VersionMetadata.ts"
+)]
 struct VersionMetadata {
     id: String,
     #[serde(rename = "javaVersion")]
</code_context>

<issue_to_address>
**issue (bug_risk):** Generated TS for `VersionMetadata`/`InstalledVersion` fields won’t respect serde `rename`, causing type/JSON divergence.

In `VersionMetadata` and `InstalledVersion`, fields using `#[serde(rename = ...)]` (e.g. `javaVersion`, `type`) will still be emitted by `ts-rs` as `java_version`/`r#type` unless configured. That means the generated TS types won’t match the actual JSON shape the frontend receives.

Please either enable `ts-rs`’s `serde-compat` feature globally, or add explicit `#[ts(rename = "...")]` on the renamed fields so the TS definitions align with the serialized JSON.
</issue_to_address>

---

Sourcery is free for open source - if you like our reviews please consider sharing them ✨

• X
• Mastodon
• LinkedIn
• Facebook

_{Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.}

[Copilot]

Pull request overview

This pull request adds TypeScript type generation from Rust backend types using the ts-rs library. The changes enable automatic generation of TypeScript definitions for all data structures used in communication between the Rust backend and the frontend UI, ensuring type safety across the Rust-TypeScript boundary.

Changes:

• Added ts-rs 11.1.0 dependency to Cargo.toml
• Annotated 40+ core Rust structs and enums with #[derive(TS)] and export metadata
• Configured TypeScript output paths to packages/ui/src/types/generated/
• Added proper type overrides for complex types (PathBuf → string, serde_json::Value → Record<string, unknown>)

Reviewed changes

Copilot reviewed 12 out of 12 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
src-tauri/Cargo.toml	Added ts-rs dependency for TypeScript type generation
src-tauri/src/main.rs	Added TS import and annotations for UI-facing types (VersionMetadata, InstalledVersion, GithubRelease, PastebinResponse, MigrationResult, FileInfo)
src-tauri/src/core/auth.rs	Annotated authentication types with TS exports including tagged Account enum; includes unrelated CLIENT_ID change
src-tauri/src/core/config.rs	Exported configuration types (LauncherConfig, AssistantConfig, FeatureFlags)
src-tauri/src/core/downloader.rs	Exported download-related types with progress tracking structures
src-tauri/src/core/fabric.rs	Exported Fabric loader types including loader versions, libraries, and main class enum
src-tauri/src/core/forge.rs	Exported Forge types with proper PathBuf→string type override
src-tauri/src/core/game_version.rs	Exported comprehensive game version types with Record<string, unknown> overrides for serde_json::Value fields
src-tauri/src/core/instance.rs	Exported instance/profile configuration types
src-tauri/src/core/java.rs	Exported Java installation and catalog types with ImageType enum
src-tauri/src/core/manifest.rs	Exported Mojang version manifest types
src-tauri/src/core/assistant.rs	Exported AI assistant message and model types