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/checklist/ModerationChecklist.vue b/apps/frontend/src/components/ui/moderation/checklist/ModerationChecklist.vue
index 21acd31a13..d3cece740b 100644
--- a/apps/frontend/src/components/ui/moderation/checklist/ModerationChecklist.vue
+++ b/apps/frontend/src/components/ui/moderation/checklist/ModerationChecklist.vue
@@ -30,8 +30,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">{{
@@ -232,15 +237,11 @@
 					<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"
 						/>
 					</div>
 				</div>
@@ -265,8 +266,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>
@@ -383,30 +389,26 @@ import {
 	UndoIcon,
 	XIcon,
 } from '@modrinth/assets'
-import type {
-	IdentifiedNodeBuilder,
-	NodeState,
-	Priority,
-	StageNodeBuilder,
-	ValueNodeBuilder,
-} from '@modrinth/moderation'
+import type { Priority } from '@modrinth/moderation'
+import { expandVariables, handleKeybind, kebabToTitleCase, useStages } from '@modrinth/moderation'
+import type { NodeState, StageNode } from '@modrinth/moderation/src/types/node'
 import {
+	CHECKLIST_META_KEY,
+	collectActiveActions,
+	computeAttentionMap,
+	computeNodeMeta,
 	createTrackedPatch,
 	evalSegment,
-	expandVariables,
-	getBooleanChildState,
-	GLOBAL_STATE_KEY,
-	handleKeybind,
-	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 LoaderPicker from '~/components/ui/create-project-version/components/LoaderPicker.vue'
+import McVersionPicker from '~/components/ui/create-project-version/components/McVersionPicker.vue'
 import {
 	Avatar,
 	ButtonStyled,
@@ -424,11 +426,15 @@ import type { ProjectStatus } 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 { 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,
@@ -437,9 +443,8 @@ import {
 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 { type ActiveAction, type LiveNode, STATE_KEY } from './checklist-context'
 import KeybindsModal from './ChecklistKeybindsModal.vue'
-import NodeRenderer from './NodeRenderer.vue'
 
 const notifications = injectNotificationManager()
 const { addNotification } = notifications
@@ -609,7 +614,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)
 
@@ -627,10 +631,8 @@ async function navigateToNextUnlockedProject(): Promise<boolean> {
 		}
 	}
 
-	// Remove from queue after validation
 	prefetchQueue.value.shift()
 
-	// Mark skipped projects as completed
 	await Promise.all(
 		next.skippedIds.map((id) => moderationQueue.completeCurrentProject(id, 'skipped')),
 	)
@@ -660,10 +662,26 @@ 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 resolvedMessageAvailability = ref<Map<object, boolean>>(new Map())
 const generatedMessage = computed(() => message.value !== null)
 const loadingMessage = ref(false)
 const moderationDecision = ref<ProjectStatus | null>(null)
@@ -747,11 +765,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
@@ -798,24 +814,23 @@ async function batchCheckQueueCandidates(
 ): 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, projectData] = await Promise.all([
-				moderationQueue.checkLock(id),
-				useBaseFetch(`project/${id}`, { method: 'GET' }).catch(() => null),
-			])
-
-			const status = (projectData as { status?: string } | null)?.status
+			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: (projectData as { slug?: string } | null)?.slug,
-				projectType: (projectData as { project_type?: string } | null)?.project_type,
-				status,
-				isProcessing: projectData === null ? true : status === 'processing',
+				slug: project?.slug,
+				projectType: project?.project_types[0],
+				status: project?.status,
+				isProcessing: project === null ? true : project.status === 'processing',
 			}
 		}),
 	)
@@ -853,7 +868,6 @@ async function findNextEligibleQueueProject(candidateIds: string[]) {
 	return null
 }
 
-// Maintain a queue of prefetched unlocked projects for instant navigation
 async function maintainPrefetchQueue() {
 	if (isPrefetching.value) return
 	if (!moderationQueue.isQueueMode) return
@@ -863,21 +877,17 @@ 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)
 		}
 
