fix rebase

This reverts commit 3b21944a75.

.claude/skills/api-module/SKILL.md

@@ -0,0 +1,156 @@
+# Adding a New API Module
+
+How to add a new API endpoint module to `packages/api-client`.
+
+## Steps
+
+### 1. Define types in the module's `types.ts`
+
+Types must match 1:1 with the backend API response. Do not reshape, rename, or omit fields.
+
+Add to an existing namespace or create a new one:
+
+```ts
+// modules/labrinth/types.ts (existing namespace)
+export namespace Labrinth {
+	export namespace MyDomain {
+		export namespace v3 {
+			export type Thing = {
+				id: string
+				name: string
+				created: string
+				// ... matches API response exactly
+			}
+
+			export type CreateThingRequest = {
+				name: string
+			}
+		}
+	}
+}
+```
+
+For a new API service, create `modules/<service>/types.ts` with a new top-level namespace and re-export it from `modules/types.ts`.
+
+### 2. Create the module class
+
+Create `modules/<api>/<domain>/v<N>.ts`:
+
+```ts
+// modules/labrinth/things/v3.ts
+import { AbstractModule } from '../../../core/abstract-module'
+import type { Labrinth } from '../types'
+
+export class LabrinthThingsV3Module extends AbstractModule {
+	public getModuleID(): string {
+		return 'labrinth_things_v3'
+	}
+
+	public async get(id: string): Promise<Labrinth.MyDomain.v3.Thing> {
+		return this.client.request<Labrinth.MyDomain.v3.Thing>(`/thing/${id}`, {
+			api: 'labrinth',
+			version: 3,
+			method: 'GET',
+		})
+	}
+
+	public async create(data: Labrinth.MyDomain.v3.CreateThingRequest): Promise<Labrinth.MyDomain.v3.Thing> {
+		return this.client.request<Labrinth.MyDomain.v3.Thing>(`/thing`, {
+			api: 'labrinth',
+			version: 3,
+			method: 'POST',
+			body: data,
+		})
+	}
+
+	public async delete(id: string): Promise<void> {
+		return this.client.request(`/thing/${id}`, {
+			api: 'labrinth',
+			version: 3,
+			method: 'DELETE',
+		})
+	}
+}
+```
+
+#### Request options
+
+| Field | Values | Purpose |
+|-------|--------|---------|
+| `api` | `'labrinth'`, `'archon'`, or a full URL | Which base URL to use |
+| `version` | `2`, `3`, `'internal'`, `'modrinth/v0'`, etc. | URL version segment |
+| `method` | `'GET'`, `'POST'`, `'PUT'`, `'PATCH'`, `'DELETE'` | HTTP method |
+| `body` | object | JSON request body |
+| `params` | `Record<string, string>` | Query parameters |
+| `skipAuth` | `boolean` | Skip auth feature for this request |
+| `useNodeAuth` | `boolean` | Use node-level auth (kyros) |
+| `timeout` | `number` | Request timeout in ms |
+| `retry` | `boolean \| number` | Override retry behavior |
+
+#### For uploads
+
+Return an `UploadHandle` instead of a `Promise`:
+
+```ts
+public uploadThing(id: string, file: File): UploadHandle<void> {
+	return this.client.upload<void>(`/thing/${id}/file`, {
+		api: 'labrinth',
+		version: 3,
+		file,
+	})
+}
+
+// Or with FormData for multipart:
+public createWithFiles(data: CreateRequest, files: File[]): UploadHandle<Thing> {
+	const formData = new FormData()
+	formData.append('data', JSON.stringify(data))
+	files.forEach((f, i) => formData.append(`file-${i}`, f, f.name))
+
+	return this.client.upload<Thing>(`/thing`, {
+		api: 'labrinth',
+		version: 3,
+		formData,
+		timeout: 60 * 5 * 1000,  // longer timeout for uploads
+	})
+}
+```
+
+### 3. Register in the MODULE_REGISTRY
+
+Add to `modules/index.ts`:
+
+```ts
+import { LabrinthThingsV3Module } from './labrinth/things/v3'
+
+export const MODULE_REGISTRY = {
+	// ... existing modules
+	labrinth_things_v3: LabrinthThingsV3Module,
+} as const
+```
+
+The naming convention is `<api>_<domain>_<version>`. This flat key gets transformed into nested access: `client.labrinth.things_v3`.
+
+### 4. Export types
+
+If you added to an existing namespace, types are already re-exported. If you created a new `types.ts`, add it to `modules/types.ts`:
+
+```ts
+export * from './<service>/types'
+```
+
+## Naming Conventions
+
+| Convention | Example |
+|-----------|---------|
+| Module class | `LabrinthThingsV3Module` — `{Api}{Domain}V{N}Module` |
+| Module ID | `labrinth_things_v3` — `{api}_{domain}_v{n}` |
+| Type namespace | `Labrinth.MyDomain.v3.Thing` |
+| File path | `modules/labrinth/things/v3.ts` |
+
+## Key Files
+
+- `src/core/abstract-module.ts` — base class all modules extend
+- `src/core/abstract-client.ts` — `request()` and `upload()` methods
+- `src/modules/index.ts` — `MODULE_REGISTRY` and `buildModuleStructure()`
+- `src/modules/<api>/types.ts` — type definitions per API
+- `src/types/upload.ts` — `UploadHandle`, `UploadProgress`, `UploadRequestOptions`

.claude/skills/cross-platform-pages/SKILL.md

@@ -0,0 +1,144 @@
+# Cross-Platform Page System
+
+When a page needs to exist in both the Modrinth App (`apps/app-frontend`) and the Modrinth Website (`apps/frontend`), use the cross-platform page system.
+
+## How It Works
+
+1. **Pages live as Vue SFCs in `packages/ui`** — either in `src/pages/` or `src/layout/` (if `src/pages/` doesn't exist, it's been renamed to `src/layout/`).
+2. **Platform-dependent data flows via DI** — the app uses Tauri `invoke` commands, the website uses `api-client` or the legacy `useBaseFetch` composable. The shared page never knows which. See the `dependency-injection` skill for full DI docs.
+3. **Non-platform-dependent data flows via props** — if data doesn't change based on _how_ it's fetched, just pass it as a prop.
+
+## Example: Content Page
+
+`ContentPageLayout` demonstrates the full pattern.
+
+### 1. Define a DI contract in `packages/ui/src/providers/`
+
+The provider interface abstracts all platform-specific operations:
+
+```ts
+// packages/ui/src/providers/content-manager.ts
+export interface ContentManagerContext {
+	items: Ref<ContentItem[]>
+	loading: Ref<boolean>
+	error: Ref<Error | null>
+	contentTypeLabel: Ref<string>
+
+	// These are the platform-abstracted operations:
+	// App uses invoke(), website uses api-client
+	toggleEnabled: (item: ContentItem) => Promise<void>
+	deleteItem: (item: ContentItem) => Promise<void>
+	refresh: () => Promise<void>
+	browse: () => void
+	uploadFiles: () => void
+
+	// Optional capabilities — not every platform supports everything
+	hasUpdateSupport: boolean
+	updateItem?: (item: ContentItem) => Promise<void>
+	bulkUpdateItem?: (items: ContentItem[]) => Promise<void>
+
+	mapToTableItem: (item: ContentItem) => ContentCardTableItem
+}
+
+export const [injectContentManager, provideContentManager] =
+	createContext<ContentManagerContext>('ContentManager')
+```
+
+### 2. Build the shared page in `packages/ui`
+
+The page component injects the context and handles all UI logic (search, filtering, selection, bulk operations, empty states, modals) without knowing the platform:
+
+```vue
+<!-- packages/ui/src/components/instances/ContentPageLayout.vue -->
+<script setup lang="ts">
+import { injectContentManager } from '../../providers/content-manager'
+
+const { items, loading, toggleEnabled, deleteItem, refresh, mapToTableItem } =
+	injectContentManager()
+
+// All UI logic lives here — search, filters, sort, bulk ops, etc.
+</script>
+
+<template>
+	<ContentCardTable :items="filteredItems" />
+</template>
+```
+
+### 3. Each platform provides its implementation
+
+**Website (Nuxt)** — uses `api-client` or `useBaseFetch`:
+
+```vue
+<!-- apps/frontend/src/pages/hosting/manage/[id]/content.vue -->
+<script setup lang="ts">
+import { provideContentManager, ContentPageLayout } from '@modrinth/ui'
+const { labrinth } = injectModrinthClient()
+
+const { data: items } = useQuery({
+	queryKey: ['content', serverId],
+	queryFn: () => labrinth.servers_v0.getAddons(serverId),
+})
+
+provideContentManager({
+	items: computed(() => items.value?.map(addonToContentItem) ?? []),
+	deleteItem: async (item) => {
+		await labrinth.servers_v0.deleteAddon(serverId, item.id)
+	},
+	// ... rest of the contract
+})
+</script>
+
+<template>
+	<ContentPageLayout />
+</template>
+```
+
+**App (Tauri)** — uses `invoke`:
+
+```vue
+<!-- apps/app-frontend/src/pages/instance/Content.vue -->
+<script setup lang="ts">
+import { provideContentManager, ContentPageLayout } from '@modrinth/ui'
+import { invoke } from '@tauri-apps/api/core'
+
+const items = ref<ContentItem[]>([])
+await invoke('get_instance_content', { instanceId }).then(/* map to ContentItem[] */)
+
+provideContentManager({
+	items,
+	deleteItem: async (item) => {
+		await invoke('delete_content', { instanceId, path: item.file_path })
+	},
+	// ... rest of the contract
+})
+</script>
+
+<template>
+	<ContentPageLayout />
+</template>
+```
+
+## When to Use Props vs DI
+
+| Use       | When                                                                                                     |
+| --------- | -------------------------------------------------------------------------------------------------------- |
+| **DI**    | The data depends on _how_ it's fetched (different per platform) — API calls, file operations, navigation |
+| **Props** | The data is the same regardless of platform — configuration flags, display options                       |
+
+## Composables for Shared Logic
+
+Extract reusable stateful logic into composables in `packages/ui/src/composables/`. The shared page orchestrates them internally:
+
+- Search (Fuse.js fuzzy search over items)
+- Filtering (dynamic filter pills)
+- Selection (multi-select with bulk operations)
+- Bulk operations (sequential execution with progress tracking)
+
+## Key Files
+
+- `packages/ui/src/pages/` (or `src/layout/`) — shared page components
+- `packages/ui/src/providers/` — DI contracts
+- `packages/ui/src/composables/` — shared stateful logic
+- `apps/frontend/src/app.vue` — website root provider setup
+- `apps/app-frontend/src/App.vue` — app root provider setup
+- `apps/app-frontend/src/routes.js` — app route definitions

.claude/skills/dependency-injection/SKILL.md

@@ -0,0 +1,174 @@
+# Dependency Injection
+
+Modrinth uses a lightweight DI layer built on Vue's `provide`/`inject` for sharing platform-specific capabilities and page-level state across shared UI components.
+
+## The `createContext` Factory
+
+All providers are defined using `createContext` from `packages/ui/src/providers/index.ts` (adapted from Reka UI). It produces a typed `[inject, provide]` tuple:
+
+```ts
+import { createContext } from '@modrinth/ui'
+
+interface MyContext {
+	someValue: Ref<string>
+	doSomething: () => void
+}
+
+export const [injectMyContext, provideMyContext] = createContext<MyContext>('MyComponent')
+```
+
+- **`provideMyContext(value)`** — call in a parent component's `setup()`.
+- **`injectMyContext()`** — call in any descendant's `setup()`. Throws if never provided.
+- **`injectMyContext(null)`** — returns `null` instead of throwing (for optional contexts).
+
+## When to Use DI
+
+Use DI when:
+- **The same interface needs different implementations** depending on the platform (web vs desktop app).
+- **Deeply nested components** need access to shared page-level state without prop drilling through 3+ levels.
+
+### Platform Abstraction (Primary Use Case)
+
+`packages/ui` components need capabilities that each frontend fulfils differently:
+
+| Provider | App Frontend | Website Frontend |
+|----------|-------------|-----------------|
+| API client | Tauri IPC client | REST fetch client |
+| Notifications | `ref()` state + app window mgmt | `useState()` for SSR hydration |
+| File picker | Native Tauri dialogs | Browser file inputs |
+| Tags | Tauri commands | Nuxt server state |
+| Page context | `sidebar: true`, ad window hooks | `sidebar: false`, no ads |
+
+### Page-Level Context
+
+Sharing data between a page and deeply nested children — e.g. project page data consumed by sidebar, header, and version components.
+
+## Creating a New Provider
+
+### 1. Define the interface in `packages/ui/src/providers/`
+
+```ts
+// packages/ui/src/providers/my-feature.ts
+import type { Ref } from 'vue'
+import { createContext } from '.'
+
+export interface MyFeatureContext {
+	items: Ref<Item[]>
+	addItem: (item: Item) => Promise<void>
+	removeItem: (id: string) => Promise<void>
+}
+
+export const [injectMyFeature, provideMyFeature] = createContext<MyFeatureContext>('MyFeature')
+```
+
+Re-export from the barrel file (`packages/ui/src/providers/index.ts`).
+
+### 2. For complex platform-specific logic, use an abstract class
+
+```ts
+export abstract class AbstractMyFeatureManager {
+	abstract items: Ref<Item[]>
+	abstract addItem(item: Item): Promise<void>
+
+	// Shared logic lives on the base class
+	handleError(err: unknown) {
+		console.error(err)
+	}
+}
+
+export const [injectMyFeature, provideMyFeature] =
+	createContext<AbstractMyFeatureManager>('MyFeature')
+```
+
+See `AbstractWebNotificationManager` in `packages/ui/src/providers/web-notifications.ts` for a real example.
+
+## Wiring Up Providers
+
+### App Frontend (Tauri)
+
+Create a setup function in `apps/app-frontend/src/providers/setup/`:
+
+```ts
+// apps/app-frontend/src/providers/setup/my-feature.ts
+import { ref } from 'vue'
+import { provideMyFeature } from '@modrinth/ui'
+
+export function setupMyFeatureProvider() {
+	const items = ref<Item[]>([])
+
+	provideMyFeature({
+		items,
+		addItem: async (item) => {
+			await invoke('add_item', { item })
+			items.value.push(item)
+		},
+		removeItem: async (id) => {
+			await invoke('remove_item', { id })
+			items.value = items.value.filter(i => i.id !== id)
+		},
+	})
+}
+```
+
+Register it in `apps/app-frontend/src/providers/setup.ts`, which is called from `App.vue`'s `setup()`.
+
+### Website Frontend (Nuxt)
+
+Provide directly in `apps/frontend/src/app.vue`, using Nuxt's `useState()` where SSR hydration is needed:
+
+```ts
+provideMyFeature({
+	items: useState<Item[]>('my-feature-items', () => []),
+	addItem: async (item) => {
+		await $fetch('/api/items', { method: 'POST', body: item })
+	},
+	removeItem: async (id) => {
+		await $fetch(`/api/items/${id}`, { method: 'DELETE' })
+	},
+})
+```
+
+## Consuming Providers
+
+In any component across `packages/ui`, `apps/frontend`, or `apps/app-frontend`:
+
+```vue
+<script setup lang="ts">
+import { injectMyFeature } from '@modrinth/ui'
+
+const { items, addItem } = injectMyFeature()
+</script>
+
+<template>
+	<div v-for="item in items" :key="item.id">{{ item.name }}</div>
+	<button @click="addItem({ id: '1', name: 'New' })">Add</button>
+</template>
+```
+
+## When NOT to Use DI
+
+Default to props and emits. DI adds indirection — only use it with a concrete reason.
+
+- **Parent to direct child** — use props.
+- **Data only exists in one frontend** — keep context local to that app, not in `packages/ui`.
+- **Shallow prop drilling (1–2 levels)** — passing through one intermediate is fine.
+- **Component-local state** — use `ref()` / `reactive()` locally.
+
+## Existing Providers
+
+| Provider | File | Purpose |
+|----------|------|---------|
+| `provideModrinthClient` | `providers/api-client.ts` | API client instance |
+| `provideNotificationManager` | `providers/web-notifications.ts` | Notification management |
+| `providePageContext` | `providers/page-context.ts` | Page config (sidebar, ads) |
+| `provideProjectPageContext` | `providers/project-page.ts` | Project page state + mutations |
+| `provideServerContext` | `providers/server-context.ts` | Server hosting state |
+| `provideUserPageContext` | `providers/user-page.ts` | User page state |
+
+## Key Files
+
+- `packages/ui/src/providers/index.ts` — `createContext` factory + barrel exports
+- `packages/ui/src/providers/*.ts` — Provider definitions
+- `apps/frontend/src/app.vue` — Nuxt root provider setup
+- `apps/app-frontend/src/App.vue` — Tauri root provider setup
+- `apps/app-frontend/src/providers/setup/` — App provider setup functions

.claude/skills/figma-mcp/SKILL.md

@@ -0,0 +1,45 @@
+# Figma MCP Usage
+
+When the Figma MCP server is connected, use it to translate Figma designs into production-ready Vue components for this monorepo.
+
+## Workflow
+
+### 1. Get the design context
+
+Use `get_design_context` with the node ID from a Figma URL. If the URL is `https://figma.com/design/:fileKey/:fileName?node-id=1-2`, the node ID is `1:2`.
+
+```
+get_design_context(nodeId: "1:2", clientLanguages: "typescript,html,css", clientFrameworks: "vue")
+```
+
+This returns reference code, a screenshot, and metadata. Always start here.
+
+### 2. Get a screenshot for visual reference
+
+Use `get_screenshot` if you need to see the design without full code context:
+
+```
+get_screenshot(nodeId: "1:2")
+```
+
+### 3. Get variable definitions
+
+Use `get_variable_defs` to see what design tokens are applied to a node:
+
+```
+get_variable_defs(nodeId: "1:2")
+```
+
+### 4. Get metadata for structure overview
+
+Use `get_metadata` to get an XML overview of node IDs, layer types, names, positions and sizes — useful for understanding the structure of a complex frame before diving into individual nodes.
+
+## Adapting Figma Output
+
+The Figma MCP returns generic reference code. Adapt it to match the Modrinth codebase:
+
+1. **Read `packages/ui/CLAUDE.md`** for color usage rules, surface token mapping, and component patterns.
+2. **Map Figma color variables to `surface-*` tokens** — never use Figma's aliased names like `bg/default` or `bg/raised` directly. The CLAUDE.md has the full mapping table.
+3. **Check `packages/assets/styles/variables.scss`** for tokens not exposed in Figma (brand highlights, semantic backgrounds, shadows).
+4. **Check for existing components** in `packages/ui/src/components/` before building from scratch.
+5. **Match spacing exactly** — do not approximate values from the design.

.claude/skills/i18n-convert/SKILL.md

@@ -0,0 +1,105 @@
+# i18n String Conversion
+
+Convert hard-coded natural-language strings in Vue SFCs into the localization system using utilities from `@modrinth/ui`.
+
+## Rules
+
+### 1. Identify translatable strings
+
+- Scan `<template>` for all user-visible strings: inner text, alt attributes, placeholders, button labels, etc.
+- Check `<script>` too: dropdown option labels, notification messages, etc.
+- Do NOT extract dynamic expressions (`{{ user.name }}`) or HTML tags — only static human-readable text.
+
+### 2. Create message definitions
+
+Import `defineMessage` or `defineMessages` from `@modrinth/ui` in `<script setup>`. Define messages with a unique `id` (descriptive prefix based on component path) and `defaultMessage` equal to the original English string:
+
+```ts
+const messages = defineMessages({
+	welcomeTitle: { id: 'auth.welcome.title', defaultMessage: 'Welcome' },
+	welcomeDescription: { id: 'auth.welcome.description', defaultMessage: "You're now part of the community…" },
+})
+```
+
+### 3. Handle variables and ICU formats
+
+- Dynamic parts become ICU placeholders: `"Hello, ${user.name}!"` → `defaultMessage: 'Hello, {name}!'`
+- Numbers/dates/times use ICU options: `{price, number, ::currency/USD}`
+- Plurals/selects use ICU: `'{count, plural, one {# message} other {# messages}}'`
+
+### 4. Rich-text messages (links/markup)
+
+Wrap link/markup ranges with tags in `defaultMessage`:
+
+```
+"By creating an account, you agree to our <terms-link>Terms</terms-link> and <privacy-link>Privacy Policy</privacy-link>."
+```
+
+Render with `<IntlFormatted>` from `@modrinth/ui` using named slots:
+
+```vue
+<IntlFormatted :message-id="messages.tosLabel">
+	<template #terms-link="{ children }">
+		<NuxtLink to="/terms">
+			<component :is="() => children" />
+		</NuxtLink>
+	</template>
+	<template #privacy-link="{ children }">
+		<NuxtLink to="/privacy">
+			<component :is="() => children" />
+		</NuxtLink>
+	</template>
+</IntlFormatted>
+```
+
+For simple emphasis: `'Welcome to <strong>Modrinth</strong>!'` with a slot:
+
+```vue
+<template #strong="{ children }">
+	<strong><component :is="() => children" /></strong>
+</template>
+```
+
+For complex child handling, use `normalizeChildren` from `@modrinth/ui`:
+
+```vue
+<template #bold="{ children }">
+	<strong><component :is="() => normalizeChildren(children)" /></strong>
+</template>
+```
+
+### 5. Formatting in templates
+
+Use `useVIntl()` from `@modrinth/ui`; prefer `formatMessage` for simple strings:
+
+```ts
+const { formatMessage } = useVIntl()
+```
+
+```vue
+<button>{{ formatMessage(messages.welcomeTitle) }}</button>
+{{ formatMessage(messages.greeting, { name: user.name }) }}
+```
+
+### 6. Naming conventions
+
+Make `id`s descriptive and stable (e.g., `error.generic.default.title`). Group related messages with `defineMessages`.
+
+### 7. Avoid Vue/ICU delimiter collisions
+
+If an ICU placeholder ends right before `}}` in a Vue template, insert a space: `} }` to avoid parsing issues.
+
+### 8. Imports
+
+Ensure these are imported from `@modrinth/ui` as needed: `defineMessage`/`defineMessages`, `useVIntl`, `IntlFormatted`, `normalizeChildren`.
+
+### 9. Preserve functionality
+
+Do not change logic, layout, reactivity, or bindings — only refactor strings into i18n.
+
+## Reference Examples
+
+- Variables/plurals: `apps/frontend/src/pages/frog.vue`
+- Rich-text link tags: `apps/frontend/src/pages/auth/welcome.vue` and `apps/frontend/src/error.vue`
+
+When finished, there should be no hard-coded English strings left in the template — everything comes from `formatMessage` or `<IntlFormatted>`.

.claude/skills/multistage-modals/SKILL.md

@@ -0,0 +1,215 @@
+# Multistage Modals
+
+The `MultiStageModal` component (`packages/ui/src/components/base/MultiStageModal.vue`) provides a wizard-like modal with progress tracking, conditional stages, and per-stage button configuration.
+
+## Architecture
+
+A multistage modal has three parts:
+
+1. **Context** — A DI provider that holds all state, business logic, and stage configs
+2. **Stage configs** — Data objects describing each stage (title, component, buttons, skip conditions)
+3. **Stage components** — Vue components rendered inside the modal, consuming the context
+
+## Building a Multistage Modal
+
+### 1. Define the context
+
+Create a DI provider with all the state your wizard needs. Include the modal ref and stage configs.
+
+```ts
+// providers/my-feature/my-modal.ts
+import type { ShallowRef } from 'vue'
+import type { ComponentExposed } from 'vue-component-type-helpers'
+import type { MultiStageModal, StageConfigInput } from '@modrinth/ui'
+import { createContext } from '@modrinth/ui'
+
+export interface MyModalContext {
+	// State
+	formData: Ref<MyFormData>
+	isSubmitting: Ref<boolean>
+
+	// Modal control
+	modal: ShallowRef<ComponentExposed<typeof MultiStageModal> | null>
+	stageConfigs: StageConfigInput<MyModalContext>[]
+
+	// Business logic
+	handleSubmit: () => Promise<void>
+}
+
+export const [injectMyModalContext, provideMyModalContext] =
+	createContext<MyModalContext>('MyModal')
+
+export function createMyModalContext(
+	modal: ShallowRef<ComponentExposed<typeof MultiStageModal> | null>,
+): MyModalContext {
+	const formData = ref<MyFormData>({ ... })
+	const isSubmitting = ref(false)
+
+	async function handleSubmit() {
+		isSubmitting.value = true
+		try {
+			await saveData(formData.value)
+			modal.value?.hide()
+		} finally {
+			isSubmitting.value = false
+		}
+	}
+
+	return { formData, isSubmitting, modal, stageConfigs, handleSubmit }
+}
+```
+
+### 2. Define stage configs
+
+Each stage is a `StageConfigInput<T>` where `T` is your context type. Most fields accept either a static value or a function receiving the context (`MaybeCtxFn<T, R>`).
+
+```ts
+// providers/my-feature/stages/details-stage.ts
+import { markRaw } from 'vue'
+import type { StageConfigInput } from '@modrinth/ui'
+import type { MyModalContext } from '../my-modal'
+import DetailsStage from './DetailsStage.vue'
+import { RightArrowIcon, SaveIcon } from '@modrinth/assets'
+
+export const detailsStageConfig: StageConfigInput<MyModalContext> = {
+	id: 'details',
+	stageContent: markRaw(DetailsStage),
+	title: 'Details',
+
+	// Conditional behavior based on context
+	skip: (ctx) => ctx.shouldSkipDetails.value,
+	cannotNavigateForward: (ctx) => !ctx.formData.value.name,
+	disableClose: (ctx) => ctx.isSubmitting.value,
+
+	leftButtonConfig: (ctx) => ({
+		label: 'Cancel',
+		onClick: () => ctx.modal.value?.hide(),
+	}),
+
+	rightButtonConfig: (ctx) => ({
+		label: 'Next',
+		icon: RightArrowIcon,
+		iconPosition: 'after',
+		disabled: !ctx.formData.value.name,
+		onClick: () => ctx.modal.value?.nextStage(),
+	}),
+}
+```
+
+**Stage config fields:**
+
+| Field | Type | Purpose |
+|-------|------|---------|
+| `id` | `string` | Unique stage identifier (used with `setStage()`) |
+| `stageContent` | `Component` | Vue component to render (wrap with `markRaw()`) |
+| `title` | `MaybeCtxFn<T, string>` | Stage title in breadcrumbs |
+| `skip` | `MaybeCtxFn<T, boolean>` | Skip this stage conditionally |
+| `nonProgressStage` | `MaybeCtxFn<T, boolean>` | Exclude from progress bar (for edit sub-flows) |
+| `hideStageInBreadcrumb` | `MaybeCtxFn<T, boolean>` | Hide from breadcrumb nav |
+| `cannotNavigateForward` | `MaybeCtxFn<T, boolean>` | Block forward navigation (validation) |
+| `disableClose` | `MaybeCtxFn<T, boolean>` | Disable closing the modal |
+| `leftButtonConfig` | `MaybeCtxFn<T, StageButtonConfig \| null>` | Left action button |
+| `rightButtonConfig` | `MaybeCtxFn<T, StageButtonConfig \| null>` | Right action button |
+| `maxWidth` | `MaybeCtxFn<T, string>` | Per-stage max width (default `560px`) |
+
+**Button config fields:**
+
+| Field | Purpose |
+|-------|---------|
+| `label` | Button text |
+| `icon` | Icon component |
+| `iconPosition` | `'before'` or `'after'` |
+| `color` | ButtonStyled color prop |
+| `disabled` | Disable the button |
+| `onClick` | Click handler |
+
+### 3. Create stage components
+
+Stage components inject the context and render their UI:
+
+```vue
+<!-- providers/my-feature/stages/DetailsStage.vue -->
+<script setup lang="ts">
+import { injectMyModalContext } from '../my-modal'
+
+const { formData } = injectMyModalContext()
+</script>
+
+<template>
+	<div class="flex flex-col gap-4">
+		<StyledInput v-model="formData.name" label="Name" />
+		<StyledInput v-model="formData.description" label="Description" />
+	</div>
+</template>
+```
+
+### 4. Create the wrapper component
+
+The wrapper provides context and renders `MultiStageModal`:
+
+```vue
+<!-- components/MyModalWrapper.vue -->
+<script setup lang="ts">
+import { shallowRef } from 'vue'
+import { MultiStageModal } from '@modrinth/ui'
+import { createMyModalContext, provideMyModalContext } from '../providers/my-feature/my-modal'
+
+const modal = shallowRef<InstanceType<typeof MultiStageModal> | null>(null)
+const ctx = createMyModalContext(modal)
+provideMyModalContext(ctx)
+
+defineExpose({ show: () => modal.value?.show() })
+</script>
+
+<template>
+	<MultiStageModal ref="modal" :stages="ctx.stageConfigs" :context="ctx" />
+</template>
+```
+
+## Modal API
+
+`MultiStageModal` exposes via ref:
+
+| Method/Property | Description |
+|----------------|-------------|
+| `show()` | Open the modal |
+| `hide()` | Close the modal |
+| `setStage(indexOrId)` | Jump to stage by index or string id |
+| `nextStage()` | Advance to next non-skipped stage |
+| `prevStage()` | Go back to previous stage |
+| `currentStageIndex` | Ref to current stage index |
+
+## Non-Progress Stages (Edit Sub-Flows)
+
+For stages that shouldn't appear in the progress bar (e.g. editing a specific field from a summary page):
+
+```ts
+export const editLoadersStageConfig: StageConfigInput<MyContext> = {
+	id: 'edit-loaders',
+	nonProgressStage: true,
+	stageContent: markRaw(EditLoadersStage),
+	title: 'Edit loaders',
+	leftButtonConfig: (ctx) => ({
+		label: 'Back',
+		onClick: () => ctx.modal.value?.setStage('summary'),
+	}),
+	rightButtonConfig: (ctx) => ({
+		...ctx.saveButtonConfig(),
+		label: 'Save',
+	}),
+}
+```
+
+Navigate to it with `modal.value?.setStage('edit-loaders')` — it won't affect the progress indicator.
+
+## Reference Implementation
+
+The version creation/edit modal is the most complete example:
+
+| File | Purpose |
+|------|---------|
+| `apps/frontend/src/providers/version/manage-version-modal.ts` | Context creation + business logic |
+| `apps/frontend/src/providers/version/stages/index.ts` | Stage config barrel export |
+| `apps/frontend/src/providers/version/stages/*-stage.ts` | Individual stage configs |
+
+The context includes computed properties for conditional UI, watchers for auto-fetching dependencies, loading states for granular button disabling, and both "create" and "edit" flows sharing the same stages with different button configs.

.claude/skills/tanstack-query/SKILL.md

@@ -0,0 +1,154 @@
+# TanStack Query
+
+TanStack Query (`@tanstack/vue-query` v5) is used for server state management — caching, background refetching, and cache invalidation. Use it instead of manual `ref()` + `await` patterns for any data that comes from an API.
+
+A TanStack MCP server is available — use `tanstack_doc` and `tanstack_search_docs` tools to look up API details when needed.
+
+## Setup
+
+TanStack Query is configured in `apps/frontend/src/plugins/tanstack.ts` as a Nuxt plugin with SSR hydration support. Default stale time is 5 seconds. The `QueryClient` is available via `useQueryClient()` or `useAppQueryClient()` (which also works in middleware).
+
+## Queries
+
+Use `useQuery` with the api-client for data fetching:
+
+```ts
+const client = injectModrinthClient()
+
+const { data, isPending, isError, error } = useQuery({
+	queryKey: ['project', 'v3', projectId],
+	queryFn: () => client.labrinth.projects_v3.get(projectId),
+	staleTime: 1000 * 60 * 5,
+})
+```
+
+In templates:
+
+```vue
+<span v-if="isPending">Loading...</span>
+<span v-else-if="isError">Error: {{ error.message }}</span>
+<div v-else>{{ data.title }}</div>
+```
+
+### Query Option Factories
+
+For queries used across multiple components, define reusable query option factories in `packages/ui/src/queries/`:
+
+```ts
+// composables/queries/project.ts
+export const STALE_TIME = 1000 * 60 * 5
+export const STALE_TIME_LONG = 1000 * 60 * 10
+
+export const projectQueryOptions = {
+	v3: (projectId: string, client: AbstractModrinthClient) => ({
+		queryKey: ['project', 'v3', projectId] as const,
+		queryFn: () => client.labrinth.projects_v3.get(projectId),
+		staleTime: STALE_TIME,
+	}),
+
+	members: (projectId: string, client: AbstractModrinthClient) => ({
+		queryKey: ['project', projectId, 'members'] as const,
+		queryFn: () => client.labrinth.projects_v3.getMembers(projectId),
+		staleTime: STALE_TIME,
+	}),
+}
+```
+
+Then use them:
+
+```ts
+const { data } = useQuery(projectQueryOptions.v3(projectId, client))
+```
+
+### Conditional Queries
+
+Use `enabled` as a computed for queries that depend on other data:
+
+```ts
+const { data: members } = useQuery({
+	queryKey: ['project', projectId, 'members'],
+	queryFn: () => client.labrinth.projects_v3.getMembers(projectId),
+	enabled: computed(() => !!projectId.value),
+})
+```
+
+## Mutations
+
+Use `useMutation` for create/update/delete operations. Invalidate related queries on success:
+
+```ts
+const queryClient = useQueryClient()
+const client = injectModrinthClient()
+
+const createMutation = useMutation({
+	mutationFn: (name: string) => client.archon.backups_v0.create(serverId, { name }),
+	onSuccess: () => queryClient.invalidateQueries({ queryKey: ['backups', 'list', serverId] }),
+})
+```
+
+Use `createMutation.isPending.value` to disable buttons during submission.
+
+### Optimistic Updates
+
+For mutations where responsiveness matters, use optimistic updates with rollback:
+
+```ts
+const patchMutation = useMutation({
+	mutationFn: async ({ projectId, data }) => {
+		await client.labrinth.projects_v3.patch(projectId, data)
+		return data
+	},
+
+	onMutate: async ({ projectId, data }) => {
+		await queryClient.cancelQueries({ queryKey: ['project', 'v3', projectId] })
+		const previous = queryClient.getQueryData(['project', 'v3', projectId])
+
+		queryClient.setQueryData(['project', 'v3', projectId], (old) => {
+			if (!old) return old
+			return { ...old, ...data }
+		})
+
+		return { previous }
+	},
+
+	onError: (_err, _variables, context) => {
+		if (context?.previous) {
+			queryClient.setQueryData(['project', 'v3', projectId], context.previous)
+		}
+	},
+
+	onSettled: () => {
+		queryClient.invalidateQueries({ queryKey: ['project', 'v3', projectId] })
+	},
+})
+```
+
+## Query Keys
+
+Keys use a hierarchical array pattern:
+
+```ts
+// Resource type → version/qualifier → ID
+['project', 'v3', projectId]
+
+// Resource type → ID → sub-resource
+['project', projectId, 'members']
+['project', projectId, 'versions', 'v3']
+
+// Domain → action → ID
+['backups', 'list', serverId]
+['tech-reviews']
+```
+
+Use `as const` for type safety. Put the resource ID last when possible — this makes partial key matching work for invalidation:
+
+```ts
+// Invalidates all project queries for this ID
+queryClient.invalidateQueries({ queryKey: ['project', projectId] })
+```
+
+## Key Files
+
+- `apps/frontend/src/plugins/tanstack.ts` — QueryClient setup + SSR hydration
+- `apps/frontend/src/composables/query-client.ts` — `useAppQueryClient()` helper
+- `apps/frontend/src/composables/queries/` — reusable query option factories

.github/workflows/theseus-build.yml

@@ -21,6 +21,14 @@ on:
         type: boolean
         default: false
         required: false
+      environment:
+        description: Environment
+        type: choice
+        options:
+          - prod
+          - staging
+        default: prod
+        required: false
 
 jobs:
   build:
@@ -94,12 +102,14 @@ jobs:
         shell: bash
         run: |
           APP_VERSION="$(git describe --tags --always | sed -E 's/-([0-9]+)-(g[0-9a-fA-F]+)$/-canary+\1.\2/')"
+          BUILD_ENVIRONMENT="${{ inputs.environment || 'prod' }}"
           echo "Setting application version to $APP_VERSION"
+          echo "Using environment $BUILD_ENVIRONMENT"
           dasel put -f apps/app/Cargo.toml -t string -v "${APP_VERSION#v}" 'package.version'
           dasel put -f packages/app-lib/Cargo.toml -t string -v "${APP_VERSION#v}" 'package.version'
           dasel put -f apps/app-frontend/package.json -t string -v "${APP_VERSION#v}" 'version'
 
-          cp packages/app-lib/.env.prod packages/app-lib/.env
+          cp "packages/app-lib/.env.${BUILD_ENVIRONMENT}" packages/app-lib/.env
 
       - name: Setup Turbo cache
         uses: rharkor/caching-for-turbo@v1.8

.gitignore

@@ -64,7 +64,8 @@ generated
 app-playground-data/*
 
 .astro
-.claude
+.claude/*
+!.claude/skills/
 .letta
 
 # labrinth demo fixtures

AGENTS.md

@@ -0,0 +1 @@
+See [CLAUDE.md](./CLAUDE.md) for all project instructions and guidelines.

CLAUDE.md

@@ -1,63 +1,128 @@
-# Architecture
+# Modrinth Monorepo
 
-Use TAB instead of spaces.
+This is the Modrinth monorepo — it contains all Modrinth projects, both frontend and backend. When entering a project, either to edit or analyse, you should read it's CLAUDE.md.
 
-## Frontend
+## Architecture
 
-There are two similar frontends in the Modrinth monorepo, the website (apps/frontend) and the app frontend (apps/app-frontend).
+- **Monorepo tooling:** [Turborepo](https://turbo.build/) (`turbo.jsonc`) + [pnpm workspaces](https://pnpm.io/workspaces) (`pnpm-workspace.yaml`)
+- **Frontend:** Vue 3 / Nuxt 3, Tailwind CSS v3
+- **Backend:** Rust (Labrinth API), Postgres, Clickhouse
+- **Indentation:** Use TAB everywhere, never spaces
 
-Both use Tailwind v3, and their respective configs can be seen at `tailwind.config.ts` and `tailwind.config.js` respectively.
+### Apps (`apps/`)
 
-Both utilize shared and common components from `@modrinth/ui` which can be found at `packages/ui`, and stylings from `@modrinth/assets` which can be found at `packages/assets`.
+| App               | Description                    |
+| ----------------- | ------------------------------ |
+| `frontend`        | Main Modrinth website (Nuxt 3) |
+| `app-frontend`    | Desktop/app frontend (Vue 3)   |
+| `app`             | Desktop/app shell (Tauri)      |
+| `app-playground`  | Testing playground for app     |
+| `labrinth`        | Backend API service            |
+| `daedalus_client` | Daedalus client implementation |
+| `docs`            | Documentation site (Astro)     |
 
-Both can utilize icons from `@modrinth/assets`, which are automatically generated based on what's available within the `icons` folder of the `packages/assets` directory. You can see the generated icons list in `generated-icons.ts`.
+### Packages (`packages/`)
 
-Both have access to our dependency injection framework, examples as seen in `packages/ui/src/providers/`. Ideally any state which is shared between a page and it's subpages should be shared using this dependency injection framework.
+| Package            | Description                                           |
+| ------------------ | ----------------------------------------------------- |
+| `ui`               | Shared Vue component library (`@modrinth/ui`)         |
+| `assets`           | Styling and auto-generated icons (`@modrinth/assets`) |
+| `api-client`       | API client for Nuxt, Tauri, and Node/browser          |
+| `app-lib`          | Shared app library                                    |
+| `blog`             | Blog system and changelog data                        |
+| `utils`            | Shared utility functions                              |
+| `moderation`       | Moderation utilities                                  |
+| `daedalus`         | Daedalus protocol                                     |
+| `tooling-config`   | ESLint, Prettier, TypeScript configs                  |
+| `ariadne`          | Analytics library                                     |
+| `modrinth-log`     | Logging utilities                                     |
+| `modrinth-maxmind` | MaxMind GeoIP                                         |
+| `modrinth-util`    | General utilities                                     |
+| `muralpay`         | Payment processing                                    |
+| `path-util`        | Path utilities                                        |
+| `sqlx-tracing`     | SQLx query tracing                                    |
 
-### Website (apps/frontend)
+## Pre-PR Commands
 
-Before a pull request can be opened for the website, run `pnpm prepr:frontend:web` from the root folder, otherwise CI will fail.
+Run these from the **root** folder before opening a pull request - do not run these after each prompt the user gives you, only run when asked, ask the user a question if they want to run it if the user indicates that they are about to create a pull request.
 
-To run a development version of the frontend, you must first copy over the relevant `.env` template file (prod, staging or local, usually prod) within the `apps/frontend` folder into `apps/frontend/.env`. Then you can run the frontend by running `pnpm web:dev` in the root folder.
+- **Website:** `pnpm prepr:frontend:web`
+- **App frontend:** `pnpm prepr:frontend:app`
+- **Frontend libs:** `pnpm prepr:frontend:lib`
+- **All frontend (app+web):** `pnpm prepr`
+- **Labrinth (backend):** See `apps/labrinth/CLAUDE.md`
 
-### App Frontend (apps/app-frontend)
+The website and app `prepr` commands
 
-Before a pull request can be opened for the app frontend, run `pnpm prepr:frontend:app` from the root folder, otherwise CI will fail.
+## Dev Commands
 
-To run a development version of the app frontend, you must first copy over the relevant `.env` template file (prod, staging or local, usually prod) within `packages/app-lib` into `packages/app-lib/.env`. Then you must run the app itself by running `pnpm app:dev` in the root folder.
+- **Website:** `pnpm web:dev` (copy `.env` template in `apps/frontend/` first)
+- **App:** `pnpm app:dev` (copy `.env` template in `packages/app-lib/` first)
+- **Storybook (packages/ui):** `pnpm storybook`
 
-### Localization
+## Project-Specific Instructions
 
-Refer to `.github/instructions/i18n-convert.instructions.md` if the user asks you to perform any i18n conversion work on a component, set of components, pages or sets of pages.
+Each project may have its own `CLAUDE.md` with detailed instructions:
 
-## Labrinth
+- [`apps/labrinth/CLAUDE.md`](apps/labrinth/CLAUDE.md) — Backend API
+- [`apps/frontend/CLAUDE.md`](apps/frontend/CLAUDE.md) - Frontend Website
 
-Labrinth is the backend API service for Modrinth.
+## Skills (`.claude/skills/`)
 
-### Testing
+Project-specific skill files with detailed patterns. Use them when the task matches:
 
-Before a pull request can be opened, run `cargo clippy -p labrinth --all-targets` and make sure there are ZERO warnings, otherwise CI will fail.
+- **`api-module`** — Adding a new API endpoint module to `packages/api-client` (types, module class, registry registration)
+- **`cross-platform-pages`** — Building a page that needs to work in both the website (`apps/frontend`) and the desktop app (`apps/app-frontend`)
+- **`dependency-injection`** — Creating or wiring up a `provide`/`inject` context for platform abstraction or deep component state sharing
+- **`figma-mcp`** — Translating a Figma design into Vue components using the Figma MCP tools
+- **`i18n-convert`** — Converting hardcoded English strings in Vue SFCs into the `@modrinth/ui` i18n system (`defineMessages`, `formatMessage`, `IntlFormatted`)
+- **`multistage-modals`** — Building a wizard-like modal with multiple stages, progress tracking, and per-stage buttons using `MultiStageModal`
+- **`tanstack-query`** — Fetching, caching, or mutating server data with `@tanstack/vue-query` (queries, mutations, invalidation, optimistic updates)
 
-Use `cargo test -p labrinth --all-targets` to test your changes. All tests must pass, otherwise CI will fail.
+## Code Guidelines
 
-To prepare the sqlx cache, cd into `apps/labrinth` and run `cargo sqlx prepare`. Make sure to NEVER run `cargo sqlx prepare --workspace`.
+### Comments
+- DO NOT use "heading" comments like: `=== Helper methods ===`.
+- Use doc comments, but avoid inline comments unless ABSOLUTELY necessary for clarity. Code should aim to be self documenting!
 
-Read the root `docker-compose.yml` to see what running services are available while developing. Use `docker exec` to access these services.
+## Bash Guidelines
 
-When the user refers to "performing pre-PR checks", do the following:
+### Output handling
+- DO NOT pipe output through `head`, `tail`, `less`, or `more`
+- NEVER use `| head -n X` or `| tail -n X` to truncate output
+- IMPORTANT: Run commands directly without pipes when possible
+- IMPORTANT: If you need to limit output, use command-specific flags (e.g. `git log -n 10` instead of `git log | head -10`)
+- ALWAYS read the full output — never pipe through filters
 
-- Run clippy as described above
-- DO NOT run tests unless explicitly requested (they take a long time)
-- Prepare the sqlx cache
+### General
+- Do not create new non-source code files (e.g. Bash scripts, SQL scripts) unless explicitly prompted to
+- For Frontend, when doing lint checks, only use the `prepr` commands, do not use `typecheck` or `tsc` etc.
 
-### Clickhouse
+## Edit Tool - Whitespace Handling (CLAUDE ONLY)
 
-Use `docker exec labrinth-clickhouse clickhouse-client` to access the Clickhouse instance. We use the `staging_ariadne` database to store data in testing.
+The Read tool uses `→` to mark where line numbers end and file content begins.
 
-### Postgres
+**Rule:** Copy the EXACT whitespace that appears after the `→` marker.
+- Whatever appears between `→` and the code text is what's actually in the file
+- That whitespace must be used EXACTLY in Edit tool's old_string
+- Don't count arrows, don't interpret - just copy what's after the `→`
 
-Use `docker exec labrinth-postgres psql -U labrinth -d labrinth -c "SELECT 1"` to access the PostgreSQL instance, replacing the `SELECT 1` with your query.
+**Example:**
+14→		private byte tag;
+For Edit, use: `		private byte tag;` (copy everything after →, including the two tabs)
 
-# Guidelines
+**If Edit fails:** Stop and explain the problem. Do not attempt sed/awk/bash workarounds.
 
-- Do not create new non-source code files (e.g. Bash scripts, SQL scripts) unless explicitly prompted to.
+**IMPORTANT**: Trust the Read tool output. Copy what's after `→` into Edit immediately. DO NOT verify with sed/od/grep first - that's wasting time and the instructions already tell you to stop if Edit fails, not to pre-verify.
+
+## Skills
+
+Project-specific skills (patterns, conventions, and implementation guides) are located in [`.claude/skills/`](./.claude/skills/). Each skill has a `SKILL.md` describing the pattern:
+
+- **[Dependency Injection](./.claude/skills/dependency-injection/SKILL.md)** — Vue provide/inject DI layer using `createContext`
+- **[Cross-Platform Pages](./.claude/skills/cross-platform-pages/SKILL.md)** — Shared component architecture across Nuxt and Tauri frontends
+- **[Multistage Modals](./.claude/skills/multistage-modals/SKILL.md)** — Wizard-like modal flows with `MultiStageModal`
+- **[Figma MCP](./.claude/skills/figma-mcp/SKILL.md)** — Translating Figma designs to Modrinth Vue components
+- **[i18n Convert](./.claude/skills/i18n-convert/SKILL.md)** — Converting hard-coded strings to vue-i18n localization
+- **[API Module](./.claude/skills/api-module/SKILL.md)** — Adding new endpoint modules to `@modrinth/api-client`
+- **[TanStack Query](./.claude/skills/tanstack-query/SKILL.md)** — Server state management with `@tanstack/vue-query` v5

Cargo.lock

@@ -378,6 +378,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "ansi_term"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "anstream"
 version = "0.6.21"
@@ -640,6 +649,20 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "async-minecraft-ping"
+version = "0.8.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "hickory-resolver 0.24.4",
+ "serde",
+ "serde_json",
+ "structopt",
+ "thiserror 1.0.69",
+ "tokio",
+]
+
 [[package]]
 name = "async-process"
 version = "2.5.0"
@@ -851,6 +874,17 @@ dependencies = [
  "webpki-roots 1.0.3",
 ]
 
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -1568,6 +1602,21 @@ dependencies = [
  "libloading 0.8.8",
 ]
 
+[[package]]
+name = "clap"
+version = "2.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags 1.3.2",
+ "strsim 0.8.0",
+ "textwrap",
+ "unicode-width 0.1.14",
+ "vec_map",
+]
+
 [[package]]
 name = "clap"
 version = "4.5.48"
@@ -1587,7 +1636,7 @@ dependencies = [
  "anstream",
  "anstyle",
  "clap_lex",
- "strsim",
+ "strsim 0.11.1",
 ]
 
 [[package]]
@@ -2134,7 +2183,7 @@ dependencies = [
  "futures",
  "indexmap 2.11.4",
  "itertools 0.14.0",
- "reqwest",
+ "reqwest 0.12.24",
  "rust-s3",
  "serde",
  "serde-xml-rs",
@@ -2167,6 +2216,16 @@ dependencies = [
  "darling_macro 0.21.3",
 ]
 
+[[package]]
+name = "darling"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
+dependencies = [
+ "darling_core 0.23.0",
+ "darling_macro 0.23.0",
+]
+
 [[package]]
 name = "darling_core"
 version = "0.20.11"
@@ -2177,7 +2236,7 @@ dependencies = [
  "ident_case",
  "proc-macro2",
  "quote",
- "strsim",
+ "strsim 0.11.1",
  "syn 2.0.106",
 ]
 
@@ -2191,7 +2250,20 @@ dependencies = [
  "ident_case",
  "proc-macro2",
  "quote",
- "strsim",
+ "strsim 0.11.1",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
+dependencies = [
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim 0.11.1",
  "syn 2.0.106",
 ]
 
@@ -2217,6 +2289,17 @@ dependencies = [
  "syn 2.0.106",
 ]
 
+[[package]]
+name = "darling_macro"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
+dependencies = [
+ "darling_core 0.23.0",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "dashmap"
 version = "6.1.0"
@@ -2631,6 +2714,29 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "elasticsearch"
+version = "9.1.0-alpha.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12bb303aa6e1d28c0c86b6fbfe484fd0fd3f512629aeed1ac4f6b85f81d9834a"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "dyn-clone",
+ "flate2",
+ "lazy_static",
+ "parking_lot",
+ "percent-encoding",
+ "reqwest 0.12.24",
+ "rustc_version",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "tokio",
+ "url",
+ "void",
+]
+
 [[package]]
 name = "elliptic-curve"
 version = "0.13.8"
@@ -3717,6 +3823,15 @@ dependencies = [
  "hashbrown 0.15.5",
 ]
 
+[[package]]
+name = "heck"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "heck"
 version = "0.4.1"
@@ -3729,6 +3844,15 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
@@ -3741,6 +3865,30 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hickory-proto"
+version = "0.24.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92652067c9ce6f66ce53cc38d1169daa36e6e7eb7dd3b63b5103bd9d97117248"
+dependencies = [
+ "async-trait",
+ "cfg-if",
+ "data-encoding",
+ "enum-as-inner",
+ "futures-channel",
+ "futures-io",
+ "futures-util",
+ "idna",
+ "ipnet",
+ "once_cell",
+ "rand 0.8.5",
+ "thiserror 1.0.69",
+ "tinyvec",
+ "tokio",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "hickory-proto"
 version = "0.25.2"
@@ -3766,6 +3914,27 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "hickory-resolver"
+version = "0.24.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbb117a1ca520e111743ab2f6688eddee69db4e0ea242545a604dce8a66fd22e"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "hickory-proto 0.24.4",
+ "ipconfig",
+ "lru-cache",
+ "once_cell",
+ "parking_lot",
+ "rand 0.8.5",
+ "resolv-conf",
+ "smallvec",
+ "thiserror 1.0.69",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "hickory-resolver"
 version = "0.25.2"
@@ -3774,7 +3943,7 @@ checksum = "dc62a9a99b0bfb44d2ab95a7208ac952d31060efc16241c87eaf36406fecf87a"
 dependencies = [
  "cfg-if",
  "futures-util",
- "hickory-proto",
+ "hickory-proto 0.25.2",
  "ipconfig",
  "moka",
  "once_cell",
@@ -4124,9 +4293,9 @@ dependencies = [
 
 [[package]]
 name = "ico"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc50b891e4acf8fe0e71ef88ec43ad82ee07b3810ad09de10f1d01f072ed4b98"
+checksum = "3e795dff5605e0f04bff85ca41b51a96b83e80b281e96231bcaaf1ac35103371"
 dependencies = [
  "byteorder",
  "png 0.17.16",
@@ -4355,7 +4524,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e96d2465363ed2d81857759fc864cf6bb7997f79327aec028d65bd7989393685"
 dependencies = [
  "ahash 0.8.12",
- "clap",
+ "clap 4.5.48",
  "crossbeam-channel",
  "crossbeam-utils",
  "dashmap",
@@ -4470,7 +4639,7 @@ version = "0.4.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.5.2",
  "libc",
  "windows-sys 0.59.0",
 ]
@@ -4607,9 +4776,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.81"
+version = "0.3.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305"
+checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -4730,6 +4899,7 @@ dependencies = [
  "arc-swap",
  "argon2",
  "ariadne",
+ "async-minecraft-ping",
  "async-stripe",
  "async-trait",
  "base64 0.22.1",
@@ -4737,7 +4907,7 @@ dependencies = [
  "bytes",
  "censor",
  "chrono",
- "clap",
+ "clap 4.5.48",
  "clickhouse",
  "color-eyre",
  "color-thief",
@@ -4748,9 +4918,11 @@ dependencies = [
  "dotenv-build",
  "dotenvy",
  "either",
+ "elasticsearch",
  "eyre",
  "futures",
  "futures-util",
+ "heck 0.5.0",
  "hex",
  "hmac",
  "hyper-rustls 0.27.7",
@@ -4773,7 +4945,7 @@ dependencies = [
  "rand_chacha 0.3.1",
  "redis",
  "regex",
- "reqwest",
+ "reqwest 0.12.24",
  "rust-s3",
  "rust_decimal",
  "rust_iso3166",
@@ -4811,6 +4983,16 @@ dependencies = [
  "zxcvbn",
 ]
 
+[[package]]
+name = "labrinth-derive"
+version = "0.0.0"
+dependencies = [
+ "darling 0.23.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "language-tags"
 version = "0.3.2"
@@ -4974,6 +5156,12 @@ dependencies = [
  "zlib-rs",
 ]
 
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.4.15"
@@ -5039,6 +5227,15 @@ dependencies = [
  "imgref",
 ]
 
+[[package]]
+name = "lru-cache"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
+dependencies = [
+ "linked-hash-map",
+]
+
 [[package]]
 name = "lru-slab"
 version = "0.1.2"
@@ -5197,7 +5394,7 @@ dependencies = [
  "log",
  "meilisearch-index-setting-macro",
  "pin-project-lite",
- "reqwest",
+ "reqwest 0.12.24",
  "serde",
  "serde_json",
  "thiserror 2.0.17",
@@ -5300,13 +5497,13 @@ name = "modrinth-maxmind"
 version = "0.0.0"
 dependencies = [
  "bytes",
- "clap",
+ "clap 4.5.48",
  "directories",
  "eyre",
  "flate2",
  "maxminddb",
  "modrinth-util",
- "reqwest",
+ "reqwest 0.12.24",
  "tar",
  "tokio",
  "tracing",
@@ -5385,7 +5582,7 @@ dependencies = [
  "bytes",
  "chrono",
  "derive_more 2.0.1",
- "reqwest",
+ "reqwest 0.12.24",
  "rust_decimal",
  "rust_iso3166",
  "secrecy",
@@ -5708,7 +5905,7 @@ version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.5.2",
  "libc",
 ]
 
@@ -6139,7 +6336,7 @@ dependencies = [
  "bytes",
  "http 1.3.1",
  "opentelemetry",
- "reqwest",
+ "reqwest 0.12.24",
 ]
 
 [[package]]
@@ -6154,7 +6351,7 @@ dependencies = [
  "opentelemetry-proto",
  "opentelemetry_sdk",
  "prost 0.13.5",
- "reqwest",
+ "reqwest 0.12.24",
  "thiserror 2.0.17",
  "tokio",
  "tonic 0.13.1",
@@ -6716,7 +6913,7 @@ checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
 dependencies = [
  "cfg-if",
  "concurrent-queue",
- "hermit-abi",
+ "hermit-abi 0.5.2",
  "pin-project-lite",
  "rustix 1.1.2",
  "windows-sys 0.61.2",
@@ -7595,11 +7792,45 @@ dependencies = [
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
- "wasm-streams",
+ "wasm-streams 0.4.2",
  "web-sys",
  "webpki-roots 1.0.3",
 ]
 
+[[package]]
+name = "reqwest"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http 1.3.1",
+ "http-body 1.0.1",
+ "http-body-util",
+ "hyper 1.7.0",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde",
+ "serde_json",
+ "sync_wrapper",
+ "tokio",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams 0.5.0",
+ "web-sys",
+]
+
 [[package]]
 name = "resolv-conf"
 version = "0.7.5"
@@ -7785,7 +8016,7 @@ dependencies = [
  "minidom",
  "percent-encoding",
  "quick-xml 0.38.3",
- "reqwest",
+ "reqwest 0.12.24",
  "serde",
  "serde_derive",
  "serde_json",
@@ -8253,7 +8484,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48b85e25e8a1fc13928885e8bf13abe8a09e15c46993aed05d6405f7755d6e20"
 dependencies = [
  "httpdate",
- "reqwest",
+ "reqwest 0.12.24",
  "rustls 0.23.32",
  "sentry-backtrace",
  "sentry-contexts",
@@ -9160,6 +9391,12 @@ dependencies = [
  "unicode-properties",
 ]
 
+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -9189,6 +9426,30 @@ dependencies = [
  "syn 2.0.106",
 ]
 
+[[package]]
+name = "structopt"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c6b5c64445ba8094a6ab0c3cd2ad323e07171012d9c98b0b15651daf1787a10"
+dependencies = [
+ "clap 2.34.0",
+ "lazy_static",
+ "structopt-derive",
+]
+
+[[package]]
+name = "structopt-derive"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcb5ae327f9cc13b68763b5749770cb9e048a99bd9dfdfa58d0cf05d5f64afe0"
+dependencies = [
+ "heck 0.3.3",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "strum"
 version = "0.27.2"
@@ -9334,9 +9595,9 @@ checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
 
 [[package]]
 name = "tao"
-version = "0.34.3"
+version = "0.34.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "959469667dbcea91e5485fc48ba7dd6023face91bb0f1a14681a70f99847c3f7"
+checksum = "f3a753bdc39c07b192151523a3f77cd0394aa75413802c883a0f6f6a0e5ee2e7"
 dependencies = [
  "bitflags 2.9.4",
  "block2 0.6.2",
@@ -9408,9 +9669,9 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "tauri"
-version = "2.8.5"
+version = "2.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d1d3b3dc4c101ac989fd7db77e045cc6d91a25349cd410455cb5c57d510c1c"
+checksum = "463ae8677aa6d0f063a900b9c41ecd4ac2b7ca82f0b058cc4491540e55b20129"
 dependencies = [
  "anyhow",
  "bytes",
@@ -9437,7 +9698,7 @@ dependencies = [
  "percent-encoding",
  "plist",
  "raw-window-handle",
- "reqwest",
+ "reqwest 0.13.2",
  "serde",
  "serde_json",
  "serde_repr",
@@ -9452,7 +9713,6 @@ dependencies = [
  "tokio",
  "tray-icon",
  "url",
- "urlpattern",
  "webkit2gtk",
  "webview2-com",
  "window-vibrancy",
@@ -9461,9 +9721,9 @@ dependencies = [
 
 [[package]]
 name = "tauri-build"
-version = "2.4.1"
+version = "2.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c432ccc9ff661803dab74c6cd78de11026a578a9307610bbc39d3c55be7943f"
+checksum = "ca7bd893329425df750813e95bd2b643d5369d929438da96d5bbb7cc2c918f74"
 dependencies = [
  "anyhow",
  "cargo_toml",
@@ -9485,9 +9745,9 @@ dependencies = [
 
 [[package]]
 name = "tauri-codegen"
-version = "2.4.0"
+version = "2.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ab3a62cf2e6253936a8b267c2e95839674e7439f104fa96ad0025e149d54d8a"
+checksum = "aac423e5859d9f9ccdd32e3cf6a5866a15bedbf25aa6630bcb2acde9468f6ae3"
 dependencies = [
  "base64 0.22.1",
  "brotli",
@@ -9512,9 +9772,9 @@ dependencies = [
 
 [[package]]
 name = "tauri-macros"
-version = "2.4.0"
+version = "2.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4368ea8094e7045217edb690f493b55b30caf9f3e61f79b4c24b6db91f07995e"
+checksum = "1b6a1bd2861ff0c8766b1d38b32a6a410f6dc6532d4ef534c47cfb2236092f59"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -9526,9 +9786,9 @@ dependencies = [
 
 [[package]]
 name = "tauri-plugin"
-version = "2.4.0"
+version = "2.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9946a3cede302eac0c6eb6c6070ac47b1768e326092d32efbb91f21ed58d978f"
+checksum = "692a77abd8b8773e107a42ec0e05b767b8d2b7ece76ab36c6c3947e34df9f53f"
 dependencies = [
  "anyhow",
  "glob",
@@ -9582,9 +9842,9 @@ dependencies = [
 
 [[package]]
 name = "tauri-plugin-fs"
-version = "2.4.2"
+version = "2.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "315784ec4be45e90a987687bae7235e6be3d6e9e350d2b75c16b8a4bf22c1db7"
+checksum = "ed390cc669f937afeb8b28032ce837bac8ea023d975a2e207375ec05afaf1804"
 dependencies = [
  "anyhow",
  "dunce",
@@ -9604,16 +9864,16 @@ dependencies = [
 
 [[package]]
 name = "tauri-plugin-http"
-version = "2.5.2"
+version = "2.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "938a3d7051c9a82b431e3a0f3468f85715b3442b3c3a3913095e9fa509e2652c"
+checksum = "d8f069451c4e87e7e2636b7f065a4c52866c4ce5e60e2d53fa1038edb6d184dc"
 dependencies = [
  "bytes",
  "cookie_store",
  "data-url",
  "http 1.3.1",
  "regex",
- "reqwest",
+ "reqwest 0.12.24",
  "schemars 0.8.22",
  "serde",
  "serde_json",
@@ -9697,7 +9957,7 @@ dependencies = [
  "minisign-verify",
  "osakit",
  "percent-encoding",
- "reqwest",
+ "reqwest 0.12.24",
  "semver",
  "serde",
  "serde_json",
@@ -9730,9 +9990,9 @@ dependencies = [
 
 [[package]]
 name = "tauri-runtime"
-version = "2.8.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4cfc9ad45b487d3fded5a4731a567872a4812e9552e3964161b08edabf93846"
+checksum = "b885ffeac82b00f1f6fd292b6e5aabfa7435d537cef57d11e38a489956535651"
 dependencies = [
  "cookie 0.18.1",
  "dpi",
@@ -9755,9 +10015,9 @@ dependencies = [
 
 [[package]]
 name = "tauri-runtime-wry"
-version = "2.8.1"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1fe9d48bd122ff002064e88cfcd7027090d789c4302714e68fcccba0f4b7807"
+checksum = "5204682391625e867d16584fedc83fc292fb998814c9f7918605c789cd876314"
 dependencies = [
  "gtk",
  "http 1.3.1",
@@ -9782,9 +10042,9 @@ dependencies = [
 
 [[package]]
 name = "tauri-utils"
-version = "2.7.0"
+version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41a3852fdf9a4f8fbeaa63dc3e9a85284dd6ef7200751f0bd66ceee30c93f212"
+checksum = "fcd169fccdff05eff2c1033210b9b94acd07a47e6fa9a3431cf09cfd4f01c87e"
 dependencies = [
  "anyhow",
  "brotli",
@@ -9892,12 +10152,22 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width 0.1.14",
+]
+
 [[package]]
 name = "theseus"
 version = "1.0.0-local"
 dependencies = [
  "ariadne",
  "async-compression",
+ "async-minecraft-ping",
  "async-recursion",
  "async-tungstenite",
  "async-walkdir",
@@ -9923,7 +10193,7 @@ dependencies = [
  "fs4",
  "futures",
  "heck 0.5.0",
- "hickory-resolver",
+ "hickory-resolver 0.25.2",
  "indicatif",
  "itertools 0.14.0",
  "notify",
@@ -9938,7 +10208,7 @@ dependencies = [
  "quick-xml 0.38.3",
  "rand 0.8.5",
  "regex",
- "reqwest",
+ "reqwest 0.12.24",
  "rgb",
  "serde",
  "serde_ini",
@@ -10459,9 +10729,9 @@ dependencies = [
 
 [[package]]
 name = "tower-http"
-version = "0.6.6"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
  "bitflags 2.9.4",
  "bytes",
@@ -11032,6 +11302,12 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
 [[package]]
 name = "version-compare"
 version = "0.2.0"
@@ -11143,9 +11419,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.104"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d"
+checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -11154,27 +11430,14 @@ dependencies = [
  "wasm-bindgen-shared",
 ]
 
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.104"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19"
-dependencies = [
- "bumpalo",
- "log",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "wasm-bindgen-shared",
-]
-
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.54"
+version = "0.4.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e038d41e478cc73bae0ff9b36c60cff1c98b8f38f8d7e8061e79ee63608ac5c"
+checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8"
 dependencies = [
  "cfg-if",
+ "futures-util",
  "js-sys",
  "once_cell",
  "wasm-bindgen",
@@ -11183,9 +11446,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.104"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119"
+checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -11193,22 +11456,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.104"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7"
+checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3"
 dependencies = [
+ "bumpalo",
  "proc-macro2",
  "quote",
  "syn 2.0.106",
- "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.104"
+version = "0.2.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1"
+checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16"
 dependencies = [
  "unicode-ident",
 ]
@@ -11226,6 +11489,19 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "wasm-streams"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "wayland-backend"
 version = "0.3.11"
@@ -11288,9 +11564,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.81"
+version = "0.3.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120"
+checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -11308,9 +11584,9 @@ dependencies = [
 
 [[package]]
 name = "webkit2gtk"
-version = "2.0.1"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76b1bc1e54c581da1e9f179d0b38512ba358fb1af2d634a1affe42e37172361a"
+checksum = "a1027150013530fb2eaf806408df88461ae4815a45c541c8975e61d6f2fc4793"
 dependencies = [
  "bitflags 1.3.2",
  "cairo-rs",
@@ -11332,9 +11608,9 @@ dependencies = [
 
 [[package]]
 name = "webkit2gtk-sys"
-version = "2.0.1"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62daa38afc514d1f8f12b8693d30d5993ff77ced33ce30cd04deebc267a6d57c"
+checksum = "916a5f65c2ef0dfe12fff695960a2ec3d4565359fdbb2e9943c974e06c734ea5"
 dependencies = [
  "bitflags 1.3.2",
  "cairo-sys-rs",
@@ -12037,9 +12313,9 @@ checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
 
 [[package]]
 name = "wry"
-version = "0.53.4"
+version = "0.54.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d78ec082b80fa088569a970d043bb3050abaabf4454101d44514ee8d9a8c9f6"
+checksum = "bb26159b420aa77684589a744ae9a9461a95395b848764ad12290a14d960a11a"
 dependencies = [
  "base64 0.22.1",
  "block2 0.6.2",

Cargo.toml

@@ -8,6 +8,7 @@ members = [
   "packages/app-lib",
   "packages/ariadne",
   "packages/daedalus",
+  "packages/labrinth-derive",
   "packages/modrinth-log",
   "packages/modrinth-maxmind",
   "packages/modrinth-util",
@@ -32,6 +33,7 @@ arc-swap = "1.7.1"
 argon2 = { version = "0.5.3", features = ["std"] }
 ariadne = { path = "packages/ariadne" }
 async-compression = { version = "0.4.32", default-features = false }
+async-minecraft-ping = { path = "packages/async-minecraft-ping" }
 async-recursion = "1.1.1"
 async-stripe = { version = "0.41.0", default-features = false, features = [
   "runtime-tokio-hyper-rustls",
@@ -58,6 +60,7 @@ color-eyre = "0.6.5"
 color-thief = "0.2.2"
 const_format = "0.2.34"
 daedalus = { path = "packages/daedalus" }
+darling = { version = "0.23" }
 dashmap = "6.1.0"
 data-url = "0.3.2"
 deadpool-redis = { git = "https://github.com/modrinth/deadpool", rev = "db5fb00b036ecc8fe5f18853c559b745ffe47bde", version = "0.22.1" }
@@ -69,6 +72,7 @@ dotenv-build = "0.1.1"
 dotenvy = "0.15.7"
 dunce = "1.0.5"
 either = "1.15.0"
+elasticsearch = "9.1.0-alpha.1"
 encoding_rs = "0.8.35"
 enumset = "1.1.10"
 eyre = "0.6.12"
@@ -121,9 +125,11 @@ paste = "1.0.15"
 path-util = { path = "packages/path-util" }
 phf = { version = "0.13.1", features = ["macros"] }
 png = "0.18.0"
+proc-macro2 = { version = "1.0" }
 prometheus = "0.14.0"
 quartz_nbt = "0.2.9"
 quick-xml = "0.38.3"
+quote = { version = "1.0" }
 rand = "=0.8.5"  # Locked on 0.8 until argon2 and p256 update to 0.9
 rand_chacha = "=0.3.1"  # Locked on 0.3 until we can update rand to 0.9
 redis = "0.32.7"
@@ -166,13 +172,14 @@ spdx = "0.12.0"
 sqlx = { version = "0.8.6", default-features = false }
 sqlx-tracing = { path = "packages/sqlx-tracing" }
 strum = "0.27.2"
+syn = { version = "2.0" }
 sysinfo = { version = "0.37.2", default-features = false }
 tar = "0.4.44"
 tauri = "2.8.5"
 tauri-build = "2.4.1"
 tauri-plugin-deep-link = "2.4.3"
 tauri-plugin-dialog = "2.4.0"
-tauri-plugin-http = "2.5.2"
+tauri-plugin-http = "2.5.7"
 tauri-plugin-opener = "2.5.0"
 tauri-plugin-os = "2.3.1"
 tauri-plugin-single-instance = "2.3.4"

apps/app-frontend/package.json

@@ -22,23 +22,24 @@
 		"@tanstack/vue-query": "^5.90.7",
 		"@tauri-apps/api": "^2.5.0",
 		"@tauri-apps/plugin-dialog": "^2.2.1",
-		"@tauri-apps/plugin-http": "^2.5.0",
+		"@tauri-apps/plugin-http": "~2.5.7",
 		"@tauri-apps/plugin-opener": "^2.2.6",
 		"@tauri-apps/plugin-os": "^2.2.1",
 		"@tauri-apps/plugin-updater": "^2.7.1",
 		"@tauri-apps/plugin-window-state": "^2.2.2",
 		"@types/three": "^0.172.0",
-		"intl-messageformat": "^10.7.7",
-		"vue-i18n": "^10.0.0",
 		"@vueuse/core": "^11.1.0",
 		"dayjs": "^1.11.10",
 		"floating-vue": "^5.2.2",
+		"fuse.js": "^6.6.2",
+		"intl-messageformat": "^10.7.7",
 		"ofetch": "^1.3.4",
 		"pinia": "^3.0.0",
 		"posthog-js": "^1.158.2",
 		"three": "^0.172.0",
 		"vite-svg-loader": "^5.1.0",
 		"vue": "^3.5.13",
+		"vue-i18n": "^10.0.0",
 		"vue-multiselect": "3.0.0",
 		"vue-router": "^4.6.0",
 		"vue-virtual-scroller": "v2.0.0-beta.8"

apps/app-frontend/src/App.vue

@@ -31,19 +31,24 @@ import {
 	Button,
 	ButtonStyled,
 	commonMessages,
+	ContentInstallModal,
+	CreationFlowModal,
 	defineMessages,
 	I18nDebugPanel,
 	NewsArticleCard,
 	NotificationPanel,
 	OverflowMenu,
+	PopupNotificationPanel,
 	ProgressSpinner,
+	provideModalBehavior,
 	provideModrinthClient,
 	provideNotificationManager,
 	providePageContext,
+	providePopupNotificationManager,
 	useDebugLogger,
 	useVIntl,
 } from '@modrinth/ui'
-import { renderString } from '@modrinth/utils'
+import { formatBytes, renderString } from '@modrinth/utils'
 import { useQuery } from '@tanstack/vue-query'
 import { getVersion } from '@tauri-apps/api/app'
 import { invoke } from '@tauri-apps/api/core'
@@ -61,20 +66,19 @@ import AccountsCard from '@/components/ui/AccountsCard.vue'
 import Breadcrumbs from '@/components/ui/Breadcrumbs.vue'
 import ErrorModal from '@/components/ui/ErrorModal.vue'
 import FriendsList from '@/components/ui/friends/FriendsList.vue'
+import AddServerToInstanceModal from '@/components/ui/install_flow/AddServerToInstanceModal.vue'
 import IncompatibilityWarningModal from '@/components/ui/install_flow/IncompatibilityWarningModal.vue'
 import InstallConfirmModal from '@/components/ui/install_flow/InstallConfirmModal.vue'
-import ModInstallModal from '@/components/ui/install_flow/ModInstallModal.vue'
-import InstanceCreationModal from '@/components/ui/InstanceCreationModal.vue'
 import MinecraftAuthErrorModal from '@/components/ui/minecraft-auth-error-modal/MinecraftAuthErrorModal.vue'
 import AppSettingsModal from '@/components/ui/modal/AppSettingsModal.vue'
 import AuthGrantFlowWaitModal from '@/components/ui/modal/AuthGrantFlowWaitModal.vue'
+import InstallToPlayModal from '@/components/ui/modal/InstallToPlayModal.vue'
+import UpdateToPlayModal from '@/components/ui/modal/UpdateToPlayModal.vue'
 import NavButton from '@/components/ui/NavButton.vue'
 import PromotionWrapper from '@/components/ui/PromotionWrapper.vue'
 import QuickInstanceSwitcher from '@/components/ui/QuickInstanceSwitcher.vue'
 import RunningAppBar from '@/components/ui/RunningAppBar.vue'
 import SplashScreen from '@/components/ui/SplashScreen.vue'
-import UpdateAvailableToast from '@/components/ui/UpdateAvailableToast.vue'
-import UpdateToast from '@/components/ui/UpdateToast.vue'
 import URLConfirmModal from '@/components/ui/URLConfirmModal.vue'
 import { useCheckDisableMouseover } from '@/composables/macCssFix.js'
 import { hide_ads_window, init_ads_window, show_ads_window } from '@/helpers/ads.js'
@@ -82,8 +86,8 @@ import { debugAnalytics, initAnalytics, trackEvent } from '@/helpers/analytics'
 import { check_reachable } from '@/helpers/auth.js'
 import { get_user } from '@/helpers/cache.js'
 import { command_listener, warning_listener } from '@/helpers/events.js'
-import { useFetch } from '@/helpers/fetch.js'
 import { cancelLogin, get as getCreds, login, logout } from '@/helpers/mr_auth.ts'
+import { create_profile_and_install_from_file } from '@/helpers/pack'
 import { list } from '@/helpers/profile.js'
 import { get as getSettings, set as setSettings } from '@/helpers/settings.ts'
 import { get_opening_command, initialize_state } from '@/helpers/state'
@@ -96,18 +100,20 @@ import {
 	isNetworkMetered,
 } from '@/helpers/utils.js'
 import i18n from '@/i18n.config'
+import { createContentInstall, provideContentInstall } from '@/providers/content-install'
 import {
 	provideAppUpdateDownloadProgress,
 	subscribeToDownloadProgress,
 } from '@/providers/download-progress.ts'
+import { createServerInstall, provideServerInstall } from '@/providers/server-install'
+import { setupProviders } from '@/providers/setup'
 import { useError } from '@/store/error.js'
-import { useInstall } from '@/store/install.js'
 import { useLoading, useTheming } from '@/store/state'
 
-import { create_profile_and_install_from_file } from './helpers/pack'
 import { generateSkinPreviews } from './helpers/rendering/batch-skin-renderer'
 import { get_available_capes, get_available_skins } from './helpers/skins'
 import { AppNotificationManager } from './providers/app-notifications'
+import { AppPopupNotificationManager } from './providers/app-popup-notifications'
 
 const themeStore = useTheming()
 
@@ -115,6 +121,10 @@ const notificationManager = new AppNotificationManager()
 provideNotificationManager(notificationManager)
 const { handleError, addNotification } = notificationManager
 
+const popupNotificationManager = new AppPopupNotificationManager()
+providePopupNotificationManager(popupNotificationManager)
+const { addPopupNotification } = popupNotificationManager
+
 const tauriApiClient = new TauriModrinthClient({
 	userAgent: `modrinth/theseus/${getVersion()} (support@modrinth.com)`,
 	features: [
@@ -129,6 +139,20 @@ providePageContext({
 	hierarchicalSidebarAvailable: ref(true),
 	showAds: ref(false),
 })
+provideModalBehavior({
+	noblur: computed(() => !themeStore.advancedRendering),
+	onShow: () => hide_ads_window(),
+	onHide: () => show_ads_window(),
+})
+
+const {
+	installationModal,
+	handleCreate,
+	handleBrowseModpacks,
+	searchModpacks,
+	getProjectVersions,
+} = setupProviders(notificationManager)
+
 const news = ref([])
 const availableSurvey = ref(false)
 
@@ -295,11 +319,7 @@ async function setupApp() {
 		}),
 	)
 
-	useFetch(
-		`https://api.modrinth.com/appCriticalAnnouncement.json?version=${version}`,
-		'criticalAnnouncements',
-		true,
-	)
+	fetch(`https://api.modrinth.com/appCriticalAnnouncement.json?version=${version}`)
 		.then((response) => response.json())
 		.then((res) => {
 			if (res && res.header && res.body) {
@@ -312,23 +332,21 @@ async function setupApp() {
 			)
 		})
 
-	useFetch(`https://modrinth.com/news/feed/articles.json`, 'news', true)
+	fetch(`https://modrinth.com/news/feed/articles.json`)
 		.then((response) => response.json())
 		.then((res) => {
 			if (res && res.articles) {
-				// Format expected by NewsArticleCard component.
 				news.value = res.articles
 					.map((article) => ({
 						...article,
 						path: article.link,
-						thumbnail: article.thumbnail,
-						title: article.title,
-						summary: article.summary,
-						date: article.date,
 					}))
 					.slice(0, 4)
 			}
 		})
+		.catch((error) => {
+			console.error('Failed to fetch news articles', error)
+		})
 
 	get_opening_command().then(handleCommand)
 	fetchCredentials()
@@ -391,10 +409,40 @@ const error = useError()
 const errorModal = ref()
 const minecraftAuthErrorModal = ref()
 
-const install = useInstall()
+const contentInstall = createContentInstall({ router, handleError })
+provideContentInstall(contentInstall)
+const {
+	instances: contentInstallInstances,
+	compatibleLoaders: contentInstallLoaders,
+	gameVersions: contentInstallGameVersions,
+	loading: contentInstallLoading,
+	defaultTab: contentInstallDefaultTab,
+	preferredLoader: contentInstallPreferredLoader,
+	preferredGameVersion: contentInstallPreferredGameVersion,
+	releaseGameVersions: contentInstallReleaseGameVersions,
+	handleInstallToInstance,
+	handleCreateAndInstall,
+	handleNavigate: handleContentInstallNavigate,
+	handleCancel: handleContentInstallCancel,
+	setContentInstallModal,
+	setInstallConfirmModal: setContentInstallConfirmModal,
+	setIncompatibilityWarningModal: setContentIncompatibilityWarningModal,
+} = contentInstall
+
+const serverInstall = createServerInstall({ router, handleError, popupNotificationManager })
+provideServerInstall(serverInstall)
+const {
+	setInstallToPlayModal: setServerInstallToPlayModal,
+	setUpdateToPlayModal: setServerUpdateToPlayModal,
+	setAddServerToInstanceModal: setServerAddServerToInstanceModal,
+} = serverInstall
+
 const modInstallModal = ref()
+const addServerToInstanceModal = ref()
 const installConfirmModal = ref()
 const incompatibilityWarningModal = ref()
+const installToPlayModal = ref()
+const updateToPlayModal = ref()
 
 const credentials = ref()
 
@@ -403,7 +451,7 @@ const modrinthLoginFlowWaitModal = ref()
 async function fetchCredentials() {
 	const creds = await getCreds().catch(handleError)
 	if (creds && creds.user_id) {
-		creds.user = await get_user(creds.user_id).catch(handleError)
+		creds.user = await get_user(creds.user_id, 'bypass').catch(handleError)
 	}
 	credentials.value = creds ?? null
 }
@@ -470,9 +518,12 @@ onMounted(() => {
 	error.setErrorModal(errorModal.value)
 	error.setMinecraftAuthErrorModal(minecraftAuthErrorModal.value)
 
-	install.setIncompatibilityWarningModal(incompatibilityWarningModal)
-	install.setInstallConfirmModal(installConfirmModal)
-	install.setModInstallModal(modInstallModal)
+	setContentIncompatibilityWarningModal(incompatibilityWarningModal.value)
+	setContentInstallConfirmModal(installConfirmModal.value)
+	setContentInstallModal(modInstallModal.value)
+	setServerAddServerToInstanceModal(addServerToInstanceModal.value)
+	setServerInstallToPlayModal(installToPlayModal.value)
+	setServerUpdateToPlayModal(updateToPlayModal.value)
 })
 
 const accounts = ref(null)
@@ -490,6 +541,9 @@ async function handleCommand(e) {
 				source: 'CreationModalFileDrop',
 			})
 		}
+	} else if (e.event === 'InstallServer') {
+		await router.push(`/project/${e.id}`)
+		await playServerProject(e.id).catch(handleError)
 	} else {
 		// Other commands are URL-based (deep linking)
 		urlModal.value.show(e)
@@ -508,14 +562,60 @@ const downloadPercent = computed(() => Math.trunc(appUpdateDownload.progress.val
 const metered = ref(true)
 const finishedDownloading = ref(false)
 const restarting = ref(false)
-const updateToastDismissed = ref(false)
 const availableUpdate = ref(null)
 const updateSize = ref(null)
 const updatesEnabled = ref(true)
+
+const updatePopupMessages = defineMessages({
+	updateAvailable: {
+		id: 'app.update-popup.title',
+		defaultMessage: 'Update available',
+	},
+	downloadComplete: {
+		id: 'app.update-popup.download-complete',
+		defaultMessage: 'Download complete',
+	},
+	body: {
+		id: 'app.update-popup.body',
+		defaultMessage:
+			'Modrinth App v{version} is ready to install! Reload to update now, or automatically when you close Modrinth App.',
+	},
+	meteredBody: {
+		id: 'app.update-popup.body.metered',
+		defaultMessage: `Modrinth App v{version} is available now! Since you're on a metered network, we didn't automatically download it.`,
+	},
+	downloadedBody: {
+		id: 'app.update-popup.body.download-complete',
+		defaultMessage: `Modrinth App v{version} has finished downloading. Reload to update now, or automatically when you close Modrinth App.`,
+	},
+	linuxBody: {
+		id: 'app.update-popup.body.linux',
+		defaultMessage:
+			'Modrinth App v{version} is available. Use your package manager to update for the latest features and fixes!',
+	},
+	reload: {
+		id: 'app.update-popup.reload',
+		defaultMessage: 'Reload',
+	},
+	download: {
+		id: 'app.update-popup.download',
+		defaultMessage: 'Download ({size})',
+	},
+	changelog: {
+		id: 'app.update-popup.changelog',
+		defaultMessage: 'Changelog',
+	},
+})
+
 async function checkUpdates() {
 	if (!(await areUpdatesEnabled())) {
 		console.log('Skipping update check as updates are disabled in this build or environment')
 		updatesEnabled.value = false
+
+		if (os.value === 'Linux' && !isDevEnvironment.value) {
+			checkLinuxUpdates()
+			setInterval(checkLinuxUpdates, 5 * 60 * 1000)
+		}
 		return
 	}
 
@@ -535,7 +635,6 @@ async function checkUpdates() {
 
 		appUpdateDownload.progress.value = 0
 		finishedDownloading.value = false
-		updateToastDismissed.value = false
 
 		console.log(`Update ${update.version} is available.`)
 
@@ -545,6 +644,28 @@ async function checkUpdates() {
 			downloadUpdate(update)
 		} else {
 			console.log(`Metered connection detected, not auto-downloading update.`)
+			getUpdateSize(update.rid).then((size) => {
+				updateSize.value = size
+				addPopupNotification({
+					title: formatMessage(updatePopupMessages.updateAvailable),
+					text: formatMessage(updatePopupMessages.meteredBody, { version: update.version }),
+					type: 'info',
+					autoCloseMs: null,
+					buttons: [
+						{
+							label: formatMessage(updatePopupMessages.download, {
+								size: formatBytes(updateSize.value ?? 0),
+							}),
+							action: () => downloadAvailableUpdate(),
+							color: 'brand',
+						},
+						{
+							label: formatMessage(updatePopupMessages.changelog),
+							action: () => openUrl('https://modrinth.com/news/changelog?filter=app'),
+						},
+					],
+				})
+			})
 		}
 
 		getUpdateSize(update.rid).then((size) => (updateSize.value = size))
@@ -561,8 +682,26 @@ async function checkUpdates() {
 	)
 }
 
-async function showUpdateToast() {
-	updateToastDismissed.value = false
+async function checkLinuxUpdates() {
+	try {
+		const [response, currentVersion] = await Promise.all([
+			fetch('https://launcher-files.modrinth.com/updates.json'),
+			getVersion(),
+		])
+		const updates = await response.json()
+		const latestVersion = updates?.version
+
+		if (latestVersion && latestVersion !== currentVersion) {
+			addPopupNotification({
+				title: formatMessage(updatePopupMessages.updateAvailable),
+				text: formatMessage(updatePopupMessages.linuxBody, { version: latestVersion }),
+				type: 'info',
+				autoCloseMs: null,
+			})
+		}
+	} catch (e) {
+		console.error('Failed to check for updates:', e)
+	}
 }
 
 async function downloadAvailableUpdate() {
@@ -588,6 +727,26 @@ async function downloadUpdate(versionToDownload) {
 				unlistenUpdateDownload = null
 			})
 			console.log('Finished downloading!')
+
+			addPopupNotification({
+				title: formatMessage(updatePopupMessages.downloadComplete),
+				text: formatMessage(updatePopupMessages.downloadedBody, {
+					version: versionToDownload.version,
+				}),
+				type: 'success',
+				autoCloseMs: null,
+				buttons: [
+					{
+						label: formatMessage(updatePopupMessages.reload),
+						action: () => installUpdate(),
+						color: 'brand',
+					},
+					{
+						label: formatMessage(updatePopupMessages.changelog),
+						action: () => openUrl('https://modrinth.com/news/changelog?filter=app'),
+					},
+				],
+			})
 		})
 		unlistenUpdateDownload = await subscribeToDownloadProgress(
 			appUpdateDownload,
@@ -761,25 +920,6 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 		class="app-grid-layout experimental-styles-within relative"
 		:class="{ 'disable-advanced-rendering': !themeStore.advancedRendering }"
 	>
-		<Suspense>
-			<Transition name="toast">
-				<UpdateToast
-					v-if="
-						!!availableUpdate &&
-						!updateToastDismissed &&
-						!restarting &&
-						(finishedDownloading || metered)
-					"
-					:version="availableUpdate.version"
-					:size="updateSize"
-					:metered="metered"
-					@close="updateToastDismissed = true"
-					@restart="installUpdate"
-					@download="downloadAvailableUpdate"
-				/>
-				<UpdateAvailableToast v-else-if="!updatesEnabled && os === 'Linux' && !isDevEnvironment" />
-			</Transition>
-		</Suspense>
 		<Transition name="fade">
 			<div
 				v-if="restarting"
@@ -801,9 +941,15 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 		<Suspense>
 			<AuthGrantFlowWaitModal ref="modrinthLoginFlowWaitModal" @flow-cancel="cancelLogin" />
 		</Suspense>
-		<Suspense>
-			<InstanceCreationModal ref="installationModal" />
-		</Suspense>
+		<CreationFlowModal
+			ref="installationModal"
+			type="instance"
+			show-snapshot-toggle
+			:search-modpacks="searchModpacks"
+			:get-project-versions="getProjectVersions"
+			@create="handleCreate"
+			@browse-modpacks="handleBrowseModpacks"
+		/>
 		<div
 			class="app-grid-navbar bg-bg-raised flex flex-col p-[0.5rem] pt-0 gap-[0.5rem] w-[--left-bar-width]"
 		>
@@ -849,21 +995,14 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 			</suspense>
 			<NavButton
 				v-tooltip.right="'Create new instance'"
-				:to="() => $refs.installationModal.show()"
+				:to="() => installationModal?.show()"
 				:disabled="offline"
 			>
 				<PlusIcon />
 			</NavButton>
 			<div class="flex flex-grow"></div>
 			<Transition name="nav-button-animated">
-				<div
-					v-if="
-						availableUpdate &&
-						updateToastDismissed &&
-						!restarting &&
-						(finishedDownloading || metered)
-					"
-				>
+				<div v-if="availableUpdate && !restarting && (finishedDownloading || metered)">
 					<NavButton
 						v-tooltip.right="
 							formatMessage(
@@ -877,13 +1016,7 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 								},
 							)
 						"
-						:to="
-							finishedDownloading
-								? installUpdate
-								: downloadProgress > 0 && downloadProgress < 1
-									? showUpdateToast
-									: downloadAvailableUpdate
-						"
+						:to="finishedDownloading ? installUpdate : downloadAvailableUpdate"
 					>
 						<ProgressSpinner
 							v-if="downloadProgress > 0 && downloadProgress < 1"
@@ -902,7 +1035,7 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 				<SettingsIcon />
 			</NavButton>
 			<OverflowMenu
-				v-if="credentials"
+				v-if="credentials?.user"
 				v-tooltip.right="`Modrinth account`"
 				class="w-12 h-12 text-primary rounded-full flex items-center justify-center text-2xl transition-all bg-transparent hover:bg-button-bg hover:text-contrast border-0 cursor-pointer"
 				:options="[
@@ -918,14 +1051,14 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 				]"
 				placement="right-end"
 			>
-				<Avatar :src="credentials.user.avatar_url" alt="" size="32px" circle />
+				<Avatar :src="credentials?.user?.avatar_url" alt="" size="32px" circle />
 				<template #view-profile>
 					<UserIcon />
 					<span class="inline-flex items-center gap-1">
 						Signed in as
 						<span class="inline-flex items-center gap-1 text-contrast font-semibold">
-							<Avatar :src="credentials.user.avatar_url" alt="" size="20px" circle />
-							{{ credentials.user.username }}
+							<Avatar :src="credentials?.user?.avatar_url" alt="" size="20px" circle />
+							{{ credentials?.user?.username }}
 						</span>
 					</span>
 					<ExternalIcon />
@@ -937,9 +1070,9 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 			</NavButton>
 		</div>
 		<div data-tauri-drag-region class="app-grid-statusbar bg-bg-raised h-[--top-bar-height] flex">
-			<div data-tauri-drag-region class="flex p-3">
-				<ModrinthAppLogo class="h-full w-auto text-contrast pointer-events-none" />
-				<div data-tauri-drag-region class="flex items-center gap-1 ml-3">
+			<div data-tauri-drag-region class="flex min-w-0 flex-1 overflow-hidden p-3">
+				<ModrinthAppLogo class="h-full w-auto shrink-0 text-contrast pointer-events-none" />
+				<div data-tauri-drag-region class="flex shrink-0 items-center gap-1 ml-3">
 					<button
 						class="cursor-pointer p-0 m-0 text-contrast border-none outline-none bg-button-bg rounded-full flex items-center justify-center w-6 h-6 hover:brightness-75 transition-all"
 						@click="router.back()"
@@ -955,7 +1088,7 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 				</div>
 				<Breadcrumbs class="pt-[2px]" />
 			</div>
-			<section data-tauri-drag-region class="flex ml-auto items-center">
+			<section data-tauri-drag-region class="flex shrink-0 ml-auto items-center">
 				<ButtonStyled
 					v-if="!forceSidebar && themeStore.toggleSidebar"
 					:type="sidebarToggled ? 'standard' : 'transparent'"
@@ -1133,11 +1266,29 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 	<URLConfirmModal ref="urlModal" />
 	<I18nDebugPanel />
 	<NotificationPanel has-sidebar />
+	<PopupNotificationPanel has-sidebar />
 	<ErrorModal ref="errorModal" />
 	<MinecraftAuthErrorModal ref="minecraftAuthErrorModal" />
-	<ModInstallModal ref="modInstallModal" />
+	<ContentInstallModal
+		ref="modInstallModal"
+		:instances="contentInstallInstances"
+		:compatible-loaders="contentInstallLoaders"
+		:game-versions="contentInstallGameVersions"
+		:loading="contentInstallLoading"
+		:default-tab="contentInstallDefaultTab"
+		:preferred-loader="contentInstallPreferredLoader"
+		:preferred-game-version="contentInstallPreferredGameVersion"
+		:release-game-versions="contentInstallReleaseGameVersions"
+		@install="handleInstallToInstance"
+		@create-and-install="handleCreateAndInstall"
+		@navigate="handleContentInstallNavigate"
+		@cancel="handleContentInstallCancel"
+	/>
+	<AddServerToInstanceModal ref="addServerToInstanceModal" />
 	<IncompatibilityWarningModal ref="incompatibilityWarningModal" />
 	<InstallConfirmModal ref="installConfirmModal" />
+	<InstallToPlayModal ref="installToPlayModal" />
+	<UpdateToPlayModal ref="updateToPlayModal" />
 </template>
 
 <style lang="scss" scoped>
@@ -1366,38 +1517,15 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 	transform: translateY(10rem) scale(0.8) scaleY(1.6);
 }
 
-.toast-enter-active {
-	transition: opacity 0.25s linear;
-}
-
-.toast-enter-from,
-.toast-leave-to {
-	opacity: 0;
-}
-
 @media (prefers-reduced-motion: no-preference) {
-	.toast-enter-active,
 	.nav-button-animated-enter-active {
 		transition: all 0.5s cubic-bezier(0.15, 1.4, 0.64, 0.96);
 	}
 
-	.toast-leave-active,
 	.nav-button-animated-leave-active {
 		transition: all 0.25s ease;
 	}
 
-	.toast-enter-from {
-		scale: 0.5;
-		translate: 0 -10rem;
-		opacity: 0;
-	}
-
-	.toast-leave-to {
-		scale: 0.96;
-		translate: 20rem 0;
-		opacity: 0;
-	}
-
 	.nav-button-animated-enter-active {
 		position: relative;
 	}
@@ -1461,7 +1589,7 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 	}
 
 	.info-card {
-		right: 8rem;
+		right: 22rem;
 	}
 
 	.profile-card {

apps/app-frontend/src/assets/stylesheets/global.scss

@@ -155,4 +155,23 @@ img {
 	box-shadow: var(--shadow-card);
 }
 
+// From the Bootstrap project
+// The MIT License (MIT)
+// Copyright (c) 2011-2023 The Bootstrap Authors
+// https://github.com/twbs/bootstrap/blob/2f617215755b066904248525a8c56ea425dde871/scss/mixins/_visually-hidden.scss#L8
+.visually-hidden {
+	width: 1px !important;
+	height: 1px !important;
+	padding: 0 !important;
+	margin: -1px !important;
+	overflow: hidden !important;
+	clip: rect(0, 0, 0, 0) !important;
+	white-space: nowrap !important;
+	border: 0 !important;
+
+	&:not(caption) {
+		position: absolute !important;
+	}
+}
+
 @import '@modrinth/assets/omorphia.scss';

apps/app-frontend/src/components/GridDisplay.vue

@@ -22,7 +22,7 @@ import { computed, ref } from 'vue'
 
 import ContextMenu from '@/components/ui/ContextMenu.vue'
 import Instance from '@/components/ui/Instance.vue'
-import ConfirmModalWrapper from '@/components/ui/modal/ConfirmModalWrapper.vue'
+import ConfirmDeleteInstanceModal from '@/components/ui/modal/ConfirmDeleteInstanceModal.vue'
 import { duplicate, remove } from '@/helpers/profile.js'
 
 const { handleError } = injectNotificationManager()
@@ -302,14 +302,7 @@ const filteredResults = computed(() => {
 			/>
 		</section>
 	</div>
-	<ConfirmModalWrapper
-		ref="confirmModal"
-		title="Are you sure you want to delete this instance?"
-		description="If you proceed, all data for your instance will be removed. You will not be able to recover it."
-		:has-to-type="false"
-		proceed-label="Delete"
-		@proceed="deleteProfile"
-	/>
+	<ConfirmDeleteInstanceModal ref="confirmModal" @delete="deleteProfile" />
 	<ContextMenu ref="instanceOptions" @option-clicked="handleOptionsClick">
 		<template #play> <PlayIcon /> Play </template>
 		<template #stop> <StopCircleIcon /> Stop </template>

apps/app-frontend/src/components/RowDisplay.vue

@@ -19,15 +19,16 @@ import { useRouter } from 'vue-router'
 import ContextMenu from '@/components/ui/ContextMenu.vue'
 import Instance from '@/components/ui/Instance.vue'
 import LegacyProjectCard from '@/components/ui/LegacyProjectCard.vue'
-import ConfirmModalWrapper from '@/components/ui/modal/ConfirmModalWrapper.vue'
+import ConfirmDeleteInstanceModal from '@/components/ui/modal/ConfirmDeleteInstanceModal.vue'
 import { trackEvent } from '@/helpers/analytics'
 import { get_by_profile_path } from '@/helpers/process.js'
 import { duplicate, kill, remove, run } from '@/helpers/profile.js'
 import { showProfileInFolder } from '@/helpers/utils.js'
+import { injectContentInstall } from '@/providers/content-install'
 import { handleSevereError } from '@/store/error.js'
-import { install as installVersion } from '@/store/install.js'
 
 const { handleError } = injectNotificationManager()
+const { install: installVersion } = injectContentInstall()
 
 const router = useRouter()
 
@@ -238,14 +239,7 @@ onUnmounted(() => {
 </script>
 
 <template>
-	<ConfirmModalWrapper
-		ref="deleteConfirmModal"
-		title="Are you sure you want to delete this instance?"
-		description="If you proceed, all data for your instance will be removed. You will not be able to recover it."
-		:has-to-type="false"
-		proceed-label="Delete"
-		@proceed="deleteProfile"
-	/>
+	<ConfirmDeleteInstanceModal ref="deleteConfirmModal" @delete="deleteProfile" />
 	<div ref="rowContainer" class="flex flex-col gap-4">
 		<div v-for="row in actualInstances" ref="rows" :key="row.label" class="row">
 			<HeadingLink class="mt-1" :to="row.route">

apps/app-frontend/src/components/ui/Breadcrumbs.vue

@@ -1,64 +1,147 @@
 <template>
-	<div data-tauri-drag-region class="flex items-center gap-1 pl-3">
-		<Button v-if="false" class="breadcrumbs__back transparent" icon-only @click="$router.back()">
-			<ChevronLeftIcon />
-		</Button>
-		<Button
-			v-if="false"
-			class="breadcrumbs__forward transparent"
-			icon-only
-			@click="$router.forward()"
+	<div
+		ref="outerRef"
+		data-tauri-drag-region
+		class="min-w-0 overflow-hidden pl-3"
+		:style="isOverflowing ? { '--scroll-distance': `-${overflowAmount}px` } : undefined"
+		@mouseenter="onMouseEnter"
+		@mouseleave="onMouseLeave"
+	>
+		<div
+			ref="innerRef"
+			data-tauri-drag-region
+			class="flex w-fit items-center gap-1"
+			:class="{ 'breadcrumbs-scroll': isAnimating }"
+			@animationiteration="onAnimationIteration"
 		>
-			<ChevronRightIcon />
-		</Button>
-		{{ breadcrumbData.resetToNames(breadcrumbs) }}
-		<template v-for="breadcrumb in breadcrumbs" :key="breadcrumb.name">
-			<router-link
-				v-if="breadcrumb.link"
-				:to="{
-					path: breadcrumb.link.replace('{id}', encodeURIComponent($route.params.id)),
-					query: breadcrumb.query,
-				}"
-				class="text-primary"
-				>{{
-					breadcrumb.name.charAt(0) === '?'
-						? breadcrumbData.getName(breadcrumb.name.slice(1))
-						: breadcrumb.name
-				}}
-			</router-link>
-			<span
-				v-else
-				data-tauri-drag-region
-				class="text-contrast font-semibold cursor-default select-none"
-				>{{
-					breadcrumb.name.charAt(0) === '?'
-						? breadcrumbData.getName(breadcrumb.name.slice(1))
-						: breadcrumb.name
-				}}</span
-			>
-			<ChevronRightIcon v-if="breadcrumb.link" data-tauri-drag-region class="w-5 h-5" />
-		</template>
+			{{ breadcrumbData.resetToNames(breadcrumbs) }}
+			<template v-for="breadcrumb in breadcrumbs" :key="breadcrumb.name">
+				<router-link
+					v-if="breadcrumb.link"
+					:to="{
+						path: breadcrumb.link.replace('{id}', encodeURIComponent($route.params.id as string)),
+						query: breadcrumb.query,
+					}"
+					class="shrink-0 whitespace-nowrap text-primary"
+				>
+					{{ resolveLabel(breadcrumb.name) }}
+				</router-link>
+				<span
+					v-else
+					data-tauri-drag-region
+					class="shrink-0 whitespace-nowrap text-contrast font-semibold cursor-default select-none"
+				>
+					{{ resolveLabel(breadcrumb.name) }}
+				</span>
+				<ChevronRightIcon v-if="breadcrumb.link" data-tauri-drag-region class="w-5 h-5 shrink-0" />
+			</template>
+		</div>
 	</div>
 </template>
 
-<script setup>
-import { ChevronLeftIcon, ChevronRightIcon } from '@modrinth/assets'
-import { Button } from '@modrinth/ui'
-import { computed } from 'vue'
+<script setup lang="ts">
+import { ChevronRightIcon } from '@modrinth/assets'
+import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
 import { useRoute } from 'vue-router'
 
 import { useBreadcrumbs } from '@/store/breadcrumbs'
 
-const route = useRoute()
+interface Breadcrumb {
+	name: string
+	link?: string
+	query?: Record<string, string>
+}
 
+const route = useRoute()
 const breadcrumbData = useBreadcrumbs()
-const breadcrumbs = computed(() => {
+
+const breadcrumbs = computed<Breadcrumb[]>(() => {
 	const additionalContext =
 		route.meta.useContext === true
 			? breadcrumbData.context
 			: route.meta.useRootContext === true
 				? breadcrumbData.rootContext
 				: null
-	return additionalContext ? [additionalContext, ...route.meta.breadcrumb] : route.meta.breadcrumb
+	const crumbs = (route.meta.breadcrumb ?? []) as Breadcrumb[]
+	return additionalContext ? [additionalContext as Breadcrumb, ...crumbs] : crumbs
+})
+
+function resolveLabel(name: string): string {
+	return name.charAt(0) === '?' ? breadcrumbData.getName(name.slice(1)) : name
+}
+
+// Overflow detection
+const outerRef = ref<HTMLDivElement | null>(null)
+const innerRef = ref<HTMLDivElement | null>(null)
+const isOverflowing = ref(false)
+const isAnimating = ref(false)
+const overflowAmount = ref(0)
+
+let hovered = false
+let stopping = false
+
+function checkOverflow() {
+	if (!outerRef.value || !innerRef.value) return
+	const overflow = innerRef.value.scrollWidth - outerRef.value.clientWidth
+	isOverflowing.value = overflow > 0
+	overflowAmount.value = overflow + 12
+}
+
+function onMouseEnter() {
+	hovered = true
+	stopping = false
+	if (isOverflowing.value) {
+		isAnimating.value = true
+	}
+}
+
+function onMouseLeave() {
+	hovered = false
+	if (isAnimating.value) {
+		stopping = true
+	}
+}
+
+function onAnimationIteration() {
+	if (stopping && !hovered) {
+		isAnimating.value = false
+		stopping = false
+	}
+}
+
+let resizeObserver: ResizeObserver | null = null
+
+onMounted(() => {
+	checkOverflow()
+	resizeObserver = new ResizeObserver(checkOverflow)
+	if (outerRef.value) resizeObserver.observe(outerRef.value)
+	if (innerRef.value) resizeObserver.observe(innerRef.value)
+})
+
+onBeforeUnmount(() => {
+	resizeObserver?.disconnect()
+})
+
+watch(breadcrumbs, () => {
+	requestAnimationFrame(checkOverflow)
 })
 </script>
+
+<style scoped>
+.breadcrumbs-scroll {
+	animation: breadcrumb-scroll 10s ease-in-out infinite;
+}
+
+@keyframes breadcrumb-scroll {
+	0% {
+		transform: translateX(0);
+	}
+	35%,
+	65% {
+		transform: translateX(var(--scroll-distance));
+	}
+	100% {
+		transform: translateX(0);
+	}
+}
+</style>

apps/app-frontend/src/components/ui/ExportModal.vue

@@ -1,6 +1,14 @@
 <script setup>
 import { PlusIcon, XIcon } from '@modrinth/assets'
-import { Button, Checkbox, injectNotificationManager, StyledInput } from '@modrinth/ui'
+import {
+	Button,
+	Checkbox,
+	commonMessages,
+	defineMessages,
+	injectNotificationManager,
+	StyledInput,
+	useVIntl,
+} from '@modrinth/ui'
 import { open } from '@tauri-apps/plugin-dialog'
 import { ref } from 'vue'
 
@@ -9,6 +17,33 @@ import ModalWrapper from '@/components/ui/modal/ModalWrapper.vue'
 import { export_profile_mrpack, get_pack_export_candidates } from '@/helpers/profile.js'
 
 const { handleError } = injectNotificationManager()
+const { formatMessage } = useVIntl()
+
+const messages = defineMessages({
+	header: { id: 'app.export-modal.header', defaultMessage: 'Export modpack' },
+	modpackNameLabel: { id: 'app.export-modal.modpack-name-label', defaultMessage: 'Modpack Name' },
+	modpackNamePlaceholder: {
+		id: 'app.export-modal.modpack-name-placeholder',
+		defaultMessage: 'Modpack name',
+	},
+	versionNumberLabel: {
+		id: 'app.export-modal.version-number-label',
+		defaultMessage: 'Version number',
+	},
+	versionNumberPlaceholder: {
+		id: 'app.export-modal.version-number-placeholder',
+		defaultMessage: '1.0.0',
+	},
+	descriptionPlaceholder: {
+		id: 'app.export-modal.description-placeholder',
+		defaultMessage: 'Enter modpack description...',
+	},
+	selectFilesLabel: {
+		id: 'app.export-modal.select-files-label',
+		defaultMessage: 'Select files and folders to include in pack',
+	},
+	exportButton: { id: 'app.export-modal.export-button', defaultMessage: 'Export' },
+})
 
 const props = defineProps({
 	instance: {
@@ -106,36 +141,36 @@ const exportPack = async () => {
 </script>
 
 <template>
-	<ModalWrapper ref="exportModal" header="Export modpack">
+	<ModalWrapper ref="exportModal" :header="formatMessage(messages.header)">
 		<div class="modal-body">
 			<div class="labeled_input">
-				<p>Modpack Name</p>
+				<p>{{ formatMessage(messages.modpackNameLabel) }}</p>
 				<StyledInput
 					v-model="nameInput"
 					:icon="PackageIcon"
 					type="text"
-					placeholder="Modpack name"
+					:placeholder="formatMessage(messages.modpackNamePlaceholder)"
 					clearable
 				/>
 			</div>
 			<div class="labeled_input">
-				<p>Version number</p>
+				<p>{{ formatMessage(messages.versionNumberLabel) }}</p>
 				<StyledInput
 					v-model="versionInput"
 					:icon="VersionIcon"
 					type="text"
-					placeholder="1.0.0"
+					:placeholder="formatMessage(messages.versionNumberPlaceholder)"
 					clearable
 				/>
 			</div>
 			<div class="adjacent-input">
 				<div class="labeled_input">
-					<p>Description</p>
+					<p>{{ formatMessage(commonMessages.descriptionLabel) }}</p>
 
 					<StyledInput
 						v-model="exportDescription"
 						multiline
-						placeholder="Enter modpack description..."
+						:placeholder="formatMessage(messages.descriptionPlaceholder)"
 					/>
 				</div>
 			</div>
@@ -143,7 +178,7 @@ const exportPack = async () => {
 			<div class="table">
 				<div class="table-head">
 					<div class="table-cell row-wise">
-						Select files and folders to include in pack
+						{{ formatMessage(messages.selectFilesLabel) }}
 						<Button
 							class="sleek-primary collapsed-button"
 							icon-only
@@ -202,11 +237,11 @@ const exportPack = async () => {
 			<div class="button-row push-right">
 				<Button @click="exportModal.hide">
 					<XIcon />
-					Cancel
+					{{ formatMessage(commonMessages.cancelButton) }}
 				</Button>
 				<Button color="primary" @click="exportPack">
 					<PackageIcon />
-					Export
+					{{ formatMessage(messages.exportButton) }}
 				</Button>
 			</div>
 		</div>

apps/app-frontend/src/components/ui/Instance.vue

@@ -69,7 +69,7 @@ const play = async (e, context) => {
 	await run(props.instance.path)
 		.catch((err) => handleSevereError(err, { profilePath: props.instance.path }))
 		.finally(() => {
-			trackEvent('InstancePlay', {
+			trackEvent('InstanceStart', {
 				loader: props.instance.loader,
 				game_version: props.instance.game_version,
 				source: context,

apps/app-frontend/src/components/ui/InstanceCreationModal.vue

@@ -1,662 +0,0 @@
-<template>
-	<ModalWrapper ref="modal" header="Creating an instance">
-		<div class="modal-header">
-			<Chips v-model="creationType" :items="['custom', 'from file', 'import from launcher']" />
-		</div>
-		<hr class="card-divider" />
-		<div v-if="creationType === 'custom'" class="modal-body">
-			<div class="image-upload">
-				<Avatar :src="display_icon" size="md" :rounded="true" />
-				<div class="image-input">
-					<Button @click="upload_icon()">
-						<UploadIcon />
-						Select icon
-					</Button>
-					<Button :disabled="!display_icon" @click="reset_icon">
-						<XIcon />
-						Remove icon
-					</Button>
-				</div>
-			</div>
-			<div class="input-row">
-				<p class="input-label">Name</p>
-				<StyledInput
-					v-model="profile_name"
-					autocomplete="off"
-					type="text"
-					placeholder="Enter a name for your instance..."
-					:maxlength="100"
-					wrapper-class="w-full"
-				/>
-			</div>
-			<div class="input-row">
-				<p class="input-label">Loader</p>
-				<Chips v-model="loader" :items="loaders" />
-			</div>
-			<div class="input-row">
-				<p class="input-label">Game version</p>
-				<div class="flex gap-4 items-center">
-					<multiselect
-						v-model="game_version"
-						class="selector"
-						:options="game_versions"
-						:multiple="false"
-						:searchable="true"
-						placeholder="Select game version"
-						open-direction="top"
-						:show-labels="false"
-					/>
-					<Checkbox v-model="showSnapshots" class="shrink-0" label="Show all versions" />
-				</div>
-			</div>
-			<div v-if="loader !== 'vanilla'" class="input-row">
-				<p class="input-label">Loader version</p>
-				<Chips v-model="loader_version" :items="['stable', 'latest', 'other']" />
-			</div>
-			<div v-if="loader_version === 'other' && loader !== 'vanilla'">
-				<div v-if="game_version" class="input-row">
-					<p class="input-label">Select version</p>
-					<multiselect
-						v-model="specified_loader_version"
-						class="selector"
-						:options="selectable_versions"
-						:searchable="true"
-						placeholder="Select loader version"
-						open-direction="top"
-						:show-labels="false"
-					/>
-				</div>
-				<div v-else class="input-row">
-					<p class="warning">Select a game version before you select a loader version</p>
-				</div>
-			</div>
-			<div class="input-group push-right">
-				<Button @click="hide()">
-					<XIcon />
-					Cancel
-				</Button>
-				<Button color="primary" :disabled="!check_valid || creating" @click="create_instance()">
-					<PlusIcon v-if="!creating" />
-					{{ creating ? 'Creating...' : 'Create' }}
-				</Button>
-			</div>
-		</div>
-		<div v-else-if="creationType === 'from file'" class="modal-body">
-			<Button @click="openFile"> <FolderOpenIcon /> Import from file </Button>
-			<div class="info"><InfoIcon /> Or drag and drop your .mrpack file</div>
-		</div>
-		<div v-else class="modal-body">
-			<Chips
-				v-model="selectedProfileType"
-				:items="profileOptions"
-				:format-label="(profile) => profile?.name"
-			/>
-			<div class="path-selection">
-				<h3>{{ selectedProfileType.name }} path</h3>
-				<div class="path-input">
-					<StyledInput
-						v-model="selectedProfileType.path"
-						:icon="FolderOpenIcon"
-						type="text"
-						placeholder="Path to launcher"
-						clearable
-						@change="setPath"
-					/>
-					<Button icon-only @click="selectLauncherPath">
-						<FolderSearchIcon />
-					</Button>
-					<Button icon-only @click="reload">
-						<UpdatedIcon />
-					</Button>
-				</div>
-			</div>
-			<div class="table">
-				<div class="table-head table-row">
-					<div class="toggle-all table-cell">
-						<Checkbox
-							class="select-checkbox"
-							:model-value="
-								profiles.get(selectedProfileType.name)?.every((child) => child.selected)
-							"
-							@update:model-value="
-								(newValue) =>
-									profiles
-										.get(selectedProfileType.name)
-										?.forEach((child) => (child.selected = newValue))
-							"
-						/>
-					</div>
-					<div class="name-cell table-cell">Profile name</div>
-				</div>
-				<div
-					v-if="
-						profiles.get(selectedProfileType.name) &&
-						profiles.get(selectedProfileType.name).length > 0
-					"
-					class="table-content"
-				>
-					<div
-						v-for="(profile, index) in profiles.get(selectedProfileType.name)"
-						:key="index"
-						class="table-row"
-					>
-						<div class="checkbox-cell table-cell">
-							<Checkbox v-model="profile.selected" class="select-checkbox" />
-						</div>
-						<div class="name-cell table-cell">
-							{{ profile.name }}
-						</div>
-					</div>
-				</div>
-				<div v-else class="table-content empty">No profiles found</div>
-			</div>
-			<div class="button-row">
-				<Button
-					:disabled="
-						loading ||
-						!Array.from(profiles.values())
-							.flatMap((e) => e)
-							.some((e) => e.selected)
-					"
-					color="primary"
-					@click="next"
-				>
-					{{
-						loading
-							? 'Importing...'
-							: Array.from(profiles.values())
-										.flatMap((e) => e)
-										.some((e) => e.selected)
-								? `Import ${
-										Array.from(profiles.values())
-											.flatMap((e) => e)
-											.filter((e) => e.selected).length
-									} profiles`
-								: 'Select profiles to import'
-					}}
-				</Button>
-				<ProgressBar
-					v-if="loading"
-					:progress="(importedProfiles / (totalProfiles + 0.0001)) * 100"
-				/>
-			</div>
-		</div>
-	</ModalWrapper>
-</template>
-
-<script setup>
-import {
-	FolderOpenIcon,
-	FolderSearchIcon,
-	InfoIcon,
-	PlusIcon,
-	UpdatedIcon,
-	UploadIcon,
-	XIcon,
-} from '@modrinth/assets'
-import {
-	Avatar,
-	Button,
-	Checkbox,
-	Chips,
-	injectNotificationManager,
-	StyledInput,
-} from '@modrinth/ui'
-import { convertFileSrc } from '@tauri-apps/api/core'
-import { getCurrentWebview } from '@tauri-apps/api/webview'
-import { open } from '@tauri-apps/plugin-dialog'
-import { computed, onUnmounted, ref, shallowRef } from 'vue'
-import Multiselect from 'vue-multiselect'
-
-import ModalWrapper from '@/components/ui/modal/ModalWrapper.vue'
-import ProgressBar from '@/components/ui/ProgressBar.vue'
-import { trackEvent } from '@/helpers/analytics'
-import {
-	get_default_launcher_path,
-	get_importable_instances,
-	import_instance,
-} from '@/helpers/import.js'
-import { get_game_versions, get_loader_versions } from '@/helpers/metadata'
-import { create_profile_and_install_from_file } from '@/helpers/pack.js'
-import { create } from '@/helpers/profile'
-import { get_loaders } from '@/helpers/tags'
-
-const { handleError } = injectNotificationManager()
-
-const profile_name = ref('')
-const game_version = ref('')
-const loader = ref('vanilla')
-const loader_version = ref('stable')
-const specified_loader_version = ref('')
-const icon = ref(null)
-const display_icon = ref(null)
-const creating = ref(false)
-const showSnapshots = ref(false)
-const creationType = ref('custom')
-const isShowing = ref(false)
-
-defineExpose({
-	show: async () => {
-		game_version.value = ''
-		specified_loader_version.value = ''
-		profile_name.value = ''
-		creating.value = false
-		showSnapshots.value = false
-		loader.value = 'vanilla'
-		loader_version.value = 'stable'
-		icon.value = null
-		display_icon.value = null
-		isShowing.value = true
-		modal.value.show()
-
-		unlistener.value = await getCurrentWebview().onDragDropEvent(async (event) => {
-			// Only if modal is showing
-			if (!isShowing.value) return
-			if (event.payload.type !== 'drop') return
-			if (creationType.value !== 'from file') return
-			hide()
-			const { paths } = event.payload
-			if (paths && paths.length > 0 && paths[0].endsWith('.mrpack')) {
-				await create_profile_and_install_from_file(paths[0]).catch(handleError)
-				trackEvent('InstanceCreate', {
-					source: 'CreationModalFileDrop',
-				})
-			}
-		})
-
-		trackEvent('InstanceCreateStart', { source: 'CreationModal' })
-	},
-})
-
-const unlistener = ref(null)
-const hide = () => {
-	isShowing.value = false
-	modal.value.hide()
-	if (unlistener.value) {
-		unlistener.value()
-		unlistener.value = null
-	}
-}
-onUnmounted(() => {
-	if (unlistener.value) {
-		unlistener.value()
-		unlistener.value = null
-	}
-})
-
-const [
-	fabric_versions,
-	forge_versions,
-	quilt_versions,
-	neoforge_versions,
-	all_game_versions,
-	loaders,
-] = await Promise.all([
-	get_loader_versions('fabric').then(shallowRef).catch(handleError),
-	get_loader_versions('forge').then(shallowRef).catch(handleError),
-	get_loader_versions('quilt').then(shallowRef).catch(handleError),
-	get_loader_versions('neo').then(shallowRef).catch(handleError),
-	get_game_versions().then(shallowRef).catch(handleError),
-	get_loaders()
-		.then((value) =>
-			ref(
-				value
-					.filter((item) => item.supported_project_types.includes('modpack'))
-					.map((item) => item.name.toLowerCase()),
-			),
-		)
-		.catch((err) => {
-			handleError(err)
-			return ref([])
-		}),
-])
-loaders.value.unshift('vanilla')
-
-const game_versions = computed(() => {
-	return all_game_versions.value.versions
-		.filter((item) => {
-			let defaultVal = item.type === 'release' || showSnapshots.value
-			if (loader.value === 'fabric') {
-				defaultVal &= fabric_versions.value.gameVersions.some((x) => item.id === x.id)
-			} else if (loader.value === 'forge') {
-				defaultVal &= forge_versions.value.gameVersions.some((x) => item.id === x.id)
-			} else if (loader.value === 'quilt') {
-				defaultVal &= quilt_versions.value.gameVersions.some((x) => item.id === x.id)
-			} else if (loader.value === 'neoforge') {
-				defaultVal &= neoforge_versions.value.gameVersions.some((x) => item.id === x.id)
-			}
-
-			return defaultVal
-		})
-		.map((item) => item.id)
-})
-
-const modal = ref(null)
-
-const check_valid = computed(() => {
-	return (
-		profile_name.value.trim() &&
-		game_version.value &&
-		game_versions.value.includes(game_version.value)
-	)
-})
-
-const create_instance = async () => {
-	creating.value = true
-	const loader_version_value =
-		loader_version.value === 'other' ? specified_loader_version.value : loader_version.value
-	const loaderVersion = loader.value === 'vanilla' ? null : (loader_version_value ?? 'stable')
-
-	hide()
-	creating.value = false
-
-	await create(
-		profile_name.value,
-		game_version.value,
-		loader.value,
-		loader.value === 'vanilla' ? null : (loader_version_value ?? 'stable'),
-		icon.value,
-	).catch(handleError)
-
-	trackEvent('InstanceCreate', {
-		profile_name: profile_name.value,
-		game_version: game_version.value,
-		loader: loader.value,
-		loader_version: loaderVersion,
-		has_icon: !!icon.value,
-		source: 'CreationModal',
-	})
-}
-
-const upload_icon = async () => {
-	const res = await open({
-		multiple: false,
-		filters: [
-			{
-				name: 'Image',
-				extensions: ['png', 'jpeg', 'svg', 'webp', 'gif', 'jpg'],
-			},
-		],
-	})
-
-	icon.value = res.path ?? res
-
-	if (!icon.value) return
-	display_icon.value = convertFileSrc(icon.value)
-}
-
-const reset_icon = () => {
-	icon.value = null
-	display_icon.value = null
-}
-
-const selectable_versions = computed(() => {
-	if (game_version.value) {
-		if (loader.value === 'fabric') {
-			return fabric_versions.value.gameVersions[0].loaders.map((item) => item.id)
-		} else if (loader.value === 'forge') {
-			return forge_versions.value.gameVersions
-				.find((item) => item.id === game_version.value)
-				.loaders.map((item) => item.id)
-		} else if (loader.value === 'quilt') {
-			return quilt_versions.value.gameVersions[0].loaders.map((item) => item.id)
-		} else if (loader.value === 'neoforge') {
-			return neoforge_versions.value.gameVersions
-				.find((item) => item.id === game_version.value)
-				.loaders.map((item) => item.id)
-		}
-	}
-	return []
-})
-
-const openFile = async () => {
-	const newProject = await open({ multiple: false })
-	if (!newProject) return
-	hide()
-	await create_profile_and_install_from_file(newProject.path ?? newProject).catch(handleError)
-
-	trackEvent('InstanceCreate', {
-		source: 'CreationModalFileOpen',
-	})
-}
-
-const profiles = ref(
-	new Map([
-		['MultiMC', []],
-		['GDLauncher', []],
-		['ATLauncher', []],
-		['Curseforge', []],
-		['PrismLauncher', []],
-	]),
-)
-
-const loading = ref(false)
-const importedProfiles = ref(0)
-const totalProfiles = ref(0)
-
-const selectedProfileType = ref('MultiMC')
-const profileOptions = ref([
-	{ name: 'MultiMC', path: '' },
-	{ name: 'GDLauncher', path: '' },
-	{ name: 'ATLauncher', path: '' },
-	{ name: 'Curseforge', path: '' },
-	{ name: 'PrismLauncher', path: '' },
-])
-
-// Attempt to get import profiles on default paths
-const promises = profileOptions.value.map(async (option) => {
-	const path = await get_default_launcher_path(option.name).catch(handleError)
-	if (!path || path === '') return
-
-	// Try catch to allow failure and simply ignore default path attempt
-	try {
-		const instances = await get_importable_instances(option.name, path)
-
-		if (!instances) return
-		profileOptions.value.find((profile) => profile.name === option.name).path = path
-		profiles.value.set(
-			option.name,
-			instances.map((name) => ({ name, selected: false })),
-		)
-	} catch {
-		// Allow failure silently
-	}
-})
-await Promise.all(promises)
-
-const selectLauncherPath = async () => {
-	selectedProfileType.value.path = await open({ multiple: false, directory: true })
-
-	if (selectedProfileType.value.path) {
-		await reload()
-	}
-}
-
-const reload = async () => {
-	const instances = await get_importable_instances(
-		selectedProfileType.value.name,
-		selectedProfileType.value.path,
-	).catch(handleError)
-	if (instances) {
-		profiles.value.set(
-			selectedProfileType.value.name,
-			instances.map((name) => ({ name, selected: false })),
-		)
-	} else {
-		profiles.value.set(selectedProfileType.value.name, [])
-	}
-}
-
-const setPath = () => {
-	profileOptions.value.find((profile) => profile.name === selectedProfileType.value.name).path =
-		selectedProfileType.value.path
-}
-
-const next = async () => {
-	importedProfiles.value = 0
-	totalProfiles.value = Array.from(profiles.value.values())
-		.map((profiles) => profiles.filter((profile) => profile.selected).length)
-		.reduce((a, b) => a + b, 0)
-	loading.value = true
-	for (const launcher of Array.from(profiles.value.entries()).map(([launcher, profiles]) => ({
-		launcher,
-		path: profileOptions.value.find((option) => option.name === launcher).path,
-		profiles,
-	}))) {
-		for (const profile of launcher.profiles.filter((profile) => profile.selected)) {
-			await import_instance(launcher.launcher, launcher.path, profile.name)
-				.catch(handleError)
-				.then(() => console.log(`Successfully Imported ${profile.name} from ${launcher.launcher}`))
-			profile.selected = false
-			importedProfiles.value++
-		}
-	}
-	loading.value = false
-}
-</script>
-
-<style lang="scss" scoped>
-.modal-body {
-	display: flex;
-	flex-direction: column;
-	gap: var(--gap-md);
-	margin-top: var(--gap-lg);
-}
-
-.input-label {
-	font-size: 1rem;
-	font-weight: bolder;
-	color: var(--color-contrast);
-	margin-bottom: 0.5rem;
-}
-
-.text-input {
-	width: 20rem;
-}
-
-.image-upload {
-	display: flex;
-	gap: 1rem;
-}
-
-.image-input {
-	display: flex;
-	flex-direction: column;
-	gap: 0.5rem;
-	justify-content: center;
-}
-
-.warning {
-	font-style: italic;
-}
-
-:deep(button.checkbox) {
-	border: none;
-}
-
-.selector {
-	max-width: 20rem;
-}
-
-.labeled-divider {
-	text-align: center;
-}
-
-.labeled-divider:after {
-	background-color: var(--color-raised-bg);
-	content: 'Or';
-	color: var(--color-base);
-	padding: var(--gap-sm);
-	position: relative;
-	top: -0.5rem;
-}
-
-.info {
-	display: flex;
-	flex-direction: row;
-	gap: 0.5rem;
-	align-items: center;
-}
-
-.modal-header {
-	display: flex;
-	flex-direction: row;
-	justify-content: space-between;
-	align-items: center;
-	padding-bottom: 0;
-}
-
-.path-selection {
-	padding: var(--gap-xl);
-	background-color: var(--color-bg);
-	border-radius: var(--radius-lg);
-	display: flex;
-	flex-direction: column;
-	gap: var(--gap-md);
-
-	h3 {
-		margin: 0;
-	}
-
-	.path-input {
-		display: flex;
-		align-items: center;
-		width: 100%;
-		flex-direction: row;
-		gap: var(--gap-sm);
-
-		.iconified-input {
-			flex-grow: 1;
-			:deep(input) {
-				width: 100%;
-				flex-basis: auto;
-			}
-		}
-	}
-}
-
-.table {
-	border: 1px solid var(--color-bg);
-}
-
-.table-row {
-	grid-template-columns: min-content auto;
-}
-
-.table-content {
-	max-height: calc(5 * (18px + 2rem));
-	height: calc(5 * (18px + 2rem));
-	overflow-y: auto;
-}
-
-.select-checkbox {
-	button.checkbox {
-		border: none;
-	}
-}
-
-.button-row {
-	display: flex;
-	flex-direction: row;
-	justify-content: space-between;
-	align-items: center;
-	gap: var(--gap-md);
-
-	.transparent {
-		padding: var(--gap-sm) 0;
-	}
-}
-
-.empty {
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	font-size: 1.5rem;
-	font-weight: bolder;
-	color: var(--color-contrast);
-}
-
-.card-divider {
-	margin: var(--gap-md) var(--gap-lg) 0 var(--gap-lg);
-}
-</style>

apps/app-frontend/src/components/ui/LegacyProjectCard.vue

@@ -1,7 +1,6 @@
 <script setup>
 import { DownloadIcon, HeartIcon, TagIcon } from '@modrinth/assets'
-import { Avatar, FormattedTag, TagItem } from '@modrinth/ui'
-import { formatNumber } from '@modrinth/utils'
+import { Avatar, FormattedTag, TagItem, useCompactNumber } from '@modrinth/ui'
 import dayjs from 'dayjs'
 import relativeTime from 'dayjs/plugin/relativeTime'
 import { computed } from 'vue'
@@ -11,6 +10,8 @@ dayjs.extend(relativeTime)
 
 const router = useRouter()
 
+const { formatCompactNumber } = useCompactNumber()
+
 const props = defineProps({
 	project: {
 		type: Object,
@@ -96,13 +97,13 @@ const toTransparent = computed(() => {
 					class="flex items-center gap-1 pr-2 border-0 border-r-[1px] border-solid border-button-border"
 				>
 					<DownloadIcon />
-					{{ formatNumber(project.downloads) }}
+					{{ formatCompactNumber(project.downloads) }}
 				</div>
 				<div
 					class="flex items-center gap-1 pr-2 border-0 border-r-[1px] border-solid border-button-border"
 				>
 					<HeartIcon />
-					{{ formatNumber(project.follows) }}
+					{{ formatCompactNumber(project.follows) }}
 				</div>
 				<div class="flex items-center gap-1 pr-2">
 					<TagIcon />

apps/app-frontend/src/components/ui/NavTabs.vue

@@ -1,5 +1,7 @@
 <template>
 	<nav
+		v-if="filteredLinks.length > 1"
+		ref="scrollContainer"
 		class="card-shadow experimental-styles-within relative flex w-fit overflow-clip rounded-full bg-bg-raised p-1 text-sm font-bold"
 	>
 		<RouterLink
@@ -14,13 +16,17 @@
 			<span class="text-nowrap">{{ link.label }}</span>
 		</RouterLink>
 		<div
-			:class="`navtabs-transition pointer-events-none absolute h-[calc(100%-0.5rem)] overflow-hidden rounded-full p-1 ${subpageSelected ? 'bg-button-bg' : 'bg-button-bgSelected'}`"
+			:class="[
+				'pointer-events-none absolute h-[calc(100%-0.5rem)] overflow-hidden rounded-full p-1',
+				subpageSelected ? 'bg-button-bg' : 'bg-button-bgSelected',
+				{ 'navtabs-transition': transitionsEnabled },
+			]"
 			:style="{
 				left: sliderLeftPx,
 				top: sliderTopPx,
 				right: sliderRightPx,
 				bottom: sliderBottomPx,
-				opacity: sliderLeft === 4 && sliderLeft === sliderRight ? 0 : activeIndex === -1 ? 0 : 1,
+				opacity: sliderReady && activeIndex !== -1 ? 1 : 0,
 			}"
 			aria-hidden="true"
 		></div>
@@ -28,7 +34,7 @@
 </template>
 
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
+import { computed, nextTick, onMounted, onUnmounted, ref, watch } from 'vue'
 import type { RouteLocationRaw } from 'vue-router'
 import { RouterLink, useRoute } from 'vue-router'
 
@@ -47,13 +53,16 @@ const props = defineProps<{
 	query?: string
 }>()
 
+const scrollContainer = ref<HTMLElement | null>(null)
 const sliderLeft = ref(4)
 const sliderTop = ref(4)
 const sliderRight = ref(4)
 const sliderBottom = ref(4)
 const activeIndex = ref(-1)
-const oldIndex = ref(-1)
 const subpageSelected = ref(false)
+const sliderReady = ref(false)
+const transitionsEnabled = ref(false)
+const sliderDelays = ref({ left: '0ms', top: '0ms', right: '0ms', bottom: '0ms' })
 
 const filteredLinks = computed(() =>
 	props.links.filter((x) => (x.shown === undefined ? true : x.shown)),
@@ -63,6 +72,11 @@ const sliderTopPx = computed(() => `${sliderTop.value}px`)
 const sliderRightPx = computed(() => `${sliderRight.value}px`)
 const sliderBottomPx = computed(() => `${sliderBottom.value}px`)
 
+const leftDelay = computed(() => sliderDelays.value.left)
+const rightDelay = computed(() => sliderDelays.value.right)
+const topDelay = computed(() => sliderDelays.value.top)
+const bottomDelay = computed(() => sliderDelays.value.bottom)
+
 function pickLink() {
 	let index = -1
 	subpageSelected.value = false
@@ -83,62 +97,60 @@ function pickLink() {
 	if (activeIndex.value !== -1) {
 		startAnimation()
 	} else {
-		oldIndex.value = -1
 		sliderLeft.value = 0
 		sliderRight.value = 0
 	}
 }
 
-const tabLinkElements = ref()
+function getTabElement(index: number): HTMLElement | null {
+	if (index === -1) return null
+	const container = scrollContainer.value
+	if (!container) return null
+	const tabs = container.querySelectorAll('.button-animation')
+	return (tabs[index] as HTMLElement) ?? null
+}
 
 function startAnimation() {
-	const el = tabLinkElements.value[activeIndex.value].$el
-
-	if (!el || !el.offsetParent) return
+	const el = getTabElement(activeIndex.value)
+	if (!el?.offsetParent) return
 
+	const parent = el.offsetParent as HTMLElement
 	const newValues = {
 		left: el.offsetLeft,
 		top: el.offsetTop,
-		right: el.offsetParent.offsetWidth - el.offsetLeft - el.offsetWidth,
-		bottom: el.offsetParent.offsetHeight - el.offsetTop - el.offsetHeight,
+		right: parent.offsetWidth - el.offsetLeft - el.offsetWidth,
+		bottom: parent.offsetHeight - el.offsetTop - el.offsetHeight,
 	}
 
-	if (sliderLeft.value === 4 && sliderRight.value === 4) {
+	const isInitialPosition = sliderLeft.value === 4 && sliderRight.value === 4
+
+	if (isInitialPosition) {
 		sliderLeft.value = newValues.left
 		sliderRight.value = newValues.right
 		sliderTop.value = newValues.top
 		sliderBottom.value = newValues.bottom
+		sliderReady.value = true
+		requestAnimationFrame(() => {
+			transitionsEnabled.value = true
+		})
 	} else {
-		const delay = 200
-
-		if (newValues.left < sliderLeft.value) {
-			sliderLeft.value = newValues.left
-			setTimeout(() => {
-				sliderRight.value = newValues.right
-			}, delay)
-		} else {
-			sliderRight.value = newValues.right
-			setTimeout(() => {
-				sliderLeft.value = newValues.left
-			}, delay)
-		}
-
-		if (newValues.top < sliderTop.value) {
-			sliderTop.value = newValues.top
-			setTimeout(() => {
-				sliderBottom.value = newValues.bottom
-			}, delay)
-		} else {
-			sliderBottom.value = newValues.bottom
-			setTimeout(() => {
-				sliderTop.value = newValues.top
-			}, delay)
+		const STAGGER_DELAY = '200ms'
+		sliderDelays.value = {
+			left: newValues.left < sliderLeft.value ? '0ms' : STAGGER_DELAY,
+			right: newValues.left < sliderLeft.value ? STAGGER_DELAY : '0ms',
+			top: newValues.top < sliderTop.value ? '0ms' : STAGGER_DELAY,
+			bottom: newValues.top < sliderTop.value ? STAGGER_DELAY : '0ms',
 		}
+		sliderLeft.value = newValues.left
+		sliderRight.value = newValues.right
+		sliderTop.value = newValues.top
+		sliderBottom.value = newValues.bottom
 	}
 }
 
-onMounted(() => {
+onMounted(async () => {
 	window.addEventListener('resize', pickLink)
+	await nextTick()
 	pickLink()
 })
 
@@ -146,7 +158,17 @@ onUnmounted(() => {
 	window.removeEventListener('resize', pickLink)
 })
 
-watch(route, () => {
+watch(
+	filteredLinks,
+	async () => {
+		await nextTick()
+		pickLink()
+	},
+	{ deep: true },
+)
+
+watch(route, async () => {
+	await nextTick()
 	pickLink()
 })
 </script>
@@ -154,7 +176,10 @@ watch(route, () => {
 .navtabs-transition {
 	/* Delay on opacity is to hide any jankiness as the page loads */
 	transition:
-		all 150ms cubic-bezier(0.4, 0, 0.2, 1) 0s,
+		left 150ms cubic-bezier(0.4, 0, 0.2, 1) v-bind(leftDelay),
+		right 150ms cubic-bezier(0.4, 0, 0.2, 1) v-bind(rightDelay),
+		top 150ms cubic-bezier(0.4, 0, 0.2, 1) v-bind(topDelay),
+		bottom 150ms cubic-bezier(0.4, 0, 0.2, 1) v-bind(bottomDelay),
 		opacity 250ms cubic-bezier(0.5, 0, 0.2, 1) 50ms;
 }
 </style>

apps/app-frontend/src/components/ui/QuickInstanceSwitcher.vue

@@ -49,27 +49,26 @@ onUnmounted(() => {
 </script>
 
 <template>
-	<NavButton
-		v-for="instance in recentInstances"
-		:key="instance.id"
-		v-tooltip.right="instance.name"
-		:to="`/instance/${encodeURIComponent(instance.path)}`"
-		class="relative"
-	>
-		<Avatar
-			:src="instance.icon_path ? convertFileSrc(instance.icon_path) : null"
-			size="28px"
-			:tint-by="instance.path"
-			:class="`transition-all ${instance.install_stage !== 'installed' ? `brightness-[0.25] scale-[0.85]` : `group-hover:brightness-75`}`"
-		/>
-		<div
-			v-if="instance.install_stage !== 'installed'"
-			class="absolute inset-0 flex items-center justify-center z-10"
-		>
-			<SpinnerIcon class="animate-spin w-4 h-4" />
-		</div>
-	</NavButton>
-	<div v-if="recentInstances.length > 0" class="h-px w-6 mx-auto my-2 bg-divider"></div>
+	<div v-for="instance in recentInstances" :key="instance.id" v-tooltip.right="instance.name">
+		<NavButton :to="`/instance/${encodeURIComponent(instance.path)}`" class="relative">
+			<Avatar
+				:src="instance.icon_path ? convertFileSrc(instance.icon_path) : null"
+				size="28px"
+				:tint-by="instance.path"
+				:class="`transition-all ${instance.install_stage !== 'installed' ? `brightness-[0.25] scale-[0.85]` : `group-hover:brightness-75`}`"
+			/>
+			<div
+				v-if="instance.install_stage !== 'installed'"
+				class="absolute inset-0 flex items-center justify-center z-10 pointer-events-none"
+			>
+				<SpinnerIcon class="animate-spin w-4 h-4" />
+			</div>
+		</NavButton>
+	</div>
+	<div
+		v-if="instances && recentInstances.length > 0"
+		class="h-px w-6 mx-auto my-2 bg-divider"
+	></div>
 </template>
 
 <style scoped lang="scss"></style>

apps/app-frontend/src/components/ui/RunningAppBar.vue

@@ -52,10 +52,12 @@
 				<h3 class="info-title">
 					{{ loadingBar.title }}
 				</h3>
-				<ProgressBar :progress="Math.floor((100 * loadingBar.current) / loadingBar.total)" />
-				<div class="row">
-					{{ Math.floor((100 * loadingBar.current) / loadingBar.total) }}%
-					{{ loadingBar.message }}
+				<div class="flex flex-col gap-2 w-full">
+					<ProgressBar :progress="Math.floor((100 * loadingBar.current) / loadingBar.total)" />
+					<div class="row">
+						{{ Math.floor((100 * loadingBar.current) / loadingBar.total) }}%
+						{{ loadingBar.message }}
+					</div>
 				</div>
 			</div>
 		</Card>
@@ -346,7 +348,7 @@ onBeforeUnmount(() => {
 .info-card {
 	position: absolute;
 	top: 3.5rem;
-	right: 0.5rem;
+	right: 2rem;
 	z-index: 9;
 	width: 20rem;
 	background-color: var(--color-raised-bg);
@@ -420,7 +422,7 @@ onBeforeUnmount(() => {
 	display: flex;
 	flex-direction: column;
 	align-items: flex-start;
-	gap: 0.5rem;
+	gap: 0.75rem;
 	margin: 0;
 	padding: 0;
 }

apps/app-frontend/src/components/ui/SearchCard.vue

@@ -1,6 +1,6 @@
 <template>
 	<ProjectCard
-		:title="project.title"
+		:title="project.name"
 		:link="
 			() => {
 				emit('open')
@@ -12,7 +12,7 @@
 		"
 		:author="{ name: project.author, link: `https://modrinth.com/user/${project.author}` }"
 		:icon-url="project.icon_url"
-		:summary="project.description"
+		:summary="project.summary"
 		:tags="project.display_categories"
 		:all-tags="project.categories"
 		:downloads="project.downloads"
@@ -20,16 +20,6 @@
 		:date-updated="project.date_modified"
 		:banner="project.featured_gallery ?? undefined"
 		:color="project.color ?? undefined"
-		:environment="
-			projectType
-				? ['mod', 'modpack'].includes(projectType)
-					? {
-							clientSide: project.client_side,
-							serverSide: project.server_side,
-						}
-					: undefined
-				: undefined
-		"
 		layout="list"
 	>
 		<template #actions>
@@ -39,7 +29,8 @@
 					class="shrink-0 no-wrap"
 					@click.stop="install()"
 				>
-					<template v-if="!installed">
+					<SpinnerIcon v-if="installing" class="animate-spin" />
+					<template v-else-if="!installed">
 						<DownloadIcon v-if="modpack || instance" />
 						<PlusIcon v-else />
 					</template>
@@ -60,14 +51,17 @@
 </template>
 
 <script setup>
-import { CheckIcon, DownloadIcon, PlusIcon } from '@modrinth/assets'
+import { CheckIcon, DownloadIcon, PlusIcon, SpinnerIcon } from '@modrinth/assets'
 import { ButtonStyled, injectNotificationManager, ProjectCard } from '@modrinth/ui'
 import dayjs from 'dayjs'
 import relativeTime from 'dayjs/plugin/relativeTime'
 import { computed, ref } from 'vue'
 import { useRouter } from 'vue-router'
 
-import { install as installVersion } from '@/store/install.js'
+import { injectContentInstall } from '@/providers/content-install'
+
+const { install: installVersion } = injectContentInstall()
+
 dayjs.extend(relativeTime)
 
 const { handleError } = injectNotificationManager()
@@ -99,6 +93,14 @@ const props = defineProps({
 		type: String,
 		default: undefined,
 	},
+	activeLoader: {
+		type: String,
+		default: null,
+	},
+	activeGameVersion: {
+		type: String,
+		default: null,
+	},
 })
 
 const emit = defineEmits(['open', 'install'])
@@ -112,15 +114,21 @@ async function install() {
 		null,
 		props.instance ? props.instance.path : null,
 		'SearchCard',
-		() => {
+		(versionId) => {
 			installing.value = false
-			emit('install', props.project.project_id ?? props.project.id)
+			if (versionId) {
+				emit('install', props.project.project_id ?? props.project.id)
+			}
 		},
 		(profile) => {
 			router.push(`/instance/${profile}`)
 		},
+		{
+			preferredLoader: props.activeLoader ?? undefined,
+			preferredGameVersion: props.activeGameVersion ?? undefined,
+		},
 	).catch(handleError)
 }
 
-const modpack = computed(() => props.project.project_type === 'modpack')
+const modpack = computed(() => props.project.project_types?.includes('modpack'))
 </script>

apps/app-frontend/src/components/ui/URLConfirmModal.vue

@@ -6,9 +6,10 @@ import ModalWrapper from '@/components/ui/modal/ModalWrapper.vue'
 import SearchCard from '@/components/ui/SearchCard.vue'
 import { get_project, get_version } from '@/helpers/cache.js'
 import { get_categories } from '@/helpers/tags.js'
-import { install as installVersion } from '@/store/install.js'
+import { injectContentInstall } from '@/providers/content-install'
 
 const { handleError } = injectNotificationManager()
+const { install: installVersion } = injectContentInstall()
 
 const confirmModal = ref(null)
 const project = ref(null)

apps/app-frontend/src/components/ui/UpdateAvailableToast.vue

@@ -1,84 +0,0 @@
-<script setup lang="ts">
-import { XIcon } from '@modrinth/assets'
-import { ButtonStyled, commonMessages, defineMessages, useVIntl } from '@modrinth/ui'
-import { getVersion } from '@tauri-apps/api/app'
-import { onMounted, onUnmounted, ref } from 'vue'
-
-const { formatMessage } = useVIntl()
-
-const dismissed = ref(false)
-const availableUpdate = ref<{ version: string } | null>(null)
-
-let checkInterval: ReturnType<typeof setInterval> | null = null
-
-async function checkForUpdate() {
-	try {
-		const [response, currentVersion] = await Promise.all([
-			fetch('https://launcher-files.modrinth.com/updates.json'),
-			getVersion(),
-		])
-		const updates = await response.json()
-		const latestVersion = updates?.version
-
-		if (latestVersion && latestVersion !== currentVersion) {
-			if (latestVersion !== availableUpdate.value?.version) {
-				availableUpdate.value = { version: latestVersion }
-				dismissed.value = false
-			}
-		}
-	} catch (e) {
-		console.error('Failed to check for updates:', e)
-	}
-}
-
-function dismiss() {
-	dismissed.value = true
-}
-
-onMounted(() => {
-	checkForUpdate()
-	checkInterval = setInterval(checkForUpdate, 5 * 60 * 1000)
-})
-
-onUnmounted(() => {
-	if (checkInterval) {
-		clearInterval(checkInterval)
-	}
-})
-
-const messages = defineMessages({
-	title: {
-		id: 'app.update-toast.title',
-		defaultMessage: 'Update available',
-	},
-	body: {
-		id: 'app.update-toast.body.linux',
-		defaultMessage:
-			'Modrinth App v{version} is available. Use your package manager to update for the latest features and fixes!',
-	},
-	download: {
-		id: 'app.update-toast.download-page',
-		defaultMessage: 'Download',
-	},
-})
-</script>
-<template>
-	<div
-		v-if="availableUpdate && !dismissed"
-		class="grid grid-cols-[min-content] fixed card-shadow rounded-2xl top-[--top-bar-height] mt-6 right-6 p-4 z-10 bg-bg-raised border-surface-5 border-solid border-[2px]"
-	>
-		<div class="flex min-w-[25rem] gap-4">
-			<h2 class="whitespace-nowrap text-base text-contrast font-semibold m-0 grow">
-				{{ formatMessage(messages.title) }}
-			</h2>
-			<ButtonStyled size="small" circular>
-				<button v-tooltip="formatMessage(commonMessages.closeButton)" @click="dismiss">
-					<XIcon />
-				</button>
-			</ButtonStyled>
-		</div>
-		<p class="text-sm mt-2 mb-0">
-			{{ formatMessage(messages.body, { version: availableUpdate.version }) }}
-		</p>
-	</div>
-</template>

apps/app-frontend/src/components/ui/UpdateToast.vue

@@ -1,130 +0,0 @@
-<script setup lang="ts">
-import { DownloadIcon, ExternalIcon, RefreshCwIcon, SpinnerIcon, XIcon } from '@modrinth/assets'
-import { ButtonStyled, commonMessages, defineMessages, ProgressBar, useVIntl } from '@modrinth/ui'
-import { formatBytes } from '@modrinth/utils'
-import { ref } from 'vue'
-
-import { injectAppUpdateDownloadProgress } from '@/providers/download-progress.ts'
-
-const { formatMessage } = useVIntl()
-
-const emit = defineEmits<{
-	(e: 'close' | 'restart' | 'download'): void
-}>()
-
-defineProps<{
-	version: string
-	size: number | null
-	metered: boolean
-}>()
-
-const downloading = ref(false)
-const { progress } = injectAppUpdateDownloadProgress()
-
-function download() {
-	emit('download')
-	downloading.value = true
-}
-
-const messages = defineMessages({
-	title: {
-		id: 'app.update-toast.title',
-		defaultMessage: 'Update available',
-	},
-	body: {
-		id: 'app.update-toast.body',
-		defaultMessage:
-			'Modrinth App v{version} is ready to install! Reload to update now, or automatically when you close Modrinth App.',
-	},
-	reload: {
-		id: 'app.update-toast.reload',
-		defaultMessage: 'Reload',
-	},
-	download: {
-		id: 'app.update-toast.download',
-		defaultMessage: 'Download ({size})',
-	},
-	downloading: {
-		id: 'app.update-toast.downloading',
-		defaultMessage: 'Downloading...',
-	},
-	changelog: {
-		id: 'app.update-toast.changelog',
-		defaultMessage: 'Changelog',
-	},
-	meteredBody: {
-		id: 'app.update-toast.body.metered',
-		defaultMessage: `Modrinth App v{version} is available now! Since you're on a metered network, we didn't automatically download it.`,
-	},
-	downloadCompleteTitle: {
-		id: 'app.update-toast.title.download-complete',
-		defaultMessage: 'Download complete',
-	},
-	downloadedBody: {
-		id: 'app.update-toast.body.download-complete',
-		defaultMessage: `Modrinth App v{version} has finished downloading. Reload to update now, or automatically when you close Modrinth App.`,
-	},
-})
-</script>
-<template>
-	<div
-		class="grid grid-cols-[min-content] fixed card-shadow rounded-2xl top-[--top-bar-height] mt-6 right-6 p-4 z-10 bg-bg-raised border-surface-5 border-solid border-[2px]"
-		:class="{
-			'download-complete': progress === 1,
-		}"
-	>
-		<div class="flex min-w-[25rem] gap-4">
-			<h2 class="whitespace-nowrap text-base text-contrast font-semibold m-0 grow">
-				{{
-					formatMessage(metered && progress === 1 ? messages.downloadCompleteTitle : messages.title)
-				}}
-			</h2>
-			<ButtonStyled size="small" circular>
-				<button v-tooltip="formatMessage(commonMessages.closeButton)" @click="emit('close')">
-					<XIcon />
-				</button>
-			</ButtonStyled>
-		</div>
-		<p class="text-sm mt-2 mb-0">
-			{{
-				formatMessage(
-					metered
-						? progress === 1
-							? messages.downloadedBody
-							: messages.meteredBody
-						: messages.body,
-					{ version },
-				)
-			}}
-		</p>
-		<p
-			v-if="metered && progress < 1"
-			class="text-sm text-secondary mt-2 mb-0 flex items-center gap-1"
-		>
-			<template v-if="progress > 0">
-				<ProgressBar :progress="progress" class="max-w-[unset]" />
-			</template>
-		</p>
-		<div class="flex gap-2 mt-4">
-			<ButtonStyled color="brand">
-				<button v-if="metered && progress < 1" :disabled="downloading" @click="download">
-					<SpinnerIcon v-if="downloading" class="animate-spin" />
-					<DownloadIcon v-else />
-					{{
-						formatMessage(downloading ? messages.downloading : messages.download, {
-							size: formatBytes(size ?? 0),
-						})
-					}}
-				</button>
-				<button v-else @click="emit('restart')">
-					<RefreshCwIcon /> {{ formatMessage(messages.reload) }}
-				</button>
-			</ButtonStyled>
-			<ButtonStyled>
-				<a href="https://modrinth.com/news/changelog?filter=app">
-					{{ formatMessage(messages.changelog) }} <ExternalIcon />
-				</a>
-			</ButtonStyled>
-		</div>
-	</div>
-</template>

apps/app-frontend/src/components/ui/install_flow/AddServerToInstanceModal.vue

@@ -0,0 +1,125 @@
+<script setup>
+import { CheckIcon, PlusIcon, SearchIcon } from '@modrinth/assets'
+import {
+	Admonition,
+	Avatar,
+	ButtonStyled,
+	injectNotificationManager,
+	StyledInput,
+} from '@modrinth/ui'
+import { convertFileSrc } from '@tauri-apps/api/core'
+import { computed, ref } from 'vue'
+
+import ModalWrapper from '@/components/ui/modal/ModalWrapper.vue'
+import { trackEvent } from '@/helpers/analytics'
+import { list } from '@/helpers/profile'
+import { add_server_to_profile, get_profile_worlds } from '@/helpers/worlds.ts'
+
+const { handleError } = injectNotificationManager()
+
+const modal = ref()
+const searchFilter = ref('')
+const profiles = ref([])
+
+const serverName = ref('')
+const serverAddress = ref('')
+
+const shownProfiles = computed(() =>
+	profiles.value.filter((profile) => {
+		return profile.name.toLowerCase().includes(searchFilter.value.toLowerCase())
+	}),
+)
+
+defineExpose({
+	show: async (name, address) => {
+		serverName.value = name
+		serverAddress.value = address
+		searchFilter.value = ''
+
+		const profilesVal = await list().catch(handleError)
+		await Promise.allSettled(
+			profilesVal.map(async (profile) => {
+				profile.adding = false
+				profile.added = false
+
+				try {
+					const worlds = await get_profile_worlds(profile.path)
+					profile.added = worlds.some(
+						(w) => w.type === 'server' && w.address === serverAddress.value,
+					)
+				} catch {
+					// Ignore - will show as not added
+				}
+			}),
+		)
+
+		profiles.value = profilesVal
+		modal.value.show()
+
+		trackEvent('AddServerToInstanceStart', { source: 'AddServerToInstanceModal' })
+	},
+})
+
+async function addServer(profile) {
+	profile.adding = true
+	try {
+		await add_server_to_profile(profile.path, serverName.value, serverAddress.value, 'prompt')
+		profile.added = true
+
+		trackEvent('AddServerToInstance', {
+			server_name: serverName.value,
+			instance_name: profile.name,
+			source: 'AddServerToInstanceModal',
+		})
+	} catch (err) {
+		handleError(err)
+	}
+	profile.adding = false
+}
+</script>
+
+<template>
+	<ModalWrapper ref="modal" header="Add server to instance">
+		<div class="flex flex-col gap-4 min-w-[350px]">
+			<Admonition type="warning" body="This server may not be compatible with all instances." />
+			<StyledInput
+				v-model="searchFilter"
+				:icon="SearchIcon"
+				type="search"
+				placeholder="Search for an instance"
+				autocomplete="off"
+			/>
+			<div class="max-h-[21rem] overflow-y-auto">
+				<div
+					v-for="profile in shownProfiles"
+					:key="profile.path"
+					class="flex w-full items-center justify-between gap-2 bg-bg-raised text-icon shadow-none"
+				>
+					<router-link
+						class="btn btn-transparent p-2 text-left"
+						:to="`/instance/${encodeURIComponent(profile.path)}`"
+						@click="modal.hide()"
+					>
+						<Avatar
+							:src="profile.icon_path ? convertFileSrc(profile.icon_path) : null"
+							class="mr-2 [--size:2rem]"
+						/>
+						{{ profile.name }}
+					</router-link>
+					<ButtonStyled>
+						<button :disabled="profile.added || profile.adding" @click="addServer(profile)">
+							<PlusIcon v-if="!profile.added && !profile.adding" />
+							<CheckIcon v-else-if="profile.added" />
+							{{ profile.adding ? 'Adding...' : profile.added ? 'Added' : 'Add' }}
+						</button>
+					</ButtonStyled>
+				</div>
+			</div>
+			<div class="input-group push-right">
+				<ButtonStyled>
+					<button @click="modal.hide()">Cancel</button>
+				</ButtonStyled>
+			</div>
+		</div>
+	</ModalWrapper>
+</template>

apps/app-frontend/src/components/ui/install_flow/ModInstallModal.vue

@@ -16,6 +16,7 @@ import { useRouter } from 'vue-router'
 
 import ModalWrapper from '@/components/ui/modal/ModalWrapper.vue'
 import { trackEvent } from '@/helpers/analytics'
+import { get_project_v3_many } from '@/helpers/cache.js'
 import {
 	add_project_from_version as installMod,
 	check_installed,
@@ -81,6 +82,22 @@ defineExpose({
 				handleError,
 			)
 		}
+
+		const linkedProjectIds = profilesVal
+			.filter((p) => p.linked_data?.project_id)
+			.map((p) => p.linked_data.project_id)
+		if (linkedProjectIds.length > 0) {
+			const linkedProjects = await get_project_v3_many(linkedProjectIds, 'must_revalidate').catch(
+				() => [],
+			)
+			const serverProjectIds = new Set(
+				linkedProjects.filter((p) => p?.minecraft_server != null).map((p) => p.id),
+			)
+			for (const profile of profilesVal) {
+				profile.isServerInstance = serverProjectIds.has(profile.linked_data?.project_id)
+			}
+		}
+
 		profiles.value = profilesVal
 
 		installModal.value.show()

apps/app-frontend/src/components/ui/instance_settings/GeneralSettings.vue

@@ -15,7 +15,7 @@ import { open } from '@tauri-apps/plugin-dialog'
 import { computed, type Ref, ref, watch } from 'vue'
 import { useRouter } from 'vue-router'
 
-import ConfirmModalWrapper from '@/components/ui/modal/ConfirmModalWrapper.vue'
+import ConfirmDeleteInstanceModal from '@/components/ui/modal/ConfirmDeleteInstanceModal.vue'
 import { trackEvent } from '@/helpers/analytics'
 import { duplicate, edit, edit_icon, list, remove } from '@/helpers/profile'
 
@@ -100,7 +100,8 @@ const addCategory = () => {
 watch(
 	[title, groups, groups],
 	async () => {
-		await edit(props.instance.path, editProfileObject.value)
+		if (removing.value) return
+		await edit(props.instance.path, editProfileObject.value).catch(handleError)
 	},
 	{ deep: true },
 )
@@ -108,8 +109,6 @@ watch(
 const removing = ref(false)
 async function removeProfile() {
 	removing.value = true
-	await remove(props.instance.path).catch(handleError)
-	removing.value = false
 
 	trackEvent('InstanceRemove', {
 		loader: props.instance.loader,
@@ -117,6 +116,7 @@ async function removeProfile() {
 	})
 
 	await router.push({ path: '/' })
+	await remove(props.instance.path).catch(handleError)
 }
 
 const messages = defineMessages({
@@ -194,15 +194,7 @@ const messages = defineMessages({
 </script>
 
 <template>
-	<ConfirmModalWrapper
-		ref="deleteConfirmModal"
-		title="Are you sure you want to delete this instance?"
-		description="If you proceed, all data for your instance will be permanently erased, including your worlds. You will not be able to recover it."
-		:has-to-type="false"
-		proceed-label="Delete"
-		:show-ad-on-close="false"
-		@proceed="removeProfile"
-	/>
+	<ConfirmDeleteInstanceModal ref="deleteConfirmModal" @delete="removeProfile" />
 	<div class="block">
 		<div class="float-end ml-4 relative group">
 			<OverflowMenu

apps/app-frontend/src/components/ui/instance_settings/InstallationSettings.vue

@@ -1,59 +1,43 @@
 <script setup lang="ts">
+import type { Labrinth } from '@modrinth/api-client'
 import {
-	DownloadIcon,
-	getLoaderIcon,
-	HammerIcon,
-	IssuesIcon,
-	SpinnerIcon,
-	TransferIcon,
-	UndoIcon,
-	UnlinkIcon,
-	UnplugIcon,
-	WrenchIcon,
-} from '@modrinth/assets'
-import {
-	Avatar,
-	ButtonStyled,
-	Checkbox,
-	Chips,
-	Combobox,
+	commonMessages,
 	defineMessages,
-	formatLoader,
+	formatLoaderLabel,
 	injectNotificationManager,
+	InstallationSettingsLayout,
+	provideAppBackup,
+	provideInstallationSettings,
 	useVIntl,
 } from '@modrinth/ui'
-import type { GameVersionTag, PlatformTag, Project, Version } from '@modrinth/utils'
-import dayjs from 'dayjs'
-import { computed, type ComputedRef, type Ref, ref, shallowRef, watch } from 'vue'
+import type { GameVersionTag, PlatformTag } from '@modrinth/utils'
+import { useQuery, useQueryClient } from '@tanstack/vue-query'
+import { computed, ref, shallowRef } from 'vue'
 
-import ConfirmModalWrapper from '@/components/ui/modal/ConfirmModalWrapper.vue'
-import ModpackVersionModal from '@/components/ui/ModpackVersionModal.vue'
 import { trackEvent } from '@/helpers/analytics'
-import { get_project, get_version_many } from '@/helpers/cache'
+import { get_project_versions, get_version } from '@/helpers/cache'
 import { get_loader_versions } from '@/helpers/metadata'
-import { edit, install, update_repair_modrinth } from '@/helpers/profile'
+import {
+	duplicate,
+	edit,
+	get_linked_modpack_info,
+	install,
+	list,
+	update_managed_modrinth_version,
+	update_repair_modrinth,
+} from '@/helpers/profile'
 import { get_game_versions, get_loaders } from '@/helpers/tags'
 
-import type {
-	InstanceSettingsTabProps,
-	Manifest,
-	ManifestLoaderVersion,
-} from '../../../helpers/types'
+import type { InstanceSettingsTabProps, Manifest } from '../../../helpers/types'
 
 const { handleError } = injectNotificationManager()
 const { formatMessage } = useVIntl()
-
-const repairConfirmModal = ref()
-const modpackVersionModal = ref()
-const modalConfirmUnpair = ref()
-const modalConfirmReinstall = ref()
+const queryClient = useQueryClient()
 
 const props = defineProps<InstanceSettingsTabProps>()
-
-const loader = ref(props.instance.loader)
-const gameVersion = ref(props.instance.game_version)
-
-const showSnapshots = ref(false)
+const emit = defineEmits<{
+	unlinked: []
+}>()
 
 const [
 	fabric_versions,
@@ -90,730 +74,211 @@ const [
 		.catch(handleError),
 ])
 
-const modpackProject: Ref<Project | null> = ref(null)
-const modpackVersion: Ref<Version | null> = ref(null)
-const modpackVersions: Ref<Version[] | null> = ref(null)
-const fetching = ref(true)
-
-if (props.instance.linked_data && props.instance.linked_data.project_id && !props.offline) {
-	get_project(props.instance.linked_data.project_id, 'must_revalidate')
-		.then((project) => {
-			modpackProject.value = project
-
-			if (project && project.versions) {
-				get_version_many(project.versions, 'must_revalidate')
-					.then((versions: Version[]) => {
-						modpackVersions.value = versions.sort((a, b) =>
-							dayjs(b.date_published).diff(dayjs(a.date_published)),
-						)
-						modpackVersion.value =
-							versions.find(
-								(version: Version) => version.id === props.instance.linked_data?.version_id,
-							) ?? null
-					})
-					.catch(handleError)
-					.finally(() => {
-						fetching.value = false
-					})
-			}
-		})
-		.catch((err) => {
-			handleError(err)
-			fetching.value = false
-		})
-} else {
-	fetching.value = false
-}
-
-const currentLoaderIcon = computed(() => getLoaderIcon(props.instance.loader))
-
-const gameVersionsForLoader = computed(() => {
-	return all_game_versions?.value.filter((item) => {
-		if (loader.value === 'fabric') {
-			return !!fabric_versions?.value.gameVersions.some((x) => item.version === x.id)
-		} else if (loader.value === 'forge') {
-			return !!forge_versions?.value.gameVersions.some((x) => item.version === x.id)
-		} else if (loader.value === 'quilt') {
-			return !!quilt_versions?.value.gameVersions.some((x) => item.version === x.id)
-		} else if (loader.value === 'neoforge') {
-			return !!neoforge_versions?.value.gameVersions.some((x) => item.version === x.id)
-		}
-
-		return []
-	})
+const { data: modpackInfo } = useQuery({
+	queryKey: computed(() => ['linkedModpackInfo', props.instance.path]),
+	queryFn: () => get_linked_modpack_info(props.instance.path, 'must_revalidate'),
+	enabled: computed(() => !!props.instance.linked_data?.project_id && !props.offline),
 })
 
-const hasSnapshots = computed(() =>
-	gameVersionsForLoader.value?.some((x) => x.version_type !== 'release'),
-)
-
-const selectableGameVersionNumbers = computed(() => {
-	return gameVersionsForLoader.value
-		?.filter((x) => x.version_type === 'release' || showSnapshots.value)
-		.map((x) => x.version)
-})
-
-const gameVersionOptions = computed(() =>
-	(selectableGameVersionNumbers.value ?? []).map((v) => ({ value: v, label: v })),
-)
-
-const loaderVersionOptions = computed(() =>
-	(selectableLoaderVersions.value ?? []).map((opt, index) => ({ value: index, label: opt.id })),
-)
-
-const loaderVersionLabel = computed(() => {
-	const idx = loaderVersionIndex.value
-	return idx >= 0 && selectableLoaderVersions.value
-		? selectableLoaderVersions.value[idx]?.id
-		: 'Select version'
-})
-
-const selectableLoaderVersions: ComputedRef<ManifestLoaderVersion[] | undefined> = computed(() => {
-	if (gameVersion.value) {
-		if (loader.value === 'fabric') {
-			return fabric_versions?.value.gameVersions[0].loaders
-		} else if (loader.value === 'forge') {
-			return forge_versions?.value?.gameVersions?.find((item) => item.id === gameVersion.value)
-				?.loaders
-		} else if (loader.value === 'quilt') {
-			return quilt_versions?.value.gameVersions[0].loaders
-		} else if (loader.value === 'neoforge') {
-			return neoforge_versions?.value?.gameVersions?.find((item) => item.id === gameVersion.value)
-				?.loaders
-		}
-	}
-	return []
-})
-const loaderVersionIndex: Ref<number> = ref(-1)
-
-resetLoaderVersionIndex()
-
-function resetLoaderVersionIndex() {
-	loaderVersionIndex.value =
-		selectableLoaderVersions.value?.findIndex((x) => x.id === props.instance.loader_version) ?? -1
-}
-
-const isValid = computed(() => {
-	return (
-		selectableGameVersionNumbers.value?.includes(gameVersion.value) &&
-		((loaderVersionIndex.value !== undefined && loaderVersionIndex.value >= 0) ||
-			loader.value === 'vanilla')
-	)
-})
-
-const isChanged = computed(() => {
-	return (
-		loader.value !== props.instance.loader ||
-		gameVersion.value !== props.instance.game_version ||
-		(loader.value !== 'vanilla' &&
-			loaderVersionIndex.value !== undefined &&
-			loaderVersionIndex.value >= 0 &&
-			selectableLoaderVersions.value?.[loaderVersionIndex.value].id !==
-				props.instance.loader_version)
-	)
-})
-
-watch(loader, () => {
-	loaderVersionIndex.value = 0
-})
-
-const editing = ref(false)
-
-async function saveGvLoaderEdits() {
-	editing.value = true
-
-	const editProfile: { loader?: string; game_version?: string; loader_version?: string } = {}
-	editProfile.loader = loader.value
-	editProfile.game_version = gameVersion.value
-
-	if (loader.value !== 'vanilla' && loaderVersionIndex.value !== undefined) {
-		editProfile.loader_version = selectableLoaderVersions.value?.[loaderVersionIndex.value].id
-	} else {
-		loaderVersionIndex.value = -1
-	}
-	console.log('Editing:')
-	console.log(loader.value)
-
-	await edit(props.instance.path, editProfile).catch(handleError)
-	await repairProfile(false)
-
-	editing.value = false
-}
-
-const installing = computed(() => props.instance.install_stage !== 'installed')
 const repairing = ref(false)
 const reinstalling = ref(false)
-const changingVersion = ref(false)
-
-async function repairProfile(force: boolean) {
-	if (force) {
-		repairing.value = true
-	}
-	await install(props.instance.path, force).catch(handleError)
-	if (force) {
-		repairing.value = false
-	}
-
-	trackEvent('InstanceRepair', {
-		loader: props.instance.loader,
-		game_version: props.instance.game_version,
-	})
-}
-
-async function unpairProfile() {
-	await edit(props.instance.path, {
-		linked_data: null,
-	})
-	modpackProject.value = null
-	modpackVersion.value = null
-	modpackVersions.value = null
-	modalConfirmUnpair.value.hide()
-}
-
-async function repairModpack() {
-	reinstalling.value = true
-	await update_repair_modrinth(props.instance.path).catch(handleError)
-	reinstalling.value = false
-
-	trackEvent('InstanceRepair', {
-		loader: props.instance.loader,
-		game_version: props.instance.game_version,
-	})
-}
 
 const messages = defineMessages({
-	cannotWhileInstalling: {
-		id: 'instance.settings.tabs.installation.tooltip.cannot-while-installing',
-		defaultMessage: 'Cannot {action} while installing',
-	},
-	cannotWhileOffline: {
-		id: 'instance.settings.tabs.installation.tooltip.cannot-while-offline',
-		defaultMessage: 'Cannot {action} while offline',
-	},
-	cannotWhileRepairing: {
-		id: 'instance.settings.tabs.installation.tooltip.cannot-while-repairing',
-		defaultMessage: 'Cannot {action} while repairing',
-	},
-	currentlyInstalled: {
-		id: 'instance.settings.tabs.installation.currently-installed',
-		defaultMessage: 'Currently installed',
-	},
-	platform: {
-		id: 'instance.settings.tabs.installation.platform',
-		defaultMessage: 'Platform',
-	},
-	gameVersion: {
-		id: 'instance.settings.tabs.installation.game-version',
-		defaultMessage: 'Game version',
-	},
 	loaderVersion: {
 		id: 'instance.settings.tabs.installation.loader-version',
 		defaultMessage: '{loader} version',
 	},
-	showAllVersions: {
-		id: 'instance.settings.tabs.installation.show-all-versions',
-		defaultMessage: 'Show all versions',
+})
+
+function getManifest(loader: string) {
+	const map: Record<string, typeof fabric_versions> = {
+		fabric: fabric_versions,
+		forge: forge_versions,
+		quilt: quilt_versions,
+		neoforge: neoforge_versions,
+	}
+	return map[loader]
+}
+
+provideAppBackup({
+	async createBackup() {
+		const allProfiles = await list()
+		const prefix = `${props.instance.name} - Backup #`
+		const existingNums = allProfiles
+			.filter((p) => p.name.startsWith(prefix))
+			.map((p) => parseInt(p.name.slice(prefix.length), 10))
+			.filter((n) => !isNaN(n))
+		const nextNum = existingNums.length > 0 ? Math.max(...existingNums) + 1 : 1
+		const newPath = await duplicate(props.instance.path)
+		await edit(newPath, { name: `${prefix}${nextNum}` })
 	},
-	install: {
-		id: 'instance.settings.tabs.installation.install',
-		defaultMessage: 'Install',
+})
+
+provideInstallationSettings({
+	loading: ref(false),
+	installationInfo: computed(() => {
+		const rows = [
+			{
+				label: formatMessage(commonMessages.platformLabel),
+				value: formatLoaderLabel(props.instance.loader),
+			},
+			{
+				label: formatMessage(commonMessages.gameVersionLabel),
+				value: props.instance.game_version,
+			},
+		]
+		if (props.instance.loader !== 'vanilla' && props.instance.loader_version) {
+			rows.push({
+				label: formatMessage(messages.loaderVersion, {
+					loader: formatLoaderLabel(props.instance.loader),
+				}),
+				value: props.instance.loader_version,
+			})
+		}
+		return rows
+	}),
+	isLinked: computed(() => !!props.instance.linked_data?.locked),
+	isBusy: computed(
+		() =>
+			props.instance.install_stage !== 'installed' ||
+			repairing.value ||
+			reinstalling.value ||
+			!!props.offline,
+	),
+	modpack: computed(() => {
+		if (!modpackInfo.value) return null
+		return {
+			iconUrl: modpackInfo.value.project.icon_url,
+			title: modpackInfo.value.project.title,
+			link: `/project/${modpackInfo.value.project.slug ?? modpackInfo.value.project.id}`,
+			versionNumber: modpackInfo.value.version?.version_number,
+		}
+	}),
+	currentPlatform: computed(() => props.instance.loader),
+	currentGameVersion: computed(() => props.instance.game_version),
+	currentLoaderVersion: computed(() => props.instance.loader_version ?? ''),
+	availablePlatforms: loaders?.value?.map((x) => x.name) ?? [],
+
+	resolveGameVersions(loader, showSnapshots) {
+		const versions = all_game_versions?.value ?? []
+		const filtered = versions.filter((item) => {
+			if (loader === 'vanilla') return true
+			const manifest = getManifest(loader)
+			return !!manifest?.value?.gameVersions?.some((x) => item.version === x.id)
+		})
+		return (showSnapshots ? filtered : filtered.filter((x) => x.version_type === 'release')).map(
+			(x) => ({ value: x.version, label: x.version }),
+		)
 	},
-	resetSelections: {
-		id: 'instance.settings.tabs.installation.reset-selections',
-		defaultMessage: 'Reset to current',
+
+	resolveLoaderVersions(loader, gameVersion) {
+		if (loader === 'vanilla' || !gameVersion) return []
+		const manifest = getManifest(loader)
+		if (!manifest?.value) return []
+		if (loader === 'fabric' || loader === 'quilt') {
+			return manifest.value.gameVersions[0]?.loaders ?? []
+		}
+		return manifest.value.gameVersions?.find((item) => item.id === gameVersion)?.loaders ?? []
 	},
-	unknownVersion: {
-		id: 'instance.settings.tabs.installation.unknown-version',
-		defaultMessage: '(unknown version)',
+
+	resolveHasSnapshots(loader) {
+		const versions = all_game_versions?.value ?? []
+		if (loader === 'vanilla') return versions.some((x) => x.version_type !== 'release')
+		const manifest = getManifest(loader)
+		const supported = versions.filter(
+			(item) => !!manifest?.value?.gameVersions?.some((x) => item.version === x.id),
+		)
+		return supported.some((x) => x.version_type !== 'release')
 	},
-	repairConfirmTitle: {
-		id: 'instance.settings.tabs.installation.repair.confirm.title',
-		defaultMessage: 'Repair instance?',
+
+	async save(platform, gameVersion, loaderVersionId) {
+		const editProfile: Record<string, string | undefined> = {
+			loader: platform,
+			game_version: gameVersion,
+		}
+		if (platform !== 'vanilla' && loaderVersionId) {
+			editProfile.loader_version = loaderVersionId
+		}
+		await edit(props.instance.path, editProfile).catch(handleError)
 	},
-	repairConfirmDescription: {
-		id: 'instance.settings.tabs.installation.repair.confirm.description',
-		defaultMessage:
-			'Repairing reinstalls Minecraft dependencies and checks for corruption. This may resolve issues if your game is not launching due to launcher-related errors, but will not resolve issues or crashes related to installed mods.',
+
+	afterSave: async () => {
+		await install(props.instance.path, false).catch(handleError)
+		trackEvent('InstanceRepair', {
+			loader: props.instance.loader,
+			game_version: props.instance.game_version,
+		})
 	},
-	repairButton: {
-		id: 'instance.settings.tabs.installation.repair.button',
-		defaultMessage: 'Repair',
+
+	async repair() {
+		repairing.value = true
+		await install(props.instance.path, true).catch(handleError)
+		repairing.value = false
+		trackEvent('InstanceRepair', {
+			loader: props.instance.loader,
+			game_version: props.instance.game_version,
+		})
 	},
-	repairingButton: {
-		id: 'instance.settings.tabs.installation.repair.button.repairing',
-		defaultMessage: 'Repairing',
+
+	async reinstallModpack() {
+		reinstalling.value = true
+		await update_repair_modrinth(props.instance.path).catch(handleError)
+		reinstalling.value = false
+		trackEvent('InstanceRepair', {
+			loader: props.instance.loader,
+			game_version: props.instance.game_version,
+		})
 	},
-	repairInProgress: {
-		id: 'instance.settings.tabs.installation.repair.in-progress',
-		defaultMessage: 'Repair in progress',
+
+	async unlinkModpack() {
+		await edit(props.instance.path, {
+			linked_data: null as unknown as undefined,
+		})
+		await queryClient.invalidateQueries({
+			queryKey: ['linkedModpackInfo', props.instance.path],
+		})
+		emit('unlinked')
 	},
-	repairAction: {
-		id: 'instance.settings.tabs.installation.tooltip.action.repair',
-		defaultMessage: 'repair',
+
+	getCachedModpackVersions: () => null,
+	async fetchModpackVersions() {
+		const versions = await get_project_versions(props.instance.linked_data!.project_id!).catch(
+			handleError,
+		)
+		return (versions ?? []) as Labrinth.Versions.v2.Version[]
 	},
-	changeVersionCannotWhileFetching: {
-		id: 'instance.settings.tabs.installation.change-version.cannot-while-fetching',
-		defaultMessage: 'Fetching modpack versions',
+
+	async getVersionChangelog(versionId: string) {
+		return (await get_version(versionId, 'must_revalidate').catch(
+			() => null,
+		)) as Labrinth.Versions.v2.Version | null
 	},
-	changeVersionButton: {
-		id: 'instance.settings.tabs.installation.change-version.button',
-		defaultMessage: 'Change version',
-	},
-	changeVersionAction: {
-		id: 'instance.settings.tabs.installation.tooltip.action.change-version',
-		defaultMessage: 'change version',
-	},
-	installingButton: {
-		id: 'instance.settings.tabs.installation.change-version.button.installing',
-		defaultMessage: 'Installing',
-	},
-	installInProgress: {
-		id: 'instance.settings.tabs.installation.install.in-progress',
-		defaultMessage: 'Installation in progress',
-	},
-	installButton: {
-		id: 'instance.settings.tabs.installation.change-version.button.install',
-		defaultMessage: 'Install',
-	},
-	alreadyInstalledVanilla: {
-		id: 'instance.settings.tabs.installation.change-version.already-installed.vanilla',
-		defaultMessage: 'Vanilla {game_version} already installed',
-	},
-	alreadyInstalledModded: {
-		id: 'instance.settings.tabs.installation.change-version.already-installed.modded',
-		defaultMessage: '{platform} {version} for Minecraft {game_version} already installed',
-	},
-	installAction: {
-		id: 'instance.settings.tabs.installation.tooltip.action.install',
-		defaultMessage: 'install',
-	},
-	installingNewVersion: {
-		id: 'instance.settings.tabs.installation.change-version.in-progress',
-		defaultMessage: 'Installing new version',
-	},
-	minecraftVersion: {
-		id: 'instance.settings.tabs.installation.minecraft-version',
-		defaultMessage: 'Minecraft {version}',
-	},
-	noLoaderVersions: {
-		id: 'instance.settings.tabs.installation.no-loader-versions',
-		defaultMessage: '{loader} is not available for Minecraft {version}. Try another mod loader.',
-	},
-	noConnection: {
-		id: 'instance.settings.tabs.installation.no-connection',
-		defaultMessage: 'Cannot fetch linked modpack details. Please check your internet connection.',
-	},
-	noModpackFound: {
-		id: 'instance.settings.tabs.installation.no-modpack-found',
-		defaultMessage:
-			'This instance is linked to a modpack, but the modpack could not be found on Modrinth.',
-	},
-	debugInformation: {
-		id: 'instance.settings.tabs.installation.debug-information',
-		defaultMessage: 'Debug information:',
-	},
-	fetchingModpackDetails: {
-		id: 'instance.settings.tabs.installation.fetching-modpack-details',
-		defaultMessage: 'Fetching modpack details',
-	},
-	unlinkInstanceTitle: {
-		id: 'instance.settings.tabs.installation.unlink.title',
-		defaultMessage: 'Unlink from modpack',
-	},
-	unlinkInstanceDescription: {
-		id: 'instance.settings.tabs.installation.unlink.description',
-		defaultMessage: `This instance is linked to a modpack, which means mods can't be updated and you can't change the mod loader or Minecraft version. Unlinking will permanently disconnect this instance from the modpack.`,
-	},
-	unlinkInstanceButton: {
-		id: 'instance.settings.tabs.installation.unlink.button',
-		defaultMessage: 'Unlink instance',
-	},
-	unlinkInstanceConfirmTitle: {
-		id: 'instance.settings.tabs.installation.unlink.confirm.title',
-		defaultMessage: 'Are you sure you want to unlink this instance?',
-	},
-	unlinkInstanceConfirmDescription: {
-		id: 'instance.settings.tabs.installation.unlink.confirm.description',
-		defaultMessage:
-			'If you proceed, you will not be able to re-link it without creating an entirely new instance. You will no longer receive modpack updates and it will become a normal.',
-	},
-	reinstallModpackConfirmTitle: {
-		id: 'instance.settings.tabs.installation.reinstall.confirm.title',
-		defaultMessage: 'Are you sure you want to reinstall this instance?',
-	},
-	reinstallModpackConfirmDescription: {
-		id: 'instance.settings.tabs.installation.reinstall.confirm.description',
-		defaultMessage: `Reinstalling will reset all installed or modified content to what is provided by the modpack, removing any mods or content you have added on top of the original installation. This may fix unexpected behavior if changes have been made to the instance, but if your worlds now depend on additional installed content, it may break existing worlds.`,
-	},
-	reinstallModpackTitle: {
-		id: 'instance.settings.tabs.installation.reinstall.title',
-		defaultMessage: 'Reinstall modpack',
-	},
-	reinstallModpackDescription: {
-		id: 'instance.settings.tabs.installation.reinstall.description',
-		defaultMessage: `Resets the instance's content to its original state, removing any mods or content you have added on top of the original modpack.`,
-	},
-	reinstallModpackButton: {
-		id: 'instance.settings.tabs.installation.reinstall.button',
-		defaultMessage: 'Reinstall modpack',
-	},
-	reinstallingModpackButton: {
-		id: 'instance.settings.tabs.installation.reinstall.button.reinstalling',
-		defaultMessage: 'Reinstalling modpack',
-	},
-	reinstallAction: {
-		id: 'instance.settings.tabs.installation.tooltip.action.reinstall',
-		defaultMessage: 'reinstall',
+
+	async onModpackVersionConfirm(version) {
+		await update_managed_modrinth_version(props.instance.path, version.id)
+		await queryClient.invalidateQueries({
+			queryKey: ['linkedModpackInfo', props.instance.path],
+		})
 	},
+
+	updaterModalProps: computed(() => ({
+		isApp: true,
+		currentVersionId:
+			modpackInfo.value?.update_version_id ?? props.instance.linked_data?.version_id ?? '',
+		projectIconUrl: modpackInfo.value?.project?.icon_url,
+		projectName: modpackInfo.value?.project?.title ?? 'Modpack',
+		currentGameVersion: props.instance.game_version,
+		currentLoader: props.instance.loader,
+	})),
+
+	isServer: false,
+	isApp: true,
+	showModpackVersionActions: !props.isMinecraftServer,
+	repairing,
+	reinstalling,
 })
 </script>
 
 <template>
-	<ConfirmModalWrapper
-		ref="repairConfirmModal"
-		:title="formatMessage(messages.repairConfirmTitle)"
-		:description="formatMessage(messages.repairConfirmDescription)"
-		:proceed-icon="HammerIcon"
-		:proceed-label="formatMessage(messages.repairButton)"
-		:danger="false"
-		:show-ad-on-close="false"
-		@proceed="() => repairProfile(true)"
-	/>
-	<ModpackVersionModal
-		v-if="instance.linked_data && modpackVersions"
-		ref="modpackVersionModal"
-		:instance="instance"
-		:versions="modpackVersions"
-		@finish-install="
-			() => {
-				changingVersion = false
-				modpackVersion =
-					modpackVersions?.find(
-						(version: Version) => version.id === props.instance.linked_data?.version_id,
-					) ?? null
-			}
-		"
-	/>
-	<ConfirmModalWrapper
-		ref="modalConfirmUnpair"
-		:title="formatMessage(messages.unlinkInstanceConfirmTitle)"
-		:description="formatMessage(messages.unlinkInstanceConfirmDescription)"
-		:proceed-icon="UnlinkIcon"
-		:proceed-label="formatMessage(messages.unlinkInstanceButton)"
-		:show-ad-on-close="false"
-		@proceed="() => unpairProfile()"
-	/>
-	<ConfirmModalWrapper
-		ref="modalConfirmReinstall"
-		:title="formatMessage(messages.reinstallModpackConfirmTitle)"
-		:description="formatMessage(messages.reinstallModpackConfirmDescription)"
-		:proceed-icon="DownloadIcon"
-		:proceed-label="formatMessage(messages.reinstallModpackButton)"
-		:show-ad-on-close="false"
-		@proceed="() => repairModpack()"
-	/>
-	<div>
-		<h2 id="project-name" class="m-0 mb-1 text-lg font-extrabold text-contrast block">
-			{{ formatMessage(messages.currentlyInstalled) }}
-		</h2>
-		<div
-			v-if="!modpackProject && instance.linked_data && offline && !fetching"
-			class="text-secondary font-medium mb-2"
-		>
-			<UnplugIcon class="top-[3px] relative" /> {{ formatMessage(messages.noConnection) }}
-		</div>
-		<div v-else-if="!modpackProject && instance.linked_data && !fetching" class="mb-2">
-			<p class="text-brand-red font-medium mt-0">
-				<IssuesIcon class="top-[3px] relative" />
-				{{ formatMessage(messages.noModpackFound) }}
-			</p>
-			<p>{{ formatMessage(messages.debugInformation) }}</p>
-			<div class="bg-bg p-6 rounded-2xl mt-2 text-sm text-secondary">
-				{{ instance.linked_data }}
-			</div>
-		</div>
-		<div class="flex gap-4 items-center justify-between p-4 bg-bg rounded-2xl">
-			<div v-if="fetching" class="flex items-center gap-2 h-10">
-				<SpinnerIcon class="animate-spin" />
-				{{ formatMessage(messages.fetchingModpackDetails) }}
-			</div>
-			<template v-else>
-				<div class="flex gap-2 items-center">
-					<Avatar v-if="modpackProject" :src="modpackProject?.icon_url" size="40px" />
-					<div
-						v-else
-						class="w-10 h-10 flex items-center justify-center rounded-full bg-button-bg border-solid border-[1px] border-button-border p-2 [&_svg]:h-full [&_svg]:w-full"
-					>
-						<component :is="currentLoaderIcon" v-if="currentLoaderIcon" />
-						<WrenchIcon v-else />
-					</div>
-					<div class="flex flex-col gap-2 justify-center">
-						<span class="font-semibold leading-none">
-							{{
-								modpackProject
-									? modpackProject.title
-									: formatMessage(messages.minecraftVersion, {
-											version: instance.game_version,
-										})
-							}}
-						</span>
-						<span class="text-sm text-secondary leading-none">
-							{{
-								modpackProject
-									? modpackVersion
-										? modpackVersion?.version_number
-										: 'Unknown version'
-									: formatLoader(formatMessage, instance.loader)
-							}}
-							<template v-if="instance.loader !== 'vanilla' && !modpackProject">
-								{{ instance.loader_version || formatMessage(messages.unknownVersion) }}
-							</template>
-						</span>
-					</div>
-				</div>
-				<div class="flex gap-1">
-					<ButtonStyled color="orange" type="transparent" hover-color-fill="background">
-						<button
-							v-tooltip="
-								repairing
-									? formatMessage(messages.repairInProgress)
-									: installing || reinstalling
-										? formatMessage(messages.cannotWhileInstalling, {
-												action: formatMessage(messages.repairAction),
-											})
-										: offline
-											? formatMessage(messages.cannotWhileOffline, {
-													action: formatMessage(messages.repairAction),
-												})
-											: null
-							"
-							:disabled="installing || repairing || reinstalling || offline"
-							@click="repairConfirmModal.show()"
-						>
-							<SpinnerIcon v-if="repairing" class="animate-spin" />
-							<HammerIcon v-else />
-							{{
-								repairing
-									? formatMessage(messages.repairingButton)
-									: formatMessage(messages.repairButton)
-							}}
-						</button>
-					</ButtonStyled>
-					<ButtonStyled v-if="modpackProject" hover-color-fill="background">
-						<button
-							v-tooltip="
-								changingVersion
-									? formatMessage(messages.installingNewVersion)
-									: repairing
-										? formatMessage(messages.cannotWhileRepairing, {
-												action: formatMessage(messages.changeVersionAction),
-											})
-										: installing || reinstalling
-											? formatMessage(messages.cannotWhileInstalling, {
-													action: formatMessage(messages.changeVersionAction),
-												})
-											: fetching && !modpackVersions
-												? formatMessage(messages.changeVersionCannotWhileFetching)
-												: offline
-													? formatMessage(messages.cannotWhileOffline, {
-															action: formatMessage(messages.changeVersionAction),
-														})
-													: null
-							"
-							:disabled="
-								changingVersion ||
-								repairing ||
-								installing ||
-								reinstalling ||
-								offline ||
-								fetching ||
-								!modpackVersions
-							"
-							@click="
-								() => {
-									changingVersion = true
-									modpackVersionModal.show()
-								}
-							"
-						>
-							<SpinnerIcon v-if="changingVersion" class="animate-spin" />
-							<TransferIcon v-else />
-							{{
-								changingVersion
-									? formatMessage(messages.installingButton)
-									: formatMessage(messages.changeVersionButton)
-							}}
-						</button>
-					</ButtonStyled>
-				</div>
-			</template>
-		</div>
-		<template v-if="!instance.linked_data || !instance.linked_data.locked">
-			<h2 class="m-0 mt-4 text-lg font-extrabold text-contrast block">
-				{{ formatMessage(messages.platform) }}
-			</h2>
-			<Chips v-if="loaders" v-model="loader" :items="loaders.map((x) => x.name)" class="mt-2" />
-			<h2 class="m-0 mt-4 text-lg font-extrabold text-contrast block">
-				{{ formatMessage(messages.gameVersion) }}
-			</h2>
-			<div class="flex flex-wrap mt-2 gap-2">
-				<Combobox
-					v-if="selectableGameVersionNumbers !== undefined"
-					v-model="gameVersion"
-					:options="gameVersionOptions"
-					:display-value="gameVersion || formatMessage(messages.unknownVersion)"
-				/>
-				<Checkbox
-					v-if="hasSnapshots"
-					v-model="showSnapshots"
-					:label="formatMessage(messages.showAllVersions)"
-				/>
-			</div>
-			<template v-if="loader !== 'vanilla'">
-				<h2 class="m-0 mt-4 text-lg font-extrabold text-contrast block">
-					{{
-						formatMessage(messages.loaderVersion, {
-							loader: formatLoader(formatMessage, loader),
-						})
-					}}
-				</h2>
-				<Combobox
-					v-if="selectableLoaderVersions"
-					v-model="loaderVersionIndex"
-					:options="loaderVersionOptions"
-					:display-value="loaderVersionLabel"
-					name="Version selector"
-					class="mt-2"
-				/>
-				<div v-else class="mt-2 text-brand-red flex gap-2 items-center">
-					<IssuesIcon />
-					{{
-						formatMessage(messages.noLoaderVersions, {
-							loader: loader,
-							version: gameVersion,
-						})
-					}}
-				</div>
-			</template>
-			<div class="mt-4 flex flex-wrap gap-2">
-				<ButtonStyled color="brand">
-					<button
-						v-tooltip="
-							installing || reinstalling
-								? formatMessage(messages.installInProgress)
-								: !isChanged
-									? formatMessage(
-											loader === 'vanilla'
-												? messages.alreadyInstalledVanilla
-												: messages.alreadyInstalledModded,
-											{
-												platform: formatLoader(formatMessage, loader),
-												version: instance.loader_version,
-												game_version: gameVersion,
-											},
-										)
-									: repairing
-										? formatMessage(messages.cannotWhileRepairing, {
-												action: formatMessage(messages.installAction),
-											})
-										: offline
-											? formatMessage(messages.cannotWhileOffline, {
-													action: formatMessage(messages.installAction),
-												})
-											: null
-						"
-						:disabled="!isValid || !isChanged || editing || offline || repairing"
-						@click="saveGvLoaderEdits()"
-					>
-						<SpinnerIcon v-if="editing" class="animate-spin" />
-						<DownloadIcon v-else />
-						{{
-							editing
-								? formatMessage(messages.installingButton)
-								: formatMessage(messages.installButton)
-						}}
-					</button>
-				</ButtonStyled>
-				<ButtonStyled>
-					<button
-						:disabled="!isChanged"
-						@click="
-							() => {
-								loader = instance.loader
-								gameVersion = instance.game_version
-								resetLoaderVersionIndex()
-							}
-						"
-					>
-						<UndoIcon />
-						{{ formatMessage(messages.resetSelections) }}
-					</button>
-				</ButtonStyled>
-			</div>
-		</template>
-		<template v-else>
-			<template v-if="instance.linked_data && instance.linked_data.locked">
-				<h2 class="mt-4 mb-1 text-lg font-extrabold text-contrast block">
-					{{ formatMessage(messages.unlinkInstanceTitle) }}
-				</h2>
-				<p class="m-0">
-					{{ formatMessage(messages.unlinkInstanceDescription) }}
-				</p>
-				<ButtonStyled>
-					<button class="mt-2" @click="modalConfirmUnpair.show()">
-						<UnlinkIcon /> {{ formatMessage(messages.unlinkInstanceButton) }}
-					</button>
-				</ButtonStyled>
-				<template v-if="modpackProject">
-					<div>
-						<h2 class="m-0 mb-1 text-lg font-extrabold text-contrast block mt-4">
-							{{ formatMessage(messages.reinstallModpackTitle) }}
-						</h2>
-						<p class="m-0">
-							{{ formatMessage(messages.reinstallModpackDescription) }}
-						</p>
-					</div>
-					<ButtonStyled color="red" type="outlined">
-						<button
-							v-tooltip="
-								reinstalling
-									? formatMessage(messages.reinstallingModpackButton)
-									: repairing
-										? formatMessage(messages.cannotWhileRepairing, {
-												action: formatMessage(messages.reinstallAction),
-											})
-										: installing
-											? formatMessage(messages.cannotWhileInstalling, {
-													action: formatMessage(messages.reinstallAction),
-												})
-											: offline
-												? formatMessage(messages.cannotWhileOffline, {
-														action: formatMessage(messages.reinstallAction),
-													})
-												: null
-							"
-							class="mt-2"
-							:disabled="
-								changingVersion ||
-								repairing ||
-								installing ||
-								offline ||
-								fetching ||
-								!modpackVersions
-							"
-							@click="modalConfirmReinstall.show()"
-						>
-							<SpinnerIcon v-if="reinstalling" class="animate-spin" />
-							<DownloadIcon v-else />
-							{{
-								reinstalling
-									? formatMessage(messages.reinstallingModpackButton)
-									: formatMessage(messages.reinstallModpackButton)
-							}}
-						</button>
-					</ButtonStyled>
-				</template>
-			</template>
-		</template>
-	</div>
+	<InstallationSettingsLayout />
 </template>

apps/app-frontend/src/components/ui/minecraft-auth-error-modal/MinecraftAuthErrorModal.vue

@@ -10,6 +10,7 @@ import {
 import { Admonition, ButtonStyled, Collapsible, NewModal } from '@modrinth/ui'
 import { computed, ref } from 'vue'
 
+import { hide_ads_window, show_ads_window } from '@/helpers/ads.js'
 import { login as login_flow, set_default_user } from '@/helpers/auth.js'
 import { handleSevereError } from '@/store/error.js'
 
@@ -28,13 +29,19 @@ function show(errorVal: { message?: string }) {
 	matchedError.value = minecraftAuthErrors.find((e) => rawError.value.includes(e.errorCode)) ?? null
 
 	debugCollapsed.value = true
+	hide_ads_window()
 	modal.value?.show()
 }
 
 function hide() {
+	onModalHide()
 	modal.value?.hide()
 }
 
+function onModalHide() {
+	show_ads_window()
+}
+
 defineExpose({
 	show,
 	hide,
@@ -67,7 +74,7 @@ async function copyToClipboard(text: string) {
 </script>
 
 <template>
-	<NewModal ref="modal" header="Sign in Failed" :max-width="'548px'">
+	<NewModal ref="modal" header="Sign in Failed" :max-width="'548px'" @hide="onModalHide">
 		<div class="flex flex-col gap-6">
 			<Admonition
 				type="warning"
@@ -161,8 +168,12 @@ async function copyToClipboard(text: string) {
 						/>
 					</button>
 					<Collapsible :collapsed="debugCollapsed">
-						<div class="p-3 bg-surface-2 rounded-2xl text-xs flex items-start">
-							<div class="m-0 p-0 rounded-none bg-transparent text-sm font-mono">
+						<div
+							class="p-3 bg-surface-2 rounded-2xl text-xs grid grid-cols-[1fr_auto] max-w-full items-start"
+						>
+							<div
+								class="m-0 p-0 rounded-none bg-transparent text-sm font-mono break-words overflow-auto"
+							>
 								{{ debugInfo }}
 							</div>
 							<ButtonStyled circular>

apps/app-frontend/src/components/ui/modal/ConfirmDeleteInstanceModal.vue

@@ -0,0 +1,78 @@
+<template>
+	<NewModal ref="modal" :header="formatMessage(messages.header)" fade="danger" max-width="500px">
+		<Admonition type="critical" :header="formatMessage(messages.admonitionHeader)">
+			{{ formatMessage(messages.admonitionBody) }}
+		</Admonition>
+
+		<template #actions>
+			<div class="flex gap-2 justify-end">
+				<ButtonStyled type="outlined">
+					<button class="!border !border-surface-4" @click="modal?.hide()">
+						<XIcon />
+						{{ formatMessage(commonMessages.cancelButton) }}
+					</button>
+				</ButtonStyled>
+				<ButtonStyled color="red">
+					<button @click="confirm">
+						<TrashIcon />
+						{{ formatMessage(messages.deleteButton) }}
+					</button>
+				</ButtonStyled>
+			</div>
+		</template>
+	</NewModal>
+</template>
+
+<script setup lang="ts">
+import { TrashIcon, XIcon } from '@modrinth/assets'
+import {
+	Admonition,
+	ButtonStyled,
+	commonMessages,
+	defineMessages,
+	NewModal,
+	useVIntl,
+} from '@modrinth/ui'
+import { ref } from 'vue'
+
+const { formatMessage } = useVIntl()
+
+const messages = defineMessages({
+	header: {
+		id: 'app.instance.confirm-delete.header',
+		defaultMessage: 'Delete instance',
+	},
+	admonitionHeader: {
+		id: 'app.instance.confirm-delete.admonition-header',
+		defaultMessage: 'This action cannot be undone',
+	},
+	admonitionBody: {
+		id: 'app.instance.confirm-delete.admonition-body',
+		defaultMessage:
+			'All data for your instance will be permanently deleted, including your worlds, configs, and all installed content.',
+	},
+	deleteButton: {
+		id: 'app.instance.confirm-delete.delete-button',
+		defaultMessage: 'Delete instance',
+	},
+})
+
+const emit = defineEmits<{
+	(e: 'delete'): void
+}>()
+
+const modal = ref<InstanceType<typeof NewModal>>()
+
+function show() {
+	modal.value?.show()
+}
+
+function confirm() {
+	modal.value?.hide()
+	emit('delete')
+}
+
+defineExpose({
+	show,
+})
+</script>

apps/app-frontend/src/components/ui/modal/ConfirmModalWrapper.vue

@@ -1,13 +1,9 @@
+<!-- @deprecated Use ConfirmModal from @modrinth/ui directly. Ads/noblur now handled by injectModalBehavior. -->
 <script setup lang="ts">
 import { ConfirmModal } from '@modrinth/ui'
-import { ref } from 'vue'
+import { useTemplateRef } from 'vue'
 
-import { hide_ads_window, show_ads_window } from '@/helpers/ads.js'
-import { useTheming } from '@/store/theme.ts'
-
-const themeStore = useTheming()
-
-const props = defineProps({
+defineProps({
 	confirmationText: {
 		type: String,
 		default: '',
@@ -38,6 +34,7 @@ const props = defineProps({
 		type: Boolean,
 		default: true,
 	},
+	/** @deprecated No longer used — ads are handled by provideModalBehavior */
 	showAdOnClose: {
 		type: Boolean,
 		default: true,
@@ -49,25 +46,17 @@ const props = defineProps({
 })
 
 const emit = defineEmits(['proceed'])
-const modal = ref(null)
+const modal = useTemplateRef('modal')
 
 defineExpose({
 	show: () => {
-		hide_ads_window()
-		modal.value.show()
+		modal.value?.show()
 	},
 	hide: () => {
-		onModalHide()
-		modal.value.hide()
+		modal.value?.hide()
 	},
 })
 
-function onModalHide() {
-	if (props.showAdOnClose) {
-		show_ads_window()
-	}
-}
-
 function proceed() {
 	emit('proceed')
 }
@@ -82,8 +71,6 @@ function proceed() {
 		:description="description"
 		:proceed-icon="proceedIcon"
 		:proceed-label="proceedLabel"
-		:on-hide="onModalHide"
-		:noblur="!themeStore.advancedRendering"
 		:danger="danger"
 		:markdown="markdown"
 		@proceed="proceed"

apps/app-frontend/src/components/ui/modal/InstallToPlayModal.vue

@@ -1,36 +1,41 @@
 <template>
 	<NewModal ref="modal" :header="formatMessage(messages.installToPlay)" :closable="true">
-		<div class="flex flex-col gap-6 max-w-[500px]">
-			<Admonition type="info" :header="formatMessage(messages.sharedServerInstance)">
+		<div v-if="requiredContentProject" class="flex flex-col gap-6 max-w-[500px]">
+			<Admonition type="info" :header="formatMessage(messages.contentRequired)">
 				{{ formatMessage(messages.serverRequiresMods) }}
 			</Admonition>
 
-			<div v-if="sharedBy?.name" class="flex items-center gap-2 text-sm text-secondary">
-				<Avatar
-					v-if="sharedBy?.icon_url"
-					:src="sharedBy.icon_url"
-					:alt="sharedBy.name"
-					size="24px"
-				/>
-				<span>
-					<IntlFormatted :message-id="messages.sharedByToday">
-						<template #~name>
-							<span class="font-semibold text-contrast">{{ sharedBy.name }}</span>
-						</template>
-					</IntlFormatted>
-				</span>
-			</div>
+			<div class="flex flex-col gap-1">
+				<div class="flex justify-between items-center">
+					<span class="font-semibold text-contrast">{{
+						formatMessage(messages.requiredModpack)
+					}}</span>
 
-			<div class="flex flex-col gap-2">
-				<span class="font-semibold text-contrast">
-					{{ formatMessage(messages.sharedInstance) }}
-				</span>
-				<div class="flex items-center gap-3 rounded-xl bg-surface-4 p-3">
-					<Avatar :src="project.icon_url" :alt="project.title" size="48px" />
+					<ButtonStyled type="transparent">
+						<button @click="openViewContents">
+							<EyeIcon />
+							{{ formatMessage(messages.viewContents) }}
+						</button>
+					</ButtonStyled>
+				</div>
+
+				<div class="flex items-center gap-3 rounded-xl bg-surface-2 p-3">
+					<Avatar
+						:src="requiredContentProject.icon_url"
+						:alt="requiredContentProject.title"
+						size="48px"
+					/>
 					<div class="flex flex-col gap-0.5">
-						<span class="font-semibold text-contrast">{{ project.title }}</span>
+						<span class="font-semibold text-contrast">
+							<template v-if="usingCustomModpack && modpackVersion">
+								{{ modpackVersion.name }}
+							</template>
+							<template v-else>
+								{{ requiredContentProject.title }}
+							</template>
+						</span>
 						<span class="text-sm text-secondary">
-							{{ loaderDisplay }} {{ project.game_versions?.[0] }}
+							{{ loaderDisplay }} {{ requiredContentProject.game_versions?.[0] }}
 							<template v-if="modCount">
 								· {{ formatMessage(messages.modCount, { count: modCount }) }}
 							</template>
@@ -57,11 +62,18 @@
 			</div>
 		</template>
 	</NewModal>
+
+	<ModpackContentModal
+		ref="modpackContentModal"
+		:modpack-name="project?.name ?? ''"
+		:modpack-icon-url="project?.icon_url ?? undefined"
+	/>
 </template>
 
 <script setup lang="ts">
 import type { Labrinth } from '@modrinth/api-client'
-import { DownloadIcon, XIcon } from '@modrinth/assets'
+import { DownloadIcon, EyeIcon, XIcon } from '@modrinth/assets'
+import type { ContentItem } from '@modrinth/ui'
 import {
 	Admonition,
 	Avatar,
@@ -69,75 +81,57 @@ import {
 	commonMessages,
 	defineMessages,
 	formatLoader,
-	IntlFormatted,
+	ModpackContentModal,
 	NewModal,
 	useVIntl,
 } from '@modrinth/ui'
-import { useQuery } from '@tanstack/vue-query'
 import { computed, ref } from 'vue'
 
-import { get_organization, get_team, get_version } from '@/helpers/cache.js'
-import { install } from '@/store/install.js'
-
-const props = defineProps<{
-	project: Labrinth.Projects.v2.Project
-}>()
+import { hide_ads_window, show_ads_window } from '@/helpers/ads'
+import { get_project, get_project_many, get_version, get_version_many } from '@/helpers/cache.js'
+import { injectServerInstall } from '@/providers/server-install'
 
 const modal = ref<InstanceType<typeof NewModal>>()
+const modpackVersionId = ref<string | null>(null)
+const modpackVersion = ref<Labrinth.Versions.v2.Version | null>(null)
+const project = ref<Labrinth.Projects.v3.Project | null>(null)
+const requiredContentProject = ref<Labrinth.Projects.v2.Project | null>(null)
+const onInstallComplete = ref<() => void>(() => {})
 const { formatMessage } = useVIntl()
+const { installServerProject, startInstallingServer, stopInstallingServer } = injectServerInstall()
 
-const { data: organization } = useQuery({
-	queryKey: computed(() => ['organization', props.project.organization]),
-	queryFn: () => get_organization(props.project.organization!, 'must_revalidate'),
-	enabled: computed(() => !!props.project.organization),
-})
-
-const { data: teamMembers } = useQuery({
-	queryKey: computed(() => ['team', props.project.team]),
-	queryFn: () => get_team(props.project.team, 'must_revalidate'),
-	enabled: computed(() => !!props.project.team && !props.project.organization),
-})
-
-const sharedBy = computed(() => {
-	if (organization.value) {
-		return {
-			name: organization.value.name,
-			icon_url: organization.value.icon_url,
-		}
-	}
-	if (teamMembers.value) {
-		const owner = teamMembers.value.find((member: { is_owner: boolean }) => member.is_owner)
-		if (owner) {
-			return {
-				name: owner.user.username,
-				icon_url: owner.user.avatar_url,
-			}
-		}
-	}
-	return null
+const usingCustomModpack = computed(() => {
+	return requiredContentProject.value?.id === project.value?.id
 })
 
 const loaderDisplay = computed(() => {
-	const loader = props.project.loaders?.[0]
+	const loader = requiredContentProject.value?.loaders?.[0]
 	if (!loader) return ''
 	return formatLoader(formatMessage, loader)
 })
 
-// Fetch the most recent version to get mod count from dependencies
-const latestVersionId = computed(() => props.project.versions?.[0] ?? null)
-const { data: latestVersion } = useQuery({
-	queryKey: computed(() => ['version', latestVersionId.value]),
-	queryFn: () => get_version(latestVersionId.value, 'must_revalidate'),
-	enabled: computed(() => !!latestVersionId.value),
-})
-const modCount = computed(() => latestVersion.value?.dependencies?.length)
+const modCount = computed(() => modpackVersion.value?.dependencies?.length)
+
+async function fetchData(versionId: string) {
+	// cache is making version null for some reason so bypassing for now
+	modpackVersion.value = await get_version(versionId, 'bypass')
+
+	if (modpackVersion.value?.project_id) {
+		requiredContentProject.value = await get_project(modpackVersion.value.project_id, 'bypass')
+	}
+}
 
 async function handleAccept() {
 	hide()
+	const serverProjectId = project.value?.id
+	startInstallingServer(serverProjectId)
 	try {
-		await install(props.project.id, null, null, 'ProjectPageInstallToPlayModal')
+		await installServerProject(serverProjectId)
+		onInstallComplete.value()
 	} catch (error) {
-		console.error('Failed to install project from InstallToPlayModal:', error)
+		console.error('Failed to install server project from InstallToPlayModal:', error)
+	} finally {
+		stopInstallingServer(serverProjectId)
 	}
 }
 
@@ -145,12 +139,95 @@ function handleDecline() {
 	hide()
 }
 
-function show(e?: MouseEvent) {
+const modpackContentModal = ref<InstanceType<typeof ModpackContentModal>>()
+
+async function openViewContents() {
+	modpackContentModal.value?.showLoading()
+	try {
+		// Ensure version data is available — the useQuery may not have resolved yet
+		const versionId = modpackVersionId.value
+		const version =
+			modpackVersion.value ?? (versionId ? await get_version(versionId, 'must_revalidate') : null)
+
+		const deps = version?.dependencies ?? []
+
+		const projectIds = deps
+			.map((d: { project_id?: string }) => d.project_id)
+			.filter((id: string | undefined): id is string => !!id)
+
+		const versionIds = deps
+			.map((d: { version_id?: string }) => d.version_id)
+			.filter((id: string | undefined): id is string => !!id)
+
+		const projects: Labrinth.Projects.v2.Project[] =
+			projectIds.length > 0 ? await get_project_many(projectIds, 'must_revalidate') : []
+
+		const versions: Labrinth.Versions.v2.Version[] =
+			versionIds.length > 0 ? await get_version_many(versionIds, 'must_revalidate') : []
+
+		const projectMap = new Map(projects.map((p: Labrinth.Projects.v2.Project) => [p.id, p]))
+
+		const contentItems: ContentItem[] = deps.map(
+			(dep: Labrinth.Versions.v2.Dependency): ContentItem => {
+				const depProject = dep.project_id ? projectMap.get(dep.project_id) : null
+				// @ts-expect-error - version_id is missing from the type for some reason
+				const depVersion = dep.version_id
+					? // @ts-expect-error - version_id is missing from the type for some reason
+						versions.find((v: Labrinth.Versions.v2.Version) => v.id === dep.version_id)
+					: null
+
+				return {
+					file_name: dep.file_name ?? depProject?.title ?? 'Unknown',
+					project_type: depProject?.project_type ?? 'mod',
+					has_update: false,
+					update_version_id: null,
+					project: {
+						id: depProject?.id ?? dep.project_id ?? dep.file_name ?? 'unknown',
+						slug: depProject?.slug ?? dep.project_id ?? 'unknown',
+						title: depProject?.title ?? dep.file_name ?? 'Unknown',
+						icon_url: depProject?.icon_url ?? undefined,
+					},
+					...(depVersion
+						? {
+								version: {
+									id: depVersion.id,
+									file_name: depVersion.files?.[0]?.filename ?? dep.file_name,
+									version_number: depVersion.version_number ?? undefined,
+									date_published: depVersion.date_published ?? undefined,
+								},
+							}
+						: {}),
+				}
+			},
+		)
+		modpackContentModal.value?.show(contentItems)
+	} catch (err) {
+		console.error('Failed to load modpack contents:', err)
+		modpackContentModal.value?.show([])
+	}
+}
+
+async function show(
+	projectVal: Labrinth.Projects.v3.Project,
+	modpackVersionIdVal: string | null = null,
+	callback: () => void = () => {},
+	e?: MouseEvent,
+) {
+	project.value = projectVal
+	modpackVersionId.value = modpackVersionIdVal
+	modpackVersion.value = null
+	requiredContentProject.value = null
+	onInstallComplete.value = callback
+
+	if (modpackVersionIdVal) await fetchData(modpackVersionIdVal)
+
+	hide_ads_window()
 	modal.value?.show(e)
 }
 
 function hide() {
 	modal.value?.hide()
+	show_ads_window()
 }
 
 const messages = defineMessages({
@@ -162,14 +239,18 @@ const messages = defineMessages({
 		id: 'app.modal.install-to-play.shared-server-instance',
 		defaultMessage: 'Shared server instance',
 	},
+	contentRequired: {
+		id: 'app.modal.install-to-play.content-required',
+		defaultMessage: 'Content required',
+	},
 	serverRequiresMods: {
 		id: 'app.modal.install-to-play.server-requires-mods',
 		defaultMessage:
-			'This server requires mods to play. Click install to set up the required files from Modrinth.',
+			'This server requires mods to play. Click Install to set up the required files from Modrinth, then launch directly into the server.',
 	},
-	sharedByToday: {
-		id: 'app.modal.install-to-play.shared-by-today',
-		defaultMessage: '{name} shared this instance with you today.',
+	requiredModpack: {
+		id: 'app.modal.install-to-play.required-modpack',
+		defaultMessage: 'Required modpack',
 	},
 	sharedInstance: {
 		id: 'app.modal.install-to-play.shared-instance',
@@ -183,6 +264,10 @@ const messages = defineMessages({
 		id: 'app.modal.install-to-play.install-button',
 		defaultMessage: 'Install',
 	},
+	viewContents: {
+		id: 'app.modal.install-to-play.view-contents',
+		defaultMessage: 'View contents',
+	},
 })
 
 defineExpose({ show, hide })

apps/app-frontend/src/components/ui/modal/InstanceSettingsModal.vue

@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import type { Labrinth } from '@modrinth/api-client'
 import {
 	ChevronRightIcon,
 	CodeIcon,
@@ -11,27 +12,53 @@ import {
 	Avatar,
 	commonMessages,
 	defineMessage,
+	NewModal,
 	TabbedModal,
 	type TabbedModalTab,
 	useVIntl,
 } from '@modrinth/ui'
+import { useQueryClient } from '@tanstack/vue-query'
 import { convertFileSrc } from '@tauri-apps/api/core'
-import { ref } from 'vue'
+import { computed, nextTick, ref, useTemplateRef, watch } from 'vue'
 
 import GeneralSettings from '@/components/ui/instance_settings/GeneralSettings.vue'
 import HooksSettings from '@/components/ui/instance_settings/HooksSettings.vue'
 import InstallationSettings from '@/components/ui/instance_settings/InstallationSettings.vue'
 import JavaSettings from '@/components/ui/instance_settings/JavaSettings.vue'
 import WindowSettings from '@/components/ui/instance_settings/WindowSettings.vue'
-import ModalWrapper from '@/components/ui/modal/ModalWrapper.vue'
+import { get_project_v3 } from '@/helpers/cache'
+import { get_linked_modpack_info } from '@/helpers/profile'
 
 import type { InstanceSettingsTabProps } from '../../../helpers/types'
 
 const { formatMessage } = useVIntl()
 
 const props = defineProps<InstanceSettingsTabProps>()
+const emit = defineEmits<{
+	unlinked: []
+}>()
 
-const tabs: TabbedModalTab<InstanceSettingsTabProps>[] = [
+const isMinecraftServer = ref(false)
+const handleUnlinked = () => emit('unlinked')
+
+watch(
+	() => props.instance,
+	(instance) => {
+		isMinecraftServer.value = false
+		if (instance.linked_data?.project_id) {
+			get_project_v3(instance.linked_data.project_id, 'must_revalidate')
+				.then((project: Labrinth.Projects.v3.Project | undefined) => {
+					if (project?.minecraft_server != null) {
+						isMinecraftServer.value = true
+					}
+				})
+				.catch(() => {})
+		}
+	},
+	{ immediate: true },
+)
+
+const tabs = computed<TabbedModalTab<InstanceSettingsTabProps>[]>(() => [
 	{
 		name: defineMessage({
 			id: 'instance.settings.tabs.general',
@@ -72,18 +99,33 @@ const tabs: TabbedModalTab<InstanceSettingsTabProps>[] = [
 		icon: CodeIcon,
 		content: HooksSettings,
 	},
-]
+])
 
+const queryClient = useQueryClient()
 const modal = ref()
+const tabbedModal = useTemplateRef('tabbedModal')
 
-function show() {
+function show(tabIndex?: number) {
+	if (props.instance.linked_data?.project_id) {
+		queryClient.prefetchQuery({
+			queryKey: ['linkedModpackInfo', props.instance.path],
+			queryFn: () => get_linked_modpack_info(props.instance.path, 'stale_while_revalidate'),
+		})
+	}
 	modal.value.show()
+	if (tabIndex !== undefined) {
+		nextTick(() => tabbedModal.value?.setTab(tabIndex))
+	}
 }
 
 defineExpose({ show })
 </script>
 <template>
-	<ModalWrapper ref="modal">
+	<NewModal
+		ref="modal"
+		:max-width="'min(928px, calc(95vw - 10rem))'"
+		:width="'min(928px, calc(95vw - 10rem))'"
+	>
 		<template #title>
 			<span class="flex items-center gap-2 text-lg font-semibold text-primary">
 				<Avatar
@@ -98,6 +140,18 @@ defineExpose({ show })
 			</span>
 		</template>
 
-		<TabbedModal :tabs="tabs.map((tab) => ({ ...tab, props }))" />
-	</ModalWrapper>
+		<TabbedModal
+			ref="tabbedModal"
+			:tabs="
+				tabs.map((tab) => ({
+					...tab,
+					props: {
+						...props,
+						isMinecraftServer,
+						onUnlinked: handleUnlinked,
+					},
+				}))
+			"
+		/>
+	</NewModal>
 </template>

apps/app-frontend/src/components/ui/modal/ModalWrapper.vue

@@ -1,12 +1,8 @@
+<!-- @deprecated Use NewModal from @modrinth/ui directly. Ads/noblur now handled by injectModalBehavior. -->
 <script setup lang="ts">
 import { NewModal as Modal } from '@modrinth/ui'
 import { useTemplateRef } from 'vue'
 
-import { hide_ads_window, show_ads_window } from '@/helpers/ads.js'
-import { useTheming } from '@/store/theme.ts'
-
-const themeStore = useTheming()
-
 const props = defineProps({
 	header: {
 		type: String,
@@ -26,6 +22,7 @@ const props = defineProps({
 			return () => {}
 		},
 	},
+	/** @deprecated No longer used — ads are handled by provideModalBehavior */
 	showAdOnClose: {
 		type: Boolean,
 		default: true,
@@ -35,31 +32,21 @@ const modal = useTemplateRef('modal')
 
 defineExpose({
 	show: (e: MouseEvent) => {
-		hide_ads_window()
 		modal.value?.show(e)
 	},
 	hide: () => {
-		onModalHide()
 		modal.value?.hide()
 	},
 })
-
-function onModalHide() {
-	if (props.showAdOnClose) {
-		show_ads_window()
-	}
-	props.onHide?.()
-}
 </script>
 
 <template>
 	<Modal
 		ref="modal"
 		:header="header"
-		:noblur="!themeStore.advancedRendering"
 		:closable="closable"
 		:hide-header="hideHeader"
-		@hide="onModalHide"
+		:on-hide="() => props.onHide?.()"
 	>
 		<template #title>
 			<slot name="title" />

apps/app-frontend/src/components/ui/modal/ShareModalWrapper.vue

@@ -1,12 +1,8 @@
+<!-- @deprecated Use ShareModal from @modrinth/ui directly. Ads/noblur now handled by injectModalBehavior. -->
 <script setup lang="ts">
 import { ShareModal } from '@modrinth/ui'
 import { ref } from 'vue'
 
-import { hide_ads_window, show_ads_window } from '@/helpers/ads.js'
-import { useTheming } from '@/store/theme.ts'
-
-const themeStore = useTheming()
-
 defineProps({
 	header: {
 		type: String,
@@ -34,18 +30,12 @@ const modal = ref(null)
 
 defineExpose({
 	show: (passedContent) => {
-		hide_ads_window()
 		modal.value.show(passedContent)
 	},
 	hide: () => {
-		onModalHide()
 		modal.value.hide()
 	},
 })
-
-function onModalHide() {
-	show_ads_window()
-}
 </script>
 
 <template>
@@ -56,7 +46,5 @@ function onModalHide() {
 		:share-text="shareText"
 		:link="link"
 		:open-in-new-tab="openInNewTab"
-		:on-hide="onModalHide"
-		:noblur="!themeStore.advancedRendering"
 	/>
 </template>

apps/app-frontend/src/components/ui/modal/UpdateToPlayModal.vue

@@ -1,119 +1,39 @@
 <template>
-	<NewModal ref="modal" :header="formatMessage(messages.updateToPlay)" :closable="true" no-padding>
-		<div class="max-w-[500px]">
-			<div class="flex flex-col gap-4 p-4">
-				<Admonition type="warning" :header="formatMessage(messages.updateRequired)">
-					{{ formatMessage(messages.updateRequiredDescription, { name: instance.name }) }}
-				</Admonition>
-
-				<div v-if="diffs.length" class="flex flex-col gap-2">
-					<span v-if="publishedDate" class="text-contrast font-semibold">{{
-						formatMessage(messages.publishedDate, { date: publishedDate })
-					}}</span>
-					<div class="flex gap-2">
-						<div v-if="removedCount" class="flex gap-1 items-center">
-							<MinusIcon />
-							{{ formatMessage(messages.removedCount, { count: removedCount }) }}
-						</div>
-						<div v-if="addedCount" class="flex gap-1 items-center">
-							<PlusIcon />
-							{{ formatMessage(messages.addedCount, { count: addedCount }) }}
-						</div>
-						<div v-if="updatedCount" class="flex gap-1 items-center">
-							<RefreshCwIcon />
-							{{ formatMessage(messages.updatedCount, { count: updatedCount }) }}
-						</div>
-					</div>
-				</div>
-			</div>
-			<div v-if="diffs.length" class="flex flex-col bg-surface-2 p-4 max-h-[272px] overflow-y-auto">
-				<div
-					v-for="diff in diffs"
-					:key="diff.project_id"
-					class="grid grid-cols-[auto_1fr_1fr_1fr] items-center min-h-10 h-10 gap-2"
-				>
-					<div class="flex flex-col justify-between items-center">
-						<div class="w-[1px] h-2"></div>
-						<PlusIcon v-if="diff.type === 'added'" />
-						<MinusIcon v-else-if="diff.type === 'removed'" />
-						<RefreshCwIcon v-else />
-						<div class="bg-surface-5 w-[1px] h-2 relative top-1"></div>
-					</div>
-
-					<div class="flex gap-1 col-span-2">
-						<span class="text-sm">{{ formatMessage(diffTypeMessages[diff.type]) }}</span>
-						<span
-							v-if="diff.project"
-							v-tooltip="diff.project.title"
-							class="text-sm text-contrast font-medium truncate"
-						>
-							{{ diff.project.title }}
-						</span>
-					</div>
-
-					<span
-						v-if="getFilename(diff.newVersion) || getFilename(diff.currentVersion)"
-						v-tooltip="getFilename(diff.newVersion) || getFilename(diff.currentVersion)"
-						class="text-xs truncate text-right"
-					>
-						{{ getFilename(diff.newVersion) || getFilename(diff.currentVersion) }}
-					</span>
-				</div>
-			</div>
-		</div>
-
-		<template #actions>
-			<div class="flex justify-between gap-2">
-				<ButtonStyled color="red" type="transparent">
-					<button @click="handleReport">
-						<ReportIcon />
-						{{ formatMessage(commonMessages.reportButton) }}
-					</button>
-				</ButtonStyled>
-				<div class="flex gap-2">
-					<ButtonStyled>
-						<button @click="handleDecline">
-							<XIcon />
-							{{ formatMessage(commonMessages.cancelButton) }}
-						</button>
-					</ButtonStyled>
-					<ButtonStyled color="brand">
-						<button @click="handleUpdate">
-							<DownloadIcon />
-							{{ formatMessage(commonMessages.updateButton) }}
-						</button>
-					</ButtonStyled>
-				</div>
-			</div>
-		</template>
-	</NewModal>
+	<ContentDiffModal
+		ref="diffModal"
+		:header="formatMessage(messages.updateToPlay)"
+		:admonition-header="formatMessage(messages.updateRequired)"
+		:description="
+			instance ? formatMessage(messages.updateRequiredDescription, { name: instance.name }) : ''
+		"
+		:diffs="normalizedDiffs"
+		:confirm-label="formatMessage(commonMessages.updateButton)"
+		:confirm-icon="DownloadIcon"
+		:show-report-button="true"
+		@confirm="handleUpdate"
+		@cancel="handleDecline"
+		@report="handleReport"
+	/>
 </template>
 
 <script setup lang="ts">
 import type { Labrinth } from '@modrinth/api-client'
+import { DownloadIcon } from '@modrinth/assets'
 import {
-	DownloadIcon,
-	MinusIcon,
-	PlusIcon,
-	RefreshCwIcon,
-	ReportIcon,
-	XIcon,
-} from '@modrinth/assets'
-import {
-	Admonition,
-	ButtonStyled,
 	commonMessages,
+	type ContentDiffItem,
+	ContentDiffModal,
 	defineMessages,
-	NewModal,
 	useVIntl,
 } from '@modrinth/ui'
 import { openUrl } from '@tauri-apps/plugin-opener'
 import dayjs from 'dayjs'
 import { computed, ref, watch } from 'vue'
 
-import { get_project, get_project_many, get_version_many } from '@/helpers/cache.js'
+import { get_project_many, get_version, get_version_many } from '@/helpers/cache.js'
 import { update_managed_modrinth_version } from '@/helpers/profile'
 import type { GameInstance } from '@/helpers/types'
+import { injectServerInstall } from '@/providers/server-install'
 
 type Dependency = Labrinth.Versions.v3.Dependency
 type Version = Labrinth.Versions.v2.Version
@@ -129,6 +49,7 @@ interface BaseDiff {
 	newVersionId?: string
 	currentVersion?: Version
 	newVersion?: Version
+	fileName?: string
 }
 interface AddedDiff extends BaseDiff {
 	type: 'added'
@@ -151,44 +72,52 @@ type ProjectInfo = {
 	slug: string
 }
 
-const { instance } = defineProps<{
-	instance: GameInstance
-}>()
-
 const { formatMessage } = useVIntl()
+const { startInstallingServer, stopInstallingServer } = injectServerInstall()
+type UpdateCompleteCallback = () => void | Promise<void>
 
-const modal = ref<InstanceType<typeof NewModal>>()
+const diffModal = ref<InstanceType<typeof ContentDiffModal>>()
+const instance = ref<GameInstance | null>(null)
+const onUpdateComplete = ref<UpdateCompleteCallback>(() => {})
 const diffs = ref<DependencyDiff[]>([])
-const latestVersionId = ref<string | null>(null)
-const latestVersion = ref<Version | null>(null)
+const modpackVersionId = ref<string | null>(null)
+const modpackVersion = ref<Version | null>(null)
 
-const removedCount = computed(() => diffs.value.filter((d) => d.type === 'removed').length)
-const addedCount = computed(() => diffs.value.filter((d) => d.type === 'added').length)
-const updatedCount = computed(() => diffs.value.filter((d) => d.type === 'updated').length)
-const publishedDate = computed(() =>
-	latestVersion.value?.date_published ? new Date(latestVersion.value.date_published) : null,
+const normalizedDiffs = computed<ContentDiffItem[]>(() =>
+	diffs.value.map((diff) => ({
+		type: diff.type,
+		projectName: diff.project?.title,
+		fileName: diff.fileName,
+		currentVersionName: diff.currentVersion?.version_number,
+		newVersionName: diff.newVersion?.version_number,
+	})),
 )
 
-function getFilename(version?: Version): string | undefined {
-	return version?.files.find((f) => f.primary)?.filename
-}
-
 async function computeDependencyDiffs(
 	currentDeps: Dependency[],
 	latestDeps: Dependency[],
 ): Promise<DependencyDiff[]> {
+	console.log('Computing dependency diffs', { currentDeps, latestDeps })
+
+	// Separate deps with project_id from file_name-only deps
+	const currentWithProject = currentDeps.filter((d) => d.project_id)
+	const latestWithProject = latestDeps.filter((d) => d.project_id)
+	const currentFileOnly = currentDeps.filter((d) => !d.project_id && d.file_name)
+	const latestFileOnly = latestDeps.filter((d) => !d.project_id && d.file_name)
+
 	const currentByProject = new Map<string, Dependency>(
-		currentDeps.map((d) => [d.project_id || '', d]),
+		currentWithProject.map((d) => [d.project_id!, d]),
 	)
 	const latestByProject = new Map<string, Dependency>(
-		latestDeps.map((d) => [d.project_id || '', d]),
+		latestWithProject.map((d) => [d.project_id!, d]),
 	)
+	const currentFilenames = new Set(currentFileOnly.map((d) => d.file_name!))
+	const latestFilenames = new Set(latestFileOnly.map((d) => d.file_name!))
 
 	const diffs: DependencyDiff[] = []
 
-	// Find added and updated dependencies
+	// Find added and updated dependencies (by project_id)
 	latestByProject.forEach((latestDep, projectId) => {
-		if (!projectId) return
 		const currentDep = currentByProject.get(projectId)
 		if (!currentDep && latestDep.version_id) {
 			diffs.push({ type: 'added', project_id: projectId, newVersionId: latestDep.version_id })
@@ -206,9 +135,8 @@ async function computeDependencyDiffs(
 		}
 	})
 
-	// Find removed dependencies
+	// Find removed dependencies (by project_id)
 	currentByProject.forEach((currentDep, projectId) => {
-		if (!projectId) return
 		if (!latestByProject.has(projectId)) {
 			diffs.push({
 				type: 'removed',
@@ -218,6 +146,19 @@ async function computeDependencyDiffs(
 		}
 	})
 
+	// Find added/removed file_name-only dependencies
+	// ideally in future, this should use the hash of the file instead of filename, but since version dependencies don't include file hashes, we'll use filename as a best effort approach
+	for (const fileName of latestFilenames) {
+		if (!currentFilenames.has(fileName)) {
+			diffs.push({ type: 'added', project_id: '', newVersionId: '' as string, fileName })
+		}
+	}
+	for (const fileName of currentFilenames) {
+		if (!latestFilenames.has(fileName)) {
+			diffs.push({ type: 'removed', project_id: '', fileName })
+		}
+	}
+
 	// Fetch projects and versions of diffs
 	const allProjectIds = [...new Set(diffs.map((d) => d.project_id).filter(Boolean))]
 	const allVersionIds = [
@@ -228,14 +169,14 @@ async function computeDependencyDiffs(
 		),
 	] as string[]
 	const [projects, versions] = await Promise.all([
-		get_project_many(allProjectIds, 'must_revalidate'),
-		get_version_many(allVersionIds, 'must_revalidate'),
+		get_project_many(allProjectIds, 'bypass'),
+		get_version_many(allVersionIds, 'bypass'),
 	])
 
 	const projectMap = new Map<string, ProjectInfo>(projects.map((p: ProjectInfo) => [p.id, p]))
 	const versionMap = new Map<string, Version>(versions.map((v: Version) => [v.id, v]))
 
-	return diffs
+	const mappedDiffs = diffs
 		.map((diff) => {
 			const project = projectMap.get(diff.project_id)
 			return {
@@ -248,7 +189,7 @@ async function computeDependencyDiffs(
 			}
 		})
 		.sort((a, b) => {
-			const typeOrder = { removed: 0, added: 1, updated: 2 }
+			const typeOrder = { added: 0, updated: 1, removed: 2 }
 			const typeCompare = typeOrder[a.type] - typeOrder[b.type]
 			if (typeCompare !== 0) return typeCompare
 
@@ -256,34 +197,26 @@ async function computeDependencyDiffs(
 			const bDate = b.newVersion?.date_published || b.currentVersion?.date_published || ''
 			return dayjs(bDate).valueOf() - dayjs(aDate).valueOf()
 		})
+		.filter((d) => d.project || d.fileName) // filter out any diffs that couldn't be matched to a project or file
+	return mappedDiffs
 }
 
-async function checkUpdateAvailable(instance: GameInstance): Promise<DependencyDiff[] | null> {
-	if (!instance.linked_data) return null
+async function checkUpdateAvailable(inst: GameInstance): Promise<DependencyDiff[] | null> {
+	if (!inst.linked_data) return null
+	if (!modpackVersionId.value || !inst.linked_data.version_id) return null
 
 	try {
-		const project = await get_project(instance.linked_data.project_id, 'must_revalidate')
-		if (!project || !project.versions || project.versions.length === 0) {
-			return null
-		}
-
-		const versions = await get_version_many(project.versions, 'must_revalidate')
-		const sortedVersions = versions.sort(
-			(a: { date_published: string }, b: { date_published: string }) =>
-				dayjs(b.date_published).valueOf() - dayjs(a.date_published).valueOf(),
-		)
-
-		latestVersion.value = sortedVersions[0]
-		latestVersionId.value = latestVersion.value?.id || null
-
-		const currentVersionId = instance.linked_data.version_id
-		const currentVersion = versions.find((v: { id: string }) => v.id === currentVersionId)
+		// For server projects, linked_data.project_id is the server project but
+		// linked_data.version_id references a content modpack version from a different project.
+		// Detect this by comparing the version's project_id with linked_data.project_id.
+		modpackVersion.value = await get_version(modpackVersionId.value, 'bypass')
+		const instanceModpackVersion = await get_version(inst.linked_data.version_id, 'bypass')
 
 		// Compute dependency diffs between current and latest version
-		if (currentVersion && latestVersion.value) {
+		if (instanceModpackVersion && modpackVersion.value) {
 			return await computeDependencyDiffs(
-				currentVersion.dependencies || [],
-				latestVersion.value.dependencies || [],
+				instanceModpackVersion.dependencies || [],
+				modpackVersion.value.dependencies || [],
 			)
 		}
 	} catch (error) {
@@ -294,9 +227,10 @@ async function checkUpdateAvailable(instance: GameInstance): Promise<DependencyD
 }
 
 watch(
-	() => instance,
-	async () => {
-		const result = await checkUpdateAvailable(instance)
+	() => instance.value,
+	async (newInstance) => {
+		if (!newInstance) return
+		const result = await checkUpdateAvailable(newInstance)
 		diffs.value = result || []
 	},
 	{ immediate: true, deep: true },
@@ -304,18 +238,25 @@ watch(
 
 async function handleUpdate() {
 	hide()
+	const serverProjectId = instance.value?.linked_data?.project_id
+	if (serverProjectId) startInstallingServer(serverProjectId)
 	try {
-		if (latestVersionId.value) {
-			await update_managed_modrinth_version(instance.path, latestVersionId.value)
+		if (modpackVersionId.value && instance.value) {
+			await update_managed_modrinth_version(instance.value.path, modpackVersionId.value)
+			await onUpdateComplete.value()
 		}
 	} catch (error) {
 		console.error('Error updating instance:', error)
+	} finally {
+		if (serverProjectId) stopInstallingServer(serverProjectId)
 	}
 }
 
 function handleReport() {
-	if (instance.linked_data?.project_id) {
-		openUrl(`https://modrinth.com/report?item=project&itemID=${instance.linked_data.project_id}`)
+	if (instance.value?.linked_data?.project_id) {
+		openUrl(
+			`https://modrinth.com/report?item=project&itemID=${instance.value.linked_data.project_id}`,
+		)
 	}
 }
 
@@ -323,12 +264,20 @@ function handleDecline() {
 	hide()
 }
 
-function show(e?: MouseEvent) {
-	modal.value?.show(e)
+function show(
+	instanceVal: GameInstance,
+	modpackVersionIdVal: string | null = null,
+	callback: UpdateCompleteCallback = () => {},
+	e?: MouseEvent,
+) {
+	instance.value = instanceVal
+	modpackVersionId.value = modpackVersionIdVal
+	onUpdateComplete.value = callback
+	diffModal.value?.show(e)
 }
 
 function hide() {
-	modal.value?.hide()
+	diffModal.value?.hide()
 }
 
 const messages = defineMessages({
@@ -345,38 +294,15 @@ const messages = defineMessages({
 		defaultMessage:
 			'An update is required to play {name}. Please update to the latest version to launch the game.',
 	},
-	publishedDate: {
-		id: 'app.modal.update-to-play.published-date',
-		defaultMessage: '{date, date, long}',
-	},
-	removedCount: {
-		id: 'app.modal.update-to-play.removed-count',
-		defaultMessage: '{count} removed',
-	},
-	addedCount: {
-		id: 'app.modal.update-to-play.added-count',
-		defaultMessage: '{count} added',
-	},
-	updatedCount: {
-		id: 'app.modal.update-to-play.updated-count',
-		defaultMessage: '{count} updated',
-	},
 })
 
-const diffTypeMessages = defineMessages({
-	added: {
-		id: 'app.modal.update-to-play.diff-type.added',
-		defaultMessage: 'Added',
-	},
-	removed: {
-		id: 'app.modal.update-to-play.diff-type.removed',
-		defaultMessage: 'Removed',
-	},
-	updated: {
-		id: 'app.modal.update-to-play.diff-type.updated',
-		defaultMessage: 'Updated',
-	},
+const hasUpdate = computed(() => {
+	if (!instance.value?.linked_data) return false
+	return (
+		modpackVersionId.value != null &&
+		modpackVersionId.value !== instance.value.linked_data.version_id
+	)
 })
 
-defineExpose({ show, hide })
+defineExpose({ show, hide, hasUpdate })
 </script>

apps/app-frontend/src/components/ui/settings/LanguageSettings.vue

@@ -8,14 +8,14 @@ import {
 	LOCALES,
 	useVIntl,
 } from '@modrinth/ui'
-import { ref, watch } from 'vue'
+import { computed, ref, watch } from 'vue'
 
 import { get, set } from '@/helpers/settings.ts'
 import i18n from '@/i18n.config'
 
 const { formatMessage } = useVIntl()
 
-const platform = formatMessage(languageSelectorMessages.platformApp)
+const platform = computed(() => formatMessage(languageSelectorMessages.platformApp))
 
 const settings = ref(await get())
 

apps/app-frontend/src/components/ui/settings/ResourceManagementSettings.vue

@@ -28,10 +28,12 @@ watch(
 async function purgeCache() {
 	await purge_cache_types([
 		'project',
+		'project_v3',
 		'version',
 		'user',
 		'team',
 		'organization',
+		'file',
 		'loader_manifest',
 		'minecraft_manifest',
 		'categories',
@@ -39,8 +41,10 @@ async function purgeCache() {
 		'loaders',
 		'game_versions',
 		'donation_platforms',
+		'file_hash',
 		'file_update',
 		'search_results',
+		'search_results_v3',
 	]).catch(handleError)
 }
 

apps/app-frontend/src/components/ui/world/InstanceItem.vue

@@ -14,13 +14,13 @@ import {
 	injectNotificationManager,
 	OverflowMenu,
 	SmartClickable,
+	useFormatDateTime,
 	useRelativeTime,
 	useVIntl,
 } from '@modrinth/ui'
 import { capitalizeString } from '@modrinth/utils'
 import { convertFileSrc } from '@tauri-apps/api/core'
 import type { Dayjs } from 'dayjs'
-import dayjs from 'dayjs'
 import { computed, nextTick, onMounted, onUnmounted, ref } from 'vue'
 import { useRouter } from 'vue-router'
 
@@ -36,6 +36,10 @@ import { handleSevereError } from '@/store/error'
 const { handleError } = injectNotificationManager()
 const { formatMessage } = useVIntl()
 const formatRelativeTime = useRelativeTime()
+const formatDateTime = useFormatDateTime({
+	timeStyle: 'short',
+	dateStyle: 'long',
+})
 
 const router = useRouter()
 
@@ -80,7 +84,7 @@ const play = async (event: MouseEvent) => {
 	await run(props.instance.path)
 		.catch((err) => handleSevereError(err, { profilePath: props.instance.path }))
 		.finally(() => {
-			trackEvent('InstancePlay', {
+			trackEvent('InstanceStart', {
 				loader: props.instance.loader,
 				game_version: props.instance.game_version,
 				source: 'InstanceItem',
@@ -145,18 +149,14 @@ onUnmounted(() => {
 				</div>
 				<div class="flex items-center gap-2 text-sm text-secondary">
 					<div
-						v-tooltip="
-							instance.last_played
-								? dayjs(instance.last_played).format('MMMM D, YYYY [at] h:mm A')
-								: null
-						"
+						v-tooltip="instance.last_played ? formatDateTime(instance.last_played) : null"
 						class="w-fit shrink-0"
 						:class="{ 'cursor-help smart-clickable:allow-pointer-events': last_played }"
 					>
 						<template v-if="last_played">
 							{{
 								formatMessage(commonMessages.playedLabel, {
-									time: formatRelativeTime(last_played.toISOString?.()),
+									ago: formatRelativeTime(last_played.toISOString?.()),
 								})
 							}}
 						</template>

apps/app-frontend/src/components/ui/world/RecentWorldsList.vue

@@ -175,10 +175,17 @@ function refreshServer(address: string, instancePath: string) {
 	refreshServerData(serverData.value[address], protocolVersions.value[instancePath], address)
 }
 
-async function joinWorld(world: WorldWithProfile) {
+async function joinWorld(world: WorldWithProfile, instance?: GameInstance) {
 	console.log(`Joining world ${getWorldIdentifier(world)}`)
 	if (world.type === 'server') {
 		await start_join_server(world.profile, world.address).catch(handleError)
+		if (instance) {
+			trackEvent('InstanceStart', {
+				loader: instance.loader,
+				game_version: instance.game_version,
+				source: 'WorldItem',
+			})
+		}
 	} else if (world.type === 'singleplayer') {
 		await start_join_singleplayer_world(world.profile, world.path).catch(handleError)
 	}
@@ -188,7 +195,7 @@ async function playInstance(instance: GameInstance) {
 	await run(instance.path)
 		.catch((err) => handleSevereError(err, { profilePath: instance.path }))
 		.finally(() => {
-			trackEvent('InstancePlay', {
+			trackEvent('InstanceStart', {
 				loader: instance.loader,
 				game_version: instance.game_version,
 				source: 'WorldItem',
@@ -317,7 +324,7 @@ onUnmounted(() => {
 						() => {
 							currentProfile = item.instance.path
 							currentWorld = getWorldIdentifier(item.world)
-							joinWorld(item.world)
+							joinWorld(item.world, item.instance)
 						}
 					"
 					@play-instance="

apps/app-frontend/src/components/ui/world/WorldItem.vue

@@ -25,10 +25,13 @@ import {
 	defineMessages,
 	OverflowMenu,
 	SmartClickable,
+	TagItem,
+	useFormatDateTime,
+	useFormatNumber,
 	useRelativeTime,
 	useVIntl,
 } from '@modrinth/ui'
-import { formatNumber, getPingLevel } from '@modrinth/utils'
+import { getPingLevel } from '@modrinth/utils'
 import { convertFileSrc } from '@tauri-apps/api/core'
 import dayjs from 'dayjs'
 import { Tooltip } from 'floating-vue'
@@ -46,8 +49,15 @@ import type {
 } from '@/helpers/worlds.ts'
 import { getWorldIdentifier, set_world_display_status } from '@/helpers/worlds.ts'
 
+import { LockIcon } from '../../../../../../packages/assets/generated-icons'
+
 const { formatMessage } = useVIntl()
 const formatRelativeTime = useRelativeTime()
+const formatNumber = useFormatNumber()
+const formatDateTime = useFormatDateTime({
+	timeStyle: 'short',
+	dateStyle: 'long',
+})
 
 const router = useRouter()
 
@@ -78,6 +88,8 @@ const props = withDefaults(
 			message: MessageDescriptor
 		}
 
+		managed?: boolean
+
 		// Instance
 		instancePath?: string
 		instanceName?: string
@@ -96,6 +108,7 @@ const props = withDefaults(
 		renderedMotd: undefined,
 
 		gameMode: undefined,
+		managed: false,
 
 		instancePath: undefined,
 		instanceName: undefined,
@@ -117,6 +130,7 @@ const serverIncompatible = computed(
 )
 
 const locked = computed(() => props.world.type === 'singleplayer' && props.world.locked)
+const managed = computed(() => props.managed)
 
 const messages = defineMessages({
 	hardcore: {
@@ -171,6 +185,10 @@ const messages = defineMessages({
 		id: 'instance.worlds.dont_show_on_home',
 		defaultMessage: `Don't show on Home`,
 	},
+	linkedServer: {
+		id: 'instance.worlds.linked_server',
+		defaultMessage: 'Managed by server project',
+	},
 })
 </script>
 <template>
@@ -200,6 +218,14 @@ const messages = defineMessages({
 					<div class="text-lg text-contrast font-bold truncate smart-clickable:underline-on-hover">
 						{{ world.name }}
 					</div>
+					<TagItem
+						v-if="managed"
+						v-tooltip="formatMessage(messages.linkedServer)"
+						class="border !border-solid border-blue bg-highlight-blue text-xs"
+						:style="`--_color: var(--color-blue)`"
+					>
+						<LockIcon aria-hidden="true" class="h-5 w-5" />
+					</TagItem>
 					<div
 						v-if="world.type === 'singleplayer'"
 						class="text-sm text-secondary flex items-center gap-1 font-semibold"
@@ -239,7 +265,7 @@ const messages = defineMessages({
 								/>
 								<Tooltip :disabled="!hasPlayersTooltip">
 									<span :class="{ 'cursor-help': hasPlayersTooltip }">
-										{{ formatNumber(serverStatus.players?.online, false) }}
+										{{ formatNumber(serverStatus.players?.online) }}
 										online
 									</span>
 									<template #popper>
@@ -260,9 +286,7 @@ const messages = defineMessages({
 				</div>
 				<div class="flex items-center gap-2 text-sm text-secondary">
 					<div
-						v-tooltip="
-							world.last_played ? dayjs(world.last_played).format('MMMM D, YYYY [at] h:mm A') : null
-						"
+						v-tooltip="world.last_played ? formatDateTime(world.last_played) : null"
 						class="w-fit shrink-0"
 						:class="{
 							'cursor-help smart-clickable:allow-pointer-events': world.last_played,
@@ -271,7 +295,7 @@ const messages = defineMessages({
 						<template v-if="world.last_played">
 							{{
 								formatMessage(commonMessages.playedLabel, {
-									time: formatRelativeTime(dayjs(world.last_played).toISOString()),
+									ago: formatRelativeTime(dayjs(world.last_played).toISOString()),
 								})
 							}}
 						</template>
@@ -396,8 +420,12 @@ const messages = defineMessages({
 								id: 'edit',
 								action: () => emit('edit'),
 								shown: !instancePath,
-								disabled: locked,
-								tooltip: locked ? formatMessage(messages.worldInUse) : undefined,
+								disabled: locked || managed,
+								tooltip: locked
+									? formatMessage(messages.worldInUse)
+									: managed
+										? formatMessage(messages.linkedServer)
+										: undefined,
 							},
 							{
 								id: 'open-folder',
@@ -432,8 +460,12 @@ const messages = defineMessages({
 								hoverFilled: true,
 								action: () => emit('delete'),
 								shown: !instancePath,
-								disabled: locked,
-								tooltip: locked ? formatMessage(messages.worldInUse) : undefined,
+								disabled: locked || managed,
+								tooltip: locked
+									? formatMessage(messages.worldInUse)
+									: managed
+										? formatMessage(messages.linkedServer)
+										: undefined,
 							},
 						]"
 					>

apps/app-frontend/src/helpers/analytics.ts

@@ -15,7 +15,7 @@ type AnalyticsEventMap = {
 	PageView: { path: string; fromPath: string; failed: unknown }
 	InstanceCreate: { source: string }
 	InstanceCreateStart: { source: string }
-	InstancePlay: InstanceProperties & { source: string }
+	InstanceStart: InstanceProperties & { source: string }
 	InstanceStop: Partial<InstanceProperties> & { source?: string }
 	InstanceDuplicate: InstanceProperties
 	InstanceRepair: InstanceProperties

apps/app-frontend/src/helpers/cache.js

@@ -8,6 +8,14 @@ export async function get_project_many(ids, cacheBehaviour) {
 	return await invoke('plugin:cache|get_project_many', { ids, cacheBehaviour })
 }
 
+export async function get_project_v3(id, cacheBehaviour) {
+	return await invoke('plugin:cache|get_project_v3', { id, cacheBehaviour })
+}
+
+export async function get_project_v3_many(ids, cacheBehaviour) {
+	return await invoke('plugin:cache|get_project_v3_many', { ids, cacheBehaviour })
+}
+
 export async function get_version(id, cacheBehaviour) {
 	return await invoke('plugin:cache|get_version', { id, cacheBehaviour })
 }
@@ -48,6 +56,28 @@ export async function get_search_results_many(ids, cacheBehaviour) {
 	return await invoke('plugin:cache|get_search_results_many', { ids, cacheBehaviour })
 }
 
+export async function get_search_results_v3(id, cacheBehaviour) {
+	return await invoke('plugin:cache|get_search_results_v3', { id, cacheBehaviour })
+}
+
+export async function get_search_results_v3_many(ids, cacheBehaviour) {
+	return await invoke('plugin:cache|get_search_results_v3_many', { ids, cacheBehaviour })
+}
+
 export async function purge_cache_types(cacheTypes) {
 	return await invoke('plugin:cache|purge_cache_types', { cacheTypes })
 }
+
+/**
+ * Get versions for a project (without changelogs for fast loading).
+ * Uses the cache system - versions are cached for 30 minutes.
+ * @param {string} projectId - The project ID
+ * @param {string} [cacheBehaviour] - Cache behaviour ('must_revalidate', etc.)
+ * @returns {Promise<Array|null>} Array of version objects (without changelogs) or null
+ */
+export async function get_project_versions(projectId, cacheBehaviour) {
+	return await invoke('plugin:cache|get_project_versions', {
+		projectId,
+		cacheBehaviour,
+	})
+}

apps/app-frontend/src/helpers/fetch.js

@@ -1,18 +0,0 @@
-import { getVersion } from '@tauri-apps/api/app'
-import { fetch } from '@tauri-apps/plugin-http'
-
-export const useFetch = async (url, item, isSilent) => {
-	try {
-		const version = await getVersion()
-		return await fetch(url, {
-			method: 'GET',
-			headers: { 'User-Agent': `modrinth/theseus/${version} (support@modrinth.com)` },
-		})
-	} catch (err) {
-		if (!isSilent) {
-			throw err
-		} else {
-			console.error(err)
-		}
-	}
-}

apps/app-frontend/src/helpers/pack.js

@@ -1,65 +0,0 @@
-/**
- * All theseus API calls return serialized values (both return values and errors);
- * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
- *  and deserialized into a usable JS object.
- */
-import { invoke } from '@tauri-apps/api/core'
-
-import { create } from './profile'
-
-// Installs pack from a version ID
-export async function create_profile_and_install(
-	projectId,
-	versionId,
-	packTitle,
-	iconUrl,
-	createInstanceCallback = () => {},
-) {
-	const location = {
-		type: 'fromVersionId',
-		project_id: projectId,
-		version_id: versionId,
-		title: packTitle,
-		icon_url: iconUrl,
-	}
-	const profile_creator = await invoke('plugin:pack|pack_get_profile_from_pack', { location })
-	const profile = await create(
-		profile_creator.name,
-		profile_creator.gameVersion,
-		profile_creator.modloader,
-		profile_creator.loaderVersion,
-		null,
-		true,
-	)
-	createInstanceCallback(profile)
-
-	return await invoke('plugin:pack|pack_install', { location, profile })
-}
-
-export async function install_to_existing_profile(projectId, versionId, title, profilePath) {
-	const location = {
-		type: 'fromVersionId',
-		project_id: projectId,
-		version_id: versionId,
-		title,
-	}
-	return await invoke('plugin:pack|pack_install', { location, profile: profilePath })
-}
-
-// Installs pack from a path
-export async function create_profile_and_install_from_file(path) {
-	const location = {
-		type: 'fromFile',
-		path: path,
-	}
-	const profile_creator = await invoke('plugin:pack|pack_get_profile_from_pack', { location })
-	const profile = await create(
-		profile_creator.name,
-		profile_creator.gameVersion,
-		profile_creator.modloader,
-		profile_creator.loaderVersion,
-		null,
-		true,
-	)
-	return await invoke('plugin:pack|pack_install', { location, profile })
-}

apps/app-frontend/src/helpers/pack.ts

@@ -0,0 +1,90 @@
+import { invoke } from '@tauri-apps/api/core'
+
+import { create } from './profile'
+import type { InstanceLoader } from './types'
+
+interface PackProfileCreator {
+	name: string
+	gameVersion: string
+	modloader: InstanceLoader
+	loaderVersion: string | null
+}
+
+interface PackLocationVersionId {
+	type: 'fromVersionId'
+	project_id: string
+	version_id: string
+	title: string
+	icon_url?: string
+}
+
+interface PackLocationFile {
+	type: 'fromFile'
+	path: string
+}
+
+export async function create_profile_and_install(
+	projectId: string,
+	versionId: string,
+	packTitle: string,
+	iconUrl?: string,
+	createInstanceCallback: (profile: string) => void = () => {},
+): Promise<void> {
+	const location: PackLocationVersionId = {
+		type: 'fromVersionId',
+		project_id: projectId,
+		version_id: versionId,
+		title: packTitle,
+		icon_url: iconUrl,
+	}
+	const profile_creator = await invoke<PackProfileCreator>(
+		'plugin:pack|pack_get_profile_from_pack',
+		{ location },
+	)
+	const profile = await create(
+		profile_creator.name,
+		profile_creator.gameVersion,
+		profile_creator.modloader,
+		profile_creator.loaderVersion,
+		null,
+		true,
+	)
+	createInstanceCallback(profile)
+
+	return await invoke('plugin:pack|pack_install', { location, profile })
+}
+
+export async function install_to_existing_profile(
+	projectId: string,
+	versionId: string,
+	title: string,
+	profilePath: string,
+): Promise<void> {
+	const location: PackLocationVersionId = {
+		type: 'fromVersionId',
+		project_id: projectId,
+		version_id: versionId,
+		title,
+	}
+	return await invoke('plugin:pack|pack_install', { location, profile: profilePath })
+}
+
+export async function create_profile_and_install_from_file(path: string): Promise<void> {
+	const location: PackLocationFile = {
+		type: 'fromFile',
+		path,
+	}
+	const profile_creator = await invoke<PackProfileCreator>(
+		'plugin:pack|pack_get_profile_from_pack',
+		{ location },
+	)
+	const profile = await create(
+		profile_creator.name,
+		profile_creator.gameVersion,
+		profile_creator.modloader,
+		profile_creator.loaderVersion,
+		null,
+		true,
+	)
+	return await invoke('plugin:pack|pack_install', { location, profile })
+}

apps/app-frontend/src/helpers/profile.js

@@ -1,207 +0,0 @@
-/**
- * All theseus API calls return serialized values (both return values and errors);
- * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
- *  and deserialized into a usable JS object.
- */
-import { invoke } from '@tauri-apps/api/core'
-
-import { install_to_existing_profile } from '@/helpers/pack.js'
-
-/// Add instance
-/*
-    name: String,           // the name of the profile, and relative path to create
-    game_version: String,   // the game version of the profile
-    modloader: ModLoader,   // the modloader to use
-    - ModLoader is an enum, with the following variants: Vanilla, Forge, Fabric, Quilt
-    loader_version: String, // the modloader version to use, set to "latest", "stable", or the ID of your chosen loader
-    icon: Path,  // the icon for the profile
-    - icon is a path to an image file, which will be copied into the profile directory
-*/
-
-export async function create(name, gameVersion, modloader, loaderVersion, icon, skipInstall) {
-	//Trim string name to avoid "Unable to find directory"
-	name = name.trim()
-	return await invoke('plugin:profile-create|profile_create', {
-		name,
-		gameVersion,
-		modloader,
-		loaderVersion,
-		icon,
-		skipInstall,
-	})
-}
-
-// duplicate a profile
-export async function duplicate(path) {
-	return await invoke('plugin:profile-create|profile_duplicate', { path })
-}
-
-// Remove a profile
-export async function remove(path) {
-	return await invoke('plugin:profile|profile_remove', { path })
-}
-
-// Get a profile by path
-// Returns a Profile
-export async function get(path) {
-	return await invoke('plugin:profile|profile_get', { path })
-}
-
-export async function get_many(paths) {
-	return await invoke('plugin:profile|profile_get_many', { paths })
-}
-
-// Get a profile's projects
-// Returns a map of a path to profile file
-export async function get_projects(path, cacheBehaviour) {
-	return await invoke('plugin:profile|profile_get_projects', { path, cacheBehaviour })
-}
-
-// Get a profile's full fs path
-// Returns a path
-export async function get_full_path(path) {
-	return await invoke('plugin:profile|profile_get_full_path', { path })
-}
-
-// Get's a mod's full fs path
-// Returns a path
-export async function get_mod_full_path(path, projectPath) {
-	return await invoke('plugin:profile|profile_get_mod_full_path', { path, projectPath })
-}
-
-// Get optimal java version from profile
-// Returns a java version
-export async function get_optimal_jre_key(path) {
-	return await invoke('plugin:profile|profile_get_optimal_jre_key', { path })
-}
-
-// Get a copy of the profile set
-// Returns hashmap of path -> Profile
-export async function list() {
-	return await invoke('plugin:profile|profile_list')
-}
-
-export async function check_installed(path, projectId) {
-	return await invoke('plugin:profile|profile_check_installed', { path, projectId })
-}
-
-// Installs/Repairs a profile
-export async function install(path, force) {
-	return await invoke('plugin:profile|profile_install', { path, force })
-}
-
-// Updates all of a profile's projects
-export async function update_all(path) {
-	return await invoke('plugin:profile|profile_update_all', { path })
-}
-
-// Updates a specified project
-export async function update_project(path, projectPath) {
-	return await invoke('plugin:profile|profile_update_project', { path, projectPath })
-}
-
-// Add a project to a profile from a version
-// Returns a path to the new project file
-export async function add_project_from_version(path, versionId) {
-	return await invoke('plugin:profile|profile_add_project_from_version', { path, versionId })
-}
-
-// Add a project to a profile from a path + project_type
-// Returns a path to the new project file
-export async function add_project_from_path(path, projectPath, projectType) {
-	return await invoke('plugin:profile|profile_add_project_from_path', {
-		path,
-		projectPath,
-		projectType,
-	})
-}
-
-// Toggle disabling a project
-export async function toggle_disable_project(path, projectPath) {
-	return await invoke('plugin:profile|profile_toggle_disable_project', { path, projectPath })
-}
-
-// Remove a project
-export async function remove_project(path, projectPath) {
-	return await invoke('plugin:profile|profile_remove_project', { path, projectPath })
-}
-
-// Update a managed Modrinth profile to a specific version
-export async function update_managed_modrinth_version(path, versionId) {
-	return await invoke('plugin:profile|profile_update_managed_modrinth_version', {
-		path,
-		versionId,
-	})
-}
-
-// Repair a managed Modrinth profile
-export async function update_repair_modrinth(path) {
-	return await invoke('plugin:profile|profile_repair_managed_modrinth', { path })
-}
-
-// Export a profile to .mrpack
-/// included_overrides is an array of paths to override folders to include (ie: 'mods', 'resource_packs')
-// Version id is optional (ie: 1.1.5)
-export async function export_profile_mrpack(
-	path,
-	exportLocation,
-	includedOverrides,
-	versionId,
-	description,
-	name,
-) {
-	return await invoke('plugin:profile|profile_export_mrpack', {
-		path,
-		exportLocation,
-		includedOverrides,
-		versionId,
-		description,
-		name,
-	})
-}
-
-// Given a folder path, populate an array of all the subfolders
-// Intended to be used for finding potential override folders
-// profile
-// -- mods
-// -- resourcepacks
-// -- file1
-// => [mods, resourcepacks]
-// allows selection for 'included_overrides' in export_profile_mrpack
-export async function get_pack_export_candidates(profilePath) {
-	return await invoke('plugin:profile|profile_get_pack_export_candidates', { profilePath })
-}
-
-// Run Minecraft using a pathed profile
-// Returns PID of child
-export async function run(path) {
-	return await invoke('plugin:profile|profile_run', { path })
-}
-
-export async function kill(path) {
-	return await invoke('plugin:profile|profile_kill', { path })
-}
-
-// Edits a profile
-export async function edit(path, editProfile) {
-	return await invoke('plugin:profile|profile_edit', { path, editProfile })
-}
-
-// Edits a profile's icon
-export async function edit_icon(path, iconPath) {
-	return await invoke('plugin:profile|profile_edit_icon', { path, iconPath })
-}
-
-export async function finish_install(instance) {
-	if (instance.install_stage !== 'pack_installed') {
-		let linkedData = instance.linked_data
-		await install_to_existing_profile(
-			linkedData.project_id,
-			linkedData.version_id,
-			instance.name,
-			instance.path,
-		)
-	} else {
-		await install(instance.path, false)
-	}
-}

apps/app-frontend/src/helpers/profile.ts

@@ -0,0 +1,298 @@
+/**
+ * All theseus API calls return serialized values (both return values and errors);
+ * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
+ *  and deserialized into a usable JS object.
+ */
+import type { Labrinth } from '@modrinth/api-client'
+import type { ContentItem, ContentOwner } from '@modrinth/ui'
+import { invoke } from '@tauri-apps/api/core'
+
+import { install_to_existing_profile } from '@/helpers/pack'
+
+import type {
+	CacheBehaviour,
+	ContentFile,
+	ContentFileProjectType,
+	GameInstance,
+	InstanceLoader,
+} from './types'
+
+// Add instance
+/*
+    name: String,           // the name of the profile, and relative path to create
+    game_version: String,   // the game version of the profile
+    modloader: ModLoader,   // the modloader to use
+    - ModLoader is an enum, with the following variants: Vanilla, Forge, Fabric, Quilt
+    loader_version: String, // the modloader version to use, set to "latest", "stable", or the ID of your chosen loader
+    icon: Path,  // the icon for the profile
+    - icon is a path to an image file, which will be copied into the profile directory
+*/
+
+export async function create(
+	name: string,
+	gameVersion: string,
+	modloader: InstanceLoader,
+	loaderVersion: string | null,
+	icon: string | null,
+	skipInstall: boolean,
+	linkedData?: { project_id: string; version_id: string; locked: boolean } | null,
+): Promise<string> {
+	// Trim string name to avoid "Unable to find directory"
+	name = name.trim()
+	return await invoke('plugin:profile-create|profile_create', {
+		name,
+		gameVersion,
+		modloader,
+		loaderVersion,
+		icon,
+		skipInstall,
+		linkedData,
+	})
+}
+
+// duplicate a profile
+export async function duplicate(path: string): Promise<string> {
+	return await invoke('plugin:profile-create|profile_duplicate', { path })
+}
+
+// Remove a profile
+export async function remove(path: string): Promise<void> {
+	return await invoke('plugin:profile|profile_remove', { path })
+}
+
+// Get a profile by path
+// Returns a Profile
+export async function get(path: string): Promise<GameInstance | null> {
+	return await invoke('plugin:profile|profile_get', { path })
+}
+
+export async function get_many(paths: string[]): Promise<GameInstance[]> {
+	return await invoke('plugin:profile|profile_get_many', { paths })
+}
+
+// Get a profile's projects
+// Returns a map of a path to profile file
+export async function get_projects(
+	path: string,
+	cacheBehaviour?: CacheBehaviour,
+): Promise<Record<string, ContentFile>> {
+	return await invoke('plugin:profile|profile_get_projects', { path, cacheBehaviour })
+}
+
+// Get just the installed project IDs for a profile (lightweight, skips update checks)
+export async function get_installed_project_ids(path: string): Promise<string[]> {
+	return await invoke('plugin:profile|profile_get_installed_project_ids', { path })
+}
+
+// Get content items with rich metadata for a profile
+// Returns content items filtered to exclude modpack files (if linked),
+// sorted alphabetically by project name
+export async function get_content_items(
+	path: string,
+	cacheBehaviour?: CacheBehaviour,
+): Promise<ContentItem[]> {
+	return await invoke('plugin:profile|profile_get_content_items', { path, cacheBehaviour })
+}
+
+// Linked modpack info returned from backend
+export interface LinkedModpackInfo {
+	project: Labrinth.Projects.v2.Project
+	version: Labrinth.Versions.v2.Version
+	owner: ContentOwner | null
+	has_update: boolean
+	update_version_id: string | null
+	update_version: Labrinth.Versions.v2.Version | null
+}
+
+// Get linked modpack info for a profile
+// Returns project, version, and owner information for the linked modpack,
+// or null if the profile is not linked to a modpack
+export async function get_linked_modpack_info(
+	path: string,
+	cacheBehaviour?: CacheBehaviour,
+): Promise<LinkedModpackInfo | null> {
+	return await invoke('plugin:profile|profile_get_linked_modpack_info', { path, cacheBehaviour })
+}
+
+// Get content items that are part of the linked modpack
+// Returns the modpack's dependencies as ContentItem list
+// Returns empty array if the profile is not linked to a modpack
+export async function get_linked_modpack_content(
+	path: string,
+	cacheBehaviour?: CacheBehaviour,
+): Promise<ContentItem[]> {
+	return await invoke('plugin:profile|profile_get_linked_modpack_content', { path, cacheBehaviour })
+}
+
+// Convert a list of dependencies into ContentItems with rich metadata
+export async function get_dependencies_as_content_items(
+	dependencies: Labrinth.Versions.v3.Dependency[],
+	cacheBehaviour?: CacheBehaviour,
+): Promise<ContentItem[]> {
+	return await invoke('plugin:profile|profile_get_dependencies_as_content_items', {
+		dependencies,
+		cacheBehaviour,
+	})
+}
+
+// Get a profile's full fs path
+// Returns a path
+export async function get_full_path(path: string): Promise<string> {
+	return await invoke('plugin:profile|profile_get_full_path', { path })
+}
+
+// Get's a mod's full fs path
+// Returns a path
+export async function get_mod_full_path(path: string, projectPath: string): Promise<string> {
+	return await invoke('plugin:profile|profile_get_mod_full_path', { path, projectPath })
+}
+
+// Get optimal java version from profile
+// Returns a java version
+export async function get_optimal_jre_key(path: string): Promise<string | null> {
+	return await invoke('plugin:profile|profile_get_optimal_jre_key', { path })
+}
+
+// Get a copy of the profile set
+// Returns hashmap of path -> Profile
+export async function list(): Promise<GameInstance[]> {
+	return await invoke('plugin:profile|profile_list')
+}
+
+export async function check_installed(path: string, projectId: string): Promise<boolean> {
+	return await invoke('plugin:profile|profile_check_installed', { path, projectId })
+}
+
+export async function check_installed_batch(projectId: string): Promise<Record<string, boolean>> {
+	return await invoke('plugin:profile|profile_check_installed_batch', { projectId })
+}
+
+// Installs/Repairs a profile
+export async function install(path: string, force: boolean): Promise<void> {
+	return await invoke('plugin:profile|profile_install', { path, force })
+}
+
+// Updates all of a profile's projects
+export async function update_all(path: string): Promise<Record<string, string>> {
+	return await invoke('plugin:profile|profile_update_all', { path })
+}
+
+// Updates a specified project
+export async function update_project(path: string, projectPath: string): Promise<string> {
+	return await invoke('plugin:profile|profile_update_project', { path, projectPath })
+}
+
+// Add a project to a profile from a version
+// Returns a path to the new project file
+export async function add_project_from_version(path: string, versionId: string): Promise<string> {
+	return await invoke('plugin:profile|profile_add_project_from_version', { path, versionId })
+}
+
+// Add a project to a profile from a path + project_type
+// Returns a path to the new project file
+export async function add_project_from_path(
+	path: string,
+	projectPath: string,
+	projectType?: ContentFileProjectType,
+): Promise<string> {
+	return await invoke('plugin:profile|profile_add_project_from_path', {
+		path,
+		projectPath,
+		projectType,
+	})
+}
+
+// Toggle disabling a project
+export async function toggle_disable_project(path: string, projectPath: string): Promise<string> {
+	return await invoke('plugin:profile|profile_toggle_disable_project', { path, projectPath })
+}
+
+// Remove a project
+export async function remove_project(path: string, projectPath: string): Promise<void> {
+	return await invoke('plugin:profile|profile_remove_project', { path, projectPath })
+}
+
+// Update a managed Modrinth profile to a specific version
+export async function update_managed_modrinth_version(
+	path: string,
+	versionId: string,
+): Promise<void> {
+	return await invoke('plugin:profile|profile_update_managed_modrinth_version', {
+		path,
+		versionId,
+	})
+}
+
+// Repair a managed Modrinth profile
+export async function update_repair_modrinth(path: string): Promise<void> {
+	return await invoke('plugin:profile|profile_repair_managed_modrinth', { path })
+}
+
+// Export a profile to .mrpack
+// included_overrides is an array of paths to override folders to include (ie: 'mods', 'resource_packs')
+// Version id is optional (ie: 1.1.5)
+export async function export_profile_mrpack(
+	path: string,
+	exportLocation: string,
+	includedOverrides: string[],
+	versionId?: string,
+	description?: string,
+	name?: string,
+): Promise<void> {
+	return await invoke('plugin:profile|profile_export_mrpack', {
+		path,
+		exportLocation,
+		includedOverrides,
+		versionId,
+		description,
+		name,
+	})
+}
+
+// Given a folder path, populate an array of all the subfolders
+// Intended to be used for finding potential override folders
+// profile
+// -- mods
+// -- resourcepacks
+// -- file1
+// => [mods, resourcepacks]
+// allows selection for 'included_overrides' in export_profile_mrpack
+export async function get_pack_export_candidates(profilePath: string): Promise<string[]> {
+	return await invoke('plugin:profile|profile_get_pack_export_candidates', { profilePath })
+}
+
+// Run Minecraft using a pathed profile
+// Returns PID of child
+export async function run(path: string, serverAddress: string | null = null): Promise<unknown> {
+	return await invoke('plugin:profile|profile_run', { path, serverAddress })
+}
+
+export async function kill(path: string): Promise<void> {
+	return await invoke('plugin:profile|profile_kill', { path })
+}
+
+// Edits a profile
+export async function edit(path: string, editProfile: Partial<GameInstance>): Promise<void> {
+	return await invoke('plugin:profile|profile_edit', { path, editProfile })
+}
+
+// Edits a profile's icon
+export async function edit_icon(path: string, iconPath: string | null): Promise<void> {
+	return await invoke('plugin:profile|profile_edit_icon', { path, iconPath })
+}
+
+export async function finish_install(instance: GameInstance): Promise<void> {
+	if (instance.install_stage !== 'pack_installed') {
+		const linkedData = instance.linked_data
+		if (linkedData) {
+			await install_to_existing_profile(
+				linkedData.project_id,
+				linkedData.version_id,
+				instance.name,
+				instance.path,
+			)
+		}
+	} else {
+		await install(instance.path, false)
+	}
+}

apps/app-frontend/src/helpers/types.d.ts

@@ -49,17 +49,10 @@ type LinkedData = {
 type InstanceLoader = 'vanilla' | 'forge' | 'fabric' | 'quilt' | 'neoforge'
 
 type ContentFile = {
-	hash: string
-	file_name: string
-	size: number
-	metadata?: FileMetadata
-	update_version_id?: string
-	project_type: ContentFileProjectType
-}
-
-type FileMetadata = {
-	project_id: string
-	version_id: string
+	metadata?: {
+		project_id: string
+		version_id: string
+	}
 }
 
 type ContentFileProjectType = 'mod' | 'datapack' | 'resourcepack' | 'shaderpack'
@@ -139,4 +132,5 @@ type AppSettings = {
 export type InstanceSettingsTabProps = {
 	instance: GameInstance
 	offline?: boolean
+	isMinecraftServer?: boolean
 }

apps/app-frontend/src/helpers/worlds.ts

@@ -141,7 +141,12 @@ export async function add_server_to_profile(
 	address: string,
 	packStatus: ServerPackStatus,
 ): Promise<number> {
-	return await invoke('plugin:worlds|add_server_to_profile', { path, name, address, packStatus })
+	return await invoke('plugin:worlds|add_server_to_profile', {
+		path,
+		name,
+		address,
+		packStatus,
+	})
 }
 
 export async function edit_server_in_profile(
@@ -212,6 +217,150 @@ export function isServerWorld(world: World): world is ServerWorld {
 	return world.type === 'server'
 }
 
+const DEFAULT_MINECRAFT_SERVER_PORT = 25565
+
+function parseServerPort(port: string): number | null {
+	const parsed = Number.parseInt(port, 10)
+	return Number.isInteger(parsed) && parsed > 0 && parsed <= 65535 ? parsed : null
+}
+
+function parseServerHost(address: string): string {
+	const trimmedAddress = address.trim()
+	if (!trimmedAddress) return ''
+
+	if (trimmedAddress.startsWith('[')) {
+		const closingBracket = trimmedAddress.indexOf(']')
+		if (closingBracket > 0) {
+			return trimmedAddress.slice(1, closingBracket).trim().toLowerCase()
+		}
+	}
+
+	const firstColon = trimmedAddress.indexOf(':')
+	const lastColon = trimmedAddress.lastIndexOf(':')
+
+	if (firstColon !== -1 && firstColon === lastColon) {
+		return trimmedAddress.slice(0, firstColon).trim().toLowerCase()
+	}
+
+	return trimmedAddress.toLowerCase()
+}
+
+function isIPv4Host(host: string): boolean {
+	const segments = host.split('.')
+	if (segments.length !== 4) return false
+
+	return segments.every((segment) => {
+		if (!/^\d+$/.test(segment)) return false
+		const value = Number.parseInt(segment, 10)
+		return value >= 0 && value <= 255
+	})
+}
+
+/**
+ * Normalization converts addresses to a canonical form (lowercase-host:port, default port 25565)
+ */
+export function normalizeServerAddress(address: string): string {
+	const trimmedAddress = address.trim()
+	const host = parseServerHost(trimmedAddress)
+	if (!host) return ''
+	let port = DEFAULT_MINECRAFT_SERVER_PORT
+
+	// ipv6 address
+	if (trimmedAddress.startsWith('[')) {
+		const closingBracket = trimmedAddress.indexOf(']')
+		if (closingBracket > 0) {
+			const suffix = trimmedAddress.slice(closingBracket + 1)
+			if (suffix.startsWith(':')) {
+				const parsedPort = parseServerPort(suffix.slice(1))
+				if (parsedPort != null) {
+					port = parsedPort
+				}
+			}
+		}
+
+		// ipv4 address or hostname
+	} else {
+		const firstColon = trimmedAddress.indexOf(':')
+		const lastColon = trimmedAddress.lastIndexOf(':')
+		if (firstColon !== -1 && firstColon === lastColon) {
+			const parsedPort = parseServerPort(trimmedAddress.slice(firstColon + 1))
+			if (parsedPort != null) {
+				port = parsedPort
+			}
+		}
+	}
+
+	return `${host}:${port}`
+}
+
+/**
+ * Domain key used for deduping server entries by removing a single leading subdomain.
+ * Example: test.cobblemon.gg and cobblemon.gg map to cobblemon.gg
+ */
+export function getServerDomainKey(address: string): string {
+	const normalizedAddress = normalizeServerAddress(address)
+	if (!normalizedAddress) return ''
+
+	const separator = normalizedAddress.lastIndexOf(':')
+	if (separator <= 0 || separator === normalizedAddress.length - 1) return normalizedAddress
+
+	const host = normalizedAddress.slice(0, separator).replace(/\.+$/, '')
+	if (!host) return normalizedAddress
+	if (host.includes(':') || isIPv4Host(host)) return normalizedAddress
+
+	const segments = host.split('.').filter(Boolean)
+	if (segments.length <= 2) return host
+
+	return segments.slice(1).join('.')
+}
+
+export function resolveManagedServerWorld(
+	worlds: World[],
+	managedName: string | null | undefined,
+	managedAddress: string | null | undefined,
+): ServerWorld | null {
+	if (!managedName || !managedAddress) return null
+
+	const normalizedManagedAddress = normalizeServerAddress(managedAddress)
+	if (!normalizedManagedAddress) return null
+
+	const servers = worlds
+		.filter(isServerWorld)
+		.slice()
+		.sort((a, b) => a.index - b.index)
+
+	const exactMatch = servers.find(
+		(server) =>
+			server.name === managedName &&
+			normalizeServerAddress(server.address) === normalizedManagedAddress,
+	)
+	if (exactMatch) return exactMatch
+
+	return (
+		servers.find((server) => normalizeServerAddress(server.address) === normalizedManagedAddress) ??
+		null
+	)
+}
+
+export async function getServerLatency(
+	address: string,
+	protocolVersion: ProtocolVersion | null = null,
+): Promise<number | undefined> {
+	const pings: number[] = []
+	for (let i = 0; i < 3; i++) {
+		try {
+			const status = await get_server_status(address, protocolVersion)
+			if (status.ping != null) {
+				pings.push(status.ping)
+			}
+		} catch {
+			// Ignore individual ping failures
+		}
+	}
+	if (pings.length === 0) return undefined
+	return Math.round(pings.reduce((sum, p) => sum + p, 0) / pings.length)
+}
+
 export async function refreshServerData(
 	serverData: ServerData,
 	protocolVersion: ProtocolVersion | null,

apps/app-frontend/src/i18n.config.ts

@@ -1,4 +1,5 @@
 import { buildLocaleMessages, createMessageCompiler, type CrowdinMessages } from '@modrinth/ui'
+import { uiLocaleModulesEager } from '@modrinth/ui/src/locales.eager.ts'
 import { createI18n } from 'vue-i18n'
 
 const localeModules = import.meta.glob<{ default: CrowdinMessages }>('./locales/*/index.json', {
@@ -12,7 +13,7 @@ const i18n = createI18n({
 	messageCompiler: createMessageCompiler(),
 	missingWarn: false,
 	fallbackWarn: false,
-	messages: buildLocaleMessages(localeModules),
+	messages: buildLocaleMessages(localeModules, uiLocaleModulesEager),
 })
 
 export default i18n

apps/app-frontend/src/locales/ar-SA/index.json

@@ -14,11 +14,20 @@
   "app.modal.install-to-play.mod-count": {
     "message": ""
   },
+  "app.modal.install-to-play.shared-instance": {
+    "message": "حُزْمَة مشاركة"
+  },
+  "app.modal.install-to-play.shared-server-instance": {
+    "message": "حُزْمَة خادم مشاركة"
+  },
+  "app.modal.update-to-play.added-count": {
+    "message": "{count} مضاف"
+  },
   "app.modal.update-to-play.diff-type.added": {
-    "message": "تم إضافة"
+    "message": "تمت الإضافة"
   },
   "app.modal.update-to-play.diff-type.removed": {
-    "message": "تم إزالة"
+    "message": "تمت الإزالة"
   },
   "app.modal.update-to-play.diff-type.updated": {
     "message": "تم تحديث"
@@ -26,9 +35,21 @@
   "app.modal.update-to-play.header": {
     "message": "حدث للعب"
   },
+  "app.modal.update-to-play.published-date": {
+    "message": "{date, date, long}"
+  },
+  "app.modal.update-to-play.removed-count": {
+    "message": "{count} مزال"
+  },
   "app.modal.update-to-play.update-required": {
     "message": "يلزم التحديث"
   },
+  "app.modal.update-to-play.update-required-description": {
+    "message": "هناك تحديث لازم للعب بـ {name}. الرجاء التحديث إلى آخر اصدار لتشغيل اللعبة."
+  },
+  "app.modal.update-to-play.updated-count": {
+    "message": "{count} حُدِّث"
+  },
   "app.settings.developer-mode-enabled": {
     "message": "تم تفعيل وضع المطوّر."
   },
@@ -56,33 +77,6 @@
   "app.settings.tabs.resource-management": {
     "message": "إدارة الموارد"
   },
-  "app.update-toast.body": {
-    "message": "تطبيق Modrinth الإصدار {version} جاهز للتثبيت!\nأعد التحميل لتحديث التطبيق الآن، أو سيتم التحديث تلقائيًا عند إغلاق تطبيق Modrinth."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "تطبيق Modrinth الإصدار {version} جاهز للتثبيت!\nأعد التحميل لتحديث التطبيق الآن، أو سيتم التحديث تلقائيًا عند إغلاق تطبيق Modrinth."
-  },
-  "app.update-toast.body.metered": {
-    "message": "تطبيق Modrinth الإصدار {version} متاح الآن!\nنظرًا لأنك تستخدم شبكة محدودة البيانات، لم نقم بتنزيل التحديث تلقائيًا.\n"
-  },
-  "app.update-toast.changelog": {
-    "message": "سجلّ التغييرات"
-  },
-  "app.update-toast.download": {
-    "message": "تنزيل ({size})"
-  },
-  "app.update-toast.downloading": {
-    "message": "جار التنزيل..."
-  },
-  "app.update-toast.reload": {
-    "message": "إعادة تحميل"
-  },
-  "app.update-toast.title": {
-    "message": "تحديث متاح"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "اكتمل التنزيل"
-  },
   "app.update.complete-toast.text": {
     "message": "انقر هنا لعرض سجلّ التغييرات."
   },
@@ -210,7 +204,7 @@
     "message": "الاسم"
   },
   "instance.server-modal.placeholder-name": {
-    "message": "خادم ماينكرافت"
+    "message": "خادم Minecraft"
   },
   "instance.server-modal.resource-pack": {
     "message": "حزمة الموارد"
@@ -312,7 +306,7 @@
     "message": "تثبيت"
   },
   "instance.settings.tabs.installation.change-version.already-installed.modded": {
-    "message": "{platform} {version} لماينكرافت {game_version} مثبت بالفعل"
+    "message": "{platform} {version} لـ Minecraft{game_version} مثبت بالفعل"
   },
   "instance.settings.tabs.installation.change-version.already-installed.vanilla": {
     "message": "فانيلا {game_version} مُثبّتة بالفعل"
@@ -354,7 +348,7 @@
     "message": "إصدار {loader}"
   },
   "instance.settings.tabs.installation.minecraft-version": {
-    "message": "ماين كرافت {version}"
+    "message": "Minecraft {version}"
   },
   "instance.settings.tabs.installation.no-connection": {
     "message": "تعذّر جلب تفاصيل حزمة المودات المرتبطة. يرجى التحقق من اتصالك بالإنترنت."

apps/app-frontend/src/locales/cs-CZ/index.json

@@ -14,12 +14,6 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural,one  {#mód} other  {#módy}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Tento server k hraní vyžaduje módy. Klikni na instalovat pro získání potřebných módů z Modrinth."
-  },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} dnes s vámi sdílel tuto instanci."
-  },
   "app.modal.install-to-play.shared-instance": {
     "message": "Sdílená instance"
   },
@@ -83,39 +77,6 @@
   "app.settings.tabs.resource-management": {
     "message": "Správa zdrojů"
   },
-  "app.update-toast.body": {
-    "message": "Aplikace Modrinth v{version} je připravena k instalaci! Nainstalujte aktualizaci nyní nebo automaticky po zavření aplikace Modrinth."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "Stahování aplikace Modrinth v{version} bylo dokončeno. Nainstalujte aktualizaci nyní nebo automaticky po zavření aplikace Modrinth."
-  },
-  "app.update-toast.body.linux": {
-    "message": "Modrinth App v{version} je k dispozici. Aktualizujte pomocí svého správce balíčků, abyste získali nejnovější funkce a opravy!"
-  },
-  "app.update-toast.body.metered": {
-    "message": "Aplikace Modrinth v{version} je nyní k dispozici! Protože jste v měřené síti, nebyla stažena automaticky."
-  },
-  "app.update-toast.changelog": {
-    "message": "Seznam změn"
-  },
-  "app.update-toast.download": {
-    "message": "Stahování ({size})"
-  },
-  "app.update-toast.download-page": {
-    "message": "Stáhnout"
-  },
-  "app.update-toast.downloading": {
-    "message": "Stahování..."
-  },
-  "app.update-toast.reload": {
-    "message": "Načíst znovu"
-  },
-  "app.update-toast.title": {
-    "message": "Aktualizace je k dispozici"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Stahování bylo dokončeno"
-  },
   "app.update.complete-toast.text": {
     "message": "Kliknutím sem zobrazíte seznam změn."
   },

apps/app-frontend/src/locales/da-DK/index.json

@@ -15,7 +15,7 @@
     "message": "{count, plural, one {# mod} other {# mods}}"
   },
   "app.modal.install-to-play.server-requires-mods": {
-    "message": "Denne server kræver mods for at spille. Klik installer for at sætte op filerne som er krævet fra Modrinth."
+    "message": "Denne server kræver mods for at spille. Tryk på installer for at sætte de krævet filler fra modrinth op, så lancer direkte til serveren."
   },
   "app.modal.update-to-play.added-count": {
     "message": "{count} tilføjet"
@@ -32,6 +32,9 @@
   "app.modal.update-to-play.header": {
     "message": "Opdater for at spille"
   },
+  "app.modal.update-to-play.published-date": {
+    "message": "{date, date, long}"
+  },
   "app.modal.update-to-play.removed-count": {
     "message": "{count} fjernet"
   },
@@ -71,39 +74,6 @@
   "app.settings.tabs.resource-management": {
     "message": "Ressourcestyring"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} er allerede installeret! Genindlæs for at opdatere nu, eller automatisk når du lukker Modrinth App."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} er færdig med at download. Genindlæs for at opdatere nu, eller automatisk når du lukker Modrinth App."
-  },
-  "app.update-toast.body.linux": {
-    "message": "Modrinth App v{version} er nu tilgængelig. Brug din pakke-manager til at opdatere for de nyeste features og fejlrettelser!"
-  },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version} er nu tilgængelig! Siden du er på et begrænset netværk, vi downloadede den ikke automatisk."
-  },
-  "app.update-toast.changelog": {
-    "message": "Ændringslog"
-  },
-  "app.update-toast.download": {
-    "message": "Download ({size})"
-  },
-  "app.update-toast.download-page": {
-    "message": "Download"
-  },
-  "app.update-toast.downloading": {
-    "message": "Downloader..."
-  },
-  "app.update-toast.reload": {
-    "message": "Geninlæs"
-  },
-  "app.update-toast.title": {
-    "message": "Opdatering tilgængelig"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Download færdiggjort"
-  },
   "app.update.complete-toast.text": {
     "message": "Klik her for at vise ændringslog."
   },

apps/app-frontend/src/locales/de-CH/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Authentifizierungsserver sind nicht erreichbar"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Inhalte benötigt"
+  },
   "app.modal.install-to-play.header": {
     "message": "Installieren zum Spielen"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# Mod} other {# Mods}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Dieser Server benötigt Mods zum spielen. Klicke auf Installieren um die nötigen Dateien von Modrinth einzurichten."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Benötigtes Modpack"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} hat diese Instanz heute mit dir geteilt."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Dieser Server benötigt Mods zum spielen. Klicke auf Installieren um die nötigen Dateien von Modrinth herunterzuladen und dannach direkt dem Server beizutreten."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Geteilte Instanz"
@@ -26,8 +29,11 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Geteilte Server Instanz"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Inhalte ansehen"
+  },
   "app.modal.update-to-play.added-count": {
-    "message": "{count} hinzugefügt"
+    "message": "{count} hinzuäfüägt"
   },
   "app.modal.update-to-play.diff-type.added": {
     "message": "Hinzugefügt"
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Ressourcenmanagement"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} ist bereit zur Installation! Lade die App neu, oder schliesse sie, um zu aktualisieren."
+  "app.update-popup.body": {
+    "message": "Modrinth App v{version} ist bereit zur Installation! Lade die App neu um jetzt zu aktualisieren, oder automatisch nach dem schliessen der Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} wurde heruntergeladen. Lade die App neu, oder schliesse sie, um zu aktualisieren."
+  "app.update-popup.body.download-complete": {
+    "message": "Modrinth App v{version} wurde heruntergeladen. Lade die App neu um jetzt zu aktualisieren, oder automatisch nach dem schliessen der Modrinth App."
   },
-  "app.update-toast.body.linux": {
-    "message": "Modrinth App v{version} ist verfügbar. Benutze deinen Paketmanager zum aktualisieren um die neusten Features und Bugfixes zu erhalten!"
+  "app.update-popup.body.linux": {
+    "message": "Modrinth App v{version} ist verfügbar. Benutze deinen Paketmanager zum aktualisieren, um die neusten Features und Bugfixes zu erhalten!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version} ist jetzt verfügbar! Da du in einem begrenzten Netzwerk bist, haben wir es nicht automatisch heruntergeladen."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Änderungen"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Herunterladen ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Herunterladen"
+  "app.update-popup.download-complete": {
+    "message": "Download abgeschlossen"
   },
-  "app.update-toast.downloading": {
-    "message": "Lade herunter..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Neu Laden"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Aktualisierung verfügbar"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Download abgeschlossen"
-  },
   "app.update.complete-toast.text": {
     "message": "Klicke Hier um die Änderungen zu sehen."
   },
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(unbekannte Version)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Diese Instanz ist mit einem Server verknüpft, was bedeutet, dass du die Minecraft Version nicht ändern kannst. Das trennen der Verknüpfung trennt diese Instanz permanent vom Server."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Diese Instanz ist mit einem Server verknüpft, was bedeutet, dass du Mods nicht aktualisieren, und den Modloader oder die Minecraft Version nicht ändern kannst. Das trennen der Verknüpfung trennt diese Instanz permanent vom Server."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Serververknüpfung trennen"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Verlinking der Instanz trennen"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Server ist inkompatibel"
   },
+  "instance.worlds.linked_server": {
+    "message": "Von Serverprojekt verwaltet"
+  },
   "instance.worlds.no_contact": {
     "message": "Server konnte nicht erreicht werden"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Mit Instanz synchronisieren"
+  },
+  "search.filter.locked.server": {
+    "message": "Von Server bereitgestellt"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Nur Clientseitige Mods können der Serverinstanz hinzugefügt werden"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Spielversion vom Server bereitgestellt"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Loader vom Server bereitgestellt"
   }
 }

apps/app-frontend/src/locales/de-DE/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Authentifizierungsserver sind nicht erreichbar"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Inhalte benötigt"
+  },
   "app.modal.install-to-play.header": {
     "message": "Installieren zum Spielen"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# Mod} other {# Mods}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Dieser Server benötigt Mods zum Spielen. Klick auf „Installieren“ um die erforderlichen Dateien von Modrinth zu installieren."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Benötigtes Modpack"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} hat diese Instanz heute mit dir geteilt."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Dieser Server benötigt Mods zum Spielen. Klicke auf Installieren um die nötigen Dateien von Modrinth herunterzuladen und dannach direkt dem Server beizutreten."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Geteilte Instanz"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Geteilte Serverinstanz"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Inhalte ansehen"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} hinzugefügt"
   },
@@ -83,38 +89,32 @@
   "app.settings.tabs.resource-management": {
     "message": "Ressourcenmanagement"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Modrinth App v{version} ist bereit zur Installation! Neu laden, um jetzt zu aktualisieren, oder automatisch, wenn du die Modrinth App schließt."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Modrinth App v{version} wurde heruntergeladen. Neu laden, um jetzt zu aktualisieren, oder automatisch, wenn du die Modrinth App schließt."
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Modrinth App v{version} ist verfügbar. Verwende deinen Paketmanager, um die neuesten Funktionen und Fehlerbehebungen zu installieren!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version} ist jetzt verfügbar! Da du ein getaktetes Netzwerk nutzt, haben wir den Download nicht automatisch gestartet."
   },
-  "app.update-toast.changelog": {
-    "message": "Änderungsverlauf"
+  "app.update-popup.changelog": {
+    "message": "Änderungen"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Herunterladen ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Herunterladen"
+  "app.update-popup.download-complete": {
+    "message": "Download abgeschlossen"
   },
-  "app.update-toast.downloading": {
-    "message": "Wird Heruntergeladen..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Neu laden"
   },
-  "app.update-toast.title": {
-    "message": "Update verfügbar"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Download abgeschlossen"
+  "app.update-popup.title": {
+    "message": "Aktualisierung verfügbar"
   },
   "app.update.complete-toast.text": {
     "message": "Hier klicken, um das Änderungsprotokoll anzuzeigen."
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(unbekannte Version)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Diese Instanz ist mit einem Server verknüpft, was bedeutet, dass du die Minecraft-Version nicht ändern kannst. Durch das Aufheben der Verknüpfung wird diese Instanz dauerhaft vom Server getrennt."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Diese Instanz ist mit einem Server verknüpft, was bedeutet, dass Mods nicht aktualisiert werden können und du den Mod-Loader oder die Minecraft-Version nicht ändern kannst. Durch das Aufheben der Verknüpfung wird diese Instanz dauerhaft vom Server getrennt."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Vom Server trennen"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Verknüpfung der Instanz trennen"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Server ist nicht kompatibel"
   },
+  "instance.worlds.linked_server": {
+    "message": "Von Serverprojekt verwaltet"
+  },
   "instance.worlds.no_contact": {
     "message": "Server konnte nicht erreicht werden"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Mit Instanz synchronisieren"
+  },
+  "search.filter.locked.server": {
+    "message": "Vom Server vorgegeben"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Nur clientseitige Mods können der Serverinstanz hinzugefügt werden"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Spielversion vom Server vorgegeben"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Loader vom Server vorgegeben"
   }
 }

apps/app-frontend/src/locales/en-US/index.json

@@ -5,6 +5,81 @@
   "app.auth-servers.unreachable.header": {
     "message": "Cannot reach authentication servers"
   },
+  "app.export-modal.description-placeholder": {
+    "message": "Enter modpack description..."
+  },
+  "app.export-modal.export-button": {
+    "message": "Export"
+  },
+  "app.export-modal.header": {
+    "message": "Export modpack"
+  },
+  "app.export-modal.modpack-name-label": {
+    "message": "Modpack Name"
+  },
+  "app.export-modal.modpack-name-placeholder": {
+    "message": "Modpack name"
+  },
+  "app.export-modal.select-files-label": {
+    "message": "Select files and folders to include in pack"
+  },
+  "app.export-modal.version-number-label": {
+    "message": "Version number"
+  },
+  "app.export-modal.version-number-placeholder": {
+    "message": "1.0.0"
+  },
+  "app.instance.confirm-delete.admonition-body": {
+    "message": "All data for your instance will be permanently deleted, including your worlds, configs, and all installed content."
+  },
+  "app.instance.confirm-delete.admonition-header": {
+    "message": "This action cannot be undone"
+  },
+  "app.instance.confirm-delete.delete-button": {
+    "message": "Delete instance"
+  },
+  "app.instance.confirm-delete.header": {
+    "message": "Delete instance"
+  },
+  "app.instance.mods.content-type-project": {
+    "message": "project"
+  },
+  "app.instance.mods.copy-link": {
+    "message": "Copy link"
+  },
+  "app.instance.mods.installing": {
+    "message": "Installing..."
+  },
+  "app.instance.mods.modpack-fallback": {
+    "message": "Modpack"
+  },
+  "app.instance.mods.project-was-added": {
+    "message": "\"{name}\" was added"
+  },
+  "app.instance.mods.projects-were-added": {
+    "message": "{count} projects were added"
+  },
+  "app.instance.mods.share-text": {
+    "message": "Check out the projects I'm using in my modpack!"
+  },
+  "app.instance.mods.share-title": {
+    "message": "Sharing modpack content"
+  },
+  "app.instance.mods.show-file": {
+    "message": "Show file"
+  },
+  "app.instance.mods.successfully-uploaded": {
+    "message": "Successfully uploaded"
+  },
+  "app.instance.mods.unknown-version": {
+    "message": "Unknown"
+  },
+  "app.instance.mods.updating": {
+    "message": "Updating..."
+  },
+  "app.modal.install-to-play.content-required": {
+    "message": "Content required"
+  },
   "app.modal.install-to-play.header": {
     "message": "Install to play"
   },
@@ -14,11 +89,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# mod} other {# mods}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "This server requires mods to play. Click install to set up the required files from Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Required modpack"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} shared this instance with you today."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "This server requires mods to play. Click Install to set up the required files from Modrinth, then launch directly into the server."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Shared instance"
@@ -26,36 +101,18 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Shared server instance"
   },
-  "app.modal.update-to-play.added-count": {
-    "message": "{count} added"
-  },
-  "app.modal.update-to-play.diff-type.added": {
-    "message": "Added"
-  },
-  "app.modal.update-to-play.diff-type.removed": {
-    "message": "Removed"
-  },
-  "app.modal.update-to-play.diff-type.updated": {
-    "message": "Updated"
+  "app.modal.install-to-play.view-contents": {
+    "message": "View contents"
   },
   "app.modal.update-to-play.header": {
     "message": "Update to play"
   },
-  "app.modal.update-to-play.published-date": {
-    "message": "{date, date, long}"
-  },
-  "app.modal.update-to-play.removed-count": {
-    "message": "{count} removed"
-  },
   "app.modal.update-to-play.update-required": {
     "message": "Update required"
   },
   "app.modal.update-to-play.update-required-description": {
     "message": "An update is required to play {name}. Please update to the latest version to launch the game."
   },
-  "app.modal.update-to-play.updated-count": {
-    "message": "{count} updated"
-  },
   "app.settings.developer-mode-enabled": {
     "message": "Developer mode enabled."
   },
@@ -83,39 +140,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Resource management"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Modrinth App v{version} is ready to install! Reload to update now, or automatically when you close Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Modrinth App v{version} has finished downloading. Reload to update now, or automatically when you close Modrinth App."
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Modrinth App v{version} is available. Use your package manager to update for the latest features and fixes!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version} is available now! Since you're on a metered network, we didn't automatically download it."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Changelog"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Download ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Download"
+  "app.update-popup.download-complete": {
+    "message": "Download complete"
   },
-  "app.update-toast.downloading": {
-    "message": "Downloading..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Reload"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Update available"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Download complete"
-  },
   "app.update.complete-toast.text": {
     "message": "Click here to view the changelog."
   },
@@ -230,12 +281,6 @@
   "instance.edit-world.title": {
     "message": "Edit world"
   },
-  "instance.filter.disabled": {
-    "message": "Disabled projects"
-  },
-  "instance.filter.updates-available": {
-    "message": "Updates available"
-  },
   "instance.server-modal.address": {
     "message": "Address"
   },
@@ -344,141 +389,9 @@
   "instance.settings.tabs.installation": {
     "message": "Installation"
   },
-  "instance.settings.tabs.installation.change-version.already-installed.modded": {
-    "message": "{platform} {version} for Minecraft {game_version} already installed"
-  },
-  "instance.settings.tabs.installation.change-version.already-installed.vanilla": {
-    "message": "Vanilla {game_version} already installed"
-  },
-  "instance.settings.tabs.installation.change-version.button": {
-    "message": "Change version"
-  },
-  "instance.settings.tabs.installation.change-version.button.install": {
-    "message": "Install"
-  },
-  "instance.settings.tabs.installation.change-version.button.installing": {
-    "message": "Installing"
-  },
-  "instance.settings.tabs.installation.change-version.cannot-while-fetching": {
-    "message": "Fetching modpack versions"
-  },
-  "instance.settings.tabs.installation.change-version.in-progress": {
-    "message": "Installing new version"
-  },
-  "instance.settings.tabs.installation.currently-installed": {
-    "message": "Currently installed"
-  },
-  "instance.settings.tabs.installation.debug-information": {
-    "message": "Debug information:"
-  },
-  "instance.settings.tabs.installation.fetching-modpack-details": {
-    "message": "Fetching modpack details"
-  },
-  "instance.settings.tabs.installation.game-version": {
-    "message": "Game version"
-  },
-  "instance.settings.tabs.installation.install": {
-    "message": "Install"
-  },
-  "instance.settings.tabs.installation.install.in-progress": {
-    "message": "Installation in progress"
-  },
   "instance.settings.tabs.installation.loader-version": {
     "message": "{loader} version"
   },
-  "instance.settings.tabs.installation.minecraft-version": {
-    "message": "Minecraft {version}"
-  },
-  "instance.settings.tabs.installation.no-connection": {
-    "message": "Cannot fetch linked modpack details. Please check your internet connection."
-  },
-  "instance.settings.tabs.installation.no-loader-versions": {
-    "message": "{loader} is not available for Minecraft {version}. Try another mod loader."
-  },
-  "instance.settings.tabs.installation.no-modpack-found": {
-    "message": "This instance is linked to a modpack, but the modpack could not be found on Modrinth."
-  },
-  "instance.settings.tabs.installation.platform": {
-    "message": "Platform"
-  },
-  "instance.settings.tabs.installation.reinstall.button": {
-    "message": "Reinstall modpack"
-  },
-  "instance.settings.tabs.installation.reinstall.button.reinstalling": {
-    "message": "Reinstalling modpack"
-  },
-  "instance.settings.tabs.installation.reinstall.confirm.description": {
-    "message": "Reinstalling will reset all installed or modified content to what is provided by the modpack, removing any mods or content you have added on top of the original installation. This may fix unexpected behavior if changes have been made to the instance, but if your worlds now depend on additional installed content, it may break existing worlds."
-  },
-  "instance.settings.tabs.installation.reinstall.confirm.title": {
-    "message": "Are you sure you want to reinstall this instance?"
-  },
-  "instance.settings.tabs.installation.reinstall.description": {
-    "message": "Resets the instance's content to its original state, removing any mods or content you have added on top of the original modpack."
-  },
-  "instance.settings.tabs.installation.reinstall.title": {
-    "message": "Reinstall modpack"
-  },
-  "instance.settings.tabs.installation.repair.button": {
-    "message": "Repair"
-  },
-  "instance.settings.tabs.installation.repair.button.repairing": {
-    "message": "Repairing"
-  },
-  "instance.settings.tabs.installation.repair.confirm.description": {
-    "message": "Repairing reinstalls Minecraft dependencies and checks for corruption. This may resolve issues if your game is not launching due to launcher-related errors, but will not resolve issues or crashes related to installed mods."
-  },
-  "instance.settings.tabs.installation.repair.confirm.title": {
-    "message": "Repair instance?"
-  },
-  "instance.settings.tabs.installation.repair.in-progress": {
-    "message": "Repair in progress"
-  },
-  "instance.settings.tabs.installation.reset-selections": {
-    "message": "Reset to current"
-  },
-  "instance.settings.tabs.installation.show-all-versions": {
-    "message": "Show all versions"
-  },
-  "instance.settings.tabs.installation.tooltip.action.change-version": {
-    "message": "change version"
-  },
-  "instance.settings.tabs.installation.tooltip.action.install": {
-    "message": "install"
-  },
-  "instance.settings.tabs.installation.tooltip.action.reinstall": {
-    "message": "reinstall"
-  },
-  "instance.settings.tabs.installation.tooltip.action.repair": {
-    "message": "repair"
-  },
-  "instance.settings.tabs.installation.tooltip.cannot-while-installing": {
-    "message": "Cannot {action} while installing"
-  },
-  "instance.settings.tabs.installation.tooltip.cannot-while-offline": {
-    "message": "Cannot {action} while offline"
-  },
-  "instance.settings.tabs.installation.tooltip.cannot-while-repairing": {
-    "message": "Cannot {action} while repairing"
-  },
-  "instance.settings.tabs.installation.unknown-version": {
-    "message": "(unknown version)"
-  },
-  "instance.settings.tabs.installation.unlink.button": {
-    "message": "Unlink instance"
-  },
-  "instance.settings.tabs.installation.unlink.confirm.description": {
-    "message": "If you proceed, you will not be able to re-link it without creating an entirely new instance. You will no longer receive modpack updates and it will become a normal."
-  },
-  "instance.settings.tabs.installation.unlink.confirm.title": {
-    "message": "Are you sure you want to unlink this instance?"
-  },
-  "instance.settings.tabs.installation.unlink.description": {
-    "message": "This instance is linked to a modpack, which means mods can't be updated and you can't change the mod loader or Minecraft version. Unlinking will permanently disconnect this instance from the modpack."
-  },
-  "instance.settings.tabs.installation.unlink.title": {
-    "message": "Unlink from modpack"
-  },
   "instance.settings.tabs.java": {
     "message": "Java and memory"
   },
@@ -551,6 +464,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Server is incompatible"
   },
+  "instance.worlds.linked_server": {
+    "message": "Managed by server project"
+  },
   "instance.worlds.no_contact": {
     "message": "Server couldn't be contacted"
   },
@@ -586,5 +502,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Sync with instance"
+  },
+  "search.filter.locked.server": {
+    "message": "Provided by the server"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Only client-side mods can be added to the server instance"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Game version is provided by the server"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Loader is provided by the server"
   }
 }

apps/app-frontend/src/locales/es-419/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "No se puede acceder a los servidores de autenticación"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Contenido requerido"
+  },
   "app.modal.install-to-play.header": {
     "message": "Instala para jugar"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# mod} other {# mods}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Este servidor requiere mods para jugar. Haz clic en instalar para configurar los archivos necesarios desde Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Modpack requerido"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} compartió esta instancia contigo hoy."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Este servidor requiere mods para poder jugar. Haz click en Instalar para configurar los archivos requeridos desde Modrinth, después se ejecutará para entrar directamente al servidor."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Instancia compartida"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Instancia de servidor compartida"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Ver contenidos"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} agregados"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Gestión de recursos"
   },
-  "app.update-toast.body": {
-    "message": "¡Modrinth App v{version} lista para instalar! Actualiza ahora o automáticamente al cerrar la aplicación."
+  "app.update-popup.body": {
+    "message": "¡Modrinth App v{version} está lista para instalarse! Actualiza ahora o automáticamente al cerrar la Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
-    "message": "La descarga de la Modrinth App v{version} ha finalizado. Actualiza ahora o automáticamente al cerrar la aplicación Modrinth."
+  "app.update-popup.body.download-complete": {
+    "message": "La descarga de la Modrinth App v{version} ha finalizado. Actualiza ahora o automáticamente al cerrar la Modrinth App."
   },
-  "app.update-toast.body.linux": {
-    "message": "La aplicación Modrinth v{version} ya está disponible. ¡Utiliza tu gestor de paquetes para actualizarla y disfrutar de las últimas funciones y correcciones!"
+  "app.update-popup.body.linux": {
+    "message": "La Modrinth App v{version} está disponible. ¡Usa tu gestor de paquetes para actualizarla y tener las últimas funciones y corrección de errores!"
   },
-  "app.update-toast.body.metered": {
-    "message": "¡Modrinth App v{version} ya está disponible! Como estás en una red con límite de datos, no se descargó automáticamente."
+  "app.update-popup.body.metered": {
+    "message": "¡La Modrinth App v{version} ya está disponible! Al estar usando una red de datos límitada, no la hemos descargado automáticamente."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Registro de cambios"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Descargar ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Descargar"
+  "app.update-popup.download-complete": {
+    "message": "Descarga completada"
   },
-  "app.update-toast.downloading": {
-    "message": "Descargando..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Recargar"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Actualización disponible"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Descarga completada"
-  },
   "app.update.complete-toast.text": {
     "message": "Haz clic aquí para ver el registro de cambios."
   },
@@ -297,7 +297,7 @@
     "message": "Los grupos de la librería te ayudan a organizar tus instancias en diferentes secciones en tu librería."
   },
   "instance.settings.tabs.general.library-groups.enter-name": {
-    "message": "Ingresa el nombre del grupo"
+    "message": "Escribe nombre del grupo"
   },
   "instance.settings.tabs.general.name": {
     "message": "Nombre"
@@ -306,7 +306,7 @@
     "message": "Hooks de inicio"
   },
   "instance.settings.tabs.hooks.custom-hooks": {
-    "message": "Hooks de inicio personalizados"
+    "message": "Hooks personalizados"
   },
   "instance.settings.tabs.hooks.description": {
     "message": "Los hooks permiten que usuarios avanzados ejecuten comandos del sistema antes y despues de lanzar el juego."
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(versión desconocida)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Esta instancia está vinculada a un servidor, lo que significa que no puedes cambiar la versión de Minecraft. Desvincularla la desconectará permanentemente del servidor."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Esta instancia está vinculada a un servidor, lo que significa que los mods no pueden actualizarse y no puedes cambiar el mod loader ni la versión de Minecraft. Desvincularla la desconectará permanentemente del servidor."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Desvincular del servidor"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Desvincular instancia"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "El servidor es incompatible"
   },
+  "instance.worlds.linked_server": {
+    "message": "Gestionado por el proyecto del servidor"
+  },
   "instance.worlds.no_contact": {
     "message": "No se pudo conectar al servidor"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Sincronizar con la instancia"
+  },
+  "search.filter.locked.server": {
+    "message": "Proporcionado por el servidor"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Solo se puede añadir mods que sean del lado del cliente a la instancia del servidor"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "La versión del juego es proporcionada por el servidor"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "El loader es proporcionado por el servidor"
   }
 }

apps/app-frontend/src/locales/es-ES/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "No se puede conectar con los servidores de autenticación"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Contenu requis"
+  },
   "app.modal.install-to-play.header": {
     "message": "Instala para jugar"
   },
@@ -14,12 +17,6 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# mod} other {# mods}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Este servidor requiere mods para jugar. Haz clic en instalar para configurar los archivos necesarios de Modrinth."
-  },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} ha compartido contigo hoy esta instancia."
-  },
   "app.modal.install-to-play.shared-instance": {
     "message": "Instancia compartida"
   },
@@ -83,39 +80,6 @@
   "app.settings.tabs.resource-management": {
     "message": "Gestión de recursos"
   },
-  "app.update-toast.body": {
-    "message": "¡La versión v{version} de Modrinth está lista para instalarse! Actualiza ahora o automáticamente al cerrar la aplicación."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "La descarga de la versión v{version} de Modrinth ha finalizado. Actualice ahora o automáticamente al cerrar la aplicación."
-  },
-  "app.update-toast.body.linux": {
-    "message": "Modrinth App v{version} está disponible. ¡Usa tu gestor de paquetes para actualizar a la última versión con nuevas funciones y correcciones!"
-  },
-  "app.update-toast.body.metered": {
-    "message": "¡La versión v{version} de Modrinth App ya está disponible! Como estás conectado a una red con límite de datos, no la hemos descargado automáticamente."
-  },
-  "app.update-toast.changelog": {
-    "message": "Registro de cambios"
-  },
-  "app.update-toast.download": {
-    "message": "Descarga ({size})"
-  },
-  "app.update-toast.download-page": {
-    "message": "Descargar"
-  },
-  "app.update-toast.downloading": {
-    "message": "Descargando..."
-  },
-  "app.update-toast.reload": {
-    "message": "Recarga"
-  },
-  "app.update-toast.title": {
-    "message": "Actualización disponible"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Descarga completada"
-  },
   "app.update.complete-toast.text": {
     "message": "Haga clic aquí para ver el registro de cambios."
   },

apps/app-frontend/src/locales/fi-FI/index.json

@@ -5,6 +5,51 @@
   "app.auth-servers.unreachable.header": {
     "message": "Todennuspalvelimiin ei saada yhteyttä"
   },
+  "app.modal.install-to-play.header": {
+    "message": "Asenna pelataksesi"
+  },
+  "app.modal.install-to-play.install-button": {
+    "message": "Asenna"
+  },
+  "app.modal.install-to-play.mod-count": {
+    "message": "{count, plural, one {# mod} other {# modia}}"
+  },
+  "app.modal.install-to-play.shared-instance": {
+    "message": "Jaettu instanssi"
+  },
+  "app.modal.install-to-play.shared-server-instance": {
+    "message": "Jaettu palvelininstanssi"
+  },
+  "app.modal.update-to-play.added-count": {
+    "message": "{count} lisätty"
+  },
+  "app.modal.update-to-play.diff-type.added": {
+    "message": "Lisätty"
+  },
+  "app.modal.update-to-play.diff-type.removed": {
+    "message": "Poistettu"
+  },
+  "app.modal.update-to-play.diff-type.updated": {
+    "message": "Päivitetty"
+  },
+  "app.modal.update-to-play.header": {
+    "message": "Päivitä pelataksesi"
+  },
+  "app.modal.update-to-play.published-date": {
+    "message": "{date, date, long}"
+  },
+  "app.modal.update-to-play.removed-count": {
+    "message": "{count} poistettu"
+  },
+  "app.modal.update-to-play.update-required": {
+    "message": "Päivitys vaaditaan"
+  },
+  "app.modal.update-to-play.update-required-description": {
+    "message": "Pävitys vaaditaan pelataksesi {name}. Päivitä viimeisimpään versioon pelataksesi."
+  },
+  "app.modal.update-to-play.updated-count": {
+    "message": "{count} päivitetty"
+  },
   "app.settings.developer-mode-enabled": {
     "message": "Kehittäjätila käytössä."
   },
@@ -32,36 +77,6 @@
   "app.settings.tabs.resource-management": {
     "message": "Resurssien hallinta"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth-sovellus v{version} on valmis asennettavaksi! Lataa sovellus uudelleen päivittääksesi sen nyt tai automaattisesti, kun suljet Modrinth-sovelluksen."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth-sovellus v{version} on ladattu. Lataa sovellus uudelleen päivittääksesi sen nyt tai automaattisesti, kun suljet Modrinth-sovelluksen."
-  },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth-sovellus v{version} on nyt saatavilla! Koska käytät käyttömaksullista verkkoa, emme ladanneet sitä automaattisesti."
-  },
-  "app.update-toast.changelog": {
-    "message": "Muutosloki"
-  },
-  "app.update-toast.download": {
-    "message": "Lataa ({size})"
-  },
-  "app.update-toast.download-page": {
-    "message": "Lataa"
-  },
-  "app.update-toast.downloading": {
-    "message": "Ladataan..."
-  },
-  "app.update-toast.reload": {
-    "message": "Uudelleen lataa"
-  },
-  "app.update-toast.title": {
-    "message": "Päivitys saatavilla"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Lataus valmis"
-  },
   "app.update.complete-toast.text": {
     "message": "Klikkaa tästä nähdäksesi muutoslokin."
   },

apps/app-frontend/src/locales/fil-PH/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Hindi maabot ang mga authentication server"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Nangangailangan ng kontento"
+  },
   "app.modal.install-to-play.header": {
     "message": "Mag-install upang malaro"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# mod} other {# na mod}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Ang server na ito ay nangangailangan ng mga mod upang malaro. Pindutin ang install upang mahanda ang mga kinakailangang file galing sa Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Kinailangan na modpack"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "Ibinahagi ngayong araw ni {name} ang instansiyang ito sa iyo."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Ang server rna ito ay nangangailangan ng mga mod upang makalaro. Pindutin ang install upang maihanda ang mga kinakailangang file galing sa Modrinth, matapos ay ilunsad nang diretso sa server."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Binahaging instansiya"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Binahaging instansiyang pang-server"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Tingnan ang mga kontento"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} nadagdag"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Pamamahala ng paglalaan"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Ang Modrinth App v{version} ay handa nang ma-install. Mag-reload upang ma-update ngayon, o awtomatiko sa pagsara ng Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Tapos nang ma-download ang Modrinth App v{version}. Mag-reload upang ma-update ngayon, o awtomatiko sa pagsara ng Modrinth App."
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Magagamit na ngayon ang Modrinth App v{version}. Gamitin ang iyong package manager upang i-update sa pinabagong tampok at pag-aayos!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Magagamit na ngayon ang Modrinth App v{version}! Hindi namin dinanload kaagad dahil naka-metro ang inyong network."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Changelog"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "I-download ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "I-download"
+  "app.update-popup.download-complete": {
+    "message": "Nakumpleto ang pagdownload"
   },
-  "app.update-toast.downloading": {
-    "message": "Nagda-download..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Mag-reload"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "May bagong update"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Nakumpleto ang pagdownload"
-  },
   "app.update.complete-toast.text": {
     "message": "Dito pumindot upang matingnan ang changelog."
   },
@@ -309,7 +309,7 @@
     "message": "Mga custom na launch hook"
   },
   "instance.settings.tabs.hooks.description": {
-    "message": "Binibigyan-daan ng mga hook ang mga ekspertong tagagamit na makapagtakbo ng mga system command bago at pagkatapos ma-launch ang laro."
+    "message": "Binibigyan-daan ng mga hook ang mga ekspertong tagagamit na makapagtakbo ng mga pansistemang utos o system command bago at pagkatapos ma-launch ang laro."
   },
   "instance.settings.tabs.hooks.post-exit": {
     "message": "Post-exist"
@@ -414,7 +414,7 @@
     "message": "Sigurado ka bang gusto mong i-reinstall ang instansiyang ito?"
   },
   "instance.settings.tabs.installation.reinstall.description": {
-    "message": "Mare-reset ang mga kontento ng instansiya sa orihinal niyang estado, tatanggalin ang mga mods at kontentong idinagdag mo sa orihinal na modpack."
+    "message": "Mare-reset ang mga kontento ng instansiya sa orihinal niyang estado, tatanggalin ang mga mod at kontentong idinagdag mo sa orihinal na modpack."
   },
   "instance.settings.tabs.installation.reinstall.title": {
     "message": "I-reinstall ang modpack"
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(hindi kilalang bersiyon)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Ang instansiyang ito ay naka-link sa isang server, ibig sabihin ay hindi mo mapapalitan ang bersiyon ng Minecraft. Permanenteng madi-diskonekta ang instansiyang ito sa server kung mag-unlink."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Ang instansiyang ito ay naka-link sa isang server, ibig sabihin ang mga mod ay hindi mai-update at hindi mo mapapalitan ang mod loader at ang bersiyon ng Minecraft. Permanenteng madi-diskonekta ang instansiyang ito sa server kung mag-unlink."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "I-unlink sa server"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "I-unlink sa instansiya"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Hindi magkatugma sa server"
   },
+  "instance.worlds.linked_server": {
+    "message": "Pinamamahala ng proyektong server"
+  },
   "instance.worlds.no_contact": {
     "message": "Hindi makontak ang server"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Maki-sync sa instansiya"
+  },
+  "search.filter.locked.server": {
+    "message": "Handog ng server"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Mga mod sa panig ng client lamang ang maidadaragdag sa instansiyang server"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Ang bersiyon ng laro ay handog ng server"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Ang loader ay handog na ng server"
   }
 }

apps/app-frontend/src/locales/fr-FR/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Impossible de contacter les serveurs d'authentification"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Contenu requis"
+  },
   "app.modal.install-to-play.header": {
     "message": "Installer pour jouer"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# mod} other {# mods}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Ce serveur nécessite des mods pour pouvoir y jouer. Cliquez sur installer pour mettre les fichiers de Modrinth en place."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Modpack requis"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} a partagé cette instance avec vous aujourd'hui."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Ce serveur a besoin de mods pour jouer. Cliquez sur Installer pour mettre en place les fichiers requis depuis Modrinth, puis lancez directement dans le serveur."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Instance partagée"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Instance serveur partagée"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Voir le contenu"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} {count, plural, one {# ajouté} other {# ajoutés}}"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Gestion des ressources"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} est prête à être installée ! Relancez l'application pour faire la mise à jour maintenant, ou automatiquement à la fermeture de Modrinth App."
+  "app.update-popup.body": {
+    "message": "Modrinth App v{version} est prête à être installée ! Rechargez pour mettre à jour maintenant, ou automatiquement quand vous fermez Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
-    "message": "Le téléchargement de Modrinth App v{version} est terminé ! Relancez l'application pour mettre à jour maintenant, ou automatiquement à la fermeture de Modrinth App."
+  "app.update-popup.body.download-complete": {
+    "message": "Modrinth App v{version} a finie d'être téléchargée. Rechargez pour mettre à jour maintenant, ou automatiquement quand vous fermez Modrinth App."
   },
-  "app.update-toast.body.linux": {
-    "message": "Modrith App v{version} est disponible. Utilisez votre gestionnaire de paquets pour obtenir les derniers changements et corrections de bugs !"
+  "app.update-popup.body.linux": {
+    "message": "Modrinth App v{version} est disponible. Utilisez votre gestionnaire de paquets pour mettre à jour les dernières fonctionnalités et corrections de bogues !"
   },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version} est disponible dès maintenant ! Lorsque vous êtes sur un réseau limité ou en données mobiles, nous ne téléchargerons pas les mises à jour automatiquement."
+  "app.update-popup.body.metered": {
+    "message": "Modrinth App v{version} est disponible maintenant ! Puisque vous êtes sur un réseau métré, nous ne l'avons pas téléchargé automatiquement."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Journal des modifications"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Télécharger ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Télécharger"
+  "app.update-popup.download-complete": {
+    "message": "Téléchargement terminé"
   },
-  "app.update-toast.downloading": {
-    "message": "Téléchargement..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Recharger"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Mise à jour disponible"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Téléchargement terminé"
-  },
   "app.update.complete-toast.text": {
     "message": "Cliquez ici pour voir les changements récents."
   },
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(version inconnue)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Cette instance est liée à un modpack, ce qui veut dire que vous ne pouvez pas changer la version de Minecraft. Délier déconnectera cette instance du serveur en permanence."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Cette instance est liée à un serveur, ce qui veut dire que les mods ne peuvent pas être mis à jour et que vous ne pouvez pas changer de mod loader ou de version de Minecraft. Délier déconnectera cette instance du serveur en permanence."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Délier du serveur"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Délier l'instance"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Le serveur est incompatible"
   },
+  "instance.worlds.linked_server": {
+    "message": "Géré par le projet du serveur"
+  },
   "instance.worlds.no_contact": {
     "message": "Le serveur n'a pas pu être contacté"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Synchroniser avec l'instance"
+  },
+  "search.filter.locked.server": {
+    "message": "Fournis par le serveur"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Seuls les mods client peuvent être ajoutés à l'instance du serveur"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Version du jeu est procurée par le serveur"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Loader est procuré par le serveur"
   }
 }

apps/app-frontend/src/locales/he-IL/index.json

@@ -14,12 +14,6 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {מוד אחד} other {# מודים}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "השרת דורש מודים כדי לשחק. התקנה מגדירה את הקבצים הדרושים מModrinth."
-  },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} שיתף איתך את ההתקנה הזאת היום."
-  },
   "app.modal.install-to-play.shared-instance": {
     "message": "התקנה משותפת"
   },
@@ -83,39 +77,6 @@
   "app.settings.tabs.resource-management": {
     "message": "ניהול משאבים"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} מוכנה להורדה!\nיש לרענן כדי לעדכן עכשיו, או באופן אוטומטי בעת סגירת האפליקציה."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} סיימה את תהליך ההורדה. יש לרענן כדי לעדכן עכשיו, או באופן אוטומטי בעת סגירת האפליקציה."
-  },
-  "app.update-toast.body.linux": {
-    "message": "Modrinth App v{version} זמין. יש להשתמש במנהל חבילות שלך כדי לעדכן בשביל התכונות החדשות ותיקונים!"
-  },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version} זמינה עכשיו! בגלל החיבור לפי שימוש, לא הורדנו אותה אוטומטית."
-  },
-  "app.update-toast.changelog": {
-    "message": "יומן שינויים"
-  },
-  "app.update-toast.download": {
-    "message": "הורדה ({size})"
-  },
-  "app.update-toast.download-page": {
-    "message": "הורד"
-  },
-  "app.update-toast.downloading": {
-    "message": "מוריד..."
-  },
-  "app.update-toast.reload": {
-    "message": "רענן"
-  },
-  "app.update-toast.title": {
-    "message": "עדכונים זמינים"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "הורדה הושלמה"
-  },
   "app.update.complete-toast.text": {
     "message": "לחיצה כדי לראות את יומן השינויים."
   },

apps/app-frontend/src/locales/hu-HU/index.json

@@ -5,20 +5,23 @@
   "app.auth-servers.unreachable.header": {
     "message": "Nem lehet elérni a hitelesítési kiszolgálókat"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Szükséges tartalom"
+  },
   "app.modal.install-to-play.header": {
-    "message": "Töltsd le a játékhoz"
+    "message": "Telepítés a játékhoz"
   },
   "app.modal.install-to-play.install-button": {
     "message": "Telepítés"
   },
   "app.modal.install-to-play.mod-count": {
-    "message": "# mod"
+    "message": "{count, plural,one {# mod}other {# modok}}"
+  },
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Szükséges modcsomag"
   },
   "app.modal.install-to-play.server-requires-mods": {
-    "message": "Ehhez a szerverhez modok szükségesek a játékhoz. Kattints a telepítés gombra, hogy beállítsd a szükséges fájlokat a Modrinthból."
-  },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} ma megosztotta veled ezt a profilt."
+    "message": "Ehhez a szerverhez modok szükségesek a játékhoz. Kattints a Telepítés gombra, hogy telepítsd a szükséges fájlokat a Modrinth-ról, majd indítsd el közvetlenül a szervert."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Megosztott profil"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Megosztott szerverprofil"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Tartalom megjelenítése"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} hozzáadva"
   },
@@ -83,38 +89,32 @@
   "app.settings.tabs.resource-management": {
     "message": "Erőforráskezelés"
   },
-  "app.update-toast.body": {
-    "message": "A Modrinth App v{version} telepítésre kész! Frissítéshez indítsa újra a programot, vagy zárja be a Modrinth App alkalmazást, és a frissítés automatikusan megtörténik."
+  "app.update-popup.body": {
+    "message": "A Modrinth App v{version} telepítésre kész! Frissítéshez Töltsd újra az oldalt, vagy a Modrinth App bezárásakor automatikusan frissül."
   },
-  "app.update-toast.body.download-complete": {
-    "message": "A Modrinth App v{version} letöltése befejeződött. Frissítéshez indítsa újra az alkalmazást, vagy zárja be a Modrinth App alkalmazást, és a frissítés automatikusan megtörténik."
+  "app.update-popup.body.download-complete": {
+    "message": "A Modrinth App v{version} letöltése befejeződött. Frissítéshez Töltsd újra az oldalt, vagy a Modrinth App bezárásakor automatikusan frissül."
   },
-  "app.update-toast.body.linux": {
-    "message": "A Modrinth alkalmazás v{version} elérhető. Használd a csomagkezelődet a legújabb funkciók és hibajavítások telepítéséhez!"
+  "app.update-popup.body.linux": {
+    "message": "A Modrinth App v{version} elérhető. Használd a csomagkezelőt a legújabb funkciók és javítások frissítéséhez!"
   },
-  "app.update-toast.body.metered": {
-    "message": "A Modrinth App v{version} már elérhető! Mivel díjköteles hálózaton vagy, így nem töltöttük le automatikusan."
+  "app.update-popup.body.metered": {
+    "message": "A Modrinth App v{version} már elérhető! Mivel mérhető hálózaton vagy, nem töltöttük le automatikusan."
   },
-  "app.update-toast.changelog": {
-    "message": "Változtatások"
+  "app.update-popup.changelog": {
+    "message": "Változásnapló"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Letöltés ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Letöltés"
+  "app.update-popup.download-complete": {
+    "message": "Letöltés sikeres"
   },
-  "app.update-toast.downloading": {
-    "message": "Letöltés..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Újratöltés"
   },
-  "app.update-toast.title": {
-    "message": "Frissítések elérhetőek"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Letöltés befejezve"
+  "app.update-popup.title": {
+    "message": "Frissítés elérhető"
   },
   "app.update.complete-toast.text": {
     "message": "Kattints ide a változások megtekintéséhez."
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(ismeretlen verzió)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Ez az profil egy szerverhez van kapcsolva, ami azt jelenti, hogy nem lehet megváltoztatni a Minecraft verzióját. A kapcsolás megszüntetése véglegesen leválasztja ezt az profilt a szerverről."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Ez az profil egy szerverhez van kapcsolva, ami azt jelenti, hogy a modok nem frissíthetők, és nem lehet megváltoztatni a modbetöltőt vagy a Minecraft verziót. A kapcsolódás megszüntetése véglegesen leválasztja ezt a profilt a szerverről."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Leválasztás a szerverről"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Profil leválasztása"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "A Szerver nem kompatibilis"
   },
+  "instance.worlds.linked_server": {
+    "message": "Szerverprojekt által kezelt"
+  },
   "instance.worlds.no_contact": {
     "message": "Nem lehet kapcsolatot létesíteni a szerverrel"
   },
@@ -567,7 +579,7 @@
     "message": "Szerver"
   },
   "instance.worlds.type.singleplayer": {
-    "message": "Egyjátékosmód"
+    "message": "Egyjátékos"
   },
   "instance.worlds.view_instance": {
     "message": "Profil megtekintése"
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Profil szinkronizálása"
+  },
+  "search.filter.locked.server": {
+    "message": "A szerver biztosítja"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Csak kliensoldali modok adhatók hozzá a szerverprofilhoz"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "A játékverziót a szerver biztosítja"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "A betöltőt a szerver biztosítja"
   }
 }

apps/app-frontend/src/locales/id-ID/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Tidak dapat terhubung ke server autentikasi"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Konten diperlukan"
+  },
   "app.modal.install-to-play.header": {
     "message": "Pasang untuk memainkan"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, other {# mod}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Server ini memerlukan mod untuk dimainkan. Klik pasang untuk menyiapkan berkas-berkas yang diperlukan dari Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Paket mod yang diperlukan"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} membagikan instans ini dengan Anda hari ini."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Mod diperlukan untuk bermain di server ini. Klik pasang untuk menyiapkan berkas-berkas yang diperlukan dari Modrinth, kemudian luncurkan langsung sari server."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Instans terbagi"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Instans server terbagi"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Lihat konten"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} ditambahkan"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Manajemen sumber"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Modrinth App v{version} siap dipasang! Muat ulang untuk memperbarui sekarang, atau secara otomatis saat Anda menutup Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Modrinth App v{version} telah selesai mengunduh. Muat ulang untuk memperbarui sekarang, atau secara otomatis saat Anda menutup Modrinth App."
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Modrinth App v{version} tersedia. Gunakan pengelola paket Anda untuk memperbarui dan mendapatkan fitur-fitur dan perbaikan terbaru!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version} sudah tersedia! Karena Anda saat ini sedang berada dalam jaringan terukur, kami tidak mengunduhnya secara otomatis."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Catatan perubahan"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Unduh ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Unduh"
+  "app.update-popup.download-complete": {
+    "message": "Selesai mengunduh"
   },
-  "app.update-toast.downloading": {
-    "message": "Mengunduh..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Muat ulang"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Pembaruan tersedia"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Selesai mengunduh"
-  },
   "app.update.complete-toast.text": {
     "message": "Klik di sini untuk melihat catatan perubahan."
   },
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(versi tidak dikenal)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Instans ini berkaitan dengan suatu server, yang berarti Anda tidak dapat mengubah versi Minecraft. Melepas kaitan akan memutuskan instans ini dari server secara permanen."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Instans ini berkaitan dengan suatu server, yang berarti mod tidak dapat diperbarui dan Anda tidak dapat mengubah versi peluncur mod atau Minecraft. Melepas kaitan akan memutuskan instans ini dari server secara permanen."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Lepas kaitan dari server"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Lepas kaitan instans"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Server tidak cocok"
   },
+  "instance.worlds.linked_server": {
+    "message": "Dikelola oleh proyek server"
+  },
   "instance.worlds.no_contact": {
     "message": "Server tidak dapat dihubungi"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Sinkronkan dengan instans"
+  },
+  "search.filter.locked.server": {
+    "message": "Disediakan oleh server"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Anda hanya dapat menambahkan mod sisi klien pada instans server"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Versi permainan disediakan oleh server"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Pemuat disediakan oleh server"
   }
 }

apps/app-frontend/src/locales/it-IT/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Impossibile raggiungere i server di autenticazione"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Contenuto richiesto"
+  },
   "app.modal.install-to-play.header": {
     "message": "Installa per continuare"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count} mod"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Questo server necessita di alcune mod. Clicca installa per scaricarle direttamente da Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Pacchetto di mod richiesto"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} ha condiviso questa istanza con te oggi."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Questo server richiede alcune mod. Clicca Installa per scaricarle direttamente da Modrinth, poi sarai pronto a giocare."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Istanza condivisa"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Istanza del server condivisa"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Mostra contenuti"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count, plural, one {# aggiunta} other {# aggiunte}}"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Gestione delle risorse"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Modrinth App v{version} è pronta per essere installata! Ricarica per aggiornare ora, o avverrà in automatico alla chiusura dell'app."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Modrinth App v{version} è stata scaricata. Ricarica per aggiornare ora, o avverrà in automatico alla chiusura dell'app."
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Modrinth App v{version} è disponibile. Usa il tuo gestore di pacchetti per aggiornare e ricevere le novità più recenti!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version} è ora disponibile! Poiché sei su una rete a consumo, non l'abbiamo scaricata automaticamente."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Novità"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Scarica ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Scarica"
+  "app.update-popup.download-complete": {
+    "message": "Download completato"
   },
-  "app.update-toast.downloading": {
-    "message": "Scaricando..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Ricarica"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Aggiornamento disponibile"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Download completato"
-  },
   "app.update.complete-toast.text": {
     "message": "Consulta qui le ultime novità in inglese."
   },
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(versione sconosciuta)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Questa istanza è collegata a un server, cioè non puoi cambiare la versione di Minecraft. Lo scollegamento disconnetterà definitivamente questa istanza dal server."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Questa istanza è collegata a un server, perciò le mod non possono essere aggiornate manualmente, e non puoi cambiare loader di mod né versione di Minecraft. Lo scollegamento disconnetterà definitivamente questa istanza dal server."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Scollega dal server"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Scollega istanza"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Server non è compatibile"
   },
+  "instance.worlds.linked_server": {
+    "message": "Gestito dal server"
+  },
   "instance.worlds.no_contact": {
     "message": "Impossibile contattare il server"
   },
@@ -576,15 +588,27 @@
     "message": "Mondo già in uso"
   },
   "search.filter.locked.instance": {
-    "message": "Fornito dall'istanza"
+    "message": "Determinato dall'istanza"
   },
   "search.filter.locked.instance-game-version.title": {
-    "message": "La versione del gioco è fornita dall'istanza"
+    "message": "La versione del gioco è determinata dall'istanza"
   },
   "search.filter.locked.instance-loader.title": {
-    "message": "Il loader è fornito dall'istanza"
+    "message": "Il loader è determinato dall'istanza"
   },
   "search.filter.locked.instance.sync": {
     "message": "Sincronizza con l'istanza"
+  },
+  "search.filter.locked.server": {
+    "message": "Determinato dal server"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Solo mod lato client possono essere aggiunte all'istanza del server"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "La versione del gioco è determinata dal server"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Il loader è determinato dal server"
   }
 }

apps/app-frontend/src/locales/ja-JP/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "認証サーバーにアクセスできません"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "必須コンテンツ"
+  },
   "app.modal.install-to-play.header": {
     "message": "インストールしてプレイ"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, other {#個のMod}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "このサーバーをプレイするにはMODが必要です。インストールをクリックしてModrinthから必要なファイルを設定してください。"
+  "app.modal.install-to-play.required-modpack": {
+    "message": "必須なModpack"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} が本日この事例を共有しました。"
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "このサーバーをプレイするにはModが必要です。インストールをクリックしてModrinthから必要なファイルを設定し、サーバーに接続してください。"
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "共有インスタンス"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "共有サーバーインスタンス"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "コンテンツを見る"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count}追加"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "リソース管理"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version}のインストールの準備ができました。再起動して今すぐ更新するか、アプリを閉じた際に自動で更新されます。"
+  "app.update-popup.body": {
+    "message": "Modrinth App v{version} のインストール準備が整いました！今すぐ更新するには再読み込みするか、Modrinth App を閉じる際に自動更新されます。"
   },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version}のダウンロードが完了しました。再起動して今すぐ更新するか、アプリを閉じた際に自動で更新されます。"
+  "app.update-popup.body.download-complete": {
+    "message": "Modrinth App v{version} のダウンロードが完了しました。今すぐ更新するには再読み込みするか、Modrinth App を閉じる際に自動更新されます。"
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Modrinth App v{version} が利用可能です。最新の機能と修正プログラムを入手するには、パッケージマネージャーを使用して更新してください！"
   },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version}は今すぐダウンロードできます。従量課金制ネットワークを使用しているため自動ダウンロードはされていません。"
+  "app.update-popup.body.metered": {
+    "message": "Modrinth App v{version} が利用可能になりました！お使いのネットワークが従量制のため、自動ダウンロードは行っておりません。"
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "更新履歴"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "ダウンロード ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "ダウンロード"
-  },
-  "app.update-toast.downloading": {
-    "message": "ダウンロード中..."
-  },
-  "app.update-toast.reload": {
-    "message": "再起動"
-  },
-  "app.update-toast.title": {
-    "message": "アップデートが利用可能です"
-  },
-  "app.update-toast.title.download-complete": {
+  "app.update-popup.download-complete": {
     "message": "ダウンロード完了"
   },
+  "app.update-popup.reload": {
+    "message": "リロード"
+  },
+  "app.update-popup.title": {
+    "message": "アップデートが利用可能です"
+  },
   "app.update.complete-toast.text": {
     "message": "クリックすると更新履歴を表示できます。"
   },
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(不明なバージョン)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "このインスタンスはサーバーにリンクされているので、Minecraftのバージョンを変更することはできません。リンクを解除するとこのインスタンスはサーバーから永久に切断されます。"
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "このインスタンスはサーバーにリンクされているので、Modの更新はできず、ModローダーやMinecraftのバージョンを変更することもできません。リンクを解除すると、このインスタンスはサーバーから永久に切断されます。"
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "サーバーとのリンクを解除する"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "インスタンスのリンク解除"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "サーバーに互換性がありません"
   },
+  "instance.worlds.linked_server": {
+    "message": "サーバープロジェクトによる管理"
+  },
   "instance.worlds.no_contact": {
     "message": "サーバーに接続できませんでした"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "インスタンスと同期"
+  },
+  "search.filter.locked.server": {
+    "message": "サーバーにより提供されています"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "サーバー構成にはクライアント側Modのみ追加可能"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "ゲームバージョンはサーバーにより提供されています"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "ローダーはサーバーにより提供されています"
   }
 }

apps/app-frontend/src/locales/ko-KR/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "인증 서버에 연결할 수 없습니다"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "콘텐츠 설치 필요"
+  },
   "app.modal.install-to-play.header": {
     "message": "설치하고 플레이"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {모드 #개} other {모드 #개}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "이 서버에서 플레이하려면 모드가 필요합니다. 설치를 눌러 Modrinth에서 필요한 파일을 설정하세요."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "필요한 모드팩"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name}이(가) 오늘 이 인스턴스를 공유했습니다."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "이 서버를 플레이하려면 모드가 필요합니다. '설치'를 클릭하여 Modrinth에서 필수 파일을 내려받은 후, 서버에 바로 접속하세요."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "인스턴스 공유됨"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "서버 인스턴스 공유됨"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "구성 요소 보기"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} 추가됨"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "리소스 관리"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Modrinth App v{version}을 설치할 준비가 완료되었습니다! 새로고침하거나 Modrinth App을 종료하면 자동으로 업데이트됩니다."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Modrinth App v{version} 다운로드가 완료되었습니다. 새로고침하거나 Modrinth App을 종료하면 자동으로 업데이트됩니다."
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Modrinth App v{version} 버전을 사용할 수 있습니다. 최신 기능과 오류 수정을 적용하려면 패키지 관리자를 통해 업데이트하세요!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version}을 지금 사용할 수 있습니다! 데이터 통신 연결을 사용 중이므로, 자동으로 다운로드하지 않았습니다."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "변경 내역"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "({size}) 다운로드"
   },
-  "app.update-toast.download-page": {
-    "message": "다운로드"
+  "app.update-popup.download-complete": {
+    "message": "다운로드 완료"
   },
-  "app.update-toast.downloading": {
-    "message": "다운로드 중..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "새로고침"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "업데이트 가능"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "다운로드 완료"
-  },
   "app.update.complete-toast.text": {
     "message": "변경 내역을 보려면 클릭하세요."
   },
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(알 수 없는 버전)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "이 인스턴스는 서버에 연결되어 있으므로, 마인크래프트 버전을 변경할 수 없습니다. 연결을 해제하면 이 인스턴스가 서버에서 영구적으로 연결이 끊어집니다."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "이 인스턴스는 서버에 연결되어 있으므로 모드를 업데이트할 수 없으며 모드 로더나 Minecraft 버전을 변경할 수 없습니다. 연결을 해제하면 이 인스턴스가 서버에서 영구적으로 연결이 끊어집니다."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "서버 연결 해제"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "인스턴스 연결 해제"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "호환되지 않는 서버"
   },
+  "instance.worlds.linked_server": {
+    "message": "서버 설정에 의해 관리됨"
+  },
   "instance.worlds.no_contact": {
     "message": "서버가 응답하지 않음"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "인스턴스와 동기화"
+  },
+  "search.filter.locked.server": {
+    "message": "서버에 의해 관리됨"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "서버 인스턴스에는 클라이언트 전용 모드만 추가할 수 있습니다"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "게임 버전이 서버에 의해 제공됩니다"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "로더가 서버에 의해 제공됩니다"
   }
 }

apps/app-frontend/src/locales/ms-MY/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Tidak dapat mencapai pelayan pengesahan"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Kandungan yang diperlukan"
+  },
   "app.modal.install-to-play.header": {
     "message": "Pasang untuk mainkan"
   },
@@ -14,11 +17,8 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, other {# mod}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Pelayan ini memerlukan mod untuk dimainkan. Klik pasang untuk menyediakan fail yang diperlukan daripada Modrinth."
-  },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} berkongsi pemasangan ini dengan anda hari ini."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Pek mod yang diperlukan"
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Pemasangan yang dikongsi"
@@ -26,6 +26,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Pemasangan pelayan yang dikongsi"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Lihat kandungan"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} ditambah"
   },
@@ -83,39 +86,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Pengurusan sumber"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Modrinth App v{version} sudah bersedia untuk dipasang! Muat semula untuk kemas kini sekarang, atau kemas kini secara automatik apabila anda menutup Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} sudah selesai dipasang! Muat semula untuk kemas kini sekarang, atau kemas kini secara automatik apabila anda menutup Modrinth App."
+  "app.update-popup.body.download-complete": {
+    "message": "Modrinth App v{version} sudah selesai dimuat turun! Muat semula untuk kemas kini sekarang, atau kemas kini secara automatik apabila anda menutup Modrinth App."
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Modrinth App v{version} tersedia. Gunakan pengurus pakej anda untuk mengemas kini dan mendapatkan ciri-ciri dan pembetulan terkini!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version} kini tersedia! Memandangkan anda sedang menggunakan rangkaian bermeter, kami tidak memuat turunnya secara automatik."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Log perubahan"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Muat turun ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Muat turun"
+  "app.update-popup.download-complete": {
+    "message": "Muat turun selesai"
   },
-  "app.update-toast.downloading": {
-    "message": "Sedang memuat turun..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Muat semula"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Kemas kini tersedia"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Muat turun selesai"
-  },
   "app.update.complete-toast.text": {
     "message": "Klik di sini untuk melihat log perubahan."
   },
@@ -464,6 +461,9 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(versi tidak diketahui)"
   },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Nyahpaut daripada pelayan"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Nyahpautkan pemasangan"
   },
@@ -551,6 +551,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Pelayan tidak serasi"
   },
+  "instance.worlds.linked_server": {
+    "message": "Diurus oleh projek pelayan"
+  },
   "instance.worlds.no_contact": {
     "message": "Pelayan tidak dapat dihubungi"
   },
@@ -586,5 +589,14 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Selaraskan dengan pemasangan"
+  },
+  "search.filter.locked.server": {
+    "message": "Disediakan oleh pelayan"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Versi permainan adalah disediakan oleh pelayan"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Pemuat adalah disediakan oleh pelayan"
   }
 }

apps/app-frontend/src/locales/nl-NL/index.json

@@ -1,10 +1,67 @@
 {
   "app.auth-servers.unreachable.body": {
-    "message": "Minecraft verificatie servers zijn mogelijk offline. Check je internetverbinding en probeer opnieuw later."
+    "message": "Minecraft authenticatie servers zijn mogelijk offline. Controleer je internetverbinding en probeer opnieuw later."
   },
   "app.auth-servers.unreachable.header": {
     "message": "Authenticatieservers kunnen niet worden bereikt"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Content vereist"
+  },
+  "app.modal.install-to-play.header": {
+    "message": "Installeer om te spelen"
+  },
+  "app.modal.install-to-play.install-button": {
+    "message": "Installeer"
+  },
+  "app.modal.install-to-play.mod-count": {
+    "message": "{count, plural,one {# mod}other {# mods}}"
+  },
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Vereist modpack"
+  },
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Deze server vereist mods om te spelen. Klik op Installeer om de vereiste bestanden van Modrinth in te stellen, en start direct in de server."
+  },
+  "app.modal.install-to-play.shared-instance": {
+    "message": "Gedeelde instantie"
+  },
+  "app.modal.install-to-play.shared-server-instance": {
+    "message": "Gedeelde server instantie"
+  },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Toon content"
+  },
+  "app.modal.update-to-play.added-count": {
+    "message": "{count} toegevoegd"
+  },
+  "app.modal.update-to-play.diff-type.added": {
+    "message": "Toegevoegd"
+  },
+  "app.modal.update-to-play.diff-type.removed": {
+    "message": "Verwijderd"
+  },
+  "app.modal.update-to-play.diff-type.updated": {
+    "message": "Geüpdatet"
+  },
+  "app.modal.update-to-play.header": {
+    "message": "Update om te spelen"
+  },
+  "app.modal.update-to-play.published-date": {
+    "message": "{date, date, long}"
+  },
+  "app.modal.update-to-play.removed-count": {
+    "message": "{count} verwijderd"
+  },
+  "app.modal.update-to-play.update-required": {
+    "message": "Update vereist"
+  },
+  "app.modal.update-to-play.update-required-description": {
+    "message": "Een update is vereist om {name} te spelen. Update naar de laatste versie om het spel te starten."
+  },
+  "app.modal.update-to-play.updated-count": {
+    "message": "{count} geüpdatet"
+  },
   "app.settings.developer-mode-enabled": {
     "message": "Ontwikkelaarsmodus ingeschakeld."
   },
@@ -32,33 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Bronnenbeheer"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Modrinth App v{version} is klaar om geïnstalleerd te worden! Herlaad om nu te updaten, of automatisch wanneer je de Modrinth App afsluit."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Modrinth App v{version} is klaar met downloaden. Herlaad om nu te updaten, of automatisch wanneer je de Modrinth App afsluit."
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.linux": {
+    "message": "Modrinth App v{version} is beschikbaar. Gebruik je pakketbeheerder om te updaten voor de laatste functies en oplossingen!"
+  },
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version} is nu beschikbaar! Omdat je nu op een netwerk met datalimiet zit, is de download niet automatisch gestart."
   },
-  "app.update-toast.changelog": {
-    "message": "Wijzigingenlogboek"
+  "app.update-popup.changelog": {
+    "message": "Wijzigingen"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Download ({size})"
   },
-  "app.update-toast.downloading": {
-    "message": "Aan het downloaden..."
+  "app.update-popup.download-complete": {
+    "message": "Downloaden voltooid"
   },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Herlaad"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Update beschikbaar"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Downloaden voltooid"
-  },
   "app.update.complete-toast.text": {
     "message": "Klik hier om het wijzigingenlogboek te bekijken."
   },
@@ -407,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(Onherkende versie)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Deze instantie is gekoppeld aan een server, wat betekent dat je de Minecraft versie niet kunt wijzigen. Ontkoppelen zal deze instantie definitief van de server loskoppelen."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Deze instantie is gekoppeld aan een server, wat betekent dat mods niet kunnen worden bijgewerkt en je de modloader of Minecraft-versie niet kunt wijzigen. Ontkoppelen zal deze instantie definitief van de server loskoppelen."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Ontkoppel van server"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Ontkoppel exemplaar"
   },
@@ -494,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Server is niet compatibel"
   },
+  "instance.worlds.linked_server": {
+    "message": "Beheerd door serverproject"
+  },
   "instance.worlds.no_contact": {
     "message": "Server kon niet worden bereikt"
   },
@@ -529,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Synchroniseer installatie"
+  },
+  "search.filter.locked.server": {
+    "message": "Aangeleverd door de server"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Alleen client-side mods kunnen toegevoegd worden aan de server instantie"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Spel versie is gegeven door de server"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Loader is gegeven door de server"
   }
 }

apps/app-frontend/src/locales/no-NO/index.json

@@ -5,6 +5,51 @@
   "app.auth-servers.unreachable.header": {
     "message": "Kan ikke nå autentiseringsservere"
   },
+  "app.modal.install-to-play.header": {
+    "message": "Installer for å spille"
+  },
+  "app.modal.install-to-play.install-button": {
+    "message": "Installer"
+  },
+  "app.modal.install-to-play.mod-count": {
+    "message": "{count, plural, one {#mod} other {# mods}}"
+  },
+  "app.modal.install-to-play.shared-instance": {
+    "message": "Delt instans"
+  },
+  "app.modal.install-to-play.shared-server-instance": {
+    "message": "Delt serverinstans"
+  },
+  "app.modal.update-to-play.added-count": {
+    "message": "{count} lagt til"
+  },
+  "app.modal.update-to-play.diff-type.added": {
+    "message": "Lagt til"
+  },
+  "app.modal.update-to-play.diff-type.removed": {
+    "message": "Fjerna"
+  },
+  "app.modal.update-to-play.diff-type.updated": {
+    "message": "Oppdatert"
+  },
+  "app.modal.update-to-play.header": {
+    "message": "Oppdater for å spille"
+  },
+  "app.modal.update-to-play.published-date": {
+    "message": "{date, date, long}"
+  },
+  "app.modal.update-to-play.removed-count": {
+    "message": "{count} fjerna"
+  },
+  "app.modal.update-to-play.update-required": {
+    "message": "Krever oppdatering"
+  },
+  "app.modal.update-to-play.update-required-description": {
+    "message": "Ei oppdatering er påkrevd for å spille {name}. Vær så snill å oppdater til den siste versjonen av spillet for å spille det."
+  },
+  "app.modal.update-to-play.updated-count": {
+    "message": "Oppdaterte {count} mods"
+  },
   "app.settings.developer-mode-enabled": {
     "message": "Utviklermodus aktivert."
   },
@@ -32,33 +77,6 @@
   "app.settings.tabs.resource-management": {
     "message": "Ressursforvaltning"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} er klar for installering! Last inn på nytt for å oppdatere nå, eller automatisk når du lukker Modrinth App."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} er ferdig lastet ned. Last in på nytt for å oppdatere nå, eller automatisk når du lukker Modrinth App."
-  },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version} er tilgjengelig nå! Siden du er på en forbruksmålt tilkobling, lastet vi den ikke ned automatisk."
-  },
-  "app.update-toast.changelog": {
-    "message": "Endringslogg"
-  },
-  "app.update-toast.download": {
-    "message": "Last ned ({size})"
-  },
-  "app.update-toast.downloading": {
-    "message": "Laster ned..."
-  },
-  "app.update-toast.reload": {
-    "message": "Last inn på nytt"
-  },
-  "app.update-toast.title": {
-    "message": "Oppdatering tilgjengelig"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Ferdig lastet ned"
-  },
   "app.update.complete-toast.text": {
     "message": "Klikk her for å se endringsloggen."
   },

apps/app-frontend/src/locales/pl-PL/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Nie udało się połączyć się z serwerami uwierzytelniania"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Wymagane treści"
+  },
   "app.modal.install-to-play.header": {
     "message": "Zainstaluj, aby grać"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# mod} few {# mody} other {# modów}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Ten serwer potrzebuje modów, aby grać. Kliknij, instaluj, aby ustawić potrzebne pliki z Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Wymagana paczka modów"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} dziś udostępnił/-a Ci tę instancję."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Ten serwer wymaga modów, aby na nim grać. Kliknij \"Zainstaluj\" aby otrzymać potrzebne pliki z Modrinth, a potem dołącz bezpośrednio do serwera."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Wspólna instancja"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Wspólna instancja serwera"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Pokaż zawartość"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "Dodano {count}"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Zarządzanie zasobami"
   },
-  "app.update-toast.body": {
-    "message": "Wersja Modrinth App v{version} jest gotowa do zainstalowania! Odśwież, żeby zaktualizować teraz, albo automatycznie, gdy zamkniesz aplikacje Modrinth."
+  "app.update-popup.body": {
+    "message": "Wersja Modrinth App v{version} jest gotowa do zainstalowania! Załaduj ponownie, żeby zaktualizować teraz, albo automatycznie, gdy zamkniesz Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
-    "message": "Wersja Modrinth App v{version} została pobrana. Odśwież, żeby zaktualizować teraz, albo automatycznie, gdy zamkniesz Modrinth App."
+  "app.update-popup.body.download-complete": {
+    "message": "Wersja Modrinth App v{version} została pobrana. Załaduj ponownie, żeby zaktualizować teraz, albo automatycznie, gdy zamkniesz Modrinth App."
   },
-  "app.update-toast.body.linux": {
-    "message": "Modrinth App v{version} jest dostępna. Użyj menedżera pakietów, aby zaktualizować i uzyskać najnowsze funkcje i poprawki!"
+  "app.update-popup.body.linux": {
+    "message": "Wersja Modrinth App v{version} jest dostępna. Pobierz aktualizację poprzez menedżer pakietów, by uzyskać najnowsze funkcje i poprawki!"
   },
-  "app.update-toast.body.metered": {
-    "message": "Wersja v{version} Modrinth App jest dostępna! Skoro korzystasz z sieci taryfowej, nie pobraliśmy jej automatycznie."
+  "app.update-popup.body.metered": {
+    "message": "Wersja Modrinth App v{version} jest dostępna! Skoro korzystasz z sieci taryfowej, nie pobraliśmy jej automatycznie."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Dziennik zmian"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Pobierz ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Pobierz"
+  "app.update-popup.download-complete": {
+    "message": "Pobieranie ukończone"
   },
-  "app.update-toast.downloading": {
-    "message": "Pobieranie..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Załaduj ponownie"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Dostępna aktualizacja"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Pobieranie ukończone"
-  },
   "app.update.complete-toast.text": {
     "message": "Kliknij, by pokazać dziennik zmian."
   },
@@ -464,17 +464,26 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(nieznana wersja)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Ta instancja jest powiązana z serwerem, co oznacza, że nie możesz zmienić wersji gry. Rozłączenie spowoduje trwałe odłączenie tej instancji od serwera."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Ta instancja jest powiązana z serwerem, co oznacza, że mody nie mogą być aktualizowane i nie można zmienić ani loadera, ani wersji gry. Rozłączenie spowoduje trwałe odłączenie tej instancji od serwera."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Rozłącz od serwera"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Rozłącz instancję"
   },
   "instance.settings.tabs.installation.unlink.confirm.description": {
-    "message": "Jeśli przejdziesz dalej, nie będziesz mógł jej ponownie złączyć, bez tworzenia kompletnie nowej instancji. Nie będziesz otrzymywał aktualizacji paczki modów i zamieni się w normalną instancję."
+    "message": "Jeśli przejdziesz dalej, nie będziesz mógł ponownie złączyć tej instancji bez tworzenia całkowicie nowej. Nie będziesz otrzymywać aktualizacji i zostanie ona przekształcona w zwykłą instancję."
   },
   "instance.settings.tabs.installation.unlink.confirm.title": {
     "message": "Czy jesteś pewien, że chcesz rozłączyć tę instancję?"
   },
   "instance.settings.tabs.installation.unlink.description": {
-    "message": "Ta instancja jest powiązana z paczką modów, co oznacza, że mody nie mogą być aktualizowane i nie można zmienić silnika gry ani wersji Minecrafta. Odłączenie spowoduje trwałe odłączenie tej instancji od paczki modów."
+    "message": "Ta instancja jest powiązana z paczką modów, co oznacza, że mody nie mogą być aktualizowane i nie można zmienić ani loadera, ani wersji gry. Rozłączenie spowoduje trwałe odłączenie tej instancji od paczki modów."
   },
   "instance.settings.tabs.installation.unlink.title": {
     "message": "Rozłącz od paczki modów"
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Serwer jest nie kompatybilny"
   },
+  "instance.worlds.linked_server": {
+    "message": "Zarządzane przez serwer"
+  },
   "instance.worlds.no_contact": {
     "message": "Nie można nawiązać połączenia z serwerem"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Synchronizuj z instancją"
+  },
+  "search.filter.locked.server": {
+    "message": "Dostarczone przez serwer"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Tylko mody po stronie klienta mogą być dodane do instancji serwera"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Wersja gry jest dostarczona przez serwer"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Loader jest dostarczony przez serwer"
   }
 }

apps/app-frontend/src/locales/pt-BR/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Não foi possível acessar os servidores de autenticação"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Conteúdo necessário"
+  },
   "app.modal.install-to-play.header": {
     "message": "Instale para jogar"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, =0 {Nenhum mod} one {# mod} other {# mods}}\n"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Este servidor requer mods para jogar. Clique em Instalar para configurar os arquivos necessários a partir do Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Pacote de mods necessário"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} compartilhou esta instância com você hoje."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Este servidor requer mods para jogar. Clique em Instalar para configurar os arquivos necessários a partir do Modrinth, e iniciar diretamente no servidor."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Instância compartilhada"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Instância de servidor compartilhada"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Ver conteúdos"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} adicionado"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Gerenciamento de recursos"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "O Modrinth App v{version} está pronto para ser instalado! Você pode recarregar para atualizar agora ou a atualização será feita automaticamente ao fechar o Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "O Modrinth App v{version} baixado. Recarregue para atualizar agora ou a atualização será aplicada automaticamente ao fechar o Modrinth App."
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "O Modrinth App v{version} está disponível. Use seu gerenciador de pacotes para atualizar e obter os recursos e correções mais recentes!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "O Modrinth App v{version} já está disponível! Como você está em uma rede limitada, não o baixamos automaticamente."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Mudanças"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Baixar ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Baixar"
-  },
-  "app.update-toast.downloading": {
-    "message": "Baixando..."
-  },
-  "app.update-toast.reload": {
-    "message": "Atualizar"
-  },
-  "app.update-toast.title": {
-    "message": "Atualização disponível"
-  },
-  "app.update-toast.title.download-complete": {
+  "app.update-popup.download-complete": {
     "message": "Download concluído"
   },
+  "app.update-popup.reload": {
+    "message": "Recarregar"
+  },
+  "app.update-popup.title": {
+    "message": "Atualização disponível"
+  },
   "app.update.complete-toast.text": {
     "message": "Clique aqui para ver as mudanças."
   },
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(versão desconhecida)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Esta instância está vinculada a um servidor, o que significa que você não pode alterar a versão do Minecraft. Ao desvincular, esta instância será permanentemente desconectada do servidor."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Esta instância está vinculada a um servidor, o que significa que mods não podem ser atualizados e você não pode alterar o carregador de mods ou a versão do Minecraft. Desvincular desconectará permanentemente esta instância do servidor."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Desvincular do servidor"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Desvincular instância"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Servidor incompatível"
   },
+  "instance.worlds.linked_server": {
+    "message": "Gerenciado pelo projeto do servidor"
+  },
   "instance.worlds.no_contact": {
     "message": "Não foi possível conectar-se ao servidor"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Sincronizar com a instância"
+  },
+  "search.filter.locked.server": {
+    "message": "Fornecido pelo servidor"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Apenas mods do lado do cliente podem ser adicionados à instância do servidor"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "A versão do jogo é fornecida pelo servidor"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "O carregador é fornecido pelo servidor"
   }
 }

apps/app-frontend/src/locales/pt-PT/index.json

@@ -14,12 +14,6 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {mod} other {mods}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Este servidor requer mods para jogares. Clica instalar para transferir os ficheiros necessários do Modrinth."
-  },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} partilhou esta instância contigo hoje."
-  },
   "app.modal.install-to-play.shared-instance": {
     "message": "Instância partilhada"
   },
@@ -48,7 +42,7 @@
     "message": "{count} removidos"
   },
   "app.modal.update-to-play.update-required": {
-    "message": "Atualização necessitada"
+    "message": "Atualização necessária"
   },
   "app.modal.update-to-play.update-required-description": {
     "message": "Uma atualização é necessária para jogar {name}. Por favor atualiza para a versão mais recente para iniciar o jogo."
@@ -83,39 +77,6 @@
   "app.settings.tabs.resource-management": {
     "message": "Gestão de recursos"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} está pronta para ser instalada! Recarrega para atualizar agora, ou automaticamente quando fechares a Modrinth App."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} acabou de ser transferida. Recarrega para atualizar agora, ou automaticamente quando fechares a Modrinth App."
-  },
-  "app.update-toast.body.linux": {
-    "message": "Modrinth App v{version} está disponível. Usa o teu gestor de pacotes para atualizar e receber as correções e recursos mais recentes!"
-  },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version} está disponível! Como estás numa rede com tráfego limitado, não a transferimos automaticamente."
-  },
-  "app.update-toast.changelog": {
-    "message": "Lista de alterações"
-  },
-  "app.update-toast.download": {
-    "message": "Transferir ({size})"
-  },
-  "app.update-toast.download-page": {
-    "message": "Transferir"
-  },
-  "app.update-toast.downloading": {
-    "message": "A transferir..."
-  },
-  "app.update-toast.reload": {
-    "message": "Recarregar"
-  },
-  "app.update-toast.title": {
-    "message": "Atualização disponível"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Transferência concluída"
-  },
   "app.update.complete-toast.text": {
     "message": "Clica aqui para ver a lista de alterações."
   },

apps/app-frontend/src/locales/ro-RO/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Nu se pot accesa serverele de autentificare"
   },
+  "app.modal.install-to-play.install-button": {
+    "message": "Instalează"
+  },
   "app.settings.developer-mode-enabled": {
     "message": "Modul dezvoltator activat."
   },
@@ -32,33 +35,6 @@
   "app.settings.tabs.resource-management": {
     "message": "Administrare resurse"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} este gata de instalare! Reîncarcă pentru a actualiza acum, sau automat când închizi Modrinth App."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} a terminat descărcarea. Reîncarcă pentru a actualiza acum, sau automat când închizi Modrinth App."
-  },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version} este disponibilă acum! Deoarece ești pe o rețea cu trafic limitat, nu am descărcat-o automat."
-  },
-  "app.update-toast.changelog": {
-    "message": "Istoric modificări"
-  },
-  "app.update-toast.download": {
-    "message": "Descarcă ({size})"
-  },
-  "app.update-toast.downloading": {
-    "message": "Se descarcă..."
-  },
-  "app.update-toast.reload": {
-    "message": "Reîncarcă"
-  },
-  "app.update-toast.title": {
-    "message": "Actualizare disponibilă"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Descărcare completă"
-  },
   "app.update.complete-toast.text": {
     "message": "Apasă aici pentru a vedea istoricul de modificări."
   },

apps/app-frontend/src/locales/ru-RU/index.json

@@ -5,8 +5,11 @@
   "app.auth-servers.unreachable.header": {
     "message": "Нет связи с серверами аутентификации"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Требуется дополнительный контент"
+  },
   "app.modal.install-to-play.header": {
-    "message": "Установите, чтобы играть"
+    "message": "Установка перед запуском"
   },
   "app.modal.install-to-play.install-button": {
     "message": "Установить"
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# мод} few {# мода} other {# модов}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Для игры на сервере требуются моды. Установите необходимые файлы с Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Необходимая сборка"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "Сегодня {name} делится с вами этой сборкой."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Для игры на сервере требуются моды. Установите необходимые файлы с Modrinth, чтобы подключиться."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Сборка"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Общая сборка сервера"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Посмотреть содержимое"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count, plural, one {# добавление} few {# добавления} other {# добавлений}}"
   },
@@ -39,7 +45,7 @@
     "message": "Обновлён"
   },
   "app.modal.update-to-play.header": {
-    "message": "Обновите перед запуском"
+    "message": "Обновление перед запуском"
   },
   "app.modal.update-to-play.published-date": {
     "message": "{date, date, long}"
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Управление ресурсами"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Версия Modrinth App {version} готова к установке! Перезапустите приложение, чтобы обновить его, или оно обновится автоматически после закрытия."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Скачивание версии Modrinth App {version} завершено. Перезапустите приложение, чтобы обновить его, или оно обновится автоматически после закрытия."
   },
-  "app.update-toast.body.linux": {
-    "message": "Доступна версия Modrinth App {version}. Обновите приложение через менеджер пакетов и получите последние улучшения и исправления!"
+  "app.update-popup.body.linux": {
+    "message": "Доступна версия Modrinth App {version}. Обновите приложение через менеджер пакетов, чтобы получить последние улучшения и исправления!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Версия Modrinth App {version} доступна для скачивания! Используется сеть с лимитным тарифным планом, поэтому скачивание не началось автоматически."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Список изменений"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Скачать ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Скачать"
+  "app.update-popup.download-complete": {
+    "message": "Скачивание завершено"
   },
-  "app.update-toast.downloading": {
-    "message": "Скачивание..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Перезапустить"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Доступно обновление"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Скачивание завершено"
-  },
   "app.update.complete-toast.text": {
     "message": "Нажмите здесь, чтобы посмотреть изменения."
   },
@@ -153,7 +153,7 @@
     "message": "Какое имя у друга на Modrinth?"
   },
   "friends.add-friends-to-share": {
-    "message": "<link>Добавьте друзей</link>, чтобы видеть их статус игры!"
+    "message": "<link>Добавьте друзей</link>, чтобы видеть, во что они играют!"
   },
   "friends.friend.cancel-request": {
     "message": "Отменить запрос"
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(неизвестная версия)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Текущее содержимое связано с сервером — смена версии игры недоступна. Отвязка сервера необратимо разорвёт эту связь."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Текущее содержимое связано с сервером — обновление модов и смена загрузчика или версии игры недоступны. Отвязка сервера необратимо разорвёт эту связь."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Отвязка сервера"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Отвязать сборку"
   },
@@ -474,7 +483,7 @@
     "message": "Вы действительно хотите отвязать сборку?"
   },
   "instance.settings.tabs.installation.unlink.description": {
-    "message": "Эта сборка связана с модпаком, что означает, что моды не могут быть обновлены, и вы не можете изменить загрузчик или версию Minecraft. Отвязка приведет к постоянному отключению этой сборки от модпака."
+    "message": "Текущее содержимое связано со сборкой на Modrinth — обновление модов и смена загрузчика или версии игры недоступны. Отвязка сборки необратимо разорвёт эту связь."
   },
   "instance.settings.tabs.installation.unlink.title": {
     "message": "Отвязка сборки"
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Сервер несовместим"
   },
+  "instance.worlds.linked_server": {
+    "message": "Управляется серверным проектом"
+  },
   "instance.worlds.no_contact": {
     "message": "Не удалось связаться с сервером"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Использовать из сборки"
+  },
+  "search.filter.locked.server": {
+    "message": "Управляется сервером"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "В серверную сборку можно добавлять только моды для клиента"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Версия игры управляется сервером"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Загрузчик управляется сервером"
   }
 }

apps/app-frontend/src/locales/sv-SE/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Kan ej nå autentiseringsservrarna"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Innehåll krävs"
+  },
   "app.modal.install-to-play.header": {
     "message": "Installera för att spela"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# mod} other {# moddar}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Servern kräver moddar för att du ska kunna spela. Tryck på installera för att sätta upp dem nödvändiga filerna från Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Modpaket som krävs"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} delade denna instans med dig idag."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Servern kräver moddar för att du ska kunna spela. Klicka på Installera för att sätta upp dem nödvändiga filerna från Modrinth, och starta sedan på servern direkt."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Delad instans"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Delad serverinstans"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Visa innehåll"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} tillagda"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Resurshantering"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Modrinth App v{version} är redo att laddas ner! Ladda om för att uppdatera nu, eller automatiskt när du stänger Modrinth App."
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Modrinth App v{version} har laddats ner. Ladda om för att uppdatera nu, eller automatiskt när du stänger Modrinth App."
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Modrinth App v{version} är tillgänglig. Använd din pakethanterare för att uppdatera och få tillgång till de senaste funktionerna och buggfixarna!"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version} är nu tillgänglig! Eftersom du använder ett nätverk med datatrafikbegränsningar har vi inte laddat ner det automatiskt."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Ändringslogg"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Ladda ner ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Ladda ner"
+  "app.update-popup.download-complete": {
+    "message": "Nedladdning slutförd"
   },
-  "app.update-toast.downloading": {
-    "message": "Laddar ner..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "Ladda om"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Uppdatering tillgänglig"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Nedladdning slutförd"
-  },
   "app.update.complete-toast.text": {
     "message": "Tryck här för att visa ändringsloggen."
   },
@@ -243,7 +243,7 @@
     "message": "Namn"
   },
   "instance.server-modal.placeholder-name": {
-    "message": "Minecraft Server"
+    "message": "Minecraft-server"
   },
   "instance.server-modal.resource-pack": {
     "message": "Resurs pack"
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(okänd version)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Denna instans är länkad till en server, vilket betyder att du inte kan ändra Minecraft-version. Att avlänka kommer koppla bort instansen från servern permanent."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Denna instans är länkad till en server, vilket innebär att moddar inte kan uppdateras och mod-loader eller Minecraft-version inte kan ändras. Att avlänka kommer koppla bort instansen från servern permanent."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Avlänka från server"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Ta bort koppling till instans"
   },
@@ -474,7 +483,7 @@
     "message": "Är du säker att du vill ta bort koppling till denna instans?"
   },
   "instance.settings.tabs.installation.unlink.description": {
-    "message": "Denna instans är kopplad till ett modpaket, vilket innebär att moddar inte kan uppdateras och mod-loader eller Minecraft version inte kan ändras. Att ta bort kopplingen kommer permanent att koppla bort denna instans från modpaketet."
+    "message": "Denna instans är länkad till ett modpaket, vilket innebär att moddar inte kan uppdateras och mod-loader eller Minecraft-version inte kan ändras. Att avlänka kommer koppla bort instansen från modpaketet permanent."
   },
   "instance.settings.tabs.installation.unlink.title": {
     "message": "Ta bort koppling från modpack"
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Servern är inkompatibel"
   },
+  "instance.worlds.linked_server": {
+    "message": "Hanteras av serverprojekt"
+  },
   "instance.worlds.no_contact": {
     "message": "Servern kunde inte kontaktas"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Synkronisera med instansen"
+  },
+  "search.filter.locked.server": {
+    "message": "Tillhandahållet av servern"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Endast klient-sido moddar kan läggas till i serverinstansen"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Spelversion tillhandahålls av servern"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Loader tillhandahålls av servern"
   }
 }

apps/app-frontend/src/locales/th-TH/index.json

@@ -59,39 +59,6 @@
   "app.settings.tabs.resource-management": {
     "message": "การจัดการทรัพยากร"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} พร้อมติดตั้งแล้ว! รีโหลดเพื่ออัปเดตทันที หรือจะอัปเดตอัตโนมัติเมื่อคุณปิดแอป"
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} ดาวน์โหลดเสร็จแล้ว! รีโหลดเพื่ออัปเดตทันที หรือจะอัปเดตอัตโนมัติเมื่อคุณปิดแอป"
-  },
-  "app.update-toast.body.linux": {
-    "message": "แอป Modrinth v{version} มีให้อัปเดตแล้ว. ใช้ Package Manager ของคุณเพื่ออัปเดตให้มีฟีเจอร์ใหม่และแก้ไข!"
-  },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version} พร้อมให้ดาวน์โหลดแล้ว! เนื่องจากคุณกำลังใช้งานเครือข่ายที่มีการคิดค่าใช้จ่ายตามปริมาณข้อมูล ระบบจึงไม่ได้ดาวน์โหลดอัตโนมัติ"
-  },
-  "app.update-toast.changelog": {
-    "message": "บันทึกการเปลี่ยนแปลง"
-  },
-  "app.update-toast.download": {
-    "message": "ดาวน์โหลด ({size})"
-  },
-  "app.update-toast.download-page": {
-    "message": "ดาวน์โหลด"
-  },
-  "app.update-toast.downloading": {
-    "message": "กำลังดาวน์โหลด...."
-  },
-  "app.update-toast.reload": {
-    "message": "รีโหลด"
-  },
-  "app.update-toast.title": {
-    "message": "อัพเดตพร้อมแล้ว"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "ดาวน์โหลดเรียบร้อยแล้ว"
-  },
   "app.update.complete-toast.text": {
     "message": "คลิกที่นี่เพื่อดูบันทึกการเปลี่ยนแปลง"
   },

apps/app-frontend/src/locales/tr-TR/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Doğrulama sunucularına erişilemedi"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "İçerik gerekli"
+  },
   "app.modal.install-to-play.header": {
     "message": "Yükleyip oynayın"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural,one {#mod}other {#modlar}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Bu sunucuda oynamak için modlar gerekiyor. İndir'e basarak gerekli dosyaları Modrinth üzerinden kurabilirsin."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Gerekli mod paketi"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} bugün senle bu Kurulumu paylaştı."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Bu sunucuya girebilmek için modlar gereklidir. Gerekli dosyaları Modrinth üzerinden kurmak için Yükle butonuna tıkla, ardından doğrudan sunucuya başlat."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Paylaşılan Kurulum"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Paylaşılan Sunucu Kurulumu"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "İçeriği görüntüle"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "{count} eklendi"
   },
@@ -39,7 +45,7 @@
     "message": "Güncellendi"
   },
   "app.modal.update-to-play.header": {
-    "message": "Oynamak için güncelleyin"
+    "message": "Oynamak için güncelle"
   },
   "app.modal.update-to-play.published-date": {
     "message": "{date, date, long}"
@@ -83,41 +89,35 @@
   "app.settings.tabs.resource-management": {
     "message": "Kaynak yönetimi"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} indirilmeye hazır! Şimdi güncellemek için uygulamayı yeniden yükleyin ya da veya Modrinth App'i kapattığınızda otomatik olarak güncellensin."
+  "app.update-popup.body": {
+    "message": "Modrinth App v{version} güncellemesi hazır! Hemen güncellemek için yeniden yükle veya Modrinth App’i kapattığında otomatik olarak güncellenecek."
   },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} indirildi. Şimdi güncellemek için uygulamayı yeniden yükleyin ya da Modrinth App'i kapattığınızda otomatik olarak güncellensin."
+  "app.update-popup.body.download-complete": {
+    "message": "Modrinth App v{version} indirildi. Güncellemek için sayfayı yeniden yükle veya Modrinth App’i kapattığında otomatik olarak güncellenecek."
   },
-  "app.update-toast.body.linux": {
-    "message": "Modrinth App v{version} sürümü kullanılabilir. En yeni özellikler ve düzeltmeler için paket yöneticinizi kullanarak güncelleyin!"
+  "app.update-popup.body.linux": {
+    "message": "Modrinth App v{version} yayımlandı. En yeni özellikler ve hata düzeltmeleri için paket yöneticin üzerinden güncelle!"
   },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version} artık mevcut! Ölçülü ağda olduğunuzdan otomatik olarak indirmedik."
+  "app.update-popup.body.metered": {
+    "message": "Modrinth App v{version} artık mevcut! Ölçüllü bağlantıda olduğunuzdan otomatik olarak indirmedik."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Değişiklikler"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "İndir ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "İndir"
+  "app.update-popup.download-complete": {
+    "message": "İndirme tamamlandı"
   },
-  "app.update-toast.downloading": {
-    "message": "İndiriliyor..."
+  "app.update-popup.reload": {
+    "message": "Yeniden yükle"
   },
-  "app.update-toast.reload": {
-    "message": "Yeniden Yükle"
-  },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "Güncelleme mevcut"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "Yükleme tamamlandı"
-  },
   "app.update.complete-toast.text": {
-    "message": "Değişiklik günlüğünü görüntülemek için buraya tıklayın."
+    "message": "Değişiklikleri görüntülemek için buraya tıklayın."
   },
   "app.update.complete-toast.title": {
     "message": "{version} sürümü başarıyla kuruldu!"
@@ -258,7 +258,7 @@
     "message": "Profili sil"
   },
   "instance.settings.tabs.general.delete.description": {
-    "message": "Profili, içindeki dünyaları, ayarları ve indirilen şeyleri cihazından sonsuza kadar siler. Bir profil silindikten sonra geri dönüşü yok. Dikkatli ol."
+    "message": "Profili, içindeki dünyaları, ayarları ve indirilen şeyleri cihazınızdan sonsuza kadar siler. Dikkatli olun, bir profil silindikten sonra geri alınamaz."
   },
   "instance.settings.tabs.general.deleting.button": {
     "message": "Siliniyor..."
@@ -288,7 +288,7 @@
     "message": "Simge seç"
   },
   "instance.settings.tabs.general.library-groups": {
-    "message": "Gruplar"
+    "message": "Kütüphane grupları"
   },
   "instance.settings.tabs.general.library-groups.create": {
     "message": "Yeni grup oluştur"
@@ -312,40 +312,40 @@
     "message": "Kancalar gelişmiş kullanıcıların oyunu başlattıktan önce ve sonra belirli sistem komutları çalıştırmasını sağlar."
   },
   "instance.settings.tabs.hooks.post-exit": {
-    "message": "Çıkış-sonrası"
+    "message": "Çıkış sonrası"
   },
   "instance.settings.tabs.hooks.post-exit.description": {
     "message": "Oyun kapandıktan sonra çalışır."
   },
   "instance.settings.tabs.hooks.post-exit.enter": {
-    "message": "Çıkış-sonrası komutu gir..."
+    "message": "Çıkış sonrası komutu girin..."
   },
   "instance.settings.tabs.hooks.pre-launch": {
-    "message": "Başlatma-öncesi"
+    "message": "Başlatma öncesi"
   },
   "instance.settings.tabs.hooks.pre-launch.description": {
-    "message": "Oyunu başlatmadan önce çalıştırır."
+    "message": "Oyun başlatılmadan önce çalıştırılır."
   },
   "instance.settings.tabs.hooks.pre-launch.enter": {
-    "message": "Başlatma-öncesi komutu gir..."
+    "message": "Başlatma öncesi komutu girin..."
   },
   "instance.settings.tabs.hooks.title": {
     "message": "Oyun başlatma kancaları"
   },
   "instance.settings.tabs.hooks.wrapper": {
-    "message": "Örtü"
+    "message": "Sarmalayıcı"
   },
   "instance.settings.tabs.hooks.wrapper.description": {
-    "message": "Minecraft başlatmak için örtü komutu."
+    "message": "Minecraft'ı başlatmak için sarmalayıcı komutu."
   },
   "instance.settings.tabs.hooks.wrapper.enter": {
-    "message": "Örtü komutunu girin..."
+    "message": "Sarmalayıcı komutu girin..."
   },
   "instance.settings.tabs.installation": {
     "message": "Kurulum"
   },
   "instance.settings.tabs.installation.change-version.already-installed.modded": {
-    "message": "Minecraft {game_version} için {platform} {version} zaten kurulmuş"
+    "message": "Minecraft {game_version} için {platform} {version} zaten kurulu"
   },
   "instance.settings.tabs.installation.change-version.already-installed.vanilla": {
     "message": "Vanilla {game_version} zaten kurulu"
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(bilinmeyen sürüm)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Bu örnek bir sunucuya bağlıdır, bu da Minecraft sürümünü değiştiremeyeceğin anlamına gelir. Bağlantıyı kesmek, bu örneği sunucudan kalıcı olarak ayıracaktır."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Bu örnek bir sunucuya bağlıdır, bu da modların güncellenemeyeceği ve mod yükleyicisini veya Minecraft sürümünü değiştiremeyeceğin anlamına gelir. Bağlantıyı kaldırmak, bu örneği sunucudan kalıcı olarak ayıracaktır."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Sunucudan ayrıl"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Kurulum bağlantısını kes"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Sunucu uyumlu değil"
   },
+  "instance.worlds.linked_server": {
+    "message": "Sunucu projesi tarafından yönetilmektedir"
+  },
   "instance.worlds.no_contact": {
     "message": "Sunucuya erişilemedi"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Kurulumla senkronize et"
+  },
+  "search.filter.locked.server": {
+    "message": "Sunucu tarafından sağlanmıştır"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "Sunucu örneğine yalnızca istemci tarafında çalışan modlar eklenebilir"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Oyun sürümü sunucu tarafından sağlanıyor"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Yükleyici sunucu tarafından sağlanıyor"
   }
 }

apps/app-frontend/src/locales/uk-UA/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "Не вдається зв’язатися зі серверами автентифікації"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "Потрібний уміст"
+  },
   "app.modal.install-to-play.header": {
     "message": "Установлення для гри"
   },
@@ -14,11 +17,11 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count, plural, one {# мод} few {# мода} other {# модів}}"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "Для гри на цьому сервері потрібні моди. Натисніть «Установити», щоб завантажити необхідні файли з Modrinth."
+  "app.modal.install-to-play.required-modpack": {
+    "message": "Потрібна збірка"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} ділиться цим профілем з вами."
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "Для гри на цьому сервері потрібні моди. Натисніть «Установити», щоб налаштувати необхідні файли з Modrinth, а потім запустіть безпосередньо на сервері."
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "Профіль"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "Серверний профіль"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "Дивитися вміст"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "Додано {count}"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "Керування ресурсами"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} готовий до встановлення! Перезапустіть, щоб оновити зараз. Або, оновлення буде здійснено автоматично, коли закриєте Modrinth App."
+  "app.update-popup.body": {
+    "message": "Modrinth App v{version} готовий до встановлення! Перезапустіть, щоб оновити зараз. Або, оновлення буде здійснено автоматично, коли закриєте застосунок Modrinth."
   },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} завантажено. Перезапустіть зараз, щоб оновити застосунок, або оновлення відбудеться автоматично після закриття Modrinth App."
+  "app.update-popup.body.download-complete": {
+    "message": "Modrinth App v{version} завантажено. Перезапустіть зараз, щоб оновити його, або це відбудеться автоматично після закриття Modrinth App."
   },
-  "app.update-toast.body.linux": {
-    "message": "Доступна версія Modrinth App {version}. Скористайтеся вашим менеджером пакетів, щоб отримати найновіші функції та виправлення!"
+  "app.update-popup.body.linux": {
+    "message": "Modrinth App v{version} вже доступно. Скористайтеся вашим менеджером пакетів, щоб отримати найновіші функції та виправлення!"
   },
-  "app.update-toast.body.metered": {
-    "message": "Версія {version} Modrinth App доступна для завантаження! Оскільки ви на лімітному з’єднанні, ми не завантажили її автоматично."
+  "app.update-popup.body.metered": {
+    "message": "Modrinth App v{version} доступний для завантаження! Оскільки ви на лімітному з’єднанні, ми не завантажили його автоматично."
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "Журнал змін"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "Завантажити ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "Завантажити"
-  },
-  "app.update-toast.downloading": {
-    "message": "Завантаження…"
-  },
-  "app.update-toast.reload": {
-    "message": "Перезапустити"
-  },
-  "app.update-toast.title": {
-    "message": "Доступне оновлення"
-  },
-  "app.update-toast.title.download-complete": {
+  "app.update-popup.download-complete": {
     "message": "Завантаження завершено"
   },
+  "app.update-popup.reload": {
+    "message": "Перезавантажити"
+  },
+  "app.update-popup.title": {
+    "message": "Доступне оновлення"
+  },
   "app.update.complete-toast.text": {
     "message": "Натисніть тут, щоб переглянути журнал змін."
   },
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "(невідома версія)"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "Цей профіль пов’язаний із сервером, що означає, що ви не можете змінити версію Minecraft. Від’єднання назавжди від’єднає цей профіль від сервера."
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "Цей профіль пов’язаний із сервером, що означає, що моди не можна оновлювати, і ви не можете змінити завантажувач модів або версію Minecraft. Від’єднання назавжди від’єднає цей профіль від сервера."
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "Від'єднати від сервера"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "Відв’язати профіль"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "Сервер несумісний"
   },
+  "instance.worlds.linked_server": {
+    "message": "Керується серверним проєктом"
+  },
   "instance.worlds.no_contact": {
     "message": "Не вдалося зв’язатися зі сервером"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "Синхронізувати з профілем"
+  },
+  "search.filter.locked.server": {
+    "message": "Надано сервером"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "До профілю сервера можна додавати лише клієнтські моди"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "Версія гри надана сервером"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "Завантажувач наданий сервером"
   }
 }

apps/app-frontend/src/locales/vi-VN/index.json

@@ -32,33 +32,6 @@
   "app.settings.tabs.resource-management": {
     "message": "Quản lý tài nguyên"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth phiên bản v{version} đã sẵn sằng! Chạy lại để cập nhật ngay bây giờ, hoặc cập nhật tự động khi bạn đóng Modrinth."
-  },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth phiên bản v{version} đã tải xuống hoàn tất. Chạy lại để cập nhật ngay bây giờ, hoặc tự động cập nhật khi bạn thoát Modrinth."
-  },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth phiên bản v{version} đang có sẵn! Do mạng của bạn đang tính phí theo dung lượng và có định mức, chúng tôi không tải phiên bản này tự động."
-  },
-  "app.update-toast.changelog": {
-    "message": "Nhật ký thay đổi"
-  },
-  "app.update-toast.download": {
-    "message": "Tải xuống ({size})"
-  },
-  "app.update-toast.downloading": {
-    "message": "Đang tải xuống..."
-  },
-  "app.update-toast.reload": {
-    "message": "Tải lại"
-  },
-  "app.update-toast.title": {
-    "message": "Có bản cập nhật mới"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "Đã tải xuống xong"
-  },
   "app.update.complete-toast.text": {
     "message": "Nháy vào đây để xem nhật kí thay đổi."
   },

apps/app-frontend/src/locales/zh-CN/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "无法连接到身份验证服务器"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "内容需求"
+  },
   "app.modal.install-to-play.header": {
     "message": "安装以游玩"
   },
@@ -14,17 +17,20 @@
   "app.modal.install-to-play.mod-count": {
     "message": "{count} 个模组"
   },
-  "app.modal.install-to-play.server-requires-mods": {
-    "message": "此服务器需要安装模组才能游玩。点击安装，从 Modrinth 下载所需文件。"
+  "app.modal.install-to-play.required-modpack": {
+    "message": "整合包需求"
   },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} 今天与你分享了这个实例。"
+  "app.modal.install-to-play.server-requires-mods": {
+    "message": "此服务器需要安装模组才能游玩。点击安装，从 Modrinth 下载所需文件，然后直接进入服务器。"
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "共享实例"
   },
   "app.modal.install-to-play.shared-server-instance": {
-    "message": "共享服务端实例"
+    "message": "共享的服务端实例"
+  },
+  "app.modal.install-to-play.view-contents": {
+    "message": "查看内容"
   },
   "app.modal.update-to-play.added-count": {
     "message": "添加了 {count} 项"
@@ -83,38 +89,32 @@
   "app.settings.tabs.resource-management": {
     "message": "资源管理"
   },
-  "app.update-toast.body": {
+  "app.update-popup.body": {
     "message": "Modrinth App v{version} 更新已就绪！立即重启更新，或退出时自动安装。"
   },
-  "app.update-toast.body.download-complete": {
+  "app.update-popup.body.download-complete": {
     "message": "Modrinth App v{version} 更新已下载完成！立即重启更新，或退出时自动安装。"
   },
-  "app.update-toast.body.linux": {
+  "app.update-popup.body.linux": {
     "message": "Modrinth App v{version} 现已发布。请使用你的软件包管理器进行更新，获取最新功能与修复！"
   },
-  "app.update-toast.body.metered": {
+  "app.update-popup.body.metered": {
     "message": "Modrinth App v{version} 现已发布！由于你正在使用按流量计费的网络，该更新未自动下载。"
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "更新日志"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "下载（{size}）"
   },
-  "app.update-toast.download-page": {
-    "message": "下载"
+  "app.update-popup.download-complete": {
+    "message": "下载完成"
   },
-  "app.update-toast.downloading": {
-    "message": "下载中…"
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "重新启动"
   },
-  "app.update-toast.title": {
-    "message": "有可用更新"
-  },
-  "app.update-toast.title.download-complete": {
-    "message": "下载完成"
+  "app.update-popup.title": {
+    "message": "有可用的更新"
   },
   "app.update.complete-toast.text": {
     "message": "点击此处查看更新日志。"
@@ -162,7 +162,7 @@
     "message": "删除好友"
   },
   "friends.friend.request-sent": {
-    "message": "已发送好友请求"
+    "message": "已发送好友申请"
   },
   "friends.friend.view-profile": {
     "message": "查看个人资料"
@@ -222,10 +222,10 @@
     "message": "名称"
   },
   "instance.edit-world.placeholder-name": {
-    "message": "Minecraft 世界"
+    "message": "Minecraft 存档"
   },
   "instance.edit-world.reset-icon": {
-    "message": "重置图标"
+    "message": "重设图标"
   },
   "instance.edit-world.title": {
     "message": "编辑存档"
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "（未知版本）"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "该实例已关联至服务器，因此无法更改 Minecraft 版本。解除关联将永久断开该实例与服务器。"
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "该实例已关联至服务器，因此无法单独更新模组，也无法更改模组加载器和 Minecraft 版本。解除关联将永久断开该实例与服务器。"
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "与服务器解除关联"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "取消实例关联"
   },
@@ -477,7 +486,7 @@
     "message": "该实例已关联至整合包，因此无法单独更新模组，也无法更改模组加载器和 Minecraft 版本。解除关联后，该实例将无法重新关联至整合包。"
   },
   "instance.settings.tabs.installation.unlink.title": {
-    "message": "取消整合包关联"
+    "message": "解除整合包关联"
   },
   "instance.settings.tabs.java": {
     "message": "Java 及内存"
@@ -486,7 +495,7 @@
     "message": "环境变量"
   },
   "instance.settings.tabs.java.hooks": {
-    "message": "钩子"
+    "message": "Hooks"
   },
   "instance.settings.tabs.java.java-arguments": {
     "message": "Java 参数"
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "服务器不兼容"
   },
+  "instance.worlds.linked_server": {
+    "message": "由服务器项目管理"
+  },
   "instance.worlds.no_contact": {
     "message": "无法连接服务器"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "与实例同步"
+  },
+  "search.filter.locked.server": {
+    "message": "由该服务器提供"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "只能将客户端模组添加到服务器实例中"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "游戏版本由服务器提供"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "加载器由服务器提供"
   }
 }

apps/app-frontend/src/locales/zh-TW/index.json

@@ -5,6 +5,9 @@
   "app.auth-servers.unreachable.header": {
     "message": "無法連線到驗證伺服器"
   },
+  "app.modal.install-to-play.content-required": {
+    "message": "所需內容"
+  },
   "app.modal.install-to-play.header": {
     "message": "安裝以遊玩"
   },
@@ -12,13 +15,13 @@
     "message": "安裝"
   },
   "app.modal.install-to-play.mod-count": {
-    "message": "{count} 個模組"
+    "message": "{count, plural, one {# 個模組} other {# 個模組}}"
+  },
+  "app.modal.install-to-play.required-modpack": {
+    "message": "所需模組包"
   },
   "app.modal.install-to-play.server-requires-mods": {
-    "message": "這個伺服器需要模組才能遊玩。請點選安裝，以從 Modrinth 設定所需的檔案。"
-  },
-  "app.modal.install-to-play.shared-by-today": {
-    "message": "{name} 今天與你共用了這個實例。"
+    "message": "這個伺服器需要模組才能遊玩。請點選「安裝」以從 Modrinth 設定所需的檔案，完成後即可直接加入伺服器。"
   },
   "app.modal.install-to-play.shared-instance": {
     "message": "共用實例"
@@ -26,6 +29,9 @@
   "app.modal.install-to-play.shared-server-instance": {
     "message": "共用伺服器實例"
   },
+  "app.modal.install-to-play.view-contents": {
+    "message": "檢視內容"
+  },
   "app.modal.update-to-play.added-count": {
     "message": "新增了 {count} 個"
   },
@@ -83,39 +89,33 @@
   "app.settings.tabs.resource-management": {
     "message": "資源管理"
   },
-  "app.update-toast.body": {
-    "message": "Modrinth App v{version} 安裝已準備就緒！重新載入立即更新，或是在你關閉 Modrinth App 時自動更新。"
+  "app.update-popup.body": {
+    "message": "Modrinth App v{version} 已準備好安裝！立即重新載入以更新，或在關閉 Modrinth App 時自動更新。"
   },
-  "app.update-toast.body.download-complete": {
-    "message": "Modrinth App v{version} 已完成下載。重新載入立即更新，或是在你關閉 Modrinth App 時自動更新。"
+  "app.update-popup.body.download-complete": {
+    "message": "Modrinth App v{version} 已完成下載！立即重新載入以更新，或在關閉 Modrinth App 時自動更新。"
   },
-  "app.update-toast.body.linux": {
-    "message": "Modrinth App v{version} 現已推出。請使用你的套件管理員進行更新，以取得最新的功能與修正！"
+  "app.update-popup.body.linux": {
+    "message": "Modrinth App v{version} 現已推出。請使用套件管理員進行更新，以取得最新的功能與修正！"
   },
-  "app.update-toast.body.metered": {
-    "message": "Modrinth App v{version} 現已推出！由於你正使用計量付費的網路，我們沒有自動下載它。"
+  "app.update-popup.body.metered": {
+    "message": "Modrinth App v{version} 現已推出！由於你目前使用的是計量付費網路，我們並未自動下載更新。"
   },
-  "app.update-toast.changelog": {
+  "app.update-popup.changelog": {
     "message": "更新日誌"
   },
-  "app.update-toast.download": {
+  "app.update-popup.download": {
     "message": "下載 ({size})"
   },
-  "app.update-toast.download-page": {
-    "message": "下載"
+  "app.update-popup.download-complete": {
+    "message": "下載完成"
   },
-  "app.update-toast.downloading": {
-    "message": "下載中..."
-  },
-  "app.update-toast.reload": {
+  "app.update-popup.reload": {
     "message": "重新載入"
   },
-  "app.update-toast.title": {
+  "app.update-popup.title": {
     "message": "有可用的更新"
   },
-  "app.update-toast.title.download-complete": {
-    "message": "下載完成"
-  },
   "app.update.complete-toast.text": {
     "message": "按這裡查看更新日誌。"
   },
@@ -135,7 +135,7 @@
     "message": "新增好友"
   },
   "friends.action.view-friend-requests": {
-    "message": "{count} 個好友邀請"
+    "message": "{count} 位好友的 {count, plural, one {邀請} other {邀請}}"
   },
   "friends.add-friend.submit": {
     "message": "送出好友邀請"
@@ -147,7 +147,7 @@
     "message": "這可能與對方的 Minecraft 使用者名稱不同！"
   },
   "friends.add-friend.username.placeholder": {
-    "message": "輸入 Modrinth 使用者名稱..."
+    "message": "請輸入 Modrinth 用戶名稱……"
   },
   "friends.add-friend.username.title": {
     "message": "你好友的 Modrinth 使用者名稱是什麼？"
@@ -186,7 +186,7 @@
     "message": "沒有符合「{query}」的好友"
   },
   "friends.search-friends-placeholder": {
-    "message": "搜尋好友..."
+    "message": "搜尋好友……"
   },
   "friends.section.heading": {
     "message": "{title} - {count}"
@@ -339,7 +339,7 @@
     "message": "用於啟動 Minecraft 的包裝指令。"
   },
   "instance.settings.tabs.hooks.wrapper.enter": {
-    "message": "輸入包裝指令..."
+    "message": "輸入包裝指令……"
   },
   "instance.settings.tabs.installation": {
     "message": "安裝"
@@ -464,6 +464,15 @@
   "instance.settings.tabs.installation.unknown-version": {
     "message": "（未知的版本）"
   },
+  "instance.settings.tabs.installation.unlink-server-vanilla.description": {
+    "message": "這個實例已連結至伺服器，這代表你無法變更 Minecraft 版本。取消連結將會永久中斷這個實例與伺服器的連線。"
+  },
+  "instance.settings.tabs.installation.unlink-server.description": {
+    "message": "這個實例已連結至伺服器，這代表模組無法被更新，且你無法變更模組載入器或 Minecraft 版本。取消連結將會永久中斷這個實例與伺服器的連線。"
+  },
+  "instance.settings.tabs.installation.unlink-server.title": {
+    "message": "從伺服器取消連結"
+  },
   "instance.settings.tabs.installation.unlink.button": {
     "message": "取消連結實例"
   },
@@ -551,6 +560,9 @@
   "instance.worlds.incompatible_server": {
     "message": "伺服器不相容"
   },
+  "instance.worlds.linked_server": {
+    "message": "由伺服器專案管理"
+  },
   "instance.worlds.no_contact": {
     "message": "伺服器沒有回應"
   },
@@ -586,5 +598,17 @@
   },
   "search.filter.locked.instance.sync": {
     "message": "與實例同步"
+  },
+  "search.filter.locked.server": {
+    "message": "由伺服器提供"
+  },
+  "search.filter.locked.server-environment.title": {
+    "message": "只有用戶端模組可以被加到伺服器實例"
+  },
+  "search.filter.locked.server-game-version.title": {
+    "message": "遊戲版本由伺服器提供"
+  },
+  "search.filter.locked.server-loader.title": {
+    "message": "載入器由伺服器提供"
   }
 }

apps/app-frontend/src/main.js

@@ -42,6 +42,10 @@ app.use(FloatingVue, {
 			instantMove: true,
 			distance: 8,
 		},
+		'dismissable-prompt': {
+			$extend: 'dropdown',
+			placement: 'bottom-start',
+		},
 	},
 })
 app.use(i18nPlugin)

apps/app-frontend/src/pages/Browse.vue

@@ -1,23 +1,37 @@
 <script setup lang="ts">
-import { ClipboardCopyIcon, ExternalIcon, GlobeIcon, SearchIcon } from '@modrinth/assets'
-import type { Category, GameVersion, Platform, ProjectType, SortType, Tags } from '@modrinth/ui'
+import type { Labrinth } from '@modrinth/api-client'
 import {
+	ClipboardCopyIcon,
+	ExternalIcon,
+	GlobeIcon,
+	PlayIcon,
+	PlusIcon,
+	SearchIcon,
+	StopCircleIcon,
+} from '@modrinth/assets'
+import type { ProjectType, SortType, Tags } from '@modrinth/ui'
+import {
+	Admonition,
+	ButtonStyled,
 	Checkbox,
 	defineMessages,
 	DropdownSelect,
 	injectNotificationManager,
 	LoadingIndicator,
 	Pagination,
+	ProjectCard,
 	ProjectCardList,
 	SearchFilterControl,
 	SearchSidebarFilter,
 	StyledInput,
+	useDebugLogger,
 	useSearch,
+	useServerSearch,
 	useVIntl,
 } from '@modrinth/ui'
 import { openUrl } from '@tauri-apps/plugin-opener'
 import type { Ref } from 'vue'
-import { computed, nextTick, ref, shallowRef, watch } from 'vue'
+import { computed, nextTick, onUnmounted, ref, shallowRef, toRaw, watch } from 'vue'
 import type { LocationQuery } from 'vue-router'
 import { useRoute, useRouter } from 'vue-router'
 
@@ -26,31 +40,53 @@ import type Instance from '@/components/ui/Instance.vue'
 import InstanceIndicator from '@/components/ui/InstanceIndicator.vue'
 import NavTabs from '@/components/ui/NavTabs.vue'
 import SearchCard from '@/components/ui/SearchCard.vue'
-import { get_search_results } from '@/helpers/cache.js'
-import { get as getInstance, get_projects as getInstanceProjects } from '@/helpers/profile.js'
+import { get_project_v3, get_search_results_v3 } from '@/helpers/cache.js'
+import { process_listener } from '@/helpers/events'
+import { get_by_profile_path } from '@/helpers/process'
+import {
+	get as getInstance,
+	get_installed_project_ids as getInstalledProjectIds,
+	kill,
+	list as listInstances,
+} from '@/helpers/profile.js'
 import { get_categories, get_game_versions, get_loaders } from '@/helpers/tags'
+import type { GameInstance } from '@/helpers/types'
+import { getServerLatency } from '@/helpers/worlds'
+import { injectServerInstall } from '@/providers/server-install'
 import { useBreadcrumbs } from '@/store/breadcrumbs'
+import { getServerAddress } from '@/store/install.js'
 
 const { handleError } = injectNotificationManager()
 const { formatMessage } = useVIntl()
+const { installingServerProjects, playServerProject, showAddServerToInstanceModal } =
+	injectServerInstall()
+const debugLog = useDebugLogger('Browse')
 
 const router = useRouter()
 const route = useRoute()
 
 const projectTypes = computed(() => {
+	debugLog('projectTypes computed', route.params.projectType)
 	return [route.params.projectType as ProjectType]
 })
 
+debugLog('fetching tags (categories, loaders, gameVersions)')
 const [categories, loaders, availableGameVersions] = await Promise.all([
-	get_categories().catch(handleError).then(ref),
-	get_loaders().catch(handleError).then(ref),
-	get_game_versions().catch(handleError).then(ref),
+	get_categories()
+		.catch(handleError)
+		.then(ref<Labrinth.Tags.v2.Category[]>),
+	get_loaders()
+		.catch(handleError)
+		.then(ref<Labrinth.Tags.v2.Loader[]>),
+	get_game_versions()
+		.catch(handleError)
+		.then(ref<Labrinth.Tags.v2.GameVersion[]>),
 ])
 
 const tags: Ref<Tags> = computed(() => ({
-	gameVersions: availableGameVersions.value as GameVersion[],
-	loaders: loaders.value as Platform[],
-	categories: categories.value as Category[],
+	gameVersions: availableGameVersions.value ?? [],
+	loaders: loaders.value ?? [],
+	categories: categories.value ?? [],
 }))
 
 type Instance = {
@@ -60,48 +96,69 @@ type Instance = {
 	install_stage: string
 	icon_path?: string
 	name: string
-}
-
-type InstanceProject = {
-	metadata: {
+	linked_data?: {
 		project_id: string
+		version_id: string
+		locked: boolean
 	}
 }
 
 const instance: Ref<Instance | null> = ref(null)
-const instanceProjects: Ref<InstanceProject[] | null> = ref(null)
+const installedProjectIds: Ref<string[] | null> = ref(null)
 const instanceHideInstalled = ref(false)
-const newlyInstalled = ref([])
+const newlyInstalled = ref<string[]>([])
+const isServerInstance = ref(false)
 
 const PERSISTENT_QUERY_PARAMS = ['i', 'ai']
 
-await updateInstanceContext()
+await initInstanceContext()
 
-watch(route, () => {
-	updateInstanceContext()
-})
-
-async function updateInstanceContext() {
+async function initInstanceContext() {
+	debugLog('initInstanceContext', { queryI: route.query.i, queryAi: route.query.ai })
 	if (route.query.i) {
-		;[instance.value, instanceProjects.value] = await Promise.all([
-			getInstance(route.query.i).catch(handleError),
-			getInstanceProjects(route.query.i).catch(handleError),
-		])
-		newlyInstalled.value = []
+		instance.value = await getInstance(route.query.i).catch(handleError)
+		debugLog('instance loaded', {
+			name: instance.value?.name,
+			loader: instance.value?.loader,
+			gameVersion: instance.value?.game_version,
+		})
+
+		// Load installed project IDs in background — the page and initial search render immediately.
+		// When this resolves, instanceFilters recomputes and triggers a search refresh
+		// that applies the "hide installed" negative filters and marks installed badges.
+		getInstalledProjectIds(route.query.i)
+			.then((ids) => {
+				debugLog('installedProjectIds loaded', { count: ids?.length })
+				installedProjectIds.value = ids
+			})
+			.catch(handleError)
+
+		if (instance.value?.linked_data?.project_id) {
+			debugLog('checking linked project for server status', instance.value.linked_data.project_id)
+			const projectV3 = await get_project_v3(
+				instance.value.linked_data.project_id,
+				'must_revalidate',
+			).catch(handleError)
+			if (projectV3?.minecraft_server != null) {
+				debugLog('instance is a server instance')
+				isServerInstance.value = true
+			}
+		}
 	}
 
 	if (route.query.ai && !(projectTypes.value.length === 1 && projectTypes.value[0] === 'modpack')) {
+		debugLog('setting instanceHideInstalled from query', route.query.ai)
 		instanceHideInstalled.value = route.query.ai === 'true'
 	}
-
-	if (instance.value && instance.value.path !== route.query.i && route.path.startsWith('/browse')) {
-		instance.value = null
-		instanceHideInstalled.value = false
-	}
 }
 
 const instanceFilters = computed(() => {
 	const filters = []
+	debugLog('instanceFilters recomputing', {
+		hasInstance: !!instance.value,
+		isServer: isServerInstance.value,
+		hideInstalled: instanceHideInstalled.value,
+	})
 
 	if (instance.value) {
 		const gameVersion = instance.value.game_version
@@ -123,15 +180,21 @@ const instanceFilters = computed(() => {
 			})
 		}
 
-		if (instanceHideInstalled.value && instanceProjects.value) {
-			const installedMods = Object.values(instanceProjects.value)
-				.filter((x) => x.metadata)
-				.map((x) => x.metadata.project_id)
+		if (isServerInstance.value) {
+			filters.push({
+				type: 'environment',
+				option: 'client',
+			})
+		}
 
-			installedMods.push(...newlyInstalled.value)
+		if (
+			instanceHideInstalled.value &&
+			(installedProjectIds.value || newlyInstalled.value.length > 0)
+		) {
+			const allInstalled = [...(installedProjectIds.value ?? []), ...newlyInstalled.value]
 
-			installedMods
-				?.map((x) => ({
+			allInstalled
+				.map((x) => ({
 					type: 'project_id',
 					option: `project_id:${x}`,
 					negative: true,
@@ -140,6 +203,7 @@ const instanceFilters = computed(() => {
 		}
 	}
 
+	debugLog('instanceFilters result', filters)
 	return filters
 })
 
@@ -164,13 +228,117 @@ const {
 	createPageParams,
 } = useSearch(projectTypes, tags, instanceFilters)
 
+const activeLoader = computed(() => {
+	const filter = currentFilters.value.find((f) => f.type === 'mod_loader')
+	if (filter) return filter.option
+	if (projectType.value === 'datapack' || projectType.value === 'resourcepack') return 'vanilla'
+	return instance.value?.loader ?? null
+})
+
+const activeGameVersion = computed(() => {
+	const filter = currentFilters.value.find((f) => f.type === 'game_version')
+	if (filter) return filter.option
+	return instance.value?.game_version ?? null
+})
+
+const serverHits = shallowRef<Labrinth.Search.v3.ResultSearchProject[]>([])
+const serverPings = shallowRef<Record<string, number | undefined>>({})
+const runningServerProjects = ref<Record<string, string>>({})
+
+async function checkServerRunningStates(hits: Labrinth.Search.v3.ResultSearchProject[]) {
+	debugLog('checkServerRunningStates', { hitCount: hits.length })
+	const packs = await listInstances()
+	const newRunning: Record<string, string> = {}
+	for (const hit of hits) {
+		const inst = packs.find((p: GameInstance) => p.linked_data?.project_id === hit.project_id)
+		if (inst) {
+			const processes = await get_by_profile_path(inst.path).catch(() => [])
+			if (Array.isArray(processes) && processes.length > 0) {
+				newRunning[hit.project_id] = inst.path
+			}
+		}
+	}
+	debugLog('runningServerProjects updated', newRunning)
+	runningServerProjects.value = newRunning
+}
+
+async function handleStopServerProject(projectId: string) {
+	debugLog('handleStopServerProject', projectId)
+	const instancePath = runningServerProjects.value[projectId]
+	if (!instancePath) return
+	await kill(instancePath).catch(() => {})
+	const { [projectId]: _, ...rest } = runningServerProjects.value
+	runningServerProjects.value = rest
+}
+
+async function handlePlayServerProject(projectId: string) {
+	debugLog('handlePlayServerProject', projectId)
+	await playServerProject(projectId)
+	checkServerRunningStates(serverHits.value)
+}
+
+function handleAddServerToInstance(project: Labrinth.Search.v3.ResultSearchProject) {
+	debugLog('handleAddServerToInstance', { projectId: project.project_id, name: project.name })
+	const address = getServerAddress(project.minecraft_java_server)
+	if (!address) return
+	showAddServerToInstanceModal(project.name, address)
+}
+
+const unlistenProcesses = await process_listener(
+	(e: { event: string; profile_path_id: string }) => {
+		debugLog('process event', e)
+		if (e.event === 'finished') {
+			const projectId = Object.entries(runningServerProjects.value).find(
+				([, path]) => path === e.profile_path_id,
+			)?.[0]
+			if (projectId) {
+				const { [projectId]: _, ...rest } = runningServerProjects.value
+				runningServerProjects.value = rest
+			}
+		}
+	},
+)
+
+onUnmounted(() => {
+	unlistenProcesses()
+})
+
+const {
+	serverCurrentSortType,
+	serverCurrentFilters,
+	serverToggledGroups,
+	serverSortTypes,
+	serverFilterTypes,
+	serverRequestParams,
+	createServerPageParams,
+} = useServerSearch({ tags, query, maxResults, currentPage })
+
+async function pingServerHits(hits: Labrinth.Search.v3.ResultSearchProject[]) {
+	debugLog('pingServerHits', { hitCount: hits.length })
+	const pingsToFetch = hits.filter((hit) => hit.minecraft_java_server?.address)
+	await Promise.all(
+		pingsToFetch.map(async (hit) => {
+			const address = hit.minecraft_java_server!.address!
+			try {
+				const latency = await getServerLatency(address)
+				serverPings.value = { ...serverPings.value, [hit.project_id]: latency }
+			} catch (err) {
+				console.error(`Failed to ping server ${address}:`, err)
+			}
+		}),
+	)
+}
+
 const previousFilterState = ref('')
+let searchVersion = 0
 
 const offline = ref(!navigator.onLine)
 window.addEventListener('offline', () => {
+	debugLog('went offline')
 	offline.value = true
 })
 window.addEventListener('online', () => {
+	debugLog('went online')
 	offline.value = false
 })
 
@@ -179,97 +347,168 @@ breadcrumbs.setContext({ name: 'Discover content', link: route.path, query: rout
 
 const loading = ref(true)
 
-const projectType = ref(route.params.projectType)
+const projectType = ref<ProjectType>(route.params.projectType as ProjectType)
 
 watch(projectType, () => {
 	loading.value = true
 })
 
-type SearchResult = {
-	project_id: string
-}
-
-type SearchResults = {
-	total_hits: number
-	limit: number
-	hits: SearchResult[]
+interface SearchResults extends Labrinth.Search.v3.SearchResults {
+	hits: (Labrinth.Search.v3.ResultSearchProject & { installed?: boolean })[]
 }
 
 const results: Ref<SearchResults | null> = shallowRef(null)
 const pageCount = computed(() =>
-	results.value ? Math.ceil(results.value.total_hits / results.value.limit) : 1,
+	results.value ? Math.ceil(results.value.total_hits / results.value.hits_per_page) : 1,
 )
 
-watch(requestParams, () => {
+const effectiveRequestParams = computed(() => {
+	const isServer = projectType.value === 'server'
+	debugLog('effectiveRequestParams computed', { isServer })
+	return isServer ? serverRequestParams.value : requestParams.value
+})
+
+let searchDebounceTimer: ReturnType<typeof setTimeout> | null = null
+
+watch(effectiveRequestParams, () => {
 	if (!route.params.projectType) return
-	refreshSearch()
+	debugLog('effectiveRequestParams changed, debouncing search')
+	if (searchDebounceTimer) clearTimeout(searchDebounceTimer)
+	searchDebounceTimer = setTimeout(() => {
+		refreshSearch()
+	}, 200)
 })
 
 async function refreshSearch() {
-	let rawResults = await get_search_results(requestParams.value)
-	if (!rawResults) {
-		rawResults = {
-			result: {
+	const version = ++searchVersion
+	debugLog('refreshSearch start', { version, projectType: projectType.value })
+
+	try {
+		const isServer = projectType.value === 'server'
+		const searchParams = isServer ? serverRequestParams.value : requestParams.value
+
+		debugLog('searching v3', searchParams)
+		let rawResults = (await get_search_results_v3(searchParams)) as {
+			result: SearchResults
+		} | null
+
+		if (version !== searchVersion) {
+			debugLog('search version stale, discarding', { version, current: searchVersion })
+			return
+		}
+
+		if (!rawResults) {
+			rawResults = {
+				result: {
+					hits: [],
+					total_hits: 0,
+					hits_per_page: maxResults.value,
+					page: 1,
+				},
+			}
+		}
+
+		if (isServer) {
+			const hits = rawResults.result.hits ?? []
+			debugLog('server search results', {
+				hitCount: hits.length,
+				totalHits: rawResults.result.total_hits,
+			})
+			serverHits.value = hits
+			serverPings.value = {}
+			pingServerHits(hits)
+			checkServerRunningStates(hits)
+			results.value = {
 				hits: [],
-				total_hits: 0,
-				limit: 1,
-			},
+				total_hits: rawResults.result.total_hits ?? 0,
+				hits_per_page: maxResults.value,
+				page: 1,
+			}
+		} else {
+			if (instance.value) {
+				const allInstalledIds = new Set([
+					...newlyInstalled.value,
+					...(installedProjectIds.value ?? []),
+				])
+
+				rawResults.result.hits = rawResults.result.hits.map((val) => ({
+					...val,
+					installed: allInstalledIds.has(val.project_id),
+				}))
+			}
+			debugLog('v3 search results', {
+				hitCount: rawResults.result.hits.length,
+				totalHits: rawResults.result.total_hits,
+			})
+			results.value = {
+				...rawResults.result,
+				hits_per_page: maxResults.value,
+			}
+		}
+
+		const currentFilterState = JSON.stringify({
+			query: query.value,
+			filters: toRaw(currentFilters.value),
+			sort: toRaw(currentSortType.value),
+			maxResults: maxResults.value,
+			projectTypes: toRaw(projectTypes.value),
+		})
+
+		if (previousFilterState.value && previousFilterState.value !== currentFilterState) {
+			debugLog('filters changed, resetting to page 1')
+			currentPage.value = 1
+		}
+
+		previousFilterState.value = currentFilterState
+
+		const persistentParams: LocationQuery = {}
+
+		for (const [key, value] of Object.entries(route.query)) {
+			if (PERSISTENT_QUERY_PARAMS.includes(key)) {
+				persistentParams[key] = value
+			}
+		}
+
+		if (instanceHideInstalled.value) {
+			persistentParams.ai = 'true'
+		} else {
+			delete persistentParams.ai
+		}
+
+		const params = {
+			...persistentParams,
+			...(isServer ? createServerPageParams() : createPageParams()),
+		}
+
+		breadcrumbs.setContext({
+			name: 'Discover content',
+			link: `/browse/${projectType.value}`,
+			query: params,
+		})
+		const queryString = Object.entries(params)
+			.flatMap(([key, value]) => {
+				const values = Array.isArray(value) ? value : [value]
+				return values
+					.filter((v): v is string => v != null)
+					.map((v) => `${encodeURIComponent(key)}=${encodeURIComponent(v)}`)
+			})
+			.join('&')
+		const newUrl = `${route.path}${queryString ? '?' + queryString : ''}`
+		debugLog('updating URL', newUrl)
+		window.history.replaceState(window.history.state, '', newUrl)
+
+		loading.value = false
+		debugLog('refreshSearch complete', { version })
+	} catch (err) {
+		debugLog('refreshSearch error', err)
+		if (version === searchVersion) {
+			loading.value = false
 		}
 	}
-	if (instance.value) {
-		for (const val of rawResults.result.hits) {
-			val.installed =
-				newlyInstalled.value.includes(val.project_id) ||
-				Object.values(instanceProjects.value).some(
-					(x) => x.metadata && x.metadata.project_id === val.project_id,
-				)
-		}
-	}
-	results.value = rawResults.result
-
-	const currentFilterState = JSON.stringify({
-		query: query.value,
-		filters: currentFilters.value,
-		sort: currentSortType.value,
-		maxResults: maxResults.value,
-		projectTypes: projectTypes.value,
-	})
-
-	if (previousFilterState.value && previousFilterState.value !== currentFilterState) {
-		currentPage.value = 1
-	}
-
-	previousFilterState.value = currentFilterState
-
-	const persistentParams: LocationQuery = {}
-
-	for (const [key, value] of Object.entries(route.query)) {
-		if (PERSISTENT_QUERY_PARAMS.includes(key)) {
-			persistentParams[key] = value
-		}
-	}
-
-	if (instanceHideInstalled.value) {
-		persistentParams.ai = 'true'
-	} else {
-		delete persistentParams.ai
-	}
-
-	const params = {
-		...persistentParams,
-		...createPageParams(),
-	}
-
-	breadcrumbs.setContext({
-		name: 'Discover content',
-		link: `/browse/${projectType.value}`,
-		query: params,
-	})
-	await router.replace({ path: route.path, query: params })
-	loading.value = false
 }
 
 async function setPage(newPageNumber: number) {
+	debugLog('setPage', newPageNumber)
 	currentPage.value = newPageNumber
 
 	await onSearchChangeToTop()
@@ -284,16 +523,18 @@ async function onSearchChangeToTop() {
 }
 
 function clearSearch() {
+	debugLog('clearSearch')
 	query.value = ''
 	currentPage.value = 1
 }
 
 watch(
-	() => route.params.projectType,
+	() => route.params.projectType as ProjectType,
 	async (newType) => {
 		// Check if the newType is not the same as the current value
 		if (!newType || newType === projectType.value) return
 
+		debugLog('projectType route param changed', { from: projectType.value, to: newType })
 		projectType.value = newType
 
 		currentSortType.value = { display: 'Relevance', name: 'relevance' }
@@ -308,8 +549,10 @@ const selectableProjectTypes = computed(() => {
 
 	if (instance.value) {
 		if (
-			availableGameVersions.value.findIndex((x) => x.version === instance.value.game_version) <=
-			availableGameVersions.value.findIndex((x) => x.version === '1.13')
+			availableGameVersions.value &&
+			availableGameVersions.value.findIndex((x) => x.version === instance.value?.game_version) <=
+				availableGameVersions.value.findIndex((x) => x.version === '1.13') &&
+			!isServerInstance.value
 		) {
 			dataPacks = true
 		}
@@ -338,6 +581,7 @@ const selectableProjectTypes = computed(() => {
 		{ label: 'Resource Packs', href: `/browse/resourcepack` },
 		{ label: 'Data Packs', href: `/browse/datapack`, shown: dataPacks },
 		{ label: 'Shaders', href: `/browse/shader` },
+		{ label: 'Servers', href: `/browse/server`, shown: !instance.value },
 	]
 
 	if (params) {
@@ -360,23 +604,61 @@ const messages = defineMessages({
 		id: 'search.filter.locked.instance-game-version.title',
 		defaultMessage: 'Game version is provided by the instance',
 	},
+	gameVersionProvidedByServer: {
+		id: 'search.filter.locked.server-game-version.title',
+		defaultMessage: 'Game version is provided by the server',
+	},
 	modLoaderProvidedByInstance: {
 		id: 'search.filter.locked.instance-loader.title',
 		defaultMessage: 'Loader is provided by the instance',
 	},
+	modLoaderProvidedByServer: {
+		id: 'search.filter.locked.server-loader.title',
+		defaultMessage: 'Loader is provided by the server',
+	},
+	environmentProvidedByServer: {
+		id: 'search.filter.locked.server-environment.title',
+		defaultMessage: 'Only client-side mods can be added to the server instance',
+	},
 	providedByInstance: {
 		id: 'search.filter.locked.instance',
 		defaultMessage: 'Provided by the instance',
 	},
+	providedByServer: {
+		id: 'search.filter.locked.server',
+		defaultMessage: 'Provided by the server',
+	},
 	syncFilterButton: {
 		id: 'search.filter.locked.instance.sync',
 		defaultMessage: 'Sync with instance',
 	},
 })
 
+const getServerModpackContent = (project: Labrinth.Search.v3.ResultSearchProject) => {
+	const content = project.minecraft_java_server?.content
+	if (content?.kind === 'modpack') {
+		const { project_name, project_icon, project_id } = content
+		if (!project_name) return undefined
+		return {
+			name: project_name,
+			icon: project_icon,
+			onclick:
+				project_id !== project.project_id
+					? () => {
+							router.push(`/project/${project_id}`)
+						}
+					: undefined,
+			showCustomModpackTooltip: project_id === project.project_id,
+		}
+	}
+	return undefined
+}
+
 const options = ref(null)
+// @ts-expect-error - no event types
 const handleRightClick = (event, result) => {
-	options.value.showMenu(event, result, [
+	// @ts-ignore
+	options.value?.showMenu(event, result, [
 		{
 			name: 'open_link',
 		},
@@ -385,19 +667,21 @@ const handleRightClick = (event, result) => {
 		},
 	])
 }
+// @ts-expect-error - no event types
 const handleOptionsClick = (args) => {
 	switch (args.option) {
 		case 'open_link':
-			openUrl(`https://modrinth.com/${args.item.project_type}/${args.item.slug}`)
+			openUrl(`https://modrinth.com/${args.item.project_types?.[0] ?? 'project'}/${args.item.slug}`)
 			break
 		case 'copy_link':
 			navigator.clipboard.writeText(
-				`https://modrinth.com/${args.item.project_type}/${args.item.slug}`,
+				`https://modrinth.com/${args.item.project_types?.[0] ?? 'project'}/${args.item.slug}`,
 			)
 			break
 	}
 }
 
+debugLog('performing initial search')
 await refreshSearch()
 
 // Initialize previousFilterState after first search
@@ -424,38 +708,85 @@ previousFilterState.value = JSON.stringify({
 				@click.prevent.stop
 			/>
 		</div>
-		<SearchSidebarFilter
-			v-for="filter in filters.filter((f) => f.display !== 'none')"
-			:key="`filter-${filter.id}`"
-			v-model:selected-filters="currentFilters"
-			v-model:toggled-groups="toggledGroups"
-			v-model:overridden-provided-filter-types="overriddenProvidedFilterTypes"
-			:provided-filters="instanceFilters"
-			:filter-type="filter"
-			class="border-0 border-b-[1px] [&:first-child>button]:pt-4 last:border-b-0 border-[--brand-gradient-border] border-solid"
-			button-class="button-animation flex flex-col gap-1 px-4 py-3 w-full bg-transparent cursor-pointer border-none hover:bg-button-bg"
-			content-class="mb-3"
-			inner-panel-class="ml-2 mr-3"
-			:open-by-default="
-				filter.id.startsWith('category') || filter.id === 'environment' || filter.id === 'license'
-			"
-		>
-			<template #header>
-				<h3 class="text-base m-0">{{ filter.formatted_name }}</h3>
-			</template>
-			<template #locked-game_version>
-				{{ formatMessage(messages.gameVersionProvidedByInstance) }}
-			</template>
-			<template #locked-mod_loader>
-				{{ formatMessage(messages.modLoaderProvidedByInstance) }}
-			</template>
-			<template #sync-button> {{ formatMessage(messages.syncFilterButton) }} </template>
-		</SearchSidebarFilter>
+		<template v-if="projectType === 'server'">
+			<SearchSidebarFilter
+				v-for="filterType in serverFilterTypes.filter((f) => f.options.length > 0)"
+				:key="`server-filter-${filterType.id}`"
+				v-model:selected-filters="serverCurrentFilters"
+				v-model:toggled-groups="serverToggledGroups"
+				:provided-filters="[]"
+				:filter-type="filterType"
+				class="border-0 border-b-[1px] [&:first-child>button]:pt-4 last:border-b-0 border-[--brand-gradient-border] border-solid"
+				button-class="button-animation flex flex-col gap-1 px-4 py-3 w-full bg-transparent cursor-pointer border-none hover:bg-button-bg"
+				content-class="mb-3"
+				inner-panel-class="ml-2 mr-3"
+				:open-by-default="
+					![
+						'server_category_minecraft_server_meta',
+						'server_category_minecraft_server_community',
+						'server_game_version',
+						'server_status',
+					].includes(filterType.id)
+				"
+			>
+				<template #header>
+					<h3 class="text-base m-0">{{ filterType.formatted_name }}</h3>
+				</template>
+			</SearchSidebarFilter>
+		</template>
+		<template v-else>
+			<SearchSidebarFilter
+				v-for="filter in filters.filter((f) => f.display !== 'none')"
+				:key="`filter-${filter.id}`"
+				v-model:selected-filters="currentFilters"
+				v-model:toggled-groups="toggledGroups"
+				v-model:overridden-provided-filter-types="overriddenProvidedFilterTypes"
+				:provided-filters="instanceFilters"
+				:filter-type="filter"
+				class="border-0 border-b-[1px] [&:first-child>button]:pt-4 last:border-b-0 border-[--brand-gradient-border] border-solid"
+				button-class="button-animation flex flex-col gap-1 px-4 py-3 w-full bg-transparent cursor-pointer border-none hover:bg-button-bg"
+				content-class="mb-3"
+				inner-panel-class="ml-2 mr-3"
+				:open-by-default="
+					filter.id.startsWith('category') || filter.id === 'environment' || filter.id === 'license'
+				"
+			>
+				<template #header>
+					<h3 class="text-base m-0">{{ filter.formatted_name }}</h3>
+				</template>
+				<template #locked-game_version>
+					{{
+						formatMessage(
+							isServerInstance
+								? messages.gameVersionProvidedByServer
+								: messages.gameVersionProvidedByInstance,
+						)
+					}}
+				</template>
+				<template #locked-mod_loader>
+					{{
+						formatMessage(
+							isServerInstance
+								? messages.modLoaderProvidedByServer
+								: messages.modLoaderProvidedByInstance,
+						)
+					}}
+				</template>
+				<template #locked-environment>
+					{{ formatMessage(messages.environmentProvidedByServer) }}
+				</template>
+				<template #sync-button> {{ formatMessage(messages.syncFilterButton) }} </template>
+			</SearchSidebarFilter>
+		</template>
 	</Teleport>
 	<div ref="searchWrapper" class="flex flex-col gap-3 p-6">
 		<template v-if="instance">
 			<InstanceIndicator :instance="instance" />
 			<h1 class="m-0 mb-1 text-xl">Install content to instance</h1>
+			<Admonition v-if="isServerInstance" type="warning" class="mb-1">
+				Adding content can break compatibility when joining the server. Any added content will also
+				be lost when you update the server instance content.
+			</Admonition>
 		</template>
 		<NavTabs :links="selectableProjectTypes" />
 		<StyledInput
@@ -472,11 +803,17 @@ previousFilterState.value = JSON.stringify({
 		<div class="flex gap-2">
 			<DropdownSelect
 				v-slot="{ selected }"
-				v-model="currentSortType"
+				:model-value="projectType === 'server' ? serverCurrentSortType : currentSortType"
 				class="max-w-[16rem]"
 				name="Sort by"
-				:options="sortTypes as any"
+				:options="(projectType === 'server' ? serverSortTypes : sortTypes) as any"
 				:display-name="(option: SortType | undefined) => option?.display"
+				@update:model-value="
+					(v: SortType) => {
+						if (projectType === 'server') serverCurrentSortType = v
+						else currentSortType = v
+					}
+				"
 			>
 				<span class="font-semibold text-primary">Sort by: </span>
 				<span class="font-semibold text-secondary">{{ selected }}</span>
@@ -494,46 +831,132 @@ previousFilterState.value = JSON.stringify({
 			<Pagination :page="currentPage" :count="pageCount" class="ml-auto" @switch-page="setPage" />
 		</div>
 		<SearchFilterControl
+			v-if="projectType === 'server'"
+			v-model:selected-filters="serverCurrentFilters"
+			:filters="serverFilterTypes"
+			:provided-filters="[]"
+			:overridden-provided-filter-types="[]"
+		/>
+		<SearchFilterControl
+			v-else
 			v-model:selected-filters="currentFilters"
 			:filters="filters.filter((f) => f.display !== 'none')"
 			:provided-filters="instanceFilters"
 			:overridden-provided-filter-types="overriddenProvidedFilterTypes"
-			:provided-message="messages.providedByInstance"
+			:provided-message="isServerInstance ? messages.providedByServer : messages.providedByInstance"
 		/>
 		<div class="search">
 			<section v-if="loading" class="offline">
 				<LoadingIndicator />
 			</section>
-			<section v-else-if="offline && results.total_hits === 0" class="offline">
+			<section v-else-if="offline && results?.total_hits === 0" class="offline">
 				You are currently offline. Connect to the internet to browse Modrinth!
 			</section>
+			<section
+				v-else-if="
+					projectType === 'server'
+						? serverHits.length === 0
+						: results && results.hits && results.hits.length === 0
+				"
+				class="offline"
+			>
+				No results found for your query!
+			</section>
 
 			<ProjectCardList v-else :layout="'list'">
-				<SearchCard
-					v-for="result in results.hits"
-					:key="result?.project_id"
-					:project-type="projectType"
-					:project="result"
-					:instance="instance"
-					:categories="[
-						...categories.filter(
-							(cat) =>
-								result?.display_categories.includes(cat.name) && cat.project_type === projectType,
-						),
-						...loaders.filter(
-							(loader) =>
-								result?.display_categories.includes(loader.name) &&
-								loader.supported_project_types?.includes(projectType),
-						),
-					]"
-					:installed="result.installed || newlyInstalled.includes(result.project_id)"
-					@install="
-						(id) => {
-							newlyInstalled.push(id)
-						}
-					"
-					@contextmenu.prevent.stop="(event) => handleRightClick(event, result)"
-				/>
+				<template v-if="projectType === 'server'">
+					<ProjectCard
+						v-for="project in serverHits"
+						:key="`server-card-${project.project_id}`"
+						:title="project.name"
+						:icon-url="project.icon_url || undefined"
+						:summary="project.summary"
+						:tags="project.categories"
+						:link="`/project/${project.slug ?? project.project_id}`"
+						:server-online-players="project.minecraft_java_server?.ping?.data?.players_online ?? 0"
+						:server-region="project.minecraft_server?.region"
+						:server-recent-plays="project.minecraft_java_server?.verified_plays_2w ?? 0"
+						:server-modpack-content="getServerModpackContent(project)"
+						:server-ping="serverPings[project.project_id]"
+						:server-status-online="!!project.minecraft_java_server?.ping?.data"
+						:hide-online-players-label="true"
+						:hide-recent-plays-label="true"
+						layout="list"
+						:max-tags="2"
+						is-server-project
+						exclude-loaders
+						@contextmenu.prevent.stop="
+							(event: any) =>
+								handleRightClick(event, { project_types: ['server'], slug: project.slug })
+						"
+					>
+						<template #actions>
+							<div class="flex gap-2">
+								<ButtonStyled circular>
+									<button
+										v-tooltip="'Add server to instance'"
+										@click.stop="() => handleAddServerToInstance(project)"
+									>
+										<PlusIcon />
+									</button>
+								</ButtonStyled>
+								<ButtonStyled
+									v-if="runningServerProjects[project.project_id]"
+									color="red"
+									type="outlined"
+								>
+									<button @click="() => handleStopServerProject(project.project_id)">
+										<StopCircleIcon />
+										Stop
+									</button>
+								</ButtonStyled>
+								<ButtonStyled v-else color="brand" type="outlined">
+									<button
+										:disabled="(installingServerProjects as string[]).includes(project.project_id)"
+										@click="() => handlePlayServerProject(project.project_id)"
+									>
+										<PlayIcon />
+										{{
+											(installingServerProjects as string[]).includes(project.project_id)
+												? 'Installing...'
+												: 'Play'
+										}}
+									</button>
+								</ButtonStyled>
+							</div>
+						</template>
+					</ProjectCard>
+				</template>
+				<template v-else>
+					<SearchCard
+						v-for="result in results?.hits ?? []"
+						:key="result?.project_id"
+						:project-type="projectType"
+						:project="result"
+						:instance="instance ?? undefined"
+						:active-loader="activeLoader ?? undefined"
+						:active-game-version="activeGameVersion ?? undefined"
+						:categories="[
+							...(categories ?? []).filter(
+								(cat) =>
+									result?.display_categories.includes(cat.name) && cat.project_type === projectType,
+							),
+							...(loaders ?? []).filter(
+								(loader) =>
+									result?.display_categories.includes(loader.name) &&
+									loader.supported_project_types?.includes(projectType),
+							),
+						]"
+						:installed="result.installed || newlyInstalled.includes(result.project_id || '')"
+						@install="
+							(id) => {
+								newlyInstalled.push(id)
+							}
+						"
+						@contextmenu.prevent.stop="(event: any) => handleRightClick(event, result)"
+					/>
+				</template>
+
 				<ContextMenu ref="options" @option-clicked="handleOptionsClick">
 					<template #open_link> <GlobeIcon /> Open in Modrinth <ExternalIcon /> </template>
 					<template #copy_link> <ClipboardCopyIcon /> Copy link </template>

apps/app-frontend/src/pages/instance/Index.vue

@@ -1,45 +1,122 @@
 <template>
-	<div>
-		<div
-			class="p-6 pr-2 pb-4"
-			@contextmenu.prevent.stop="(event) => handleRightClick(event, instance.path)"
-		>
+	<div v-if="instance">
+		<div class="p-6 pr-2 pb-4" @contextmenu.prevent.stop="(event) => handleRightClick(event)">
 			<ExportModal ref="exportModal" :instance="instance" />
-			<InstanceSettingsModal ref="settingsModal" :instance="instance" :offline="offline" />
+			<InstanceSettingsModal
+				ref="settingsModal"
+				:instance="instance"
+				:offline="offline"
+				@unlinked="fetchInstance"
+			/>
 			<UpdateToPlayModal ref="updateToPlayModal" :instance="instance" />
-			<ButtonStyled v-if="themeStore.featureFlags.server_project_qa">
-				<button @click="updateToPlayModal.show()">Update to play modal</button>
-			</ButtonStyled>
 			<ContentPageHeader>
 				<template #icon>
-					<Avatar :src="icon" :alt="instance.name" size="96px" :tint-by="instance.path" />
+					<Avatar
+						:src="icon ? icon : undefined"
+						:alt="instance.name"
+						size="64px"
+						:tint-by="instance.path"
+					/>
 				</template>
 				<template #title>
 					{{ instance.name }}
 				</template>
-				<template #summary> </template>
 				<template #stats>
-					<div
-						class="flex items-center gap-2 font-semibold transform capitalize border-0 border-solid border-divider pr-4 md:border-r"
-					>
-						<GameIcon class="h-6 w-6 text-secondary" />
-						{{ instance.loader }} {{ instance.game_version }}
-					</div>
-					<div class="flex items-center gap-2 font-semibold">
-						<TimerIcon class="h-6 w-6 text-secondary" />
-						<template v-if="timePlayed > 0">
-							{{ timePlayedHumanized }}
+					<div class="flex items-center flex-wrap gap-2">
+						<template v-if="!isServerInstance">
+							<div class="flex items-center gap-2 capitalize font-medium">
+								{{ instance.loader }} {{ instance.game_version }}
+							</div>
+
+							<div class="w-1.5 h-1.5 rounded-full bg-surface-5"></div>
+
+							<div class="flex items-center gap-2 font-medium">
+								<template v-if="timePlayed > 0">
+									{{ timePlayedHumanized }}
+								</template>
+								<template v-else> Never played </template>
+							</div>
+
+							<div v-if="linkedProjectV3" class="w-1.5 h-1.5 rounded-full bg-surface-5"></div>
+
+							<div
+								v-if="linkedProjectV3"
+								class="flex gap-1.5 items-center font-medium text-primary"
+							>
+								Linked to
+								<Avatar
+									:src="linkedProjectV3.icon_url"
+									:alt="linkedProjectV3.name"
+									:tint-by="instance.path"
+									size="24px"
+								/>
+								<router-link
+									:to="`/project/${linkedProjectV3.slug ?? linkedProjectV3.id}`"
+									class="hover:underline text-primary truncate"
+								>
+									{{ linkedProjectV3.name }}
+								</router-link>
+							</div>
+						</template>
+
+						<template v-else>
+							<template v-if="loadingServerPing">
+								<ServerOnlinePlayers
+									v-if="playersOnline !== undefined"
+									:online="playersOnline"
+									:status-online="statusOnline"
+									hide-label
+								/>
+								<ServerRecentPlays :recent-plays="recentPlays ?? 0" hide-label />
+								<div
+									v-if="
+										(playersOnline !== undefined || recentPlays !== undefined) &&
+										(minecraftServer?.region || ping)
+									"
+									class="w-1.5 h-1.5 rounded-full bg-surface-5"
+								></div>
+								<ServerPing v-if="ping" :ping="ping" />
+							</template>
+
+							<ServerRegion v-if="minecraftServer?.region" :region="minecraftServer?.region" />
+
+							<div
+								v-if="minecraftServer?.region || ping"
+								class="w-1.5 h-1.5 rounded-full bg-surface-5"
+							></div>
+
+							<div
+								v-if="linkedProjectV3"
+								class="flex gap-1.5 items-center font-medium text-primary"
+							>
+								Linked to
+								<Avatar
+									:src="linkedProjectV3.icon_url"
+									:alt="linkedProjectV3.name"
+									:tint-by="instance.path"
+									size="24px"
+								/>
+								<router-link
+									:to="`/project/${linkedProjectV3.slug ?? linkedProjectV3.id}`"
+									class="hover:underline text-primary truncate"
+								>
+									{{ linkedProjectV3.name }}
+								</router-link>
+							</div>
 						</template>
-						<template v-else> Never played </template>
 					</div>
 				</template>
 				<template #actions>
 					<div class="flex gap-2">
 						<ButtonStyled
 							v-if="
-								['installing', 'pack_installing', 'minecraft_installing'].includes(
-									instance.install_stage,
-								)
+								[
+									'installing',
+									'pack_installing',
+									'pack_installed',
+									'not_installed',
+									'minecraft_installing',
+								].includes(instance.install_stage)
 							"
 							color="brand"
 							size="large"
@@ -63,7 +140,7 @@
 							</button>
 						</ButtonStyled>
 						<ButtonStyled
-							v-else-if="playing === false && loading === false"
+							v-else-if="playing === false && loading === false && !isServerInstance"
 							color="brand"
 							size="large"
 						>
@@ -72,6 +149,44 @@
 								Play
 							</button>
 						</ButtonStyled>
+						<div
+							v-else-if="playing === false && loading === false && isServerInstance"
+							class="joined-buttons"
+						>
+							<ButtonStyled color="brand" size="large">
+								<button @click="handlePlayServer()">
+									<PlayIcon />
+									Play
+								</button>
+							</ButtonStyled>
+							<ButtonStyled color="brand" size="large">
+								<OverflowMenu
+									:options="[
+										{
+											id: 'join_server',
+											action: () => handlePlayServer(),
+										},
+										{
+											id: 'launch_instance',
+											action: () => startInstance('InstancePage'),
+										},
+									]"
+								>
+									<div class="w-0 text-xl relative top-0.5 right-2.5">
+										<DropdownIcon />
+									</div>
+
+									<template #join_server>
+										<PlayIcon />
+										Join server
+									</template>
+									<template #launch_instance>
+										<PlayIcon />
+										Launch instance
+									</template>
+								</OverflowMenu>
+							</ButtonStyled>
+						</div>
 						<ButtonStyled
 							v-else-if="loading === true && playing === false"
 							color="brand"
@@ -79,21 +194,23 @@
 						>
 							<button disabled>Loading...</button>
 						</ButtonStyled>
-						<ButtonStyled size="large" circular>
-							<button v-tooltip="'Instance settings'" @click="settingsModal.show()">
+						<ButtonStyled circular size="large">
+							<button v-tooltip="'Instance settings'" @click="settingsModal?.show()">
 								<SettingsIcon />
 							</button>
 						</ButtonStyled>
-						<ButtonStyled size="large" type="transparent" circular>
+						<ButtonStyled type="transparent" circular size="large">
 							<OverflowMenu
 								:options="[
 									{
 										id: 'open-folder',
-										action: () => showProfileInFolder(instance.path),
+										action: () => {
+											if (instance) showProfileInFolder(instance.path)
+										},
 									},
 									{
 										id: 'export-mrpack',
-										action: () => $refs.exportModal.show(),
+										action: () => exportModal?.show(),
 									},
 								]"
 							>
@@ -112,7 +229,11 @@
 			<NavTabs :links="tabs" />
 		</div>
 		<div v-if="!!instance" class="p-6 pt-4">
-			<RouterView v-slot="{ Component }" :key="instance.path">
+			<RouterView
+				v-if="route.path.startsWith('/instance')"
+				v-slot="{ Component }"
+				:key="instance.path"
+			>
 				<template v-if="Component">
 					<Suspense
 						:key="instance.path"
@@ -127,6 +248,8 @@
 							:playing="playing"
 							:versions="modrinthVersions"
 							:installed="instance.install_stage !== 'installed'"
+							:is-server-instance="isServerInstance"
+							:open-settings="() => settingsModal?.show(1)"
 							@play="updatePlayState"
 							@stop="() => stopInstance('InstanceSubpage')"
 						></component>
@@ -160,16 +283,17 @@
 		</ContextMenu>
 	</div>
 </template>
-<script setup>
+<script setup lang="ts">
+import type { Labrinth } from '@modrinth/api-client'
 import {
 	CheckCircleIcon,
 	ClipboardCopyIcon,
 	DownloadIcon,
+	DropdownIcon,
 	EditIcon,
 	ExternalIcon,
 	EyeIcon,
 	FolderOpenIcon,
-	GameIcon,
 	GlobeIcon,
 	HashIcon,
 	MoreVerticalIcon,
@@ -179,7 +303,6 @@ import {
 	ServerIcon,
 	SettingsIcon,
 	StopCircleIcon,
-	TimerIcon,
 	UpdatedIcon,
 	UserPlusIcon,
 	XIcon,
@@ -191,6 +314,10 @@ import {
 	injectNotificationManager,
 	LoadingIndicator,
 	OverflowMenu,
+	ServerOnlinePlayers,
+	ServerPing,
+	ServerRecentPlays,
+	ServerRegion,
 } from '@modrinth/ui'
 import { convertFileSrc } from '@tauri-apps/api/core'
 import dayjs from 'dayjs'
@@ -205,20 +332,22 @@ import InstanceSettingsModal from '@/components/ui/modal/InstanceSettingsModal.v
 import UpdateToPlayModal from '@/components/ui/modal/UpdateToPlayModal.vue'
 import NavTabs from '@/components/ui/NavTabs.vue'
 import { trackEvent } from '@/helpers/analytics'
-import { get_project, get_version_many } from '@/helpers/cache.js'
+import { get_project_v3, get_version_many } from '@/helpers/cache.js'
 import { process_listener, profile_listener } from '@/helpers/events'
 import { get_by_profile_path } from '@/helpers/process'
 import { finish_install, get, get_full_path, kill, run } from '@/helpers/profile'
+import type { GameInstance } from '@/helpers/types'
 import { showProfileInFolder } from '@/helpers/utils.js'
+import { get_server_status } from '@/helpers/worlds'
+import { injectServerInstall } from '@/providers/server-install'
 import { handleSevereError } from '@/store/error.js'
 import { useBreadcrumbs, useLoading } from '@/store/state'
-import { useTheming } from '@/store/theme'
 
 dayjs.extend(duration)
 dayjs.extend(relativeTime)
 
 const { handleError } = injectNotificationManager()
-const themeStore = useTheming()
+const { playServerProject } = injectServerInstall()
 const route = useRoute()
 
 const router = useRouter()
@@ -232,38 +361,89 @@ window.addEventListener('online', () => {
 	offline.value = false
 })
 
-const instance = ref()
-const modrinthVersions = ref([])
+const instance = ref<GameInstance>()
+const modrinthVersions = ref<Labrinth.Versions.v2.Version[]>([])
 const playing = ref(false)
 const loading = ref(false)
-const updateToPlayModal = ref()
+const exportModal = ref<InstanceType<typeof ExportModal>>()
+const updateToPlayModal = ref<InstanceType<typeof UpdateToPlayModal>>()
+
+const isServerInstance = ref(false)
+const linkedProjectV3 = ref<Labrinth.Projects.v3.Project>()
+const selected = ref<unknown[]>([])
+
+const minecraftServer = computed(() => linkedProjectV3.value?.minecraft_server)
+const javaServerPingData = computed(() => linkedProjectV3.value?.minecraft_java_server?.ping?.data)
+const statusOnline = computed(() => !!javaServerPingData.value)
+const recentPlays = computed(
+	() => linkedProjectV3.value?.minecraft_java_server?.verified_plays_2w ?? undefined,
+)
+const playersOnline = ref<number | undefined>(undefined)
+const ping = ref<number | undefined>(undefined)
+const loadingServerPing = ref(false)
 
 async function fetchInstance() {
-	instance.value = await get(route.params.id).catch(handleError)
+	isServerInstance.value = false
+	linkedProjectV3.value = undefined
+	modrinthVersions.value = []
+	ping.value = undefined
+	playersOnline.value = undefined
+	loadingServerPing.value = false
 
-	if (!offline.value && instance.value.linked_data && instance.value.linked_data.project_id) {
-		get_project(instance.value.linked_data.project_id, 'must_revalidate')
-			.catch(handleError)
-			.then((project) => {
-				if (project && project.versions) {
-					get_version_many(project.versions, 'must_revalidate')
-						.catch(handleError)
-						.then((versions) => {
-							modrinthVersions.value = versions.sort(
-								(a, b) => dayjs(b.date_published) - dayjs(a.date_published),
-							)
-						})
-				}
-			})
+	instance.value = await get(route.params.id as string).catch(handleError)
+
+	if (!offline.value && instance.value?.linked_data && instance.value.linked_data.project_id) {
+		try {
+			linkedProjectV3.value = await get_project_v3(
+				instance.value.linked_data.project_id,
+				'must_revalidate',
+			)
+
+			if (linkedProjectV3.value?.minecraft_server != null) {
+				isServerInstance.value = true
+			}
+
+			if (linkedProjectV3.value && linkedProjectV3.value.versions) {
+				const versions = await get_version_many(linkedProjectV3.value.versions, 'must_revalidate')
+				modrinthVersions.value = versions.sort(
+					(a: Labrinth.Versions.v2.Version, b: Labrinth.Versions.v2.Version) =>
+						dayjs(b.date_published).valueOf() - dayjs(a.date_published).valueOf(),
+				)
+			}
+		} catch (error) {
+			handleError(error as Error)
+		}
 	}
 
-	await updatePlayState()
+	fetchDeferredData()
+}
+
+function fetchDeferredData() {
+	const serverAddress = linkedProjectV3.value?.minecraft_java_server?.address
+	if (isServerInstance.value && serverAddress) {
+		get_server_status(serverAddress)
+			.then((status) => {
+				playersOnline.value = status.players?.online
+				ping.value = status.ping
+			})
+			.catch((error) => {
+				console.error(`Failed to fetch server status for ${serverAddress}:`, error)
+			})
+			.finally(() => {
+				loadingServerPing.value = true
+			})
+	} else {
+		loadingServerPing.value = true
+	}
+
+	updatePlayState()
 }
 
 async function updatePlayState() {
-	const runningProcesses = await get_by_profile_path(route.params.id).catch(handleError)
+	if (!route.params.id) return
+	const runningProcesses = await get_by_profile_path(route.params.id as string).catch(handleError)
 
-	playing.value = runningProcesses.length > 0
+	playing.value = Array.isArray(runningProcesses) && runningProcesses.length > 0
 }
 
 await fetchInstance()
@@ -276,7 +456,7 @@ watch(
 	},
 )
 
-const basePath = computed(() => `/instance/${encodeURIComponent(route.params.id)}`)
+const basePath = computed(() => `/instance/${encodeURIComponent(route.params.id as string)}`)
 
 const tabs = computed(() => [
 	{
@@ -293,30 +473,37 @@ const tabs = computed(() => [
 	},
 ])
 
-breadcrumbs.setName(
-	'Instance',
-	instance.value.name.length > 40
-		? instance.value.name.substring(0, 40) + '...'
-		: instance.value.name,
-)
-
-breadcrumbs.setContext({
-	name: instance.value.name,
-	link: route.path,
-	query: route.query,
-})
+if (instance.value) {
+	breadcrumbs.setName(
+		'Instance',
+		instance.value.name.length > 40
+			? instance.value.name.substring(0, 40) + '...'
+			: instance.value.name,
+	)
+	breadcrumbs.setContext({
+		name: instance.value.name,
+		link: route.path,
+		query: route.query,
+	})
+}
 
 const loadingBar = useLoading()
 
-const options = ref(null)
+const options = ref<InstanceType<typeof ContextMenu> | null>(null)
+
+const startInstance = async (context: string) => {
+	if (!instance.value) return
+	if (updateToPlayModal.value?.hasUpdate) {
+		updateToPlayModal.value.show(instance.value)
+		return
+	}
 
-const startInstance = async (context) => {
 	loading.value = true
 	try {
-		await run(route.params.id)
+		await run(route.params.id as string)
 		playing.value = true
 	} catch (err) {
-		handleSevereError(err, { profilePath: route.params.id })
+		handleSevereError(err, { profilePath: route.params.id as string })
 	}
 	loading.value = false
 
@@ -327,10 +514,11 @@ const startInstance = async (context) => {
 	})
 }
 
-const stopInstance = async (context) => {
+const stopInstance = async (context: string) => {
 	playing.value = false
-	await kill(route.params.id).catch(handleError)
+	await kill(route.params.id as string).catch(handleError)
 
+	if (!instance.value) return
 	trackEvent('InstanceStop', {
 		loader: instance.value.loader,
 		game_version: instance.value.game_version,
@@ -338,11 +526,22 @@ const stopInstance = async (context) => {
 	})
 }
 
+const handlePlayServer = async () => {
+	if (!instance.value?.linked_data?.project_id) return
+	loading.value = true
+	try {
+		await playServerProject(instance.value.linked_data.project_id)
+	} finally {
+		await updatePlayState()
+		loading.value = false
+	}
+}
+
 const repairInstance = async () => {
 	await finish_install(instance.value).catch(handleError)
 }
 
-const handleRightClick = (event) => {
+const handleRightClick = (event: MouseEvent) => {
 	const baseOptions = [
 		{ name: 'add_content' },
 		{ type: 'divider' },
@@ -351,7 +550,7 @@ const handleRightClick = (event) => {
 		{ name: 'copy_path' },
 	]
 
-	options.value.showMenu(
+	options.value?.showMenu(
 		event,
 		instance.value,
 		playing.value
@@ -372,7 +571,7 @@ const handleRightClick = (event) => {
 	)
 }
 
-const handleOptionsClick = async (args) => {
+const handleOptionsClick = async (args: { option: string; item: unknown }) => {
 	switch (args.option) {
 		case 'play':
 			await startInstance('InstancePageContextMenu')
@@ -382,52 +581,64 @@ const handleOptionsClick = async (args) => {
 			break
 		case 'add_content':
 			await router.push({
-				path: `/browse/${instance.value.loader === 'vanilla' ? 'datapack' : 'mod'}`,
+				path: `/browse/${instance.value?.loader === 'vanilla' ? 'datapack' : 'mod'}`,
 				query: { i: route.params.id },
 			})
 			break
 		case 'edit':
 			await router.push({
-				path: `/instance/${encodeURIComponent(route.params.id)}/options`,
+				path: `/instance/${encodeURIComponent(route.params.id as string)}/options`,
 			})
 			break
 		case 'open_folder':
-			await showProfileInFolder(instance.value.path)
+			if (instance.value) await showProfileInFolder(instance.value.path)
 			break
 		case 'copy_path': {
-			const fullPath = await get_full_path(instance.value.path)
-			await navigator.clipboard.writeText(fullPath)
+			if (instance.value) {
+				const fullPath = await get_full_path(instance.value?.path)
+				await navigator.clipboard.writeText(fullPath)
+			}
 			break
 		}
 	}
 }
 
-const unlistenProfiles = await profile_listener(async (event) => {
-	if (event.profile_path_id === route.params.id) {
-		if (event.event === 'removed') {
-			await router.push({
-				path: '/',
-			})
-			return
+const unlistenProfiles = await profile_listener(
+	async (event: { profile_path_id: string; event: string }) => {
+		if (event.profile_path_id === route.params.id) {
+			if (event.event === 'removed') {
+				await router.push({
+					path: '/',
+				})
+				return
+			}
+			instance.value = await get(route.params.id as string).catch(handleError)
+			if (!instance.value?.linked_data?.project_id) {
+				linkedProjectV3.value = undefined
+				isServerInstance.value = false
+			}
 		}
-		instance.value = await get(route.params.id).catch(handleError)
-	}
-})
-
-const unlistenProcesses = await process_listener((e) => {
-	if (e.event === 'finished' && e.profile_path_id === route.params.id) {
-		playing.value = false
-	}
-})
-
-const icon = computed(() =>
-	instance.value.icon_path ? convertFileSrc(instance.value.icon_path) : null,
+	},
 )
 
-const settingsModal = ref()
+const unlistenProcesses = await process_listener(
+	(e: { event: string; profile_path_id: string }) => {
+		if (e.event === 'finished' && e.profile_path_id === route.params.id) {
+			playing.value = false
+		}
+	},
+)
+
+const icon = computed(() =>
+	instance.value?.icon_path ? convertFileSrc(instance.value.icon_path) : null,
+)
+
+const settingsModal = ref<InstanceType<typeof InstanceSettingsModal>>()
 
 const timePlayed = computed(() => {
-	return instance.value.recent_time_played + instance.value.submitted_time_played
+	return instance.value
+		? instance.value.recent_time_played + instance.value.submitted_time_played
+		: 0
 })
 
 const timePlayedHumanized = computed(() => {

apps/app-frontend/src/pages/instance/Worlds.vue

@@ -26,7 +26,7 @@
 		:description="`'${worldToDelete?.name}' will be **permanently deleted**, and there will be no way to recover it.`"
 		@proceed="proceedDeleteWorld"
 	/>
-	<div v-if="worlds.length > 0" class="flex flex-col gap-4">
+	<div v-if="dedupedWorlds.length > 0" class="flex flex-col gap-4">
 		<div class="flex flex-wrap gap-2 items-center">
 			<StyledInput
 				v-model="searchFilter"
@@ -62,6 +62,7 @@
 				v-for="world in filteredWorlds"
 				:key="`world-${world.type}-${world.type == 'singleplayer' ? world.path : `${world.address}-${world.index}`}`"
 				:world="world"
+				:managed="world.type === 'server' ? isManagedServerWorld(world) : false"
 				:highlighted="highlightedWorld === getWorldIdentifier(world)"
 				:supports-server-quick-play="supportsServerQuickPlay"
 				:supports-world-quick-play="supportsWorldQuickPlay"
@@ -80,9 +81,13 @@
 				@refresh="() => refreshServer((world as ServerWorld).address)"
 				@edit="
 					() =>
-						world.type === 'server' ? editServerModal?.show(world) : editWorldModal?.show(world)
+						world.type === 'singleplayer'
+							? editWorldModal?.show(world)
+							: isManagedServerWorld(world)
+								? undefined
+								: editServerModal?.show(world)
 				"
-				@delete="() => promptToRemoveWorld(world)"
+				@delete="() => !isManagedServerWorld(world) && promptToRemoveWorld(world)"
 				@open-folder="(world: SingleplayerWorld) => showWorldInFolder(instance.path, world.path)"
 			/>
 		</div>
@@ -140,16 +145,20 @@ import AddServerModal from '@/components/ui/world/modal/AddServerModal.vue'
 import EditServerModal from '@/components/ui/world/modal/EditServerModal.vue'
 import EditWorldModal from '@/components/ui/world/modal/EditSingleplayerWorldModal.vue'
 import WorldItem from '@/components/ui/world/WorldItem.vue'
+import { trackEvent } from '@/helpers/analytics'
+import { get_project, get_project_v3 } from '@/helpers/cache.js'
 import { profile_listener } from '@/helpers/events'
 import { get_game_versions } from '@/helpers/tags'
 import type { GameInstance } from '@/helpers/types'
 import {
 	delete_world,
 	get_profile_protocol_version,
+	getServerDomainKey,
 	getWorldIdentifier,
 	handleDefaultProfileUpdateEvent,
 	hasServerQuickPlaySupport,
 	hasWorldQuickPlaySupport,
+	normalizeServerAddress,
 	type ProfileEvent,
 	type ProtocolVersion,
 	refreshServerData,
@@ -157,6 +166,7 @@ import {
 	refreshWorld,
 	refreshWorlds,
 	remove_server_from_profile,
+	resolveManagedServerWorld,
 	type ServerData,
 	type ServerWorld,
 	showWorldInFolder,
@@ -166,8 +176,11 @@ import {
 	start_join_singleplayer_world,
 	type World,
 } from '@/helpers/worlds.ts'
+import { injectServerInstall } from '@/providers/server-install'
+import { ensureManagedServerWorldExists, getServerAddress } from '@/store/install'
 
 const { handleError } = injectNotificationManager()
+const { playServerProject } = injectServerInstall()
 const route = useRoute()
 
 const addServerModal = ref<InstanceType<typeof AddServerModal>>()
@@ -219,6 +232,69 @@ const linuxRefreshCount = ref(0)
 const protocolVersion = ref<ProtocolVersion | null>(
 	await get_profile_protocol_version(instance.value.path),
 )
+const managedServerName = ref<string | null>(null)
+const managedServerAddress = ref<string | null>(null)
+
+const managedServerWorld = computed(() =>
+	resolveManagedServerWorld(worlds.value, managedServerName.value, managedServerAddress.value),
+)
+
+function isManagedServerWorld(world: World): world is ServerWorld {
+	return world.type === 'server' && managedServerWorld.value?.index === world.index
+}
+
+async function refreshManagedServerMetadata() {
+	await ensureManagedServerWorldExists(
+		instance.value.path,
+		managedServerName.value,
+		managedServerAddress.value,
+	)
+
+	const projectId = instance.value.linked_data?.project_id
+	if (!projectId) {
+		managedServerName.value = null
+		managedServerAddress.value = null
+		return
+	}
+
+	try {
+		const [project, projectV3] = await Promise.all([
+			get_project(projectId, 'bypass'),
+			get_project_v3(projectId, 'bypass'),
+		])
+
+		if (projectV3?.minecraft_server == null) {
+			managedServerName.value = null
+			managedServerAddress.value = null
+			return
+		}
+
+		const serverAddress = getServerAddress(projectV3.minecraft_java_server)
+		if (!serverAddress) {
+			managedServerName.value = null
+			managedServerAddress.value = null
+			return
+		}
+
+		managedServerName.value = project.title
+		managedServerAddress.value = serverAddress
+	} catch (err) {
+		console.error(
+			`Failed to resolve managed server metadata for profile: ${instance.value.path}`,
+			err,
+		)
+		managedServerName.value = null
+		managedServerAddress.value = null
+	}
+}
+
+watch(
+	() => instance.value.linked_data?.project_id,
+	async () => {
+		await refreshManagedServerMetadata()
+	},
+	{ immediate: true },
+)
 
 const unlistenProfile = await profile_listener(async (e: ProfileEvent) => {
 	if (e.profile_path_id !== instance.value.path) return
@@ -251,6 +327,7 @@ async function refreshAllWorlds() {
 		console.log(`Already refreshing, cancelling refresh.`)
 		return
 	}
+	await refreshManagedServerMetadata()
 
 	refreshingAll.value = true
 
@@ -328,7 +405,23 @@ async function joinWorld(world: World) {
 	startingInstance.value = true
 	worldPlaying.value = world
 	if (world.type === 'server') {
+		const managedProjectId = instance.value.linked_data?.project_id
+		if (managedProjectId && isManagedServerWorld(world)) {
+			await playServerProject(managedProjectId).catch(handleJoinError)
+			trackEvent('InstanceStart', {
+				loader: instance.value.loader,
+				game_version: instance.value.game_version,
+				source: 'WorldsPage',
+			})
+			startingInstance.value = false
+			return
+		}
 		await start_join_server(instance.value.path, world.address).catch(handleJoinError)
+		trackEvent('InstanceStart', {
+			loader: instance.value.loader,
+			game_version: instance.value.game_version,
+			source: 'WorldsPage',
+		})
 	} else if (world.type === 'singleplayer') {
 		await start_join_singleplayer_world(instance.value.path, world.path).catch(handleJoinError)
 	}
@@ -370,12 +463,48 @@ const supportsWorldQuickPlay = computed(() =>
 	hasWorldQuickPlaySupport(gameVersions.value, instance.value.game_version),
 )
 
+const dedupedWorlds = computed(() => {
+	const visibleWorlds: World[] = []
+	const serverIndexByDomain = new Map<string, number>()
+
+	for (const world of worlds.value) {
+		if (world.type !== 'server') {
+			visibleWorlds.push(world)
+			continue
+		}
+
+		const domainKey =
+			getServerDomainKey(world.address) ||
+			normalizeServerAddress(world.address) ||
+			`server-${world.index}`
+		const existingIndex = serverIndexByDomain.get(domainKey)
+
+		if (existingIndex == null) {
+			serverIndexByDomain.set(domainKey, visibleWorlds.length)
+			visibleWorlds.push(world)
+			continue
+		}
+
+		// replace world with managed world if applicable
+		const existingWorld = visibleWorlds[existingIndex]
+		if (
+			existingWorld?.type === 'server' &&
+			!isManagedServerWorld(existingWorld) &&
+			isManagedServerWorld(world)
+		) {
+			visibleWorlds[existingIndex] = world
+		}
+	}
+
+	return visibleWorlds
+})
+
 const filterOptions = computed(() => {
 	const options: FilterBarOption[] = []
 
-	const hasServer = worlds.value.some((x) => x.type === 'server')
+	const hasServer = dedupedWorlds.value.some((x) => x.type === 'server')
 
-	if (worlds.value.some((x) => x.type === 'singleplayer') && hasServer) {
+	if (dedupedWorlds.value.some((x) => x.type === 'singleplayer') && hasServer) {
 		options.push({
 			id: 'singleplayer',
 			message: messages.singleplayer,
@@ -389,13 +518,13 @@ const filterOptions = computed(() => {
 	if (hasServer) {
 		// add available filter if there's any offline ("unavailable") servers AND there's any singleplayer worlds or available servers
 		if (
-			worlds.value.some(
+			dedupedWorlds.value.some(
 				(x) =>
 					x.type === 'server' &&
 					!serverData.value[x.address]?.status &&
 					!serverData.value[x.address]?.refreshing,
 			) &&
-			worlds.value.some(
+			dedupedWorlds.value.some(
 				(x) =>
 					x.type === 'singleplayer' ||
 					(x.type === 'server' &&
@@ -414,7 +543,7 @@ const filterOptions = computed(() => {
 })
 
 const filteredWorlds = computed(() =>
-	worlds.value.filter((x) => {
+	dedupedWorlds.value.filter((x) => {
 		const availableFilter = filters.value.includes('available')
 		const typeFilter = filters.value.includes('server') || filters.value.includes('singleplayer')
 

apps/app-frontend/src/pages/library/Custom.vue

@@ -1,4 +1,4 @@
-<script setup>
+<script setup lang="ts">
 import GridDisplay from '@/components/GridDisplay.vue'
 
 defineProps({
@@ -10,7 +10,7 @@ defineProps({
 </script>
 <template>
 	<GridDisplay
-		v-if="instances.length > 0"
+		v-if="instances && instances.length > 0"
 		label="Instances"
 		:instances="instances.filter((i) => !i.linked_data)"
 	/>

apps/app-frontend/src/pages/library/Downloaded.vue

@@ -1,4 +1,4 @@
-<script setup>
+<script setup lang="ts">
 import GridDisplay from '@/components/GridDisplay.vue'
 
 defineProps({
@@ -10,7 +10,7 @@ defineProps({
 </script>
 <template>
 	<GridDisplay
-		v-if="instances.length > 0"
+		v-if="instances && instances.length > 0"
 		label="Instances"
 		:instances="instances.filter((i) => i.linked_data)"
 	/>

apps/app-frontend/src/pages/library/Index.vue

@@ -1,17 +1,17 @@
-<script setup>
+<script setup lang="ts">
 import { PlusIcon } from '@modrinth/assets'
 import { Button, injectNotificationManager } from '@modrinth/ui'
-import { onUnmounted, ref, shallowRef } from 'vue'
+import { inject, onUnmounted, ref, shallowRef } from 'vue'
 import { useRoute } from 'vue-router'
 
 import { NewInstanceImage } from '@/assets/icons'
-import InstanceCreationModal from '@/components/ui/InstanceCreationModal.vue'
 import NavTabs from '@/components/ui/NavTabs.vue'
 import { profile_listener } from '@/helpers/events.js'
 import { list } from '@/helpers/profile.js'
 import { useBreadcrumbs } from '@/store/breadcrumbs.js'
 
 const { handleError } = injectNotificationManager()
+const showCreationModal = inject('showCreationModal')
 const route = useRoute()
 const breadcrumbs = useBreadcrumbs()
 
@@ -41,13 +41,14 @@ onUnmounted(() => {
 		<NavTabs
 			:links="[
 				{ label: 'All instances', href: `/library` },
-				{ label: 'Downloaded', href: `/library/downloaded` },
+				{ label: 'Modpacks', href: `/library/modpacks` },
+				{ label: 'Servers', href: `/library/servers` },
 				{ label: 'Custom', href: `/library/custom` },
 				{ label: 'Shared with me', href: `/library/shared`, shown: false },
 				{ label: 'Saved', href: `/library/saved`, shown: false },
 			]"
 		/>
-		<template v-if="instances.length > 0">
+		<template v-if="instances && instances.length > 0">
 			<RouterView v-if="route.path.startsWith('/library')" :instances="instances" />
 		</template>
 		<div v-else class="no-instance">
@@ -55,11 +56,10 @@ onUnmounted(() => {
 				<NewInstanceImage />
 			</div>
 			<h3>No instances found</h3>
-			<Button color="primary" :disabled="offline" @click="$refs.installationModal.show()">
+			<Button color="primary" :disabled="offline" @click="showCreationModal?.()">
 				<PlusIcon />
 				Create new instance
 			</Button>
-			<InstanceCreationModal ref="installationModal" />
 		</div>
 	</div>
 </template>

apps/app-frontend/src/pages/library/Modpacks.vue

@@ -0,0 +1,47 @@
+<script setup lang="ts">
+import { computed, ref, watchEffect } from 'vue'
+
+import GridDisplay from '@/components/GridDisplay.vue'
+import { get_project_v3_many } from '@/helpers/cache.js'
+
+const props = defineProps({
+	instances: {
+		type: Array,
+		required: true,
+	},
+})
+
+const serverProjectIds = ref(new Set())
+
+const linkedInstances = computed(() => props.instances.filter((i) => i.linked_data))
+
+watchEffect(async () => {
+	const projectIds = [
+		...new Set(linkedInstances.value.map((i) => i.linked_data?.project_id).filter(Boolean)),
+	]
+	if (projectIds.length === 0) {
+		serverProjectIds.value = new Set()
+		return
+	}
+
+	try {
+		const projects = await get_project_v3_many(projectIds, 'must_revalidate')
+		serverProjectIds.value = new Set(
+			projects.filter((p) => p?.minecraft_server != null).map((p) => p.id),
+		)
+	} catch {
+		serverProjectIds.value = new Set()
+	}
+})
+
+const filteredInstances = computed(() =>
+	linkedInstances.value.filter((i) => !serverProjectIds.value.has(i.linked_data?.project_id)),
+)
+</script>
+<template>
+	<GridDisplay
+		v-if="filteredInstances && filteredInstances.length > 0"
+		label="Instances"
+		:instances="filteredInstances"
+	/>
+</template>

apps/app-frontend/src/pages/library/Overview.vue

@@ -1,4 +1,4 @@
-<script setup>
+<script setup lang="ts">
 import GridDisplay from '@/components/GridDisplay.vue'
 
 defineProps({
@@ -9,5 +9,5 @@ defineProps({
 })
 </script>
 <template>
-	<GridDisplay v-if="instances.length > 0" label="Instances" :instances="instances" />
+	<GridDisplay v-if="instances && instances.length > 0" label="Instances" :instances="instances" />
 </template>

apps/app-frontend/src/pages/library/Servers.vue

@@ -0,0 +1,47 @@
+<script setup lang="ts">
+import { computed, ref, watchEffect } from 'vue'
+
+import GridDisplay from '@/components/GridDisplay.vue'
+import { get_project_v3_many } from '@/helpers/cache.js'
+
+const props = defineProps({
+	instances: {
+		type: Array,
+		required: true,
+	},
+})
+
+const serverProjectIds = ref(new Set())
+
+const linkedInstances = computed(() => props.instances.filter((i) => i.linked_data))
+
+watchEffect(async () => {
+	const projectIds = [
+		...new Set(linkedInstances.value.map((i) => i.linked_data?.project_id).filter(Boolean)),
+	]
+	if (projectIds.length === 0) {
+		serverProjectIds.value = new Set()
+		return
+	}
+
+	try {
+		const projects = await get_project_v3_many(projectIds, 'must_revalidate')
+		serverProjectIds.value = new Set(
+			projects.filter((p) => p?.minecraft_server != null).map((p) => p.id),
+		)
+	} catch {
+		serverProjectIds.value = new Set()
+	}
+})
+
+const filteredInstances = computed(() =>
+	linkedInstances.value.filter((i) => serverProjectIds.value.has(i.linked_data?.project_id)),
+)
+</script>
+<template>
+	<GridDisplay
+		v-if="filteredInstances && filteredInstances.length > 0"
+		label="Instances"
+		:instances="filteredInstances"
+	/>
+</template>