feat: 移植远程公告中心

从 Axolotl 搬 RemoteAnnouncements.vue，顶栏加公告铃铛。远程拉取先禁用，等接口。

.github/workflows/check-rust.yml

@@ -22,5 +22,5 @@ jobs:
           node-version-file: .nvmrc
       - uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable
       - uses: cargo-bins/cargo-binstall@dc19f1e48450eefe5a29b8da6c6b00a87d730b37 # v1.18.1
-      - run: cargo binstall --no-confirm cargo-shear
+      - run: cargo binstall --no-confirm cargo-shear@1.13.4
       - run: cargo shear

Cargo.lock

@@ -6841,7 +6841,7 @@ dependencies = [
 
 [[package]]
 name = "theseus"
-version = "1.0.0-beta15"
+version = "1.0.2-beta4"
 dependencies = [
  "ariadne",
  "async-minecraft-ping",
@@ -6945,7 +6945,7 @@ dependencies = [
 
 [[package]]
 name = "theseus_gui"
-version = "1.0.0-beta15"
+version = "1.0.2-beta4"
 dependencies = [
  "ashpd",
  "async_zip",

apps/app-frontend/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@modrinth/app-frontend",
 	"private": true,
-	"version": "1.0.0-beta15",
+	"version": "1.0.2-beta4",
 	"type": "module",
 	"scripts": {
 		"dev": "vite",

apps/app-frontend/src/App.vue

@@ -95,6 +95,7 @@ import NavRail from '@/components/ui/NavRail.vue'
 import OnboardingOverlay from '@/components/ui/onboarding/OnboardingOverlay.vue'
 import QuickInstanceSwitcher from '@/components/ui/QuickInstanceSwitcher.vue'
 import SkinSiteSessionFrame from '@/components/ui/SkinSiteSessionFrame.vue'
+import RemoteAnnouncements from '@/components/ui/RemoteAnnouncements.vue'
 import StartupAnnouncementModal from '@/components/ui/StartupAnnouncementModal.vue'
 import SplashScreen from '@/components/ui/SplashScreen.vue'
 import WindowControls from '@/components/ui/WindowControls.vue'
@@ -2227,6 +2228,7 @@ provideAppUpdateDownloadProgress(appUpdateDownload)
 	<SkinSiteSessionFrame v-if="stateInitialized" />
 	<InstancePlayerModal v-if="stateInitialized" />
 	<StartupAnnouncementModal ref="startupAnnouncementModal" />
+	<RemoteAnnouncements :ready="stateInitialized && !showOnboarding && !stateFailed" />
 	<div id="teleports"></div>
 	<div
 		v-if="stateInitialized && themeStore.customBackgroundPath && !themeStore.transparentBackground"

apps/app-frontend/src/announcements/catalog.ts

@@ -32,6 +32,43 @@ export const ANNOUNCEMENT_CHANGE_TYPES: readonly AnnouncementChangeType[] = [
 ]
 
 export const launcherAnnouncements: readonly LauncherAnnouncement[] = [
+	{
+		id: 'launcher-1.0.2-beta4',
+		version: '1.0.2-beta4',
+		publishedAt: '2026-10-08',
+		title: {
+			'en-US': 'Starlight Launcher 1.0.2-beta4',
+			'zh-CN': 'Starlight Launcher 1.0.2-beta4',
+		},
+		changes: {
+			added: [
+				{
+					'en-US': 'Added armor and armor-trim rendering to the skin preview, letting you try on armor pieces and trim patterns directly in the skin editor.',
+					'zh-CN': '皮肤预览新增盔甲与盔甲纹饰渲染，可在皮肤编辑器内直接试穿各部位盔甲并调整纹饰图案。',
+				},
+				{
+					'en-US': 'Armor preview selections in the skin editor are now saved locally, so they persist across sessions.',
+					'zh-CN': '皮肤编辑器中的盔甲预览选择现在会保存在本地，跨会话保留。',
+				},
+			],
+			changed: [
+				{
+					'en-US': 'Improved download scheduling to reduce concurrency automatically when tasks are waiting for capacity, making large Minecraft installations more reliable on constrained connections.',
+					'zh-CN': '优化下载任务调度：任务因容量不足排队时会自动降低并发，提升大型 Minecraft 版本在受限网络环境下的安装稳定性。',
+				},
+			],
+			fixed: [
+				{
+					'en-US': 'Fixed downloads timing out while waiting for internal connection capacity, which could cause Minecraft installations to fail even when the network was available.',
+					'zh-CN': '修复下载任务等待内部连接容量时过早超时，导致网络正常的情况下 Minecraft 安装仍可能失败的问题。',
+				},
+				{
+					'en-US': 'Fixed instance group changes not saving for some instances.',
+					'zh-CN': '修复部分实例的分组修改无法保存的问题。',
+				},
+			],
+		},
+	},
 	{
 		id: 'launcher-1.0.2-beta3',
 		version: '1.0.2-beta3',

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

@@ -67,6 +67,23 @@
 				</div>
 			</template>
 		</Dropdown>
+		<ButtonStyled
+			v-tooltip="formatMessage(messages.announcements)"
+			type="transparent"
+			circular
+		>
+			<button
+				:aria-label="formatMessage(messages.announcements)"
+				class="relative"
+				@click="openAnnouncementCenter"
+			>
+				<NewspaperIcon />
+				<span
+					v-if="announcementUnreadCount"
+					class="absolute right-0 top-0 size-2 rounded-full bg-red ring-2 ring-bg-raised"
+				/>
+			</button>
+		</ButtonStyled>
 		<ButtonStyled
 			v-if="!isDownloadsPage && hasActiveDownloads && !hasVisibleActiveDownloadToasts"
 			color="brand"
@@ -190,6 +207,7 @@
 <script setup lang="ts">
 import {
 	BellIcon,
+	NewspaperIcon,
 	DownloadIcon,
 	DropdownIcon,
 	OnlineIndicatorIcon,
@@ -211,7 +229,7 @@ import {
 } from '@modrinth/ui'
 import { convertFileSrc } from '@tauri-apps/api/core'
 import { Dropdown } from 'floating-vue'
-import { computed, onBeforeUnmount, ref, watch } from 'vue'
+import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 
 import AppUpdateButton from '@/components/ui/app-update-button/index.vue'
@@ -222,6 +240,10 @@ import { get_many as getInstances } from '@/helpers/instance'
 import { get_all as getRunningProcesses, kill as killProcess } from '@/helpers/process'
 import type { LoadingBar } from '@/helpers/state'
 import { progress_bars_list } from '@/helpers/state'
+import {
+	OPEN_REMOTE_ANNOUNCEMENT_CENTER_EVENT,
+	REMOTE_ANNOUNCEMENTS_UPDATED_EVENT,
+} from '@/helpers/remote-announcements'
 import type { GameInstance } from '@/helpers/types'
 import { downloadBarTypes, injectDownloadManager } from '@/providers/download-manager'
 
@@ -231,6 +253,25 @@ const popupNotificationManager = injectPopupNotificationManager()
 const downloadManager = injectDownloadManager()
 const { formatMessage } = useVIntl()
 
+const announcementUnreadCount = ref(0)
+
+function openAnnouncementCenter() {
+	window.dispatchEvent(new CustomEvent(OPEN_REMOTE_ANNOUNCEMENT_CENTER_EVENT))
+}
+
+function updateAnnouncementCount(event: Event) {
+	const detail = (event as CustomEvent<{ unreadKeys?: string[] }>).detail
+	announcementUnreadCount.value = detail?.unreadKeys?.length ?? 0
+}
+
+onMounted(() => {
+	window.addEventListener(REMOTE_ANNOUNCEMENTS_UPDATED_EVENT, updateAnnouncementCount)
+})
+
+onBeforeUnmount(() => {
+	window.removeEventListener(REMOTE_ANNOUNCEMENTS_UPDATED_EVENT, updateAnnouncementCount)
+})
+
 type NotificationHistoryItem = {
 	key: string
 	createdAt?: number
@@ -370,6 +411,10 @@ const messages = defineMessages({
 		id: 'app.action-bar.notifications',
 		defaultMessage: 'Notifications',
 	},
+	announcements: {
+		id: 'app.action-bar.announcements',
+		defaultMessage: 'Announcements',
+	},
 	clearNotifications: {
 		id: 'app.action-bar.notifications.clear',
 		defaultMessage: 'Clear all',

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

@@ -0,0 +1,388 @@
+<script setup lang="ts">
+import {
+	Button,
+	commonMessages,
+	defineMessages,
+	NewModal,
+	useModalStack,
+	useVIntl,
+} from '@modrinth/ui'
+import { renderString } from '@modrinth/utils'
+import { openUrl } from '@tauri-apps/plugin-opener'
+import { computed, nextTick, onMounted, onUnmounted, reactive, ref, watch } from 'vue'
+
+import {
+	announcementKey,
+	isAnnouncementActive,
+	OPEN_REMOTE_ANNOUNCEMENT_CENTER_EVENT,
+	parseAnnouncements,
+	REMOTE_ANNOUNCEMENTS_UPDATED_EVENT,
+	type RemoteAnnouncement,
+	safeAnnouncementUrl,
+} from '@/helpers/remote-announcements'
+
+const props = defineProps<{ ready: boolean; previewOnly?: boolean }>()
+const { formatMessage } = useVIntl()
+const { hasModal } = useModalStack()
+const messages = defineMessages({
+	view: { id: 'app.remote-announcements.view', defaultMessage: 'View announcement' },
+	unread: { id: 'app.remote-announcements.unread', defaultMessage: 'Unread' },
+	readAll: {
+		id: 'app.remote-announcements.read-all',
+		defaultMessage: 'Mark all announcements as read',
+	},
+	centerTitle: { id: 'app.remote-announcements.center-title', defaultMessage: 'Announcements' },
+	empty: { id: 'app.remote-announcements.empty', defaultMessage: 'No announcements' },
+	previewTitle: {
+		id: 'app.remote-announcements.preview-title',
+		defaultMessage: 'Announcement style preview',
+	},
+	previewSummary: {
+		id: 'app.remote-announcements.preview-summary',
+		defaultMessage:
+			'This is a local preview. Select View announcement to preview the full Markdown content.',
+	},
+	previewContent: {
+		id: 'app.remote-announcements.preview-content',
+		defaultMessage:
+			'## Announcement preview\n\nThis is **sample content**, not a published announcement.\n\n- Supports headings, lists, and links\n- Close buttons are always available\n\n> Previewing does not change real announcement read status.\n\n| Type | Display |\n| --- | --- |\n| Modal | Full Markdown content |\n| Popup | Summary, then full content |\n\n[Visit the website](https://skin.starlight.cool/)',
+	},
+	previewAction: { id: 'app.remote-announcements.preview-action', defaultMessage: 'Visit website' },
+})
+const modal = ref<InstanceType<typeof NewModal>>()
+const selected = ref<RemoteAnnouncement | null>(null)
+const active = ref(false)
+const centerOpen = ref(false)
+const startupNotice = ref<RemoteAnnouncement | null>(null)
+const html = computed(() => renderString(selected.value?.content ?? ''))
+const stateKey = 'starlight-remote-announcements-v2'
+const read = reactive(new Set<string>())
+const queuedThisSession = new Set<string>()
+const startupNotified = new Set<string>()
+let items: RemoteAnnouncement[] = []
+let pending: RemoteAnnouncement[] = []
+let cacheKey = ''
+let cacheLoaded = false
+let disposed = false
+let interval: ReturnType<typeof setInterval> | undefined
+let advanceTimer: ReturnType<typeof setTimeout> | undefined
+
+function persist() {
+	if (props.previewOnly) return
+	try {
+		localStorage.setItem(
+			stateKey,
+			JSON.stringify({
+				read: [...read].slice(-1000),
+			}),
+		)
+	} catch {
+		// localStorage may be unavailable (private mode / quota)
+	}
+}
+function emitState() {
+	window.dispatchEvent(
+		new CustomEvent(REMOTE_ANNOUNCEMENTS_UPDATED_EVENT, {
+			detail: {
+				items,
+				unreadKeys: items.filter((item) => !read.has(announcementKey(item))).map(announcementKey),
+			},
+		}),
+	)
+}
+function openCenter(item?: RemoteAnnouncement) {
+	if (!props.ready || disposed) return
+	centerOpen.value = true
+	if (item) {
+		startupNotice.value = null
+		selectAnnouncement(item)
+	} else if (!selected.value && items.length) {
+		selectAnnouncement(items[0])
+	}
+	void nextTick(() => modal.value?.show())
+}
+function handleOpenCenter() {
+	if (props.previewOnly) return
+	openCenter()
+}
+async function show(item: RemoteAnnouncement) {
+	if (
+		disposed ||
+		!props.ready ||
+		!isAnnouncementActive(item) ||
+		(hasModal.value && !active.value && !centerOpen.value)
+	)
+		return
+	centerOpen.value = true
+	active.value = true
+	selectAnnouncement(item)
+	await nextTick()
+	if (!disposed) modal.value?.show()
+}
+function selectAnnouncement(item: RemoteAnnouncement) {
+	selected.value = item
+	const key = announcementKey(item)
+	read.add(key)
+	pending = pending.filter((entry) => announcementKey(entry) !== key)
+	persist()
+	emitState()
+}
+function markAllRead() {
+	for (const item of items) {
+		read.add(announcementKey(item))
+	}
+	pending = []
+	persist()
+	emitState()
+}
+function advance() {
+	if (disposed || !props.ready || hasModal.value || active.value) return
+	const next = pending.shift()
+	if (next) {
+		void show(next)
+		return
+	}
+	for (const item of items) {
+		const key = announcementKey(item)
+		if (
+			item.type === 'notification' &&
+			!startupNotified.has(key) &&
+			!read.has(key) &&
+			isAnnouncementActive(item)
+		) {
+			startupNotice.value = item
+			startupNotified.add(key)
+			setTimeout(() => {
+				if (startupNotice.value === item) {
+					startupNotice.value = null
+					advance()
+				}
+			}, 8000)
+			break
+		}
+	}
+}
+function closed() {
+	active.value = false
+	centerOpen.value = false
+	if (advanceTimer) clearTimeout(advanceTimer)
+	advanceTimer = setTimeout(advance, 350)
+}
+function sync(next: RemoteAnnouncement[], fresh: boolean) {
+	items = next.filter((item) => isAnnouncementActive(item))
+	const keys = new Set(items.map(announcementKey))
+	pending = pending.filter((item) => keys.has(announcementKey(item)))
+	if (selected.value && !keys.has(announcementKey(selected.value))) selected.value = null
+	emitState()
+	if (fresh) {
+		for (const item of items) {
+			const key = announcementKey(item)
+			if (
+				item.type === 'modal' &&
+				!queuedThisSession.has(key) &&
+				(!read.has(key) || item.priority === 'critical')
+			) {
+				queuedThisSession.add(key)
+				pending.push(item)
+			}
+		}
+		advance()
+	}
+}
+function loadCache() {
+	if (cacheLoaded || !cacheKey) return
+	cacheLoaded = true
+	try {
+		const cached = JSON.parse(localStorage.getItem(cacheKey) ?? 'null')
+		if (cached && typeof cached.savedAt === 'number' && Date.now() - cached.savedAt < 86400000) {
+			const parsed = parseAnnouncements(cached.items)
+			if (parsed) sync(parsed, false)
+		}
+	} catch {
+		// Ignore malformed or expired cache payloads
+	}
+}
+async function refresh() {
+	// Remote fetching is disabled until Starlight has its own announcements API.
+	// We still load any previously cached items so the center has content to show.
+	if (disposed) return
+	loadCache()
+}
+async function openLink(value: unknown) {
+	const url = safeAnnouncementUrl(value)
+	if (!url) return
+	try {
+		await openUrl(url)
+	} catch {
+		// Opener may reject unknown schemes
+	}
+}
+function contentClick(event: MouseEvent) {
+	const link = event.target instanceof Element ? event.target.closest('a') : null
+	if (!link) return
+	event.preventDefault()
+	event.stopPropagation()
+	void openLink(link.getAttribute('href'))
+}
+function preview(type: RemoteAnnouncement['type'], withAction = false) {
+	if (!props.previewOnly || !props.ready || hasModal.value || disposed) return
+	const now = new Date().toISOString()
+	const item: RemoteAnnouncement = {
+		id: 'local-preview-' + type,
+		title: formatMessage(messages.previewTitle),
+		summary: formatMessage(messages.previewSummary),
+		content: formatMessage(messages.previewContent),
+		type,
+		priority: 'normal',
+		starts_at: now,
+		ends_at: null,
+		published_at: now,
+		action_label: withAction ? formatMessage(messages.previewAction) : null,
+		action_url: withAction ? 'https://skin.starlight.cool/' : null,
+	}
+	read.clear()
+	queuedThisSession.clear()
+	sync([item], true)
+}
+defineExpose({ preview })
+onMounted(() => {
+	if (props.previewOnly) return
+	try {
+		const saved = JSON.parse(localStorage.getItem(stateKey) ?? 'null')
+		if (saved && Array.isArray(saved.read))
+			for (const key of saved.read) if (typeof key === 'string') read.add(key)
+	} catch {
+		// Ignore malformed local read-state
+	}
+	window.addEventListener(OPEN_REMOTE_ANNOUNCEMENT_CENTER_EVENT, handleOpenCenter)
+	const start = () => {
+		if (disposed) return
+		void refresh()
+		interval = setInterval(() => {
+			sync(items, false)
+			advance()
+		}, 15000)
+	}
+	// Defer the startup request until after first paint.
+	if (typeof requestIdleCallback === 'function') {
+		requestIdleCallback(start, { timeout: 2000 })
+	} else {
+		setTimeout(start, 500)
+	}
+})
+watch([() => props.ready, hasModal], () => {
+	if (advanceTimer) clearTimeout(advanceTimer)
+	advanceTimer = setTimeout(advance, 350)
+})
+onUnmounted(() => {
+	disposed = true
+	if (interval) clearInterval(interval)
+	if (advanceTimer) clearTimeout(advanceTimer)
+	window.removeEventListener(OPEN_REMOTE_ANNOUNCEMENT_CENTER_EVENT, handleOpenCenter)
+})
+</script>
+
+<template>
+	<div
+		v-if="startupNotice"
+		class="fixed right-4 top-16 z-50 w-[22rem] max-w-[calc(100vw-2rem)] rounded-xl border border-surface-5 bg-surface-3 p-3 shadow-lg"
+	>
+		<button class="w-full text-left" @click="startupNotice && openCenter(startupNotice)">
+			<div class="mb-1 text-xs font-semibold uppercase text-brand">
+				{{ formatMessage(messages.unread) }}
+			</div>
+			<div class="font-semibold text-[var(--color-text-primary)]">{{ startupNotice.title }}</div>
+			<div
+				v-if="startupNotice.summary"
+				class="mt-1 line-clamp-2 text-sm text-[var(--color-text-tertiary)]"
+			>
+				{{ startupNotice.summary }}
+			</div>
+		</button>
+	</div>
+	<NewModal
+		ref="modal"
+		:header="formatMessage(messages.centerTitle)"
+		:on-hide="closed"
+		max-width="80vw"
+		width="80vw"
+		max-content-height="calc(80vh - 8rem)"
+		scrollable
+	>
+		<div class="flex h-[calc(80vh-8rem)] min-h-0 gap-3">
+			<aside class="flex min-h-0 w-[32%] min-w-[14rem] flex-col border-r border-surface-5 pr-3">
+				<div class="mb-2 flex items-center justify-between">
+					<span class="font-semibold text-[var(--color-text-primary)]">{{
+						formatMessage(messages.centerTitle)
+					}}</span>
+					<Button
+						v-if="items.some((item) => !read.has(announcementKey(item)))"
+						@click="markAllRead"
+						>{{ formatMessage(messages.readAll) }}</Button
+					>
+				</div>
+				<div
+					v-if="!items.length"
+					class="py-8 text-center text-sm text-[var(--color-text-tertiary)]"
+				>
+					{{ formatMessage(messages.empty) }}
+				</div>
+				<div v-else class="flex min-h-0 flex-col gap-1 overflow-auto">
+					<button
+						v-for="item in items"
+						:key="announcementKey(item)"
+						class="flex items-start gap-2 rounded-lg p-2 text-left hover:bg-surface-4"
+						:class="{
+							'bg-surface-4': selected && announcementKey(selected) === announcementKey(item),
+						}"
+						@click="selectAnnouncement(item)"
+					>
+						<span
+							class="mt-1.5 size-2 shrink-0 rounded-full"
+							:class="read.has(announcementKey(item)) ? 'opacity-0' : 'bg-red'"
+						/>
+						<span class="min-w-0 flex-1">
+							<span class="block truncate font-medium text-[var(--color-text-primary)]">{{
+								item.title
+							}}</span>
+							<span class="block line-clamp-2 text-xs text-[var(--color-text-tertiary)]">{{
+								item.summary || item.content
+							}}</span>
+						</span>
+					</button>
+				</div>
+			</aside>
+			<section v-if="selected" class="min-h-0 min-w-0 flex-1 overflow-auto px-1">
+				<h2 class="mb-4 text-xl font-semibold text-[var(--color-text-primary)]">
+					{{ selected.title }}
+				</h2>
+				<div
+					class="markdown-body break-words"
+					@click="contentClick"
+					@auxclick="contentClick"
+					v-html="html"
+				/>
+				<div class="mt-4 flex justify-end">
+					<Button
+						v-if="selected.action_url && selected.action_label"
+						type="colored"
+						color="brand"
+						@click="openLink(selected.action_url)"
+						>{{ selected.action_label }}</Button
+					>
+				</div>
+			</section>
+			<div
+				v-else
+				class="flex flex-1 items-center justify-center text-sm text-[var(--color-text-tertiary)]"
+			>
+				{{ formatMessage(messages.empty) }}
+			</div>
+		</div>
+		<template #actions>
+			<div class="flex flex-wrap justify-end gap-2">
+				<Button @click="modal?.hide()">{{ formatMessage(commonMessages.closeButton) }} </Button>
+			</div>
+		</template>
+	</NewModal>
+</template>

apps/app-frontend/src/helpers/remote-announcements.ts

@@ -64,3 +64,6 @@ export function isAnnouncementActive(item: RemoteAnnouncement, now = Date.now())
 export function announcementKey(item: RemoteAnnouncement) {
 	return item.id + ':' + item.published_at
 }
+
+export const REMOTE_ANNOUNCEMENTS_UPDATED_EVENT = 'starlight:remote-announcements-updated'
+export const OPEN_REMOTE_ANNOUNCEMENT_CENTER_EVENT = 'starlight:open-remote-announcement-center'

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

@@ -11431,5 +11431,35 @@
   },
   "app.anniversary.banner": {
     "message": "Happy {ordinal} Anniversary, Starlight!"
+  },
+  "app.action-bar.announcements": {
+    "message": "Announcements"
+  },
+  "app.remote-announcements.center-title": {
+    "message": "Announcements"
+  },
+  "app.remote-announcements.empty": {
+    "message": "No announcements"
+  },
+  "app.remote-announcements.view": {
+    "message": "View announcement"
+  },
+  "app.remote-announcements.unread": {
+    "message": "Unread"
+  },
+  "app.remote-announcements.read-all": {
+    "message": "Mark all announcements as read"
+  },
+  "app.remote-announcements.preview-title": {
+    "message": "Announcement style preview"
+  },
+  "app.remote-announcements.preview-summary": {
+    "message": "This is a local preview notification. Select View announcement to see the full Markdown content."
+  },
+  "app.remote-announcements.preview-content": {
+    "message": "## Announcement preview\n\nThis is **sample content**, not a published announcement.\n\n- Supports headings, lists, and links\n- Close buttons are always available\n\n> Previewing does not change real announcement read status.\n\n| Type | Display |\n| --- | --- |\n| Modal | Full Markdown content |\n| Popup | Summary, then full content |\n\n[Visit the website](https://skin.starlight.cool/)"
+  },
+  "app.remote-announcements.preview-action": {
+    "message": "Visit website"
   }
 }

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

@@ -11351,5 +11351,8 @@
 	"app.settings.synced-options.game-settings.value-off": { "message": "关闭" },
 	"app.settings.synced-options.game-settings.value-on": { "message": "开启" },
 	"app.settings.synced-options.game-settings.value-unset": { "message": "选择一个值" },
-	"app.anniversary.banner": { "message": "Starlight {ordinal} 周年快乐！" }
+	"app.anniversary.banner": { "message": "Starlight {ordinal} 周年快乐！" },
+	"app.action-bar.announcements": { "message": "公告" },
+	"app.remote-announcements.center-title": { "message": "公告" },
+	"app.remote-announcements.empty": { "message": "暂无公告" }
 }

apps/app/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "theseus_gui"
 # The actual version is set by the theseus-build workflow on tagging
-version = "1.0.0-beta15"
+version = "1.0.2-beta4"
 edition.workspace = true
 description = "Axolotl Launcher is a cross-platform Minecraft launcher"
 homepage = "https://www.ghs.red"

packages/app-lib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "theseus"
 # The actual version is set by the theseus-build workflow on tagging
-version = "1.0.0-beta15"
+version = "1.0.2-beta4"
 edition.workspace = true
 
 [dependencies]

packages/app-lib/src/launcher/download.rs

@@ -1947,8 +1947,8 @@ pub async fn download_assets(
     // failures. Runs concurrently (same budget as the original scheduler) so
     // import flows are not serialised.
     if !fallback_assets.is_empty() {
-        let limit = crate::util::download::task_concurrency_limit(st)
-            .map(|limit| limit.saturating_mul(2))
+        let limit =
+            crate::util::download::single_authority_task_concurrency_limit(st)
                 .unwrap_or(ASSET_BATCH_CONCURRENCY);
         futures::stream::iter(fallback_assets)
             .map(Ok::<FallbackAsset, crate::Error>)
@@ -2123,7 +2123,7 @@ pub async fn download_libraries(
     let num_files = tasks.len();
     loading_try_for_each_concurrent(
 		stream::iter(tasks).map(Ok::<LibraryDownloadTask<'_>, crate::Error>),
-		crate::util::download::task_concurrency_limit(&st).map(|limit| limit.saturating_mul(2)),
+		crate::util::download::task_concurrency_limit(&st),
         loading_bar,
         loading_amount,
         num_files,

packages/app-lib/src/state/instances/commands/create_direct_link_instance.rs

@@ -1,6 +1,5 @@
 use crate::api::pack::import::{
-    ImportLauncherType,
-    direct_link::resolve_direct_link,
+    ImportLauncherType, direct_link::resolve_direct_link,
 };
 use crate::launcher::ExternalGameDirMode;
 use crate::state::instances::{

packages/app-lib/src/state/instances/commands/sync_direct_link_instances.rs

@@ -1,7 +1,7 @@
 use super::create_direct_link_instance::create_direct_link_instance;
 use crate::api::pack::import::direct_link::{
-    detect_direct_link_source,
-    has_minecraft_version_manifest, resolve_direct_link,
+    detect_direct_link_source, has_minecraft_version_manifest,
+    resolve_direct_link,
 };
 use crate::event::{InstancePayloadType, emit::emit_instance};
 use crate::launcher::ExternalGameDirMode;

packages/app-lib/src/state/mod.rs

@@ -118,6 +118,7 @@ pub struct State {
     download_sample_requests: AtomicU64,
     download_sample_errors: AtomicU64,
     download_sample_throttles: AtomicU64,
+    download_sample_queue_waits: AtomicU64,
     pub(crate) install_job_semaphore: Semaphore,
     pub(crate) install_db_semaphore: Semaphore,
     pub(crate) install_job_cancellations: DashMap<Uuid, CancellationToken>,
@@ -196,6 +197,7 @@ struct AutoConcurrencySample {
     requests: u64,
     errors: u64,
     throttles: u64,
+    queue_waits: u64,
 }
 
 /// Per-instance lock registry with task-local reentrancy.
@@ -399,6 +401,15 @@ impl AutoConcurrencyController {
         } else {
             sample.errors as f64 / sample.requests as f64
         };
+        if sample.queue_waits > 0 {
+            self.high_utilization_windows = 0;
+            self.pressure_windows = 0;
+            self.probe = None;
+            self.cooldown_until = Some(now + AUTO_DOWNLOAD_PROBE_COOLDOWN);
+            return current
+                .saturating_sub(current.div_ceil(4))
+                .max(AUTO_DOWNLOAD_CONCURRENCY_MIN);
+        }
         // A single throttled window is handled by the per-host limiter; the
         // global concurrency only backs off when pressure persists across
         // several samples, and then in small steps instead of a big cut.
@@ -677,6 +688,11 @@ impl State {
         self.download_sample_errors.fetch_add(1, Ordering::AcqRel);
     }
 
+    pub(crate) fn record_download_queue_wait(&self) {
+        self.download_sample_queue_waits
+            .fetch_add(1, Ordering::AcqRel);
+    }
+
     pub(crate) fn update_download_settings(
         self: &Arc<Self>,
         settings: &Settings,
@@ -735,6 +751,7 @@ impl State {
                 self.download_sample_requests.swap(0, Ordering::AcqRel);
                 self.download_sample_errors.swap(0, Ordering::AcqRel);
                 self.download_sample_throttles.swap(0, Ordering::AcqRel);
+                self.download_sample_queue_waits.swap(0, Ordering::AcqRel);
                 continue;
             }
             let sample = AutoConcurrencySample {
@@ -749,6 +766,9 @@ impl State {
                 throttles: self
                     .download_sample_throttles
                     .swap(0, Ordering::AcqRel),
+                queue_waits: self
+                    .download_sample_queue_waits
+                    .swap(0, Ordering::AcqRel),
             };
             let current = self.download_concurrency();
             let ceiling =
@@ -771,6 +791,7 @@ impl State {
                     requests = sample.requests,
                     errors = sample.errors,
                     throttles = sample.throttles,
+                    queue_waits = sample.queue_waits,
                     "Adjusted automatic download concurrency"
                 );
                 self.resize_download_concurrency(target);
@@ -935,6 +956,7 @@ impl State {
             download_sample_requests: AtomicU64::new(0),
             download_sample_errors: AtomicU64::new(0),
             download_sample_throttles: AtomicU64::new(0),
+            download_sample_queue_waits: AtomicU64::new(0),
             install_job_semaphore: Semaphore::new(MAX_CONCURRENT_INSTALL_JOBS),
             install_db_semaphore: Semaphore::new(1),
             install_job_cancellations: DashMap::new(),
@@ -1024,6 +1046,7 @@ pub(crate) async fn test_state(
         download_sample_requests: AtomicU64::new(0),
         download_sample_errors: AtomicU64::new(0),
         download_sample_throttles: AtomicU64::new(0),
+        download_sample_queue_waits: AtomicU64::new(0),
         install_job_semaphore: Semaphore::new(1),
         install_db_semaphore: Semaphore::new(1),
         install_job_cancellations: DashMap::new(),
@@ -1053,9 +1076,24 @@ mod auto_concurrency_tests {
             requests: 100,
             errors: 0,
             throttles: 0,
+            queue_waits: 0,
         }
     }
 
+    #[test]
+    fn queue_pressure_backs_off_immediately_and_repeatedly() {
+        let mut controller = AutoConcurrencyController::default();
+        let now = Instant::now();
+        let congested = AutoConcurrencySample {
+            queue_waits: 1,
+            ..healthy(8, 100)
+        };
+
+        assert_eq!(controller.next_target(now, 128, 128, congested), 96);
+        assert_eq!(controller.next_target(now, 96, 128, congested), 72);
+        assert_eq!(controller.next_target(now, 16, 128, congested), 16);
+    }
+
     #[test]
     fn probes_up_after_two_saturated_windows_and_respects_ceiling() {
         let mut controller = AutoConcurrencyController::default();
@@ -1130,6 +1168,7 @@ mod auto_concurrency_tests {
             requests: 100,
             errors: 5,
             throttles: 0,
+            queue_waits: 0,
         };
         assert_eq!(controller.next_target(Instant::now(), 16, 128, sample), 16);
     }

packages/app-lib/src/util/download/h2_download.rs

@@ -62,6 +62,7 @@ pub(crate) enum H2DownloadOutcome {
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum H2DownloadFailure {
     Ineligible(&'static str),
+    Capacity,
     Connect,
     Tls,
     Protocol,
@@ -76,6 +77,7 @@ impl H2DownloadFailure {
     pub(crate) const fn as_str(self) -> &'static str {
         match self {
             Self::Ineligible(reason) => reason,
+            Self::Capacity => "HTTP/2 connection capacity is unavailable",
             Self::Connect => "HTTP/2 TCP connection failed",
             Self::Tls => "HTTP/2 TLS connection failed",
             Self::Protocol => "HTTP/2 protocol failed",
@@ -104,6 +106,7 @@ impl H2DownloadFailure {
 pub(crate) async fn try_download_via_h2(
     request: &DownloadRequest,
     route: &DownloadRoute,
+    semaphore: &fetch::FetchSemaphore,
     destination: &Path,
     part_path: &Path,
     policy: super::native::NativeH2Policy,
@@ -122,13 +125,19 @@ pub(crate) async fn try_download_via_h2(
             preserve_partial: false,
         };
     }
-    let connection = match connect_authority(
-        route,
-        true,
-        policy.allow_cold_connection,
-    )
-    .await
+    let connection_wait =
+        connect_authority(route, true, policy.allow_cold_connection);
+    let connection_result = if let Some(cancellation) =
+        request.cancellation.as_ref()
     {
+        tokio::select! {
+            _ = cancellation.cancelled() => return H2DownloadOutcome::Canceled,
+            result = connection_wait => result,
+        }
+    } else {
+        connection_wait.await
+    };
+    let connection = match connection_result {
         Ok(connection) => connection,
         Err(failure) => {
             return H2DownloadOutcome::Fallback {
@@ -137,6 +146,30 @@ pub(crate) async fn try_download_via_h2(
             };
         }
     };
+    // The shared connection reserves native capacity when it is created.
+    // Acquire the per-download permit afterwards so every native path uses
+    // the same native-then-fetch order and cannot form a circular wait.
+    let fetch_permit_wait =
+        fetch::acquire_fetch_permit_with_pressure(semaphore);
+    let fetch_permit_result = if let Some(cancellation) =
+        request.cancellation.as_ref()
+    {
+        tokio::select! {
+            _ = cancellation.cancelled() => return H2DownloadOutcome::Canceled,
+            result = fetch_permit_wait => result,
+        }
+    } else {
+        fetch_permit_wait.await
+    };
+    let _fetch_permit = match fetch_permit_result {
+        Ok(permit) => permit,
+        Err(_) => {
+            return H2DownloadOutcome::Fallback {
+                failure: H2DownloadFailure::Connect,
+                preserve_partial: false,
+            };
+        }
+    };
     let Ok(uri) = route.url.parse::<Uri>() else {
         return H2DownloadOutcome::Fallback {
             failure: H2DownloadFailure::Http,
@@ -156,14 +189,20 @@ pub(crate) async fn try_download_via_h2(
     let total_size = if let Some(size) = expected_size {
         size
     } else {
-        let _probe_stream_permit = match tokio::time::timeout(
-            ASSET_RESOURCE_WAIT_TIMEOUT,
-            super::h2_stream_budget::acquire(route),
-        )
-        .await
+        let probe_wait = super::h2_stream_budget::acquire_with_pressure(route);
+        let probe_result = if let Some(cancellation) =
+            request.cancellation.as_ref()
         {
-            Ok(Ok(permit)) => permit,
-            Ok(Err(_)) | Err(_) => {
+            tokio::select! {
+                _ = cancellation.cancelled() => return H2DownloadOutcome::Canceled,
+                result = probe_wait => result,
+            }
+        } else {
+            probe_wait.await
+        };
+        let _probe_stream_permit = match probe_result {
+            Ok(permit) => permit,
+            Err(_) => {
                 return H2DownloadOutcome::Fallback {
                     failure: H2DownloadFailure::Connect,
                     preserve_partial: false,
@@ -239,10 +278,7 @@ pub(crate) async fn try_download_via_h2(
         crate::install::DownloadItemStatus::WaitingForResource,
     )
     .await;
-    let stream_wait = tokio::time::timeout(
-        ASSET_RESOURCE_WAIT_TIMEOUT,
-        super::h2_stream_budget::acquire(route),
-    );
+    let stream_wait = super::h2_stream_budget::acquire_with_pressure(route);
     let stream_wait_started = Instant::now();
     let stream_result = if let Some(cancellation) =
         request.cancellation.as_ref()
@@ -255,8 +291,8 @@ pub(crate) async fn try_download_via_h2(
         stream_wait.await
     };
     let _stream_permit = match stream_result {
-        Ok(Ok(permit)) => permit,
-        Ok(Err(_)) | Err(_) => {
+        Ok(permit) => permit,
+        Err(_) => {
             return H2DownloadOutcome::Fallback {
                 failure: H2DownloadFailure::Connect,
                 preserve_partial: false,
@@ -327,6 +363,7 @@ async fn connect_authority(
                 "Failed to establish shared HTTP/2 connection"
             );
             Err(match error.kind {
+                H2ConnectFailureKind::Capacity => H2DownloadFailure::Capacity,
                 H2ConnectFailureKind::Tcp => H2DownloadFailure::Connect,
                 H2ConnectFailureKind::Tls => H2DownloadFailure::Tls,
                 H2ConnectFailureKind::Protocol => H2DownloadFailure::Protocol,
@@ -771,6 +808,12 @@ mod tests {
     use super::*;
     use bytes::Bytes;
 
+    #[test]
+    fn capacity_wait_is_not_classified_as_a_transport_failure() {
+        assert!(!H2DownloadFailure::Capacity.is_transfer_failure());
+        assert!(!H2DownloadFailure::Capacity.should_cooldown_authority());
+    }
+
     #[tokio::test]
     async fn single_stream_reports_bytes_before_the_response_finishes() {
         let size = 512 * 1024;
@@ -1183,28 +1226,6 @@ async fn download_asset_item(
             "timed out waiting for asset destination lock".to_string(),
         )
     })?;
-    let fetch_permit = if apply_native_policy {
-        let Some(semaphore) = native_semaphore else {
-            return Err(crate::ErrorKind::OtherError(
-                "native asset batch is missing fetch budget".to_string(),
-            )
-            .into());
-        };
-        Some(
-            tokio::time::timeout(
-                ASSET_RESOURCE_WAIT_TIMEOUT,
-                semaphore.0.acquire(),
-            )
-            .await
-            .map_err(|_| {
-                crate::ErrorKind::NetworkError(
-                    "timed out waiting for asset fetch permit".to_string(),
-                )
-            })??,
-        )
-    } else {
-        None
-    };
     // A different downloader may have committed the object while this item
     // waited for the destination lock. Reuse it instead of opening another
     // stream, which also prevents cross-engine `.part`/rename races.
@@ -1243,24 +1264,26 @@ async fn download_asset_item(
             return Ok(AssetBatchItemOutcome::LocalObjectFailed { error });
         }
     };
-    let _stream_permit = if apply_native_policy {
-        Some(
-            tokio::time::timeout(
-                ASSET_RESOURCE_WAIT_TIMEOUT,
-                super::h2_stream_budget::acquire_asset(route),
-            )
-            .await
-            .map_err(|_| {
-                crate::ErrorKind::NetworkError(
-                    "timed out waiting for asset HTTP/2 stream permit"
-                        .to_string(),
-                )
-            })??,
+    // Resolve the primary or lazily expanded sibling before taking the fetch
+    // permit. Shared connections reserve native capacity, so this preserves
+    // the native-then-fetch order used by every other native path.
+    let connection = connections.connection(rescue).await;
+    let fetch_permit = if apply_native_policy {
+        let Some(semaphore) = native_semaphore else {
+            return Err(crate::ErrorKind::OtherError(
+                "native asset batch is missing fetch budget".to_string(),
             )
+            .into());
+        };
+        Some(fetch::acquire_fetch_permit_with_pressure(semaphore).await?)
+    } else {
+        None
+    };
+    let _stream_permit = if apply_native_policy {
+        Some(super::h2_stream_budget::acquire_asset_with_pressure(route).await?)
     } else {
         None
     };
-    let connection = connections.connection(rescue).await;
     let _connection_stream = connection.track_stream();
     let mut headers = HeaderMap::new();
     headers.insert(

packages/app-lib/src/util/download/h2_pool.rs

@@ -34,6 +34,7 @@ const CONNECTION_WAIT_TIMEOUT: Duration = Duration::from_secs(45);
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub(crate) enum H2ConnectFailureKind {
+    Capacity,
     Tcp,
     Tls,
     Protocol,
@@ -357,9 +358,41 @@ async fn connect_tcp(host: &str, port: u16) -> std::io::Result<TcpStream> {
 }
 
 /// Connects a new shared HTTP/2 connection to `authority` (host[:port]).
-async fn establish(
+async fn reserve_physical_budget(
     route: &DownloadRoute,
     reserve_native_budget: bool,
+) -> Result<Option<super::native_budget::NativeBudgetPermit>, H2ConnectError> {
+    Ok(if reserve_native_budget {
+        Some(
+            crate::util::fetch::wait_for_download_resource(
+                super::native_budget::acquire(route),
+            )
+            .await
+            .map_err(|_| {
+                H2ConnectError::new(
+                    H2ConnectFailureKind::Capacity,
+                    "HTTP/2 connection capacity remained stalled for 5 minutes"
+                        .to_string(),
+                )
+            })?
+            .map_err(|error| {
+                H2ConnectError::new(
+                    H2ConnectFailureKind::Capacity,
+                    format!(
+                        "failed to reserve HTTP/2 connection capacity: {error}"
+                    ),
+                )
+            })?,
+        )
+    } else {
+        None
+    })
+}
+
+/// Connects a new shared HTTP/2 connection to `authority` (host[:port]).
+async fn establish(
+    route: &DownloadRoute,
+    physical_budget: Option<super::native_budget::NativeBudgetPermit>,
 ) -> Result<Arc<SharedH2Connection>, H2ConnectError> {
     let authority =
         crate::util::fetch::url_authority(&route.url).ok_or_else(|| {
@@ -368,16 +401,6 @@ async fn establish(
                 "HTTP/2 route has no authority".to_string(),
             )
         })?;
-    let physical_budget = if reserve_native_budget {
-        Some(super::native_budget::acquire(route).await.map_err(|error| {
-            H2ConnectError::new(
-                H2ConnectFailureKind::Tcp,
-                format!("failed to reserve HTTP/2 connection capacity: {error}"),
-            )
-        })?)
-    } else {
-        None
-    };
     let (host, port) = authority
         .rsplit_once(':')
         .map(|(host, port)| (host, port.parse::<u16>().unwrap_or(443)))
@@ -487,14 +510,14 @@ pub(crate) async fn shared_connection(
             )
         })?;
     let slot = connection_slot(&authority).await;
-    let mut cached = tokio::time::timeout(CONNECTION_WAIT_TIMEOUT, slot.lock())
+    let mut cached = crate::util::fetch::wait_for_download_resource(
+        slot.lock(),
+    )
     .await
     .map_err(|_| {
         H2ConnectError::new(
-                H2ConnectFailureKind::Protocol,
-                format!(
-                    "timed out waiting for HTTP/2 connection slot {authority}"
-                ),
+            H2ConnectFailureKind::Capacity,
+            format!("HTTP/2 connection slot remained stalled for {authority}"),
         )
     })?;
     if let Some(connection) = cached.as_ref().filter(|connection| {
@@ -525,9 +548,11 @@ pub(crate) async fn shared_connection(
         ));
     }
     tracing::debug!(authority, "Establishing cold shared HTTP/2 connection");
+    let physical_budget =
+        reserve_physical_budget(route, reserve_native_budget).await?;
     let connection = tokio::time::timeout(
         CONNECTION_WAIT_TIMEOUT,
-        establish(route, reserve_native_budget),
+        establish(route, physical_budget),
     )
     .await
     .map_err(|_| {
@@ -555,15 +580,16 @@ pub(crate) async fn shared_batch_connection(
             )
         })?;
     let slot = batch_connection_slot(&authority).await;
-    let mut cached = tokio::time::timeout(
-        CONNECTION_WAIT_TIMEOUT,
+    let mut cached = crate::util::fetch::wait_for_download_resource(
         slot.lock(),
     )
     .await
     .map_err(|_| {
         H2ConnectError::new(
-            H2ConnectFailureKind::Protocol,
-            format!("timed out waiting for asset HTTP/2 connection slot {authority}"),
+            H2ConnectFailureKind::Capacity,
+            format!(
+                "asset HTTP/2 connection slot remained stalled for {authority}"
+            ),
         )
     })?;
     if let Some(connection) = cached.as_ref().filter(|connection| {
@@ -591,9 +617,11 @@ pub(crate) async fn shared_batch_connection(
         *cached = None;
     }
     tracing::debug!(authority, "Establishing sibling HTTP/2 asset connection");
+    let physical_budget =
+        reserve_physical_budget(route, reserve_native_budget).await?;
     let connection = tokio::time::timeout(
         CONNECTION_WAIT_TIMEOUT,
-        establish(route, reserve_native_budget),
+        establish(route, physical_budget),
     )
     .await
     .map_err(|_| {
@@ -614,10 +642,13 @@ pub(crate) async fn has_live_connection(authority: &str) -> bool {
         return false;
     };
     drop(connections);
-    let live = slot
-        .lock()
-        .await
+    let Ok(cached) = slot.try_lock() else {
+        // This is only an eligibility probe. A busy slot means another task
+        // is establishing or refreshing the connection; do not queue this
+        // caller behind that work before its cancellation-aware download path.
+        return false;
+    };
+    cached
         .as_ref()
-        .is_some_and(|connection| !connection.is_dead());
-    live
+        .is_some_and(|connection| !connection.is_dead())
 }

packages/app-lib/src/util/download/h2_range.rs

@@ -218,12 +218,8 @@ async fn download_range(
         crate::install::DownloadItemStatus::WaitingForResource,
     )
     .await;
-    let _permit = tokio::time::timeout(
-        Duration::from_secs(45),
-        super::h2_stream_budget::acquire(route),
-    )
+    let _permit = super::h2_stream_budget::acquire_with_pressure(route)
         .await
-    .map_err(|_| H2DownloadFailure::Connect)?
         .map_err(|_| H2DownloadFailure::Connect)?;
     super::h2_download::record_install_stage(
         request,

packages/app-lib/src/util/download/h2_stream_budget.rs

@@ -104,6 +104,20 @@ pub(crate) async fn acquire(
     }
 }
 
+pub(crate) async fn acquire_with_pressure(
+    route: &DownloadRoute,
+) -> crate::Result<H2StreamPermit> {
+    crate::util::fetch::wait_for_download_resource(acquire(route))
+        .await
+        .map_err(|_| {
+            crate::Error::from(crate::ErrorKind::NetworkError(
+                "HTTP/2 stream permit remained stalled for 5 minutes"
+                    .to_string(),
+            ))
+        })?
+        .map_err(Into::into)
+}
+
 /// Acquires a stream for the Minecraft asset batch. Assets retain a large
 /// logical worker window, but use a separate physical stream pool so they
 /// cannot consume the ordinary native content share.
@@ -134,10 +148,25 @@ pub(crate) async fn acquire_asset(
     }
 }
 
+pub(crate) async fn acquire_asset_with_pressure(
+    route: &DownloadRoute,
+) -> crate::Result<H2StreamPermit> {
+    crate::util::fetch::wait_for_download_resource(acquire_asset(route))
+        .await
+        .map_err(|_| {
+            crate::Error::from(crate::ErrorKind::NetworkError(
+                "asset HTTP/2 stream permit remained stalled for 5 minutes"
+                    .to_string(),
+            ))
+        })?
+        .map_err(Into::into)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::util::fetch::DownloadRouteSource;
+    use std::sync::atomic::{AtomicUsize, Ordering};
 
     fn route() -> DownloadRoute {
         DownloadRoute {
@@ -190,4 +219,40 @@ mod tests {
             MAX_H2_STREAMS_PER_AUTHORITY
         );
     }
+
+    #[tokio::test]
+    async fn contended_stream_wait_reports_pressure_and_resumes() {
+        let route = DownloadRoute {
+            url: "https://h2-pressure.example/file".to_string(),
+            source: DownloadRouteSource::Official,
+            is_mirror: false,
+            allow_sensitive_headers: true,
+            supports_range: true,
+            proxy: ProxyPolicy::Direct,
+        };
+        let mut held = Vec::new();
+        for _ in 0..MAX_H2_STREAMS_PER_AUTHORITY {
+            held.push(acquire(&route).await.unwrap());
+        }
+        let pressure = Arc::new(AtomicUsize::new(0));
+        let observed = Arc::clone(&pressure);
+        let release = tokio::spawn(async move {
+            tokio::time::sleep(Duration::from_millis(35)).await;
+            drop(held);
+        });
+
+        let permit = crate::util::fetch::wait_for_resource_with_pressure(
+            acquire(&route),
+            Duration::from_millis(5),
+            Duration::from_millis(100),
+            move || {
+                observed.fetch_add(1, Ordering::Relaxed);
+            },
+        )
+        .await;
+
+        release.await.unwrap();
+        assert!(permit.is_ok());
+        assert!(pressure.load(Ordering::Relaxed) >= 1);
+    }
 }

packages/app-lib/src/util/download/mod.rs

@@ -73,6 +73,19 @@ pub(crate) fn task_concurrency_limit(state: &crate::State) -> Option<usize> {
     if active_engine() == DownloadEngine::XmclCompat {
         None
     } else {
-        Some(state.download_concurrency())
+        Some(native_budget::task_limit(
+            state.download_concurrency(),
+            usize::MAX,
+        ))
+    }
+}
+
+pub(crate) fn single_authority_task_concurrency_limit(
+    state: &crate::State,
+) -> Option<usize> {
+    if active_engine() == DownloadEngine::XmclCompat {
+        None
+    } else {
+        Some(native_budget::task_limit(state.download_concurrency(), 1))
     }
 }

packages/app-lib/src/util/download/native_budget.rs

@@ -144,6 +144,15 @@ pub(crate) fn available(route: &DownloadRoute) -> usize {
         .unwrap_or(MAX_CONNECTIONS_PER_AUTHORITY)
 }
 
+pub(crate) fn task_limit(
+    configured_limit: usize,
+    authority_count: usize,
+) -> usize {
+    configured_limit.max(1).min(MAX_NATIVE_CONNECTIONS).min(
+        MAX_CONNECTIONS_PER_AUTHORITY.saturating_mul(authority_count.max(1)),
+    )
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -174,4 +183,11 @@ mod tests {
         drop(permits);
         assert!(try_acquire(&route).is_ok());
     }
+
+    #[test]
+    fn task_limit_matches_native_connection_capacity() {
+        assert_eq!(task_limit(128, 1), 8);
+        assert_eq!(task_limit(128, 4), 32);
+        assert_eq!(task_limit(4, 1), 4);
+    }
 }

packages/app-lib/src/util/fetch.rs

@@ -85,6 +85,8 @@ const MAX_REDIRECT_LOCATION_BYTES: usize = 8 * 1024;
 const FILE_TRANSFER_CONNECT_TIMEOUT: time::Duration =
     time::Duration::from_secs(20);
 const RESOURCE_WAIT_TIMEOUT: time::Duration = time::Duration::from_secs(45);
+const RESOURCE_PRESSURE_INTERVAL: time::Duration = time::Duration::from_secs(3);
+const RESOURCE_STALL_TIMEOUT: time::Duration = time::Duration::from_secs(300);
 #[cfg(not(test))]
 const FILE_TRANSFER_READ_TIMEOUT: time::Duration =
     time::Duration::from_secs(60);
@@ -3894,6 +3896,73 @@ struct NativeConnectionPermit<'a> {
     _native: crate::util::download::native_budget::NativeBudgetPermit,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum ResourceWaitError {
+    TimedOut,
+}
+
+pub(crate) async fn wait_for_resource_with_pressure<F, T, P>(
+    future: F,
+    pressure_interval: time::Duration,
+    stall_timeout: time::Duration,
+    mut on_pressure: P,
+) -> Result<T, ResourceWaitError>
+where
+    F: Future<Output = T>,
+    P: FnMut(),
+{
+    let pressure_interval =
+        pressure_interval.max(time::Duration::from_millis(1));
+    let pressure_timer = tokio::time::sleep(pressure_interval);
+    let stall_timer = tokio::time::sleep(stall_timeout);
+    tokio::pin!(future, pressure_timer, stall_timer);
+
+    loop {
+        tokio::select! {
+            result = &mut future => return Ok(result),
+            _ = &mut stall_timer => return Err(ResourceWaitError::TimedOut),
+            _ = &mut pressure_timer => {
+                on_pressure();
+                pressure_timer.as_mut().reset(
+                    tokio::time::Instant::now() + pressure_interval,
+                );
+            }
+        }
+    }
+}
+
+pub(crate) async fn wait_for_download_resource<F, T>(
+    future: F,
+) -> Result<T, ResourceWaitError>
+where
+    F: Future<Output = T>,
+{
+    wait_for_resource_with_pressure(
+        future,
+        RESOURCE_PRESSURE_INTERVAL,
+        RESOURCE_STALL_TIMEOUT,
+        || {
+            if let Some(state) = crate::State::get_if_initialized() {
+                state.record_download_queue_wait();
+            }
+        },
+    )
+    .await
+}
+
+pub(crate) async fn acquire_fetch_permit_with_pressure(
+    semaphore: &FetchSemaphore,
+) -> crate::Result<SemaphorePermit<'_>> {
+    wait_for_download_resource(semaphore.0.acquire())
+        .await
+        .map_err(|_| {
+            crate::Error::from(ErrorKind::NetworkError(
+                "download permit remained stalled for 5 minutes".to_string(),
+            ))
+        })?
+        .map_err(Into::into)
+}
+
 async fn acquire_native_connection<'a>(
     route: &DownloadRoute,
     semaphore: &'a FetchSemaphore,
@@ -3906,6 +3975,20 @@ async fn acquire_native_connection<'a>(
     })
 }
 
+async fn acquire_native_connection_with_pressure<'a>(
+    route: &DownloadRoute,
+    semaphore: &'a FetchSemaphore,
+) -> crate::Result<NativeConnectionPermit<'a>> {
+    wait_for_download_resource(acquire_native_connection(route, semaphore))
+        .await
+        .map_err(|_| {
+            crate::Error::from(ErrorKind::NetworkError(
+                "native download resources remained stalled for 5 minutes"
+                    .to_string(),
+            ))
+        })?
+}
+
 fn try_acquire_native_connection<'a>(
     route: &DownloadRoute,
     semaphore: &'a FetchSemaphore,
@@ -5703,19 +5786,11 @@ async fn download_to_path_inner(
         None
     };
     if let Some((h2_route, h2_policy)) = h2_selection {
-        let h2_permit =
-            tokio::time::timeout(RESOURCE_WAIT_TIMEOUT, semaphore.0.acquire())
-                .await
-                .map_err(|_| {
-                    ErrorKind::NetworkError(
-                        "timed out waiting for HTTP/2 download permit"
-                            .to_string(),
-                    )
-                })??;
         let h2_started = Instant::now();
         match crate::util::download::h2_download::try_download_via_h2(
             &request,
             &h2_route,
+            semaphore,
             destination,
             &part_path,
             h2_policy,
@@ -5808,7 +5883,6 @@ async fn download_to_path_inner(
                     .await?;
             }
         }
-        drop(h2_permit);
     }
 
     let mut official_integrity_retry = h2_failed_nonofficial.is_some();
@@ -6147,8 +6221,6 @@ async fn download_to_path_inner(
                 } else {
                     0
                 };
-                let mut activity = crate::State::get_if_initialized()
-                    .map(|state| state.begin_download_connection());
                 record_install_download_started(
                     &request,
                     route,
@@ -6161,25 +6233,21 @@ async fn download_to_path_inner(
                     DownloadItemStatus::WaitingForResource,
                 )
                 .await;
-                let permit_wait = tokio::time::timeout(
-                    RESOURCE_WAIT_TIMEOUT,
-                    acquire_native_connection(route, semaphore),
-                );
+                let permit_wait =
+                    acquire_native_connection_with_pressure(route, semaphore);
                 let resource_wait_started = Instant::now();
-                let permit = if let Some(cancellation) = request.cancellation.as_ref() {
+                let permit = if let Some(cancellation) =
+                    request.cancellation.as_ref()
+                {
                     tokio::select! {
                         _ = cancellation.cancelled() => return Err(ErrorKind::OtherError("download canceled while waiting for native resources".to_string()).into()),
                         result = permit_wait => result,
                     }
                 } else {
                     permit_wait.await
-                }
-                .map_err(|_| {
-                    ErrorKind::NetworkError(
-                        "timed out waiting for native download resources"
-                            .to_string(),
-                    )
-                })??;
+                }?;
+                let mut activity = crate::State::get_if_initialized()
+                    .map(|state| state.begin_download_connection());
                 tracing::debug!(
                     route = %sanitize_url_for_log(&route.url),
                     resource = "native_connection_and_fetch",
@@ -7135,6 +7203,40 @@ mod tests {
     static H2_FALLBACK_TEST_LOCK: LazyLock<std::sync::Mutex<()>> =
         LazyLock::new(|| std::sync::Mutex::new(()));
 
+    #[tokio::test]
+    async fn resource_wait_reports_pressure_without_losing_queue_position() {
+        let pressure_events = Arc::new(AtomicUsize::new(0));
+        let observed = Arc::clone(&pressure_events);
+        let result = wait_for_resource_with_pressure(
+            async {
+                tokio::time::sleep(Duration::from_millis(35)).await;
+                7
+            },
+            Duration::from_millis(5),
+            Duration::from_millis(100),
+            move || {
+                observed.fetch_add(1, Ordering::Relaxed);
+            },
+        )
+        .await;
+
+        assert_eq!(result, Ok(7));
+        assert!(pressure_events.load(Ordering::Relaxed) >= 1);
+    }
+
+    #[tokio::test]
+    async fn resource_wait_keeps_a_final_stall_guard() {
+        let result = wait_for_resource_with_pressure(
+            std::future::pending::<()>(),
+            Duration::from_millis(5),
+            Duration::from_millis(25),
+            || {},
+        )
+        .await;
+
+        assert_eq!(result, Err(ResourceWaitError::TimedOut));
+    }
+
     async fn spawn_range_server(
         data: Arc<Vec<u8>>,
         wrong_content_range: bool,

packages/ui/src/composables/index.ts

@@ -8,6 +8,7 @@ export * from './format-number'
 export * from './how-ago'
 export * from './i18n'
 export * from './i18n-debug'
+export * from './modal-stack'
 export * from './page-leave-safety'
 export * from './scroll-indicator'
 export type { ArmorPreviewConfig } from './skin-rendering/armor-preview-types'

packages/ui/src/composables/skin-rendering/index.ts

@@ -1,4 +1,6 @@
+export * from './armor-preview-types'
 export * from './types'
+export * from './use-armor-preview'
 export * from './use-skin-preview-animation'
 export * from './use-skin-preview-controls'
 export * from './use-skin-preview-fit'