-		// 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 queueItems = [...moderationQueue.currentQueue.items]
 		const currentIndex = currentProjectId ? queueItems.indexOf(currentProjectId) : -1
@@ -922,11 +932,9 @@ async function maintainPrefetchQueue() {
 	}
 }
 
-// Debounced prefetch to prevent spam from rapid stage changes
 const debouncedPrefetch = useDebounceFn(maintainPrefetchQueue, 300)
 
 async function skipToNextProject() {
-	// Skip the current project
 	const currentProjectId = projectV2.value?.id
 	if (!currentProjectId) {
 		console.warn('[skipToNextProject] No current project ID, aborting')
@@ -940,7 +948,6 @@ async function skipToNextProject() {
 	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
@@ -992,12 +999,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()
@@ -1030,85 +1039,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] })
+	}
+
+	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
@@ -1119,6 +1125,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.
@@ -1131,6 +1138,8 @@ if (!persistedState) {
 				const firstValid = findFirstValidStage()
 				if (firstValid !== currentStage.value) {
 					currentStage.value = firstValid
+				} else if (needsInitialStageSettle) {
+					markStageVisited(currentStageObj.value.id)
 				}
 			}
 		},
@@ -1157,7 +1166,9 @@ 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, {
@@ -1166,6 +1177,7 @@ function savePersistedState(open: boolean, resetReviewAnyway = false) {
 		...(stageVal && { stage: stageVal }),
 		...(messageVal && { message: messageVal }),
 		...(stateVal && { state: stateVal }),
+		...(activatedStagesVal && { activatedStages: activatedStagesVal }),
 	})
 }
 
@@ -1186,20 +1198,22 @@ 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()) {
@@ -1246,8 +1260,8 @@ function handleKeybinds(event: KeyboardEvent) {
 				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,
 
 				focusedActionIndex: null,
 				focusedActionType: null,
@@ -1302,11 +1316,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()
 	}
 })
 
