diff --git a/apps/app/Cargo.toml b/apps/app/Cargo.toml
index a5209f5c50..fd18990f8a 100644
--- a/apps/app/Cargo.toml
+++ b/apps/app/Cargo.toml
@@ -62,12 +62,12 @@ windows-core.workspace = true
 [target."cfg(windows)".dependencies.windows]
 workspace = true
 features = [
-  "Win32_Foundation",
-  "Win32_Graphics_Dwm",
-  "Win32_Graphics_Gdi",
-  "Win32_System_Com",
-  "Win32_UI_Shell",
-  "Win32_UI_WindowsAndMessaging",
+	"Win32_Foundation",
+	"Win32_Graphics_Dwm",
+	"Win32_Graphics_Gdi",
+	"Win32_System_Com",
+	"Win32_UI_Shell",
+	"Win32_UI_WindowsAndMessaging",
 ]
 
 [features]
diff --git a/apps/app/capabilities/plugins.json b/apps/app/capabilities/plugins.json
index 33dcb58f50..e58008a41a 100644
--- a/apps/app/capabilities/plugins.json
+++ b/apps/app/capabilities/plugins.json
@@ -2,9 +2,7 @@
 	"identifier": "plugins",
 	"description": "",
 	"local": true,
-	"windows": [
-		"main"
-	],
+	"windows": ["main"],
 	"permissions": [
 		"dialog:allow-open",
 		"dialog:allow-confirm",
diff --git a/apps/app/tauri.conf.json b/apps/app/tauri.conf.json
index c1b9d08003..5e9feb3c14 100644
--- a/apps/app/tauri.conf.json
+++ b/apps/app/tauri.conf.json
@@ -12,12 +12,7 @@
 		"copyright": "",
 		"targets": "all",
 		"externalBin": [],
-		"icon": [
-			"icons/128x128.png",
-			"icons/128x128@2x.png",
-			"icons/icon.icns",
-			"icons/icon.ico"
-		],
+		"icon": ["icons/128x128.png", "icons/128x128@2x.png", "icons/icon.icns", "icons/icon.ico"],
 		"windows": {
 			"nsis": {
 				"installMode": "currentUser",
@@ -55,9 +50,7 @@
 		},
 		"fileAssociations": [
 			{
-				"ext": [
-					"mrpack"
-				],
+				"ext": ["mrpack"],
 				"mimeType": "application/x-modrinth-modpack+zip"
 			}
 		]
@@ -69,9 +62,7 @@
 	"plugins": {
 		"deep-link": {
 			"desktop": {
-				"schemes": [
-					"modrinth"
-				]
+				"schemes": ["modrinth"]
 			},
 			"mobile": []
 		}
@@ -108,18 +99,11 @@
 				],
 				"enable": true
 			},
-			"capabilities": [
-				"ads",
-				"core",
-				"plugins"
-			],
+			"capabilities": ["ads", "core", "plugins"],
 			"csp": {
 				"default-src": "'self' customprotocol: asset:",
 				"connect-src": "ipc: http://ipc.localhost https://modrinth.com https://*.modrinth.com https://*.nodes.modrinth.com https://*.posthog.com https://posthog.modrinth.com https://*.sentry.io https://api.mclo.gs http://textures.minecraft.net https://textures.minecraft.net https://js.stripe.com https://*.stripe.com wss://*.stripe.com https://*.intercom.io wss://*.intercom.io https://*.intercomcdn.com https://www.intercom-reporting.com https://app.getsentry.com wss://*.nodes.modrinth.com https://*.taila228c5.ts.net https://*.taila228c5.ts.net wss://*.taila228c5.ts.net https://fill.papermc.io https://api.purpurmc.org 'self' data: blob:",
-				"font-src": [
-					"https://cdn-raw.modrinth.com/fonts/",
-					"https://js.intercomcdn.com"
-				],
+				"font-src": ["https://cdn-raw.modrinth.com/fonts/", "https://js.intercomcdn.com"],
 				"img-src": "https: 'unsafe-inline' 'self' asset: http://asset.localhost http://textures.minecraft.net blob: data:",
 				"style-src": "'unsafe-inline' 'self'",
 				"script-src": "https://*.posthog.com https://posthog.modrinth.com https://js.stripe.com https://widget.intercom.io https://js.intercomcdn.com https://tally.so/widgets/embed.js 'self'",
diff --git a/apps/daedalus_client/Cargo.toml b/apps/daedalus_client/Cargo.toml
index 1f6aa350df..5076dc7960 100644
--- a/apps/daedalus_client/Cargo.toml
+++ b/apps/daedalus_client/Cargo.toml
@@ -5,12 +5,12 @@ edition.workspace = true
 
 [dependencies]
 async_zip = { workspace = true, features = [
-  "bzip2",
-  "chrono",
-  "deflate",
-  "deflate64",
-  "tokio-fs",
-  "zstd",
+	"bzip2",
+	"chrono",
+	"deflate",
+	"deflate64",
+	"tokio-fs",
+	"zstd",
 ] }
 bytes = { workspace = true }
 chrono = { workspace = true, features = ["serde"] }
@@ -20,11 +20,7 @@ dotenvy = { workspace = true }
 futures = { workspace = true }
 indexmap = { workspace = true, features = ["serde"] }
 itertools = { workspace = true }
-reqwest = { workspace = true, features = [
-  "json",
-  "rustls-tls-native-roots",
-  "stream",
-] }
+reqwest = { workspace = true, features = ["json", "rustls-tls-native-roots", "stream"] }
 rust-s3 = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
diff --git a/apps/docs/src/styles/modrinth.css b/apps/docs/src/styles/modrinth.css
index 4f149c26a7..b61c7fbe4c 100644
--- a/apps/docs/src/styles/modrinth.css
+++ b/apps/docs/src/styles/modrinth.css
@@ -2,8 +2,9 @@
 ::backdrop,
 :root[data-theme='light'],
 [data-theme='light'] ::backdrop {
-	--sl-font-system: Inter, -apple-system, BlinkMacSystemFont, Segoe UI, Oxygen, Ubuntu, Roboto,
-		Cantarell, Fira Sans, Droid Sans, Helvetica Neue, sans-serif;
+	--sl-font-system:
+		Inter, -apple-system, BlinkMacSystemFont, Segoe UI, Oxygen, Ubuntu, Roboto, Cantarell,
+		Fira Sans, Droid Sans, Helvetica Neue, sans-serif;
 
 	--sl-color-white: var(--color-contrast); /* “white” */
 	--sl-color-gray-1: var(--color-base);
diff --git a/apps/frontend/src/components/ui/moderation/ModerationProjectNags.vue b/apps/frontend/src/components/ui/moderation/ModerationProjectNags.vue
index 33a7dbf92e..d997e2ead8 100644
--- a/apps/frontend/src/components/ui/moderation/ModerationProjectNags.vue
+++ b/apps/frontend/src/components/ui/moderation/ModerationProjectNags.vue
@@ -105,7 +105,7 @@ interface Tags {
 interface Props {
 	project: Labrinth.Projects.v2.Project
 	projectV3: Labrinth.Projects.v3.Project
-	versions?: Labrinth.Versions.v2.Version[]
+	versions?: Labrinth.Versions.v3.Version[]
 	currentMember?: Labrinth.Projects.v3.TeamMember | null
 	collapsed?: boolean
 	routeName?: string
diff --git a/apps/frontend/src/components/ui/moderation/QueueSummaryModal.vue b/apps/frontend/src/components/ui/moderation/QueueSummaryModal.vue
new file mode 100644
index 0000000000..79cf6cc9e1
--- /dev/null
+++ b/apps/frontend/src/components/ui/moderation/QueueSummaryModal.vue
@@ -0,0 +1,114 @@
+<script setup lang="ts">
+import { ScaleIcon, XIcon } from '@modrinth/assets'
+import { AutoLink, ButtonStyled, injectModrinthClient, NewModal } from '@modrinth/ui'
+import { ref, useTemplateRef } from 'vue'
+
+import { useGeneratedState } from '~/composables/generated'
+import { getProjectTypeForUrlShorthand } from '~/helpers/projects.js'
+
+const props = defineProps<{
+	completedIds: string[]
+	skippedIds: string[]
+}>()
+
+const emit = defineEmits<{
+	(e: 'review-skipped'): void
+}>()
+
+const client = injectModrinthClient()
+const tags = useGeneratedState()
+const modalRef = useTemplateRef<InstanceType<typeof NewModal>>('modalRef')
+
+interface QueueSummaryEntry {
+	id: string
+	title: string
+	link: string
+}
+
+const completedEntries = ref<QueueSummaryEntry[]>([])
+const skippedEntries = ref<QueueSummaryEntry[]>([])
+
+function toEntries(
+	ids: string[],
+	projectsById: Map<string, { id: string; slug: string; title: string; project_types: string[] }>,
+): QueueSummaryEntry[] {
+	return ids
+		.map((id) => projectsById.get(id))
+		.filter((project): project is NonNullable<typeof project> => !!project)
+		.map((project) => ({
+			id: project.id,
+			title: project.title,
+			link: `/${getProjectTypeForUrlShorthand(project.project_types[0], [], tags.value)}/${project.slug}`,
+		}))
+}
+
+async function show() {
+	const ids = [...new Set([...props.completedIds, ...props.skippedIds])]
+	const projects =
+		ids.length > 0 ? await client.labrinth.projects_v3.getMultiple(ids).catch(() => []) : []
+	const projectsById = new Map(projects.map((project) => [project.id, project]))
+
+	completedEntries.value = toEntries(props.completedIds, projectsById)
+	skippedEntries.value = toEntries(props.skippedIds, projectsById)
+
+	modalRef.value?.show()
+}
+
+function hide() {
+	modalRef.value?.hide()
+}
+
+function reviewSkipped() {
+	emit('review-skipped')
+	hide()
+}
+
+defineExpose({ show, hide })
+</script>
+
+<template>
+	<NewModal ref="modalRef" header="Queue completed">
+		<div class="flex flex-col gap-4">
+			<div v-if="completedEntries.length > 0" class="flex flex-col gap-2">
+				<span class="font-bold text-contrast">Completed ({{ completedEntries.length }})</span>
+				<ul class="m-0 flex list-none flex-col gap-1 p-0">
+					<li v-for="entry in completedEntries" :key="entry.id">
+						<AutoLink :to="entry.link" class="text-primary hover:underline">{{
+							entry.title
+						}}</AutoLink>
+					</li>
+				</ul>
+			</div>
+
+			<div v-if="skippedEntries.length > 0" class="flex flex-col gap-2">
+				<span class="font-bold text-contrast">Skipped ({{ skippedEntries.length }})</span>
+				<ul class="m-0 flex list-none flex-col gap-1 p-0">
+					<li v-for="entry in skippedEntries" :key="entry.id">
+						<AutoLink :to="entry.link" class="text-primary hover:underline">{{
+							entry.title
+						}}</AutoLink>
+					</li>
+				</ul>
+			</div>
+
+			<div v-if="completedEntries.length === 0 && skippedEntries.length === 0" class="text-secondary">
+				No projects were reviewed during this queue.
+			</div>
+
+			<div class="flex justify-end gap-2">
+				<ButtonStyled v-if="skippedEntries.length > 0" color="orange">
+					<button @click="reviewSkipped">
+						<ScaleIcon />
+						Review skipped ({{ skippedEntries.length }})
+					</button>
+				</ButtonStyled>
+				<ButtonStyled>
+					<button @click="hide">
+						<XIcon />
+						Close
+					</button>
+				</ButtonStyled>
+			</div>
+		</div>
+	</NewModal>
+</template>
diff --git a/apps/frontend/src/components/ui/moderation/checklist/ModerationChecklist.vue b/apps/frontend/src/components/ui/moderation/checklist/ModerationChecklist.vue
index 3727b6197c..c4fa330337 100644
--- a/apps/frontend/src/components/ui/moderation/checklist/ModerationChecklist.vue
+++ b/apps/frontend/src/components/ui/moderation/checklist/ModerationChecklist.vue
@@ -34,8 +34,13 @@
 						/>
 						{{ checklistTitleText }}
 						<template v-for="opt in stageOptions" #[opt.id] :key="opt.id">
-							<component :is="opt.icon" v-if="opt.icon" class="mr-2" />
-							<span>
+							<component
+								:is="opt.icon"
+								v-if="opt.icon"
+								class="mr-2"
+								:class="{ 'opacity-50': opt.visited }"
+							/>
+							<span :class="{ 'opacity-50': opt.visited }">
 								{{ opt.text }}<span v-if="opt.requiredMissing" class="font-bold text-red">*</span>
 							</span>
 							<span v-if="opt.messages" class="ml-auto pl-2 font-semibold opacity-75">{{
@@ -56,6 +61,15 @@
 						{{ checklistTitleText }}
 					</button>
 				</h1>
+				<ButtonStyled v-if="!isPseudoStage && stageNavigateTarget" circular>
+					<button
+						v-tooltip="`Navigate to ${stageNavigateLabel}`"
+						:disabled="route.path === stageNavigateTarget"
+						@click="navigateToStagePage"
+					>
+						<MapPinIcon />
+					</button>
+				</ButtonStyled>
 				<ButtonStyled v-if="!isPseudoStage && currentStageObj._guidanceUrl" circular>
 					<a v-tooltip="`Stage guidance`" target="_blank" :href="currentStageObj._guidanceUrl">
 						<FileTextIcon />
@@ -231,15 +245,12 @@
 					<div v-else class="flex min-h-0 flex-1 flex-col">
 						<NodeRenderer
 							class="min-h-0 flex-1 overflow-y-auto p-1"
-							:nodes="
-								resolveChildren(
-									currentStageObj,
-									(nodeStates[currentStageObj.id!] ?? {}) as Record<string, NodeState>,
-								)
-							"
-							:show-context="(nodeStates[currentStageObj.id!] ?? {}) as Record<string, NodeState>"
+							:nodes="stageNodes"
+							:state="stageState"
+							:write="stageWriter"
 							:on-image-upload="onUploadHandler"
-							:parent-state-path="currentStageObj._statePath ?? []"
+							:app-components="appComponentsByKey"
+							:global-state="nodeStates"
 						/>
 					</div>
 				</div>
@@ -264,8 +275,13 @@
 									<ListBulletedIcon />
 									<span class="sr-only">Stages</span>
 									<template v-for="opt in stageOptions" #[opt.id] :key="opt.id">
-										<component :is="opt.icon" v-if="opt.icon" class="mr-2" />
-										<span>
+										<component
+											:is="opt.icon"
+											v-if="opt.icon"
+											class="mr-2"
+											:class="{ 'opacity-50': opt.visited }"
+										/>
+										<span :class="{ 'opacity-50': opt.visited }">
 											{{ opt.text
 											}}<span v-if="opt.requiredMissing" class="font-bold text-red">*</span>
 										</span>
@@ -376,35 +392,37 @@ import {
 	RightArrowIcon,
 	ScaleIcon,
 	SpinnerIcon,
+	MapPinIcon,
 	ToggleLeftIcon,
 	ToggleRightIcon,
 	UndoIcon,
 	XIcon,
 } from '@modrinth/assets'
+import type { Priority } from '@modrinth/moderation'
 import {
-	type IdentifiedNodeBuilder,
+	expandVariables,
+	kebabToTitleCase,
 	moderationSettings,
-	type NodeState,
-	type Priority,
-	type StageNodeBuilder,
-	type ValueNodeBuilder,
+	useStages,
 } from '@modrinth/moderation'
+import type { ActiveAction2, NodeState, StageNode } from '@modrinth/moderation/src/types/node'
 import {
+	CHECKLIST_META_KEY,
+	collectActiveActions,
+	collectMessageNodes,
+	computeAttentionMap,
+	computeNodeMeta,
 	createTrackedPatch,
+	evalActiveAction,
 	evalSegment,
-	expandVariables,
-	getBooleanChildState,
-	GLOBAL_STATE_KEY,
-	isNodeActive,
-	kebabToTitleCase,
-	NodeBuilder,
 	resolve,
 	resolveChildren,
 	setMessageProject,
 	setMissingMdHandler,
-	useStages,
-	walkNodes,
-} from '@modrinth/moderation'
+} from '@modrinth/moderation/src/types/node'
+import NodeRenderer from '@modrinth/moderation/src/types/node/components/NodeRenderer.vue'
+import type { FixBuilder } from '@modrinth/moderation/src/types/node/fix'
+import type { Writer } from '@modrinth/moderation/src/types/node/mutate'
 import {
 	Avatar,
 	ButtonStyled,
@@ -419,24 +437,36 @@ import {
 } from '@modrinth/ui'
 import TeleportOverflowMenu from '@modrinth/ui/src/components/base/TeleportOverflowMenu.vue'
 import type { ProjectStatus } from '@modrinth/utils'
+import { renderHighlightedString } from '@modrinth/utils'
 import { useQueryClient } from '@tanstack/vue-query'
 import { useDebounceFn } from '@vueuse/core'
 import type { Component } from 'vue'
-import { computed, nextTick, provide, ref, toRaw, watch } from 'vue'
+import { computed, nextTick, provide, ref, toRaw, watch, watchEffect } from 'vue'
 
+import LoaderPicker from '~/components/ui/create-project-version/components/LoaderPicker.vue'
+import McVersionPicker from '~/components/ui/create-project-version/components/McVersionPicker.vue'
 import { useGeneratedState } from '~/composables/generated'
 import { useImageUpload } from '~/composables/image-upload.ts'
 import { getProjectTypeForUrlShorthand } from '~/helpers/projects.js'
+import {
+	getSessionChecklistState,
+	patchSessionChecklistState,
+} from '~/services/moderation/checklist-session-storage.ts'
 import {
 	clearChecklistState,
 	loadChecklistState,
 	saveChecklistState,
-} from '~/services/moderation-checklist-storage.ts'
-import type { LockAcquireResponse } from '~/services/moderation-queue.ts'
-import { useModerationQueue } from '~/services/moderation-queue.ts'
+} from '~/services/moderation/checklist-storage.ts'
+import {
+	batchCheckQueueCandidates,
+	findNextEligibleQueueProject,
+	isEligibleQueueCandidate,
+	type QueueCandidateCheck,
+} from '~/services/moderation/queue-eligibility.ts'
+import type { LockAcquireResponse } from '~/services/moderation/queue.ts'
+import { useModerationQueue } from '~/services/moderation/queue.ts'
 
-import { type ActiveAction, type LiveNode, NODE_META_KEY, STATE_KEY } from './checklist-context'
-import NodeRenderer from './NodeRenderer.vue'
+import { type LiveNode, STATE_KEY } from './checklist-context'
 
 const notifications = injectNotificationManager()
 const { addNotification } = notifications
@@ -481,11 +511,10 @@ const alreadyReviewed = ref(false)
 
 // Prefetch queue for parallel lock checking and instant navigation
 interface PrefetchedProject {
-	projectId: string
+	project: string
 	slug: string // For canonical URL navigation
 	projectType: string // For canonical URL navigation
 	validatedAt: number
-	skippedIds: string[] // IDs that were locked when this was prefetched
 }
 
 const prefetchQueue = ref<PrefetchedProject[]>([])
@@ -606,7 +635,6 @@ function handleLockUnavailable() {
 }
 
 async function navigateToNextUnlockedProject(): Promise<boolean> {
-	// Remove stale entries first
 	const now = Date.now()
 	prefetchQueue.value = prefetchQueue.value.filter((p) => now - p.validatedAt < PREFETCH_STALE_MS)
 
@@ -616,29 +644,23 @@ async function navigateToNextUnlockedProject(): Promise<boolean> {
 
 	// Quick re-check if close to expiry (last 5 seconds of TTL)
 	if (now - next.validatedAt > PREFETCH_STALE_MS - 5000) {
-		const recheckResults = await batchCheckQueueCandidates([next.projectId])
-		const recheck = recheckResults.get(next.projectId)
+		const recheckResults = await batchCheckQueueCandidates(client, moderationQueue, [
+			next.project,
+		])
+		const recheck = recheckResults.get(next.project)
 		if (!isEligibleQueueCandidate(recheck)) {
 			prefetchQueue.value.shift()
 			return navigateToNextUnlockedProject()
 		}
 	}
 
-	// Remove from queue after validation
 	prefetchQueue.value.shift()
 
-	// Mark skipped projects as completed
-	await Promise.all(
-		next.skippedIds.map((id) => moderationQueue.completeCurrentProject(id, 'skipped')),
-	)
-
-	notifySkippedQueueProjects(next.skippedIds.length)
-
 	maintainPrefetchQueue()
 
 	navigateToQueueProject(
 		{ slug: next.slug, projectType: next.projectType, locked: false, isProcessing: true },
-		next.projectId,
+		next.project,
 	)
 	return true
 }
@@ -657,10 +679,27 @@ const persistedState = import.meta.client
 	? await loadChecklistState(checklistPersistenceProjectId)
 	: null
 nodeStates.value = persistedState?.state ?? {}
+const activatedStages = ref<Set<string>>(new Set(persistedState?.activatedStages ?? []))
+const visitedStages = ref<Set<string>>(
+	new Set(
+		import.meta.client
+			? (getSessionChecklistState(checklistPersistenceProjectId).visitedStages ?? [])
+			: [],
+	),
+)
+
+function markStageVisited(stageId: string | undefined) {
+	if (!stageId || visitedStages.value.has(stageId)) return
+	visitedStages.value.add(stageId)
+	patchSessionChecklistState(checklistPersistenceProjectId, {
+		visitedStages: [...visitedStages.value],
+	})
+}
+
 const reviewedAnyway = ref(persistedState?.reviewAnyway ?? false)
 const message = ref<string | null>(persistedState?.message ?? null)
-const generatedActiveActions = ref<ActiveAction[] | null>(null)
-const resolvedMessageAvailability = ref<Map<IdentifiedNodeBuilder, boolean>>(new Map())
+const generatedActiveActions = ref<ActiveAction2[] | null>(null)
+const resolvedMessageAvailability = ref<Map<object, boolean>>(new Map())
 const generatedMessage = computed(() => message.value !== null)
 const loadingMessage = ref(false)
 const moderationDecision = ref<ProjectStatus | null>(null)
@@ -744,36 +783,9 @@ function reviewAnyway() {
 	alreadyReviewed.value = false
 	reviewedAnyway.value = true
 	persistState()
-	// Start prefetching the next project in the background
 	maintainPrefetchQueue()
 }
 
-// Batch check locks, processing status, and fetch project metadata in parallel
-interface QueueCandidateCheck {
-	locked: boolean
-	expired?: boolean
-	isOwnLock?: boolean
-	slug?: string
-	projectType?: string
-	status?: string
-	isProcessing: boolean
-}
-
-function isEligibleQueueCandidate(result: QueueCandidateCheck | undefined): boolean {
-	if (!result?.isProcessing) return false
-	return !result.locked || !!result.expired || !!result.isOwnLock
-}
-
-function notifySkippedQueueProjects(count: number) {
-	if (count <= 0) return
-	addNotification({
-		title: 'Skipped projects',
-		text: `Skipped ${count} project(s) already moderated or locked by others.`,
-		type: 'info',
-		autoCloseMs: 2000,
-	})
-}
-
 function navigateToQueueProject(result: QueueCandidateCheck, projectId: string) {
 	if (result.slug && result.projectType) {
 		const urlType = getProjectTypeForUrlShorthand(result.projectType, [], tags.value)
@@ -790,67 +802,6 @@ function navigateToQueueProject(result: QueueCandidateCheck, projectId: string)
 	}
 }
 
-async function batchCheckQueueCandidates(
-	projectIds: string[],
-): Promise<Map<string, QueueCandidateCheck>> {
-	const results = new Map<string, QueueCandidateCheck>()
-
-	const checks = await Promise.allSettled(
-		projectIds.map(async (id) => {
-			const [lockResponse, projectData] = await Promise.all([
-				moderationQueue.checkLock(id),
-				useBaseFetch(`project/${id}`, { method: 'GET' }).catch(() => null),
-			])
-
-			const status = (projectData as { status?: string } | null)?.status
-
-			return {
-				id,
-				locked: lockResponse.locked,
-				expired: lockResponse.expired,
-				isOwnLock: lockResponse.is_own_lock,
-				slug: (projectData as { slug?: string } | null)?.slug,
-				projectType: (projectData as { project_type?: string } | null)?.project_type,
-				status,
-				isProcessing: projectData === null ? true : status === 'processing',
-			}
-		}),
-	)
-
-	checks.forEach((result, index) => {
-		if (result.status === 'fulfilled') {
-			results.set(result.value.id, result.value)
-		} else {
-			results.set(projectIds[index], { locked: false, isProcessing: true })
-		}
-	})
-
-	return results
-}
-
-async function findNextEligibleQueueProject(candidateIds: string[]) {
-	const skippedIds: string[] = []
-	let checkedCount = 0
-
-	while (checkedCount < candidateIds.length) {
-		const batch = candidateIds.slice(checkedCount, checkedCount + PREFETCH_BATCH_SIZE)
-		checkedCount += batch.length
-
-		const results = await batchCheckQueueCandidates(batch)
-
-		for (const id of batch) {
-			const result = results.get(id)
-			if (isEligibleQueueCandidate(result)) {
-				return { projectId: id, result: result!, skippedIds: [...skippedIds] }
-			}
-			skippedIds.push(id)
-		}
-	}
-
-	return null
-}
-
-// Maintain a queue of prefetched unlocked projects for instant navigation
 async function maintainPrefetchQueue() {
 	if (isPrefetching.value) return
 	if (!moderationQueue.isQueueMode) return
@@ -860,22 +811,18 @@ async function maintainPrefetchQueue() {
 	isPrefetching.value = true
 
 	try {
-		// 1. Remove stale entries (validated > 30s ago)
 		const now = Date.now()
 		prefetchQueue.value = prefetchQueue.value.filter((p) => now - p.validatedAt < PREFETCH_STALE_MS)
 
-		// 2. Remove entries for current project
 		if (currentProjectId) {
-			prefetchQueue.value = prefetchQueue.value.filter((p) => p.projectId !== currentProjectId)
+			prefetchQueue.value = prefetchQueue.value.filter((p) => p.project !== currentProjectId)
 		}
 
-		// 3. If queue is full enough, exit early
 		if (prefetchQueue.value.length >= PREFETCH_TARGET_COUNT) {
 			return
 		}
 
-		// 4. Get remaining queue items (excluding current and already prefetched)
-		const prefetchedIds = new Set(prefetchQueue.value.map((p) => p.projectId))
+		const prefetchedIds = new Set(prefetchQueue.value.map((p) => p.project))
 		const queueItems = [...moderationQueue.currentQueue.items]
 		const currentIndex = currentProjectId ? queueItems.indexOf(currentProjectId) : -1
 		const remainingItems =
@@ -885,7 +832,6 @@ async function maintainPrefetchQueue() {
 
 		if (candidateIds.length === 0) return
 
-		const skippedIds: string[] = []
 		let checkedCount = 0
 
 		while (
@@ -895,22 +841,21 @@ async function maintainPrefetchQueue() {
 			const batch = candidateIds.slice(checkedCount, checkedCount + PREFETCH_BATCH_SIZE)
 			checkedCount += batch.length
 
-			const results = await batchCheckQueueCandidates(batch)
+			const results = await batchCheckQueueCandidates(client, moderationQueue, batch)
 
 			for (const id of batch) {
 				const result = results.get(id)
 				if (isEligibleQueueCandidate(result)) {
 					prefetchQueue.value.push({
-						projectId: id,
+						project: id,
 						slug: result?.slug ?? '',
 						projectType: result?.projectType ?? '',
 						validatedAt: Date.now(),
-						skippedIds: [...skippedIds],
 					})
 
 					if (prefetchQueue.value.length >= PREFETCH_TARGET_COUNT) break
 				} else {
-					skippedIds.push(id)
+					void moderationQueue.excludeProject(id)
 				}
 			}
 		}
@@ -919,11 +864,24 @@ async function maintainPrefetchQueue() {
 	}
 }
 
-// Debounced prefetch to prevent spam from rapid stage changes
 const debouncedPrefetch = useDebounceFn(maintainPrefetchQueue, 300)
 
+async function goToNextEligibleProject(candidateIds: string[]): Promise<boolean> {
+	if (candidateIds.length === 0) return false
+
+	const next = await findNextEligibleQueueProject(client, moderationQueue, candidateIds)
+
+	if (!next) {
+		await Promise.all(candidateIds.map((id) => moderationQueue.excludeProject(id)))
+		return false
+	}
+
+	await Promise.all(next.excluded.map((id) => moderationQueue.excludeProject(id)))
+	navigateToQueueProject(next.result, next.project)
+	return true
+}
+
 async function skipToNextProject() {
-	// Skip the current project
 	const currentProjectId = projectV2.value?.id
 	if (!currentProjectId) {
 		console.warn('[skipToNextProject] No current project ID, aborting')
@@ -932,12 +890,11 @@ async function skipToNextProject() {
 	debug('[skipToNextProject] Starting. Current project:', currentProjectId)
 	debug('[skipToNextProject] Queue before complete:', [...moderationQueue.currentQueue.items])
 
-	await moderationQueue.completeCurrentProject(currentProjectId, 'skipped')
+	await moderationQueue.deferProject(currentProjectId)
 
 	debug('[skipToNextProject] Queue after complete:', [...moderationQueue.currentQueue.items])
 	debug('[skipToNextProject] hasItems:', moderationQueue.hasItems)
 
-	// Use prefetched data if available
 	if (await navigateToNextUnlockedProject()) {
 		debug('[skipToNextProject] Used prefetch, returning')
 		return
@@ -948,20 +905,7 @@ async function skipToNextProject() {
 	const remainingIds = moderationQueue.currentQueue.items.filter((id) => id !== currentProjectId)
 
 	if (remainingIds.length > 0) {
-		const next = await findNextEligibleQueueProject(remainingIds)
-
-		if (next) {
-			await Promise.all(
-				next.skippedIds.map((id) => moderationQueue.completeCurrentProject(id, 'skipped')),
-			)
-			notifySkippedQueueProjects(next.skippedIds.length)
-			navigateToQueueProject(next.result, next.projectId)
-			return
-		}
-
-		await Promise.all(
-			remainingIds.map((id) => moderationQueue.completeCurrentProject(id, 'skipped')),
-		)
+		if (await goToNextEligibleProject(remainingIds)) return
 
 		debug('[skipToNextProject] No eligible projects in queue')
 		addNotification({
@@ -989,12 +933,14 @@ const checklistHasState = computed(() =>
 function resetProgress() {
 	if (!isPseudoStage.value && currentStageHasState.value) {
 		Reflect.deleteProperty(nodeStates.value, currentStageObj.value.id!)
+		activatedStages.value.delete(currentStageObj.value.id!)
 		clearGeneratedMessageState()
 		return
 	}
 
 	currentStage.value = findFirstValidStage()
 	nodeStates.value = {}
+	activatedStages.value = new Set()
 
 	done.value = false
 	clearGeneratedMessageState()
@@ -1027,85 +973,82 @@ const checklistTitleText = computed(() => {
 
 	return currentStageObj.value.label ?? kebabToTitleCase(currentStageObj.value.id)
 })
-const checklistLive = computed<Map<IdentifiedNodeBuilder, LiveNode>>(() => {
-	const map = new Map<IdentifiedNodeBuilder, LiveNode>()
+function isStageLive(stage: StageNode): boolean {
+	return stage._shown === undefined || resolve(stage._shown)
+}
 
-	for (const stage of resolvedStages.value) {
-		const stageState = (nodeStates.value[stage.id!] ?? {}) as Record<string, NodeState>
-
-		let isVisible = false
-		let messageCount = 0
-		let fixCount = 0
-		let hasRequiredMissing = false
-		const stageActiveActions: ActiveAction[] = []
-
-		if (stage._shown === undefined || resolve(stage._shown)) {
-			if (stage._segments.length > 0) {
-				messageCount++
-				stageActiveActions.push({
-					node: stage,
-					state: stageState,
-					statePath: stage._statePath ?? [],
-				})
-			}
+function isStageEffectivelyShown(stage: StageNode): boolean {
+	if (isStageLive(stage)) return true
+	return stage._shownSticky === true && activatedStages.value.has(stage.id)
+}
 
-			walkNodes(resolveChildren(stage, stageState), stageState, (node, nodeState, localState) => {
-				isVisible = true
-				const active = isNodeActive(node, nodeState)
-				const actionState =
-					node.type === 'toggle' || node.type === 'check' || node.type === 'option'
-						? (getBooleanChildState(nodeState) as Record<string, NodeState>)
-						: localState
-				const isRequired = !!(node as ValueNodeBuilder)._required
-				const nodeActiveActions: ActiveAction[] = []
-
-				let isFixActionable = false
-				if (active) {
-					if (node._segments.length > 0) {
-						messageCount++
-						nodeActiveActions.push({ node, state: actionState, statePath: node._statePath ?? [] })
-						stageActiveActions.push({ node, state: actionState, statePath: node._statePath ?? [] })
-					}
-					isFixActionable = node._fixes.some((f) => {
-						if (f._projectFn) {
-							const { proxy, changes } = createTrackedPatch(projectV3.value as any)
-							f._projectFn(proxy as any, actionState)
-							return Object.keys(changes()).length > 0
-						}
-						if (f._versionFn) {
-							const version = versions.value?.[0]
-							if (!version) return true
-							const { proxy, changes } = createTrackedPatch(version as any)
-							f._versionFn(proxy as any, actionState)
-							return Object.keys(changes()).length > 0
-						}
-						return false
-					})
-					if (isFixActionable) fixCount++
-				}
+watchEffect(() => {
+	for (const stage of resolvedStages.value) {
+		if (stage._shownSticky && isStageLive(stage) && !activatedStages.value.has(stage.id)) {
+			activatedStages.value.add(stage.id)
+		}
+	}
+})
 
-				if (isRequired && !active) hasRequiredMissing = true
-				map.set(node, {
-					isActive: active,
-					isVisible: node._shown === undefined || resolve(node._shown),
-					isFixActionable,
-					messageCount: active && node._segments.some((s) => s.type !== 'collect') ? 1 : 0,
-					fixCount: isFixActionable ? 1 : 0,
-					hasRequiredMissing: isRequired && !active,
-					activeActions: nodeActiveActions,
-				})
-			})
+function isFixActionable(fixes: FixBuilder[], state: Record<string, NodeState>): boolean {
+	return fixes.some((f) => {
+		if (f._projectFn) {
+			const { proxy, changes } = createTrackedPatch(projectV3.value as any)
+			f._projectFn(proxy as any, state)
+			return Object.keys(changes()).length > 0
+		}
+		if (f._versionFn) {
+			const version = versions.value?.[0]
+			if (!version) return true
+			const { proxy, changes } = createTrackedPatch(version as any)
+			f._versionFn(proxy as any, state)
+			return Object.keys(changes()).length > 0
 		}
+		return false
+	})
+}
 
-		map.set(stage, {
+function computeStageLiveNode(stage: StageNode, stageState: Record<string, NodeState>): LiveNode {
+	if (!isStageEffectivelyShown(stage)) {
+		return {
 			isActive: true,
-			isVisible,
+			isVisible: false,
 			isFixActionable: false,
-			messageCount,
-			fixCount,
-			hasRequiredMissing,
-			activeActions: stageActiveActions,
-		})
+			messageCount: 0,
+			fixCount: 0,
+			hasRequiredMissing: false,
+			activeActions: [],
+		}
+	}
+
+	const stageChildren = resolveChildren(stage, stageState)
+	const metaMap = computeNodeMeta(stageChildren, stageState, isFixActionable)
+	const attentionMap = computeAttentionMap(stageChildren, stageState, metaMap)
+	const actions = collectActiveActions(stageChildren, stageState, [stage.id])
+
+	if (stage._segments.length > 0) {
+		actions.unshift({ node: stage, state: stageState, statePath: [stage.id], active: true })
+	}
+
+	return {
+		isActive: true,
+		isVisible: metaMap.size > 0,
+		isFixActionable: false,
+		messageCount: actions.length,
+		fixCount: [...metaMap.values()].filter((m) => m.isFixActionable).length,
+		hasRequiredMissing: stageChildren.some(
+			(child) => typeof child === 'object' && child !== null && attentionMap.get(child) === true,
+		),
+		activeActions: actions,
+	}
+}
+
+const checklistLive = computed<Map<object, LiveNode>>(() => {
+	const map = new Map<object, LiveNode>()
+
+	for (const stage of resolvedStages.value) {
+		const stageState = (nodeStates.value[stage.id] ?? {}) as Record<string, NodeState>
+		map.set(stage, computeStageLiveNode(stage, stageState))
 	}
 
 	return map
@@ -1116,6 +1059,7 @@ const restoredStage = persistedState
 	: -1
 const currentStage = ref(restoredStage >= 0 ? restoredStage : findFirstValidStage())
 const initialAutoStage = currentStage.value
+const needsInitialStageSettle = !persistedState && thread.value === undefined
 
 // Thread data may not be loaded when currentStage is first set, so stages that depend on it
 // (like re-review) may be invisible initially. Re-evaluate once thread loads.
@@ -1128,6 +1072,8 @@ if (!persistedState) {
 				const firstValid = findFirstValidStage()
 				if (firstValid !== currentStage.value) {
 					currentStage.value = firstValid
+				} else if (needsInitialStageSettle) {
+					markStageVisited(currentStageObj.value.id)
 				}
 			}
 		},
@@ -1136,6 +1082,30 @@ if (!persistedState) {
 }
 
 const router = useRouter()
+const route = useRoute()
+
+const projectUrlType = computed(() =>
+	getProjectTypeForUrlShorthand(projectV2.value.project_type, projectV2.value.loaders ?? [], tags.value),
+)
+
+const stageNavigateTarget = computed(() => {
+	const navigate = currentStageObj.value?._navigate
+	if (navigate === undefined || !projectV2.value) return null
+	const base = `/${projectUrlType.value}/${projectV2.value.slug}`
+	return navigate === '' ? base : `${base}${navigate}`
+})
+
+const stageNavigateLabel = computed(() => {
+	const navigate = currentStageObj.value?._navigate
+	if (navigate === '') return 'Project Page'
+	const segment = navigate?.split('/').filter(Boolean).pop()
+	if (!segment) return ''
+	return segment.charAt(0).toUpperCase() + segment.slice(1)
+})
+
+function navigateToStagePage() {
+	if (stageNavigateTarget.value) router.push(stageNavigateTarget.value)
+}
 
 let persistenceEnabled = true
 let persistenceTimer: ReturnType<typeof setTimeout> | null = null
@@ -1154,7 +1124,15 @@ function savePersistedState(open: boolean, resetReviewAnyway = false) {
 		currentStage.value !== findFirstValidStage() ? currentStageObj.value.id : undefined
 	const messageVal = message.value ?? undefined
 	const stateVal = Object.keys(rawState).length > 0 ? rawState : undefined
-	if (!openVal && !reviewAnywayVal && !stageVal && !messageVal && !stateVal) {
+	const activatedStagesVal = activatedStages.value.size > 0 ? [...activatedStages.value] : undefined
+	if (
+		!openVal &&
+		!reviewAnywayVal &&
+		!stageVal &&
+		!messageVal &&
+		!stateVal &&
+		!activatedStagesVal
+	) {
 		return clearChecklistState(checklistPersistenceProjectId)
 	}
 	return saveChecklistState(checklistPersistenceProjectId, {
@@ -1163,6 +1141,7 @@ function savePersistedState(open: boolean, resetReviewAnyway = false) {
 		...(stageVal && { stage: stageVal }),
 		...(messageVal && { message: messageVal }),
 		...(stateVal && { state: stateVal }),
+		...(activatedStagesVal && { activatedStages: activatedStagesVal }),
 	})
 }
 
@@ -1183,20 +1162,24 @@ async function persistStateImmediately(open: boolean, resetReviewAnyway = false)
 
 watch(currentStage, persistState)
 watch(nodeStates, persistState, { deep: true })
+watch(activatedStages, persistState, { deep: true })
 watch(message, persistState)
+watch(currentStageObj, (stage) => markStageVisited(stage.id), {
+	immediate: !needsInitialStageSettle,
+})
 
 watch(
 	nodeStates,
 	async () => {
-		const active = collectActiveActions()
-		const newMap = new Map<IdentifiedNodeBuilder, boolean>()
+		const active = collectAllActiveActions()
+		const newMap = new Map<object, boolean>()
 		await Promise.all(
 			active
-				.filter((a) => a.node._segments.some((s) => s.type !== 'collect'))
+				.filter((a) => (a.node as any)._segments.some((s: any) => s.type !== 'collect'))
 				.map(async ({ node, state, statePath }) => {
 					try {
 						let hasContent = false
-						for (const seg of node._segments) {
+						for (const seg of (node as any)._segments) {
 							if (seg.type === 'collect') continue
 							const text = await evalSegment(seg, state, statePath)
 							if (text?.trim()) {
@@ -1215,11 +1198,6 @@ watch(
 	{ deep: true, immediate: true },
 )
 
-interface MessagePart {
-	priority?: Priority
-	content: string
-}
-
 function handleKeybinds(event: KeyboardEvent) {
 	keybinds.value.handle(event, {
 		project: projectV2.value,
@@ -1234,12 +1212,13 @@ function handleKeybinds(event: KeyboardEvent) {
 			isDone: done.value,
 			hasGeneratedMessage: generatedMessage.value,
 			isLoadingMessage: loadingMessage.value,
+			isModpackPermissionsStage: false,
 
 			futureProjectCount: moderationQueue.queueLength,
 			visibleActionsCount: resolveChildren(
 				currentStageObj.value,
-				nodeStates.value[currentStageObj.value.id!] ?? {},
-			).filter((c) => c instanceof NodeBuilder).length,
+				nodeStates.value[currentStageObj.value.id] ?? {},
+			).filter((c) => typeof c === 'object' && c !== null).length,
 		},
 		actions: {
 			tryGoNext: nextStage,
@@ -1259,11 +1238,10 @@ function handleKeybinds(event: KeyboardEvent) {
 	})
 }
 
-// Trigger debounced prefetch when user progresses through stages
 watch(currentStage, () => {
 	// Only prefetch if we're past the first stage (user is actively moderating)
 	if (currentStage.value > 0) {
-		debouncedPrefetch() // Use debounced version to prevent spam
+		debouncedPrefetch()
 	}
 })
 
@@ -1276,23 +1254,7 @@ onMounted(async () => {
 		notifications.setNotificationLocation('left')
 	}
 
-	const finishedId = localStorage.getItem('moderation-checklist-finished')
-	if (finishedId === projectV2.value.id) {
-		localStorage.removeItem('moderation-checklist-finished')
-		hasNextProject.value = moderationQueue.queueLength > 0
-		done.value = true
-		return
-	}
-
-	if (projectV2.value.status !== 'processing' && !reviewedAnyway.value) {
-		alreadyReviewed.value = true
-		return
-	}
-
-	const initialStage = resolvedStages.value[currentStage.value]
-	if (initialStage?._navigate) {
-		router.push(`/${projectV2.value.project_type}/${projectV2.value.slug}${initialStage._navigate}`)
-	}
+	if (done.value || alreadyReviewed.value) return
 
 	const result = await moderationQueue.acquireLock(projectV2.value.id)
 
@@ -1309,7 +1271,6 @@ onMounted(async () => {
 		}
 		lockError.value = false
 
-		// Start countdown timer
 		updateLockCountdown()
 		lockCountdownInterval.value = setInterval(updateLockCountdown, 1000)
 	} else {
@@ -1355,7 +1316,6 @@ onUnmounted(() => {
 		void moderationQueue.releaseLock(projectId)
 	}
 
-	// Clear prefetch state to prevent memory leaks
 	prefetchQueue.value = []
 	isPrefetching.value = false
 })
@@ -1365,109 +1325,131 @@ watch(
 	(newIndex, oldIndex) => {
 		const stage = resolvedStages.value[newIndex]
 		// only navigate when the stage actually changes (not on initial mount/remount)
-		if (oldIndex !== undefined && newIndex !== oldIndex && stage?._navigate) {
-			router.push(`/${projectV2.value.project_type}/${projectV2.value.slug}${stage._navigate}`)
+		if (oldIndex !== undefined && newIndex !== oldIndex && stage?._navigate !== undefined) {
+			router.push(`/${projectUrlType.value}/${projectV2.value.slug}${stage._navigate}`)
 		}
 	},
 	{ immediate: true },
 )
 
-watch(
-	() => currentStageObj.value.id,
-	(stageId) => {
-		if (stageId === 'versions') {
-			loadVersions()
-		}
-	},
-	{ immediate: true },
-)
+loadVersions()
 
-function countStageActions(stage: StageNodeBuilder): number {
+function countStageActions(stage: StageNode): number {
 	const actions = checklistLive.value.get(stage)?.activeActions ?? []
 	const resolved = resolvedMessageAvailability.value
 	return actions.filter((a) => {
-		if (a.node._segments.every((s) => s.type === 'collect')) return false
+		if ((a.node as any)._segments.every((s: any) => s.type === 'collect')) return false
 		return resolved.get(a.node) ?? true
 	}).length
 }
 
-function countStageFixes(stage: StageNodeBuilder): number {
+function countStageFixes(stage: StageNode): number {
 	return checklistLive.value.get(stage)?.fixCount ?? 0
 }
 
-function hasRequiredMissing(stage: StageNodeBuilder): boolean {
+function hasRequiredMissing(stage: StageNode): boolean {
 	return checklistLive.value.get(stage)?.hasRequiredMissing ?? false
 }
 
-function collectActiveActions(): ActiveAction[] {
+function collectAllActiveActions(): ActiveAction2[] {
 	return resolvedStages.value.flatMap((s) => checklistLive.value.get(s)?.activeActions ?? [])
 }
 
-function isDescendant(childPath: string[], ancestorPath: string[]): boolean {
-	return (
-		childPath.length > ancestorPath.length && ancestorPath.every((key, i) => childPath[i] === key)
-	)
+function byPriority(a: ActiveAction2, b: ActiveAction2): number {
+	return ((a.node as any)._priority as Priority).compareTo((b.node as any)._priority as Priority)
 }
 
 async function assembleFullMessage() {
-	const allEntries = collectActiveActions()
+	const allEntries = collectAllActiveActions()
 	generatedActiveActions.value = allEntries
 
-	const consumed = new Set<IdentifiedNodeBuilder>()
-
-	async function evalEntry(entry: ActiveAction): Promise<string> {
-		let result = ''
-		for (const seg of entry.node._segments) {
-			if (seg.type === 'collect') {
-				let collected = ''
-				for (const childEntry of allEntries) {
-					if (consumed.has(childEntry.node)) continue
-					if (!isDescendant(childEntry.statePath, entry.statePath)) continue
-					consumed.add(childEntry.node)
-					collected += await evalEntry(childEntry)
-				}
-				if (!collected.trim() && seg.fallback) {
-					collected = await evalSegment(seg.fallback, entry.state, entry.statePath)
-				}
-				result += collected
-			} else {
-				result += await evalSegment(seg, entry.state, entry.statePath)
-			}
-		}
-		return result
-	}
+	const consumed = new Set<object>()
 
-	const parts: MessagePart[] = []
+	const parts: { entry: ActiveAction2; content: string }[] = []
 	for (const entry of allEntries) {
 		if (consumed.has(entry.node)) continue
-		const content = await evalEntry(entry)
+		const content = await evalActiveAction(entry, allEntries, consumed)
 		if (content.trim()) {
-			parts.push({ priority: entry.node._priority, content })
+			parts.push({ entry, content })
 		}
 	}
 
-	parts.sort((a, b) => {
-		if (!a.priority && !b.priority) return 0
-		if (!a.priority) return 1
-		if (!b.priority) return -1
-		return a.priority.compareTo(b.priority)
-	})
+	parts.sort((a, b) => byPriority(a.entry, b.entry))
 
 	return expandVariables(
 		parts
-			.map((p) => p.content)
-			.filter((c) => c.trim().length > 0)
+			.map((p) => p.content.trim())
+			.filter((c) => c.length > 0)
 			.join('\n\n'),
 		projectV2.value,
 		projectV3.value,
 	)
 }
 
-provide(NODE_META_KEY, checklistLive)
+const tooltipHtmlMap = ref(new Map<object, string>())
+
+watchEffect(async () => {
+	const stage = currentStageObj.value
+	const stageState = (nodeStates.value[stage.id] ?? {}) as Record<string, NodeState>
+	const stageChildren = resolveChildren(stage, stageState)
+	const actions = collectMessageNodes(stageChildren, stageState, [stage.id])
+
+	const newMap = new Map<object, string>()
+	await Promise.all(
+		actions.map(async (entry) => {
+			try {
+				const raw = await evalActiveAction(entry, actions, new Set())
+				const expanded = expandVariables(raw, projectV2.value, projectV3.value).trim()
+				newMap.set(
+					entry.node,
+					expanded
+						? `<div class="markdown-body moderation-tooltip-markdown">${renderHighlightedString(expanded)}</div>`
+						: '',
+				)
+			} catch {
+				newMap.set(entry.node, '')
+			}
+		}),
+	)
+	tooltipHtmlMap.value = newMap
+})
+
+const stageMeta = computed(() => {
+	const stage = currentStageObj.value
+	const stageState = (nodeStates.value[stage.id] ?? {}) as Record<string, NodeState>
+	const stageChildren = resolveChildren(stage, stageState)
+	const metaMap = computeNodeMeta(stageChildren, stageState, isFixActionable)
+	const attentionMap = computeAttentionMap(stageChildren, stageState, metaMap)
+	return { metaMap, attentionMap, tooltipHtml: tooltipHtmlMap.value }
+})
+
+const appComponentsByKey: Record<string, Component> = {
+	'loader-picker': LoaderPicker,
+	'game-version-picker': McVersionPicker,
+}
+
+const stageState = computed(
+	() => (nodeStates.value[currentStageObj.value.id] ?? {}) as Record<string, NodeState>,
+)
+const stageNodes = computed(() => resolveChildren(currentStageObj.value, stageState.value))
+
+const stageWriter: Writer = (id, value) => {
+	const stageId = currentStageObj.value.id
+	const existing = nodeStates.value[stageId]
+	const next: Record<string, NodeState> = existing ? { ...existing } : {}
+	if (value === undefined) delete next[id]
+	else next[id] = value
+	if (Object.keys(next).length === 0) {
+		if (existing !== undefined) delete nodeStates.value[stageId]
+	} else {
+		nodeStates.value[stageId] = next
+	}
+}
+
+provide(CHECKLIST_META_KEY, stageMeta)
 provide(STATE_KEY, nodeStates)
-provide(GLOBAL_STATE_KEY, nodeStates)
 
-function shouldShowStage(stage: StageNodeBuilder): boolean {
+function shouldShowStage(stage: StageNode): boolean {
 	return checklistLive.value.get(stage)?.isVisible ?? false
 }
 
@@ -1492,6 +1474,16 @@ function previousStage() {
 }
 
 function nextStage() {
+	if (done.value) {
+		endChecklist(undefined)
+		return
+	}
+
+	if (alreadyReviewed.value || isLockedByOther.value) {
+		if (moderationQueue.isQueueMode && moderationQueue.queueLength > 1) skipToNextProject()
+		return
+	}
+
 	if (generatedMessage.value) return
 
 	let targetStage = currentStage.value + 1
@@ -1523,8 +1515,9 @@ async function generateMessage() {
 	if (loadingMessage.value) return
 
 	loadingMessage.value = true
+	markStageVisited(currentStageObj.value.id)
 
-	router.push(`/${projectV2.value.project_type}/${projectV2.value.slug}/moderation`)
+	router.push(`/${projectUrlType.value}/${projectV2.value.slug}/moderation`)
 
 	try {
 		missingMdPaths.clear()
@@ -1550,6 +1543,21 @@ async function generateMessage() {
 }
 
 const hasNextProject = ref(false)
+
+const finishedId = localStorage.getItem('moderation-checklist-finished')
+if (finishedId === projectV2.value.id) {
+	localStorage.removeItem('moderation-checklist-finished')
+	hasNextProject.value = moderationQueue.queueLength > 0
+	done.value = true
+} else if (projectV2.value.status !== 'processing' && !reviewedAnyway.value) {
+	alreadyReviewed.value = true
+} else {
+	const initialStage = resolvedStages.value[currentStage.value]
+	if (initialStage?._navigate !== undefined) {
+		navigateTo(`/${projectUrlType.value}/${projectV2.value.slug}${initialStage._navigate}`)
+	}
+}
+
 async function refreshModerationCaches(threadId?: string) {
 	const refreshes: Promise<unknown>[] = [
 		invalidate(),
@@ -1564,7 +1572,6 @@ async function refreshModerationCaches(threadId?: string) {
 }
 
 async function sendMessage(status: ProjectStatus) {
-	// Capture project data upfront to avoid null issues during async operations
 	const projectId = projectV2.value?.id
 	const threadId = projectV2.value?.thread_id
 
@@ -1577,8 +1584,8 @@ async function sendMessage(status: ProjectStatus) {
 		return
 	}
 
-	const active = generatedActiveActions.value ?? collectActiveActions()
-	const shouldApplyFixes = active.some((a) => a.node._applyFixes)
+	const active = [...(generatedActiveActions.value ?? collectAllActiveActions())].sort(byPriority)
+	const shouldApplyFixes = active.some((a) => (a.node as any)._applyFixes)
 
 	moderationDecision.value = status
 	try {
@@ -1606,7 +1613,8 @@ async function sendMessage(status: ProjectStatus) {
 				projectV3.value as any,
 			)
 			for (const { node, state } of active) {
-				for (const f of node._fixes) {
+				if (!('_fixes' in (node as object))) continue
+				for (const f of (node as any)._fixes) {
 					f._projectFn?.(projectProxy, state)
 				}
 			}
@@ -1617,7 +1625,11 @@ async function sendMessage(status: ProjectStatus) {
 
 			if (versions.value) {
 				const versionFixes = active.flatMap(({ node, state }) =>
-					node._fixes.filter((f) => f._versionFn).map((f) => ({ fix: f, state })),
+					'_fixes' in (node as object)
+						? (node as any)._fixes
+								.filter((f: FixBuilder) => f._versionFn)
+								.map((f: FixBuilder) => ({ fix: f, state }))
+						: [],
 				)
 				if (versionFixes.length > 0) {
 					await Promise.all(
@@ -1638,7 +1650,7 @@ async function sendMessage(status: ProjectStatus) {
 
 		await refreshModerationCaches(threadId)
 
-		const willHaveNext = await moderationQueue.completeCurrentProject(projectId, 'completed')
+		const willHaveNext = await moderationQueue.completeProject(projectId)
 
 		await Promise.race([
 			moderationQueue.releaseLock(projectId),
@@ -1674,22 +1686,23 @@ async function endChecklist(status?: string) {
 	await clearProjectLocalStorage()
 
 	if (!hasNextProject.value) {
+		const currentProjectId = projectV2.value?.id
+		const isRealQueue =
+			!!currentProjectId &&
+			(moderationQueue.currentQueue.completed.includes(currentProjectId) ||
+				moderationQueue.currentQueue.skipped.includes(currentProjectId))
+
 		await navigateTo({
 			name: 'moderation',
 			state: {
 				confetti: true,
+				queueSummary: isRealQueue,
 			},
 		})
 
 		await nextTick()
 
-		if (moderationQueue.currentQueue.total > 1) {
-			addNotification({
-				title: 'Moderation completed',
-				text: `You have completed the moderation queue.`,
-				type: 'success',
-			})
-		} else {
+		if (!isRealQueue) {
 			addNotification({
 				title: 'Moderation submitted',
 				text: `Project ${status ?? 'completed successfully'}.`,
@@ -1703,30 +1716,15 @@ async function endChecklist(status?: string) {
 				(id) => id !== currentProjectId,
 			)
 
-			let foundEligible = false
-			if (remainingIds.length > 0) {
-				const next = await findNextEligibleQueueProject(remainingIds)
-
-				if (next) {
-					await Promise.all(
-						next.skippedIds.map((id) => moderationQueue.completeCurrentProject(id, 'skipped')),
-					)
-					notifySkippedQueueProjects(next.skippedIds.length)
-					navigateToQueueProject(next.result, next.projectId)
-					foundEligible = true
-				} else {
-					await Promise.all(
-						remainingIds.map((id) => moderationQueue.completeCurrentProject(id, 'skipped')),
-					)
+			if (!(await goToNextEligibleProject(remainingIds))) {
+				if (remainingIds.length > 0) {
 					addNotification({
 						title: 'No projects available',
 						text: 'All remaining projects are already moderated or locked by others.',
 						type: 'warning',
 					})
 				}
-			}
 
-			if (!foundEligible) {
 				await navigateTo({
 					name: 'moderation',
 				})
@@ -1751,7 +1749,7 @@ async function skipCurrentProject() {
 		new Promise((r) => setTimeout(r, 2000)),
 	])
 
-	hasNextProject.value = await moderationQueue.completeCurrentProject(projectId, 'skipped')
+	hasNextProject.value = await moderationQueue.deferProject(projectId)
 
 	await endChecklist('skipped')
 }
@@ -1761,6 +1759,7 @@ async function clearProjectLocalStorage() {
 	cancelPendingPersistence()
 
 	nodeStates.value = {}
+	activatedStages.value = new Set()
 	message.value = null
 	await clearChecklistState(checklistPersistenceProjectId)
 }
@@ -1792,6 +1791,7 @@ interface StageOption {
 	messages?: number
 	fixes?: number
 	requiredMissing?: boolean
+	visited?: boolean
 }
 
 const stageOptions = computed<StageOption[]>(() => {
@@ -1811,6 +1811,9 @@ const stageOptions = computed<StageOption[]>(() => {
 				messages: countStageActions(stage) || undefined,
 				fixes: countStageFixes(stage) || undefined,
 				requiredMissing: hasRequiredMissing(stage) || undefined,
+				visited:
+					(index !== currentStage.value && stage.id && visitedStages.value.has(stage.id)) ||
+					undefined,
 			}
 		})
 		.filter((opt): opt is StageOption => opt !== null)
diff --git a/apps/frontend/src/components/ui/moderation/checklist/NodeRenderer.vue b/apps/frontend/src/components/ui/moderation/checklist/NodeRenderer.vue
deleted file mode 100644
index 92641ce1b1..0000000000
--- a/apps/frontend/src/components/ui/moderation/checklist/NodeRenderer.vue
+++ /dev/null
@@ -1,780 +0,0 @@
-<script lang="ts" setup>
-import type {
-	BooleanNodeBuilder,
-	ButtonNodeBuilder,
-	ChildNode,
-	DropdownNodeBuilder,
-	GroupNodeBuilder,
-	IdentifiedNodeBuilder,
-	InputNodeBuilder,
-	LabeledNodeBuilder,
-	NodeState,
-	NodeStateWithChildren,
-	OverrideValue,
-	ValueNodeBuilder,
-} from '@modrinth/moderation'
-import {
-	evalSegment,
-	expandVariables,
-	flattenProjectV3Variables,
-	flattenProjectVariables,
-	flattenStaticVariables,
-	getBooleanChildState,
-	NodeBuilder,
-	resolve,
-	resolveChildren,
-	setMessageProject,
-} from '@modrinth/moderation'
-import {
-	ButtonStyled,
-	Checkbox,
-	Combobox,
-	injectProjectPageContext,
-	MarkdownEditor,
-	StyledInput,
-} from '@modrinth/ui'
-import { renderHighlightedString, renderString } from '@modrinth/utils'
-import { inject, nextTick, onMounted, reactive, watchEffect } from 'vue'
-
-import { NODE_META_KEY, STATE_KEY } from './checklist-context'
-
-const nodeMetaMap = inject(NODE_META_KEY)
-const injectedGlobalState = inject(STATE_KEY)
-
-const { projectV3: project, projectV2 } = injectProjectPageContext()
-setMessageProject(project, projectV2)
-
-const props = defineProps<{
-	nodes: ChildNode[]
-	showContext: Record<string, NodeState>
-	onImageUpload?: (file: File) => Promise<string>
-	flex?: boolean
-	titleDepth?: number
-	parentStatePath?: string[]
-}>()
-
-function titleClass(depth: number): string {
-	if (depth === 0) return 'text-lg font-extrabold text-contrast'
-	if (depth === 1) return 'text-base font-semibold'
-	if (depth === 2) return 'text-sm font-semibold'
-	return ''
-}
-
-function isVisible(node: NodeBuilder): boolean {
-	if (node._shown !== undefined) return resolve(node._shown)
-	if (node.type === 'group') {
-		const children = getChildren(node as IdentifiedNodeBuilder)
-		return children.some((c) => !(c instanceof NodeBuilder) || isVisible(c))
-	}
-	return true
-}
-
-function isEnabled(node: IdentifiedNodeBuilder): boolean {
-	const e = node._enabled
-	if (e === undefined) return true
-	if (typeof e === 'function') return e(props.showContext)
-	return resolve(e)
-}
-
-function isButtonEnabled(node: ButtonNodeBuilder): boolean {
-	const enabled = node._enabled
-	if (enabled === undefined) return true
-	if (typeof enabled === 'function') return enabled(props.showContext)
-	return resolve(enabled)
-}
-
-function asBool(node: NodeBuilder): BooleanNodeBuilder {
-	return node as BooleanNodeBuilder
-}
-
-function asButton(node: NodeBuilder): ButtonNodeBuilder {
-	return node as ButtonNodeBuilder
-}
-
-function asIdentified(node: NodeBuilder): IdentifiedNodeBuilder {
-	return node as IdentifiedNodeBuilder
-}
-
-function asLabeled(node: NodeBuilder): LabeledNodeBuilder {
-	return node as LabeledNodeBuilder
-}
-
-function asGroup(node: NodeBuilder): GroupNodeBuilder {
-	return node as GroupNodeBuilder
-}
-
-function asDropdown(node: NodeBuilder): DropdownNodeBuilder {
-	return node as DropdownNodeBuilder
-}
-
-function asInput(node: NodeBuilder): InputNodeBuilder {
-	return node as InputNodeBuilder
-}
-
-function getAtPath(path: string[]): NodeState {
-	let current: unknown = injectedGlobalState!.value
-	for (const key of path) {
-		if (current == null || typeof current !== 'object' || current instanceof Set) return undefined
-		current = (current as Record<string, unknown>)[key]
-	}
-	return current as NodeState
-}
-
-function setAtPath(path: string[], value: NodeState): void {
-	if (path.length === 0) return
-	const global = injectedGlobalState!.value as unknown as Record<string, unknown>
-	let current = global
-	const stack: [Record<string, unknown>, string][] = []
-	for (let i = 0; i < path.length - 1; i++) {
-		const key = path[i]
-		const next = current[key]
-		if (!next || typeof next !== 'object' || next instanceof Set) {
-			if (value === undefined) return
-			current[key] = next !== null && next !== undefined ? { value: next } : {}
-			current = current[key] as Record<string, unknown>
-		} else {
-			stack.push([current, key])
-			current = next as Record<string, unknown>
-		}
-	}
-	const lastKey = path[path.length - 1]
-	if (value === undefined) {
-		Reflect.deleteProperty(current, lastKey)
-		for (let i = stack.length - 1; i >= 0; i--) {
-			const [parent, key] = stack[i]
-			const child = parent[key]
-			if (
-				child &&
-				typeof child === 'object' &&
-				!(child instanceof Set) &&
-				Object.keys(child as object).length === 0
-			) {
-				Reflect.deleteProperty(parent, key)
-			} else {
-				break
-			}
-		}
-	} else {
-		current[lastKey] = value as unknown
-	}
-}
-
-function getNodeState(node: IdentifiedNodeBuilder): NodeState {
-	return node._statePath ? getAtPath(node._statePath) : undefined
-}
-
-function setNodeState(node: IdentifiedNodeBuilder, value: NodeState): void {
-	if (node._statePath) setAtPath(node._statePath, value)
-}
-
-function getBooleanState(node: BooleanNodeBuilder): boolean {
-	const state = getNodeState(node)
-	if (typeof state === 'boolean') return state
-	if (state && typeof state === 'object' && !(state instanceof Set)) {
-		const v = (state as NodeStateWithChildren).value
-		if (typeof v === 'boolean') return v
-	}
-	const def = resolveDefault(node)
-	return (def as boolean | undefined) ?? false
-}
-
-function getMultiSelectState(node: IdentifiedNodeBuilder): Set<string> {
-	const state = getNodeState(node)
-	return state instanceof Set ? state : new Set<string>()
-}
-
-function getSelectState(node: IdentifiedNodeBuilder): string | undefined {
-	const state = getNodeState(node)
-	if (typeof state === 'string') return state
-	const def = resolveDefault(node as ValueNodeBuilder)
-	return typeof def === 'string' ? def : undefined
-}
-
-function getDropdownOptions(node: DropdownNodeBuilder) {
-	return [
-		...(node._none !== undefined ? [{ value: '', label: node._none }] : []),
-		...visibleChildren(node).map((c) => ({
-			value: asIdentified(c).id!,
-			label: asLabeled(c).label,
-		})),
-	]
-}
-
-function getDropdownModelValue(node: DropdownNodeBuilder) {
-	return getSelectState(node) ?? (node._none !== undefined ? '' : undefined)
-}
-
-function toggleSelect(parent: IdentifiedNodeBuilder, child: IdentifiedNodeBuilder) {
-	const current = getSelectState(parent)
-	setNodeState(parent, current === child.id ? undefined : child.id)
-}
-
-function resolveDefault(node: ValueNodeBuilder): NodeState {
-	const d = node._defaultValue
-	return typeof d === 'function' ? d(props.showContext) : d
-}
-
-function getTextState(node: IdentifiedNodeBuilder): string {
-	const state = getNodeState(node)
-	if (typeof state === 'string') return state
-	const def = resolveDefault(node as ValueNodeBuilder)
-	return typeof def === 'string' ? def : ''
-}
-
-function getNodeTitle(node: NodeBuilder): string | undefined {
-	if (node._title === undefined) return undefined
-	return resolve(node._title) || undefined
-}
-
-function getPlaceholder(node: InputNodeBuilder): string | undefined {
-	if (node._placeholder !== undefined) return resolve(node._placeholder)
-	const def = resolveDefault(node)
-	if (typeof def === 'string') return def
-	return undefined
-}
-
-function hasActionableFixes(node: IdentifiedNodeBuilder): boolean {
-	return nodeMetaMap?.value.get(node)?.isFixActionable ?? false
-}
-
-function hasRequiredMissingDescendants(node: IdentifiedNodeBuilder): boolean {
-	for (const child of getChildren(node)) {
-		if (!(child instanceof NodeBuilder)) continue
-		const identified = child as IdentifiedNodeBuilder
-		if (nodeMetaMap?.value.get(identified)?.hasRequiredMissing) return true
-		if (identified.id !== undefined && hasRequiredMissingDescendants(identified)) return true
-	}
-	return false
-}
-
-function nodeHasRequiredMissing(node: IdentifiedNodeBuilder): boolean {
-	return !!nodeMetaMap?.value.get(node)?.hasRequiredMissing || hasRequiredMissingDescendants(node)
-}
-
-function getBooleanColor(node: BooleanNodeBuilder): string {
-	if (!getBooleanState(node)) return 'standard'
-	if (hasRequiredMissingDescendants(node)) return 'orange'
-	return hasActionableFixes(node) ? 'blue' : 'brand'
-}
-
-function setTextState(node: IdentifiedNodeBuilder, v: string): void {
-	const inputNode = node as InputNodeBuilder
-	const result = inputNode._onChange?.(v, overrideHelpers)
-
-	if (isOverrideValue(result)) {
-		const ov = result.__override
-		const def = resolveDefault(node as ValueNodeBuilder)
-		const defStr = typeof def === 'string' ? def : ''
-		setNodeState(node, ov === defStr ? undefined : ov || undefined)
-		nextTick(() => textInputRefs.get(node)?.setValue(ov))
-		return
-	}
-
-	const def = resolveDefault(node as ValueNodeBuilder)
-	const defStr = typeof def === 'string' ? def : ''
-	setNodeState(node, v === defStr ? undefined : defStr ? v : v || undefined)
-}
-
-function handleButtonClick(node: ButtonNodeBuilder): void {
-	const before = new Map<NodeBuilder, string>()
-	for (const inputNode of textInputRefs.keys()) {
-		before.set(inputNode, getTextState(asIdentified(inputNode)))
-	}
-	node._onClick?.(props.showContext)
-	for (const [inputNode, beforeVal] of before) {
-		const after = getTextState(asIdentified(inputNode))
-		if (after !== beforeVal) setTextState(asIdentified(inputNode), after)
-	}
-}
-
-onMounted(() => {
-	for (const inputNode of textInputRefs.keys()) {
-		setTextState(asIdentified(inputNode), getTextState(asIdentified(inputNode)))
-	}
-})
-
-function toggleBoolean(node: BooleanNodeBuilder) {
-	const raw = getNodeState(node)
-	const next = !getBooleanState(node)
-	const defaultVal = (resolveDefault(node) as boolean | undefined) ?? false
-	const isDefault = next === defaultVal
-	if (raw && typeof raw === 'object' && !(raw instanceof Set)) {
-		const { value: _v, ...children } = raw as NodeStateWithChildren & Record<string, NodeState>
-		const hasChildren = Object.keys(children).length > 0
-		setNodeState(
-			node,
-			isDefault && !hasChildren
-				? undefined
-				: ({ ...children, ...(isDefault ? {} : { value: next }) } as NodeState),
-		)
-	} else {
-		setNodeState(node, isDefault ? undefined : next)
-	}
-}
-
-function toggleChip(parent: IdentifiedNodeBuilder, child: IdentifiedNodeBuilder) {
-	const selected = new Set(getMultiSelectState(parent))
-	if (selected.has(child.id!)) {
-		selected.delete(child.id!)
-		if (child._statePath) {
-			setAtPath(child._statePath, undefined)
-		}
-	} else {
-		selected.add(child.id!)
-	}
-	setNodeState(parent, selected.size > 0 ? selected : undefined)
-}
-
-const textInputRefs = new Map<NodeBuilder, { setValue: (v: string) => void }>()
-const overrideHelpers = { override: (v: string): OverrideValue => ({ __override: v }) }
-
-function isOverrideValue(v: unknown): v is OverrideValue {
-	return v !== null && typeof v === 'object' && '__override' in v
-}
-
-const scopedContextFallbacks = new WeakMap<IdentifiedNodeBuilder, Record<string, NodeState>>()
-
-function childScopedContext(child: IdentifiedNodeBuilder): Record<string, NodeState> {
-	if (!child._statePath) return props.showContext
-	const basePath = child._statePath
-	const state = getAtPath(basePath)
-	if (state && typeof state === 'object' && !(state instanceof Set)) {
-		return state as Record<string, NodeState>
-	}
-	const existing = scopedContextFallbacks.get(child)
-	if (existing) return existing
-	const fallback = new Proxy({} as Record<string, NodeState>, {
-		set(_target, key, value) {
-			setAtPath([...basePath, key as string], value as NodeState)
-			return true
-		},
-	})
-	scopedContextFallbacks.set(child, fallback)
-	return fallback
-}
-
-function getChildrenContext(node: IdentifiedNodeBuilder): Record<string, NodeState> {
-	if (node.type === 'dropdown') return props.showContext
-	if (node.type === 'group' && asGroup(node)._selectMode) return props.showContext
-	return childScopedContext(node)
-}
-
-function getChildren(node: IdentifiedNodeBuilder): ChildNode[] {
-	return resolveChildren(node, getChildrenContext(node))
-}
-
-function visibleChildren(node: IdentifiedNodeBuilder): NodeBuilder[] {
-	return getChildren(node).filter((c): c is NodeBuilder => c instanceof NodeBuilder && isVisible(c))
-}
-
-const tooltipHtml = reactive(new Map<NodeBuilder, string>())
-
-function getTooltipConfig(node: NodeBuilder, state?: Record<string, NodeState>) {
-	const t = node._tooltip
-	const manual = t === undefined ? undefined : typeof t === 'function' ? t(state ?? {}) : resolve(t)
-	if (manual)
-		return {
-			content: manual,
-			delay: { show: 500, hide: 0 },
-			triggers: ['hover', 'focus'],
-			placement: 'top',
-		}
-	const html = tooltipHtml.get(node)
-	if (!html) return undefined
-	return {
-		content: html,
-		html: true,
-		delay: { show: 500, hide: 0 },
-		triggers: ['hover', 'focus'],
-		placement: 'top',
-	}
-}
-
-watchEffect(async () => {
-	// Read all reactive state synchronously before any await so Vue tracks dependencies
-	const buttonTasks: Array<{ node: BooleanNodeBuilder; state: Record<string, NodeState> }> = []
-
-	for (const node of props.nodes) {
-		if (!(node instanceof NodeBuilder)) continue
-		if (node.type === 'toggle' && isVisible(node)) {
-			const boolNode = asBool(node)
-			if (boolNode._segments.some((s) => s.type !== 'collect')) {
-				const nodeState = getNodeState(boolNode)
-				const childState =
-					nodeState && typeof nodeState === 'object' && !(nodeState instanceof Set)
-						? (() => {
-								const { value: _v, ...rest } = nodeState as NodeStateWithChildren &
-									Record<string, NodeState>
-								return rest
-							})()
-						: {}
-				buttonTasks.push({ node: boolNode, state: childState })
-			}
-		}
-		if (node.type === 'group' && asGroup(node)._selectMode === 'multi' && isVisible(node)) {
-			for (const child of visibleChildren(asIdentified(node))) {
-				const opt = child as IdentifiedNodeBuilder
-				if (opt._segments.some((s) => s.type !== 'collect')) {
-					const childState = getBooleanChildState(getNodeState(opt)) as Record<string, NodeState>
-					buttonTasks.push({ node: opt as BooleanNodeBuilder, state: childState })
-				}
-			}
-		}
-	}
-
-	async function evalCollectedChildren(node: IdentifiedNodeBuilder): Promise<string> {
-		let result = ''
-		for (const child of getChildren(node)) {
-			if (!(child instanceof NodeBuilder)) continue
-			if (!isVisible(child)) continue
-			const childNode = asIdentified(child)
-			if (child.type === 'group') {
-				const grp = asGroup(childNode)
-				if (grp._selectMode === 'multi') {
-					const selected = getMultiSelectState(childNode)
-					for (const opt of getChildren(childNode)) {
-						if (!(opt instanceof NodeBuilder) || !isVisible(opt)) continue
-						const optNode = asIdentified(opt)
-						if (!optNode.id || !selected.has(optNode.id)) continue
-						result += await evalNodeTooltip(
-							optNode,
-							getBooleanChildState(getNodeState(optNode)) as Record<string, NodeState>,
-						)
-					}
-				} else if (grp._selectMode === 'single') {
-					const selected = getSelectState(childNode)
-					for (const opt of getChildren(childNode)) {
-						if (!(opt instanceof NodeBuilder) || !isVisible(opt)) continue
-						const optNode = asIdentified(opt)
-						if (optNode.id !== selected) continue
-						result += await evalNodeTooltip(
-							optNode,
-							getBooleanChildState(getNodeState(optNode)) as Record<string, NodeState>,
-						)
-					}
-				} else {
-					result += await evalCollectedChildren(childNode)
-				}
-			} else if (child.type === 'dropdown') {
-				const selected = getSelectState(childNode)
-				for (const opt of getChildren(childNode)) {
-					if (!(opt instanceof NodeBuilder) || !isVisible(opt)) continue
-					const optNode = asIdentified(opt)
-					if (optNode.id !== selected) continue
-					result += await evalNodeTooltip(
-						optNode,
-						getBooleanChildState(getNodeState(optNode)) as Record<string, NodeState>,
-					)
-				}
-			} else if (child.type === 'toggle' || child.type === 'check') {
-				if (!getBooleanState(asBool(childNode))) continue
-				result += await evalNodeTooltip(
-					childNode,
-					getBooleanChildState(getNodeState(childNode)) as Record<string, NodeState>,
-				)
-			}
-		}
-		return result
-	}
-
-	async function evalNodeTooltip(
-		node: IdentifiedNodeBuilder,
-		state: Record<string, NodeState>,
-	): Promise<string> {
-		let result = ''
-		for (const seg of node._segments) {
-			if (seg.type === 'collect') {
-				let collected = await evalCollectedChildren(node)
-				if (!collected.trim() && seg.fallback) {
-					collected = await evalSegment(seg.fallback, state, node._statePath ?? [])
-				}
-				result += collected
-			} else {
-				result += await evalSegment(seg, state, node._statePath ?? [])
-			}
-		}
-		return result
-	}
-
-	for (const { node, state } of buttonTasks) {
-		try {
-			const raw = await evalNodeTooltip(node as unknown as IdentifiedNodeBuilder, state)
-			const expanded = expandVariables(raw, projectV2.value, project.value, {
-				...flattenStaticVariables(),
-				...flattenProjectVariables(projectV2.value),
-				...flattenProjectV3Variables(project.value),
-			})
-			const trimmed = expanded.trim()
-			tooltipHtml.set(
-				node,
-				trimmed
-					? `<div class="markdown-body moderation-tooltip-markdown">${renderHighlightedString(trimmed)}</div>`
-					: '',
-			)
-		} catch {
-			tooltipHtml.set(node, '')
-		}
-	}
-})
-</script>
-
-<template>
-	<div :class="flex ? 'flex flex-wrap gap-2' : 'space-y-4'">
-		<template
-			v-for="(item, idx) in nodes"
-			:key="
-				item instanceof NodeBuilder
-					? item.type === 'button'
-						? `button-${asButton(item).label}`
-						: (asIdentified(item)._statePath?.join('/') ?? asIdentified(item).id ?? item.type)
-					: typeof item === 'string'
-						? `s-${item}`
-						: `display-${idx}`
-			"
-		>
-			<!-- Display items: plain strings or zero-arg render functions -->
-			<template v-if="!(item instanceof NodeBuilder)">
-				<template v-if="typeof item === 'string'">{{ item }}</template>
-				<component :is="item" v-else />
-			</template>
-
-			<template v-else-if="isVisible(item)">
-				<div :class="item.type !== 'group' && !getNodeTitle(item) ? 'contents' : undefined">
-					<div v-if="getNodeTitle(item)" class="mb-2" :class="titleClass(titleDepth ?? 0)">
-						<span
-							v-html="renderString(getNodeTitle(item)!).replace(/^<p>([\s\S]*)<\/p>\n?$/, '$1')"
-						/><span v-if="nodeHasRequiredMissing(asIdentified(item))" class="text-red">*</span>
-					</div>
-
-					<!-- group -->
-					<template v-if="item.type === 'group'">
-						<!-- multi-select (chips) mode -->
-						<template v-if="asGroup(item)._selectMode === 'multi'">
-							<div class="flex flex-wrap gap-2">
-								<template
-									v-for="child in visibleChildren(asIdentified(item))"
-									:key="asIdentified(child).id"
-								>
-									<ButtonStyled
-										:color="
-											getMultiSelectState(asIdentified(item)).has(asIdentified(child).id!)
-												? hasActionableFixes(asIdentified(child))
-													? 'blue'
-													: 'brand'
-												: 'standard'
-										"
-										:circular="!!asIdentified(child)._icon"
-										@click="toggleChip(asIdentified(item), asIdentified(child))"
-									>
-										<button
-											v-tooltip="getTooltipConfig(asIdentified(child))"
-											:aria-label="asIdentified(child)._icon ? asLabeled(child).label : undefined"
-										>
-											<component :is="asIdentified(child)._icon" v-if="asIdentified(child)._icon" />
-											<template v-else>{{ asLabeled(child).label }}</template>
-										</button>
-									</ButtonStyled>
-								</template>
-							</div>
-							<template
-								v-for="child in visibleChildren(asIdentified(item))"
-								:key="`sub-${asIdentified(child).id}`"
-							>
-								<NodeRenderer
-									v-if="
-										getMultiSelectState(asIdentified(item)).has(asIdentified(child).id!) &&
-										getChildren(asIdentified(child)).length
-									"
-									:nodes="getChildren(asIdentified(child))"
-									:show-context="getChildrenContext(asIdentified(child))"
-									:on-image-upload="onImageUpload"
-									:title-depth="titleDepth"
-									:parent-state-path="asIdentified(child)._statePath ?? props.parentStatePath ?? []"
-									class="mt-2"
-								/>
-							</template>
-						</template>
-						<!-- single-select (button-style) mode -->
-						<template v-else-if="asGroup(item)._selectMode === 'single'">
-							<div class="flex flex-wrap gap-2">
-								<template
-									v-for="child in visibleChildren(asIdentified(item))"
-									:key="asIdentified(child).id"
-								>
-									<ButtonStyled
-										:color="
-											getSelectState(asIdentified(item)) === asIdentified(child).id
-												? 'brand'
-												: 'standard'
-										"
-										:circular="!!asIdentified(child)._icon"
-									>
-										<button
-											:aria-label="asIdentified(child)._icon ? asLabeled(child).label : undefined"
-											@click="toggleSelect(asIdentified(item), asIdentified(child))"
-										>
-											<component :is="asIdentified(child)._icon" v-if="asIdentified(child)._icon" />
-											<template v-else>{{ asLabeled(child).label }}</template>
-										</button>
-									</ButtonStyled>
-								</template>
-							</div>
-							<template
-								v-for="child in visibleChildren(asIdentified(item))"
-								:key="`sub-${asIdentified(child).id}`"
-							>
-								<NodeRenderer
-									v-if="
-										getSelectState(asIdentified(item)) === asIdentified(child).id &&
-										getChildren(asIdentified(child)).length
-									"
-									:nodes="getChildren(asIdentified(child))"
-									:show-context="getChildrenContext(asIdentified(child))"
-									:on-image-upload="onImageUpload"
-									:title-depth="titleDepth"
-									:parent-state-path="asIdentified(child)._statePath ?? props.parentStatePath ?? []"
-									class="mt-2"
-								/>
-							</template>
-						</template>
-						<!-- plain container mode -->
-						<NodeRenderer
-							v-else
-							:nodes="getChildren(asIdentified(item))"
-							:show-context="getChildrenContext(asIdentified(item))"
-							:on-image-upload="onImageUpload"
-							:flex="asGroup(item)._layout !== 'column'"
-							:title-depth="item._title !== undefined ? (titleDepth ?? 0) + 1 : titleDepth"
-							:parent-state-path="asIdentified(item)._statePath ?? props.parentStatePath ?? []"
-						/>
-					</template>
-
-					<!-- dropdown -->
-					<template v-else-if="item.type === 'dropdown'">
-						<Combobox
-							class="!w-80"
-							:options="getDropdownOptions(asDropdown(item))"
-							:model-value="getDropdownModelValue(asDropdown(item))"
-							trigger-class="!bg-[var(--color-button-bg)] !rounded-[var(--radius-md)] !shadow-[var(--shadow-inset-sm),0_0_0_0_transparent]"
-							dropdown-class="!rounded-[var(--radius-md)] !bg-[var(--color-button-bg)] !border-0"
-							@update:model-value="(v) => setNodeState(asIdentified(item), v || undefined)"
-						/>
-						<template
-							v-for="child in visibleChildren(asIdentified(item))"
-							:key="`sub-${asIdentified(child).id}`"
-						>
-							<NodeRenderer
-								v-if="
-									getSelectState(asIdentified(item)) === asIdentified(child).id &&
-									getChildren(asIdentified(child)).length
-								"
-								:nodes="getChildren(asIdentified(child))"
-								:show-context="getChildrenContext(asIdentified(child))"
-								:on-image-upload="onImageUpload"
-								:title-depth="titleDepth"
-								:parent-state-path="asIdentified(child)._statePath ?? props.parentStatePath ?? []"
-								class="mt-2"
-							/>
-						</template>
-					</template>
-
-					<!-- button -->
-					<template v-else-if="item.type === 'button'">
-						<ButtonStyled :circular="!!item._icon && !asButton(item).label">
-							<button
-								v-tooltip="getTooltipConfig(item, showContext)"
-								:disabled="!isButtonEnabled(asButton(item))"
-								:aria-label="item._icon && !asButton(item).label ? asButton(item).label : undefined"
-								@click="handleButtonClick(asButton(item))"
-							>
-								<component :is="item._icon" v-if="item._icon" />
-								{{ asButton(item).label }}
-							</button>
-						</ButtonStyled>
-					</template>
-
-					<!-- toggle -->
-					<template v-else-if="item.type === 'toggle'">
-						<ButtonStyled :color="getBooleanColor(asBool(item))" :circular="!!item._icon">
-							<button
-								v-tooltip="getTooltipConfig(asBool(item))"
-								:disabled="!isEnabled(asIdentified(item))"
-								:aria-label="item._icon ? asLabeled(item).label : undefined"
-								@click="toggleBoolean(asBool(item))"
-							>
-								<component :is="item._icon" v-if="item._icon" />
-								<template v-else>{{ asLabeled(item).label }}</template>
-							</button>
-						</ButtonStyled>
-					</template>
-
-					<!-- check -->
-					<template v-else-if="item.type === 'check'">
-						<Checkbox
-							:model-value="getBooleanState(asBool(item))"
-							:label="asLabeled(item).label"
-							:disabled="!isEnabled(asIdentified(item))"
-							@update:model-value="isEnabled(asIdentified(item)) && toggleBoolean(asBool(item))"
-						/>
-					</template>
-
-					<!-- text -->
-					<template v-else-if="item.type === 'text'">
-						<StyledInput
-							:id="`node-${asIdentified(item).id}`"
-							:ref="(el: any) => (el ? textInputRefs.set(item, el) : textInputRefs.delete(item))"
-							v-tooltip="getTooltipConfig(item, showContext)"
-							:model-value="getTextState(asIdentified(item))"
-							:placeholder="getPlaceholder(asInput(item))"
-							autocomplete="off"
-							@update:model-value="(v: string) => setTextState(asIdentified(item), v)"
-						/>
-					</template>
-
-					<!-- markdown -->
-					<template v-else-if="item.type === 'markdown'">
-						<MarkdownEditor
-							:id="`node-${asIdentified(item).id}`"
-							:aria-label="asLabeled(item).label || undefined"
-							:model-value="getTextState(asIdentified(item))"
-							:placeholder="getPlaceholder(asInput(item))"
-							:max-height="300"
-							:disabled="false"
-							:heading-buttons="false"
-							:on-image-upload="onImageUpload"
-							@update:model-value="(v: string) => setTextState(asIdentified(item), v)"
-						/>
-					</template>
-				</div>
-			</template>
-		</template>
-
-		<!-- children of active boolean nodes, rendered after all siblings -->
-		<template
-			v-for="(item, idx) in nodes"
-			:key="
-				item instanceof NodeBuilder
-					? item.type === 'button'
-						? `children-button-${asButton(item).label}`
-						: `children-${asIdentified(item)._statePath?.join('/') ?? asIdentified(item).id ?? item.type}`
-					: `children-display-${idx}`
-			"
-		>
-			<NodeRenderer
-				v-if="
-					item instanceof NodeBuilder &&
-					isVisible(item) &&
-					(item.type === 'toggle' || item.type === 'check') &&
-					getBooleanState(asBool(item)) &&
-					getChildren(asIdentified(item)).length
-				"
-				:nodes="getChildren(asIdentified(item))"
-				:show-context="getChildrenContext(asIdentified(item))"
-				:on-image-upload="onImageUpload"
-				:title-depth="item._title !== undefined ? (titleDepth ?? 0) + 1 : titleDepth"
-				:parent-state-path="asIdentified(item)._statePath ?? props.parentStatePath ?? []"
-				class="w-full"
-			/>
-		</template>
-	</div>
-</template>
diff --git a/apps/frontend/src/components/ui/moderation/checklist/checklist-context.ts b/apps/frontend/src/components/ui/moderation/checklist/checklist-context.ts
index e5271651d6..010d40c2d1 100644
--- a/apps/frontend/src/components/ui/moderation/checklist/checklist-context.ts
+++ b/apps/frontend/src/components/ui/moderation/checklist/checklist-context.ts
@@ -1,11 +1,5 @@
-import type { IdentifiedNodeBuilder, NodeState } from '@modrinth/moderation'
-import type { ComputedRef, InjectionKey, Ref } from 'vue'
-
-export interface ActiveAction {
-	node: IdentifiedNodeBuilder
-	state: Record<string, NodeState>
-	statePath: string[]
-}
+import type { ActiveAction2, NodeState } from '@modrinth/moderation/src/types/node'
+import type { InjectionKey, Ref } from 'vue'
 
 export interface LiveNode {
 	isActive: boolean
@@ -14,10 +8,8 @@ export interface LiveNode {
 	messageCount: number
 	fixCount: number
 	hasRequiredMissing: boolean
-	activeActions: ActiveAction[]
+	activeActions: ActiveAction2[]
 }
 
-export const NODE_META_KEY: InjectionKey<ComputedRef<Map<IdentifiedNodeBuilder, LiveNode>>> =
-	Symbol('nodeMeta')
 export const STATE_KEY: InjectionKey<Ref<Record<string, Record<string, NodeState>>>> =
 	Symbol('checklistState')
diff --git a/apps/frontend/src/pages/[type]/[project].vue b/apps/frontend/src/pages/[type]/[project].vue
index 456d8b2a82..c4ebee193c 100644
--- a/apps/frontend/src/pages/[type]/[project].vue
+++ b/apps/frontend/src/pages/[type]/[project].vue
@@ -555,8 +555,8 @@ import { versionQueryOptions } from '~/composables/queries/version'
 import { useServerInstallContent } from '~/composables/use-server-install-content'
 import { userCollectProject, userFollowProject } from '~/composables/user.js'
 import { injectCurrentProjectId } from '~/providers/current-project.ts'
-import { loadChecklistState } from '~/services/moderation-checklist-storage.ts'
-import { useModerationQueue } from '~/services/moderation-queue.ts'
+import { loadChecklistState } from '~/services/moderation/checklist-storage.ts'
+import { useModerationQueue } from '~/services/moderation/queue.ts'
 import { getReportPath, reportProject } from '~/utils/report-helpers.ts'
 
 definePageMeta({
@@ -1076,7 +1076,7 @@ const { data: thread } = useQuery({
 
 const isSettings = computed(() => route.name.startsWith('type-project-settings'))
 
-// Transform versionsV3 to be same shape as versionsV2 for compatibility in project pages
+// Jank modpack loaders fix
 const versionsRaw = computed(() => {
 	return (versionsV3.value ?? []).map((version) => {
 		const files = Array.isArray(version.files) ? version.files : []
@@ -1867,23 +1867,11 @@ function setModerationChecklistOpen(open) {
 	showModerationChecklist.value = open
 }
 
-function isProjectInActiveModerationQueue(projectId = project.value?.id) {
-	return (
-		!!projectId &&
-		moderationQueue.isQueueMode &&
-		moderationQueue.currentQueue.items.includes(projectId)
-	)
-}
-
 async function openModerationChecklistFromMenu() {
 	const projectId = project.value?.id
 	if (!projectId) return
 
 	await moderationQueue.ready
-	if (!isProjectInActiveModerationQueue(projectId)) {
-		await moderationQueue.setSingleProject(projectId)
-	}
-
 	setModerationChecklistOpen(true)
 }
 
diff --git a/apps/frontend/src/pages/moderation/index.vue b/apps/frontend/src/pages/moderation/index.vue
index f89d6d2c8c..a4a2dbfad5 100644
--- a/apps/frontend/src/pages/moderation/index.vue
+++ b/apps/frontend/src/pages/moderation/index.vue
@@ -105,6 +105,12 @@
 				@switch-page="goToPage"
 			/>
 			<ConfettiExplosion v-if="visible" />
+			<QueueSummaryModal
+				ref="queueSummaryModal"
+				:completed-ids="moderationQueue.currentQueue.completed"
+				:skipped-ids="moderationQueue.currentQueue.skipped"
+				@review-skipped="reviewSkippedQueue"
+			/>
 		</div>
 
 		<div class="flex flex-col gap-3">
@@ -157,8 +163,10 @@ import { useQuery } from '@tanstack/vue-query'
 import ConfettiExplosion from 'vue-confetti-explosion'
 
 import ModerationQueueCard from '~/components/ui/moderation/ModerationQueueCard.vue'
+import QueueSummaryModal from '~/components/ui/moderation/QueueSummaryModal.vue'
 import { type ModerationProject, toModerationProjects } from '~/helpers/moderation.ts'
-import { useModerationQueue } from '~/services/moderation-queue.ts'
+import { findNextEligibleQueueProject } from '~/services/moderation/queue-eligibility.ts'
+import { useModerationQueue } from '~/services/moderation/queue.ts'
 
 useHead({ title: 'Projects queue - Modrinth' })
 
@@ -169,6 +177,8 @@ const route = useRoute()
 const router = useRouter()
 const client = injectModrinthClient()
 
+const queueSummaryModal = ref()
+
 const visible = ref(false)
 if (import.meta.client && history && history.state && history.state.confetti) {
 	setTimeout(async () => {
@@ -181,6 +191,14 @@ if (import.meta.client && history && history.state && history.state.confetti) {
 	}, 1000)
 }
 
+if (import.meta.client && history && history.state && history.state.queueSummary) {
+	setTimeout(async () => {
+		history.state.queueSummary = false
+		await nextTick()
+		queueSummaryModal.value?.show()
+	}, 1000)
+}
+
 const messages = defineMessages({
 	moderate: {
 		id: 'moderation.moderate',
@@ -495,49 +513,19 @@ function goToPage(page: number) {
 	currentPage.value = page
 }
 
-function notifySkippedProjects(skippedCount: number) {
-	if (skippedCount <= 0) return
-	addNotification({
-		title: 'Skipped projects',
-		text: `Skipped ${skippedCount} project(s) already moderated or locked by others.`,
-		type: 'info',
-		autoCloseMs: 2000,
-	})
-}
-
 async function findFirstEligibleProject(): Promise<string | null> {
-	let skippedCount = 0
-
-	while (moderationQueue.hasItems) {
-		const currentId = moderationQueue.getCurrentProjectId()
-		if (!currentId) return null
-
-		const project = projectsById.value.get(currentId)
-
-		if (project && project.project.status !== 'processing') {
-			await moderationQueue.completeCurrentProject(currentId, 'skipped')
-			skippedCount++
-			continue
-		}
-
-		try {
-			const lockStatus = await moderationQueue.checkLock(currentId)
+	const candidateIds = [...moderationQueue.currentQueue.items]
+	if (candidateIds.length === 0) return null
 
-			if (!lockStatus.locked || lockStatus.expired || lockStatus.is_own_lock) {
-				notifySkippedProjects(skippedCount)
-				return currentId
-			}
+	const next = await findNextEligibleQueueProject(client, moderationQueue, candidateIds)
 
-			await moderationQueue.completeCurrentProject(currentId, 'skipped')
-			skippedCount++
-		} catch {
-			return currentId
-		}
+	if (!next) {
+		await Promise.all(candidateIds.map((id) => moderationQueue.excludeProject(id)))
+		return null
 	}
 
-	notifySkippedProjects(skippedCount)
-
-	return null
+	await Promise.all(next.excluded.map((id) => moderationQueue.excludeProject(id)))
+	return next.project
 }
 
 function getProjectRouteParam(projectId: string): string {
@@ -590,12 +578,9 @@ async function moderateAllInFilter() {
 async function startFromProject(projectId: string) {
 	const allFilteredProjectIds = await getFilteredProjectIds()
 	const projectIndex = allFilteredProjectIds.indexOf(projectId)
-	if (projectIndex === -1) {
-		await moderationQueue.setSingleProject(projectId)
-	} else {
-		const projectIds = allFilteredProjectIds.slice(projectIndex)
-		await moderationQueue.setQueue(projectIds)
-	}
+	const projectIds =
+		projectIndex === -1 ? [projectId] : allFilteredProjectIds.slice(projectIndex)
+	await moderationQueue.setQueue(projectIds)
 
 	const targetProjectId = await findFirstEligibleProject()
 
@@ -610,4 +595,21 @@ async function startFromProject(projectId: string) {
 
 	await navigateToModerationProject(targetProjectId)
 }
+
+async function reviewSkippedQueue() {
+	await moderationQueue.startSkippedReview()
+
+	const targetProjectId = await findFirstEligibleProject()
+
+	if (!targetProjectId) {
+		addNotification({
+			title: 'No projects available',
+			text: 'All previously skipped projects are already moderated or locked by others.',
+			type: 'warning',
+		})
+		return
+	}
+
+	await navigateToModerationProject(targetProjectId)
+}
 </script>
diff --git a/apps/frontend/src/services/moderation/checklist-session-storage.ts b/apps/frontend/src/services/moderation/checklist-session-storage.ts
new file mode 100644
index 0000000000..ffef39a029
--- /dev/null
+++ b/apps/frontend/src/services/moderation/checklist-session-storage.ts
@@ -0,0 +1,28 @@
+export interface SessionChecklistState {
+	visitedStages?: string[]
+}
+
+function sessionStorageKey(projectId: string): string {
+	return `moderation-checklist-session:${projectId}`
+}
+
+export function getSessionChecklistState(projectId: string): SessionChecklistState {
+	try {
+		const raw = sessionStorage.getItem(sessionStorageKey(projectId))
+		return raw ? JSON.parse(raw) : {}
+	} catch {
+		return {}
+	}
+}
+
+export function patchSessionChecklistState(
+	projectId: string,
+	patch: Partial<SessionChecklistState>,
+): void {
+	try {
+		sessionStorage.setItem(
+			sessionStorageKey(projectId),
+			JSON.stringify({ ...getSessionChecklistState(projectId), ...patch }),
+		)
+	} catch {}
+}
diff --git a/apps/frontend/src/services/moderation-checklist-storage.ts b/apps/frontend/src/services/moderation/checklist-storage.ts
similarity index 95%
rename from apps/frontend/src/services/moderation-checklist-storage.ts
rename to apps/frontend/src/services/moderation/checklist-storage.ts
index 3b4c1b356c..fa5c13d215 100644
--- a/apps/frontend/src/services/moderation-checklist-storage.ts
+++ b/apps/frontend/src/services/moderation/checklist-storage.ts
@@ -1,6 +1,6 @@
-import type { NodeState } from '@modrinth/moderation'
+import type { NodeState } from '@modrinth/moderation/src/types/node'
 
-import { dbDelete, dbGet, dbPut, dbScan } from './moderation-db.ts'
+import { dbDelete, dbGet, dbPut, dbScan } from './db.ts'
 
 export interface PersistedChecklistState {
 	savedAt: string
@@ -9,6 +9,7 @@ export interface PersistedChecklistState {
 	stage?: string
 	message?: string
 	state?: Record<string, Record<string, NodeState>>
+	activatedStages?: string[]
 }
 
 const STORE = 'checklist'
diff --git a/apps/frontend/src/services/moderation-db.ts b/apps/frontend/src/services/moderation/db.ts
similarity index 100%
rename from apps/frontend/src/services/moderation-db.ts
rename to apps/frontend/src/services/moderation/db.ts
diff --git a/apps/frontend/src/services/moderation/queue-eligibility.ts b/apps/frontend/src/services/moderation/queue-eligibility.ts
new file mode 100644
index 0000000000..25da387057
--- /dev/null
+++ b/apps/frontend/src/services/moderation/queue-eligibility.ts
@@ -0,0 +1,91 @@
+import type { AbstractModrinthClient } from '@modrinth/api-client'
+
+import type { ModerationQueueService } from './queue.ts'
+
+export interface QueueCandidateCheck {
+	locked: boolean
+	expired?: boolean
+	isOwnLock?: boolean
+	slug?: string
+	projectType?: string
+	status?: string
+	isProcessing: boolean
+}
+
+export interface EligibleQueueProject {
+	project: string
+	result: QueueCandidateCheck
+	excluded: string[]
+}
+
+const BATCH_SIZE = 5
+
+export function isEligibleQueueCandidate(result: QueueCandidateCheck | undefined): boolean {
+	if (!result?.isProcessing) return false
+	return !result.locked || !!result.expired || !!result.isOwnLock
+}
+
+export async function batchCheckQueueCandidates(
+	client: AbstractModrinthClient,
+	moderationQueue: ModerationQueueService,
+	projectIds: string[],
+): Promise<Map<string, QueueCandidateCheck>> {
+	const results = new Map<string, QueueCandidateCheck>()
+
+	const projects = await client.labrinth.projects_v3.getMultiple(projectIds).catch(() => [])
+	const projectsById = new Map(projects.map((project) => [project.id, project]))
+
+	const checks = await Promise.allSettled(
+		projectIds.map(async (id) => {
+			const lockResponse = await moderationQueue.checkLock(id)
+			const project = projectsById.get(id) ?? null
+
+			return {
+				id,
+				locked: lockResponse.locked,
+				expired: lockResponse.expired,
+				isOwnLock: lockResponse.is_own_lock,
+				slug: project?.slug,
+				projectType: project?.project_types[0],
+				status: project?.status,
+				isProcessing: project === null ? true : project.status === 'processing',
+			}
+		}),
+	)
+
+	checks.forEach((result, index) => {
+		if (result.status === 'fulfilled') {
+			results.set(result.value.id, result.value)
+		} else {
+			results.set(projectIds[index], { locked: false, isProcessing: true })
+		}
+	})
+
+	return results
+}
+
+export async function findNextEligibleQueueProject(
+	client: AbstractModrinthClient,
+	moderationQueue: ModerationQueueService,
+	candidateIds: string[],
+): Promise<EligibleQueueProject | null> {
+	const excluded: string[] = []
+	let checkedCount = 0
+
+	while (checkedCount < candidateIds.length) {
+		const batch = candidateIds.slice(checkedCount, checkedCount + BATCH_SIZE)
+		checkedCount += batch.length
+
+		const results = await batchCheckQueueCandidates(client, moderationQueue, batch)
+
+		for (const id of batch) {
+			const result = results.get(id)
+			if (isEligibleQueueCandidate(result)) {
+				return { project: id, result: result!, excluded: [...excluded] }
+			}
+			excluded.push(id)
+		}
+	}
+
+	return null
+}
diff --git a/apps/frontend/src/services/moderation-queue-storage.ts b/apps/frontend/src/services/moderation/queue-storage.ts
similarity index 87%
rename from apps/frontend/src/services/moderation-queue-storage.ts
rename to apps/frontend/src/services/moderation/queue-storage.ts
index d90ac1121d..22a450a337 100644
--- a/apps/frontend/src/services/moderation-queue-storage.ts
+++ b/apps/frontend/src/services/moderation/queue-storage.ts
@@ -1,13 +1,13 @@
-import { dbDelete, dbGet, dbPut } from './moderation-db.ts'
+import { dbDelete, dbGet, dbPut } from './db.ts'
 
 export interface PersistedModerationQueueState {
 	version: 1
 	savedAt: string
 	currentQueue: {
 		items: string[]
+		skipped?: string[]
 		total: number
-		completed: number
-		skipped: number
+		completed: string[]
 		lastUpdated: string
 	}
 	isQueueMode: boolean
@@ -31,9 +31,9 @@ function isPersistedStateCandidate(value: unknown): value is PersistedModeration
 	const queue = candidate.currentQueue
 	if (!queue || typeof queue !== 'object') return false
 	if (!isStringArray(queue.items)) return false
+	if (queue.skipped !== undefined && !isStringArray(queue.skipped)) return false
 	if (typeof queue.total !== 'number' || Number.isNaN(queue.total)) return false
-	if (typeof queue.completed !== 'number' || Number.isNaN(queue.completed)) return false
-	if (typeof queue.skipped !== 'number' || Number.isNaN(queue.skipped)) return false
+	if (!isStringArray(queue.completed)) return false
 	if (typeof queue.lastUpdated !== 'string') return false
 
 	return true
diff --git a/apps/frontend/src/services/moderation-queue.ts b/apps/frontend/src/services/moderation/queue.ts
similarity index 76%
rename from apps/frontend/src/services/moderation-queue.ts
rename to apps/frontend/src/services/moderation/queue.ts
index 2ebe96e8c6..9c0a45a884 100644
--- a/apps/frontend/src/services/moderation-queue.ts
+++ b/apps/frontend/src/services/moderation/queue.ts
@@ -6,13 +6,13 @@ import {
 	loadQueueState,
 	type PersistedModerationQueueState,
 	saveQueueState,
-} from './moderation-queue-storage.ts'
+} from './queue-storage.ts'
 
 export interface ModerationQueue {
 	items: string[]
+	skipped: string[]
 	total: number
-	completed: number
-	skipped: number
+	completed: string[]
 	lastUpdated: Date
 }
 
@@ -29,11 +29,14 @@ export interface ModerationQueueService {
 
 	queueLength: number
 	hasItems: boolean
+	hasSkipped: boolean
 	progress: number
 
 	setQueue(projectIds: string[]): Promise<void>
-	setSingleProject(projectId: string): Promise<void>
-	completeCurrentProject(projectId: string, status?: 'completed' | 'skipped'): Promise<boolean>
+	completeProject(projectId: string): Promise<boolean>
+	deferProject(projectId: string): Promise<boolean>
+	excludeProject(projectId: string): Promise<boolean>
+	startSkippedReview(): Promise<void>
 	getCurrentProjectId(): string | null
 	resetQueue(): Promise<void>
 
@@ -46,31 +49,31 @@ export interface ModerationQueueService {
 
 const EMPTY_QUEUE: ModerationQueue = {
 	items: [],
+	skipped: [],
 	total: 0,
-	completed: 0,
-	skipped: 0,
+	completed: [],
 	lastUpdated: new Date(),
 }
 
 function createEmptyQueue(): ModerationQueue {
-	return { ...EMPTY_QUEUE, lastUpdated: new Date(), items: [] }
+	return { ...EMPTY_QUEUE, lastUpdated: new Date(), items: [], skipped: [], completed: [] }
 }
 
 function sanitizeQueue(raw: PersistedModerationQueueState['currentQueue']): ModerationQueue {
 	const lastUpdated = new Date(raw.lastUpdated)
 	const items = raw.items.filter((id): id is string => typeof id === 'string')
-	const completed = Number.isFinite(raw.completed) ? Math.max(Math.trunc(raw.completed), 0) : 0
-	const skipped = Number.isFinite(raw.skipped) ? Math.max(Math.trunc(raw.skipped), 0) : 0
-	const minimumTotal = items.length + completed + skipped
+	const skipped = (raw.skipped ?? []).filter((id): id is string => typeof id === 'string')
+	const completed = (raw.completed ?? []).filter((id): id is string => typeof id === 'string')
+	const minimumTotal = items.length + completed.length
 	const total = Number.isFinite(raw.total)
 		? Math.max(Math.trunc(raw.total), minimumTotal)
 		: minimumTotal
 
 	return {
 		items,
+		skipped,
 		total,
 		completed,
-		skipped,
 		lastUpdated: Number.isNaN(lastUpdated.getTime()) ? new Date() : lastUpdated,
 	}
 }
@@ -84,9 +87,9 @@ function persistedPayload(
 		savedAt: new Date().toISOString(),
 		currentQueue: {
 			items: [...queue.items],
+			skipped: [...queue.skipped],
 			total: queue.total,
-			completed: queue.completed,
-			skipped: queue.skipped,
+			completed: [...queue.completed],
 			lastUpdated: queue.lastUpdated.toISOString(),
 		},
 		isQueueMode,
@@ -101,9 +104,10 @@ function createModerationQueueState(client: AbstractModrinthClient = injectModri
 
 	const queueLength = computed(() => currentQueue.value.items.length)
 	const hasItems = computed(() => currentQueue.value.items.length > 0)
+	const hasSkipped = computed(() => currentQueue.value.skipped.length > 0)
 	const progress = computed(() => {
 		if (currentQueue.value.total === 0) return 0
-		return (currentQueue.value.completed + currentQueue.value.skipped) / currentQueue.value.total
+		return (currentQueue.value.total - currentQueue.value.items.length) / currentQueue.value.total
 	})
 	let mutationChain = Promise.resolve()
 
@@ -148,51 +152,70 @@ function createModerationQueueState(client: AbstractModrinthClient = injectModri
 		return result
 	}
 
-	function setQueueState(items: string[], mode: boolean) {
-		isQueueMode.value = mode
+	function setQueueState(items: string[]) {
+		isQueueMode.value = true
 		currentQueue.value = {
 			items: [...items],
+			skipped: [],
 			total: items.length,
-			completed: 0,
-			skipped: 0,
+			completed: [],
 			lastUpdated: new Date(),
 		}
 	}
 
 	async function setQueue(projectIds: string[]): Promise<void> {
 		await withMutation(() => {
-			setQueueState(projectIds, true)
+			setQueueState(projectIds)
 		})
 	}
 
-	async function setSingleProject(projectId: string): Promise<void> {
-		await withMutation(() => {
-			setQueueState([projectId], false)
+	async function completeProject(projectId: string): Promise<boolean> {
+		return withMutation(() => {
+			if (!currentQueue.value.items.includes(projectId)) {
+				return currentQueue.value.items.length > 0
+			}
+
+			currentQueue.value.completed = [...currentQueue.value.completed, projectId]
+			currentQueue.value.items = currentQueue.value.items.filter((id) => id !== projectId)
+			currentQueue.value.lastUpdated = new Date()
+
+			return currentQueue.value.items.length > 0
 		})
 	}
 
-	async function completeCurrentProject(
-		projectId: string,
-		status: 'completed' | 'skipped' = 'completed',
-	): Promise<boolean> {
+	async function excludeProject(projectId: string): Promise<boolean> {
 		return withMutation(() => {
 			if (!currentQueue.value.items.includes(projectId)) {
 				return currentQueue.value.items.length > 0
 			}
 
-			if (status === 'completed') {
-				currentQueue.value.completed++
-			} else {
-				currentQueue.value.skipped++
+			currentQueue.value.items = currentQueue.value.items.filter((id) => id !== projectId)
+			currentQueue.value.lastUpdated = new Date()
+
+			return currentQueue.value.items.length > 0
+		})
+	}
+
+	async function deferProject(projectId: string): Promise<boolean> {
+		return withMutation(() => {
+			if (!currentQueue.value.items.includes(projectId)) {
+				return currentQueue.value.items.length > 0
 			}
 
 			currentQueue.value.items = currentQueue.value.items.filter((id) => id !== projectId)
+			currentQueue.value.skipped = [...currentQueue.value.skipped, projectId]
 			currentQueue.value.lastUpdated = new Date()
 
 			return currentQueue.value.items.length > 0
 		})
 	}
 
+	async function startSkippedReview(): Promise<void> {
+		await withMutation(() => {
+			setQueueState(currentQueue.value.skipped)
+		})
+	}
+
 	function getCurrentProjectId(): string | null {
 		return currentQueue.value.items[0] || null
 	}
@@ -294,11 +317,14 @@ function createModerationQueueState(client: AbstractModrinthClient = injectModri
 
 		queueLength,
 		hasItems,
+		hasSkipped,
 		progress,
 
 		setQueue,
-		setSingleProject,
-		completeCurrentProject,
+		completeProject,
+		deferProject,
+		excludeProject,
+		startSkippedReview,
 		getCurrentProjectId,
 		resetQueue,
 
diff --git a/apps/frontend/src/store/moderation.ts b/apps/frontend/src/store/moderation.ts
index d9ac077d57..d488524b7f 100644
--- a/apps/frontend/src/store/moderation.ts
+++ b/apps/frontend/src/store/moderation.ts
@@ -4,8 +4,8 @@ import type {
 	LockStatusResponse,
 	ModerationQueue,
 	ModerationQueueService,
-} from '~/services/moderation-queue.ts'
-import { useModerationQueue } from '~/services/moderation-queue.ts'
+} from '~/services/moderation/queue.ts'
+import { useModerationQueue } from '~/services/moderation/queue.ts'
 
 export type {
 	LockAcquireResponse,
diff --git a/apps/labrinth/.idea/copilot.data.migration.ask2agent.xml b/apps/labrinth/.idea/copilot.data.migration.ask2agent.xml
index 1f2ea11e7f..e38d36d4cf 100644
--- a/apps/labrinth/.idea/copilot.data.migration.ask2agent.xml
+++ b/apps/labrinth/.idea/copilot.data.migration.ask2agent.xml
@@ -1,6 +1,6 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8" ?>
 <project version="4">
-  <component name="Ask2AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>
\ No newline at end of file
+	<component name="Ask2AgentMigrationStateService">
+		<option name="migrationStatus" value="COMPLETED" />
+	</component>
+</project>
diff --git a/apps/labrinth/.idea/labrinth.iml b/apps/labrinth/.idea/labrinth.iml
index b5c2fdebc2..227b39cde8 100644
--- a/apps/labrinth/.idea/labrinth.iml
+++ b/apps/labrinth/.idea/labrinth.iml
@@ -1,11 +1,11 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8" ?>
 <module type="EMPTY_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
\ No newline at end of file
+	<component name="NewModuleRootManager">
+		<content url="file://$MODULE_DIR$">
+			<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+			<sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
+		</content>
+		<orderEntry type="inheritedJdk" />
+		<orderEntry type="sourceFolder" forTests="false" />
+	</component>
+</module>
diff --git a/apps/labrinth/.idea/modules.xml b/apps/labrinth/.idea/modules.xml
index 0d8b557a85..d2ffc4e5b0 100644
--- a/apps/labrinth/.idea/modules.xml
+++ b/apps/labrinth/.idea/modules.xml
@@ -1,8 +1,11 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8" ?>
 <project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/labrinth.iml" filepath="$PROJECT_DIR$/.idea/labrinth.iml" />
-    </modules>
-  </component>
-</project>
\ No newline at end of file
+	<component name="ProjectModuleManager">
+		<modules>
+			<module
+				fileurl="file://$PROJECT_DIR$/.idea/labrinth.iml"
+				filepath="$PROJECT_DIR$/.idea/labrinth.iml"
+			/>
+		</modules>
+	</component>
+</project>
diff --git a/apps/labrinth/.idea/vcs.xml b/apps/labrinth/.idea/vcs.xml
index b2bdec2d71..c0e6d24e42 100644
--- a/apps/labrinth/.idea/vcs.xml
+++ b/apps/labrinth/.idea/vcs.xml
@@ -1,6 +1,6 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8" ?>
 <project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
-  </component>
-</project>
\ No newline at end of file
+	<component name="VcsDirectoryMappings">
+		<mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+	</component>
+</project>
diff --git a/apps/labrinth/Cargo.toml b/apps/labrinth/Cargo.toml
index 1081074d9a..ed7bca43bd 100644
--- a/apps/labrinth/Cargo.toml
+++ b/apps/labrinth/Cargo.toml
@@ -22,12 +22,7 @@ arc-swap = { workspace = true }
 argon2 = { workspace = true }
 ariadne = { workspace = true }
 async-minecraft-ping = { workspace = true, features = ["srv"] }
-async-stripe = { workspace = true, features = [
-  "billing",
-  "checkout",
-  "connect",
-  "webhook-events"
-] }
+async-stripe = { workspace = true, features = ["billing", "checkout", "connect", "webhook-events"] }
 async-trait = { workspace = true }
 aws-sdk-s3 = { workspace = true }
 base64 = { workspace = true }
@@ -54,21 +49,21 @@ hmac = { workspace = true }
 hyper-rustls = { workspace = true }
 hyper-util = { workspace = true }
 image = { workspace = true, features = [
-  "avif",
-  "bmp",
-  "dds",
-  "exr",
-  "ff",
-  "gif",
-  "hdr",
-  "ico",
-  "jpeg",
-  "png",
-  "pnm",
-  "qoi",
-  "tga",
-  "tiff",
-  "webp",
+	"avif",
+	"bmp",
+	"dds",
+	"exr",
+	"ff",
+	"gif",
+	"hdr",
+	"ico",
+	"jpeg",
+	"png",
+	"pnm",
+	"qoi",
+	"tga",
+	"tiff",
+	"webp",
 ] }
 itertools = { workspace = true }
 json-patch = { workspace = true }
@@ -87,24 +82,10 @@ quick-xml = { workspace = true }
 rand = { workspace = true }
 rand_chacha = { workspace = true }
 rdkafka = { workspace = true }
-redis = { workspace = true, features = [
-  "ahash",
-  "cluster",
-  "cluster-async",
-  "r2d2",
-  "tokio-comp"
-] }
+redis = { workspace = true, features = ["ahash", "cluster", "cluster-async", "r2d2", "tokio-comp"] }
 regex = { workspace = true }
-reqwest = { workspace = true, features = [
-  "http2",
-  "json",
-  "multipart",
-  "rustls-tls-webpki-roots"
-] }
-rust_decimal = { workspace = true, features = [
-  "serde-with-float",
-  "serde-with-str"
-] }
+reqwest = { workspace = true, features = ["http2", "json", "multipart", "rustls-tls-webpki-roots"] }
+rust_decimal = { workspace = true, features = ["serde-with-float", "serde-with-str"] }
 rust_iso3166 = { workspace = true }
 rustls.workspace = true
 rusty-money = { workspace = true }
@@ -118,14 +99,14 @@ sha2 = { workspace = true }
 smallvec = { workspace = true }
 spdx = { workspace = true, features = ["text"] }
 sqlx = { workspace = true, features = [
-  "chrono",
-  "json",
-  "macros",
-  "migrate",
-  "postgres",
-  "runtime-tokio",
-  "rust_decimal",
-  "tls-rustls-aws-lc-rs",
+	"chrono",
+	"json",
+	"macros",
+	"migrate",
+	"postgres",
+	"runtime-tokio",
+	"rust_decimal",
+	"tls-rustls-aws-lc-rs",
 ] }
 sqlx-tracing = { workspace = true, features = ["postgres"] }
 strum = { workspace = true, features = ["derive"] }
@@ -141,8 +122,8 @@ utoipa = { workspace = true, features = ["url"] }
 uuid = { workspace = true, features = ["fast-rng", "serde", "v4", "v7"] }
 validator = { workspace = true, features = ["derive"] }
 webauthn-rs = { workspace = true, features = [
-  "conditional-ui",
-  "danger-allow-state-serialisation"
+	"conditional-ui",
+	"danger-allow-state-serialisation",
 ] }
 webauthn-rs-proto = { workspace = true }
 webp = { workspace = true }
@@ -165,8 +146,8 @@ iana-time-zone = { workspace = true }
 jemalloc_pprof = { workspace = true, features = ["flamegraph"] }
 tikv-jemalloc-ctl = { workspace = true, features = ["stats"] }
 tikv-jemallocator = { workspace = true, features = [
-  "profiling",
-  "unprefixed_malloc_on_supported_platforms",
+	"profiling",
+	"unprefixed_malloc_on_supported_platforms",
 ] }
 
 [features]
diff --git a/apps/labrinth/src/api_v2_description.md b/apps/labrinth/src/api_v2_description.md
index 551b6e80b7..8e620789c4 100644
--- a/apps/labrinth/src/api_v2_description.md
+++ b/apps/labrinth/src/api_v2_description.md
@@ -2,10 +2,12 @@
 > API v2 is Modrinth's current, official API. It is the recommended API for integrations and applications and will receive long-term support.
 
 ## Authentication
+
 This API has two options for authentication: personal access tokens and [OAuth2](https://en.wikipedia.org/wiki/OAuth).
 All tokens are tied to a Modrinth user and use the `Authorization` header of the request.
 
 Example:
+
 ```
 Authorization: mrp_RNtLRSPmGj2pd1v1ubi52nX7TJJM9sznrmwhAuj511oe4t1jAqAQ3D6Wc8Ic
 ```
@@ -13,6 +15,7 @@ Authorization: mrp_RNtLRSPmGj2pd1v1ubi52nX7TJJM9sznrmwhAuj511oe4t1jAqAQ3D6Wc8Ic
 > [!tip] You do not need a token for most requests.
 >
 > Generally speaking, only the following types of requests require a token:
+>
 > - those which create data (such as version creation)
 > - those which modify data (such as editing a project)
 > - those which access private data (such as draft projects, notifications, emails, and payout data)
@@ -24,18 +27,22 @@ Please note that certain scopes and requests cannot be completed with a personal
 For example, deleting a user account can only be done through Modrinth's frontend.
 
 ### Personal access tokens
+
 Personal access tokens (PATs) can be generated from [the user settings](https://modrinth.com/settings/account).
 
 ### GitHub tokens
+
 For backwards compatibility purposes, some types of GitHub tokens also work for authenticating a user with Modrinth's API, granting all scopes.
 **We urge any application still using GitHub tokens to start using personal access tokens for security and reliability purposes.**
 
 ## Cross-Origin Resource Sharing
+
 This API features Cross-Origin Resource Sharing (CORS) implemented in compliance with the [W3C spec](https://www.w3.org/TR/cors/).
 This allows for cross-domain communication from the browser.
 All responses have a wildcard same-origin which makes them completely public and accessible to everyone, including any code on any site.
 
 ## Identifiers
+
 The majority of items you can interact with in the API have a unique eight-digit base62 ID.
 Projects, versions, users, threads, teams, and reports all use this same way of identifying themselves.
 Version files use the sha1 or sha512 file hashes as identifiers.
@@ -45,7 +52,9 @@ While unique IDs are constant, slugs and usernames can change at any moment.
 If you want to store something in the long term, it is recommended to use the unique ID.
 
 ## Ratelimits
+
 The API has a ratelimit defined per IP. Limits and remaining amounts are given in the response headers.
+
 - `X-Ratelimit-Limit`: the maximum number of requests that can be made in a minute
 - `X-Ratelimit-Remaining`: the number of requests remaining in the current ratelimit window
 - `X-Ratelimit-Reset`: the time in seconds until the ratelimit window resets
@@ -57,20 +66,24 @@ The ratelimit is currently 300 requests per minute per IP. If your application i
 Higher rate limits are granted only in very rare cases. If you believe your use case requires an exception, please [contact us](mailto:support@modrinth.com).
 
 ## User Agents
+
 To access the Modrinth API, you **must** use provide a uniquely-identifying `User-Agent` header.
 Providing a user agent that only identifies your HTTP client library (such as "okhttp/4.9.3") increases the likelihood that we will block your traffic.
 It is recommended, but not required, to include contact information in your user agent.
 This allows us to contact you if we would like a change in your application's behavior without having to block your traffic.
+
 - Bad: `User-Agent: okhttp/4.9.3`
 - Good: `User-Agent: project_name`
 - Better: `User-Agent: github_username/project_name/1.56.0`
 - Best: `User-Agent: github_username/project_name/1.56.0 (launcher.com)` or `User-Agent: github_username/project_name/1.56.0 (contact@launcher.com)`
 
 ## Versioning
+
 Modrinth follows a simple pattern for its API versioning.
 In the event of a breaking API change, the API version in the URL path is bumped, and migration steps will be published below.
 
 ### Migrations
+
 Inside the following spoiler, you will be able to find all changes between versions of the Modrinth API, accompanied by tips and a guide to migrate applications to newer versions.
 
 <details><summary>API v1 to API v2</summary>
@@ -82,12 +95,12 @@ These bullet points cover most changes in the v2 API, but please note that field
 - New search facet: `project_type`
 - Alphabetical sort removed (it didn't work and is not possible due to limits in MeiliSearch)
 - New search fields: `project_type`, `gallery`
-	- The gallery field is an array of URLs to images that are part of the project's gallery
+  - The gallery field is an array of URLs to images that are part of the project's gallery
 - The gallery is a new feature which allows the user to upload images showcasing their mod to the CDN which will be displayed on their mod page
 - Internal change: Any project file uploaded to Modrinth is now validated to make sure it's a valid Minecraft mod, Modpack, etc.
-	- For example, a Forge 1.17 mod with a JAR not containing a mods.toml will not be allowed to be uploaded to Modrinth
+  - For example, a Forge 1.17 mod with a JAR not containing a mods.toml will not be allowed to be uploaded to Modrinth
 - In project creation, projects may not upload a mod with no versions to review, however they can be saved as a draft
-	- Similarly, for version creation, a version may not be uploaded without any files
+  - Similarly, for version creation, a version may not be uploaded without any files
 - Donation URLs have been enabled
 - New project status: `archived`. Projects with this status do not appear in search
 - Tags (such as categories, loaders) now have icons (SVGs) and specific project types attached
diff --git a/apps/labrinth/src/api_v3_description.md b/apps/labrinth/src/api_v3_description.md
index 2e2449615b..9b0e577c5e 100644
--- a/apps/labrinth/src/api_v3_description.md
+++ b/apps/labrinth/src/api_v3_description.md
@@ -3,6 +3,5 @@
 >
 > **Please do not use this API in production. It will be deprecated in the future.**
 
-
 > [!tip]
 > You're probably looking for [Modrinth's public API v2](/docs?api=v2)
diff --git a/packages/app-lib/Cargo.toml b/packages/app-lib/Cargo.toml
index b3d05f8885..289ef9a695 100644
--- a/packages/app-lib/Cargo.toml
+++ b/packages/app-lib/Cargo.toml
@@ -9,18 +9,15 @@ ariadne = { workspace = true }
 async-minecraft-ping = { workspace = true, features = ["srv"] }
 async-recursion = { workspace = true }
 async-trait = { workspace = true }
-async-tungstenite = { workspace = true, features = [
-  "tokio-runtime",
-  "tokio-rustls-webpki-roots"
-] }
+async-tungstenite = { workspace = true, features = ["tokio-runtime", "tokio-rustls-webpki-roots"] }
 async-walkdir = { workspace = true }
 async_zip = { workspace = true, features = [
-  "bzip2",
-  "chrono",
-  "deflate",
-  "deflate64",
-  "tokio-fs",
-  "zstd",
+	"bzip2",
+	"chrono",
+	"deflate",
+	"deflate64",
+	"tokio-fs",
+	"zstd",
 ] }
 base64 = { workspace = true }
 bon = { workspace = true }
@@ -64,16 +61,16 @@ quick-xml = { workspace = true, features = ["async-tokio"] }
 rand = { workspace = true }
 regex = { workspace = true }
 reqwest = { workspace = true, features = [
-  "brotli",
-  "charset",
-  "deflate",
-  "gzip",
-  "http2",
-  "json",
-  "macos-system-configuration",
-  "multipart",
-  "rustls-tls-webpki-roots",
-  "stream",
+	"brotli",
+	"charset",
+	"deflate",
+	"gzip",
+	"http2",
+	"json",
+	"macos-system-configuration",
+	"multipart",
+	"rustls-tls-webpki-roots",
+	"stream",
 ] }
 rgb = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
@@ -84,25 +81,25 @@ sha1_smol = { workspace = true }
 sha2 = { workspace = true }
 shlex = { workspace = true }
 sqlx = { workspace = true, features = [
-  "json",
-  "macros",
-  "migrate",
-  "runtime-tokio",
-  "sqlite",
-  "uuid",
+	"json",
+	"macros",
+	"migrate",
+	"runtime-tokio",
+	"sqlite",
+	"uuid",
 ] }
 sysinfo = { workspace = true, features = ["disk", "system"] }
 tauri = { workspace = true, features = ["unstable"], optional = true }
 tempfile = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = [
-  "fs",
-  "io-util",
-  "macros",
-  "net",
-  "process",
-  "sync",
-  "time",
+	"fs",
+	"io-util",
+	"macros",
+	"net",
+	"process",
+	"sync",
+	"time",
 ] }
 tokio-util = { workspace = true, features = ["compat", "io", "io-util", "time"] }
 tracing = { workspace = true }
diff --git a/packages/assets/generated-icons.ts b/packages/assets/generated-icons.ts
index 0b524d52ad..0038e7d6cf 100644
--- a/packages/assets/generated-icons.ts
+++ b/packages/assets/generated-icons.ts
@@ -182,6 +182,7 @@ import _LogInIcon from './icons/log-in.svg?component'
 import _LogOutIcon from './icons/log-out.svg?component'
 import _MailIcon from './icons/mail.svg?component'
 import _ManageIcon from './icons/manage.svg?component'
+import _MapPinIcon from './icons/map-pin.svg?component'
 import _MaximizeIcon from './icons/maximize.svg?component'
 import _MemoryStickIcon from './icons/memory-stick.svg?component'
 import _MessageIcon from './icons/message.svg?component'
@@ -614,6 +615,7 @@ export const LogInIcon = _LogInIcon
 export const LogOutIcon = _LogOutIcon
 export const MailIcon = _MailIcon
 export const ManageIcon = _ManageIcon
+export const MapPinIcon = _MapPinIcon
 export const MaximizeIcon = _MaximizeIcon
 export const MemoryStickIcon = _MemoryStickIcon
 export const MessageIcon = _MessageIcon
diff --git a/packages/assets/icons/map-pin.svg b/packages/assets/icons/map-pin.svg
new file mode 100644
index 0000000000..40c440cd95
--- /dev/null
+++ b/packages/assets/icons/map-pin.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-map-pin-icon lucide-map-pin"><path d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"/><circle cx="12" cy="10" r="3"/></svg>
\ No newline at end of file
diff --git a/packages/moderation/src/data/checklist.ts b/packages/moderation/src/data/checklist.ts
index 4e5383715c..c6c5a362e2 100644
--- a/packages/moderation/src/data/checklist.ts
+++ b/packages/moderation/src/data/checklist.ts
@@ -1,8 +1,6 @@
 import type { Ref } from 'vue'
-import { provide, ref } from 'vue'
 
-import type { NodeState, StageFn, StageNodeBuilder } from '../types/node'
-import { group, STAGES_KEY } from '../types/node'
+import type { NodeState, StageNode } from '../types/node'
 import useCategoriesStage from './stages/categories'
 import useDescriptionStage from './stages/description'
 import useGalleryStage from './stages/gallery'
@@ -13,17 +11,15 @@ import usePermissionsStage from './stages/permissions'
 import usePostApprovalStage from './stages/post-approval'
 import useReReviewStage from './stages/re-review'
 import useReuploadsStage from './stages/reupload'
-import useOtherRulesStage from './stages/other-rules'
+import useRulesStage from './stages/rules'
 import useStatusAlertsStage from './stages/status-alerts'
 import useSummaryStage from './stages/summary'
 import useTitleSlugStage from './stages/title-slug'
 import useUndefinedProjectStage from './stages/undefined-project'
 import useVersionsStage from './stages/versions'
 
-export function useStages(
-	globalState: Ref<Record<string, Record<string, NodeState>>>,
-): StageNodeBuilder[] {
-	const mainStages: StageNodeBuilder[] = [
+export function useStages(globalState: Ref<Record<string, Record<string, NodeState>>>): StageNode[] {
+	const mainStages: StageNode[] = [
 		usePostApprovalStage(),
 		useUndefinedProjectStage(),
 		useReReviewStage(),
@@ -38,12 +34,7 @@ export function useStages(
 		useVersionsStage(),
 		useReuploadsStage(),
 		usePermissionsStage(),
-		useOtherRulesStage(),
+		useRulesStage(),
 	]
-	provide(STAGES_KEY, ref(mainStages))
 	return [...mainStages, useStatusAlertsStage(mainStages, globalState)]
 }
-
-export const stages: ReadonlyArray<StageFn> = []
-
-export default group()
diff --git a/packages/moderation/src/data/keybinds.ts b/packages/moderation/src/data/keybinds.ts
index 25b2994374..5b3c3554d6 100644
--- a/packages/moderation/src/data/keybinds.ts
+++ b/packages/moderation/src/data/keybinds.ts
@@ -32,7 +32,6 @@ const keybinds: { [id: string]: KeybindListener } = {
 		keybind: 'ArrowRight',
 		description: 'Go to next stage',
 		scope: 'checklist',
-		enabled: (ctx) => !ctx.state.isDone,
 		action: (ctx) => ctx.actions.tryGoNext(),
 	},
 	'previous-stage': {
diff --git a/packages/moderation/src/data/messages/checklist/messages/description/insufficient/header.md b/packages/moderation/src/data/messages/checklist/messages/description/insufficient/header.md
index 4e4934805a..68f69b9e31 100644
--- a/packages/moderation/src/data/messages/checklist/messages/description/insufficient/header.md
+++ b/packages/moderation/src/data/messages/checklist/messages/description/insufficient/header.md
@@ -2,5 +2,3 @@
 
 Per section 2.1 of %RULES%, your %PROJECT_DESCRIPTION_FLINK% should clearly inform the reader of the content, purpose, and appeal of your %PROJECT_TYPE%.</br>
 Currently, it looks like there are some missing details.
-
-%CUSTOM_ADVICE%
diff --git a/packages/moderation/src/data/messages/checklist/messages/metadata/dependencies.md b/packages/moderation/src/data/messages/checklist/messages/metadata/dependencies.md
new file mode 100644
index 0000000000..8498e5c58b
--- /dev/null
+++ b/packages/moderation/src/data/messages/checklist/messages/metadata/dependencies.md
@@ -0,0 +1,4 @@
+## Missing Dependencies
+
+Per section 5.6 of %RULES%, it is important that relevant dependencies be listed in the dependencies section of your project.  
+Please ensure that all relevant dependencies are included in the Dependencies section of each version of your project.
diff --git a/packages/moderation/src/data/messages/checklist/messages/metadata/game-version/correction.md b/packages/moderation/src/data/messages/checklist/messages/metadata/game-version/correction.md
new file mode 100644
index 0000000000..a6a6a128d6
--- /dev/null
+++ b/packages/moderation/src/data/messages/checklist/messages/metadata/game-version/correction.md
@@ -0,0 +1 @@
+This project should have the following game version(s) selected: %GAME_VERSIONS%.
diff --git a/packages/moderation/src/data/messages/checklist/messages/metadata/game-version/inaccurate.md b/packages/moderation/src/data/messages/checklist/messages/metadata/game-version/inaccurate.md
new file mode 100644
index 0000000000..b2d18df43a
--- /dev/null
+++ b/packages/moderation/src/data/messages/checklist/messages/metadata/game-version/inaccurate.md
@@ -0,0 +1,5 @@
+## Game Version Metadata
+
+Per section 5.1 of %RULES%, it is important that the metadata of your project is accurate, including which Minecraft versions are selected.
+
+%CORRECT%
diff --git a/packages/moderation/src/data/messages/checklist/messages/metadata/loader/correction.md b/packages/moderation/src/data/messages/checklist/messages/metadata/loader/correction.md
new file mode 100644
index 0000000000..321e8f36aa
--- /dev/null
+++ b/packages/moderation/src/data/messages/checklist/messages/metadata/loader/correction.md
@@ -0,0 +1 @@
+This project should have the following loader(s) selected: %LOADERS%.
diff --git a/packages/moderation/src/data/messages/checklist/messages/metadata/loader/inaccurate.md b/packages/moderation/src/data/messages/checklist/messages/metadata/loader/inaccurate.md
new file mode 100644
index 0000000000..a1cf5e0f98
--- /dev/null
+++ b/packages/moderation/src/data/messages/checklist/messages/metadata/loader/inaccurate.md
@@ -0,0 +1,5 @@
+## Loader Metadata
+
+Per section 5.1 of %RULES%, it is important that the metadata of your project is accurate, including which loaders are selected.
+
+%CORRECT%
diff --git a/packages/moderation/src/data/priorities.ts b/packages/moderation/src/data/priorities.ts
index 6aea35ea99..8dfed8116c 100644
--- a/packages/moderation/src/data/priorities.ts
+++ b/packages/moderation/src/data/priorities.ts
@@ -8,4 +8,5 @@ export const Priorities = new (class extends Priority {
 	rejected = this.before()
 	withheld = this.before()
 	note = this.after()
+  tempLast = this.after()
 })()
diff --git a/packages/moderation/src/data/stages/categories.tsx b/packages/moderation/src/data/stages/categories.tsx
index ea2154dbb8..46768def6f 100644
--- a/packages/moderation/src/data/stages/categories.tsx
+++ b/packages/moderation/src/data/stages/categories.tsx
@@ -36,7 +36,7 @@ export default function () {
 			),
 
 			group().children(
-				toggle('inaccurate', 'Inaccurate').suggestedStatus('flagged').severity('low').message(),
+				toggle('inaccurate', 'Inaccurate').suggestedStatus('flagged').message(),
 
 				toggle('optimization-misused', 'Optimization')
 					.shown(
@@ -47,7 +47,6 @@ export default function () {
 						),
 					)
 					.suggestedStatus('flagged')
-					.severity('low')
 					.rawMessage(optimizationMsg)
 					.fix(
 						fix().project((patch) => {
@@ -61,7 +60,6 @@ export default function () {
 				toggle('resolutions-misused', 'Resolutions')
 					.shown(computed(() => project.value.project_types.includes('resourcepack')))
 					.suggestedStatus('flagged')
-					.severity('low')
 					.rawMessage(resolutionsMsg)
 					.fix(
 						fix().project((patch) => {
diff --git a/packages/moderation/src/data/stages/description.tsx b/packages/moderation/src/data/stages/description.tsx
index 3ca0cb1694..fb25f611fb 100644
--- a/packages/moderation/src/data/stages/description.tsx
+++ b/packages/moderation/src/data/stages/description.tsx
@@ -1,87 +1,80 @@
-import { LibraryIcon } from '@modrinth/assets'
-import { injectProjectPageContext } from '@modrinth/ui'
-import { computed } from 'vue'
+import {LibraryIcon} from "@modrinth/assets"
+import {injectProjectPageContext} from "@modrinth/ui"
+import {computed} from "vue"
 
-import { group, markdown, md, stage, toggle } from '../../types/node'
+import {group, markdown, md, stage, toggle} from "../../types/node"
 
-const SHOW_SPOILER_ADVICE = ['spoilers']
+const SHOW_SPOILER_ADVICE = ["spoilers"]
 
 export default function () {
-	const { projectV3: project } = injectProjectPageContext()
+  const {projectV3: project} = injectProjectPageContext()
 
-	return stage('description', 'Description')
-		.hint('Is the description sufficient, accurate, and accessible?')
-		.guidance(
-			'https://www.notion.so/2e15ee711bf080e4a41df61bbab49892#2e15ee711bf080508042e70089dd787e',
-		)
-		.icon(LibraryIcon)
-		.navigate('/')
-		.children(
-			group()
-				.title('Description Issues?')
-				.children(
-					toggle('insufficient', 'Insufficient')
-						.suggestedStatus('flagged')
-						.severity('medium')
-						.message('insufficient/header', (s) => ({ CUSTOM_ADVICE: s.custom?.explainer }))
-						.children(
-							group()
-								.title('Why is this Description Insufficient?')
-								.multiSelect('reason')
-								.children(
-									toggle('custom', 'Custom').children(
-										markdown('explainer')
-											.title('How can the author improve their description?')
-											.required(),
-									),
-									toggle('fork', 'Fork').message('piece/fork'),
-									toggle('unfinished', 'Unfinished').message('piece/unfinished'),
-									toggle('spoilers', 'Spoilers').message('piece/spoilers'),
-								),
-						)
-						.collect(
-							() =>
-								`insufficient/default/${project.value?.minecraft_java_server ? 'servers' : project.value?.project_types?.includes('modpack') ? 'packs' : 'projects'}`,
-						)
-						.rawMessage(async (state) => {
-							const reasons = state?.reason instanceof Set ? state.reason : new Set<string>()
-							return SHOW_SPOILER_ADVICE.some((reason) => reasons.has(reason))
-								? await md('checklist/messages/description/insufficient/piece/spoiler-guide')(state)
-								: ''
-						}),
+  return stage("description", "Description")
+    .hint("Is the description sufficient, accurate, and accessible?")
+    .guidance(
+      "https://www.notion.so/2e15ee711bf080e4a41df61bbab49892#2e15ee711bf080508042e70089dd787e",
+    )
+    .icon(LibraryIcon)
+    .navigate()
+    .children(
+      group()
+        .title("Description Issues?")
+        .children(
+          toggle("insufficient", "Insufficient")
+            .suggestedStatus("flagged")
+            .message("insufficient/header")
+            .children(
+              group()
+                .title("Why is this Description Insufficient?")
+                .children(
+                  toggle("custom", "Custom").children(
+                    markdown("explainer")
+                      .title("How can the author improve their description?")
+                      .required()
+                      .rawMessage((state) => `${state.value}\n\n`),
+                  ),
+                  toggle("fork", "Fork").message("piece/fork"),
+                  toggle("unfinished", "Unfinished").message("piece/unfinished"),
+                  toggle("spoilers", "Spoilers").message("piece/spoilers"),
+                ),
+            )
+            .collect(
+              () =>
+                `insufficient/default/${project.value?.minecraft_java_server ? "servers" : project.value?.project_types?.includes("modpack") ? "packs" : "projects"}`,
+            )
+            .rawMessage(async (state) => {
+              return SHOW_SPOILER_ADVICE.some((reason) => state?.[reason] === true)
+                ? await md("checklist/messages/description/insufficient/piece/spoiler-guide")(state)
+                : ""
+            }),
 
-					toggle('non-english', 'Non-english')
-						.suggestedStatus('flagged')
-						.severity('medium')
-						.message(() => `non-english${project.value.minecraft_java_server ? '-server' : ''}`)
-						.shown(
-							computed(() => {
-								return !(
-									!!project.value?.minecraft_java_server &&
-									!project.value.minecraft_server?.languages?.includes('en')
-								)
-							}),
-						),
+          toggle("non-english", "Non-english")
+            .suggestedStatus("flagged")
+            .message(() => `non-english${project.value.minecraft_java_server ? "-server" : ""}`)
+            .shown(
+              computed(() => {
+                return !(
+                  !!project.value?.minecraft_java_server &&
+                  !project.value.minecraft_server?.languages?.includes("en")
+                )
+              }),
+            ),
 
-					toggle('headers-as-body', 'Headers as body text')
-						.suggestedStatus('flagged')
-						.severity('low')
-						.message(),
+          toggle("headers-as-body", "Headers as body text")
+            .suggestedStatus("flagged")
+            .message(),
 
-					toggle('image-only', 'Image-only')
-						.suggestedStatus('flagged')
-						.severity('medium')
-						.message(),
+          toggle("image-only", "Image-only")
+            .suggestedStatus("flagged")
+            .message(),
 
-					toggle('non-standard-text', 'Non-standard text')
-						.suggestedStatus('flagged')
-						.severity('medium')
-						.message(),
+          toggle("non-standard-text", "Non-standard text")
+            .suggestedStatus("flagged")
+            .message(),
 
-					toggle('clarity', 'Unclear / Misleading')
-						.suggestedStatus('rejected')
-						.severity('high')
-						.message(),
-				),
-		)
+          toggle("clarity", "Unclear / Misleading")
+            .suggestedStatus("rejected")
+            .message(),
+        ),
+    )
 }
diff --git a/packages/moderation/src/data/stages/gallery.tsx b/packages/moderation/src/data/stages/gallery.tsx
index 2bfe4b1ca8..d845e43dd5 100644
--- a/packages/moderation/src/data/stages/gallery.tsx
+++ b/packages/moderation/src/data/stages/gallery.tsx
@@ -16,17 +16,15 @@ export default function () {
 		.navigate('/gallery')
 		.children(
 			group().children(
-				toggle('insufficient', 'Insufficient').suggestedStatus('flagged').severity('low').message(),
+				toggle('insufficient', 'Insufficient').suggestedStatus('flagged').message(),
 
 				toggle('not-relevant', 'Not relevant')
 					.shown(computed(() => project.value.gallery.length > 0))
 					.suggestedStatus('flagged')
-					.severity('low')
 					.message(),
 
 				toggle('showcase-clarity', 'Showcase Clarity')
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message(),
 			),
 		)
diff --git a/packages/moderation/src/data/stages/license.tsx b/packages/moderation/src/data/stages/license.tsx
index e595507dc6..3f4dc243b8 100644
--- a/packages/moderation/src/data/stages/license.tsx
+++ b/packages/moderation/src/data/stages/license.tsx
@@ -53,7 +53,6 @@ export default function () {
 				toggle('invalid-link', 'Invalid Link')
 					.shown(computed(() => !!project.value.license?.url))
 					.suggestedStatus('flagged')
-					.severity('medium')
 					.message()
 					.children(check('custom-license', 'Invalid Link: Custom License').message())
 					.collect(),
@@ -61,12 +60,11 @@ export default function () {
 				toggle('no-source', 'No Source')
 					.shown(needSource)
 					.suggestedStatus('rejected')
-					.severity('medium')
 					.rawMessage(async (state) => {
 						if (state.fork) return noSourceForkMsg(state)
 						return noSourceMsg(state)
 					})
-					.children(check('fork', 'No Source: Fork').severity('high')),
+					.children(check('fork', 'No Source: Fork')),
 			),
 		)
 }
diff --git a/packages/moderation/src/data/stages/links.tsx b/packages/moderation/src/data/stages/links.tsx
index 5110950ad8..1940a62fa8 100644
--- a/packages/moderation/src/data/stages/links.tsx
+++ b/packages/moderation/src/data/stages/links.tsx
@@ -4,14 +4,14 @@ import type { Ref } from 'vue'
 import { computed } from 'vue'
 
 import { group, md, mdOptional, stage, toggle } from '../../types/node'
-import type { ChildEntry, GroupNodeBuilder } from '../../types/node'
+import type { ChildEntry, GroupNode } from '../../types/node'
 import { promptSourceRequired } from '../..'
 
 export default function () {
 	const { projectV3: project } = injectProjectPageContext()
 	const linkNames: Record<string, string> = {}
 
-	type LinkSectionBuilder = GroupNodeBuilder & {
+	type LinkSectionBuilder = GroupNode & {
 		children(...extras: ChildEntry[]): LinkSectionBuilder
 		label(badge: Ref<boolean>): LinkSectionBuilder
 	}
@@ -75,7 +75,6 @@ export default function () {
 		.navigate('/settings/links')
 		.shown(computed(() => Object.keys(project.value.link_urls).length > 0))
 		.suggestedStatus('flagged')
-		.severity('low')
 		.rawMessage(async (state) => {
 			const sections = Object.entries(state).filter(
 				([, s]) => s && typeof s === 'object' && !(s instanceof Set),
diff --git a/packages/moderation/src/data/stages/metadata.tsx b/packages/moderation/src/data/stages/metadata.tsx
index 4aeda58cbf..2c71999d3c 100644
--- a/packages/moderation/src/data/stages/metadata.tsx
+++ b/packages/moderation/src/data/stages/metadata.tsx
@@ -3,7 +3,7 @@ import { DatabaseIcon } from '@modrinth/assets'
 import { ENVIRONMENTS_COPY, injectProjectPageContext, injectTags } from '@modrinth/ui'
 import { computed } from 'vue'
 
-import { dropdown, fix, group, md, option, stage, toggle } from '../../types/node'
+import { appComponent, dropdown, fix, group, md, option, stage, toggle } from '../../types/node'
 import { requiresEnvironmentInfo } from '../../utils'
 
 const loaderLabels: Record<string, string> = {
@@ -25,7 +25,9 @@ function formatLoaderLabel(id: string): string {
 
 export default function () {
 	const { projectV3: project } = injectProjectPageContext()
-	const { loaders } = injectTags()
+	const { loaders, gameVersions } = injectTags()
+
+			const currentGameVersions = computed(() => (project.value.game_versions as string[] | undefined) ?? [])
 
 	return (
 		stage('metadata', 'Metadata')
@@ -64,7 +66,6 @@ export default function () {
 					toggle('environment', 'Environment')
 						.shown(computed(() => requiresEnvironmentInfo(project.value.project_types)))
 						.suggestedStatus('flagged')
-						.severity('low')
 						.rawMessage(async (state) => {
 							const correctEnvironment = state?.['correct-environment'] as string | undefined
 
@@ -94,7 +95,7 @@ export default function () {
 								.title('Correct Environment')
 								.children(
 									dropdown('correct-environment')
-										.children(
+										.options(
 											...(Object.keys(ENVIRONMENTS_COPY) as Labrinth.Projects.v3.Environment[])
 												.filter((id) => id !== 'unknown')
 												.map((id) => option(id, ENVIRONMENTS_COPY[id].title.defaultMessage ?? id)),
@@ -103,67 +104,98 @@ export default function () {
 										.none('Unknown'),
 								),
 						),
-					// TODO: chyz, fix pls (make into single set of buttons where current loaders start selected and non current start non selected
-					//					toggle('loader', `Loader${project.value.loaders.length > 1 ? 's' : ''}`).children(
-					//						group()
-					//							.title('Loader Issues?')
-					//							.action(
-					//								action()
-					//									.suggestedStatus('flagged')
-					//									.severity('medium')
-					//									.message(async (state) => {
-					//										//TODO: chyz
-					//										//TODO: coolbot this one is a bit of a doozy
-					//										const header = await md('checklist/messages/metadata/loader/incorrect')(state)
-					//										const selected = state.loaders
-					//										if (selected instanceof Set && selected.size > 0) {
-					//											const list = [...selected]
-					//												.map((id) => `- ${formatLoaderLabel(id)}`)
-					//												.join('\n')
-					//											return `${header}\n${list}`
-					//										}
-					//										return header
-					//									}),
-					//							)
-					//							.children(
-					//								toggle('incorrect', 'Incorrect').children(
-					//									group()
-					//										.title('Incorrect Loaders')
-					//										.multiSelect('loaders')
-					//										.children(
-					//											...project.value.loaders.map((id) => option(id, formatLoaderLabel(id))),
-					//										),
-					//								),
-					// TODO: chyz, this should be the same interface as incorrect, as a corrections scheme, with selected loaders default on.
-					//								toggle('missing', 'Missing').children(
-					//									group()
-					//										.title('Missing Loaders')
-					//										.multiSelect('loaders')
-					//										.children(
-					//											...(() => {
-					//												//TODO: chyz maybe this can be done better
-					//												// (plugin loaders and datapack are marked as valid for mods which makes this suck)
-					//												const existingTypes = new Set(
-					//													loaders.value
-					//														.filter((l) => project.value.loaders.includes(l.name))
-					//														.flatMap((l) => l.supported_project_types),
-					//												)
-					//												const referenceTypes =
-					//													existingTypes.size > 0
-					//														? existingTypes
-					//														: new Set(project.value.project_types)
-					//												return loaders.value
-					//													.filter(
-					//														(loader) =>
-					//															loader.supported_project_types.every((t) => referenceTypes.has(t)) &&
-					//															!project.value.loaders.includes(loader.name),
-					//													)
-					//													.map((loader) => option(loader.name, formatLoaderLabel(loader.name)))
-					//											})(),
-					//									)/
-					// ),
-					//							),
-					//					),
+
+          toggle('dependencies', 'Dependencies')
+            .suggestedStatus('flagged')
+            .message(),
+
+					toggle('loader', 'Loaders (WIP)')
+						.suggestedStatus('flagged')
+						.rawMessage(async (state) => {
+							const selected =
+								state.loaders instanceof Set ? state.loaders : new Set(project.value.loaders)
+							const current = new Set(project.value.loaders)
+							const isCorrected =
+								selected.size !== current.size || [...selected].some((id) => !current.has(id))
+
+							let correct = ''
+							if (isCorrected) {
+								const list = [...selected].map((id) => formatLoaderLabel(id)).join(', ')
+								correct = await md('checklist/messages/metadata/loader/correction', () => ({
+									LOADERS: list || 'none',
+								}))(state)
+							}
+
+							return md('checklist/messages/metadata/loader/inaccurate', () => ({
+								CORRECT: correct,
+							}))(state)
+						})
+						.fix(
+							fix().project((patch, state) => {
+								const selected =
+									state.loaders instanceof Set ? state.loaders : new Set(project.value.loaders)
+								const next = [...selected]
+								const current = project.value.loaders
+								if (next.length === current.length && next.every((id) => current.includes(id)))
+									return
+								patch.loaders = next
+							}),
+						)
+						.children(
+							appComponent('loaders', 'loader-picker')
+								.valueKind('set')
+								.initial(() => new Set(project.value.loaders))
+								.props((ctx) => ({
+									loaders: loaders.value,
+									toggleLoader: ctx.toggleSetValue,
+								})),
+						),
+
+					toggle('game-version', 'Game Versions (WIP)')
+						.suggestedStatus('flagged')
+						.rawMessage(async (state) => {
+							const selected =
+								state['game-versions'] instanceof Set
+									? state['game-versions']
+									: new Set(currentGameVersions.value)
+							const current = new Set(currentGameVersions.value)
+							const isCorrected =
+								selected.size !== current.size || [...selected].some((id) => !current.has(id))
+
+							let correct = ''
+							if (isCorrected) {
+								const list = [...selected].join(', ')
+								correct = await md('checklist/messages/metadata/game-version/correction', () => ({
+									GAME_VERSIONS: list || 'none',
+								}))(state)
+							}
+
+							return md('checklist/messages/metadata/game-version/inaccurate', () => ({
+								CORRECT: correct,
+							}))(state)
+						})
+						.fix(
+							fix().project((patch, state) => {
+								const selected =
+									state['game-versions'] instanceof Set
+										? state['game-versions']
+										: new Set(currentGameVersions.value)
+								const next = [...selected]
+								const current = currentGameVersions.value
+								if (next.length === current.length && next.every((id) => current.includes(id)))
+									return
+								patch.game_versions = next
+							}),
+						)
+						.children(
+							appComponent('game-versions', 'game-version-picker')
+								.valueKind('set')
+								.initial(() => new Set(currentGameVersions.value))
+								.props(() => ({
+									gameVersions: gameVersions.value,
+									noHeader: true,
+								})),
+						),
 				),
 			)
 	)
diff --git a/packages/moderation/src/data/stages/permissions.tsx b/packages/moderation/src/data/stages/permissions.tsx
index 4baad99d57..a1d4822989 100644
--- a/packages/moderation/src/data/stages/permissions.tsx
+++ b/packages/moderation/src/data/stages/permissions.tsx
@@ -1,11 +1,30 @@
+import type { Labrinth } from '@modrinth/api-client'
 import { SignatureIcon } from '@modrinth/assets'
-import { injectProjectPageContext } from '@modrinth/ui'
+import { injectModrinthClient, injectProjectPageContext } from '@modrinth/ui'
+import { useQuery } from '@tanstack/vue-query'
 import { computed } from 'vue'
 
 import { group, stage, toggle } from '../../types/node'
 
+function isResolved(attributionGroup: Labrinth.Attribution.Internal.AttributionGroup): boolean {
+	const attribution = attributionGroup.attribution
+	if (!attribution) return false
+	if (attribution.kind === 'globally_allowed') return true
+	return attribution.moderation_status?.kind === 'approved'
+}
+
 export default function () {
 	const { projectV3: project } = injectProjectPageContext()
+	const { labrinth } = injectModrinthClient()
+
+	const { data: attributionData } = useQuery({
+		queryKey: ['project-attribution', project.value.id],
+		queryFn: () => labrinth.attribution_internal.listProjectAttribution(project.value.id),
+	})
+
+	const unresolvedCount = computed(
+		() => (attributionData.value ?? []).filter((g) => !isResolved(g)).length,
+	)
 
 	return stage('permissions', 'Modpack Permissions')
 		.hint("Does this project's external content have any issues?")
@@ -16,30 +35,28 @@ export default function () {
 			computed(
 				() =>
 					(project.value.project_types?.includes('modpack') ?? false) &&
-					!project.value.minecraft_server,
+					!project.value.minecraft_server &&
+					unresolvedCount.value > 0,
 			),
 		)
+		.sticky()
 		.children(
 			group().children(
 				toggle('invalid-permissions', 'Invalid permissions')
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message(),
 
 				toggle('prohibited-external-content', 'Prohibited externals')
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message(),
 
 				toggle('missing-permissions', 'Missing permissions')
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message(),
 
 				toggle('non-commercial-external-content', 'Non-commercial externals')
 					.shown(computed(() => project.value.monetization_status === 'monetized'))
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message(),
 			),
 		)
diff --git a/packages/moderation/src/data/stages/post-approval.tsx b/packages/moderation/src/data/stages/post-approval.tsx
index 7ed9d3ecc4..1f46bce096 100644
--- a/packages/moderation/src/data/stages/post-approval.tsx
+++ b/packages/moderation/src/data/stages/post-approval.tsx
@@ -3,6 +3,7 @@ import { injectProjectPageContext } from '@modrinth/ui'
 import { computed } from 'vue'
 
 import { group, stage, text, toggle } from '../../types/node'
+import {Priorities} from "../priorities.ts";
 
 //TODO chyz
 //TODO coolbot needs discussion
@@ -20,15 +21,15 @@ export default function () {
 			group().children(
 				toggle('issue-warning', 'Issue warning')
 					.suggestedStatus('approved')
-					.severity('low')
-					.message(),
+					.message()
+          .priority(Priorities.tempLast),
 
 				toggle('missed-deadline', 'Missed due date')
 					.suggestedStatus('flagged')
-					.severity('high')
-					.message(undefined, (state) => ({
+					.message((state) => ({
 						STATUS: state.status,
 					}))
+          .priority(Priorities.tempLast)
 					.children(
 						//TODO: chyz this shouldn't need to be provided by moderator
 						text('status').title('What status is the project being set to?').required(),
@@ -36,35 +37,31 @@ export default function () {
 
 				toggle('metadata-issue', 'Incorrect metadata')
 					.suggestedStatus('approved')
-					.severity('low')
 					.message()
 					.children(
 						toggle('dependencies', 'Missing Dependencies')
-							.severity('low')
-							.message(undefined, (state) => ({
-								DEPENDENCY_NAME: state['dependency-name'],
-								DEPENDENCY_LINK: state['dependency-link'],
+							.message((state) => ({
+								DEPENDENCY_NAME: state['name'],
+								DEPENDENCY_LINK: state['link'],
 							}))
 							.children(
-								text('dependency-name').title('Dependency name').required(),
-								text('dependency-link').title('Dependency link').required(),
+								text('name').title('Dependency name').required(),
+								text('link').title('Dependency link').required(),
 							),
 
 						toggle('mc-versions', 'Game versions')
-							.severity('low')
-							.message(undefined, (state) => ({
+							.message((state) => ({
 								SPECIFICS: state.specifics,
 							}))
 							.children(text('specifics').title('More details about the game versions issue?')),
 
 						toggle('loaders', 'Loaders')
-							.severity('low')
-							.message(undefined, (state) => ({
+							.message((state) => ({
 								SPECIFICS: state.specifics,
 							}))
 							.children(text('specifics').title('More details about the loaders issue?')),
 
-						toggle('license', 'Inconsistent Licensing').severity('low').message(),
+						toggle('license', 'Inconsistent Licensing').message(),
 					)
 					.collect(),
 			),
diff --git a/packages/moderation/src/data/stages/re-review.tsx b/packages/moderation/src/data/stages/re-review.tsx
index 0d1fd7d00e..5df78e78dd 100644
--- a/packages/moderation/src/data/stages/re-review.tsx
+++ b/packages/moderation/src/data/stages/re-review.tsx
@@ -32,12 +32,10 @@ export default function () {
 			group().children(
 				toggle('ignored', 'Yes')
 					.suggestedStatus('flagged')
-					.severity('medium')
 					.message()
 					.children(
 						toggle('warning', 'Multiple times in a row')
 							.suggestedStatus('rejected')
-							.severity('high')
 							.message(),
 					)
 					.collect(),
diff --git a/packages/moderation/src/data/stages/reupload.tsx b/packages/moderation/src/data/stages/reupload.tsx
index aa7906e97e..32df3e764f 100644
--- a/packages/moderation/src/data/stages/reupload.tsx
+++ b/packages/moderation/src/data/stages/reupload.tsx
@@ -20,14 +20,13 @@ export default function () {
 			'https://www.notion.so/2e15ee711bf080e4a41df61bbab49892#2e35ee711bf080d1a0a2cda3ff2ce997',
 		)
 		.icon(CopyrightIcon)
-		.navigate('/')
+		.navigate()
 		.children(
 			group().children(
 				toggle('reupload', 'Re-upload')
 					.shown(computed(() => !project.value.minecraft_server))
 					.suggestedStatus('rejected')
-					.severity('high')
-					.message(undefined, (state) => ({
+					.message((state) => ({
 						ORIGINAL_PROJECT: state['original-project'],
 						ORIGINAL_AUTHOR: state['original-author'],
 					}))
@@ -39,25 +38,21 @@ export default function () {
 				toggle('unclear-fork', 'Unclear Fork')
 					.shown(computed(() => !project.value.minecraft_server))
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message(),
 
 				toggle('insufficient-fork', 'Insufficient Fork')
 					.shown(computed(() => !project.value.minecraft_server))
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message(),
 
 				toggle('request-proof', 'Proof of permissions')
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message(),
 
 				toggle('identity-verification', 'Verify Identity')
 					.shown(computed(() => !project.value.minecraft_server))
 					.suggestedStatus('rejected')
-					.severity('high')
-					.message(undefined, (state) => ({
+					.message((state) => ({
 						PLATFORM: state.platform,
 					}))
 					.children(text('platform').title('Where else can the project be found?').required()),
@@ -65,8 +60,7 @@ export default function () {
 				toggle('identity-verification-server', 'Verify Identity')
 					.shown(computed(() => !!project.value.minecraft_server))
 					.suggestedStatus('rejected')
-					.severity('high')
-					.message(undefined, (state) => ({
+					.message((state) => ({
 						CONTACT: state.contact,
 					}))
 					.children(text('contact').title('Known public contact method').required()),
@@ -74,17 +68,15 @@ export default function () {
 				toggle('request-proof-server', 'Reuploaded pack')
 					.shown(isServerModpack)
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message(),
 
 				toggle('custom-pack-verification', 'Override verification')
 					.shown(isServerModpack)
 					.suggestedStatus('rejected')
-					.severity('high')
 					.message()
 					.children(
 						check('list', 'List overrides?')
-							.message(undefined, (state) => ({
+							.message((state) => ({
 								OVERRIDES: state.overrides,
 							}))
 							.children(markdown('overrides').title('Add list of overrides.')),
@@ -94,8 +86,7 @@ export default function () {
 				toggle('custom-pack-prohibited', 'Forbidden Overrides')
 					.shown(isServerModpack)
 					.suggestedStatus('rejected')
-					.severity('high')
-					.message(undefined, (state) => ({
+					.message((state) => ({
 						OVERRIDES: state.overrides,
 					}))
 					.children(markdown('overrides').title('Forbidden overrides list').required()),
diff --git a/packages/moderation/src/data/stages/other-rules.tsx b/packages/moderation/src/data/stages/rules.tsx
similarity index 56%
rename from packages/moderation/src/data/stages/other-rules.tsx
rename to packages/moderation/src/data/stages/rules.tsx
index 484d158c86..195f59f012 100644
--- a/packages/moderation/src/data/stages/other-rules.tsx
+++ b/packages/moderation/src/data/stages/rules.tsx
@@ -2,9 +2,8 @@ import { ListBulletedIcon } from '@modrinth/assets'
 import { injectProjectPageContext } from '@modrinth/ui'
 import { computed } from 'vue'
 
-import { group, markdown, option, stage, toggle } from '../../types/node'
+import { toggle, group, markdown, stage } from '../../types/node'
 
-//TODO: coolbot have fun :3
 export default function () {
 	const { projectV3: project } = injectProjectPageContext()
 
@@ -20,61 +19,53 @@ export default function () {
 				toggle('paid-access-server', 'Paid access server')
 					.shown(computed(() => !!project.value.minecraft_server))
 					.suggestedStatus('rejected')
-					.severity('critical')
 					.message(),
 
-				// TODO: chyz, the lists built by these message have empty line gaps.
 				toggle('prohibited-content', 'Prohibited Content')
 					.suggestedStatus('rejected')
-					.severity('critical')
 					.message('prohibited-content-header')
 					.collect()
 					.children(
 						group()
-							.multiSelect('options')
 							.title('Which Prohibited Content rules does this project violate?')
 							.children(
-								option('objectionable', 'Objectionable').message(),
-								option('discriminatory', 'Discriminatory or Explicit').message(),
-								option('ip-infringement', 'IP Infringement').message(),
-								option('legal-rights', 'Rights Violation').message(),
-								option('illegal-activity', 'Illegal Activity').message(),
-								option('harmful', 'Harmful or Deceptive').message(),
-								option('misleading', 'Misleading claims').message(),
-								option('impersonation', 'Impersonation').message(),
-								option('false-endorsement', 'False Endorsement').message(),
-								option('profanity', 'Profanity').message(),
-								option('undisclosed-upload', 'Undisclosed Data Upload').message(),
-								option('mojang-bypass', 'Mojang Bypass').message(),
+								toggle('objectionable', 'Objectionable').message(),
+								toggle('discriminatory', 'Discriminatory or Explicit').message(),
+								toggle('ip-infringement', 'IP Infringement').message(),
+								toggle('legal-rights', 'Rights Violation').message(),
+								toggle('illegal-activity', 'Illegal Activity').message(),
+								toggle('harmful', 'Harmful or Deceptive').message(),
+								toggle('misleading', 'Misleading claims').message(),
+								toggle('impersonation', 'Impersonation').message(),
+								toggle('false-endorsement', 'False Endorsement').message(),
+								toggle('profanity', 'Profanity').message(),
+								toggle('undisclosed-upload', 'Undisclosed Data Upload').message(),
+								toggle('mojang-bypass', 'Mojang Bypass').message(),
 							),
 					),
 
 				toggle('cheat-or-hack-advertising', 'Hacks')
 					.suggestedStatus('rejected')
-					.severity('critical')
 					.message(),
 
 				toggle('server-side-opt-out', 'Opt-out')
 					.suggestedStatus('flagged')
-					.severity('high')
 					.message(),
 
 				toggle('server-side-opt-in', 'Opt-in')
 					.suggestedStatus('flagged')
-					.severity('high')
 					.message('server-side-opt-in-header')
 					.collect()
 					.children(
 						group()
-							.multiSelect('options')
 							.title('Which features require a Server-side Opt-in?')
 							.children(
-								option('x-ray', 'X-ray').message(),
-								option('aim-bot', 'Aim Assist').message(),
-								option('movement', 'Movement').message(),
-								option('pvp', 'PvP').message(),
-								option('hiding-mods', 'Anti 3.x').message(),
-								option('item-duplication', 'Dupe').message(),
+								toggle('x-ray', 'X-ray').message(),
+								toggle('aim-bot', 'Aim Assist').message(),
+								toggle('movement', 'Movement').message(),
+								toggle('pvp', 'PvP').message(),
+								toggle('hiding-mods', 'Anti 3.x').message(),
+								toggle('item-duplication', 'Dupe').message(),
 							),
 					),
 
@@ -88,14 +79,11 @@ export default function () {
 						),
 					)
 					.suggestedStatus('flagged')
-					.severity('low')
 					.message(),
 
 				toggle('rule-breaking-other', 'Other')
-					// TODO: chyz, the required asterisk is on a separate line
 					.suggestedStatus('rejected')
-					.severity('critical')
-					.message(undefined, (state) => ({ MESSAGE: state.message }))
+					.message((state) => ({ MESSAGE: state.message }))
 					.children(
 						markdown('message').title('Explain how it infringes on content rules.').required(),
 					),
diff --git a/packages/moderation/src/data/stages/status-alerts.tsx b/packages/moderation/src/data/stages/status-alerts.tsx
index af957987c6..4536d7282e 100644
--- a/packages/moderation/src/data/stages/status-alerts.tsx
+++ b/packages/moderation/src/data/stages/status-alerts.tsx
@@ -3,22 +3,12 @@ import { injectProjectPageContext } from '@modrinth/ui'
 import type { Ref } from 'vue'
 import { computed } from 'vue'
 
-import type { NodeState, StageNodeBuilder } from '../../types/node'
-import {
-	NodeBuilder,
-	getBooleanChildState,
-	group,
-	isNodeActive,
-	md,
-	resolveChildren,
-	stage,
-	toggle,
-	walkNodes,
-} from '../../types/node'
+import type { ChildNode, NodeState, StageNode } from '../../types/node'
+import { externalGroup, getBooleanChildState, group, isNodeActive, md, resolveChildren, stage, toggle, walkNodes } from '../../types/node'
 import { Priorities } from '../priorities.ts'
 
 export default function (
-	mainStages: StageNodeBuilder[],
+	mainStages: StageNode[],
 	globalState: Ref<Record<string, Record<string, NodeState>>>,
 ) {
 	const { projectV3: project } = injectProjectPageContext()
@@ -47,23 +37,23 @@ export default function (
 					.priority(Priorities.alerts)
 					.applyFixes()
 					.children(
-						computed<NodeBuilder | null>(() => {
-							const fixNodes: NodeBuilder[] = []
+						computed<ChildNode | null>(() => {
+							const fixGroups: ChildNode[] = []
 							walkNodes(
 								[group().children(...mainStages)],
 								(globalState.value ?? {}) as unknown as Record<string, NodeState>,
-								(node, nodeState) => {
-									if (!node._fixes.length) return
+								(node, nodeState, _localState, path) => {
+									if (!('_fixes' in node) || !(node as { _fixes: unknown[] })._fixes.length) return
 									if (!isNodeActive(node, nodeState)) return
-									const childState = getBooleanChildState(nodeState)
-									fixNodes.push(
-										...resolveChildren(node, childState).filter(
-											(c): c is NodeBuilder => c instanceof NodeBuilder,
-										),
+									const children = resolveChildren(node as never, getBooleanChildState(nodeState)).filter(
+										(c): c is Exclude<ChildNode, string | (() => unknown)> =>
+											typeof c === 'object' && c !== null,
 									)
+									if (children.length === 0) return
+									fixGroups.push(externalGroup(path).children(...children))
 								},
 							)
-							return fixNodes.length > 0 ? group().children(...fixNodes) : null
+							return fixGroups.length > 0 ? group().children(...fixGroups) : null
 						}),
 					),
 
diff --git a/packages/moderation/src/data/stages/summary.tsx b/packages/moderation/src/data/stages/summary.tsx
index 050c7451c8..44b156b807 100644
--- a/packages/moderation/src/data/stages/summary.tsx
+++ b/packages/moderation/src/data/stages/summary.tsx
@@ -31,20 +31,17 @@ export default function () {
 					toggle('insufficient', 'Insufficient')
 						.enabled((state) => !state['repeat-title'])
 						.suggestedStatus('flagged')
-						.severity('low')
 						.message(),
 
 					toggle('repeat-title', 'Repeat of Title')
 						.enabled((state) => !state.insufficient)
 						.suggestedStatus('flagged')
-						.severity('low')
 						.message(),
 
-					toggle('formatting', 'Formatting').suggestedStatus('flagged').severity('low').message(),
+					toggle('formatting', 'Formatting').suggestedStatus('flagged').message(),
 
 					toggle('non-english', 'Non-english')
 						.suggestedStatus('flagged')
-						.severity('medium')
 						.message()
 						.shown(
 							computed(() => {
@@ -62,7 +59,6 @@ export default function () {
 					toggle('repeat-ip', 'Repeat of IP')
 						.shown(computed(() => !!project.value?.minecraft_server))
 						.suggestedStatus('flagged')
-						.severity('medium')
 						.message(),
 				),
 		)
diff --git a/packages/moderation/src/data/stages/title-slug.tsx b/packages/moderation/src/data/stages/title-slug.tsx
index 8844416aa9..c6e2130f45 100644
--- a/packages/moderation/src/data/stages/title-slug.tsx
+++ b/packages/moderation/src/data/stages/title-slug.tsx
@@ -1,340 +1,297 @@
-import type { Labrinth } from '@modrinth/api-client'
-import { ModrinthApiError } from '@modrinth/api-client'
-import {
-	BookOpenIcon,
-	TagCategoryRefreshCcwIcon,
-	TagCategoryWandSparklesIcon,
-	UserPlusIcon,
-} from '@modrinth/assets'
-import { Alert, injectModrinthClient, injectProjectPageContext } from '@modrinth/ui'
-import { useQueryClient } from '@tanstack/vue-query'
-import { computed, ref, watch } from 'vue'
+import type {Labrinth} from "@modrinth/api-client"
+import {ModrinthApiError} from "@modrinth/api-client"
+import {BookOpenIcon, TagCategoryRefreshCcwIcon, TagCategoryWandSparklesIcon, UserPlusIcon, WrenchIcon} from "@modrinth/assets"
+import {Alert, injectModrinthClient, injectProjectPageContext, ProjectStatusLink} from "@modrinth/ui"
+import {useQueryClient} from "@tanstack/vue-query"
+import {computed, ref, watch} from "vue"
 
-import { md, type NodeState } from '../../types/node'
-import { button, fix, group, option, stage, text, toggle } from '../../types/node'
+import {check, fix, group, md, stage, text, toggle} from "../../types/node"
 
 const STALE_TIME = 1000 * 60 * 5
 
-type AutoSlugStatus = 'loading' | 'available' | 'unavailable'
-type SlugValidation = 'checking' | 'available' | 'unchanged' | 'taken' | null
+type AutoSlugStatus = "loading" | "available" | "unavailable"
+type SlugValidation = "checking" | "available" | "unchanged" | "taken" | "empty" | "invalid" | null
 
 //TODO: make this not a copy of frontend/src/utils/slugs.generateUrlSlug
 // (as in move the other one so we can use it here)
 function generateUrlSlug(value: string) {
-	return value
-		.trim()
-		.toLowerCase()
-		.replaceAll(' ', '-')
-		.replaceAll(/[^a-zA-Z0-9._-]/g, '')
-		.replaceAll(/--+/gm, '-')
+  return value
+    .trim()
+    .toLowerCase()
+    .replaceAll(" ", "-")
+    .replaceAll(/[^a-zA-Z0-9._-]/g, "")
+    .replaceAll(/--+/gm, "-")
 }
 
 function hasCustomSlug(project: Labrinth.Projects.v3.Project) {
-	return generateUrlSlug(project.name) !== project.slug
+  return generateUrlSlug(project.name) !== project.slug
 }
 
 export default function () {
-	const { projectV3: project } = injectProjectPageContext()
-	const client = injectModrinthClient()
-	const queryClient = useQueryClient()
+  const {projectV3: project} = injectProjectPageContext()
+  const client = injectModrinthClient()
+  const queryClient = useQueryClient()
 
-	const autoSlugStatus = ref<AutoSlugStatus>('loading')
-	const resolvedAutoSlug = ref<string | null>(null)
-	const correctSlugConflict = ref<Labrinth.Projects.v3.Project | null>(null)
-	const autoSlugConflict = ref<Labrinth.Projects.v3.Project | null>(null)
-	const ownerUsername = ref<string | null>(null)
-	const slugValidation = ref<SlugValidation>(null)
-	let slugDebounceTimer: ReturnType<typeof setTimeout> | undefined
+  const autoSlugStatus = ref<AutoSlugStatus>("loading")
+  const resolvedAutoSlug = ref<string | null>(null)
+  const correctSlugConflict = ref<Labrinth.Projects.v3.Project | null>(null)
+  const autoSlugConflict = ref<Labrinth.Projects.v3.Project | null>(null)
+  const ownerUsername = ref<string | null>(null)
+  const slugValidation = ref<SlugValidation>(null)
+  let slugDebounceTimer: ReturnType<typeof setTimeout> | undefined
 
-	function currentSlug(state: Record<string, NodeState>) {
-		return (
-			(state['correct-slug'] as string | undefined) ?? resolvedAutoSlug.value ?? project.value.slug
-		)
-	}
+  async function checkSlugTaken(slug: string): Promise<Labrinth.Projects.v3.Project | null> {
+    try {
+      return await queryClient.fetchQuery({
+        queryKey: ["project", "v3", slug],
+        queryFn: () => client.labrinth.projects_v3.get(slug),
+        staleTime: STALE_TIME,
+      })
+    } catch (e) {
+      if (e instanceof ModrinthApiError && e.statusCode === 404) return null
+      throw e
+    }
+  }
 
-	async function checkSlugTaken(slug: string): Promise<Labrinth.Projects.v3.Project | null> {
-		try {
-			return await queryClient.fetchQuery({
-				queryKey: ['project', 'v3', slug],
-				queryFn: () => client.labrinth.projects_v3.get(slug),
-				staleTime: STALE_TIME,
-			})
-		} catch (e) {
-			if (e instanceof ModrinthApiError && e.statusCode === 404) return null
-			throw e
-		}
-	}
+  const SlugStatus = () => {
+    const v =
+      slugValidation.value ??
+      (autoSlugStatus.value === "loading"
+        ? "checking"
+        : autoSlugStatus.value === "unavailable"
+          ? "taken"
+          : "available")
+    if (v === "checking")
+      return (
+        <Alert type="checking" class="w-full">
+          Checking availability…
+        </Alert>
+      )
+    if (v === "unchanged")
+      return (
+        <Alert type="warning" class="w-full">
+          Already the current slug
+        </Alert>
+      )
+    if (v === "available")
+      return (
+        <Alert type="success" class="w-full">
+          Slug is available
+        </Alert>
+      )
+    if (v === "empty")
+      return (
+        <Alert type="error" class="w-full">
+          Slug cannot be empty
+        </Alert>
+      )
+    if (v === "invalid")
+      return (
+        <Alert type="error" class="w-full">
+          Invalid Slug
+        </Alert>
+      )
+    const by = correctSlugConflict.value
+    return (
+      <Alert type="error" class="w-full">
+        <div class="flex flex-wrap items-center gap-1.5">
+          Slug taken
+          {by ? <ProjectStatusLink project={by} newTab/> : null}
+        </div>
+      </Alert>
+    )
+  }
 
-	const SlugStatus = () => {
-		const v = slugValidation.value
-		if (v === null) return null
-		if (v === 'checking')
-			return (
-				<Alert type="checking" class="w-full">
-					Checking availability…
-				</Alert>
-			)
-		if (v === 'unchanged')
-			return (
-				<Alert type="warning" class="w-full">
-					Already the current slug
-				</Alert>
-			)
-		if (v === 'available')
-			return (
-				<Alert type="success" class="w-full">
-					Slug is available
-				</Alert>
-			)
-		const by = correctSlugConflict.value
-		return (
-			<Alert type="error" class="w-full">
-				Slug taken
-				{by ? (
-					<>
-						{' by '}
-						<a href={`/project/${by.slug}`} target="_blank" class="underline">
-							{by.name}
-						</a>
-						{` (${by.status})`}
-					</>
-				) : null}
-			</Alert>
-		)
-	}
+  watch(
+    [() => project.value.name, () => project.value.slug],
+    async ([name]) => {
+      clearTimeout(slugDebounceTimer)
+      autoSlugStatus.value = "loading"
+      resolvedAutoSlug.value = null
+      correctSlugConflict.value = null
+      autoSlugConflict.value = null
+      slugValidation.value = null
 
-	watch(
-		[() => project.value.name, () => project.value.slug],
-		async ([name]) => {
-			clearTimeout(slugDebounceTimer)
-			autoSlugStatus.value = 'loading'
-			resolvedAutoSlug.value = null
-			correctSlugConflict.value = null
-			autoSlugConflict.value = null
-			slugValidation.value = null
+      if (!hasCustomSlug(project.value)) {
+        autoSlugStatus.value = "available"
+        resolvedAutoSlug.value = generateUrlSlug(name)
+        return
+      }
 
-			if (!hasCustomSlug(project.value)) {
-				autoSlugStatus.value = 'available'
-				resolvedAutoSlug.value = generateUrlSlug(name)
-				return
-			}
+      const autoSlug = generateUrlSlug(name)
 
-			const autoSlug = generateUrlSlug(name)
+      try {
+        const [conflict, members] = await Promise.all([
+          checkSlugTaken(autoSlug),
+          ownerUsername.value === null
+            ? queryClient.fetchQuery({
+              queryKey: ["project", project.value.id, "members"],
+              queryFn: () => client.labrinth.projects_v3.getMembers(project.value.id),
+              staleTime: STALE_TIME,
+            })
+            : null,
+        ])
 
-			try {
-				const [conflict, members] = await Promise.all([
-					checkSlugTaken(autoSlug),
-					ownerUsername.value === null
-						? queryClient.fetchQuery({
-								queryKey: ['project', project.value.id, 'members'],
-								queryFn: () => client.labrinth.projects_v3.getMembers(project.value.id),
-								staleTime: STALE_TIME,
-							})
-						: null,
-				])
+        if (members) {
+          const owner = members.find((m) => m.is_owner) ?? members[0]
+          ownerUsername.value = owner
+            ? owner.user.username.toLowerCase().replaceAll(/[^a-z0-9-]/g, "") || null
+            : null
+        }
 
-				if (members) {
-					const owner = members.find((m) => m.is_owner) ?? members[0]
-					ownerUsername.value = owner
-						? owner.user.username.toLowerCase().replaceAll(/[^a-z0-9-]/g, '') || null
-						: null
-				}
+        if (!conflict) {
+          resolvedAutoSlug.value = autoSlug
+          autoSlugStatus.value = "available"
+          return
+        }
 
-				if (!conflict) {
-					resolvedAutoSlug.value = autoSlug
-					autoSlugStatus.value = 'available'
-					return
-				}
+        autoSlugConflict.value = conflict
 
-				autoSlugConflict.value = conflict
+        if (ownerUsername.value) {
+          const withUser = `${autoSlug}-${ownerUsername.value}`
+          const conflict2 = await checkSlugTaken(withUser)
+          if (!conflict2) {
+            resolvedAutoSlug.value = withUser
+            autoSlugStatus.value = "available"
+            return
+          }
+        }
+      } catch {
+      }
 
-				if (ownerUsername.value) {
-					const withUser = `${autoSlug}-${ownerUsername.value}`
-					const conflict2 = await checkSlugTaken(withUser)
-					if (!conflict2) {
-						resolvedAutoSlug.value = withUser
-						autoSlugStatus.value = 'available'
-						return
-					}
-				}
-			} catch {}
+      autoSlugStatus.value = "unavailable"
+    },
+    {immediate: true},
+  )
 
-			autoSlugStatus.value = 'unavailable'
-		},
-		{ immediate: true },
-	)
+  return stage("title-slug", "Title & Slug")
+    .hint("Are the Name and URL accurate and appropriate?")
+    .guidance(
+      "https://www.notion.so/2e15ee711bf080e4a41df61bbab49892#2e15ee711bf0803c9660e90f0fead705",
+    )
+    .icon(BookOpenIcon)
+    .children(
+      () => {
+        if (!hasCustomSlug(project.value)) {
+          return (
+            <div class="markdown-body w-full">
+              <strong>Title:</strong> {project.value.name}
+            </div>
+          )
+        }
+        const by = autoSlugConflict.value
+        return (
+          <div class="markdown-body w-full">
+            <strong>Title:</strong> {project.value.name}
+            <br/>
+            <strong>Slug:</strong> <code>{project.value.slug}</code>
+            <br/>
+            <strong>Slug Taken:</strong>{" "}
+            {autoSlugStatus.value === "loading" ? (
+              "..."
+            ) : by ? (
+              <ProjectStatusLink project={by} newTab/>
+            ) : (
+              "No"
+            )}
+          </div>
+        )
+      },
 
-	return stage('title-slug', 'Title & Slug')
-		.hint('Are the Name and URL accurate and appropriate?')
-		.guidance(
-			'https://www.notion.so/2e15ee711bf080e4a41df61bbab49892#2e15ee711bf0803c9660e90f0fead705',
-		)
-		.icon(BookOpenIcon)
-		.children(
-			() => {
-				if (!hasCustomSlug(project.value)) {
-					return (
-						<div class="markdown-body w-full">
-							<strong>Title:</strong> {project.value.name}
-						</div>
-					)
-				}
-				const by = autoSlugConflict.value
-				return (
-					<div class="markdown-body w-full">
-						<strong>Title:</strong> {project.value.name}
-						<br />
-						<strong>Slug:</strong> <code>{project.value.slug}</code>
-						<br />
-						<strong>Slug Taken:</strong>{' '}
-						{autoSlugStatus.value === 'loading' ? (
-							'...'
-						) : by ? (
-							<>
-								<a href={`/project/${by.slug}`} target="_blank" class="underline">
-									{by.name}
-								</a>
-								{` (${by.status})`}
-							</>
-						) : (
-							'No'
-						)}
-					</div>
-				)
-			},
+      group("title")
+        .title("Title Issues?")
+        .children(
+          toggle("useless-info", "Contains Useless Info").suggestedStatus("flagged").message(),
 
-			group('title')
-				.title('Title Issues?')
-				.children(
-					toggle('useless-info', 'Contains Useless Info')
-						.suggestedStatus('flagged')
-						.severity('low')
-						.message(),
+          toggle("minecraft-branding", "Minecraft Title").suggestedStatus("flagged").message(),
 
-					toggle('minecraft-branding', 'Minecraft Title')
-						.suggestedStatus('flagged')
-						.severity('medium')
-						.message(),
+          toggle("similarities", "Title Similarities")
+            .suggestedStatus("flagged")
+            .message()
+            .children(
+              group()
+                .title("Similarities Additional Info")
+                .children(
+                  check("modpack", "Modpack Named After Mod")
+                    .shown(computed(() => project.value.project_types.includes("modpack")))
+                    .message(),
 
-					toggle('similarities', 'Title Similarities')
-						.suggestedStatus('flagged')
-						.severity('medium')
-						.message()
-						.children(
-							group()
-								.title('Similarities Additional Info')
-								.multiSelect('options')
-								.children(
-									option('modpack', 'Modpack Named After Mod')
-										.shown(computed(() => project.value.project_types.includes('modpack')))
-										.message(),
+                  check("fork", "Forked Project")
+                    .shown(computed(() => !project.value?.minecraft_server))
+                    .message(),
+                ),
+            )
+            .collect(),
+        ),
 
-									option('fork', 'Forked Project')
-										.shown(computed(() => !project.value?.minecraft_server))
-										.message(),
-								),
-						)
-						.collect(),
-				),
+      group("slug")
+        .title("Slug Issues")
+        .shown(computed(() => hasCustomSlug(project.value)))
+        .children(
+          group().children(
+            toggle("misused", "Misused")
+              .children(
+                group()
+                  .title("Correct Slug")
+                  .children(
+                    text("correct-slug")
+                      .initial(() => resolvedAutoSlug.value ?? project.value.slug ?? "")
+                      .onChange((value) => {
+                        clearTimeout(slugDebounceTimer)
+                        if (value === project.value.slug) {
+                          slugValidation.value = "unchanged"
+                          return
+                        }
+                        if (!value) {
+                          slugValidation.value = "empty"
+                          correctSlugConflict.value = null
+                          return
+                        }
+                        if (generateUrlSlug(value) !== value) {
+                          slugValidation.value = "invalid"
+                          correctSlugConflict.value = null
+                          return
+                        }
+                        slugValidation.value = "checking"
+                        slugDebounceTimer = setTimeout(async () => {
+                          const conflict = await checkSlugTaken(value).catch(() => null)
+                          if (conflict !== null && conflict.id !== project.value.id) {
+                            correctSlugConflict.value = conflict
+                            slugValidation.value = "taken"
+                          } else {
+                            correctSlugConflict.value = null
+                            slugValidation.value = "available"
+                          }
+                        }, 400)
+                      })
+                      .tweak(TagCategoryWandSparklesIcon, () => autoSlugStatus.value === "available" ? resolvedAutoSlug.value : null)
+                      .tweak(UserPlusIcon, (current) => ownerUsername.value && !current?.includes(ownerUsername.value) ? `${current}-${ownerUsername.value}` : null)
+                      .tweak(WrenchIcon, (current) => generateUrlSlug(current ?? ""))
+                      .tweak(TagCategoryRefreshCcwIcon, () => project.value.slug),
 
-			group('slug')
-				.title('Slug Issues')
-				.shown(computed(() => hasCustomSlug(project.value)))
-				.children(
-					group()
-						.multiSelect('issues')
-						.children(
-							toggle('misused', 'Misused')
-								.children(
-									group()
-										.title('Correct Slug')
-										.children(
-											text('correct-slug')
-												.initial(() => resolvedAutoSlug.value ?? project.value.slug)
-												.onChange((value, { override }) => {
-													if (!value) return override(project.value.slug ?? '')
-													clearTimeout(slugDebounceTimer)
-													if (value === project.value.slug) {
-														slugValidation.value = 'unchanged'
-														return
-													}
-													slugValidation.value = 'checking'
-													slugDebounceTimer = setTimeout(async () => {
-														const conflict = await checkSlugTaken(value).catch(() => null)
-														if (conflict !== null && conflict.id !== project.value.id) {
-															correctSlugConflict.value = conflict
-															slugValidation.value = 'taken'
-														} else {
-															correctSlugConflict.value = null
-															slugValidation.value = 'available'
-														}
-													}, 400)
-												}),
-
-											button()
-												.icon(TagCategoryWandSparklesIcon)
-												.tooltip(computed(() => resolvedAutoSlug.value ?? ''))
-												.enabled(
-													(state) =>
-														autoSlugStatus.value === 'available' &&
-														resolvedAutoSlug.value !== null &&
-														resolvedAutoSlug.value !== currentSlug(state),
-												)
-												.onClick((state) => {
-													if (resolvedAutoSlug.value) state['correct-slug'] = resolvedAutoSlug.value
-												}),
-
-											button()
-												.icon(UserPlusIcon)
-												.tooltip((state) => {
-													const current = currentSlug(state)
-													if (!ownerUsername.value || current?.includes(ownerUsername.value))
-														return current ?? ''
-													return `${current}-${ownerUsername.value}`
-												})
-												.enabled(
-													(state) =>
-														ownerUsername.value !== null &&
-														!currentSlug(state)?.includes(ownerUsername.value),
-												)
-												.onClick((state) => {
-													state['correct-slug'] = `${currentSlug(state)}-${ownerUsername.value}`
-												}),
-
-											button()
-												.icon(TagCategoryRefreshCcwIcon)
-												.tooltip(computed(() => project.value.slug ?? ''))
-												.enabled((state) => currentSlug(state) !== project.value.slug)
-												.onClick((state) => {
-													state['correct-slug'] = project.value.slug
-												}),
-
-											SlugStatus,
-										),
-								)
-								.rawMessage(async (state) => {
-									let correct = ''
-									if (slugValidation.value === 'available') {
-										const slug = state['correct-slug'] as string | undefined
-										if (slug)
-											correct = await md('checklist/messages/title-slug/slug/correction', () => ({
-												SUGGESTED_SLUG: slug,
-											}))(state)
-									}
-									return md('checklist/messages/title-slug/slug/misused', () => ({
-										CORRECT: correct,
-									}))(state)
-								})
-								.fix(
-									//TODO chyz think of some way to have initial values actually be reflected in state without having to store them
-									fix().project((patch, state) => {
-										const slug =
-											(state['correct-slug'] as string | undefined) ?? resolvedAutoSlug.value
-										if (!slug || slug === project.value.slug) return
-										patch.slug = slug
-									}),
-								),
-						),
-				),
-		)
+                    SlugStatus,
+                  ),
+              )
+              .rawMessage(async (state) => {
+                let correct = ""
+                if (slugValidation.value === "available") {
+                  const slug = state["correct-slug"] as string | undefined
+                  if (slug)
+                    correct = await md("checklist/messages/title-slug/slug/correction", () => ({
+                      SUGGESTED_SLUG: slug,
+                    }))(state)
+                }
+                return md("checklist/messages/title-slug/slug/misused", () => ({
+                  CORRECT: correct,
+                }))(state)
+              })
+              .fix(
+                fix().project((patch, state) => {
+                  if (slugValidation.value !== "available") return
+                  patch.slug = state["correct-slug"] as string
+                }),
+              ),
+          ),
+        ),
+    )
 }
diff --git a/packages/moderation/src/data/stages/versions.tsx b/packages/moderation/src/data/stages/versions.tsx
index 3e18ded1f5..47a273cc25 100644
--- a/packages/moderation/src/data/stages/versions.tsx
+++ b/packages/moderation/src/data/stages/versions.tsx
@@ -19,38 +19,31 @@ export default function () {
 			group().children(
 				toggle('incorrect-additional-files', 'Incorrect additional files')
 					.suggestedStatus('flagged')
-					.severity('medium')
 					.message(),
 
 				toggle('incorrect-project-type', 'Incorrect Project Type')
 					.suggestedStatus('rejected')
-					.severity('medium')
 					.children(
 						dropdown('type')
 							.title('Correct Project Type')
+              .required()
 							.none('Unknown')
-							.children(
-								option('modpack', 'Modpack')
-									.shown(computed(() => !project.value.project_types.includes('modpack')))
-									.message(),
-								option('resourcepack', 'Resource Pack')
-									.shown(computed(() => !project.value.project_types.includes('resourcepack')))
-									.message(),
-								option('datapack', 'Data Pack')
-									.shown(computed(() => !project.value.loaders.includes('datapack')))
-									.message(),
+							.options(
+								option('modpack', 'Modpack').message(),
+								option('resourcepack', 'Resource Pack').message(),
+								option('datapack', 'Data Pack').message(),
 							),
 					)
 					.collect(),
 
 				toggle('alternate-versions', 'Alternate Versions')
 					.suggestedStatus('rejected')
-					.severity('high')
 					.children(
 						dropdown('distribution')
 							.title('Distribution Type')
+              .required()
 							.none('Unknown')
-							.children(
+							.options(
 								option('primary', 'Primary Files').message(),
 								option('additional', 'Additional Files').message(),
 								option('mono', 'Monofile')
@@ -78,7 +71,6 @@ export default function () {
 				toggle('vanilla-assets', 'Vanilla Assets')
 					.shown(computed(() => project.value.project_types.includes('resourcepack')))
 					.suggestedStatus('rejected')
-					.severity('medium')
 					.message(),
 
 				toggle('redist-libs', 'Packed Libs')
@@ -90,18 +82,15 @@ export default function () {
 						),
 					)
 					.suggestedStatus('rejected')
-					.severity('medium')
 					.message(),
 
 				toggle('duplicate-primary-files', 'Duplicate Primary Files')
 					.suggestedStatus('flagged')
-					.severity('medium')
 					.message(),
 
 				toggle('unsupported', 'Unsupported')
 					.suggestedStatus('rejected')
-					.severity('medium')
-					.message(undefined, (state) => ({
+					.message((state) => ({
 						INVALID_TYPE: state['invalid-type'],
 					}))
 					.children(text('invalid-type').title('Unsupported Type').required()),
diff --git a/packages/moderation/src/index.ts b/packages/moderation/src/index.ts
index 95d7944884..ae3041d724 100644
--- a/packages/moderation/src/index.ts
+++ b/packages/moderation/src/index.ts
@@ -1,4 +1,4 @@
-export { default as checklist, stages, useStages } from './data/checklist'
+export { useStages } from './data/checklist'
 export { default as keybinds } from './data/keybinds'
 export { default as moderationSettings } from './data/settings'
 export { default as nags } from './data/nags'
@@ -10,16 +10,12 @@ export {
 	default as techReviewQuickReplies,
 } from './data/quick-replies/tech-review-quick-replies'
 export * from './locales'
-export * from './types/actions'
 export * from './types/keybinds'
 export * from './types/settings'
-export * from './types/messages'
 export * from './types/nags'
-export * from './types/node'
 export * from './types/priority'
 export * from './types/quick-reply'
 export * from './types/reports'
-export * from './types/stage'
 export * from './utils'
 export * from './handles/keybinds'
 export * from './handles/settings'
diff --git a/packages/moderation/src/types/actions.ts b/packages/moderation/src/types/actions.ts
deleted file mode 100644
index 3332dabc61..0000000000
--- a/packages/moderation/src/types/actions.ts
+++ /dev/null
@@ -1,298 +0,0 @@
-import type { Labrinth } from '@modrinth/api-client'
-
-import type { WeightedMessage } from './messages'
-
-export type ActionType =
-	| 'button'
-	| 'dropdown'
-	| 'multi-select-chips'
-	| 'toggle'
-	| 'conditional-button'
-
-export type Action =
-	| ButtonAction
-	| DropdownAction
-	| MultiSelectChipsAction
-	| ToggleAction
-	| ConditionalButtonAction
-
-export type ModerationStatus = 'approved' | 'rejected' | 'flagged'
-export type ModerationSeverity = 'low' | 'medium' | 'high' | 'critical'
-
-export interface ChecklistActionContext {
-	project: Labrinth.Projects.v2.Project
-	projectV3: Labrinth.Projects.v3.Project
-	versions?: Labrinth.Versions.v2.Version[] | null
-}
-
-export interface BaseAction {
-	/**
-	 * The type of action, which determines how the action is presented to the moderator and what it does.
-	 */
-	type: ActionType
-
-	/**
-	 * Any additional text data that is required to complete the action.
-	 */
-	relevantExtraInput?: AdditionalTextInput[]
-
-	/**
-	 * Suggested moderation status when this action is selected.
-	 */
-	suggestedStatus?: ModerationStatus
-
-	/**
-	 * Suggested severity level for this moderation action.
-	 */
-	severity?: ModerationSeverity
-
-	/**
-	 * Actions that become available when this action is selected.
-	 */
-	enablesActions?: Action[]
-
-	/**
-	 * Actions that become unavailable when this action is selected.
-	 */
-	disablesActions?: string[] // Array of action IDs
-
-	/**
-	 * Unique identifier for this action, used for conditional logic.
-	 */
-	id?: string
-
-	/**
-	 * A function that determines whether this action should be shown for a given project.
-	 *
-	 * By default, it returns `true`, meaning the action is always shown.
-	 */
-	shouldShow?: (
-		project: Labrinth.Projects.v2.Project,
-		projectV3: Labrinth.Projects.v3.Project,
-		context?: ChecklistActionContext,
-	) => boolean
-}
-
-/**
- * Represents a conditional message that changes based on other selected actions.
- */
-export interface ConditionalMessage extends WeightedMessage {
-	/**
-	 * Conditions that must be met for this message to be used.
-	 */
-	conditions: {
-		/**
-		 * Action IDs that must be selected for this message to apply.
-		 */
-		requiredActions?: string[]
-
-		/**
-		 * Action IDs that must NOT be selected for this message to apply.
-		 */
-		excludedActions?: string[]
-	}
-}
-
-/**
- * Represents a button action, which is a simple toggle button that can be used to append a message to the final moderation message.
- */
-export interface ButtonAction extends BaseAction, WeightedMessage {
-	type: 'button'
-
-	/**
-	 * The label of the button, which is displayed to the moderator. The text on the button.
-	 */
-	label: string
-
-	/**
-	 * Alternative messages based on other selected actions.
-	 */
-	conditionalMessages?: ConditionalMessage[]
-}
-
-/**
- * Represents a simple toggle/checkbox action with separate layout handling.
- */
-export interface ToggleAction extends BaseAction, WeightedMessage {
-	type: 'toggle'
-
-	/**
-	 * The label of the toggle, which is displayed to the moderator.
-	 */
-	label: string
-
-	/**
-	 * Description text that appears below the toggle.
-	 */
-	description?: string
-
-	/**
-	 * Whether the toggle is checked by default.
-	 */
-	defaultChecked?: boolean
-
-	/**
-	 * Alternative messages based on other selected actions.
-	 */
-	conditionalMessages?: ConditionalMessage[]
-}
-
-/**
- * Represents a button that has different behavior based on other selected actions.
- */
-export interface ConditionalButtonAction extends BaseAction {
-	type: 'conditional-button'
-
-	/**
-	 * The label of the button, which is displayed to the moderator.
-	 */
-	label: string
-
-	/**
-	 * Different message configurations based on conditions.
-	 */
-	messageVariants: ConditionalMessage[]
-
-	/**
-	 * Global fallback message if no variants match their conditions.
-	 */
-	fallbackMessage?: () => Promise<string>
-
-	/**
-	 * The weight of the action's fallback message, used to determine the place where the message is placed in the final moderation message.
-	 */
-	fallbackWeight?: number
-}
-
-export interface DropdownActionOption extends WeightedMessage {
-	/**
-	 * The label of the option, which is displayed to the moderator.
-	 */
-	label: string
-
-	/**
-	 * A function that determines whether this option should be shown for a given project.
-	 *
-	 * By default, it returns `true`, meaning the option is always shown.
-	 */
-	shouldShow?: (
-		project: Labrinth.Projects.v2.Project,
-		projectV3: Labrinth.Projects.v3.Project,
-		context?: ChecklistActionContext,
-	) => boolean
-}
-
-export interface DropdownAction extends BaseAction {
-	type: 'dropdown'
-
-	/**
-	 * The label associated with the dropdown.
-	 */
-	label: string
-
-	/**
-	 * The options available in the dropdown.
-	 */
-	options: DropdownActionOption[]
-
-	/**
-	 * The default option selected in the dropdown, by index.
-	 */
-	defaultOption?: number
-}
-
-export interface MultiSelectChipsOption extends WeightedMessage {
-	/**
-	 * Stable identifier for the option. If omitted, the label is used.
-	 */
-	id?: string
-
-	/**
-	 * The label of the chip, which is displayed to the moderator.
-	 */
-	label: string
-
-	/**
-	 * A function that determines whether this option should be shown for a given project.
-	 *
-	 * By default, it returns `true`, meaning the option is always shown.
-	 */
-	shouldShow?: (
-		project: Labrinth.Projects.v2.Project,
-		projectV3: Labrinth.Projects.v3.Project,
-		context?: ChecklistActionContext,
-	) => boolean
-}
-
-export type MultiSelectChipsOptionsResolver = (
-	context: ChecklistActionContext,
-) => MultiSelectChipsOption[]
-
-export interface MultiSelectChipsAction extends BaseAction {
-	type: 'multi-select-chips'
-
-	/**
-	 * The label associated with the multi-select chips.
-	 */
-	label: string
-
-	/**
-	 * The options available in the multi-select chips.
-	 */
-	options: MultiSelectChipsOption[] | MultiSelectChipsOptionsResolver
-
-	/**
-	 * If set, all selected option messages are joined with this string and emitted as a single
-	 * message part rather than individual parts. Useful for building bullet lists under a shared header.
-	 */
-	joinWith?: string
-}
-
-export interface AdditionalTextInput {
-	/**
-	 * The label of the text input, which is displayed to the moderator.
-	 */
-	label: string
-
-	/**
-	 * The placeholder text for the text input.
-	 */
-	placeholder?: string
-
-	/**
-	 * Whether the text input is required to be filled out before the action can be completed.
-	 */
-	required?: boolean
-
-	/**
-	 * Whether the text input should use the full markdown editor rather than a simple text input.
-	 */
-	large?: boolean
-
-	/**
-	 * The variable name that will be replaced in the message with the input value.
-	 * For example, if variable is "MESSAGE", then "%MESSAGE%" in the action message
-	 * will be replaced with the input value.
-	 */
-	variable?: string
-
-	/**
-	 * Conditions that determine when this input is shown.
-	 */
-	showWhen?: {
-		/**
-		 * Action IDs that must be selected for this input to be shown.
-		 */
-		requiredActions?: string[]
-
-		/**
-		 * Action IDs that must NOT be selected for this input to be shown.
-		 */
-		excludedActions?: string[]
-	}
-
-	/**
-	 * Optional suggestions for the input. Useful for repeating phrases or common responses.
-	 */
-	suggestions?: string[]
-}
diff --git a/packages/moderation/src/types/messages.ts b/packages/moderation/src/types/messages.ts
deleted file mode 100644
index 28c4425129..0000000000
--- a/packages/moderation/src/types/messages.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-export interface WeightedMessage {
-	/**
-	 * The weight of the action's active message, used to determine the place where the message is placed in the final moderation message.
-	 */
-	weight: number
-
-	/**
-	 * The message which is appended to the final moderation message if the button is active.
-	 * @returns A function that lazily loads the message which is appended if the button is active.
-	 * @example async () => (await import('../messages/example.md?raw')).default,
-	 */
-	message: () => Promise<string>
-}
diff --git a/packages/moderation/src/types/node.ts b/packages/moderation/src/types/node.ts
deleted file mode 100644
index e44894b639..0000000000
--- a/packages/moderation/src/types/node.ts
+++ /dev/null
@@ -1,880 +0,0 @@
-import type { Labrinth } from '@modrinth/api-client'
-import type { FunctionalComponent, InjectionKey, Ref, SVGAttributes } from 'vue'
-import { markRaw, toValue } from 'vue'
-
-import {
-	expandVariables,
-	flattenProjectV3Variables,
-	flattenProjectVariables,
-	flattenStaticVariables,
-} from '../utils'
-import type { ModerationSeverity, ModerationStatus } from './actions'
-import type { Priority } from './priority.ts'
-
-// ─── State ────────────────────────────────────────────────────────────────────
-
-export type NodeState =
-	| boolean
-	| string
-	| number
-	| Set<string>
-	| NodeStateWithChildren
-	| null
-	| undefined
-
-export interface NodeStateWithChildren {
-	value?: NodeState
-	[childId: string]: NodeState
-}
-
-// ─── Function types ───────────────────────────────────────────────────────────
-
-export type MessageFn = ((state: Record<string, NodeState>) => Promise<string>) & {
-	concat(...others: MessageFn[]): MessageFn
-}
-export type ContentFn = (state: Record<string, NodeState>) => string | Promise<string>
-export type ChildrenFn = (state: Record<string, NodeState>) => ChildEntry[]
-
-export type Reactive<T> = T | Ref<T>
-
-export function resolve<T>(value: Reactive<T>): T {
-	return toValue(value as T | Ref<T>)
-}
-
-export type ChildNode = NodeBuilder | (() => unknown) | string
-
-export type ChildEntry =
-	| NodeBuilder
-	| string
-	| (() => unknown)
-	| null
-	| Ref<NodeBuilder | null>
-	| ((state?: Record<string, NodeState>) => NodeBuilder | NodeBuilder[] | null)
-
-export type NodeType =
-	| 'toggle'
-	| 'check'
-	| 'button'
-	| 'text'
-	| 'markdown'
-	| 'group'
-	| 'dropdown'
-	| 'option'
-	| 'stage'
-
-// ─── Message helpers ──────────────────────────────────────────────────────────
-
-const messageFiles = import.meta.glob('../data/messages/**/*.md', {
-	query: '?raw',
-	import: 'default',
-})
-
-export function mdOptional(
-	path: string,
-	getVars?: (state: Record<string, any>) => Record<string, any>,
-): MessageFn {
-	return makeMessageFn(async (state) => {
-		const loader = messageFiles[`../data/messages/${path}.md`]
-		if (!loader) return ''
-		return loadMd(path, state, _project!.value, _projectV2!.value, getVars)
-	})
-}
-
-export function mdEscape(text: string): string {
-	return text.replace(/[\\*_`[~]/g, '\\$&')
-}
-
-const USER_CONTENT_KEYS = [
-	'PROJECT_TITLE',
-	'PROJECT_SLUG',
-	'PROJECT_SUMMARY',
-	'PROJECT_TYPE',
-	'PROJECT_STATUS',
-]
-
-export async function loadMd(
-	path: string,
-	state: Record<string, NodeState>,
-	project: Labrinth.Projects.v3.Project,
-	projectV2: Labrinth.Projects.v2.Project,
-	getVars?: (state: Record<string, any>) => Record<string, any>,
-): Promise<string> {
-	// Call getVars before any await so Vue's watchEffect tracks reactive reads inside it
-	const extraVars = getVars ? getVars(state) : null
-	const loader = messageFiles[`../data/messages/${path}.md`]
-	if (!loader) {
-		_onMissingMd?.(path)
-		return ''
-	}
-	const raw = (await loader()) as string
-	const vars: Record<string, string> = {
-		...flattenStaticVariables(),
-		...flattenProjectVariables(projectV2),
-		...flattenProjectV3Variables(project),
-	}
-	for (const key of USER_CONTENT_KEYS) {
-		if (key in vars) vars[key] = mdEscape(vars[key])
-	}
-	if (extraVars) {
-		for (const [k, v] of Object.entries(extraVars)) {
-			vars[k] = String(v ?? '')
-		}
-	}
-	const expanded = expandVariables(raw, projectV2, project, vars)
-	// Code spans render literally — markdown escapes inside them show as-is, so strip them
-	return expanded.replace(/`[^`\n]*`/g, (match) => match.replace(/\\([\\*_`[~])/g, '$1'))
-}
-
-function makeMessageFn(fn: (state: Record<string, NodeState>) => Promise<string>): MessageFn {
-	const rich = fn as MessageFn
-	rich.concat = (...others) =>
-		makeMessageFn(async (state) =>
-			(await Promise.all([rich, ...others].map((f) => f(state)))).join(''),
-		)
-	return rich
-}
-
-let _project: Ref<Labrinth.Projects.v3.Project> | null = null
-let _projectV2: Ref<Labrinth.Projects.v2.Project> | null = null
-let _onMissingMd: ((path: string) => void) | null = null
-
-export function setMissingMdHandler(handler: (path: string) => void) {
-	_onMissingMd = handler
-}
-
-export function setMessageProject(
-	project: Ref<Labrinth.Projects.v3.Project>,
-	projectV2: Ref<Labrinth.Projects.v2.Project>,
-) {
-	_project = project
-	_projectV2 = projectV2
-}
-
-export function md(
-	path: string | ((state: Record<string, NodeState>) => string),
-	getVars?: (state: Record<string, any>) => Record<string, any>,
-): MessageFn {
-	return makeMessageFn(async (state) => {
-		const resolvedPath = typeof path === 'function' ? path(state) : path
-		return loadMd(resolvedPath, state, _project!.value, _projectV2!.value, getVars)
-	})
-}
-// ─── Fix builder ──────────────────────────────────────────────────────────────
-
-export function createTrackedPatch<T extends object>(
-	source: T,
-): { proxy: T; changes: () => Partial<T> } {
-	const written = new Set<string | symbol>()
-	const data = { ...source }
-	const proxy = new Proxy(data, {
-		set(target, key, value) {
-			if (value !== (source as Record<string | symbol, unknown>)[key]) {
-				written.add(key)
-			} else {
-				written.delete(key)
-			}
-			;(target as Record<string | symbol, unknown>)[key] = value
-			return true
-		},
-	})
-	return {
-		proxy,
-		changes: () =>
-			Object.fromEntries([...written].map((k) => [k, data[k as keyof T]])) as Partial<T>,
-	}
-}
-
-export class FixBuilder {
-	_projectFn?: (
-		patch: Labrinth.Projects.v3.EditProjectRequest,
-		state: Record<string, NodeState>,
-	) => void
-	_versionFn?: (
-		patch: Labrinth.Versions.v3.ModifyVersionRequest,
-		state: Record<string, NodeState>,
-	) => void
-
-	project(
-		fn: (patch: Labrinth.Projects.v3.EditProjectRequest, state: Record<string, NodeState>) => void,
-	): this {
-		this._projectFn = fn
-		return this
-	}
-
-	version(
-		fn: (
-			patch: Labrinth.Versions.v3.ModifyVersionRequest,
-			state: Record<string, NodeState>,
-		) => void,
-	): this {
-		this._versionFn = fn
-		return this
-	}
-}
-
-export function fix(): FixBuilder {
-	return new FixBuilder()
-}
-
-// ─── Message segments ─────────────────────────────────────────────────────────
-
-type GetVarsFn = (state: Record<string, any>) => Record<string, any>
-
-export type MessageSegment =
-	| { type: 'fn'; fn: ContentFn }
-	| { type: 'auto'; getVars?: GetVarsFn }
-	| { type: 'path'; path: string | (() => string); getVars?: GetVarsFn }
-	| { type: 'collect'; fallback?: MessageSegment }
-
-export function resolveRelativeMessagePath(
-	messagePath: string | (() => string),
-	statePath: string[],
-): string {
-	const name = typeof messagePath === 'function' ? messagePath() : messagePath
-	if (name.startsWith('/')) return `checklist/messages${name}`
-	const parts = [...statePath.slice(0, -1), ...name.split('/')]
-	const normalized = parts.reduce<string[]>((acc, p) => {
-		if (p === '..') acc.pop()
-		else if (p) acc.push(p)
-		return acc
-	}, [])
-	return `checklist/messages/${normalized.join('/')}`
-}
-
-export async function evalSegment(
-	seg: MessageSegment,
-	state: Record<string, NodeState>,
-	statePath: string[],
-): Promise<string> {
-	if (seg.type === 'collect') return ''
-	if (seg.type === 'fn') return String((await seg.fn(state)) ?? '')
-	if (seg.type === 'auto')
-		return loadMd(
-			`checklist/messages/${statePath.join('/')}`,
-			state,
-			_project!.value,
-			_projectV2!.value,
-			seg.getVars,
-		)
-	return loadMd(
-		resolveRelativeMessagePath(seg.path, statePath),
-		state,
-		_project!.value,
-		_projectV2!.value,
-		seg.getVars,
-	)
-}
-
-// ─── Node builders ────────────────────────────────────────────────────────────
-
-export abstract class NodeBuilder {
-	abstract readonly type: NodeType
-	_shown?: Reactive<boolean>
-	_title?: Reactive<string>
-	_icon?: FunctionalComponent<SVGAttributes>
-	_tooltip?: Reactive<string> | ((state: Record<string, NodeState>) => string)
-
-	shown(condition: Reactive<boolean>): this {
-		this._shown = condition
-		return this
-	}
-
-	title(t: Reactive<string>): this {
-		this._title = t
-		return this
-	}
-
-	icon(i: FunctionalComponent<SVGAttributes>): this {
-		this._icon = markRaw(i)
-		return this
-	}
-
-	tooltip(t: Reactive<string> | ((state: Record<string, NodeState>) => string)): this {
-		this._tooltip = t
-		return this
-	}
-}
-
-export class ButtonNodeBuilder extends NodeBuilder {
-	readonly type = 'button' as const
-	readonly label?: string
-	_onClick?: (state: Record<string, NodeState>) => void
-	_enabled?: Reactive<boolean> | ((state: Record<string, NodeState>) => boolean)
-
-	constructor(nodeLabel?: string) {
-		super()
-		this.label = nodeLabel
-	}
-
-	onClick(fn: (state: Record<string, NodeState>) => void): this {
-		this._onClick = fn
-		return this
-	}
-
-	enabled(condition: Reactive<boolean> | ((state: Record<string, NodeState>) => boolean)): this {
-		this._enabled = condition
-		return this
-	}
-}
-
-export abstract class IdentifiedNodeBuilder extends NodeBuilder {
-	readonly id: string | undefined
-	_children: ChildEntry[] = []
-	_childrenFn?: ChildrenFn
-	_computingChildren = false
-	_segments: MessageSegment[] = []
-	_suggestedStatus?: ModerationStatus
-	_severity?: ModerationSeverity
-	_priority?: Priority
-	_fixes: FixBuilder[] = []
-	_applyFixes = false
-	_enabled?: Reactive<boolean> | ((state: Record<string, NodeState>) => boolean)
-	_statePath?: string[]
-
-	constructor(id: string | undefined) {
-		super()
-		this.id = id
-	}
-
-	children(fn: ChildrenFn): this
-	children(...entries: ChildEntry[]): this
-	children(...args: [ChildrenFn] | ChildEntry[]): this {
-		if (args.length === 1 && typeof args[0] === 'function' && args[0].length >= 1) {
-			this._childrenFn = args[0] as ChildrenFn
-		} else {
-			this._children.push(...(args as ChildEntry[]))
-		}
-		return this
-	}
-
-	message(path?: string | (() => string), getVars?: GetVarsFn): this {
-		const segment: MessageSegment =
-			path === undefined
-				? { type: 'auto', ...(getVars && { getVars }) }
-				: { type: 'path', path, ...(getVars && { getVars }) }
-		this._segments.push(segment)
-		return this
-	}
-
-	rawMessage(content: string | ContentFn): this {
-		const fn: ContentFn = typeof content === 'string' ? () => content : content
-		this._segments.push({ type: 'fn', fn })
-		return this
-	}
-
-	collect(path?: string | (() => string), getVars?: GetVarsFn): this {
-		const fallback =
-			path !== undefined || getVars !== undefined
-				? path === undefined
-					? { type: 'auto' as const, ...(getVars && { getVars }) }
-					: { type: 'path' as const, path, ...(getVars && { getVars }) }
-				: undefined
-		this._segments.push({ type: 'collect', ...(fallback && { fallback }) })
-		return this
-	}
-
-	suggestedStatus(s: ModerationStatus): this {
-		this._suggestedStatus = s
-		return this
-	}
-
-	severity(s: ModerationSeverity): this {
-		this._severity = s
-		return this
-	}
-
-	priority(p: Priority): this {
-		this._priority = p
-		return this
-	}
-
-	fix(f: FixBuilder): this {
-		this._fixes.push(f)
-		return this
-	}
-
-	applyFixes(): this {
-		this._applyFixes = true
-		return this
-	}
-
-	enabled(condition: Reactive<boolean> | ((state: Record<string, NodeState>) => boolean)): this {
-		this._enabled = condition
-		return this
-	}
-
-	statePath(path: string[]): this {
-		this._statePath = path
-		return this
-	}
-}
-
-export abstract class LabeledNodeBuilder extends IdentifiedNodeBuilder {
-	readonly label: string
-
-	constructor(id: string, label: string) {
-		super(id)
-		this.label = label
-	}
-}
-
-export abstract class ValueNodeBuilder extends LabeledNodeBuilder {
-	_defaultValue?: NodeState | ((state: Record<string, NodeState>) => NodeState)
-	_required?: boolean
-
-	initial(v: NodeState | ((state: Record<string, NodeState>) => NodeState)): this {
-		this._defaultValue = v
-		return this
-	}
-
-	required(v = true): this {
-		this._required = v
-		return this
-	}
-}
-
-export class BooleanNodeBuilder extends ValueNodeBuilder {
-	readonly type: 'toggle' | 'check'
-
-	constructor(id: string, nodeLabel: string, type: 'toggle' | 'check') {
-		super(id, nodeLabel)
-		this.type = type
-	}
-}
-
-export type OverrideValue = { readonly __override: string }
-
-export type OnChangeFn = (
-	value: string,
-	helpers: { override: (value: string) => OverrideValue },
-) => OverrideValue | void
-
-export class InputNodeBuilder extends IdentifiedNodeBuilder {
-	readonly type: 'text' | 'markdown'
-	_placeholder?: Reactive<string>
-	_defaultValue?: NodeState | ((state: Record<string, NodeState>) => NodeState)
-	_required?: boolean
-	_onChange?: OnChangeFn
-
-	constructor(id: string, type: 'text' | 'markdown') {
-		super(id)
-		this.type = type
-	}
-
-	placeholder(p: Reactive<string>): this {
-		this._placeholder = p
-		return this
-	}
-
-	initial(v: NodeState | ((state: Record<string, NodeState>) => NodeState)): this {
-		this._defaultValue = v
-		return this
-	}
-
-	required(v = true): this {
-		this._required = v
-		return this
-	}
-
-	onChange(fn: OnChangeFn): this {
-		this._onChange = fn
-		return this
-	}
-}
-
-export class GroupNodeBuilder extends IdentifiedNodeBuilder {
-	readonly type = 'group' as const
-	_layout?: 'flex' | 'column'
-	_required?: boolean
-	_selectMode?: 'single' | 'multi'
-	_selectId?: string
-
-	layout(l: 'flex' | 'column'): this {
-		this._layout = l
-		return this
-	}
-
-	required(v = true): this {
-		this._required = v
-		return this
-	}
-
-	singleSelect(id?: string): this {
-		this._selectMode = 'single'
-		if (id !== undefined) this._selectId = id
-		return this
-	}
-
-	multiSelect(id?: string): this {
-		this._selectMode = 'multi'
-		if (id !== undefined) this._selectId = id
-		return this
-	}
-}
-
-export class DropdownNodeBuilder extends IdentifiedNodeBuilder {
-	readonly type = 'dropdown' as const
-	_none?: string
-
-	override children(fn: ChildrenFn): this
-	override children(...nodes: OptionNodeBuilder[]): this
-	override children(...args: [ChildrenFn] | OptionNodeBuilder[]): this {
-		if (args.length === 1 && typeof args[0] === 'function' && args[0].length >= 1) {
-			super.children(args[0] as ChildrenFn)
-		} else {
-			super.children(...(args as OptionNodeBuilder[]))
-		}
-		return this
-	}
-
-	none(text: string): this {
-		this._none = text
-		return this
-	}
-}
-
-export class OptionNodeBuilder extends LabeledNodeBuilder {
-	readonly type = 'option' as const
-}
-
-export class StageNodeBuilder extends LabeledNodeBuilder {
-	readonly type = 'stage' as const
-	_hint?: string
-	_guidanceUrl?: string
-	_icon?: FunctionalComponent<SVGAttributes>
-	_navigate?: string
-
-	hint(h: string): this {
-		this._hint = h
-		return this
-	}
-
-	guidance(url: string): this {
-		this._guidanceUrl = url
-		return this
-	}
-
-	icon(i: FunctionalComponent<SVGAttributes>): this {
-		this._icon = markRaw(i)
-		return this
-	}
-
-	navigate(path: string): this {
-		this._navigate = path
-		return this
-	}
-
-	override children(fn: ChildrenFn): this
-	override children(...entries: ChildEntry[]): this
-	override children(...args: [ChildrenFn] | ChildEntry[]): this {
-		if (args.length === 1 && typeof args[0] === 'function' && args[0].length >= 1) {
-			super.children(args[0] as ChildrenFn)
-			if (!this._statePath) this._statePath = [this.id!]
-			return this
-		}
-		const entries = args as ChildEntry[]
-		super.children(...entries)
-		if (!this._statePath) this._statePath = [this.id!]
-		stampChildPaths(entries, [this.id!])
-		return this
-	}
-}
-
-export const STAGES_KEY: InjectionKey<Ref<StageNodeBuilder[]>> = Symbol('checklistStages')
-export const GLOBAL_STATE_KEY: InjectionKey<Ref<Record<string, Record<string, NodeState>>>> =
-	Symbol('checklistGlobalState')
-
-// ─── Node traversal ───────────────────────────────────────────────────────────
-
-function childrenScopePath(node: IdentifiedNodeBuilder): string[] | null {
-	if (!node._statePath) return null
-	switch (node.type) {
-		case 'toggle':
-		case 'check':
-		case 'option':
-		case 'stage':
-			return node._statePath
-		case 'group': {
-			const g = node as GroupNodeBuilder
-			if (g._selectMode) {
-				// Option ids become namespaces at the same level as the group
-				return node._statePath.slice(0, -1)
-			}
-			return node._statePath
-		}
-		case 'dropdown':
-			// Option ids become namespaces at the same level as the dropdown
-			return node._statePath.slice(0, -1)
-		default:
-			return null
-	}
-}
-
-function stampChildPaths(entries: ChildEntry[], scopePath: string[]): void {
-	for (const entry of entries) {
-		// Skip reactive entries (refs, functions, nulls) — they get stamped on resolution
-		if (!(entry instanceof NodeBuilder)) continue
-		if (!(entry instanceof IdentifiedNodeBuilder)) continue
-		const selectId = entry instanceof GroupNodeBuilder ? entry._selectId : undefined
-		if (!entry.id && !selectId) {
-			// Truly transparent: no structural id and no select id
-			stampChildPaths(entry._children, scopePath)
-			continue
-		}
-		if (!entry._statePath) {
-			// Structural id contributes to path first, then select id
-			const pathComponents = entry.id
-				? selectId
-					? [...scopePath, entry.id, selectId]
-					: [...scopePath, entry.id]
-				: [...scopePath, selectId!]
-			entry._statePath = pathComponents
-		}
-		const childScope = childrenScopePath(entry)
-		if (childScope) stampChildPaths(entry._children, childScope)
-	}
-}
-
-export function isNodeActive(node: NodeBuilder, state: NodeState): boolean {
-	switch (node.type) {
-		case 'toggle':
-		case 'check':
-		case 'option': {
-			if (typeof state === 'boolean') return state
-			if (state && typeof state === 'object' && !(state instanceof Set)) {
-				const v = (state as NodeStateWithChildren).value
-				if (typeof v === 'boolean') return v
-			}
-			return (node as BooleanNodeBuilder)._defaultValue === true
-		}
-		case 'group': {
-			const g = node as GroupNodeBuilder
-			if (g._selectMode === 'single') return typeof state === 'string' && state !== ''
-			if (g._selectMode === 'multi') return state instanceof Set && state.size > 0
-			return false
-		}
-		case 'dropdown':
-			return typeof state === 'string' && state !== ''
-		case 'text':
-		case 'markdown':
-			return typeof state === 'string' && state !== ''
-		default:
-			return false
-	}
-}
-
-export function getBooleanChildState(nodeState: NodeState): Record<string, NodeState> {
-	if (nodeState && typeof nodeState === 'object' && !(nodeState instanceof Set)) {
-		return nodeState as Record<string, NodeState>
-	}
-	return {}
-}
-
-export function resolveChildren(
-	node: IdentifiedNodeBuilder,
-	state: Record<string, NodeState>,
-): ChildNode[] {
-	let entries: ChildEntry[]
-	let stampStatic = false
-
-	if (node._childrenFn) {
-		if (node._computingChildren) return []
-		node._computingChildren = true
-		try {
-			entries = node._childrenFn(state)
-			stampStatic = true // childrenFn results haven't been pre-stamped
-		} finally {
-			node._computingChildren = false
-		}
-	} else {
-		entries = node._children
-	}
-
-	const scopePath = childrenScopePath(node)
-	const result: ChildNode[] = []
-
-	for (const entry of entries) {
-		if (entry == null) continue
-		if (entry instanceof NodeBuilder) {
-			if (entry._shown !== undefined && !resolve(entry._shown)) continue
-			if (stampStatic && scopePath) stampChildPaths([entry], scopePath)
-			result.push(entry)
-			continue
-		}
-		if (typeof entry === 'string') {
-			result.push(entry)
-			continue
-		}
-		if (typeof entry === 'function') {
-			if (entry.length === 0) {
-				result.push(entry as () => unknown)
-				continue
-			}
-			const resolved = entry(state)
-			if (resolved == null) continue
-			if (Array.isArray(resolved)) {
-				for (const r of resolved) {
-					if (r == null) continue
-					if (r._shown !== undefined && !resolve(r._shown)) continue
-					if (scopePath) stampChildPaths([r], scopePath)
-					result.push(r)
-				}
-				continue
-			}
-			if (resolved._shown !== undefined && !resolve(resolved._shown)) continue
-			if (scopePath) stampChildPaths([resolved], scopePath)
-			result.push(resolved)
-			continue
-		}
-		// Ref<NodeBuilder | null>
-		const resolved = toValue(entry as Ref<NodeBuilder | null>)
-		if (resolved == null) continue
-		if (resolved._shown !== undefined && !resolve(resolved._shown)) continue
-		if (scopePath) stampChildPaths([resolved], scopePath)
-		result.push(resolved)
-	}
-
-	return result
-}
-
-export function walkNodes(
-	nodes: ChildNode[],
-	stageState: Record<string, NodeState>,
-	visitor: (
-		node: IdentifiedNodeBuilder,
-		nodeState: NodeState,
-		localState: Record<string, NodeState>,
-	) => void,
-): void {
-	for (const node of nodes) {
-		if (!(node instanceof NodeBuilder)) continue
-		if (node._shown !== undefined && !resolve(node._shown)) continue
-
-		if (node.type === 'stage') {
-			const identified = node as IdentifiedNodeBuilder
-			if (identified.id) {
-				const raw = stageState[identified.id]
-				const childState =
-					raw && typeof raw === 'object' && !(raw instanceof Set)
-						? (raw as Record<string, NodeState>)
-						: {}
-				walkNodes(resolveChildren(identified, childState), childState, visitor)
-			} else {
-				walkNodes(resolveChildren(identified, stageState), stageState, visitor)
-			}
-			continue
-		}
-
-		if (node.type === 'group') {
-			const g = node as GroupNodeBuilder
-			if (!g._selectMode) {
-				// Plain container: traverse children in group's own state scope
-				if (g.id) {
-					const raw = stageState[g.id]
-					const childState =
-						raw && typeof raw === 'object' && !(raw instanceof Set)
-							? (raw as Record<string, NodeState>)
-							: {}
-					walkNodes(resolveChildren(g, childState), childState, visitor)
-				} else {
-					walkNodes(resolveChildren(g, stageState), stageState, visitor)
-				}
-				continue
-			}
-			// Fall through to value-node path for groups with selectMode
-		}
-
-		if (node.type === 'button') continue
-
-		const identified = node as IdentifiedNodeBuilder
-		const stateKey =
-			node.type === 'group'
-				? ((node as GroupNodeBuilder)._selectId ?? identified.id!)
-				: identified.id!
-		const nodeState = stageState[stateKey]
-		visitor(identified, nodeState, stageState)
-
-		const active = isNodeActive(node, nodeState)
-		const children = resolveChildren(identified, stageState)
-		if (children.length === 0 || !active) continue
-
-		if (node.type === 'group' && (node as GroupNodeBuilder)._selectMode === 'multi') {
-			const selected = nodeState instanceof Set ? nodeState : new Set<string>()
-			for (const child of children) {
-				const childId = child as IdentifiedNodeBuilder
-				if (!selected.has(childId.id!) || (child._shown !== undefined && !resolve(child._shown)))
-					continue
-				const rawChildState = stageState[childId.id!]
-				// Option children are active by virtue of being in the selected Set, not by their own
-				// boolean state. If they have child state but no explicit value, inject value: true
-				// so isNodeActive returns true even after child state has been written to their path.
-				const childState: NodeState =
-					rawChildState !== null &&
-					rawChildState !== undefined &&
-					typeof rawChildState === 'object' &&
-					!(rawChildState instanceof Set) &&
-					(rawChildState as NodeStateWithChildren).value === undefined
-						? { ...(rawChildState as NodeStateWithChildren), value: true }
-						: (rawChildState ?? true)
-				visitor(childId, childState, stageState)
-				walkNodes(resolveChildren(childId, stageState), stageState, visitor)
-			}
-		} else if (node.type === 'toggle' || node.type === 'check') {
-			const childState = getBooleanChildState(nodeState)
-			walkNodes(children, childState, visitor)
-		} else if (
-			(node.type === 'group' && (node as GroupNodeBuilder)._selectMode === 'single') ||
-			node.type === 'dropdown'
-		) {
-			const selectedId = typeof nodeState === 'string' ? nodeState : undefined
-			if (selectedId) {
-				for (const child of children) {
-					const childId = child as IdentifiedNodeBuilder
-					if (childId.id !== selectedId || (child._shown !== undefined && !resolve(child._shown)))
-						continue
-					const rawChildState = stageState[childId.id!]
-					const childState: NodeState =
-						rawChildState !== null &&
-						rawChildState !== undefined &&
-						typeof rawChildState === 'object' &&
-						!(rawChildState instanceof Set) &&
-						(rawChildState as NodeStateWithChildren).value === undefined
-							? { ...(rawChildState as NodeStateWithChildren), value: true }
-							: (rawChildState ?? true)
-					visitor(childId, childState, stageState)
-					walkNodes(resolveChildren(childId, stageState), stageState, visitor)
-					break
-				}
-			}
-		} else {
-			walkNodes(children, stageState, visitor)
-		}
-	}
-}
-
-// ─── Factory functions ────────────────────────────────────────────────────────
-
-export type StageFn = (
-	project: Labrinth.Projects.v3.Project,
-	projectV2: Labrinth.Projects.v2.Project,
-) => StageNodeBuilder
-
-export function stageFn(factory: StageFn): StageFn {
-	const cache = new WeakMap<object, StageNodeBuilder>()
-	return (project, projectV2) => {
-		if (!cache.has(project)) cache.set(project, factory(project, projectV2))
-		return cache.get(project)!
-	}
-}
-
-export const toggle = (id: string, nodeLabel: string) =>
-	new BooleanNodeBuilder(id, nodeLabel, 'toggle')
-export const check = (id: string, nodeLabel: string) =>
-	new BooleanNodeBuilder(id, nodeLabel, 'check')
-export const button = (nodeLabel?: string) => new ButtonNodeBuilder(nodeLabel)
-export const text = (id: string) => new InputNodeBuilder(id, 'text')
-export const markdown = (id: string) => new InputNodeBuilder(id, 'markdown')
-export const group = (id?: string) => new GroupNodeBuilder(id)
-export const dropdown = (id: string) => new DropdownNodeBuilder(id)
-export const option = (id: string, nodeLabel: string) => new OptionNodeBuilder(id, nodeLabel)
-export const stage = (id: string, title: string) => new StageNodeBuilder(id, title)
diff --git a/packages/moderation/src/types/node/builder.ts b/packages/moderation/src/types/node/builder.ts
new file mode 100644
index 0000000000..da3e35c71c
--- /dev/null
+++ b/packages/moderation/src/types/node/builder.ts
@@ -0,0 +1,56 @@
+import type { Ref } from 'vue'
+
+import type { Configurable, Visible } from './capabilities'
+import type { NodeState } from './state'
+
+export type AnyNode = Visible
+
+export type ChildNode = AnyNode | (() => unknown) | string
+
+export type ChildEntry =
+	| AnyNode
+	| string
+	| (() => unknown)
+	| null
+	| Ref<AnyNode | null>
+	| ((state?: Record<string, NodeState>) => AnyNode | AnyNode[] | null)
+
+export type ChildrenFn = (state: Record<string, NodeState>) => ChildEntry[]
+
+export interface HasChildren {
+	_children: ChildEntry[]
+	_childrenFn?: ChildrenFn
+	children(this: this, fn: ChildrenFn): this
+	children(this: this, ...entries: ChildEntry[]): this
+}
+
+export function withChildren<T extends object>(node: T): T & HasChildren {
+	return Object.assign(node, {
+		_children: [] as ChildEntry[],
+		children(this: any, ...args: [ChildrenFn] | ChildEntry[]) {
+			if (args.length === 1 && typeof args[0] === 'function' && args[0].length >= 1) {
+				this._childrenFn = args[0] as ChildrenFn
+			} else {
+				this._children.push(...(args as ChildEntry[]))
+			}
+			return this
+		},
+	})
+}
+
+export function withAutoProps<T extends Configurable>(
+	node: T,
+): T & { [key: string]: (value: unknown) => T } {
+	return new Proxy(node, {
+		get(target, prop, receiver) {
+			if (typeof prop === 'string' && !prop.startsWith('_') && !(prop in target)) {
+				return (value: unknown) => {
+					const prev = target._extraProps
+					target._extraProps = (ctx) => ({ ...prev?.(ctx), [prop]: value })
+					return receiver
+				}
+			}
+			return Reflect.get(target, prop, receiver)
+		},
+	}) as T & { [key: string]: (value: unknown) => T }
+}
diff --git a/packages/moderation/src/types/node/capabilities.ts b/packages/moderation/src/types/node/capabilities.ts
new file mode 100644
index 0000000000..ae017207d0
--- /dev/null
+++ b/packages/moderation/src/types/node/capabilities.ts
@@ -0,0 +1,442 @@
+import type { Component, FunctionalComponent, SVGAttributes } from 'vue'
+
+import type { FixBuilder } from './fix'
+import { Priority } from '../priority.ts'
+import type {
+	GetVarsFn,
+	MessageSegment,
+	ModerationStatus,
+	NodeState,
+	Reactive,
+} from './state'
+
+export interface Visible {
+	_shown: Reactive<boolean> | undefined
+	shown(this: this, condition: Reactive<boolean>): this
+}
+
+export function withShown<T extends object>(node: T): T & Visible {
+	return Object.assign(node, {
+		_shown: undefined as Reactive<boolean> | undefined,
+		shown(this: any, condition: Reactive<boolean>) {
+			this._shown = condition
+			return this
+		},
+	})
+}
+
+export interface Iconable {
+	_icon: FunctionalComponent<SVGAttributes> | undefined
+	icon(this: this, icon: FunctionalComponent<SVGAttributes> | undefined): this
+}
+
+export function withIcon<T extends object>(node: T): T & Iconable {
+	return Object.assign(node, {
+		_icon: undefined as FunctionalComponent<SVGAttributes> | undefined,
+		icon(this: any, icon: FunctionalComponent<SVGAttributes> | undefined) {
+			this._icon = icon
+			return this
+		},
+	})
+}
+
+export interface Tooltippable {
+	_tooltip: Reactive<string> | ((state: Record<string, NodeState>) => string) | undefined
+	tooltip(
+		this: this,
+		tooltip: Reactive<string> | ((state: Record<string, NodeState>) => string) | undefined,
+	): this
+}
+
+export function withTooltip<T extends object>(node: T): T & Tooltippable {
+	return Object.assign(node, {
+		_tooltip: undefined as Tooltippable['_tooltip'],
+		tooltip(this: any, tooltip: Tooltippable['_tooltip']) {
+			this._tooltip = tooltip
+			return this
+		},
+	})
+}
+
+export interface Titled {
+	_title: Reactive<string> | undefined
+	title(this: this, title: Reactive<string>): this
+}
+
+export function withTitle<T extends object>(node: T): T & Titled {
+	return Object.assign(node, {
+		_title: undefined as Reactive<string> | undefined,
+		title(this: any, title: Reactive<string>) {
+			this._title = title
+			return this
+		},
+	})
+}
+
+export interface Identified {
+	id: string
+	_statePath?: string[]
+	statePath(this: this, path: string[]): this
+}
+
+export function withId<T extends object>(node: T, id: string): T & Identified {
+	return Object.assign(node, {
+		id,
+		statePath(this: any, path: string[]) {
+			this._statePath = path
+			return this
+		},
+	})
+}
+
+export interface Prioritizable {
+	_priority: Priority
+	priority(this: this, p: Priority): this
+}
+
+export function withPriority<T extends object>(node: T): T & Prioritizable {
+	return Object.assign(node, {
+		_priority: new Priority(),
+		priority(this: any, p: Priority) {
+			this._priority = p
+			return this
+		},
+	})
+}
+
+export interface Messageable {
+	_segments: MessageSegment[]
+	_suggestedStatus?: ModerationStatus
+	suggestedStatus(this: this, status: ModerationStatus): this
+	message(this: this, path?: string | (() => string) | GetVarsFn, getVars?: GetVarsFn): this
+	rawMessage(
+		this: this,
+		content: string | ((state: Record<string, NodeState>) => string | Promise<string>),
+	): this
+	collect(this: this, path?: string | (() => string) | GetVarsFn, getVars?: GetVarsFn): this
+}
+
+function splitPathAndVars(
+	pathOrGetVars: string | (() => string) | GetVarsFn | undefined,
+	getVars: GetVarsFn | undefined,
+): { path: string | (() => string) | undefined; getVars: GetVarsFn | undefined } {
+	if (typeof pathOrGetVars === 'function' && pathOrGetVars.length >= 1) {
+		return { path: undefined, getVars: pathOrGetVars as GetVarsFn }
+	}
+	return { path: pathOrGetVars as string | (() => string) | undefined, getVars }
+}
+
+export function withMessaging<T extends object>(node: T): T & Messageable {
+	return Object.assign(node, {
+		_segments: [] as MessageSegment[],
+		suggestedStatus(this: any, status: ModerationStatus) {
+			this._suggestedStatus = status
+			return this
+		},
+		message(this: any, pathOrGetVars?: string | (() => string) | GetVarsFn, getVarsArg?: GetVarsFn) {
+			const { path, getVars } = splitPathAndVars(pathOrGetVars, getVarsArg)
+			const segment: MessageSegment =
+				path === undefined
+					? { type: 'auto', ...(getVars && { getVars }) }
+					: { type: 'path', path, ...(getVars && { getVars }) }
+			this._segments.push(segment)
+			return this
+		},
+		rawMessage(
+			this: any,
+			content: string | ((state: Record<string, NodeState>) => string | Promise<string>),
+		) {
+			const fn = typeof content === 'string' ? () => content : content
+			this._segments.push({ type: 'fn', fn })
+			return this
+		},
+		collect(this: any, pathOrGetVars?: string | (() => string) | GetVarsFn, getVarsArg?: GetVarsFn) {
+			const { path, getVars } = splitPathAndVars(pathOrGetVars, getVarsArg)
+			const fallback: MessageSegment | undefined =
+				path !== undefined || getVars !== undefined
+					? path === undefined
+						? { type: 'auto', ...(getVars && { getVars }) }
+						: { type: 'path', path, ...(getVars && { getVars }) }
+					: undefined
+			this._segments.push({ type: 'collect', ...(fallback && { fallback }) })
+			return this
+		},
+	})
+}
+
+export interface Requireable {
+	_required: boolean | undefined
+	required(this: this, v?: boolean): this
+}
+
+export function withRequired<T extends object>(node: T): T & Requireable {
+	return Object.assign(node, {
+		_required: undefined as boolean | undefined,
+		required(this: any, v = true) {
+			this._required = v
+			return this
+		},
+	})
+}
+
+export interface Fixable {
+	_fixes: FixBuilder[]
+	_applyFixes?: boolean
+	fix(this: this, f: FixBuilder): this
+	applyFixes(this: this): this
+}
+
+export function withFix<T extends object>(node: T): T & Fixable {
+	return Object.assign(node, {
+		_fixes: [] as FixBuilder[],
+		fix(this: any, f: FixBuilder) {
+			this._fixes.push(f)
+			return this
+		},
+		applyFixes(this: any) {
+			this._applyFixes = true
+			return this
+		},
+	})
+}
+
+export interface Enableable {
+	_enabled: Reactive<boolean> | ((state: Record<string, NodeState>) => boolean) | undefined
+	enabled(this: this, condition: Enableable['_enabled']): this
+}
+
+export function withEnabled<T extends object>(node: T): T & Enableable {
+	return Object.assign(node, {
+		_enabled: undefined as Enableable['_enabled'],
+		enabled(this: any, condition: Enableable['_enabled']) {
+			this._enabled = condition
+			return this
+		},
+	})
+}
+
+export interface HasValue<V = unknown> {
+	_defaultValue?: V | ((state: Record<string, NodeState>) => V)
+	_getValue: (raw: NodeState) => V
+	_setValue: (raw: NodeState, next: V, isDefault?: boolean) => NodeState
+	_isActive: (value: V) => boolean
+	initial(this: this, v: V | ((state: Record<string, NodeState>) => V)): this
+}
+
+export function withValue<T extends object, V>(
+	node: T,
+	behavior: Pick<HasValue<V>, '_getValue' | '_setValue' | '_isActive'>,
+): T & HasValue<V> {
+	return Object.assign(node, {
+		...behavior,
+		initial(this: any, v: V | ((state: Record<string, NodeState>) => V)) {
+			this._defaultValue = v
+			return this
+		},
+	})
+}
+
+export interface Clickable {
+	_onClick: ((state: Record<string, NodeState>) => void) | undefined
+	onClick(this: this, fn: Clickable['_onClick']): this
+}
+
+export function withOnClick<T extends object>(node: T): T & Clickable {
+	return Object.assign(node, {
+		_onClick: undefined as Clickable['_onClick'],
+		onClick(this: any, fn: Clickable['_onClick']) {
+			this._onClick = fn
+			return this
+		},
+	})
+}
+
+export interface ComponentNodePropsContext {
+	onImageUpload?: (file: File) => Promise<string>
+	toggleSetValue?: (value: string) => void
+	nodeFacts?: { needsAttention: boolean; fixActionable: boolean }
+	tooltip?: Record<string, unknown>
+}
+
+export interface Renderable {
+	_component: Component | undefined
+	_rendererKey: string | undefined
+	_componentProps?: (ctx: ComponentNodePropsContext) => Record<string, unknown>
+	_modelProp: string
+}
+
+export function withComponent<T extends object>(
+	node: T,
+	opts: {
+		component?: Component
+		rendererKey?: string
+		modelProp?: string
+		componentProps?: Renderable['_componentProps']
+	},
+): T & Renderable {
+	return Object.assign(node, {
+		_component: opts.component,
+		_rendererKey: opts.rendererKey,
+		_componentProps: opts.componentProps,
+		_modelProp: opts.modelProp ?? 'modelValue',
+	})
+}
+
+export interface Configurable {
+	_extraProps: ((ctx: ComponentNodePropsContext) => Record<string, unknown>) | undefined
+}
+
+export function withExtraProps<T extends object>(node: T): T & Configurable {
+	return Object.assign(node, {
+		_extraProps: undefined as Configurable['_extraProps'],
+	})
+}
+
+export interface HasNoneLabel {
+	_none: string | undefined
+	none(this: this, text: string): this
+}
+
+export function withNoneLabel<T extends object>(node: T): T & HasNoneLabel {
+	return Object.assign(node, {
+		_none: undefined as string | undefined,
+		none(this: any, text: string) {
+			this._none = text
+			return this
+		},
+	})
+}
+
+export interface Layoutable {
+	_layout: 'flex' | 'column' | undefined
+	layout(this: this, value: 'flex' | 'column'): this
+}
+
+export function withLayout<T extends object>(node: T): T & Layoutable {
+	return Object.assign(node, {
+		_layout: undefined as 'flex' | 'column' | undefined,
+		layout(this: any, value: 'flex' | 'column') {
+			this._layout = value
+			return this
+		},
+	})
+}
+
+export interface Selectable {
+	_exclusive: boolean | undefined
+	singleSelect(this: this): this
+}
+
+export function withSelectable<T extends object>(node: T): T & Selectable {
+	return Object.assign(node, {
+		_exclusive: undefined as boolean | undefined,
+		singleSelect(this: any) {
+			this._exclusive = true
+			return this
+		},
+	})
+}
+
+export interface StageMeta {
+	_hint: string | undefined
+	_guidanceUrl: string | undefined
+	_navigate: string | undefined
+	_shownSticky: boolean | undefined
+	hint(this: this, hint: string): this
+	guidance(this: this, url: string): this
+	navigate(this: this, path?: string): this
+	sticky(this: this): this
+}
+
+export function withStageMeta<T extends object>(node: T): T & StageMeta {
+	return Object.assign(node, {
+		_hint: undefined as string | undefined,
+		_guidanceUrl: undefined as string | undefined,
+		_navigate: undefined as string | undefined,
+		_shownSticky: undefined as boolean | undefined,
+		hint(this: any, hint: string) {
+			this._hint = hint
+			return this
+		},
+		guidance(this: any, url: string) {
+			this._guidanceUrl = url
+			return this
+		},
+		navigate(this: any, path?: string) {
+			this._navigate = path ?? ''
+			return this
+		},
+		sticky(this: any) {
+			this._shownSticky = true
+			return this
+		},
+	})
+}
+
+export type OverrideValue = { readonly __override: string }
+
+export type OnChangeFn = (
+	value: string,
+	helpers: { override: (value: string) => OverrideValue },
+) => OverrideValue | void
+
+export interface Editable {
+	_placeholder: Reactive<string> | undefined
+	_onChange: OnChangeFn | undefined
+	_showTooltip: boolean | undefined
+	_imperativeSync: boolean | undefined
+	placeholder(this: this, p: Reactive<string>): this
+	onChange(this: this, fn: OnChangeFn): this
+}
+
+export function withEditable<T extends object>(node: T): T & Editable {
+	return Object.assign(node, {
+		_placeholder: undefined as Reactive<string> | undefined,
+		_onChange: undefined as OnChangeFn | undefined,
+		_showTooltip: undefined as boolean | undefined,
+		_imperativeSync: undefined as boolean | undefined,
+		placeholder(this: any, p: Reactive<string>) {
+			this._placeholder = p
+			return this
+		},
+		onChange(this: any, fn: OnChangeFn) {
+			this._onChange = fn
+			return this
+		},
+	})
+}
+
+export interface TweakDef<V = unknown> {
+	icon: FunctionalComponent<SVGAttributes>
+	compute: (current: V, state: Record<string, NodeState>) => V | null | undefined
+}
+
+export interface Tweakable<V = unknown> {
+	_tweaks: TweakDef<V>[]
+	tweak(this: this, icon: FunctionalComponent<SVGAttributes>, compute: TweakDef<V>['compute']): this
+}
+
+export function withTweak<T extends HasValue<V>, V>(node: T): T & Tweakable<V> {
+	return Object.assign(node, {
+		_tweaks: [] as TweakDef<V>[],
+		tweak(this: any, icon: FunctionalComponent<SVGAttributes>, compute: TweakDef<V>['compute']) {
+			this._tweaks.push({ icon, compute })
+			return this
+		},
+	})
+}
+
+export interface StateOrigin {
+	_stateOrigin: string[] | undefined
+	stateOrigin(this: this, path: string[]): this
+}
+
+export function withStateOrigin<T extends object>(node: T): T & StateOrigin {
+	return Object.assign(node, {
+		_stateOrigin: undefined as string[] | undefined,
+		stateOrigin(this: any, path: string[]) {
+			this._stateOrigin = path
+			return this
+		},
+	})
+}
diff --git a/packages/moderation/src/types/node/collect.ts b/packages/moderation/src/types/node/collect.ts
new file mode 100644
index 0000000000..9ec5ab8d8c
--- /dev/null
+++ b/packages/moderation/src/types/node/collect.ts
@@ -0,0 +1,85 @@
+import { evalSegment } from './messages'
+import { hasCap, isNodeActive, resolveActionState, walkNodes } from './resolve'
+import type { ChildNode } from './builder'
+import type { MessageSegment, NodeState } from './state'
+
+export interface ActiveAction2 {
+	node: object
+	state: Record<string, NodeState>
+	statePath: string[]
+	active: boolean
+}
+
+export function collectActiveActions(
+	children: ChildNode[],
+	stageState: Record<string, NodeState>,
+	basePath: string[] = [],
+): ActiveAction2[] {
+	const actions: ActiveAction2[] = []
+	walkNodes(
+		children,
+		stageState,
+		(node, nodeState, localState, path) => {
+			if (!hasCap(node, '_segments')) return
+			const segments = node._segments as MessageSegment[]
+			if (segments.length === 0) return
+			if (!isNodeActive(node, nodeState, localState)) return
+			actions.push({ node, state: resolveActionState(node, nodeState, localState), statePath: path, active: true })
+		},
+		basePath,
+	)
+	return actions
+}
+
+export function collectMessageNodes(
+	children: ChildNode[],
+	stageState: Record<string, NodeState>,
+	basePath: string[] = [],
+): ActiveAction2[] {
+	const actions: ActiveAction2[] = []
+	walkNodes(
+		children,
+		stageState,
+		(node, nodeState, localState, path) => {
+			if (!hasCap(node, '_segments')) return
+			const segments = node._segments as MessageSegment[]
+			if (segments.length === 0) return
+			const active = isNodeActive(node, nodeState, localState)
+			actions.push({ node, state: resolveActionState(node, nodeState, localState), statePath: path, active })
+		},
+		basePath,
+	)
+	return actions
+}
+
+function isDescendant(childPath: string[], ancestorPath: string[]): boolean {
+	return childPath.length > ancestorPath.length && ancestorPath.every((key, i) => childPath[i] === key)
+}
+
+export async function evalActiveAction(
+	entry: ActiveAction2,
+	allActions: ActiveAction2[],
+	consumed: Set<object>,
+): Promise<string> {
+	let result = ''
+	const segments = (entry.node as { _segments: MessageSegment[] })._segments
+	for (const seg of segments) {
+		if (seg.type === 'collect') {
+			let collected = ''
+			for (const child of allActions) {
+				if (consumed.has(child.node)) continue
+				if (!isDescendant(child.statePath, entry.statePath)) continue
+				consumed.add(child.node)
+				if (!child.active) continue
+				collected += await evalActiveAction(child, allActions, consumed)
+			}
+			if (!collected.trim() && seg.fallback) {
+				collected = await evalSegment(seg.fallback, entry.state, entry.statePath)
+			}
+			result += collected
+		} else {
+			result += await evalSegment(seg, entry.state, entry.statePath)
+		}
+	}
+	return result
+}
diff --git a/packages/moderation/src/types/node/components/ActionButton.vue b/packages/moderation/src/types/node/components/ActionButton.vue
new file mode 100644
index 0000000000..1239949e1e
--- /dev/null
+++ b/packages/moderation/src/types/node/components/ActionButton.vue
@@ -0,0 +1,39 @@
+<template>
+	<ButtonStyled :color="color" :circular="!!icon">
+		<button
+			v-tooltip="tooltip"
+			:disabled="disabled"
+			:aria-label="icon ? label : undefined"
+			@click="emit('update:modelValue', !modelValue)"
+		>
+			<component :is="icon" v-if="icon" />
+			<template v-else>{{ label }}</template>
+		</button>
+	</ButtonStyled>
+</template>
+
+<script lang="ts" setup>
+import { ButtonStyled } from '@modrinth/ui'
+import { computed } from 'vue'
+import type { Component } from 'vue'
+
+const props = defineProps<{
+	modelValue: boolean
+	label?: string
+	icon?: Component
+	disabled?: boolean
+	needsAttention?: boolean
+	fixActionable?: boolean
+	tooltip?: Record<string, unknown>
+}>()
+
+const emit = defineEmits<{
+	'update:modelValue': [boolean]
+}>()
+
+const color = computed(() => {
+	if (!props.modelValue) return 'standard'
+	if (props.needsAttention) return 'orange'
+	return props.fixActionable ? 'blue' : 'brand'
+})
+</script>
diff --git a/packages/moderation/src/types/node/components/NodeRenderer.vue b/packages/moderation/src/types/node/components/NodeRenderer.vue
new file mode 100644
index 0000000000..58663dd30e
--- /dev/null
+++ b/packages/moderation/src/types/node/components/NodeRenderer.vue
@@ -0,0 +1,364 @@
+<script lang="ts" setup>
+import { ButtonStyled } from '@modrinth/ui'
+import { renderString } from '@modrinth/utils'
+import { computed, inject, watchEffect } from 'vue'
+import type { Component } from 'vue'
+
+import type { AnyNode, ChildNode, HasChildren } from '../builder'
+import type {
+	ComponentNodePropsContext,
+	Enableable,
+	HasValue,
+	Identified,
+	OnChangeFn,
+	TweakDef,
+} from '../capabilities'
+import { CHECKLIST_META_KEY } from '../context'
+import ActionButton from './ActionButton.vue'
+import { childWriter, originScope, writeNodeValue } from '../mutate'
+import type { Writer } from '../mutate'
+import {
+	getBooleanChildState,
+	getEffectiveValue,
+	hasCap,
+	hasChildrenCap,
+	hasIdCap,
+	hasOptionsCap,
+	hasValueCap,
+	isNodeActive,
+	isShown,
+	resolveChildren,
+	withDefaults,
+} from '../resolve'
+import type { NodeState, Reactive } from '../state'
+import { resolve } from '../state'
+
+const metaCtx = inject(CHECKLIST_META_KEY)
+
+const props = defineProps<{
+	nodes: ChildNode[]
+	state: Record<string, NodeState>
+	write: Writer
+	onImageUpload?: (file: File) => Promise<string>
+	flex?: boolean
+	titleDepth?: number
+	appComponents?: Record<string, Component>
+	globalState?: Record<string, Record<string, NodeState>>
+}>()
+
+type RenderableValueNode = AnyNode &
+	HasValue &
+	Identified &
+	Partial<Enableable> & {
+		_component: Component | undefined
+		_rendererKey: string | undefined
+		_modelProp: string
+		_componentProps?: (ctx: ComponentNodePropsContext) => Record<string, unknown>
+		_extraProps?: (ctx: ComponentNodePropsContext) => Record<string, unknown>
+		_tweaks?: TweakDef[]
+	}
+
+function resolveComponent(node: RenderableValueNode): Component | undefined {
+	return node._component ?? (node._rendererKey ? props.appComponents?.[node._rendererKey] : undefined)
+}
+
+function titleClass(depth: number): string {
+	if (depth === 0) return 'text-lg font-extrabold text-contrast'
+	if (depth === 1) return 'text-base font-semibold'
+	if (depth === 2) return 'text-sm font-semibold'
+	return ''
+}
+
+function getTitle(node: object): string | undefined {
+	if (!hasCap(node, '_title')) return undefined
+	const title = node._title as Reactive<string> | undefined
+	if (title === undefined) return undefined
+	return resolve(title) || undefined
+}
+
+function needsAttention(node: object): boolean {
+	return metaCtx?.value.attentionMap.get(node) ?? false
+}
+
+function isFixActionable(node: object): boolean {
+	return metaCtx?.value.metaMap.get(node)?.isFixActionable ?? false
+}
+
+const wrappedState = computed(() => withDefaults(props.state, props.nodes, props.write))
+
+function isEnabled(node: Partial<Enableable>): boolean {
+	if (node._enabled === undefined) return true
+	if (typeof node._enabled === 'function') return node._enabled(wrappedState.value)
+	return resolve(node._enabled)
+}
+
+function toggleSetValue(node: RenderableValueNode, value: string): void {
+	const current = getEffectiveValue(node, props.state[node.id], wrappedState.value) as unknown as string[]
+	const set = new Set(Array.isArray(current) ? current : [])
+	if (set.has(value)) set.delete(value)
+	else set.add(value)
+	writeNodeValue(node, props.state, props.write, Array.from(set) as never, wrappedState.value)
+}
+
+const DROPDOWN_TRIGGER_CHROME_PX = 16 * 2 + 10 + 20 + 2
+let measureEl: HTMLSpanElement | null = null
+function measureLabelWidth(label: string): number {
+	if (typeof document === 'undefined') return 0
+	if (!measureEl) {
+		measureEl = document.createElement('span')
+		measureEl.className = 'min-w-0 truncate text-primary font-semibold leading-tight'
+		Object.assign(measureEl.style, {
+			position: 'absolute',
+			visibility: 'hidden',
+			whiteSpace: 'nowrap',
+			left: '-9999px',
+			top: '0',
+		})
+		document.body.appendChild(measureEl)
+	}
+	measureEl.textContent = label
+	return measureEl.getBoundingClientRect().width
+}
+
+const dropdownMinWidthCache = new Map<string, string>()
+function getDropdownMinWidth(options: { label: string }[]): string {
+	const key = options.map((o) => o.label).join(' ')
+	const cached = dropdownMinWidthCache.get(key)
+	if (cached) return cached
+	const maxLabelWidth = Math.max(0, ...options.map((o) => measureLabelWidth(o.label)))
+	const result = `${Math.ceil(maxLabelWidth) + DROPDOWN_TRIGGER_CHROME_PX}px`
+	dropdownMinWidthCache.set(key, result)
+	return result
+}
+
+function componentProps(node: RenderableValueNode): Record<string, unknown> {
+	const ctx: ComponentNodePropsContext = {
+		onImageUpload: props.onImageUpload,
+		toggleSetValue: (value) => toggleSetValue(node, value),
+		nodeFacts: { needsAttention: needsAttention(node), fixActionable: isFixActionable(node) },
+		tooltip: resolveTooltip(node),
+	}
+	const dropdownStyle = hasOptionsCap(node)
+		? {
+				class: '!w-auto max-w-full',
+				style: { minWidth: getDropdownMinWidth(node._options as unknown as { label: string }[]) },
+			}
+		: undefined
+	return {
+		disabled: !isEnabled(node),
+		...dropdownStyle,
+		...node._componentProps?.(ctx),
+		...node._extraProps?.(ctx),
+	}
+}
+
+function containerScope(node: HasChildren & Partial<Identified>): {
+	state: Record<string, NodeState>
+	write: Writer
+} {
+	if (hasCap(node, '_stateOrigin') && node._stateOrigin && props.globalState) {
+		return originScope(props.globalState, node._stateOrigin as string[])
+	}
+	if (!hasIdCap(node)) return { state: props.state, write: props.write }
+	const raw = props.state[node.id]
+	const state = raw && typeof raw === 'object' && !(raw instanceof Set) ? (raw as Record<string, NodeState>) : {}
+	return { state, write: childWriter(props.state, props.write, node.id) }
+}
+
+function valueScope(node: HasValue & Identified): { state: Record<string, NodeState>; write: Writer } {
+	const state = getBooleanChildState(props.state[node.id])
+	return { state, write: childWriter(props.state, props.write, node.id) }
+}
+
+const TOOLTIP_BASE = {
+	delay: { show: 500, hide: 0 },
+	triggers: ['hover', 'focus'],
+	placement: 'top',
+}
+
+function resolveTooltip(node: object): Record<string, unknown> | undefined {
+	if (hasCap(node, '_tooltip')) {
+		const t = node._tooltip as Reactive<string> | ((state: Record<string, NodeState>) => string) | undefined
+		if (t !== undefined) {
+			const content = typeof t === 'function' ? t(wrappedState.value) : resolve(t)
+			if (content) return { ...TOOLTIP_BASE, content }
+		}
+	}
+	const html = hasCap(node, '_segments') ? metaCtx?.value.tooltipHtml.get(node) : undefined
+	return html ? { ...TOOLTIP_BASE, content: html, html: true } : undefined
+}
+
+function clickButton(node: object): void {
+	if (!hasCap(node, '_onClick')) return
+	;(node._onClick as (state: Record<string, NodeState>) => void)?.(wrappedState.value)
+}
+
+function tweakCurrent(node: RenderableValueNode): unknown {
+	return getEffectiveValue(node, props.state[node.id], wrappedState.value)
+}
+
+function tweakResult(tweak: TweakDef, node: RenderableValueNode): unknown {
+	return tweak.compute(tweakCurrent(node), wrappedState.value)
+}
+
+function tweakEnabled(tweak: TweakDef, node: RenderableValueNode): boolean {
+	const result = tweakResult(tweak, node)
+	return result !== null && result !== undefined && result !== tweakCurrent(node)
+}
+
+function tweakTooltip(tweak: TweakDef, node: RenderableValueNode): Record<string, unknown> | undefined {
+	if (!tweakEnabled(tweak, node)) return undefined
+	const content = tweakResult(tweak, node)
+	return content ? { ...TOOLTIP_BASE, content: String(content) } : undefined
+}
+
+function applyTweak(tweak: TweakDef, node: RenderableValueNode): void {
+	const result = tweakResult(tweak, node)
+	if (result !== null && result !== undefined) {
+		updateValue(node, result)
+	}
+}
+
+function nodeKey(item: ChildNode, idx: number): string {
+	return typeof item === 'object' && item !== null && hasIdCap(item) ? item.id : `n-${idx}`
+}
+
+function modelProp(item: object): string {
+	return (item as RenderableValueNode)._modelProp
+}
+
+function updateEvent(item: object): string {
+	return `update:${modelProp(item)}`
+}
+
+function updateValue(item: RenderableValueNode, v: unknown): void {
+	const onChange = hasCap(item, '_onChange') ? (item._onChange as OnChangeFn | undefined) : undefined
+	if (onChange) {
+		const result = onChange(v as string, { override: (ov) => ({ __override: ov }) })
+		if (result && typeof result === 'object' && '__override' in result) {
+			writeNodeValue(item, props.state, props.write, result.__override as never, wrappedState.value)
+			return
+		}
+	}
+	writeNodeValue(item, props.state, props.write, v as never, wrappedState.value)
+}
+
+const seenOnChangeValues = new Map<object, unknown>()
+
+watchEffect(() => {
+	for (const node of props.nodes) {
+		if (typeof node !== 'object' || node === null) continue
+		if (!hasCap(node, '_onChange') || !(node as { _onChange: unknown })._onChange) continue
+		if (!hasValueCap(node) || !hasIdCap(node)) continue
+		if (!isShown(node as AnyNode)) continue
+		const value = getEffectiveValue(node, props.state[node.id], wrappedState.value)
+		if (seenOnChangeValues.has(node) && seenOnChangeValues.get(node) === value) continue
+		seenOnChangeValues.set(node, value)
+		const onChange = (node as RenderableValueNode)._onChange as OnChangeFn | undefined
+		onChange?.(value as never, { override: (ov) => ({ __override: ov }) })
+	}
+})
+</script>
+
+<template>
+	<div :class="[flex ? 'flex flex-wrap gap-2' : 'space-y-4', 'w-full']">
+		<template v-for="(item, idx) in nodes" :key="nodeKey(item, idx)">
+			<template v-if="typeof item !== 'object' || item === null">
+				<template v-if="typeof item === 'string'">{{ item }}</template>
+				<component :is="item" v-else />
+			</template>
+
+			<template v-else-if="isShown(item)">
+				<div
+					:class="
+						hasChildrenCap(item) && !hasValueCap(item)
+							? 'w-full'
+							: !getTitle(item)
+								? 'contents'
+								: undefined
+					"
+				>
+					<div v-if="getTitle(item)" class="mb-2" :class="titleClass(titleDepth ?? 0)">
+						<span
+							v-html="renderString(getTitle(item)!).replace(/^<p>([\s\S]*)<\/p>\n?$/, '$1')"
+						/><span v-if="needsAttention(item)" class="text-red">*</span>
+					</div>
+
+					<template v-if="hasChildrenCap(item) && !hasValueCap(item)">
+						<NodeRenderer
+							:nodes="resolveChildren(item, containerScope(item).state)"
+							:state="containerScope(item).state"
+							:write="containerScope(item).write"
+							:on-image-upload="onImageUpload"
+							:app-components="appComponents"
+							:global-state="globalState"
+							:flex="(item as any)._layout !== 'column'"
+							:title-depth="getTitle(item) !== undefined ? (titleDepth ?? 0) + 1 : titleDepth"
+						/>
+					</template>
+
+					<template v-else-if="hasValueCap(item) && hasIdCap(item)">
+						<component
+							:is="resolveComponent(item as RenderableValueNode)"
+							v-tooltip="resolveComponent(item as RenderableValueNode) === ActionButton ? undefined : resolveTooltip(item)"
+							v-bind="componentProps(item as RenderableValueNode)"
+							:[modelProp(item)]="getEffectiveValue(item as RenderableValueNode, state[item.id], wrappedState)"
+							@[updateEvent(item)]="(v: unknown) => updateValue(item as RenderableValueNode, v)"
+						/>
+						<template
+							v-for="(tweak, tIdx) in (item as RenderableValueNode)._tweaks ?? []"
+							:key="`tweak-${tIdx}`"
+						>
+							<ButtonStyled circular>
+								<button
+									v-tooltip="tweakTooltip(tweak, item as RenderableValueNode)"
+									:disabled="!tweakEnabled(tweak, item as RenderableValueNode)"
+									@click="applyTweak(tweak, item as RenderableValueNode)"
+								>
+									<component :is="tweak.icon" />
+								</button>
+							</ButtonStyled>
+						</template>
+					</template>
+
+					<template v-else-if="hasCap(item, '_onClick')">
+						<ButtonStyled :circular="!!(item as any)._icon && !(item as any).label">
+							<button
+								v-tooltip="resolveTooltip(item)"
+								:disabled="!isEnabled(item as any)"
+								:aria-label="(item as any)._icon ? (item as any).label : undefined"
+								@click="clickButton(item)"
+							>
+								<component :is="(item as any)._icon" v-if="(item as any)._icon" />
+								<template v-else>{{ (item as any).label }}</template>
+							</button>
+						</ButtonStyled>
+					</template>
+				</div>
+			</template>
+		</template>
+
+		<template v-for="(item, idx) in nodes" :key="`children-${nodeKey(item, idx)}`">
+			<NodeRenderer
+				v-if="
+					typeof item === 'object' &&
+					item !== null &&
+					isShown(item) &&
+					hasValueCap(item) &&
+					hasIdCap(item) &&
+					hasChildrenCap(item) &&
+					isNodeActive(item, state[item.id], wrappedState) &&
+					resolveChildren(item, valueScope(item).state).length
+				"
+				:nodes="resolveChildren(item, valueScope(item).state)"
+				:state="valueScope(item).state"
+				:write="valueScope(item).write"
+				:on-image-upload="onImageUpload"
+				:app-components="appComponents"
+				:global-state="globalState"
+				:title-depth="getTitle(item) !== undefined ? (titleDepth ?? 0) + 1 : titleDepth"
+				class="w-full"
+			/>
+		</template>
+	</div>
+</template>
diff --git a/packages/moderation/src/types/node/context.ts b/packages/moderation/src/types/node/context.ts
new file mode 100644
index 0000000000..d00be856d4
--- /dev/null
+++ b/packages/moderation/src/types/node/context.ts
@@ -0,0 +1,11 @@
+import type { InjectionKey, Ref } from 'vue'
+
+import type { NodeMeta } from './node-meta'
+
+export interface ChecklistMetaContext {
+	metaMap: Map<object, NodeMeta>
+	attentionMap: Map<object, boolean>
+	tooltipHtml: Map<object, string>
+}
+
+export const CHECKLIST_META_KEY: InjectionKey<Ref<ChecklistMetaContext>> = Symbol('checklistMeta')
diff --git a/packages/moderation/src/types/node/factories.ts b/packages/moderation/src/types/node/factories.ts
new file mode 100644
index 0000000000..1658f22de9
--- /dev/null
+++ b/packages/moderation/src/types/node/factories.ts
@@ -0,0 +1,368 @@
+import {Checkbox, Combobox, MarkdownEditor, StyledInput, Toggle} from "@modrinth/ui"
+import {markRaw} from "vue"
+
+import {
+  withExtraProps,
+  withEditable,
+  withNoneLabel,
+  withEnabled,
+  withFix,
+  withValue,
+  withIcon,
+  withId,
+  withLayout,
+  withMessaging,
+  withComponent,
+  withOnClick,
+  withPriority,
+  withRequired,
+  withSelectable,
+  withStageMeta,
+  withStateOrigin,
+  withTitle,
+  withTooltip,
+  withTweak,
+  withShown,
+} from "./capabilities"
+import type {ComponentNodePropsContext} from "./capabilities"
+import {withChildren, withAutoProps} from "./builder"
+import ActionButton from "./components/ActionButton.vue"
+import {pipe} from "./pipe"
+import type {NodeState, NodeStateWithChildren} from "./state"
+
+function getBooleanValue(raw: NodeState): boolean {
+  if (typeof raw === "boolean") return raw
+  if (raw && typeof raw === "object" && !(raw instanceof Set)) {
+    const v = (raw as NodeStateWithChildren).value
+    if (typeof v === "boolean") return v
+  }
+  return false
+}
+
+function setBooleanValue(raw: NodeState, next: boolean, isDefault?: boolean): NodeState {
+  if (raw && typeof raw === "object" && !(raw instanceof Set)) {
+    const {value: _v, ...children} = raw as NodeStateWithChildren & Record<string, NodeState>
+    if (Object.keys(children).length > 0) return isDefault ? children : {...children, value: next}
+  }
+  return isDefault ? undefined : next
+}
+
+export const booleanValue = {
+  _getValue: getBooleanValue,
+  _setValue: setBooleanValue,
+  _isActive: (v: boolean) => v === true,
+}
+
+export function toggle(id: string, label: string) {
+  return pipe(
+    {label} as { label: string },
+    (n) => withId(n, id),
+    withChildren,
+    withShown,
+    withIcon,
+    withTooltip,
+    withTitle,
+    withMessaging,
+    withPriority,
+    withRequired,
+    withFix,
+    withEnabled,
+    (n) => withValue(n, booleanValue),
+    (n) =>
+      withComponent(n, {
+        component: markRaw(ActionButton),
+        componentProps: (ctx) => ({
+          label: n.label,
+          icon: n._icon,
+          needsAttention: ctx.nodeFacts?.needsAttention ?? false,
+          fixActionable: ctx.nodeFacts?.fixActionable ?? false,
+          tooltip: ctx.tooltip,
+        }),
+      }),
+  )
+}
+
+export function button(label?: string) {
+  return pipe(
+    {label} as {label?: string},
+    withShown,
+    withIcon,
+    withTooltip,
+    withEnabled,
+    withOnClick,
+  )
+}
+
+export function check(id: string, label: string) {
+  return withAutoProps(
+    pipe(
+      {label} as { label: string },
+      (n) => withId(n, id),
+      withChildren,
+      withShown,
+      withTooltip,
+      withTitle,
+      withMessaging,
+      withPriority,
+      withRequired,
+      withFix,
+      withEnabled,
+      (n) => withValue(n, booleanValue),
+      (n) =>
+        withComponent(n, {
+          component: markRaw(Checkbox),
+          componentProps: () => ({label}),
+        }),
+      withExtraProps,
+    ),
+  )
+}
+
+export function toggleSwitch(id: string, label: string) {
+  return withAutoProps(
+    pipe(
+      {label} as { label: string },
+      (n) => withId(n, id),
+      withChildren,
+      withShown,
+      withTooltip,
+      withTitle,
+      withMessaging,
+      withPriority,
+      withRequired,
+      withFix,
+      withEnabled,
+      (n) => withValue(n, booleanValue),
+      (n) => withComponent(n, {component: markRaw(Toggle)}),
+      withExtraProps,
+    ),
+  )
+}
+
+export function group(id?: string) {
+  const base = pipe(
+    {} as {},
+    withChildren,
+    withShown,
+    withTitle,
+    withRequired,
+    withSelectable,
+    withLayout,
+  )
+  return id === undefined ? base : withId(base, id)
+}
+
+export type GroupNode = ReturnType<typeof group>
+
+export function externalGroup(path: string[]) {
+  return pipe(
+    {} as {},
+    withChildren,
+    withShown,
+    (n) => withStateOrigin(n).stateOrigin(path),
+  )
+}
+
+const optionValue = {
+  _getValue: () => true,
+  _setValue: () => undefined,
+  _isActive: () => true,
+}
+
+export function option(value: string, label: string) {
+  return pipe(
+    {value, label} as { value: string; label: string },
+    withChildren,
+    withShown,
+    withMessaging,
+    withPriority,
+    (n) => withValue(n, optionValue),
+  )
+}
+
+type OptionNode = ReturnType<typeof option>
+
+interface HasOptions {
+  _options: OptionNode[]
+  options(this: this, ...opts: OptionNode[]): this
+}
+
+function withOptions<T extends object>(node: T): T & HasOptions {
+  return Object.assign(node, {
+    _options: [] as OptionNode[],
+    options(this: any, ...opts: OptionNode[]) {
+      this._options = opts
+      return this
+    },
+  })
+}
+
+function getStringValue(raw: NodeState): string {
+  if (typeof raw === "string") return raw
+  if (raw && typeof raw === "object" && !(raw instanceof Set)) {
+    const v = (raw as NodeStateWithChildren).value
+    if (typeof v === "string") return v
+  }
+  return ""
+}
+
+function setStringValue(raw: NodeState, next: string, isDefault?: boolean): NodeState {
+  if (raw && typeof raw === "object" && !(raw instanceof Set)) {
+    const {value: _v, ...children} = raw as NodeStateWithChildren & Record<string, NodeState>
+    if (Object.keys(children).length > 0) return isDefault ? children : {...children, value: next}
+  }
+  return isDefault ? undefined : next
+}
+
+const dropdownValue = {
+  _getValue: getStringValue,
+  _setValue: setStringValue,
+  _isActive: (v: string) => v !== "",
+}
+
+export function dropdown(id: string) {
+  return pipe(
+    {} as {},
+    (n) => withId(n, id),
+    withShown,
+    withTitle,
+    withRequired,
+    (n) => withValue(n, dropdownValue),
+    withNoneLabel,
+    withOptions,
+    (n) =>
+      withComponent(n, {
+        component: markRaw(Combobox),
+        componentProps: () => ({
+          options: [
+            ...(n._none !== undefined ? [{value: "", label: n._none}] : []),
+            ...n._options.map((o) => ({value: o.value, label: o.label})),
+          ],
+          triggerClass:
+            "!bg-[var(--color-button-bg)] !rounded-[var(--radius-md)] !shadow-[var(--shadow-inset-sm),0_0_0_0_transparent]",
+          dropdownClass: "!rounded-[var(--radius-md)] !bg-[var(--color-button-bg)] !border-0",
+        }),
+      }),
+  )
+}
+
+export function stage(id: string, title: string) {
+  return pipe(
+    {label: title} as { label: string },
+    (n) => withId(n, id),
+    withChildren,
+    withShown,
+    withIcon,
+    withStageMeta,
+    withMessaging,
+    withPriority,
+  )
+}
+
+export type StageNode = ReturnType<typeof stage>
+
+const stringValue = dropdownValue
+
+export function text(id: string) {
+  return withAutoProps(
+    pipe(
+      {} as {},
+      (n) => withId(n, id),
+      withChildren,
+      withShown,
+      withTooltip,
+      withTitle,
+      withMessaging,
+      withPriority,
+      withRequired,
+      withFix,
+      withEnabled,
+      withEditable,
+      (n) => Object.assign(n, {_showTooltip: true, _imperativeSync: true}),
+      (n) => withValue(n, stringValue),
+      withTweak,
+      (n) =>
+        withComponent(n, {
+          component: markRaw(StyledInput),
+          componentProps: () => ({class: "min-w-40 flex-1", autocomplete: "off"}),
+        }),
+      withExtraProps,
+    ),
+  )
+}
+
+export function markdown(id: string) {
+  return withAutoProps(
+    pipe(
+      {} as {},
+      (n) => withId(n, id),
+      withChildren,
+      withShown,
+      withTooltip,
+      withTitle,
+      withMessaging,
+      withPriority,
+      withRequired,
+      withFix,
+      withEnabled,
+      withEditable,
+      (n) => withValue(n, stringValue),
+      (n) =>
+        withComponent(n, {
+          component: markRaw(MarkdownEditor),
+          componentProps: (ctx) => ({
+            maxHeight: 300,
+            disabled: false,
+            headingButtons: false,
+            onImageUpload: ctx.onImageUpload,
+          }),
+        }),
+      withExtraProps,
+    ),
+  )
+}
+
+function getSetValue(raw: NodeState): string[] {
+  return raw instanceof Set ? Array.from(raw) : []
+}
+
+function setSetValue(_raw: NodeState, next: string[], isDefault?: boolean): NodeState {
+  return isDefault || next.length === 0 ? undefined : new Set(next)
+}
+
+const setValue = {
+  _getValue: getSetValue,
+  _setValue: setSetValue,
+  _isActive: (v: string[]) => v.length > 0,
+}
+
+const stringValueBehavior = {_getValue: getStringValue, _setValue: setStringValue, _isActive: (v: string) => v !== ""}
+
+export function appComponent(id: string, rendererKey: string) {
+  const node = pipe(
+    {} as {},
+    (n) => withId(n, id),
+    withChildren,
+    withShown,
+    withTooltip,
+    withTitle,
+    withMessaging,
+    withPriority,
+    withRequired,
+    withFix,
+    withEnabled,
+    (n) => withValue(n, stringValueBehavior),
+    (n) => withComponent(n, {rendererKey}),
+    withExtraProps,
+  )
+  return Object.assign(node, {
+    valueKind(this: any, kind: "boolean" | "string" | "set") {
+      Object.assign(this, kind === "boolean" ? booleanValue : kind === "set" ? setValue : stringValueBehavior)
+      return this
+    },
+    props(this: any, fn: (ctx: ComponentNodePropsContext) => Record<string, unknown>) {
+      this._extraProps = fn
+      return this
+    },
+  })
+}
diff --git a/packages/moderation/src/types/node/fix.ts b/packages/moderation/src/types/node/fix.ts
new file mode 100644
index 0000000000..33ec666ccd
--- /dev/null
+++ b/packages/moderation/src/types/node/fix.ts
@@ -0,0 +1,55 @@
+import type { Labrinth } from '@modrinth/api-client'
+
+import type { NodeState } from './state'
+
+export class FixBuilder {
+	_projectFn?: (
+		patch: Labrinth.Projects.v3.EditProjectRequest,
+		state: Record<string, NodeState>,
+	) => void
+	_versionFn?: (
+		patch: Labrinth.Versions.v3.ModifyVersionRequest,
+		state: Record<string, NodeState>,
+	) => void
+
+	project(
+		fn: (patch: Labrinth.Projects.v3.EditProjectRequest, state: Record<string, NodeState>) => void,
+	): this {
+		this._projectFn = fn
+		return this
+	}
+
+	version(
+		fn: (
+			patch: Labrinth.Versions.v3.ModifyVersionRequest,
+			state: Record<string, NodeState>,
+		) => void,
+	): this {
+		this._versionFn = fn
+		return this
+	}
+}
+
+export function fix(): FixBuilder {
+	return new FixBuilder()
+}
+
+export function createTrackedPatch<T extends object>(source: T): { proxy: T; changes: () => Partial<T> } {
+	const written = new Set<string | symbol>()
+	const data = { ...source }
+	const proxy = new Proxy(data, {
+		set(target, key, value) {
+			if (value !== (source as Record<string | symbol, unknown>)[key]) {
+				written.add(key)
+			} else {
+				written.delete(key)
+			}
+			;(target as Record<string | symbol, unknown>)[key] = value
+			return true
+		},
+	})
+	return {
+		proxy,
+		changes: () => Object.fromEntries([...written].map((k) => [k, data[k as keyof T]])) as Partial<T>,
+	}
+}
diff --git a/packages/moderation/src/types/node/index.ts b/packages/moderation/src/types/node/index.ts
new file mode 100644
index 0000000000..bb3a6aa2ed
--- /dev/null
+++ b/packages/moderation/src/types/node/index.ts
@@ -0,0 +1,12 @@
+export * from './builder'
+export * from './capabilities'
+export * from './collect'
+export * from './context'
+export * from './factories'
+export * from './fix'
+export * from './messages'
+export * from './mutate'
+export * from './node-meta'
+export * from './pipe'
+export * from './resolve'
+export * from './state'
diff --git a/packages/moderation/src/types/node/messages.ts b/packages/moderation/src/types/node/messages.ts
new file mode 100644
index 0000000000..1239371631
--- /dev/null
+++ b/packages/moderation/src/types/node/messages.ts
@@ -0,0 +1,121 @@
+import type { Labrinth } from '@modrinth/api-client'
+import type { Ref } from 'vue'
+
+import {
+	expandVariables,
+	flattenProjectV3Variables,
+	flattenProjectVariables,
+	flattenStaticVariables,
+} from '../../utils'
+import type { GetVarsFn, MessageSegment, NodeState } from './state'
+
+const messageFiles = import.meta.glob('../../data/messages/**/*.md', {
+	query: '?raw',
+	import: 'default',
+})
+
+export type MessageFn = ((state: Record<string, NodeState>) => Promise<string>) & {
+	concat(...others: MessageFn[]): MessageFn
+}
+
+function makeMessageFn(fn: (state: Record<string, NodeState>) => Promise<string>): MessageFn {
+	const rich = fn as MessageFn
+	rich.concat = (...others) =>
+		makeMessageFn(async (state) =>
+			(await Promise.all([rich, ...others].map((f) => f(state)))).join(''),
+		)
+	return rich
+}
+
+let _project: Ref<Labrinth.Projects.v3.Project> | null = null
+let _projectV2: Ref<Labrinth.Projects.v2.Project> | null = null
+let _onMissingMd: ((path: string) => void) | null = null
+
+export function setMissingMdHandler(handler: (path: string) => void) {
+	_onMissingMd = handler
+}
+
+export function setMessageProject(
+	project: Ref<Labrinth.Projects.v3.Project>,
+	projectV2: Ref<Labrinth.Projects.v2.Project>,
+) {
+	_project = project
+	_projectV2 = projectV2
+}
+
+export function mdEscape(text: string): string {
+	return text.replace(/[\\*_`[~]/g, '\\$&')
+}
+
+const USER_CONTENT_KEYS = ['PROJECT_TITLE', 'PROJECT_SLUG', 'PROJECT_SUMMARY', 'PROJECT_TYPE', 'PROJECT_STATUS']
+
+export async function loadMd(
+	path: string,
+	state: Record<string, NodeState>,
+	project: Labrinth.Projects.v3.Project,
+	projectV2: Labrinth.Projects.v2.Project,
+	getVars?: GetVarsFn,
+): Promise<string> {
+	const extraVars = getVars ? getVars(state) : null
+	const loader = messageFiles[`../../data/messages/${path}.md`]
+	if (!loader) {
+		_onMissingMd?.(path)
+		return ''
+	}
+	const raw = (await loader()) as string
+	const vars: Record<string, string> = {
+		...flattenStaticVariables(),
+		...flattenProjectVariables(projectV2),
+		...flattenProjectV3Variables(project),
+	}
+	for (const key of USER_CONTENT_KEYS) {
+		if (key in vars) vars[key] = mdEscape(vars[key])
+	}
+	if (extraVars) {
+		for (const [k, v] of Object.entries(extraVars)) {
+			vars[k] = String(v ?? '')
+		}
+	}
+	const expanded = expandVariables(raw, projectV2, project, vars)
+	return expanded.replace(/`[^`\n]*`/g, (match) => match.replace(/\\([\\*_`[~])/g, '$1'))
+}
+
+export function mdOptional(path: string, getVars?: GetVarsFn): MessageFn {
+	return makeMessageFn(async (state) => {
+		const loader = messageFiles[`../../data/messages/${path}.md`]
+		if (!loader) return ''
+		return loadMd(path, state, _project!.value, _projectV2!.value, getVars)
+	})
+}
+
+export function md(path: string | ((state: Record<string, NodeState>) => string), getVars?: GetVarsFn): MessageFn {
+	return makeMessageFn(async (state) => {
+		const resolvedPath = typeof path === 'function' ? path(state) : path
+		return loadMd(resolvedPath, state, _project!.value, _projectV2!.value, getVars)
+	})
+}
+
+export function resolveRelativeMessagePath(messagePath: string | (() => string), statePath: string[]): string {
+	const name = typeof messagePath === 'function' ? messagePath() : messagePath
+	if (name.startsWith('/')) return `checklist/messages${name}`
+	const parts = [...statePath.slice(0, -1), ...name.split('/')]
+	const normalized = parts.reduce<string[]>((acc, p) => {
+		if (p === '..') acc.pop()
+		else if (p) acc.push(p)
+		return acc
+	}, [])
+	return `checklist/messages/${normalized.join('/')}`
+}
+
+export async function evalSegment(
+	seg: MessageSegment,
+	state: Record<string, NodeState>,
+	statePath: string[],
+): Promise<string> {
+	if (seg.type === 'collect') return ''
+	if (seg.type === 'fn') return String((await seg.fn(state)) ?? '')
+	if (seg.type === 'auto') {
+		return loadMd(`checklist/messages/${statePath.join('/')}`, state, _project!.value, _projectV2!.value, seg.getVars)
+	}
+	return loadMd(resolveRelativeMessagePath(seg.path, statePath), state, _project!.value, _projectV2!.value, seg.getVars)
+}
diff --git a/packages/moderation/src/types/node/mutate.ts b/packages/moderation/src/types/node/mutate.ts
new file mode 100644
index 0000000000..b7707cc691
--- /dev/null
+++ b/packages/moderation/src/types/node/mutate.ts
@@ -0,0 +1,61 @@
+import type { HasValue, Identified } from './capabilities'
+import { getEffectiveValue } from './resolve'
+import type { NodeState } from './state'
+
+function valuesEqual(a: unknown, b: unknown): boolean {
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false
+		const setB = new Set(b)
+		return a.every((v) => setB.has(v))
+	}
+	return a === b
+}
+
+export type Writer = (id: string, value: NodeState) => void
+
+export function childWriter(
+	parentRead: Record<string, NodeState>,
+	parentWrite: Writer,
+	containerId: string,
+): Writer {
+	return (childId, value) => {
+		const existing = parentRead[containerId]
+		const container: Record<string, NodeState> =
+			existing && typeof existing === 'object' && !(existing instanceof Set)
+				? { ...(existing as Record<string, NodeState>) }
+				: existing !== undefined
+					? { value: existing }
+					: {}
+		if (value === undefined) delete container[childId]
+		else container[childId] = value
+		parentWrite(containerId, Object.keys(container).length === 0 ? undefined : container)
+	}
+}
+
+export function writeNodeValue<V>(
+	node: HasValue<V> & Identified,
+	read: Record<string, NodeState>,
+	write: Writer,
+	next: V,
+	contextState: Record<string, NodeState> = read,
+): void {
+	const isDefault = valuesEqual(next, getEffectiveValue(node, undefined, contextState))
+	write(node.id, node._setValue(read[node.id], next, isDefault))
+}
+
+export function originScope(
+	root: Record<string, NodeState>,
+	path: string[],
+): { state: Record<string, NodeState>; write: Writer } {
+	let state = root
+	let write: Writer = (id, value) => {
+		if (value === undefined) delete root[id]
+		else root[id] = value
+	}
+	for (const segment of path) {
+		write = childWriter(state, write, segment)
+		const raw = state[segment]
+		state = raw && typeof raw === 'object' && !(raw instanceof Set) ? (raw as Record<string, NodeState>) : {}
+	}
+	return { state, write }
+}
diff --git a/packages/moderation/src/types/node/node-meta.ts b/packages/moderation/src/types/node/node-meta.ts
new file mode 100644
index 0000000000..dc5ee98320
--- /dev/null
+++ b/packages/moderation/src/types/node/node-meta.ts
@@ -0,0 +1,107 @@
+import type { AnyNode, ChildNode, HasChildren } from './builder'
+import type { FixBuilder } from './fix'
+import { getBooleanChildState, hasCap, hasChildrenCap, hasIdCap, hasOptionsCap, hasValueCap, isNodeActive, isShown, resolveActionState, resolveChildren, walkNodes } from './resolve'
+import type { NodeState } from './state'
+
+export interface NodeMeta {
+	hasRequiredMissing: boolean
+	isFixActionable: boolean
+}
+
+export function computeNodeMeta(
+	children: ChildNode[],
+	stageState: Record<string, NodeState>,
+	isFixActionable: (fixes: FixBuilder[], state: Record<string, NodeState>) => boolean,
+): Map<object, NodeMeta> {
+	const map = new Map<object, NodeMeta>()
+
+	walkNodes(children, stageState, (node, nodeState, localState) => {
+		const active = isNodeActive(node, nodeState, localState)
+
+		const required = hasCap(node, '_required') && node._required === true
+		const hasRequiredMissing = required && !active
+
+		let fixActionable = false
+		if (active && hasCap(node, '_fixes')) {
+			const fixes = node._fixes as FixBuilder[]
+			if (fixes.length > 0) {
+				fixActionable = isFixActionable(fixes, resolveActionState(node, nodeState, localState))
+			}
+		}
+
+		map.set(node, { hasRequiredMissing, isFixActionable: fixActionable })
+	})
+
+	return map
+}
+
+export function computeAttentionMap(
+	nodes: ChildNode[],
+	stageState: Record<string, NodeState>,
+	metaMap: Map<object, NodeMeta>,
+	attention: Map<object, boolean> = new Map(),
+): Map<object, boolean> {
+	for (const node of nodes) {
+		if (typeof node !== 'object' || node === null) continue
+		if (!isShown(node as AnyNode)) continue
+
+		if (hasChildrenCap(node) && !hasValueCap(node)) {
+			const childState = childScopeFor(node, stageState)
+			computeAttentionMap(resolveChildren(node, childState), childState, metaMap, attention)
+			const childrenNeedAttention = someChildNeedsAttention(node, childState, attention)
+			const ownRequired = hasCap(node, '_required') && node._required === true
+			const unsatisfied = ownRequired && !hasActiveChild(node, childState)
+			attention.set(node, unsatisfied || childrenNeedAttention)
+			continue
+		}
+
+		if (hasValueCap(node) && hasIdCap(node)) {
+			const rawNodeState = stageState[node.id]
+			const active = isNodeActive(node, rawNodeState, stageState)
+			let childrenNeedAttention = false
+
+			if (active) {
+				if (hasOptionsCap(node)) {
+					const selectedValue = typeof rawNodeState === 'string' ? rawNodeState : undefined
+					const selected = node._options.find((o) => o.value === selectedValue)
+					if (selected && isShown(selected) && hasChildrenCap(selected)) {
+						computeAttentionMap(resolveChildren(selected, stageState), stageState, metaMap, attention)
+						childrenNeedAttention = someChildNeedsAttention(selected, stageState, attention)
+					}
+				} else if (hasChildrenCap(node)) {
+					const childState = getBooleanChildState(rawNodeState)
+					computeAttentionMap(resolveChildren(node, childState), childState, metaMap, attention)
+					childrenNeedAttention = someChildNeedsAttention(node, childState, attention)
+				}
+			}
+
+			const ownMissing = metaMap.get(node)?.hasRequiredMissing ?? false
+			attention.set(node, ownMissing || childrenNeedAttention)
+		}
+	}
+	return attention
+}
+
+function childScopeFor(node: HasChildren & { id?: string }, state: Record<string, NodeState>): Record<string, NodeState> {
+	if (!hasIdCap(node)) return state
+	const raw = state[node.id]
+	return raw && typeof raw === 'object' && !(raw instanceof Set) ? (raw as Record<string, NodeState>) : {}
+}
+
+function hasActiveChild(node: HasChildren, childState: Record<string, NodeState>): boolean {
+	return resolveChildren(node, childState).some((child) => {
+		if (typeof child !== 'object' || child === null) return false
+		const raw = hasIdCap(child) ? childState[child.id] : undefined
+		return isNodeActive(child, raw, childState)
+	})
+}
+
+function someChildNeedsAttention(
+	node: HasChildren,
+	childState: Record<string, NodeState>,
+	attention: Map<object, boolean>,
+): boolean {
+	return resolveChildren(node, childState).some(
+		(child) => typeof child === 'object' && child !== null && attention.get(child) === true,
+	)
+}
diff --git a/packages/moderation/src/types/node/pipe.ts b/packages/moderation/src/types/node/pipe.ts
new file mode 100644
index 0000000000..3726be2b03
--- /dev/null
+++ b/packages/moderation/src/types/node/pipe.ts
@@ -0,0 +1,29 @@
+export function pipe<A>(a: A): A
+export function pipe<A, B>(a: A, f1: (a: A) => B,): B
+export function pipe<A, B, C>(a: A, f1: (a: A) => B, f2: (b: B) => C,): C
+export function pipe<A, B, C, D>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D,): D
+export function pipe<A, B, C, D, E>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E,): E
+export function pipe<A, B, C, D, E, F>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F,): F
+export function pipe<A, B, C, D, E, F, G>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G,): G
+export function pipe<A, B, C, D, E, F, G, H>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H,): H
+export function pipe<A, B, C, D, E, F, G, H, I>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I,): I
+export function pipe<A, B, C, D, E, F, G, H, I, J>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J,): J
+export function pipe<A, B, C, D, E, F, G, H, I, J, K>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K,): K
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L,): L
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M,): M
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N,): N
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O,): O
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P,): P
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q,): Q
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q, f17: (q: Q) => R,): R
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q, f17: (q: Q) => R, f18: (r: R) => S,): S
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q, f17: (q: Q) => R, f18: (r: R) => S, f19: (s: S) => T,): T
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q, f17: (q: Q) => R, f18: (r: R) => S, f19: (s: S) => T, f20: (t: T) => U,): U
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q, f17: (q: Q) => R, f18: (r: R) => S, f19: (s: S) => T, f20: (t: T) => U, f21: (u: U) => V,): V
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q, f17: (q: Q) => R, f18: (r: R) => S, f19: (s: S) => T, f20: (t: T) => U, f21: (u: U) => V, f22: (v: V) => W,): W
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q, f17: (q: Q) => R, f18: (r: R) => S, f19: (s: S) => T, f20: (t: T) => U, f21: (u: U) => V, f22: (v: V) => W, f23: (w: W) => X,): X
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q, f17: (q: Q) => R, f18: (r: R) => S, f19: (s: S) => T, f20: (t: T) => U, f21: (u: U) => V, f22: (v: V) => W, f23: (w: W) => X, f24: (x: X) => Y,): Y
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z>(a: A, f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G, f7: (g: G) => H, f8: (h: H) => I, f9: (i: I) => J, f10: (j: J) => K, f11: (k: K) => L, f12: (l: L) => M, f13: (m: M) => N, f14: (n: N) => O, f15: (o: O) => P, f16: (p: P) => Q, f17: (q: Q) => R, f18: (r: R) => S, f19: (s: S) => T, f20: (t: T) => U, f21: (u: U) => V, f22: (v: V) => W, f23: (w: W) => X, f24: (x: X) => Y, f25: (y: Y) => Z,): Z
+export function pipe(a: unknown, ...fns: Array<(x: any) => unknown>): unknown {
+  return fns.reduce((acc, fn) => fn(acc), a)
+}
diff --git a/packages/moderation/src/types/node/resolve.ts b/packages/moderation/src/types/node/resolve.ts
new file mode 100644
index 0000000000..15c63db51f
--- /dev/null
+++ b/packages/moderation/src/types/node/resolve.ts
@@ -0,0 +1,324 @@
+import type { Ref } from 'vue'
+import { toValue } from 'vue'
+
+import type { AnyNode, ChildEntry, ChildNode, HasChildren } from './builder'
+import type { HasValue, Identified } from './capabilities'
+import { childWriter, writeNodeValue } from './mutate'
+import type { Writer } from './mutate'
+import type { NodeState, NodeStateWithChildren } from './state'
+import { resolve } from './state'
+
+export function hasCap<K extends string>(node: object, key: K): node is Record<K, unknown> {
+	return key in node
+}
+
+export function hasValueCap(node: object): node is HasValue {
+	return hasCap(node, '_getValue') && hasCap(node, '_isActive')
+}
+
+export function hasChildrenCap(node: object): node is HasChildren {
+	return hasCap(node, '_children')
+}
+
+export function hasOptionsCap(node: object): node is { _options: OptionLike[] } {
+	return hasCap(node, '_options')
+}
+
+export function hasIdCap(node: object): node is Identified {
+	return hasCap(node, 'id')
+}
+
+interface OptionLike extends AnyNode, Partial<HasChildren> {
+	value: string
+	_segments?: unknown[]
+}
+
+export function isShown(node: AnyNode): boolean {
+	return node._shown === undefined || resolve(node._shown)
+}
+
+export function getEffectiveValue<V>(
+	node: HasValue<V>,
+	rawState: NodeState,
+	contextState: Record<string, NodeState> = {},
+): V {
+	if (rawState !== undefined) return node._getValue(rawState)
+	if (node._defaultValue !== undefined) {
+		const def =
+			typeof node._defaultValue === 'function'
+				? (node._defaultValue as (state: Record<string, NodeState>) => NodeState)(contextState)
+				: (node._defaultValue as unknown as NodeState)
+		return node._getValue(def)
+	}
+	return node._getValue(rawState)
+}
+
+export function isNodeActive(
+	node: object,
+	rawState: NodeState,
+	contextState: Record<string, NodeState> = {},
+): boolean {
+	if (hasValueCap(node)) return node._isActive(getEffectiveValue(node, rawState, contextState))
+	return false
+}
+
+export function getBooleanChildState(nodeState: NodeState): Record<string, NodeState> {
+	if (nodeState && typeof nodeState === 'object' && !(nodeState instanceof Set)) {
+		return nodeState as Record<string, NodeState>
+	}
+	return {}
+}
+
+export function resolveChildren(
+	node: HasChildren,
+	state: Record<string, NodeState>,
+): ChildNode[] {
+	const entries: ChildEntry[] = node._childrenFn ? node._childrenFn(state) : node._children
+
+	const result: ChildNode[] = []
+	for (const entry of entries) {
+		if (entry == null) continue
+		if (typeof entry === 'string') {
+			result.push(entry)
+			continue
+		}
+		if (typeof entry === 'function') {
+			if (entry.length === 0) {
+				result.push(entry as () => unknown)
+				continue
+			}
+			const fn = entry as (state?: Record<string, NodeState>) => AnyNode | AnyNode[] | null
+			const resolved = fn(state)
+			if (resolved == null) continue
+			if (Array.isArray(resolved)) {
+				for (const r of resolved) {
+					if (r != null && isShown(r)) result.push(r)
+				}
+				continue
+			}
+			if (isShown(resolved)) result.push(resolved)
+			continue
+		}
+		const resolved = toValue(entry as AnyNode | Ref<AnyNode | null>)
+		if (resolved != null && isShown(resolved)) result.push(resolved)
+	}
+	return result
+}
+
+function buildChildMap(
+	children: ChildNode[],
+	stateForFlattening: Record<string, NodeState>,
+): Map<string, object> {
+	const map = new Map<string, object>()
+	function collect(nodes: ChildNode[]) {
+		for (const node of nodes) {
+			if (typeof node !== 'object' || node === null) continue
+			if (hasIdCap(node)) {
+				map.set(node.id, node)
+				continue
+			}
+			if (hasChildrenCap(node)) collect(resolveChildren(node, stateForFlattening))
+		}
+	}
+	collect(children)
+	return map
+}
+
+function optionChildrenFor(node: object, state: Record<string, NodeState>): ChildNode[] {
+	if (!hasOptionsCap(node) || !hasIdCap(node)) return []
+	const raw = state[node.id]
+	const selectedValue = typeof raw === 'string' ? raw : undefined
+	const selected = node._options.find((o) => o.value === selectedValue)
+	if (!selected || !hasChildrenCap(selected)) return []
+	return resolveChildren(selected, state)
+}
+
+export function withDefaults<T extends Record<string, NodeState>>(
+	rawState: T,
+	children: ChildNode[],
+	write?: Writer,
+): T {
+	if (rawState == null || typeof rawState !== 'object' || rawState instanceof Set) return rawState
+
+	const childMap = buildChildMap(children, rawState)
+	for (const [, node] of childMap) {
+		for (const c of optionChildrenFor(node, rawState)) {
+			if (typeof c === 'object' && c !== null && hasIdCap(c)) childMap.set(c.id, c)
+		}
+	}
+	const resolving = new Set<string>()
+
+	const proxy = new Proxy(rawState, {
+		get(target, key, receiver) {
+			if (typeof key !== 'string') return Reflect.get(target, key, receiver)
+			const child = childMap.get(key)
+			let value: NodeState = Reflect.get(target, key, receiver)
+
+			if (value === undefined && child && hasValueCap(child) && !resolving.has(key)) {
+				resolving.add(key)
+				try {
+					const effective = getEffectiveValue(child, undefined, proxy)
+					const grandchildren = hasChildrenCap(child) ? resolveChildren(child, {}) : []
+					if (grandchildren.length > 0) {
+						return withDefaults(
+							{ value: effective } as Record<string, NodeState>,
+							grandchildren,
+							write && childWriter(target, write, key),
+						)
+					}
+					value = child._setValue(undefined, effective)
+				} finally {
+					resolving.delete(key)
+				}
+			}
+
+			if (
+				child &&
+				hasChildrenCap(child) &&
+				value !== null &&
+				typeof value === 'object' &&
+				!(value instanceof Set)
+			) {
+				const nested = value as Record<string, NodeState>
+				return withDefaults(nested, resolveChildren(child, nested), write && childWriter(target, write, key))
+			}
+
+			if (value === undefined && child && hasChildrenCap(child)) {
+				const grandchildren = resolveChildren(child, {})
+				if (grandchildren.length > 0) return emptyScope(grandchildren)
+			}
+
+			return value
+		},
+		set(target, key, value, receiver) {
+			if (typeof key !== 'string') return Reflect.set(target, key, value, receiver)
+			const child = childMap.get(key)
+			if (child && hasValueCap(child) && write) {
+				writeNodeValue(child as HasValue & Identified, target, write, value as never, proxy)
+				return true
+			}
+			return Reflect.set(target, key, value, receiver)
+		},
+	}) as T
+
+	return proxy
+}
+
+export function resolveActionState(
+	node: object,
+	nodeState: NodeState,
+	localState: Record<string, NodeState>,
+): Record<string, NodeState> {
+	if (!hasValueCap(node)) return localState
+	const childState = getBooleanChildState(nodeState)
+	const base = hasChildrenCap(node)
+		? withDefaults(childState, resolveChildren(node, childState))
+		: childState
+	return new Proxy(base, {
+		get(target, key, receiver) {
+			if (key === 'value') return getEffectiveValue(node, nodeState, localState) as NodeState
+			return Reflect.get(target, key, receiver)
+		},
+	})
+}
+
+function emptyScope(children: ChildNode[]): Record<string, NodeState> {
+	const childMap = buildChildMap(children, {})
+	const resolving = new Set<string>()
+	const cache = new Map<string, Record<string, NodeState>>()
+
+	const proxy: Record<string, NodeState> = new Proxy(
+		{},
+		{
+			get(_target, key) {
+				if (typeof key !== 'string') return undefined
+				const child = childMap.get(key)
+				if (!child) return undefined
+
+				if (hasValueCap(child) && !resolving.has(key)) {
+					resolving.add(key)
+					try {
+						const def = getEffectiveValue(child, undefined, proxy)
+						if (def !== undefined) return child._setValue(undefined, def)
+					} finally {
+						resolving.delete(key)
+					}
+				}
+
+				if (!hasChildrenCap(child)) return undefined
+
+				const cached = cache.get(key)
+				if (cached) return cached
+
+				const grandchildren = resolveChildren(child, {})
+				if (grandchildren.length === 0) return undefined
+
+				const nested = emptyScope(grandchildren)
+				cache.set(key, nested)
+				return nested
+			},
+		},
+	) as Record<string, NodeState>
+
+	return proxy
+}
+
+export type Visitor = (
+	node: object,
+	nodeState: NodeState,
+	localState: Record<string, NodeState>,
+	path: string[],
+) => void
+
+export function walkNodes(
+	nodes: ChildNode[],
+	stageState: Record<string, NodeState>,
+	visitor: Visitor,
+	path: string[] = [],
+): void {
+	for (const node of nodes) {
+		if (typeof node !== 'object' || node === null) continue
+		if (!isShown(node as AnyNode)) continue
+
+		if (hasChildrenCap(node) && !hasValueCap(node)) {
+			if (hasIdCap(node)) {
+				const raw = stageState[node.id]
+				const childState =
+					raw && typeof raw === 'object' && !(raw instanceof Set)
+						? (raw as Record<string, NodeState>)
+						: {}
+				walkNodes(resolveChildren(node, childState), childState, visitor, [...path, node.id])
+			} else {
+				walkNodes(resolveChildren(node, stageState), stageState, visitor, path)
+			}
+			continue
+		}
+
+		if (hasValueCap(node) && hasIdCap(node)) {
+			const rawNodeState = stageState[node.id]
+			const nodePath = [...path, node.id]
+			visitor(node, rawNodeState, stageState, nodePath)
+
+			const active = isNodeActive(node, rawNodeState, stageState)
+			if (!active) continue
+
+			if (hasOptionsCap(node)) {
+				const selectedValue = typeof rawNodeState === 'string' ? rawNodeState : undefined
+				const selected = node._options.find((o) => o.value === selectedValue)
+				if (selected && isShown(selected)) {
+					const selectedPath = [...path, selected.value]
+					visitor(selected, undefined, stageState, selectedPath)
+					if (hasChildrenCap(selected)) {
+						walkNodes(resolveChildren(selected, stageState), stageState, visitor, selectedPath)
+					}
+				}
+				continue
+			}
+
+			if (hasChildrenCap(node)) {
+				const childState = getBooleanChildState(rawNodeState)
+				walkNodes(resolveChildren(node, childState), childState, visitor, nodePath)
+			}
+		}
+	}
+}
diff --git a/packages/moderation/src/types/node/state.ts b/packages/moderation/src/types/node/state.ts
new file mode 100644
index 0000000000..1bc140f65a
--- /dev/null
+++ b/packages/moderation/src/types/node/state.ts
@@ -0,0 +1,33 @@
+import type { Ref } from 'vue'
+import { toValue } from 'vue'
+
+export type ModerationStatus = 'approved' | 'rejected' | 'flagged'
+
+export type NodeState =
+	| boolean
+	| string
+	| number
+	| Set<string>
+	| NodeStateWithChildren
+	| null
+	| undefined
+
+export interface NodeStateWithChildren {
+	value?: NodeState
+	[childId: string]: NodeState
+}
+
+export type Reactive<T> = T | Ref<T>
+
+export function resolve<T>(value: Reactive<T>): T {
+	return toValue(value as T | Ref<T>)
+}
+
+export type GetVarsFn = (state: Record<string, any>) => Record<string, any>
+export type ContentFn = (state: Record<string, NodeState>) => string | Promise<string>
+
+export type MessageSegment =
+	| { type: 'fn'; fn: ContentFn }
+	| { type: 'auto'; getVars?: GetVarsFn }
+	| { type: 'path'; path: string | (() => string); getVars?: GetVarsFn }
+	| { type: 'collect'; fallback?: MessageSegment }
diff --git a/packages/moderation/src/types/stage.ts b/packages/moderation/src/types/stage.ts
deleted file mode 100644
index 0106f15cf5..0000000000
--- a/packages/moderation/src/types/stage.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-import type { Labrinth } from '@modrinth/api-client'
-import type { FunctionalComponent, SVGAttributes } from 'vue'
-
-import type { Action } from './actions'
-
-/**
- * Represents a moderation stage with associated actions and optional navigation logic.
- */
-export interface Stage {
-	/**
-	 * The title of the stage, displayed in the checklist header.
-	 */
-	title: string
-
-	/**
-	 * The hint for this stage, tells the moderator what to do.
-	 */
-	hint: string
-
-	/**
-	 * An optional description or additional text for the stage.
-	 */
-	text?: (
-		project: Labrinth.Projects.v2.Project,
-		projectV3?: Labrinth.Projects.v3.Project,
-	) => Promise<string>
-
-	/**
-	 * Optional id for the stage, used for identification in the checklist. Will be used in the stage list as well instead of the title.
-	 */
-	id?: string
-
-	/**
-	 * Optional icon for the stage, displayed in the stage list and next to the title.
-	 */
-	icon?: FunctionalComponent<SVGAttributes>
-
-	/**
-	 * URL to the guidance document for this stage.
-	 */
-	guidance_url: string
-
-	/**
-	 * An array of actions that can be taken in this stage.
-	 */
-	actions: Action[]
-
-	/**
-	 * Optional navigation path to redirect the moderator when this stage is shown.
-	 *
-	 * This is relative to the project page. For example, `/settings#side-types` would navigate to `https://modrinth.com/project/:id/settings#side-types`.
-	 */
-	navigate?: string
-
-	/**
-	 * A function that determines whether this stage should be shown for a given project.
-	 *
-	 * By default, it returns `true`, meaning the stage is always shown.
-	 */
-	shouldShow?: (
-		project: Labrinth.Projects.v2.Project,
-		projectV3?: Labrinth.Projects.v3.Project,
-	) => boolean
-}
diff --git a/packages/moderation/src/utils.ts b/packages/moderation/src/utils.ts
index 8dee37e103..3df242bf55 100644
--- a/packages/moderation/src/utils.ts
+++ b/packages/moderation/src/utils.ts
@@ -1,181 +1,5 @@
 import type { Labrinth } from '@modrinth/api-client'
 
-import type {
-	Action,
-	AdditionalTextInput,
-	ButtonAction,
-	ConditionalMessage,
-	ToggleAction,
-} from './types/actions'
-
-export interface ActionState {
-	selected: boolean
-	value?: Set<string | number> | number | string | unknown
-}
-
-export interface MessagePart {
-	weight: number
-	content: string
-	actionId: string
-	stageIndex: number
-}
-
-export function getActionIdForStage(
-	action: Action,
-	stageIndex: number,
-	actionIndex?: number,
-	enabledIndex?: number,
-): string {
-	if (action.id) {
-		return `stage-${stageIndex}-${action.id}`
-	}
-	const suffix = enabledIndex !== undefined ? `-enabled-${enabledIndex}` : ''
-	return `stage-${stageIndex}-action-${actionIndex}${suffix}`
-}
-
-export function getActionId(action: Action, currentStage: number, index?: number): string {
-	return getActionIdForStage(action, currentStage, index)
-}
-
-export function getActionKey(
-	action: Action,
-	currentStage: number,
-	visibleActions: Action[],
-): string {
-	const index = visibleActions.indexOf(action)
-	return `${currentStage}-${index}-${getActionId(action, currentStage)}`
-}
-
-export function initializeActionState(action: Action): ActionState {
-	if (action.type === 'toggle') {
-		return {
-			selected: action.defaultChecked || false,
-		}
-	} else if (action.type === 'dropdown') {
-		return {
-			selected: true,
-			value: action.defaultOption || 0,
-		}
-	} else if (action.type === 'multi-select-chips') {
-		return {
-			selected: false,
-			value: new Set<string | number>(),
-		}
-	} else {
-		return {
-			selected: false,
-		}
-	}
-}
-
-export function processMessage(
-	message: string,
-	action: Action,
-	stageIndex: number,
-	textInputValues: Record<string, string>,
-): string {
-	let processedMessage = message
-
-	if (action.relevantExtraInput) {
-		action.relevantExtraInput.forEach((input, index) => {
-			if (input.variable) {
-				const inputKey = `stage-${stageIndex}-${action.id || `action-${index}`}-${index}`
-				const value = textInputValues[inputKey] || ''
-
-				const regex = new RegExp(`%${input.variable}%`, 'g')
-				processedMessage = processedMessage.replace(regex, value)
-			}
-		})
-	}
-
-	return processedMessage
-}
-
-export function findMatchingVariant(
-	variants: ConditionalMessage[],
-	selectedActionIds: string[],
-	allValidActionIds?: string[],
-	currentStageIndex?: number,
-): ConditionalMessage | null {
-	for (const variant of variants) {
-		const conditions = variant.conditions
-
-		const meetsRequired =
-			!conditions.requiredActions ||
-			conditions.requiredActions.every((id) => {
-				let fullId = id
-				if (currentStageIndex !== undefined && !id.startsWith('stage-')) {
-					fullId = `stage-${currentStageIndex}-${id}`
-				}
-
-				if (allValidActionIds && !allValidActionIds.includes(fullId)) {
-					return false
-				}
-				return selectedActionIds.includes(fullId)
-			})
-
-		const meetsExcluded =
-			!conditions.excludedActions ||
-			!conditions.excludedActions.some((id) => {
-				let fullId = id
-				if (currentStageIndex !== undefined && !id.startsWith('stage-')) {
-					fullId = `stage-${currentStageIndex}-${id}`
-				}
-				return selectedActionIds.includes(fullId)
-			})
-
-		if (meetsRequired && meetsExcluded) {
-			return variant
-		}
-	}
-
-	return null
-}
-
-export async function getActionMessage(
-	action: ButtonAction | ToggleAction,
-	selectedActionIds: string[],
-	allValidActionIds?: string[],
-): Promise<string> {
-	if (action.conditionalMessages && action.conditionalMessages.length > 0) {
-		const matchingConditional = findMatchingVariant(
-			action.conditionalMessages,
-			selectedActionIds,
-			allValidActionIds,
-		)
-		if (matchingConditional) {
-			return (await matchingConditional.message()) as string
-		}
-	}
-
-	return (await action.message()) as string
-}
-
-export function getVisibleInputs(
-	action: Action,
-	actionStates: Record<string, ActionState>,
-): AdditionalTextInput[] {
-	if (!action.relevantExtraInput) return []
-
-	const selectedActionIds = Object.entries(actionStates)
-		.filter(([, state]) => state.selected)
-		.map(([id]) => id)
-
-	return action.relevantExtraInput.filter((input) => {
-		if (!input.showWhen) return true
-
-		const meetsRequired =
-			!input.showWhen.requiredActions ||
-			input.showWhen.requiredActions.every((id) => selectedActionIds.includes(id))
-
-		const meetsExcluded =
-			!input.showWhen.excludedActions ||
-			!input.showWhen.excludedActions.some((id) => selectedActionIds.includes(id))
-
-		return meetsRequired && meetsExcluded
-	})
-}
-
 export function expandVariables(
 	template: string,
 	project: Labrinth.Projects.v2.Project,
@@ -283,35 +107,6 @@ export function formatProjectTypes(type: string, lower: boolean = false) {
 	return value
 }
 
-export function formatEnvironments(environment: string, lower: boolean = false) {
-	let value = environment
-	try {
-		value = value
-			.replaceAll('client_only_server_optional', 'Client and server: Optional on server')
-			.replaceAll('client_and_server', 'Required on both')
-			.replaceAll('client_only', 'Client-side only')
-			.replaceAll('server_only_client_optional', 'Client optional')
-			.replaceAll('dedicated_server_only', 'Dedicated server only')
-			.replaceAll('server_only', 'Servers and Singleplayer')
-			.replaceAll('singleplayer_only', 'Singleplayer only')
-			.replaceAll(
-				'client_or_server_prefers_both',
-				'Optional on both, works best when installed on both sides',
-			)
-			.replaceAll(
-				'client_or_server',
-				'Optional on both, works the same if installed on either side',
-			)
-			// This shouldn't come up for this use but yk
-			.replaceAll('unknown', 'Unknown')
-	} catch {
-		return 'No project environment'
-	}
-
-	if (lower === true) value = value.toLowerCase()
-	return value
-}
-
 export function requiresEnvironmentInfo(projectTypes): boolean {
 	return projectTypes.includes('mod') || projectTypes.includes('modpack')
 }
diff --git a/packages/ui/src/components/project/ProjectPageVersions.vue b/packages/ui/src/components/project/ProjectPageVersions.vue
index 012fea3115..eef51469b4 100644
--- a/packages/ui/src/components/project/ProjectPageVersions.vue
+++ b/packages/ui/src/components/project/ProjectPageVersions.vue
@@ -457,7 +457,7 @@ import {
 	VersionChannelIndicator,
 	VersionFilterControl,
 } from '@modrinth/ui'
-import { formatVersionsForDisplay, type GameVersionTag, type Version } from '@modrinth/utils'
+import { formatVersionsForDisplay, type GameVersionTag } from '@modrinth/utils'
 import { Menu } from 'floating-vue'
 import { computed, type Ref, ref } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
@@ -479,15 +479,12 @@ const formatBytes = useFormatBytes()
 const MAX_GAME_VERSION_TAGS = 5
 const MAX_PLATFORM_TAGS = 3
 
-type VersionWithDisplayUrlEnding = Version & {
+type VersionWithDisplayUrlEnding = Labrinth.Versions.v3.Version & {
 	displayUrlEnding: string
-	environment?: Labrinth.Projects.v3.Environment
-	mrpack_loaders?: string[]
 }
 
 type DisplayVersion = VersionWithDisplayUrlEnding & {
 	noModLoader: boolean
-	files_missing_attribution?: boolean
 }
 
 type VersionTableColumn =
@@ -515,7 +512,7 @@ const props = withDefaults(
 		currentMember?: boolean
 		loaders: Labrinth.Tags.v2.Loader[]
 		gameVersions: GameVersionTag[]
-		versionLink?: (version: Version) => string
+		versionLink?: (version: Labrinth.Versions.v3.Version) => string
 		openModal?: () => void
 		createVersionButtonSecondary?: boolean
 	}>(),
diff --git a/packages/ui/src/components/project/ProjectStatusLink.vue b/packages/ui/src/components/project/ProjectStatusLink.vue
new file mode 100644
index 0000000000..c7126c9d9b
--- /dev/null
+++ b/packages/ui/src/components/project/ProjectStatusLink.vue
@@ -0,0 +1,28 @@
+<template>
+	<AutoLink
+		:to="`/project/${project.slug}`"
+		:target="newTab ? '_blank' : undefined"
+		class="group inline-flex min-w-0 max-w-full items-center gap-1"
+		:style="{ color: `var(--color-${getProjectStatusColor(project.status)})` }"
+	>
+		<component :is="getProjectStatusIcon(project.status)" class="size-4 shrink-0" />
+		<span class="min-w-0 truncate font-medium group-hover:underline">{{ project.name }}</span>
+	</AutoLink>
+</template>
+
+<script setup lang="ts">
+import type { Labrinth } from '@modrinth/api-client'
+
+import { getProjectStatusColor, getProjectStatusIcon } from '../../utils'
+import AutoLink from '../base/AutoLink.vue'
+
+withDefaults(
+	defineProps<{
+		project: Pick<Labrinth.Projects.v3.Project, 'name' | 'slug' | 'status'>
+		newTab?: boolean
+	}>(),
+	{
+		newTab: false,
+	},
+)
+</script>
diff --git a/packages/ui/src/components/project/index.ts b/packages/ui/src/components/project/index.ts
index efc797c1d2..4d2fec932d 100644
--- a/packages/ui/src/components/project/index.ts
+++ b/packages/ui/src/components/project/index.ts
@@ -16,4 +16,5 @@ export { default as ProjectSidebarLinks } from './ProjectSidebarLinks.vue'
 export { default as ProjectSidebarServerInfo } from './ProjectSidebarServerInfo.vue'
 export { default as ProjectSidebarTags } from './ProjectSidebarTags.vue'
 export { default as ProjectStatusBadge } from './ProjectStatusBadge.vue'
+export { default as ProjectStatusLink } from './ProjectStatusLink.vue'
 export { default as TagsOverflow } from './TagsOverflow.vue'
diff --git a/packages/ui/src/components/version/VersionFilterControl.vue b/packages/ui/src/components/version/VersionFilterControl.vue
index 09a77a7bdd..e0f79bff2b 100644
--- a/packages/ui/src/components/version/VersionFilterControl.vue
+++ b/packages/ui/src/components/version/VersionFilterControl.vue
@@ -120,16 +120,17 @@
 </template>
 
 <script setup lang="ts">
+import type { Labrinth } from '@modrinth/api-client'
 import { ChevronLeftIcon, FilterIcon, XCircleIcon, XIcon } from '@modrinth/assets'
 import type { MultiSelectOption } from '@modrinth/ui'
 import { Checkbox, formatLoader, FormattedTag, MultiSelect, TagItem, useVIntl } from '@modrinth/ui'
-import type { GameVersionTag, Version } from '@modrinth/utils'
+import type { GameVersionTag } from '@modrinth/utils'
 import { computed, ref } from 'vue'
 import type { LocationQueryValue } from 'vue-router'
 import { useRoute } from 'vue-router'
 
 const props = defineProps<{
-	versions: Version[]
+	versions: Labrinth.Versions.v3.Version[]
 	gameVersions: GameVersionTag[]
 	baseId?: string
 }>()
diff --git a/packages/ui/src/providers/project-page.ts b/packages/ui/src/providers/project-page.ts
index c81f83b9fd..dce8569c92 100644
--- a/packages/ui/src/providers/project-page.ts
+++ b/packages/ui/src/providers/project-page.ts
@@ -15,7 +15,7 @@ export interface ProjectPageContext {
 	allMembers: Ref<Labrinth.Projects.v3.TeamMember[]>
 	organization: Ref<Labrinth.Projects.v3.Organization | null>
 	// Lazy version loading (client-side only)
-	versions: Ref<Labrinth.Versions.v2.Version[] | null>
+	versions: Ref<Labrinth.Versions.v3.Version[] | null>
 	versionsLoading: Ref<boolean>
 	versionsLoaded: Ref<boolean>
 	// Lazy dependencies loading (client-side only)
diff --git a/packages/ui/src/utils/auto-icons.ts b/packages/ui/src/utils/auto-icons.ts
index 03976cdcdd..7656d7c817 100644
--- a/packages/ui/src/utils/auto-icons.ts
+++ b/packages/ui/src/utils/auto-icons.ts
@@ -89,6 +89,22 @@ export const PROJECT_STATUS_ICONS: Record<ProjectStatus, Component> = {
 	unknown: UnknownIcon,
 }
 
+// this should probably be abstracted or something idk
+export type BadgeColor = 'red' | 'orange' | 'green' | 'blue' | 'purple' | 'gray'
+
+export const PROJECT_STATUS_COLORS: Record<ProjectStatus, BadgeColor> = {
+	approved: 'blue',
+	unlisted: 'purple',
+	withheld: 'red',
+	private: 'gray',
+	scheduled: 'orange',
+	draft: 'gray',
+	archived: 'gray',
+	rejected: 'red',
+	processing: 'orange',
+	unknown: 'gray',
+}
+
 export const DIRECTORY_ICONS: Record<string, Component> = {
 	config: FolderOpenIcon,
 	world: FolderOpenIcon,
@@ -124,6 +140,10 @@ export function getProjectStatusIcon(status: ProjectStatus): Component {
 	return PROJECT_STATUS_ICONS[status] ?? UnknownIcon
 }
 
+export function getProjectStatusColor(status: ProjectStatus): BadgeColor {
+	return PROJECT_STATUS_COLORS[status] ?? `gray`
+}
+
 export function getDirectoryIcon(name: string): Component {
 	return DIRECTORY_ICONS[name.toLowerCase()] ?? DIRECTORY_ICONS._default
 }