@@ -1317,23 +1330,7 @@ onMounted(async () => {
 	document.addEventListener('visibilitychange', handleVisibilityChange)
 	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)
 
@@ -1350,7 +1347,6 @@ onMounted(async () => {
 		}
 		lockError.value = false
 
-		// Start countdown timer
 		updateLockCountdown()
 		lockCountdownInterval.value = setInterval(updateLockCountdown, 1000)
 	} else {
@@ -1396,7 +1392,6 @@ onUnmounted(() => {
 		void moderationQueue.releaseLock(projectId)
 	}
 
-	// Clear prefetch state to prevent memory leaks
 	prefetchQueue.value = []
 	isPrefetching.value = false
 })
@@ -1413,34 +1408,26 @@ watch(
 	{ 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(): ActiveAction[] {
 	return resolvedStages.value.flatMap((s) => checklistLive.value.get(s)?.activeActions ?? [])
 }
 
@@ -1451,14 +1438,14 @@ function isDescendant(childPath: string[], ancestorPath: string[]): boolean {
 }
 
 async function assembleFullMessage() {
-	const allEntries = collectActiveActions()
+	const allEntries = collectAllActiveActions()
 	generatedActiveActions.value = allEntries
 
-	const consumed = new Set<IdentifiedNodeBuilder>()
+	const consumed = new Set<object>()
 
 	async function evalEntry(entry: ActiveAction): Promise<string> {
 		let result = ''
-		for (const seg of entry.node._segments) {
+		for (const seg of (entry.node as any)._segments) {
 			if (seg.type === 'collect') {
 				let collected = ''
 				for (const childEntry of allEntries) {
@@ -1483,7 +1470,7 @@ async function assembleFullMessage() {
 		if (consumed.has(entry.node)) continue
 		const content = await evalEntry(entry)
 		if (content.trim()) {
-			parts.push({ priority: entry.node._priority, content })
+			parts.push({ priority: (entry.node as any)._priority, content })
 		}
 	}
 
@@ -1496,19 +1483,48 @@ async function assembleFullMessage() {
 
 	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 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 }
+})
+
+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
 }
 
@@ -1533,6 +1549,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
@@ -1591,6 +1617,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) {
+		navigateTo(`/${projectV2.value.project_type}/${projectV2.value.slug}${initialStage._navigate}`)
+	}
+}
+
 async function refreshModerationCaches(threadId?: string) {
 	const refreshes: Promise<unknown>[] = [
 		invalidate(),
@@ -1605,7 +1646,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
 
@@ -1618,8 +1658,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()
+	const shouldApplyFixes = active.some((a) => (a.node as any)._applyFixes)
 
 	moderationDecision.value = status
 	try {
@@ -1647,7 +1687,7 @@ async function sendMessage(status: ProjectStatus) {
 				projectV3.value as any,
 			)
 			for (const { node, state } of active) {
-				for (const f of node._fixes) {
+				for (const f of (node as any)._fixes) {
 					f._projectFn?.(projectProxy, state)
 				}
 			}
@@ -1658,7 +1698,7 @@ 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 })),
+					(node as any)._fixes.filter((f: FixBuilder) => f._versionFn).map((f: FixBuilder) => ({ fix: f, state })),
 				)
 				if (versionFixes.length > 0) {
 					await Promise.all(
@@ -1802,6 +1842,7 @@ async function clearProjectLocalStorage() {
 	cancelPendingPersistence()
 
 	nodeStates.value = {}
+	activatedStages.value = new Set()
 	message.value = null
 	await clearChecklistState(checklistPersistenceProjectId)
 }
@@ -1833,6 +1874,7 @@ interface StageOption {
 	messages?: number
 	fixes?: number
 	requiredMissing?: boolean
+	visited?: boolean
 }
 
 const stageOptions = computed<StageOption[]>(() => {
@@ -1852,6 +1894,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..a968dcaa77 100644
--- a/apps/frontend/src/components/ui/moderation/checklist/checklist-context.ts
+++ b/apps/frontend/src/components/ui/moderation/checklist/checklist-context.ts
@@ -1,8 +1,8 @@
-import type { IdentifiedNodeBuilder, NodeState } from '@modrinth/moderation'
-import type { ComputedRef, InjectionKey, Ref } from 'vue'
+import type { NodeState } from '@modrinth/moderation/src/types/node'
+import type { InjectionKey, Ref } from 'vue'
 
 export interface ActiveAction {
-	node: IdentifiedNodeBuilder
+	node: object
 	state: Record<string, NodeState>
 	statePath: string[]
 }
@@ -17,7 +17,5 @@ export interface LiveNode {
 	activeActions: ActiveAction[]
 }
 
-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 b413ebb274..cfe84528a9 100644
--- a/apps/frontend/src/pages/[type]/[project].vue
+++ b/apps/frontend/src/pages/[type]/[project].vue
@@ -1077,7 +1077,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 : []
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
index 3b4c1b356c..f0b877cc09 100644
--- a/apps/frontend/src/services/moderation-checklist-storage.ts
+++ b/apps/frontend/src/services/moderation-checklist-storage.ts
@@ -1,4 +1,4 @@
-import type { NodeState } from '@modrinth/moderation'
+import type { NodeState } from '@modrinth/moderation/src/types/node'
 
 import { dbDelete, dbGet, dbPut, dbScan } from './moderation-db.ts'
 
@@ -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/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 b86029e2ac..67108ecc1b 100644
--- a/packages/moderation/src/data/keybinds.ts
+++ b/packages/moderation/src/data/keybinds.ts
@@ -4,7 +4,6 @@ const keybinds: { [id: string]: KeybindListener } = {
 	'next-stage': {
 		keybind: 'ArrowRight',
 		description: 'Go to next stage',
-		enabled: (ctx) => !ctx.state.isDone,
 		action: (ctx) => ctx.actions.tryGoNext(),
 	},
 	'previous-stage': {
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/stages/description.tsx b/packages/moderation/src/data/stages/description.tsx
index 3ca0cb1694..4a5f18d1d7 100644
--- a/packages/moderation/src/data/stages/description.tsx
+++ b/packages/moderation/src/data/stages/description.tsx
@@ -27,7 +27,6 @@ export default function () {
 						.children(
 							group()
 								.title('Why is this Description Insufficient?')
-								.multiSelect('reason')
 								.children(
 									toggle('custom', 'Custom').children(
 										markdown('explainer')
@@ -44,8 +43,7 @@ export default function () {
 								`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))
+							return SHOW_SPOILER_ADVICE.some((reason) => state?.[reason] === true)
 								? await md('checklist/messages/description/insufficient/piece/spoiler-guide')(state)
 								: ''
 						}),
diff --git a/packages/moderation/src/data/stages/links.tsx b/packages/moderation/src/data/stages/links.tsx
index 5110950ad8..edb845d820 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
 	}
diff --git a/packages/moderation/src/data/stages/metadata.tsx b/packages/moderation/src/data/stages/metadata.tsx
index 4aeda58cbf..b39ef8632a 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')
@@ -94,7 +96,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 +105,96 @@ 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('loader', 'Loaders (WIP)')
+						.suggestedStatus('flagged')
+						.severity('medium')
+						.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')
+						.severity('medium')
+						.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..86ad6a23d8 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,9 +35,11 @@ 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')
diff --git a/packages/moderation/src/data/stages/other-rules.tsx b/packages/moderation/src/data/stages/rules.tsx
similarity index 62%
rename from packages/moderation/src/data/stages/other-rules.tsx
rename to packages/moderation/src/data/stages/rules.tsx
index 484d158c86..a1cf092630 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()
 
@@ -23,7 +22,6 @@ export default function () {
 					.severity('critical')
 					.message(),
 
-				// TODO: chyz, the lists built by these message have empty line gaps.
 				toggle('prohibited-content', 'Prohibited Content')
 					.suggestedStatus('rejected')
 					.severity('critical')
@@ -31,21 +29,20 @@ export default function () {
 					.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(),
 							),
 					),
 
@@ -66,15 +63,14 @@ export default function () {
 					.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(),
 							),
 					),
 
@@ -92,7 +88,6 @@ export default function () {
 					.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 }))
diff --git a/packages/moderation/src/data/stages/status-alerts.tsx b/packages/moderation/src/data/stages/status-alerts.tsx
index af957987c6..7368e5c73c 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 { 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,18 +37,19 @@ export default function (
 					.priority(Priorities.alerts)
 					.applyFixes()
 					.children(
-						computed<NodeBuilder | null>(() => {
-							const fixNodes: NodeBuilder[] = []
+						computed<ChildNode | null>(() => {
+							const fixNodes: ChildNode[] = []
 							walkNodes(
 								[group().children(...mainStages)],
 								(globalState.value ?? {}) as unknown as Record<string, NodeState>,
 								(node, nodeState) => {
-									if (!node._fixes.length) return
+									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,
+										...resolveChildren(node as never, childState).filter(
+											(c): c is Exclude<ChildNode, string | (() => unknown)> =>
+												typeof c === 'object' && c !== null,
 										),
 									)
 								},
diff --git a/packages/moderation/src/data/stages/title-slug.tsx b/packages/moderation/src/data/stages/title-slug.tsx
index 8844416aa9..32fcdf7cc2 100644
--- a/packages/moderation/src/data/stages/title-slug.tsx
+++ b/packages/moderation/src/data/stages/title-slug.tsx
@@ -6,12 +6,17 @@ import {
 	TagCategoryWandSparklesIcon,
 	UserPlusIcon,
 } from '@modrinth/assets'
-import { Alert, injectModrinthClient, injectProjectPageContext } from '@modrinth/ui'
+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 { button, check, fix, group, stage, text, toggle } from '../../types/node'
 
 const STALE_TIME = 1000 * 60 * 5
 
@@ -47,9 +52,7 @@ export default function () {
 	let slugDebounceTimer: ReturnType<typeof setTimeout> | undefined
 
 	function currentSlug(state: Record<string, NodeState>) {
-		return (
-			(state['correct-slug'] as string | undefined) ?? resolvedAutoSlug.value ?? project.value.slug
-		)
+		return state['correct-slug'] as string
 	}
 
 	async function checkSlugTaken(slug: string): Promise<Labrinth.Projects.v3.Project | null> {
@@ -66,8 +69,13 @@ export default function () {
 	}
 
 	const SlugStatus = () => {
-		const v = slugValidation.value
-		if (v === null) return null
+		const v =
+			slugValidation.value ??
+			(autoSlugStatus.value === 'loading'
+				? 'checking'
+				: autoSlugStatus.value === 'unavailable'
+					? 'taken'
+					: 'available')
 		if (v === 'checking')
 			return (
 				<Alert type="checking" class="w-full">
@@ -89,16 +97,10 @@ export default function () {
 		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}
+				<div class="flex flex-wrap items-center gap-1.5">
+					Slug taken
+					{by ? <ProjectStatusLink project={by} newTab /> : null}
+				</div>
 			</Alert>
 		)
 	}
@@ -190,12 +192,7 @@ export default function () {
 						{autoSlugStatus.value === 'loading' ? (
 							'...'
 						) : by ? (
-							<>
-								<a href={`/project/${by.slug}`} target="_blank" class="underline">
-									{by.name}
-								</a>
-								{` (${by.status})`}
-							</>
+							<ProjectStatusLink project={by} newTab />
 						) : (
 							'No'
 						)}
@@ -223,13 +220,12 @@ export default function () {
 						.children(
 							group()
 								.title('Similarities Additional Info')
-								.multiSelect('options')
 								.children(
-									option('modpack', 'Modpack Named After Mod')
+									check('modpack', 'Modpack Named After Mod')
 										.shown(computed(() => project.value.project_types.includes('modpack')))
 										.message(),
 
-									option('fork', 'Forked Project')
+									check('fork', 'Forked Project')
 										.shown(computed(() => !project.value?.minecraft_server))
 										.message(),
 								),
@@ -242,7 +238,6 @@ export default function () {
 				.shown(computed(() => hasCustomSlug(project.value)))
 				.children(
 					group()
-						.multiSelect('issues')
 						.children(
 							toggle('misused', 'Misused')
 								.children(
@@ -250,7 +245,7 @@ export default function () {
 										.title('Correct Slug')
 										.children(
 											text('correct-slug')
-												.initial(() => resolvedAutoSlug.value ?? project.value.slug)
+												.initial(() => resolvedAutoSlug.value ?? project.value.slug ?? "")
 												.onChange((value, { override }) => {
 													if (!value) return override(project.value.slug ?? '')
 													clearTimeout(slugDebounceTimer)
@@ -280,8 +275,8 @@ export default function () {
 														resolvedAutoSlug.value !== null &&
 														resolvedAutoSlug.value !== currentSlug(state),
 												)
-												.onClick((state) => {
-													if (resolvedAutoSlug.value) state['correct-slug'] = resolvedAutoSlug.value
+												.onClick((_state, write) => {
+													if (resolvedAutoSlug.value) write('correct-slug', resolvedAutoSlug.value)
 												}),
 
 											button()
@@ -297,16 +292,16 @@ export default function () {
 														ownerUsername.value !== null &&
 														!currentSlug(state)?.includes(ownerUsername.value),
 												)
-												.onClick((state) => {
-													state['correct-slug'] = `${currentSlug(state)}-${ownerUsername.value}`
+												.onClick((state, write) => {
+													write('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
+												.onClick((_state, write) => {
+													write('correct-slug', project.value.slug)
 												}),
 
 											SlugStatus,
@@ -326,10 +321,8 @@ export default function () {
 									}))(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
+										const slug = state['correct-slug'] as string
 										if (!slug || slug === project.value.slug) return
 										patch.slug = slug
 									}),
diff --git a/packages/moderation/src/data/stages/versions.tsx b/packages/moderation/src/data/stages/versions.tsx
index 3e18ded1f5..64730332b9 100644
--- a/packages/moderation/src/data/stages/versions.tsx
+++ b/packages/moderation/src/data/stages/versions.tsx
@@ -29,16 +29,10 @@ export default function () {
 						dropdown('type')
 							.title('Correct Project Type')
 							.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(),
@@ -50,7 +44,7 @@ export default function () {
 						dropdown('distribution')
 							.title('Distribution Type')
 							.none('Unknown')
-							.children(
+							.options(
 								option('primary', 'Primary Files').message(),
 								option('additional', 'Additional Files').message(),
 								option('mono', 'Monofile')
diff --git a/packages/moderation/src/index.ts b/packages/moderation/src/index.ts
index 23ec61f2a7..a0b3a6d754 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 nags } from './data/nags'
 export * from './data/nags/index'
@@ -9,13 +9,10 @@ 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/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'
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/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..29404b0d73
--- /dev/null
+++ b/packages/moderation/src/types/node/capabilities.ts
@@ -0,0 +1,402 @@
+import type { Component, FunctionalComponent, SVGAttributes } from 'vue'
+
+import type { FixBuilder } from './fix'
+import type { Priority } from '../priority.ts'
+import type {
+	GetVarsFn,
+	MessageSegment,
+	ModerationSeverity,
+	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 Messageable {
+	_segments: MessageSegment[]
+	_suggestedStatus?: ModerationStatus
+	_severity?: ModerationSeverity
+	suggestedStatus(this: this, status: ModerationStatus): this
+	severity(this: this, severity: ModerationSeverity): this
+	message(this: this, path?: string | (() => string), getVars?: GetVarsFn): this
+	rawMessage(
+		this: this,
+		content: string | ((state: Record<string, NodeState>) => string | Promise<string>),
+	): this
+	collect(this: this, path?: string | (() => string), getVars?: GetVarsFn): this
+}
+
+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
+		},
+		severity(this: any, severity: ModerationSeverity) {
+			this._severity = severity
+			return this
+		},
+		message(this: any, path?: string | (() => string), getVars?: GetVarsFn) {
+			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, path?: string | (() => string), getVars?: GetVarsFn) {
+			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) => 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>, write: (id: string, value: NodeState) => void) => 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 Prioritizable {
+	_priority: Priority | undefined
+	priority(this: this, p: Priority): this
+}
+
+export function withPriority<T extends object>(node: T): T & Prioritizable {
+	return Object.assign(node, {
+		_priority: undefined as Priority | undefined,
+		priority(this: any, p: Priority) {
+			this._priority = p
+			return this
+		},
+	})
+}
+
+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
+		},
+	})
+}
diff --git a/packages/moderation/src/types/node/collect.ts b/packages/moderation/src/types/node/collect.ts
new file mode 100644
index 0000000000..cccb2c33ae
--- /dev/null
+++ b/packages/moderation/src/types/node/collect.ts
@@ -0,0 +1,76 @@
+import { evalSegment } from './messages'
+import {
+	getBooleanChildState,
+	hasCap,
+	hasChildrenCap,
+	hasValueCap,
+	isNodeActive,
+	resolveChildren,
+	walkNodes,
+	withDefaults,
+} from './resolve'
+import type { ChildNode } from './builder'
+import type { MessageSegment, NodeState } from './state'
+
+export interface ActiveAction2 {
+	node: object
+	state: Record<string, NodeState>
+	statePath: string[]
+}
+
+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
+			const state = ((): Record<string, NodeState> => {
+				if (!hasValueCap(node)) return localState
+				const childState = getBooleanChildState(nodeState)
+				return hasChildrenCap(node) ? withDefaults(childState, resolveChildren(node, childState)) : childState
+			})()
+			actions.push({ node, state, statePath: path })
+		},
+		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)
+				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..a951ac6393
--- /dev/null
+++ b/packages/moderation/src/types/node/components/NodeRenderer.vue
@@ -0,0 +1,278 @@
+<script lang="ts" setup>
+import { ButtonStyled } from '@modrinth/ui'
+import { renderString } from '@modrinth/utils'
+import { inject } from 'vue'
+import type { Component } from 'vue'
+
+import type { AnyNode, ChildNode, HasChildren } from '../builder'
+import type { ComponentNodePropsContext, Enableable, HasValue, Identified, OnChangeFn } from '../capabilities'
+import { CHECKLIST_META_KEY } from '../context'
+import { childWriter, writeNodeValue } from '../mutate'
+import type { Writer } from '../mutate'
+import {
+	getBooleanChildState,
+	getEffectiveValue,
+	hasCap,
+	hasChildrenCap,
+	hasIdCap,
+	hasOptionsCap,
+	hasValueCap,
+	isNodeActive,
+	isShown,
+	resolveChildren,
+} 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>
+}>()
+
+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>
+	}
+
+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
+}
+
+function isEnabled(node: Partial<Enableable>): boolean {
+	if (node._enabled === undefined) return true
+	if (typeof node._enabled === 'function') return node._enabled(props.state)
+	return resolve(node._enabled)
+}
+
+function toggleSetValue(node: RenderableValueNode, value: string): void {
+	const current = getEffectiveValue(node, props.state[node.id], props.state) 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)
+}
+
+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) },
+	}
+	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 (!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) }
+}
+
+function resolveTooltip(node: object): { content: string } | undefined {
+	if (!hasCap(node, '_tooltip')) return undefined
+	const t = node._tooltip as Reactive<string> | ((state: Record<string, NodeState>) => string) | undefined
+	if (t === undefined) return undefined
+	const content = typeof t === 'function' ? t(props.state) : resolve(t)
+	return content ? { content } : undefined
+}
+
+function clickButton(node: object): void {
+	if (!hasCap(node, '_onClick')) return
+	;(node._onClick as (state: Record<string, NodeState>, write: Writer) => void)?.(props.state, props.write)
+}
+
+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)
+			return
+		}
+	}
+	writeNodeValue(item, props.state, props.write, v as never)
+}
+</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"
+							: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-bind="componentProps(item as RenderableValueNode)"
+							:[modelProp(item)]="getEffectiveValue(item as RenderableValueNode, state[item.id], state)"
+							@[updateEvent(item)]="(v: unknown) => updateValue(item as RenderableValueNode, v)"
+						/>
+					</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], state) &&
+					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"
+				: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..45830f7951
--- /dev/null
+++ b/packages/moderation/src/types/node/context.ts
@@ -0,0 +1,10 @@
+import type { InjectionKey, Ref } from 'vue'
+
+import type { NodeMeta } from './node-meta'
+
+export interface ChecklistMetaContext {
+	metaMap: Map<object, NodeMeta>
+	attentionMap: Map<object, boolean>
+}
+
+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..84f81816f3
--- /dev/null
+++ b/packages/moderation/src/types/node/factories.ts
@@ -0,0 +1,333 @@
+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,
+  withTitle,
+  withTooltip,
+  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): 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 {...children, value: next}
+  }
+  return 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,
+    withRequired,
+    withFix,
+    withEnabled,
+    withPriority,
+    (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,
+      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,
+      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 option(value: string, label: string) {
+  return pipe(
+    {value, label} as { value: string; label: string },
+    withChildren,
+    withShown,
+    withMessaging,
+  )
+}
+
+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 {
+  return typeof raw === "string" ? raw : ""
+}
+
+function setStringValue(_raw: NodeState, next: string): NodeState {
+  return next || undefined
+}
+
+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,
+  )
+}
+
+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,
+      withRequired,
+      withFix,
+      withEnabled,
+      withEditable,
+      (n) => Object.assign(n, {_showTooltip: true, _imperativeSync: true}),
+      (n) => withValue(n, stringValue),
+      (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,
+      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[]): NodeState {
+  return next.length > 0 ? new Set(next) : undefined
+}
+
+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,
+    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..8a40d8176c
--- /dev/null
+++ b/packages/moderation/src/types/node/mutate.ts
@@ -0,0 +1,32 @@
+import type { HasValue, Identified } from './capabilities'
+import type { NodeState } from './state'
+
+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,
+): void {
+	write(node.id, node._setValue(read[node.id], next))
+}
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..260614d088
--- /dev/null
+++ b/packages/moderation/src/types/node/node-meta.ts
@@ -0,0 +1,108 @@
+import type { AnyNode, ChildNode, HasChildren } from './builder'
+import type { FixBuilder } from './fix'
+import { getBooleanChildState, hasCap, hasChildrenCap, hasIdCap, hasOptionsCap, hasValueCap, isNodeActive, isShown, 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) {
+				const actionState = hasValueCap(node) ? getBooleanChildState(nodeState) : localState
+				fixActionable = isFixActionable(fixes, actionState)
+			}
+		}
+
+		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..f664a4f543
--- /dev/null
+++ b/packages/moderation/src/types/node/resolve.ts
@@ -0,0 +1,289 @@
+import type { Ref } from 'vue'
+import { toValue } from 'vue'
+
+import type { AnyNode, ChildEntry, ChildNode, HasChildren } from './builder'
+import type { HasValue, Identified } from './capabilities'
+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[]): 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)
+					}
+					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))
+			}
+
+			if (value === undefined && child && hasChildrenCap(child)) {
+				const grandchildren = resolveChildren(child, {})
+				if (grandchildren.length > 0) return emptyScope(grandchildren)
+			}
+
+			return value
+		},
+		set(target, key, value, receiver) {
+			return Reflect.set(target, key, value, receiver)
+		},
+	}) as T
+
+	return proxy
+}
+
+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)) {
+					visitor(selected, undefined, stageState, path)
+					if (hasChildrenCap(selected)) {
+						walkNodes(resolveChildren(selected, stageState), stageState, visitor, path)
+					}
+				}
+				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..d5ed39df2b
--- /dev/null
+++ b/packages/moderation/src/types/node/state.ts
@@ -0,0 +1,34 @@
+import type { Ref } from 'vue'
+import { toValue } from 'vue'
+
+export type ModerationStatus = 'approved' | 'rejected' | 'flagged'
+export type ModerationSeverity = 'low' | 'medium' | 'high' | 'critical'
+
+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..98f228639c 100644
--- a/packages/ui/src/components/project/index.ts
+++ b/packages/ui/src/components/project/index.ts
@@ -9,6 +9,7 @@ export { default as ProjectCombobox } from './ProjectCombobox.vue'
 export { default as ProjectPageDescription } from './ProjectPageDescription.vue'
 export { default as ProjectPageHeader } from './ProjectPageHeader.vue'
 export { default as ProjectPageVersions } from './ProjectPageVersions.vue'
+export { default as ProjectStatusLink } from './ProjectStatusLink.vue'
 export { default as ProjectSidebarCompatibility } from './ProjectSidebarCompatibility.vue'
 export { default as ProjectSidebarCreators } from './ProjectSidebarCreators.vue'
 export { default as ProjectSidebarDetails } from './ProjectSidebarDetails.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..3348bfcbda 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
 }