릴리스: v0.1.47 템플릿 요청과 관리자 승인 흐름 추가

릴리스: v0.1.46 에디터 아이템 제거와 회원 정보 보강
릴리스: v0.1.45 토스트와 즐겨찾기 상호작용 보정
2026-03-27 11:10:45 +09:00 · 2026-03-27 10:54:31 +09:00 · 2026-03-27 10:46:29 +09:00 · 2026-03-27 10:35:16 +09:00
16 changed files with 1376 additions and 60 deletions
--- a/backend/src/db.js
+++ b/backend/src/db.js
@@ -37,6 +37,8 @@ function mapUserRow(row) {
    isAdmin: !!row.is_admin,
    avatarSrc: row.avatar_src || '',
    createdAt: Number(row.created_at),
+    tierListCount: Number(row.tierlist_count || 0),
+    recentActivityAt: Number(row.recent_activity_at || row.created_at || 0),
  }
 }

@@ -83,6 +85,30 @@ function mapTierListRow(row) {
  }
 }

+function mapTemplateRequestRow(row) {
+  if (!row) return null
+  return {
+    id: row.id,
+    type: row.request_type,
+    requesterId: row.requester_id,
+    requesterName: getUserDisplayName(row),
+    requesterAccountName: getUserAccountName(row),
+    requesterAvatarSrc: row.requester_avatar_src || '',
+    sourceTierListId: row.source_tierlist_id,
+    sourceGameId: row.source_game_id,
+    sourceGameName: row.source_game_name || '',
+    sourceTierListTitle: row.title_snapshot || '',
+    sourceDescription: row.description_snapshot || '',
+    thumbnailSrc: row.thumbnail_src_snapshot || '',
+    targetGameId: row.target_game_id || '',
+    targetGameName: row.target_game_name || '',
+    status: row.status,
+    items: parseJson(row.items_json, []),
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+  }
+}
+
 function getUserDisplayName(row) {
  if (!row) return ''
  const nickname = (row.nickname || '').trim()
@@ -224,6 +250,29 @@ async function ensureSchema() {
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
    `)

+    await query(`
+      CREATE TABLE IF NOT EXISTS template_requests (
+        id VARCHAR(64) PRIMARY KEY,
+        request_type VARCHAR(20) NOT NULL,
+        requester_id VARCHAR(64) NOT NULL,
+        source_tierlist_id VARCHAR(64) NOT NULL,
+        source_game_id VARCHAR(120) NOT NULL,
+        target_game_id VARCHAR(120) NOT NULL DEFAULT '',
+        status VARCHAR(20) NOT NULL DEFAULT 'pending',
+        title_snapshot VARCHAR(120) NOT NULL,
+        description_snapshot TEXT NOT NULL,
+        thumbnail_src_snapshot VARCHAR(255) NOT NULL DEFAULT '',
+        items_json LONGTEXT NOT NULL,
+        created_at BIGINT NOT NULL,
+        updated_at BIGINT NOT NULL,
+        INDEX idx_template_requests_status_created (status, created_at),
+        INDEX idx_template_requests_source_tierlist (source_tierlist_id),
+        INDEX idx_template_requests_requester (requester_id),
+        CONSTRAINT fk_template_requests_requester FOREIGN KEY (requester_id) REFERENCES users(id) ON DELETE CASCADE,
+        CONSTRAINT fk_template_requests_source_tierlist FOREIGN KEY (source_tierlist_id) REFERENCES tierlists(id) ON DELETE CASCADE
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+    `)
+
    const tierListThumbnailColumns = await query("SHOW COLUMNS FROM tierlists LIKE 'thumbnail_src'")
    if (!tierListThumbnailColumns.length) {
      await query("ALTER TABLE tierlists ADD COLUMN thumbnail_src VARCHAR(255) NOT NULL DEFAULT '' AFTER title")
@@ -326,9 +375,24 @@ async function updateUserProfile({ id, nickname, avatarSrc }) {
 }

 async function listUsers() {
-  const rows = await query(
-    'SELECT id, email, nickname, is_admin, avatar_src, created_at FROM users ORDER BY created_at ASC, email ASC'
-  )
+  const rows = await query(`
+    SELECT
+      u.id,
+      u.email,
+      u.nickname,
+      u.is_admin,
+      u.avatar_src,
+      u.created_at,
+      COUNT(t.id) AS tierlist_count,
+      GREATEST(
+        u.created_at,
+        COALESCE(MAX(t.updated_at), 0)
+      ) AS recent_activity_at
+    FROM users u
+    LEFT JOIN tierlists t ON t.author_id = u.id
+    GROUP BY u.id, u.email, u.nickname, u.is_admin, u.avatar_src, u.created_at
+    ORDER BY recent_activity_at DESC, u.created_at ASC, u.email ASC
+  `)
  return rows.map(mapUserRow)
 }

@@ -485,6 +549,24 @@ async function createCustomItem({ id, ownerId, src, label }) {
  return { id, ownerId, src, label, origin: 'custom', createdAt }
 }

+async function syncOwnedCustomItemLabels({ ownerId, items }) {
+  const customItems = Array.from(
+    new Map(
+      (items || [])
+        .filter((item) => item?.origin === 'custom' && item?.id && typeof item.label === 'string')
+        .map((item) => [item.id, item])
+    ).values()
+  )
+
+  if (!customItems.length) return
+
+  await Promise.all(
+    customItems.map((item) =>
+      query('UPDATE custom_items SET label = ? WHERE id = ? AND owner_id = ?', [item.label.trim().slice(0, 60), item.id, ownerId])
+    )
+  )
+}
+
 async function findCustomItemById(id) {
  const rows = await query(
    `
@@ -666,13 +748,18 @@ function applyFavoriteMetaToTierLists(tierLists, favoriteStats) {
  }))
 }

-async function listPublicTierLists(gameId, currentUserId = '') {
+async function listPublicTierLists(gameId, currentUserId = '', queryText = '') {
  const params = []
  let whereClause = 'WHERE t.is_public = 1'
  if (gameId) {
    whereClause += ' AND t.game_id = ?'
    params.push(gameId)
  }
+  if ((queryText || '').trim()) {
+    const search = `%${queryText.trim()}%`
+    whereClause += ' AND (t.title LIKE ? OR u.nickname LIKE ? OR u.email LIKE ?)'
+    params.push(search, search, search)
+  }

  const rows = await query(
    `
@@ -716,6 +803,67 @@ async function listPublicTierLists(gameId, currentUserId = '') {
  return applyFavoriteMetaToTierLists(tierLists, favoriteStats)
 }

+async function listFavoriteTierLists(userId, { queryText = '', sort = 'favorited' } = {}) {
+  const allowedSort = new Set(['favorited', 'updated', 'favorites'])
+  const normalizedSort = allowedSort.has(sort) ? sort : 'favorited'
+  const params = [userId]
+  let whereClause = 'WHERE f.user_id = ?'
+
+  if ((queryText || '').trim()) {
+    const search = `%${queryText.trim()}%`
+    whereClause += ' AND (t.title LIKE ? OR g.name LIKE ? OR u.nickname LIKE ? OR u.email LIKE ?)'
+    params.push(search, search, search, search)
+  }
+
+  const orderClause =
+    normalizedSort === 'updated'
+      ? 'ORDER BY t.updated_at DESC, f.created_at DESC'
+      : normalizedSort === 'favorites'
+        ? 'ORDER BY favorite_count DESC, t.updated_at DESC'
+        : 'ORDER BY f.created_at DESC, t.updated_at DESC'
+
+  const rows = await query(
+    `
+      SELECT
+        t.id,
+        t.author_id,
+        t.game_id,
+        g.name AS game_name,
+        t.title,
+        t.thumbnail_src,
+        t.description,
+        t.is_public,
+        t.groups_json,
+        t.pool_json,
+        t.created_at,
+        t.updated_at,
+        f.created_at AS favorited_at,
+        u.nickname,
+        u.email,
+        u.avatar_src,
+        (
+          SELECT COUNT(*)
+          FROM favorite_tierlists ff
+          WHERE ff.tierlist_id = t.id
+        ) AS favorite_count
+      FROM favorite_tierlists f
+      INNER JOIN tierlists t ON t.id = f.tierlist_id
+      INNER JOIN users u ON u.id = t.author_id
+      INNER JOIN games g ON g.id = t.game_id
+      ${whereClause}
+      ${orderClause}
+    `,
+    params
+  )
+
+  return rows.map((row) => ({
+    ...mapTierListRow(row),
+    favoritedAt: Number(row.favorited_at || 0),
+    favoriteCount: Number(row.favorite_count || 0),
+    isFavorited: true,
+  }))
+}
+
 async function listUserTierLists(userId) {
  const rows = await query(
    `
@@ -876,6 +1024,151 @@ async function findTierListById(id, currentUserId = '') {
  return applyFavoriteMetaToTierLists([tierList], favoriteStats)[0]
 }

+async function findPendingTemplateRequestByTierList({ sourceTierListId, type }) {
+  const rows = await query(
+    `
+      SELECT id, request_type, status
+      FROM template_requests
+      WHERE source_tierlist_id = ? AND request_type = ? AND status = 'pending'
+      LIMIT 1
+    `,
+    [sourceTierListId, type]
+  )
+  return rows[0] || null
+}
+
+async function createTemplateRequest({
+  id,
+  type,
+  requesterId,
+  sourceTierListId,
+  sourceGameId,
+  targetGameId = '',
+  title,
+  description = '',
+  thumbnailSrc = '',
+  items = [],
+}) {
+  const existing = await findPendingTemplateRequestByTierList({ sourceTierListId, type })
+  if (existing) {
+    const err = new Error('template_request_exists')
+    err.code = 'TEMPLATE_REQUEST_EXISTS'
+    throw err
+  }
+
+  const createdAt = now()
+  await query(
+    `
+      INSERT INTO template_requests (
+        id,
+        request_type,
+        requester_id,
+        source_tierlist_id,
+        source_game_id,
+        target_game_id,
+        status,
+        title_snapshot,
+        description_snapshot,
+        thumbnail_src_snapshot,
+        items_json,
+        created_at,
+        updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?)
+    `,
+    [
+      id,
+      type,
+      requesterId,
+      sourceTierListId,
+      sourceGameId,
+      targetGameId,
+      title,
+      description,
+      thumbnailSrc,
+      serializeJson(items),
+      createdAt,
+      createdAt,
+    ]
+  )
+  return findTemplateRequestById(id)
+}
+
+async function findTemplateRequestById(id) {
+  const rows = await query(
+    `
+      SELECT
+        tr.id,
+        tr.request_type,
+        tr.requester_id,
+        tr.source_tierlist_id,
+        tr.source_game_id,
+        tr.target_game_id,
+        tr.status,
+        tr.title_snapshot,
+        tr.description_snapshot,
+        tr.thumbnail_src_snapshot,
+        tr.items_json,
+        tr.created_at,
+        tr.updated_at,
+        u.nickname,
+        u.email,
+        u.avatar_src AS requester_avatar_src,
+        sg.name AS source_game_name,
+        tg.name AS target_game_name
+      FROM template_requests tr
+      INNER JOIN users u ON u.id = tr.requester_id
+      LEFT JOIN games sg ON sg.id = tr.source_game_id
+      LEFT JOIN games tg ON tg.id = tr.target_game_id
+      WHERE tr.id = ?
+      LIMIT 1
+    `,
+    [id]
+  )
+
+  return mapTemplateRequestRow(rows[0])
+}
+
+async function listAdminTemplateRequests({ status = 'pending' } = {}) {
+  const rows = await query(
+    `
+      SELECT
+        tr.id,
+        tr.request_type,
+        tr.requester_id,
+        tr.source_tierlist_id,
+        tr.source_game_id,
+        tr.target_game_id,
+        tr.status,
+        tr.title_snapshot,
+        tr.description_snapshot,
+        tr.thumbnail_src_snapshot,
+        tr.items_json,
+        tr.created_at,
+        tr.updated_at,
+        u.nickname,
+        u.email,
+        u.avatar_src AS requester_avatar_src,
+        sg.name AS source_game_name,
+        tg.name AS target_game_name
+      FROM template_requests tr
+      INNER JOIN users u ON u.id = tr.requester_id
+      LEFT JOIN games sg ON sg.id = tr.source_game_id
+      LEFT JOIN games tg ON tg.id = tr.target_game_id
+      WHERE tr.status = ?
+      ORDER BY tr.created_at DESC
+    `,
+    [status]
+  )
+
+  return rows.map(mapTemplateRequestRow)
+}
+
+async function updateTemplateRequestStatus({ id, status }) {
+  await query('UPDATE template_requests SET status = ?, updated_at = ? WHERE id = ?', [status, now(), id])
+  return findTemplateRequestById(id)
+}
+
 async function deleteTierList(id) {
  await query('DELETE FROM tierlists WHERE id = ?', [id])
 }
@@ -909,6 +1202,7 @@ async function deleteCustomItems(ids) {

 async function saveTierList({ id, authorId, gameId, title, thumbnailSrc = '', description, isPublic, groups, pool }) {
  const existing = id ? await findTierListById(id, authorId) : null
+  await syncOwnedCustomItemLabels({ ownerId: authorId, items: pool })

  if (existing) {
    await query(
@@ -971,6 +1265,7 @@ module.exports = {
  listCustomItems,
  findUnusedCustomItems,
  listPublicTierLists,
+  listFavoriteTierLists,
  listUserTierLists,
  listAdminTierLists,
  findTierListById,
@@ -980,4 +1275,8 @@ module.exports = {
  findCustomItemsByIds,
  deleteCustomItems,
  saveTierList,
+  createTemplateRequest,
+  findTemplateRequestById,
+  listAdminTemplateRequests,
+  updateTemplateRequestStatus,
 }
--- a/backend/src/routes/admin.js
+++ b/backend/src/routes/admin.js
@@ -24,6 +24,9 @@ const {
  listUsers,
  listAdminTierLists,
  findTierListById,
+  listAdminTemplateRequests,
+  findTemplateRequestById,
+  updateTemplateRequestStatus,
  adminUpdateUser,
  adminUpdateUserPassword,
  adminDeleteUser,
@@ -181,6 +184,11 @@ router.get('/tierlists', requireAdmin, async (req, res) => {
  res.json(result)
 })

+router.get('/template-requests', requireAdmin, async (req, res) => {
+  const requests = await listAdminTemplateRequests({ status: 'pending' })
+  res.json({ requests })
+})
+
 async function removeCustomItemFiles(items) {
  await Promise.all(
    items.map(async (item) => {
@@ -255,6 +263,24 @@ async function promoteTierListItemsToGame({ tierList, gameId, itemIds = [] }) {
  return createdItems
 }

+async function promoteSnapshotItemsToGame({ items, gameId }) {
+  const createdItems = []
+
+  for (const item of items || []) {
+    const copiedSrc = await copyUploadIntoGameAsset(item.src)
+    createdItems.push(
+      await createGameItem({
+        id: nanoid(),
+        gameId,
+        src: copiedSrc,
+        label: item.label,
+      })
+    )
+  }
+
+  return createdItems
+}
+
 async function createGameTemplateFromTierList({ tierList, gameId, gameName }) {
  await createGame({ id: gameId, name: gameName })
  if (tierList.thumbnailSrc) {
@@ -278,6 +304,22 @@ async function createGameTemplateFromTierList({ tierList, gameId, gameName }) {
  return { game: await findGameById(gameId), items: createdItems }
 }

+async function createGameTemplateFromRequest({ templateRequest, gameId, gameName }) {
+  await createGame({ id: gameId, name: gameName })
+
+  if (templateRequest.thumbnailSrc) {
+    const copiedThumb = await copyUploadIntoGameAsset(templateRequest.thumbnailSrc)
+    await updateGameThumbnail(gameId, copiedThumb)
+  }
+
+  const items = await promoteSnapshotItemsToGame({
+    items: templateRequest.items || [],
+    gameId,
+  })
+
+  return { game: await findGameById(gameId), items }
+}
+
 router.delete('/custom-items/:itemId', requireAdmin, async (req, res) => {
  const result = await listCustomItems({ page: 1, limit: 200, orphanOnly: false })
  const target = result.items.find((item) => item.id === req.params.itemId)
@@ -355,6 +397,52 @@ router.post('/tierlists/:tierListId/create-game-template', requireAdmin, async (
  res.json(result)
 })

+router.post('/template-requests/:requestId/approve', requireAdmin, async (req, res) => {
+  const templateRequest = await findTemplateRequestById(req.params.requestId)
+  if (!templateRequest) return res.status(404).json({ error: 'not_found' })
+  if (templateRequest.status !== 'pending') return res.status(409).json({ error: 'request_already_handled' })
+
+  if (templateRequest.type === 'update') {
+    const targetGameId = templateRequest.targetGameId || templateRequest.sourceGameId
+    const game = await findGameById(targetGameId)
+    if (!game) return res.status(404).json({ error: 'game_not_found' })
+
+    const items = await promoteSnapshotItemsToGame({
+      items: templateRequest.items || [],
+      gameId: game.id,
+    })
+    const request = await updateTemplateRequestStatus({ id: templateRequest.id, status: 'approved' })
+    return res.json({ request, items })
+  }
+
+  const schema = z.object({
+    gameId: z.string().trim().min(1).max(120),
+    name: z.string().trim().min(1).max(120),
+  })
+  const parsed = schema.safeParse(req.body)
+  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })
+
+  const exists = await findGameById(parsed.data.gameId)
+  if (exists) return res.status(409).json({ error: 'game_id_taken' })
+
+  const result = await createGameTemplateFromRequest({
+    templateRequest,
+    gameId: parsed.data.gameId,
+    gameName: parsed.data.name,
+  })
+  const request = await updateTemplateRequestStatus({ id: templateRequest.id, status: 'approved' })
+  res.json({ request, ...result })
+})
+
+router.post('/template-requests/:requestId/reject', requireAdmin, async (req, res) => {
+  const templateRequest = await findTemplateRequestById(req.params.requestId)
+  if (!templateRequest) return res.status(404).json({ error: 'not_found' })
+  if (templateRequest.status !== 'pending') return res.status(409).json({ error: 'request_already_handled' })
+
+  const request = await updateTemplateRequestStatus({ id: templateRequest.id, status: 'rejected' })
+  res.json({ request })
+})
+
 router.delete('/custom-items', requireAdmin, async (req, res) => {
  const schema = z.object({
    q: z.string().trim().max(120).optional().default(''),
--- a/backend/src/routes/tierlists.js
+++ b/backend/src/routes/tierlists.js
@@ -6,10 +6,12 @@ const { nanoid } = require('nanoid')
 const {
  findTierListById,
  listPublicTierLists,
+  listFavoriteTierLists,
  listUserTierLists,
  deleteTierList,
  saveTierList,
  createCustomItem,
+  createTemplateRequest,
  findUserById,
  favoriteTierList,
  unfavoriteTierList,
@@ -17,6 +19,7 @@ const {
 const { requireAuth } = require('../middleware/auth')

 const router = express.Router()
+const FREEFORM_GAME_ID = 'freeform'

 function normalizePoolItem(item) {
  if (!item || item.origin !== 'game' || typeof item.src !== 'string') return item
@@ -41,6 +44,19 @@ function normalizeTierList(tierList) {
  }
 }

+function isTierListBoardEmpty(tierList) {
+  return !(tierList?.groups || []).some((group) => Array.isArray(group?.itemIds) && group.itemIds.length > 0)
+}
+
+function getCustomTemplateItems(tierList) {
+  const seen = new Set()
+  return (tierList?.pool || []).filter((item) => {
+    if (!item?.id || item.origin !== 'custom' || seen.has(item.id)) return false
+    seen.add(item.id)
+    return true
+  })
+}
+
 function buildUploadFilename(file) {
  const ext = path.extname(file.originalname || '').toLowerCase()
  const safeExt = ext && /^[.a-z0-9]+$/.test(ext) ? ext : ''
@@ -89,7 +105,8 @@ const tierListUpsertSchema = z.object({

 router.get('/public', async (req, res) => {
  const gameId = req.query.gameId
-  const lists = await listPublicTierLists(gameId, req.session?.userId || '')
+  const queryText = typeof req.query.q === 'string' ? req.query.q : ''
+  const lists = await listPublicTierLists(gameId, req.session?.userId || '', queryText)
  res.json({ tierLists: lists })
 })

@@ -98,6 +115,13 @@ router.get('/me', requireAuth, async (req, res) => {
  res.json({ tierLists: lists })
 })

+router.get('/favorites/me', requireAuth, async (req, res) => {
+  const queryText = typeof req.query.q === 'string' ? req.query.q : ''
+  const sort = typeof req.query.sort === 'string' ? req.query.sort : 'favorited'
+  const lists = await listFavoriteTierLists(req.session.userId, { queryText, sort })
+  res.json({ tierLists: lists })
+})
+
 router.get('/:id', async (req, res) => {
  const t = await findTierListById(req.params.id, req.session?.userId || '')
  if (!t) return res.status(404).json({ error: 'not_found' })
@@ -159,6 +183,49 @@ router.post('/thumbnail', requireAuth, thumbnailUpload.single('thumbnail'), asyn
  res.json({ thumbnailSrc: `/uploads/tierlists/${req.file.filename}` })
 })

+router.post('/:id/template-request', requireAuth, async (req, res) => {
+  const schema = z.object({
+    type: z.enum(['create', 'update']),
+  })
+  const parsed = schema.safeParse(req.body)
+  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })
+
+  const tierList = await findTierListById(req.params.id, req.session.userId)
+  if (!tierList) return res.status(404).json({ error: 'not_found' })
+  if (tierList.authorId !== req.session.userId) return res.status(403).json({ error: 'forbidden' })
+
+  const customItems = getCustomTemplateItems(tierList)
+  if (!customItems.length) return res.status(400).json({ error: 'custom_items_required' })
+
+  if (parsed.data.type === 'create') {
+    if (tierList.gameId !== FREEFORM_GAME_ID) return res.status(400).json({ error: 'freeform_required' })
+    if (!isTierListBoardEmpty(tierList)) return res.status(400).json({ error: 'board_must_be_empty' })
+  } else {
+    if (tierList.gameId === FREEFORM_GAME_ID) return res.status(400).json({ error: 'game_template_required' })
+  }
+
+  try {
+    const request = await createTemplateRequest({
+      id: nanoid(),
+      type: parsed.data.type,
+      requesterId: req.session.userId,
+      sourceTierListId: tierList.id,
+      sourceGameId: tierList.gameId,
+      targetGameId: parsed.data.type === 'update' ? tierList.gameId : '',
+      title: tierList.title,
+      description: tierList.description || '',
+      thumbnailSrc: tierList.thumbnailSrc || '',
+      items: customItems,
+    })
+    return res.json({ request })
+  } catch (e) {
+    if (e?.code === 'TEMPLATE_REQUEST_EXISTS') {
+      return res.status(409).json({ error: 'template_request_exists' })
+    }
+    throw e
+  }
+})
+
 router.post('/', requireAuth, async (req, res) => {
  const parsed = tierListUpsertSchema.safeParse(req.body)
  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })
--- a/docs/history.md
+++ b/docs/history.md
@@ -1,5 +1,23 @@
 # 의사결정 이력

+## 2026-03-27 v0.1.47
+- 새 게임 템플릿 등록과 기존 템플릿 업데이트는 운영자가 직접 일일이 훑기보다, 사용자가 명시적으로 요청을 보내고 관리자가 승인하는 흐름이 더 빠르고 명확하다고 정리했다.
+- 템플릿 요청에 포함되는 커스텀 아이템 이름은 관리자 판단의 핵심 정보이므로, 티어표 편집 화면 안에서도 직접 이름을 정리하고 저장 시 원본 커스텀 아이템 라벨까지 함께 동기화하기로 결정했다.
+- 새 템플릿 등록 요청은 실제 템플릿처럼 비어 있는 상태가 더 활용도가 높으므로, `freeform + 빈 보드 + 커스텀 아이템 존재` 조건에서만 보낼 수 있게 제한하기로 했다.
+
+## 2026-03-27 v0.1.46
+- 티어표 편집 중 등급 행에 넣은 아이템도 다시 제외할 수 있어야 배치 실험이 쉬우므로, 별도 제거 버튼으로 아이템 풀로 되돌리는 흐름을 제공하기로 결정했다.
+- 관리자 회원 관리는 수정 기능만으로는 부족하므로, 운영 판단에 바로 필요한 아바타, 작성 티어표 수, 최근 활동 시각을 함께 보여주기로 했다.
+
+## 2026-03-27 v0.1.45
+- 카드형 목록의 별표는 개수 표시로 읽히기 쉬우므로, 목록에서는 상태/개수만 보여주고 실제 즐겨찾기 토글은 상세 화면에서 처리하는 편이 오해가 적다고 정리했다.
+- 토스트는 같은 메시지가 짧게 반복될 때 누적 표시가 더 낫고, 종료도 급격히 끊기지 않도록 페이드아웃을 넣는 편이 사용자 경험상 자연스럽다고 판단했다.
+
+## 2026-03-27 v0.1.44
+- 전역 토스트는 공통 composable을 템플릿에 넘길 때 top-level ref로 풀어줘야 하므로, 렌더링 구조를 단순하게 유지하는 편이 안전하다고 정리했다.
+- 공개 티어표가 많아질수록 게임별 목록 안에서 바로 제목/작성자 검색이 가능해야 하므로, 검색은 별도 페이지보다 각 게임 허브 안에서 먼저 제공하기로 결정했다.
+- 즐겨찾기는 저장만으로 끝나면 활용도가 낮으므로, 별도 `내 즐겨찾기` 화면과 정렬 옵션을 함께 제공해야 실사용성이 높다고 판단했다.
+
 ## 2026-03-27 v0.1.43
 - 화면 상단 인라인 경고는 스크롤이 생기면 놓치기 쉬우므로, 저장/삭제/가져오기 같은 사용자 행동 피드백은 전역 우측 상단 토스트로 통일하는 편이 더 적합하다고 정리했다.
 - 관리자 티어표 관리의 목적지 선택은 상단 고정 셀렉트보다 액션 직전 모달이 더 명확하므로, `기존 템플릿에 추가 / 새 템플릿 만들기`를 그 순간에 고르게 하기로 결정했다.
--- a/docs/map.md
+++ b/docs/map.md
@@ -7,7 +7,7 @@

 ## `/games/:gameId`
 - 화면 파일: `frontend/src/views/GameHubView.vue`
- 역할: 선택한 게임 정보 표시, 공개 티어표 목록 표시, 티어표별 상단 썸네일/작성자 표시, 즐겨찾기 토글, 새 티어표 작성 진입
+- 역할: 선택한 게임 정보 표시, 공개 티어표 목록 표시, 제목/작성자 검색, 티어표별 상단 썸네일/작성자 표시, 즐겨찾기 토글, 새 티어표 작성 진입
 - 연동 API: `GET /api/games/:gameId`, `GET /api/tierlists/public`, `POST /api/tierlists/:id/favorite`, `DELETE /api/tierlists/:id/favorite`

 ## `/editor/:gameId/new`, `/editor/:gameId/:tierListId`
@@ -25,10 +25,15 @@
 - 역할: 내 티어표 목록 조회, 상단 썸네일 카드 표시, 편집 화면으로 이동, 작성자 본인 티어표 삭제
 - 연동 API: `GET /api/tierlists/me`, `DELETE /api/tierlists/:id`

+## `/favorites`
+- 화면 파일: `frontend/src/views/FavoriteTierListsView.vue`
+- 역할: 즐겨찾기한 티어표 목록 조회, 검색/정렬, 편집 화면 이동, 즐겨찾기 해제
+- 연동 API: `GET /api/tierlists/favorites/me`, `DELETE /api/tierlists/:id/favorite`
+
 ## `/admin`
 - 화면 파일: `frontend/src/views/AdminView.vue`
- 역할: `게임 관리 / 아이템 관리 / 티어표 관리 / 회원 관리` 탭 분리, 선택된 게임의 썸네일 관리, 기본 아이템 다중 드래그 앤 드롭 업로드, 기본 아이템 이름 수정, 사용자 커스텀 아이템 검색/페이지네이션/사용 횟수 확인/미사용 이미지 개별·일괄 삭제, 사용자 커스텀 아이템의 기본 템플릿 승격, 전체 티어표 검색/페이지네이션/공개 여부 확인/완성본 이동, 티어표의 추가 커스텀 아이템을 모달 기반으로 기존 템플릿 또는 새 템플릿에 가져오기, freeform 티어표의 게임 템플릿화, 회원 비밀번호 초기화 포함 회원 관리, 파일 입력 초기화, 아이템 삭제, 게임 삭제
- 연동 API: `POST /api/admin/games`, `POST /api/admin/games/:gameId/thumbnail`, `POST /api/admin/games/:gameId/images`, `PATCH /api/admin/games/:gameId/items/:itemId`, `GET /api/admin/custom-items`, `POST /api/admin/custom-items/:itemId/promote`, `DELETE /api/admin/custom-items/:itemId`, `DELETE /api/admin/custom-items`, `GET /api/admin/tierlists`, `POST /api/admin/tierlists/:tierListId/promote-items`, `POST /api/admin/tierlists/:tierListId/create-game-template`, `GET /api/admin/users`, `PATCH /api/admin/users/:userId`, `PATCH /api/admin/users/:userId/password`, `DELETE /api/admin/users/:userId`, `DELETE /api/admin/games/:gameId/items/:itemId`, `DELETE /api/admin/games/:gameId`
+- 역할: `게임 관리 / 아이템 관리 / 티어표 관리 / 회원 관리` 탭 분리, 선택된 게임의 썸네일 관리, 기본 아이템 다중 드래그 앤 드롭 업로드, 기본 아이템 이름 수정, 사용자 커스텀 아이템 검색/페이지네이션/사용 횟수 확인/미사용 이미지 개별·일괄 삭제, 사용자 커스텀 아이템의 기본 템플릿 승격, 전체 티어표 검색/페이지네이션/공개 여부 확인/완성본 이동, 티어표의 추가 커스텀 아이템을 모달 기반으로 기존 템플릿 또는 새 템플릿에 가져오기, freeform 티어표의 게임 템플릿화, 사용자 템플릿 등록/업데이트 요청 승인·반려, 회원 비밀번호 초기화 포함 회원 관리, 파일 입력 초기화, 아이템 삭제, 게임 삭제
+- 연동 API: `POST /api/admin/games`, `POST /api/admin/games/:gameId/thumbnail`, `POST /api/admin/games/:gameId/images`, `PATCH /api/admin/games/:gameId/items/:itemId`, `GET /api/admin/custom-items`, `POST /api/admin/custom-items/:itemId/promote`, `DELETE /api/admin/custom-items/:itemId`, `DELETE /api/admin/custom-items`, `GET /api/admin/tierlists`, `GET /api/admin/template-requests`, `POST /api/admin/template-requests/:requestId/approve`, `POST /api/admin/template-requests/:requestId/reject`, `POST /api/admin/tierlists/:tierListId/promote-items`, `POST /api/admin/tierlists/:tierListId/create-game-template`, `GET /api/admin/users`, `PATCH /api/admin/users/:userId`, `PATCH /api/admin/users/:userId/password`, `DELETE /api/admin/users/:userId`, `DELETE /api/admin/games/:gameId/items/:itemId`, `DELETE /api/admin/games/:gameId`

 ## `/profile`
 - 화면 파일: `frontend/src/views/ProfileView.vue`
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -81,7 +81,9 @@
 - 티어표
  - `GET /api/tierlists/public`
  - `GET /api/tierlists/me`
+  - `GET /api/tierlists/favorites/me`
  - `GET /api/tierlists/:id`
+  - `POST /api/tierlists/:id/template-request`
  - `POST /api/tierlists/:id/favorite`
  - `DELETE /api/tierlists/:id/favorite`
  - `DELETE /api/tierlists/:id`
@@ -95,6 +97,9 @@
    - 여러 이미지를 한 번에 업로드할 수 있고, 별도 라벨이 없으면 파일명 기준으로 기본 아이템 이름을 만든다.
  - `PATCH /api/admin/games/:gameId/items/:itemId`
  - `GET /api/admin/tierlists`
+  - `GET /api/admin/template-requests`
+  - `POST /api/admin/template-requests/:requestId/approve`
+  - `POST /api/admin/template-requests/:requestId/reject`
  - `POST /api/admin/tierlists/:tierListId/promote-items`
  - `POST /api/admin/tierlists/:tierListId/create-game-template`
  - `GET /api/admin/custom-items`
@@ -123,18 +128,27 @@
 - `티어표 관리` 탭의 추가 아이템은 작은 그리드 카드로 표시하고, 클릭 시 `기존 템플릿에 추가 / 새 템플릿 만들기` 모달을 통해 목적지를 선택한다.
 - `티어표 관리` 탭에서는 티어표 안의 커스텀 아이템을 개별 또는 일괄로 기존 게임 템플릿에 복제할 수 있다.
 - `freeform` 티어표는 관리자 화면에서 새 게임 ID/이름을 입력해 새로운 게임 템플릿으로 복제 생성할 수 있다.
+- 관리자 티어표 관리 상단에는 사용자가 보낸 템플릿 등록/업데이트 요청 목록이 별도로 표시되며, 여기서 승인/반려를 바로 처리할 수 있다.
 - 관리자 화면에서는 회원 이메일/닉네임/권한 수정, 비밀번호 초기화, 계정 삭제가 가능하다.
+- 회원 관리 카드에는 아바타, 작성 티어표 수, 최근 활동 시각을 함께 표시한다.

 ## 티어표 접근 메모
 - `new` 작성 경로는 로그인한 사용자만 진입할 수 있다.
 - 비로그인 사용자는 공개된 티어표를 열람만 할 수 있고, 편집 UI와 저장 동작은 비활성화된다.
 - 비공개 티어표라도 관리자는 편집 화면에서 완성본을 열람할 수 있다.
 - 공개 티어표는 목록과 상세 화면에서 즐겨찾기 토글 및 개수를 함께 표시한다.
+- 카드형 목록에서는 즐겨찾기 수/상태만 표시하고, 실제 토글은 상세 화면에서 처리한다.
+- 공개 티어표 목록은 현재 게임 기준으로 제목/작성자 검색을 지원한다.
+- `내 즐겨찾기` 화면에서는 즐겨찾기한 순, 최신 업데이트순, 인기순 정렬을 제공한다.
 - 커스텀 이미지 추가는 다중 파일 선택과 드래그 앤 드롭을 모두 지원한다.
+- 사용자가 직접 추가한 커스텀 아이템 이름은 편집 화면 우측 목록에서 정리할 수 있고, 저장 시 원본 커스텀 아이템 라벨과 함께 동기화된다.
 - 티어 행은 기본 5단으로 시작하지만, 사용자가 직접 추가하거나 제거할 수 있다.
+- 티어 행에 넣은 아이템은 작은 제거 버튼으로 다시 우측 아이템 풀로 되돌릴 수 있다.
 - 신규 티어표의 공개 여부 기본값은 `ON`이며, 기존 티어표는 편집 화면과 `내 티어표` 목록에서 직접 삭제할 수 있다.
 - 제목이 비어 있는 상태로 저장하면 내부 제목은 현재 게임명을 기본값으로 사용한다.
 - 제목 입력이 비어 있는 동안에는 무분별한 도배 방지를 위한 관리자 임의 삭제 가능성 안내 문구를 표시한다.
+- `freeform` 티어표는 보드가 비어 있고 커스텀 아이템이 준비된 상태에서만 `템플릿 등록 요청`을 보낼 수 있다.
+- 기존 게임 티어표는 커스텀 아이템이 포함되어 있으면 `템플릿 업데이트 요청`을 보낼 수 있다.
 - 티어표는 편집 화면에서 16:9 썸네일 이미지를 별도로 선택해 저장할 수 있고, 목록 카드에서는 그 이미지를 상단 대표 썸네일로 사용한다.
 - 편집 화면 상단 헤더는 좌측 제목/설명, 우측 썸네일 카드 구조를 사용하며 모바일에서는 한 열로 접힌다.
 - 티어표 편집기의 아이콘 기본 크기는 `80px`이며, 사용자가 `48 / 60 / 80 / 100 / 120` 단계로 즉시 조절할 수 있다.
@@ -143,6 +157,7 @@
 - 티어표 목록 메타 정보는 최종 업데이트 시각만 간략하게 표시한다.
 - 저장 성공 시에는 에디터 안에서 반투명 오버레이 기반 확인 모달을 띄우고, PNG export 이미지는 약 `960px` 보드 폭과 `pixelRatio 1.5`, 외곽 여백, 작성자/날짜 하단 메타를 포함해 생성한다.
 - 저장/삭제/가져오기 같은 사용자 행동 피드백은 전역 우측 상단 토스트로 표시한다.
+- 전역 토스트는 동일 메시지/타입이 연속 발생하면 하나로 합쳐 카운트를 올리고, 종료 시 짧은 페이드아웃 애니메이션을 사용한다.
 - 홈 게임 목록은 관리자 상단 고정 순서가 있으면 그 순서를 먼저 적용하고, 그 외 게임은 최근 생성순으로 뒤에 이어진다.
 - `커스텀 티어표 만들기`는 카드가 아니라 홈 우측 상단 버튼으로 진입한다.

--- a/docs/todo.md
+++ b/docs/todo.md
@@ -1,16 +1,18 @@
 # 할 일 및 이슈

 ## 즉시 확인 필요
- 회원 관리에서 아바타/작성 티어표 수/최근 활동 같은 보조 정보는 아직 표시하지 않는다.
 - 미사용 커스텀 이미지 일괄 삭제는 현재 "참조가 없는 항목" 기준이며, 보관 기간 정책 같은 운영 규칙은 아직 없다.
 - 업로드 이미지는 현재 원본 파일을 그대로 저장하므로, 운영 부담이 커지면 서버 저장 전 리사이즈/압축(예: 긴 변 제한, WebP 변환) 도입이 필요하다.
 - 관리자 기본 아이템 다중 업로드는 현재 파일명 기반 자동 라벨만 지원하므로, 필요하면 업로드 후 일괄 라벨 수정/정렬 UX를 추가 검토한다.
 - 티어표 썸네일은 현재 업로드/교체만 지원하므로, 필요하면 자동 썸네일 추출이나 업로드 이미지 크롭 UX를 추가 검토한다.
 - 사용자 커스텀 아이템 승격은 현재 수동 복제 방식이므로, 필요하면 중복 감지나 “비슷한 항목 추천” 같은 보조 UX를 검토한다.
+- 템플릿 등록/업데이트 요청은 현재 승인/반려만 지원하므로, 필요하면 관리자 코멘트나 사용자용 요청 상태 이력 화면을 추가 검토한다.
 - 관리자 티어표 관리의 템플릿 생성은 현재 `freeform`만 직접 지원하므로, 필요하면 일반 게임 티어표의 전체 아이템을 복제한 파생 템플릿 생성 UX도 검토한다.
 - 관리자 티어표 관리의 추가 아이템 승격은 현재 커스텀(origin=`custom`) 아이템 기준이므로, 필요하면 “기존 게임 아이템과 비교한 차집합” 기준으로 더 정교하게 확장할 수 있다.
- 즐겨찾기는 현재 저장/토글만 지원하므로, 필요하면 `내 즐겨찾기` 목록 화면이나 즐겨찾기순 정렬을 추가 검토한다.
- 전역 토스트는 기본 시간 기반 자동 종료만 지원하므로, 필요하면 중복 합치기나 액션 링크 포함 형태로 확장할 수 있다.
+- 즐겨찾기는 현재 `내 즐겨찾기` 목록과 정렬까지 지원하므로, 필요하면 폴더 분류나 메모 같은 개인 정리 기능을 추가 검토한다.
+- 전역 토스트는 중복 합치기와 페이드아웃까지 지원하므로, 필요하면 액션 링크나 수동 고정(pin) 같은 상호작용 확장을 검토한다.
+- 공개 티어표 검색은 현재 게임별 허브 안에서만 제공하므로, 필요하면 홈 전역 통합 검색도 검토한다.
+- 즐겨찾기 토글은 현재 상세 화면 중심이므로, 필요하면 카드 목록에서도 안전한 보조 인터랙션(예: 길게 누르기, 별도 메뉴)을 검토한다.

 ## 배포 전 작업
 - NAS 실제 도메인 기준으로 `VITE_API_ORIGIN`, `CORS_ORIGINS`, `SESSION_SECRET`, `SESSION_COOKIE_SECURE`, `TRUST_PROXY` 값을 설정한다.
--- a/docs/update.md
+++ b/docs/update.md
@@ -1,5 +1,23 @@
 # 업데이트 로그

+## 2026-03-27 v0.1.47
+- **템플릿 등록/업데이트 요청 추가**: 사용자가 저장된 티어표를 기준으로 관리자에게 `새 템플릿 등록` 또는 `기존 템플릿 업데이트` 요청을 보낼 수 있도록 요청 API와 관리자 승인 흐름을 추가
+- **커스텀 아이템 이름 편집 확장**: 티어표 편집 화면에서 사용자가 직접 추가한 커스텀 아이템 이름을 정리할 수 있는 전용 입력 목록을 추가하고, 저장 시 MariaDB의 커스텀 아이템 라벨도 함께 동기화
+- **관리자 요청 목록 추가**: 관리자 티어표 관리 탭 상단에 처리 대기 중인 템플릿 요청 목록을 추가하고, 새 게임 템플릿 생성 승인과 기존 게임 템플릿 업데이트 승인을 바로 처리할 수 있게 개선
+
+## 2026-03-27 v0.1.46
+- **티어 행 아이템 제거 추가**: 티어표 편집 화면에서 이미 등급 행에 넣은 아이템도 작은 제거 버튼으로 다시 아이템 풀로 빼낼 수 있도록 보강
+- **회원 관리 보조 정보 확장**: 관리자 회원 관리 카드에 아바타, 작성 티어표 수, 최근 활동 시각을 함께 표시해 운영 판단에 필요한 정보를 바로 확인할 수 있도록 개선
+
+## 2026-03-27 v0.1.45
+- **즐겨찾기 카드 액션 보정**: 카드형 목록에서는 별표를 클릭 액션이 아닌 상태/개수 표시로만 보여주고, 실제 즐겨찾기 토글은 상세 화면에서 처리하도록 조정
+- **토스트 중복/페이드아웃 개선**: 같은 메시지 토스트는 하나로 합치고 카운트를 올리도록 변경했으며, 사라질 때는 짧은 페이드아웃 애니메이션을 적용
+
+## 2026-03-27 v0.1.44
+- **토스트 렌더링 버그 수정**: 전역 토스트가 빈 카드 여러 개로 보이던 ref 참조 문제를 수정해 실제 메시지만 표시되도록 정리
+- **공개 티어표 검색 추가**: 게임별 공개 티어표 목록에서 제목/작성자 기준 검색이 가능하도록 검색창과 API 쿼리 지원 추가
+- **내 즐겨찾기 페이지 추가**: 사용자별 즐겨찾기 목록 화면과 `즐겨찾기한 순 / 최신 업데이트순 / 인기순` 정렬 옵션을 추가
+
 ## 2026-03-27 v0.1.43
 - **전역 토스트 알림 추가**: 저장/삭제/가져오기 같은 사용자 행동 피드백을 상단 인라인 경고 대신 우측 상단 토스트로 통일해 잠시 표시 후 자동으로 사라지도록 변경
 - **관리자 티어표 아이템 가져오기 모달화**: 티어표 관리의 추가 아이템 영역을 소형 그리드로 다듬고, 가져오기 시점에 `기존 템플릿에 추가 / 새 템플릿 만들기`를 선택하는 모달 흐름으로 재정리
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -8,7 +8,7 @@ import { useToast } from './composables/useToast'
 const route = useRoute()
 const router = useRouter()
 const auth = useAuthStore()
-const toast = useToast()
+const { toasts, dismissToast } = useToast()
 const isAdmin = computed(() => !!auth.user?.isAdmin)
 const avatarUrl = computed(() => {
  if (!auth.user?.avatarSrc) return ''
@@ -65,6 +65,7 @@ async function logout() {
      <nav class="nav">
        <RouterLink to="/" class="nav__link">게임</RouterLink>
        <RouterLink to="/me" class="nav__link">내 티어표</RouterLink>
+        <RouterLink v-if="auth.user" to="/favorites" class="nav__link">즐겨찾기</RouterLink>
        <RouterLink v-if="isAdmin" to="/admin" class="nav__link">관리자</RouterLink>

        <RouterLink v-if="!auth.user" to="/login" class="nav__link">로그인</RouterLink>
@@ -84,9 +85,12 @@ async function logout() {
      <RouterView />
    </main>
    <div class="toastStack" aria-live="polite" aria-atomic="true">
-      <div v-for="item in toast.toasts" :key="item.id" class="toast" :class="`toast--${item.type}`">
-        <div class="toast__message">{{ item.message }}</div>
-        <button class="toast__close" @click="toast.dismissToast(item.id)">닫기</button>
+      <div v-for="item in toasts" :key="item.id" class="toast" :class="[`toast--${item.type}`, { 'toast--closing': item.isClosing }]">
+        <div class="toast__body">
+          <div class="toast__message">{{ item.message }}</div>
+          <div v-if="item.count > 1" class="toast__count">x{{ item.count }}</div>
+        </div>
+        <button class="toast__close" @click="dismissToast(item.id)">닫기</button>
      </div>
    </div>
  </div>
@@ -226,6 +230,13 @@ async function logout() {
  background: rgba(11, 18, 32, 0.94);
  backdrop-filter: blur(12px);
  box-shadow: 0 14px 30px rgba(0, 0, 0, 0.28);
+  opacity: 1;
+  transform: translateY(0);
+  transition: opacity 220ms ease, transform 220ms ease;
+}
+.toast--closing {
+  opacity: 0;
+  transform: translateY(-6px);
 }
 .toast--success {
  border-color: rgba(52, 211, 153, 0.38);
@@ -240,6 +251,19 @@ async function logout() {
  line-height: 1.5;
  font-size: 14px;
 }
+.toast__body {
+  min-width: 0;
+}
+.toast__count {
+  margin-top: 6px;
+  width: fit-content;
+  padding: 2px 8px;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.08);
+  font-size: 12px;
+  font-weight: 800;
+  opacity: 0.84;
+}
 .toast__close {
  flex: 0 0 auto;
  border: 0;
--- a/frontend/src/composables/useToast.js
+++ b/frontend/src/composables/useToast.js
@@ -2,18 +2,48 @@ import { readonly, ref } from 'vue'

 const toasts = ref([])
 let toastSeq = 0
+const TOAST_EXIT_MS = 220
+
+function clearToastTimer(toast) {
+  if (toast?.timerId) {
+    window.clearTimeout(toast.timerId)
+    toast.timerId = 0
+  }
+}
+
+function removeToast(id) {
+  toasts.value = toasts.value.filter((toast) => toast.id !== id)
+}

 function dismissToast(id) {
-  toasts.value = toasts.value.filter((toast) => toast.id !== id)
+  const target = toasts.value.find((toast) => toast.id === id)
+  if (!target || target.isClosing) return
+
+  clearToastTimer(target)
+  target.isClosing = true
+  target.timerId = window.setTimeout(() => removeToast(id), TOAST_EXIT_MS)
 }

 function showToast(message, { type = 'info', duration = 2600 } = {}) {
  if (!message) return ''
+  const duplicated = toasts.value.find((toast) => toast.message === message && toast.type === type && !toast.isClosing)
+
+  if (duplicated) {
+    duplicated.count = (duplicated.count || 1) + 1
+    clearToastTimer(duplicated)
+    if (duration > 0) {
+      duplicated.timerId = window.setTimeout(() => dismissToast(duplicated.id), duration)
+    }
+    toasts.value = [...toasts.value]
+    return duplicated.id
+  }
+
  const id = `toast-${++toastSeq}`
-  toasts.value = [...toasts.value, { id, message, type }]
+  const nextToast = { id, message, type, count: 1, isClosing: false, timerId: 0 }
+  toasts.value = [...toasts.value, nextToast]

  if (duration > 0) {
-    window.setTimeout(() => dismissToast(id), duration)
+    nextToast.timerId = window.setTimeout(() => dismissToast(id), duration)
  }

  return id
--- a/frontend/src/lib/api.js
+++ b/frontend/src/lib/api.js
@@ -41,12 +41,16 @@ export const api = {
    ),
  listAdminTierLists: ({ q = '', page = 1, limit = 50 } = {}) =>
    request(`/api/admin/tierlists?q=${encodeURIComponent(q)}&page=${encodeURIComponent(page)}&limit=${encodeURIComponent(limit)}`),
+  listAdminTemplateRequests: () => request('/api/admin/template-requests'),
  promoteAdminCustomItem: (itemId, payload) =>
    request(`/api/admin/custom-items/${encodeURIComponent(itemId)}/promote`, { method: 'POST', body: payload }),
  promoteAdminTierListItems: (tierListId, payload) =>
    request(`/api/admin/tierlists/${encodeURIComponent(tierListId)}/promote-items`, { method: 'POST', body: payload }),
  createAdminGameTemplateFromTierList: (tierListId, payload) =>
    request(`/api/admin/tierlists/${encodeURIComponent(tierListId)}/create-game-template`, { method: 'POST', body: payload }),
+  approveAdminTemplateRequest: (requestId, payload) =>
+    request(`/api/admin/template-requests/${encodeURIComponent(requestId)}/approve`, { method: 'POST', body: payload || {} }),
+  rejectAdminTemplateRequest: (requestId) => request(`/api/admin/template-requests/${encodeURIComponent(requestId)}/reject`, { method: 'POST', body: {} }),
  listAdminUsers: () => request('/api/admin/users'),
  updateAdminUser: (userId, payload) =>
    request(`/api/admin/users/${encodeURIComponent(userId)}`, { method: 'PATCH', body: payload }),
@@ -56,11 +60,16 @@ export const api = {

  listPublicTierLists: (gameId) =>
    request(`/api/tierlists/public?gameId=${encodeURIComponent(gameId || '')}`),
+  searchPublicTierLists: (gameId, q = '') =>
+    request(`/api/tierlists/public?gameId=${encodeURIComponent(gameId || '')}&q=${encodeURIComponent(q || '')}`),
  listMyTierLists: () => request('/api/tierlists/me'),
+  listMyFavoriteTierLists: ({ q = '', sort = 'favorited' } = {}) =>
+    request(`/api/tierlists/favorites/me?q=${encodeURIComponent(q)}&sort=${encodeURIComponent(sort)}`),
  getTierList: (id) => request(`/api/tierlists/${encodeURIComponent(id)}`),
  favoriteTierList: (id) => request(`/api/tierlists/${encodeURIComponent(id)}/favorite`, { method: 'POST' }),
  unfavoriteTierList: (id) => request(`/api/tierlists/${encodeURIComponent(id)}/favorite`, { method: 'DELETE' }),
  deleteTierList: (id) => request(`/api/tierlists/${encodeURIComponent(id)}`, { method: 'DELETE' }),
+  requestTierListTemplate: (id, payload) => request(`/api/tierlists/${encodeURIComponent(id)}/template-request`, { method: 'POST', body: payload }),
  saveTierList: (payload) => request('/api/tierlists', { method: 'POST', body: payload }),
  uploadTierListThumbnail: async (file) => {
    const fd = new FormData()
--- a/frontend/src/router/index.js
+++ b/frontend/src/router/index.js
@@ -5,6 +5,7 @@ import GameHubView from '../views/GameHubView.vue'
 import TierEditorView from '../views/TierEditorView.vue'
 import LoginView from '../views/LoginView.vue'
 import MyTierListsView from '../views/MyTierListsView.vue'
+import FavoriteTierListsView from '../views/FavoriteTierListsView.vue'
 import AdminView from '../views/AdminView.vue'
 import ProfileView from '../views/ProfileView.vue'

@@ -18,9 +19,9 @@ export function createRouter() {
      { path: '/editor/:gameId/:tierListId', name: 'editEditor', component: TierEditorView },
      { path: '/login', name: 'login', component: LoginView },
      { path: '/me', name: 'me', component: MyTierListsView },
+      { path: '/favorites', name: 'favorites', component: FavoriteTierListsView },
      { path: '/admin', name: 'admin', component: AdminView },
      { path: '/profile', name: 'profile', component: ProfileView },
    ],
  })
 }
-
--- a/frontend/src/views/AdminView.vue
+++ b/frontend/src/views/AdminView.vue
@@ -33,6 +33,7 @@ const adminTierListQuery = ref('')
 const adminTierListPage = ref(1)
 const adminTierListLimit = ref(50)
 const adminTierListTotal = ref(0)
+const templateRequests = ref([])
 const importModalOpen = ref(false)
 const importModalMode = ref('existing')
 const importModalTierList = ref(null)
@@ -74,7 +75,7 @@ const importModalItemCount = computed(() => importModalItems.value.length)

 onMounted(async () => {
  await auth.refresh()
-  await Promise.all([refreshGames(), refreshCustomItems(), refreshAdminTierLists(), refreshUsers()])
+  await Promise.all([refreshGames(), refreshCustomItems(), refreshAdminTierLists(), refreshUsers(), refreshTemplateRequests()])
  await syncFeaturedSortable()
 })

@@ -189,6 +190,30 @@ async function refreshAdminTierLists() {
  }
 }

+async function refreshTemplateRequests() {
+  if (!auth.user?.isAdmin) return
+  try {
+    const data = await api.listAdminTemplateRequests()
+    templateRequests.value = (data.requests || []).map((request) => ({
+      ...request,
+      draftGameId:
+        request.type === 'create'
+          ? (request.sourceTierListTitle || '')
+              .toLowerCase()
+              .replace(/[^a-z0-9]+/g, '-')
+              .replace(/^-+|-+$/g, '')
+              .slice(0, 80) || 'new-template'
+          : request.targetGameId || request.sourceGameId || '',
+      draftGameName:
+        request.type === 'create'
+          ? `${request.sourceTierListTitle || request.sourceGameName || '새 템플릿'}`
+          : request.targetGameName || request.sourceGameName || '',
+    }))
+  } catch (e) {
+    error.value = '템플릿 요청 목록을 불러오지 못했어요.'
+  }
+}
+
 async function refreshUsers() {
  if (!auth.user?.isAdmin) return
  try {
@@ -690,6 +715,59 @@ async function confirmTierListImport() {
  }
 }

+function templateRequestTypeLabel(request) {
+  return request.type === 'create' ? '템플릿 등록 요청' : '템플릿 업데이트 요청'
+}
+
+function templateRequestTargetLabel(request) {
+  return request.type === 'create' ? '새 게임 템플릿 생성' : request.targetGameName || request.targetGameId || request.sourceGameName
+}
+
+async function approveTemplateRequest(request) {
+  resetMessages()
+  try {
+    request.isHandling = true
+    if (request.type === 'create') {
+      const nextGameId = (request.draftGameId || '').trim()
+      const nextGameName = (request.draftGameName || '').trim()
+      if (!nextGameId || !nextGameName) {
+        error.value = '새 게임 ID와 이름을 모두 입력해주세요.'
+        return
+      }
+      await api.approveAdminTemplateRequest(request.id, {
+        gameId: nextGameId,
+        name: nextGameName,
+      })
+      await refreshGames()
+      success.value = `"${nextGameName}" 템플릿 생성을 승인했어요.`
+    } else {
+      const data = await api.approveAdminTemplateRequest(request.id)
+      if (selectedGameId.value === (request.targetGameId || request.sourceGameId)) await loadGame()
+      success.value = `${data.items?.length || 0}개의 아이템 추가 요청을 승인했어요.`
+    }
+    await refreshTemplateRequests()
+    await refreshAdminTierLists()
+  } catch (e) {
+    error.value = request.type === 'create' ? '템플릿 등록 요청 승인에 실패했어요.' : '템플릿 업데이트 요청 승인에 실패했어요.'
+  } finally {
+    request.isHandling = false
+  }
+}
+
+async function rejectTemplateRequest(request) {
+  resetMessages()
+  try {
+    request.isHandling = true
+    await api.rejectAdminTemplateRequest(request.id)
+    await refreshTemplateRequests()
+    success.value = '요청을 반려했어요.'
+  } catch (e) {
+    error.value = '요청 반려에 실패했어요.'
+  } finally {
+    request.isHandling = false
+  }
+}
+
 const displayThumbnailUrl = computed(() => {
  if (thumbPreviewUrl.value) return thumbPreviewUrl.value
  if (selectedGame.value?.game?.thumbnailSrc) return toApiUrl(selectedGame.value.game.thumbnailSrc)
@@ -706,6 +784,18 @@ function fmt(ts) {
  })
 }

+function userAvatarUrl(user) {
+  return user?.avatarSrc ? toApiUrl(user.avatarSrc) : ''
+}
+
+function userDisplayName(user) {
+  return user?.nickname || user?.email?.split('@')[0] || '알 수 없음'
+}
+
+function userAvatarFallback(user) {
+  return (user?.email?.trim()?.[0] || '?').toUpperCase()
+}
+
 function addFeaturedGame(gameId) {
  resetMessages()
  if (!gameId || featuredGameIds.value.includes(gameId)) return
@@ -994,6 +1084,53 @@ async function saveFeaturedOrder() {
        </template>

        <template v-else-if="activeTab === 'tierlists'">
+          <div class="panel">
+            <div class="sectionHeader">
+              <div>
+                <div class="panel__title">사용자 템플릿 요청</div>
+                <div class="hint hint--tight">freeform 템플릿 등록 요청과 기존 게임 템플릿 업데이트 요청을 여기서 승인하거나 반려할 수 있어요.</div>
+              </div>
+              <button class="btn btn--ghost" @click="refreshTemplateRequests">새로고침</button>
+            </div>
+
+            <div v-if="!templateRequests.length" class="hint">현재 처리 대기 중인 템플릿 요청이 없어요.</div>
+            <div v-else class="templateRequestList">
+              <article v-for="request in templateRequests" :key="request.id" class="templateRequestCard">
+                <div class="templateRequestCard__head">
+                  <div>
+                    <div class="templateRequestCard__title">{{ request.sourceTierListTitle }}</div>
+                    <div class="templateRequestCard__meta">
+                      {{ templateRequestTypeLabel(request) }} · {{ request.requesterName }} · {{ fmt(request.createdAt) }}
+                    </div>
+                    <div class="templateRequestCard__meta">{{ templateRequestTargetLabel(request) }}</div>
+                  </div>
+                  <button class="btn btn--ghost btn--small" @click="openAdminTierList({ id: request.sourceTierListId, gameId: request.sourceGameId })">
+                    원본 보기
+                  </button>
+                </div>
+
+                <div v-if="request.items?.length" class="templateRequestItems">
+                  <div v-for="item in request.items" :key="item.id" class="templateRequestItem">
+                    <img class="templateRequestItem__thumb" :src="toApiUrl(item.src)" :alt="item.label" />
+                    <div class="templateRequestItem__label">{{ item.label }}</div>
+                  </div>
+                </div>
+
+                <div v-if="request.type === 'create'" class="templateRequestCard__form">
+                  <input v-model="request.draftGameId" class="input" placeholder="새 게임 ID" />
+                  <input v-model="request.draftGameName" class="input" placeholder="새 게임 이름" />
+                </div>
+
+                <div class="templateRequestCard__actions">
+                  <button class="btn btn--primary" :disabled="request.isHandling" @click="approveTemplateRequest(request)">
+                    {{ request.isHandling ? '처리중...' : '승인' }}
+                  </button>
+                  <button class="btn btn--danger" :disabled="request.isHandling" @click="rejectTemplateRequest(request)">반려</button>
+                </div>
+              </article>
+            </div>
+          </div>
+
          <div class="panel">
            <div class="sectionHeader">
              <div>
@@ -1120,15 +1257,32 @@ async function saveFeaturedOrder() {
            <div v-else class="userList">
              <article v-for="user in users" :key="user.id" class="userCard">
                <div class="userCard__head">
-                  <div>
-                    <div class="userCard__title">{{ user.nickname || '닉네임 없음' }}</div>
-                    <div class="userCard__meta">{{ fmt(user.createdAt) }}</div>
+                  <div class="userCard__identity">
+                    <div class="userAvatar">
+                      <img v-if="userAvatarUrl(user)" class="userAvatar__image" :src="userAvatarUrl(user)" :alt="userDisplayName(user)" />
+                      <span v-else class="userAvatar__fallback">{{ userAvatarFallback(user) }}</span>
+                    </div>
+                    <div>
+                      <div class="userCard__title">{{ userDisplayName(user) }}</div>
+                      <div class="userCard__meta">가입일 {{ fmt(user.createdAt) }}</div>
+                    </div>
                  </div>
                  <span class="roleBadge" :class="{ 'roleBadge--admin': user.draftIsAdmin }">
                    {{ user.draftIsAdmin ? '관리자' : '일반 회원' }}
                  </span>
                </div>

+                <div class="userStats">
+                  <div class="userStat">
+                    <span class="userStat__label">작성 티어표</span>
+                    <strong class="userStat__value">{{ user.tierListCount }}개</strong>
+                  </div>
+                  <div class="userStat">
+                    <span class="userStat__label">최근 활동</span>
+                    <strong class="userStat__value">{{ fmt(user.recentActivityAt || user.createdAt) }}</strong>
+                  </div>
+                </div>
+
                <input v-model="user.draftEmail" class="input" placeholder="이메일" />
                <input v-model="user.draftNickname" class="input" placeholder="닉네임" />
                <label class="checkRow">
@@ -1679,6 +1833,12 @@ async function saveFeaturedOrder() {
  justify-content: space-between;
  align-items: flex-start;
 }
+.userCard__identity {
+  display: flex;
+  gap: 12px;
+  align-items: center;
+  min-width: 0;
+}
 .userCard__title {
  font-weight: 900;
 }
@@ -1687,6 +1847,48 @@ async function saveFeaturedOrder() {
  opacity: 0.72;
  font-size: 13px;
 }
+.userAvatar {
+  width: 48px;
+  height: 48px;
+  flex: 0 0 auto;
+  display: grid;
+  place-items: center;
+  border-radius: 999px;
+  overflow: hidden;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  background: rgba(96, 165, 250, 0.18);
+}
+.userAvatar__image {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+.userAvatar__fallback {
+  font-size: 18px;
+  font-weight: 900;
+}
+.userStats {
+  margin-top: 12px;
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+.userStat {
+  display: grid;
+  gap: 4px;
+  padding: 10px 12px;
+  border-radius: 12px;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  background: rgba(255, 255, 255, 0.03);
+}
+.userStat__label {
+  font-size: 12px;
+  opacity: 0.66;
+}
+.userStat__value {
+  font-size: 14px;
+  font-weight: 900;
+}
 .userCard__actions {
  display: grid;
  grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -1708,6 +1910,70 @@ async function saveFeaturedOrder() {
 .roleBadge--admin {
  background: rgba(96, 165, 250, 0.18);
 }
+.templateRequestList {
+  margin-top: 14px;
+  display: grid;
+  gap: 14px;
+}
+.templateRequestCard {
+  display: grid;
+  gap: 14px;
+  padding: 16px;
+  border-radius: 18px;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  background: rgba(255, 255, 255, 0.03);
+}
+.templateRequestCard__head {
+  display: flex;
+  gap: 12px;
+  justify-content: space-between;
+  align-items: flex-start;
+  flex-wrap: wrap;
+}
+.templateRequestCard__title {
+  font-weight: 900;
+  font-size: 18px;
+}
+.templateRequestCard__meta {
+  margin-top: 4px;
+  font-size: 13px;
+  opacity: 0.72;
+}
+.templateRequestItems {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(96px, 1fr));
+  gap: 10px;
+}
+.templateRequestItem {
+  display: grid;
+  gap: 8px;
+}
+.templateRequestItem__thumb {
+  width: 100%;
+  aspect-ratio: 1 / 1;
+  object-fit: cover;
+  border-radius: 12px;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  background: rgba(255, 255, 255, 0.04);
+}
+.templateRequestItem__label {
+  font-size: 12px;
+  font-weight: 800;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.templateRequestCard__form {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+.templateRequestCard__actions {
+  display: flex;
+  gap: 10px;
+  justify-content: flex-end;
+  flex-wrap: wrap;
+}
 .tierAdminList {
  margin-top: 14px;
  display: grid;
@@ -1882,7 +2148,9 @@ async function saveFeaturedOrder() {
  .section--topGrid,
  .toolbar,
  .itemComposer,
-  .tierAdminCard {
+  .tierAdminCard,
+  .userStats,
+  .templateRequestCard__form {
    grid-template-columns: 1fr;
  }
  .toolbar--secondary {
@@ -1891,6 +2159,9 @@ async function saveFeaturedOrder() {
  .itemPreviewCard {
    max-width: none;
  }
+  .userCard__identity {
+    width: 100%;
+  }
 }
@media (max-width: 640px) {
  .thumbGrid,
--- a/frontend/src/views/FavoriteTierListsView.vue
+++ b/frontend/src/views/FavoriteTierListsView.vue
@@ -0,0 +1,261 @@
+<script setup>
+import { computed, onMounted, ref } from 'vue'
+import { useRouter } from 'vue-router'
+import { api } from '../lib/api'
+import { toApiUrl } from '../lib/runtime'
+import { useToast } from '../composables/useToast'
+
+const router = useRouter()
+const toast = useToast()
+
+const favorites = ref([])
+const query = ref('')
+const sort = ref('favorited')
+const sortLabel = computed(() =>
+  sort.value === 'favorited' ? '즐겨찾기한 날짜' : sort.value === 'updated' ? '최종 업데이트' : '즐겨찾기 수'
+)
+
+function fmt(ts) {
+  return new Date(ts).toLocaleString(undefined, {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+  })
+}
+
+function displayNameOf(tierList) {
+  return tierList.authorName || '알 수 없음'
+}
+
+function avatarSrcOf(tierList) {
+  return tierList.authorAvatarSrc ? toApiUrl(tierList.authorAvatarSrc) : ''
+}
+
+function avatarFallbackOf(tierList) {
+  return (tierList.authorAccountName || 'u').trim().charAt(0).toUpperCase() || '?'
+}
+
+function tierListThumbnailUrl(tierList) {
+  return tierList.thumbnailSrc ? toApiUrl(tierList.thumbnailSrc) : ''
+}
+
+async function loadFavorites() {
+  try {
+    const data = await api.listMyFavoriteTierLists({ q: query.value, sort: sort.value })
+    favorites.value = data.tierLists || []
+  } catch (e) {
+    toast.error('로그인이 필요해요.')
+    router.push('/login?redirect=/favorites')
+  }
+}
+
+function openTierList(tierList) {
+  router.push(`/editor/${tierList.gameId}/${tierList.id}`)
+}
+
+onMounted(loadFavorites)
+</script>
+
+<template>
+  <section class="wrap">
+    <div class="head">
+      <div>
+        <h2 class="title">내 즐겨찾기</h2>
+        <div class="desc">마음에 드는 티어표를 모아보고, 원하는 기준으로 정렬할 수 있어요.</div>
+      </div>
+      <div class="toolbar">
+        <input v-model="query" class="input" placeholder="제목, 게임, 작성자 검색" @keydown.enter.prevent="loadFavorites" />
+        <select v-model="sort" class="select" @change="loadFavorites">
+          <option value="favorited">즐겨찾기한 순</option>
+          <option value="updated">최신 업데이트순</option>
+          <option value="favorites">인기순</option>
+        </select>
+        <button class="btn" @click="loadFavorites">검색</button>
+      </div>
+    </div>
+
+    <div v-if="favorites.length === 0" class="empty">즐겨찾기한 티어표가 없어요.</div>
+    <div v-else class="list">
+      <article v-for="tierList in favorites" :key="tierList.id" class="row">
+        <button class="row__body" @click="openTierList(tierList)">
+          <div class="row__thumbWrap">
+            <img v-if="tierListThumbnailUrl(tierList)" class="row__thumb" :src="tierListThumbnailUrl(tierList)" :alt="tierList.title" />
+            <div v-else class="row__thumbPlaceholder"></div>
+          </div>
+          <div class="row__head">
+            <div class="row__title">{{ tierList.title }}</div>
+            <div class="row__author">
+              <img v-if="avatarSrcOf(tierList)" class="row__avatar" :src="avatarSrcOf(tierList)" :alt="displayNameOf(tierList)" />
+              <div v-else class="row__avatar row__avatar--fallback">{{ avatarFallbackOf(tierList) }}</div>
+              <span>by {{ displayNameOf(tierList) }}</span>
+            </div>
+          </div>
+        </button>
+        <div class="row__foot">
+          <div class="row__meta">
+            <div>{{ tierList.gameName || tierList.gameId }}</div>
+            <div>{{ sortLabel }}: {{ fmt(sort === 'favorited' ? tierList.favoritedAt : tierList.updatedAt) }}</div>
+          </div>
+          <div class="favoriteStat">★ {{ tierList.favoriteCount || 0 }}</div>
+        </div>
+      </article>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+.wrap {
+  display: grid;
+  gap: 14px;
+}
+.head {
+  display: flex;
+  gap: 14px;
+  justify-content: space-between;
+  align-items: flex-end;
+  flex-wrap: wrap;
+}
+.title {
+  margin: 0;
+  font-size: 28px;
+}
+.desc {
+  margin-top: 6px;
+  opacity: 0.78;
+}
+.toolbar {
+  display: flex;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+.input,
+.select {
+  padding: 10px 12px;
+  border-radius: 12px;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  background: rgba(0, 0, 0, 0.18);
+  color: rgba(255, 255, 255, 0.92);
+}
+.btn {
+  padding: 10px 12px;
+  border-radius: 12px;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  background: rgba(255, 255, 255, 0.06);
+  color: rgba(255, 255, 255, 0.92);
+  font-weight: 800;
+  cursor: pointer;
+}
+.empty {
+  opacity: 0.76;
+}
+.list {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 14px;
+}
+.row {
+  border-radius: 16px;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  background: rgba(255, 255, 255, 0.04);
+  overflow: hidden;
+  display: grid;
+  gap: 10px;
+}
+.row__body {
+  border: 0;
+  background: transparent;
+  color: inherit;
+  padding: 0;
+  text-align: left;
+  cursor: pointer;
+  display: grid;
+  gap: 10px;
+}
+.row__thumbWrap {
+  width: 100%;
+  aspect-ratio: 16 / 9;
+  background: rgba(255, 255, 255, 0.03);
+}
+.row__thumb,
+.row__thumbPlaceholder {
+  width: 100%;
+  height: 100%;
+  display: block;
+}
+.row__thumb {
+  object-fit: cover;
+}
+.row__thumbPlaceholder {
+  background: linear-gradient(135deg, rgba(255,255,255,0.06), rgba(255,255,255,0.02));
+}
+.row__head {
+  padding: 14px 14px 0;
+  display: grid;
+  gap: 10px;
+}
+.row__title {
+  font-weight: 800;
+  font-size: 18px;
+}
+.row__author {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 13px;
+  opacity: 0.86;
+}
+.row__avatar {
+  width: 28px;
+  height: 28px;
+  border-radius: 999px;
+  object-fit: cover;
+  background: rgba(255, 255, 255, 0.08);
+}
+.row__avatar--fallback {
+  display: grid;
+  place-items: center;
+  font-size: 12px;
+  font-weight: 900;
+}
+.row__foot {
+  padding: 0 14px 14px;
+  display: flex;
+  gap: 12px;
+  align-items: center;
+  justify-content: space-between;
+}
+.row__meta {
+  display: grid;
+  gap: 4px;
+  opacity: 0.78;
+  font-size: 13px;
+}
+.favoriteStat {
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  background: rgba(255, 255, 255, 0.05);
+  color: rgba(255, 255, 255, 0.92);
+  border-radius: 999px;
+  padding: 7px 10px;
+  font-weight: 800;
+}
+@media (max-width: 1100px) {
+  .list {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+@media (max-width: 720px) {
+  .list {
+    grid-template-columns: 1fr;
+  }
+  .toolbar {
+    width: 100%;
+  }
+  .input,
+  .select,
+  .btn {
+    width: 100%;
+  }
+}
+</style>
--- a/frontend/src/views/GameHubView.vue
+++ b/frontend/src/views/GameHubView.vue
@@ -4,18 +4,17 @@ import { useRoute, useRouter } from 'vue-router'
 import { api } from '../lib/api'
 import { toApiUrl } from '../lib/runtime'
 import { useAuthStore } from '../stores/auth'
-import { useToast } from '../composables/useToast'

 const route = useRoute()
 const router = useRouter()
 const auth = useAuthStore()
-const toast = useToast()

 const gameId = computed(() => route.params.gameId)

 const gameName = ref('')
 const tierLists = ref([])
 const error = ref('')
+const query = ref('')

 function fmt(ts) {
  return new Date(ts).toLocaleString(undefined, {
@@ -44,14 +43,21 @@ function tierListThumbnailUrl(tierList) {
 }

 onMounted(async () => {
+  await loadTierLists()
+})
+
+async function loadTierLists() {
  try {
-    const [gameRes, listRes] = await Promise.all([api.getGame(gameId.value), api.listPublicTierLists(gameId.value)])
+    const [gameRes, listRes] = await Promise.all([
+      api.getGame(gameId.value),
+      api.searchPublicTierLists(gameId.value, query.value),
+    ])
    gameName.value = gameRes.game?.name || gameId.value
    tierLists.value = listRes.tierLists || []
  } catch (e) {
    error.value = '게임 정보를 불러오지 못했어요.'
  }
-})
+}

 function createNew() {
  if (!auth.user) {
@@ -65,19 +71,8 @@ function openTierList(id) {
  router.push(`/editor/${gameId.value}/${id}`)
 }

-async function toggleFavorite(tierList) {
-  if (!auth.user) {
-    router.push(`/login?redirect=/games/${gameId.value}`)
-    return
-  }
-
-  try {
-    const data = tierList.isFavorited ? await api.unfavoriteTierList(tierList.id) : await api.favoriteTierList(tierList.id)
-    tierLists.value = tierLists.value.map((entry) => (entry.id === tierList.id ? { ...entry, ...data.tierList } : entry))
-    toast.success(tierList.isFavorited ? '즐겨찾기를 해제했어요.' : '즐겨찾기에 추가했어요.')
-  } catch (e) {
-    toast.error('즐겨찾기 처리에 실패했어요.')
-  }
+function submitSearch() {
+  loadTierLists()
 }
 </script>

@@ -95,7 +90,13 @@ async function toggleFavorite(tierList) {

  <div v-if="error" class="error">{{ error }}</div>
  <section class="panel">
-    <div class="panel__title">공개 티어표</div>
+    <div class="panel__head">
+      <div class="panel__title">공개 티어표</div>
+      <div class="searchBar">
+        <input v-model="query" class="searchBar__input" placeholder="제목 또는 작성자 검색" @keydown.enter.prevent="submitSearch" />
+        <button class="searchBar__button" @click="submitSearch">검색</button>
+      </div>
+    </div>
    <div v-if="tierLists.length === 0" class="empty">아직 공개 티어표가 없어요.</div>
    <div v-else class="list">
      <article v-for="t in tierLists" :key="t.id" class="row">
@@ -115,9 +116,9 @@ async function toggleFavorite(tierList) {
        </button>
        <div class="row__foot">
          <div class="row__meta">{{ fmt(t.updatedAt) }}</div>
-          <button class="favoriteBtn" @click="toggleFavorite(t)">
+          <div class="favoriteStat" :title="t.isFavorited ? '이미 즐겨찾기한 티어표' : '즐겨찾기 수'">
            {{ t.isFavorited ? '★' : '☆' }} {{ t.favoriteCount || 0 }}
-          </button>
+          </div>
        </div>
      </article>
    </div>
@@ -173,8 +174,38 @@ async function toggleFavorite(tierList) {
 }
 .panel__title {
  font-weight: 800;
+}
+.panel__head {
+  display: flex;
+  gap: 12px;
+  align-items: center;
+  justify-content: space-between;
+  flex-wrap: wrap;
  margin-bottom: 10px;
 }
+.searchBar {
+  display: flex;
+  gap: 10px;
+  align-items: center;
+  flex-wrap: wrap;
+}
+.searchBar__input {
+  min-width: 240px;
+  padding: 10px 12px;
+  border-radius: 12px;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  background: rgba(0, 0, 0, 0.18);
+  color: rgba(255, 255, 255, 0.92);
+}
+.searchBar__button {
+  padding: 10px 12px;
+  border-radius: 12px;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  background: rgba(255, 255, 255, 0.06);
+  color: rgba(255, 255, 255, 0.92);
+  font-weight: 800;
+  cursor: pointer;
+}
 .empty {
  opacity: 0.75;
 }
@@ -271,18 +302,14 @@ async function toggleFavorite(tierList) {
  justify-content: space-between;
  margin-top: auto;
 }
-.favoriteBtn {
+.favoriteStat {
  border: 1px solid rgba(255, 255, 255, 0.12);
  background: rgba(255, 255, 255, 0.05);
  color: rgba(255, 255, 255, 0.92);
  border-radius: 999px;
  padding: 7px 10px;
-  cursor: pointer;
  font-weight: 800;
 }
-.favoriteBtn:hover {
-  background: rgba(255, 255, 255, 0.09);
-}
@media (max-width: 1100px) {
  .list {
    grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -292,5 +319,9 @@ async function toggleFavorite(tierList) {
  .list {
    grid-template-columns: 1fr;
  }
+  .searchBar__input {
+    min-width: 0;
+    width: 100%;
+  }
 }
 </style>
--- a/frontend/src/views/TierEditorView.vue
+++ b/frontend/src/views/TierEditorView.vue
@@ -46,6 +46,7 @@ const iconSize = ref(80)
 const isFavoriteBusy = ref(false)
 const favoriteCount = ref(0)
 const isFavorited = ref(false)
+const isRequestingTemplate = ref(false)

 const boardEl = ref(null)
 const exportBoardEl = ref(null)
@@ -84,6 +85,18 @@ const untitledWarning = computed(
    '제목 없이 저장된 티어표는 무분별한 도배 방지를 위해 관리자에 의해 임의 삭제될 수 있어요.'
 )
 const canFavorite = computed(() => !!auth.user && !isNewTierList.value && !canEdit.value)
+const customItems = computed(() =>
+  Object.values(itemsById.value)
+    .filter((item) => item?.origin === 'custom')
+    .sort((a, b) => (a.label || '').localeCompare(b.label || '', 'ko'))
+)
+const hasPlacedItems = computed(() => groups.value.some((group) => (group.itemIds || []).length > 0))
+const canRequestTemplateCreate = computed(
+  () => canEdit.value && !isNewTierList.value && gameId.value === 'freeform' && !hasPlacedItems.value && customItems.value.length > 0
+)
+const canRequestTemplateUpdate = computed(
+  () => canEdit.value && !isNewTierList.value && gameId.value !== 'freeform' && customItems.value.length > 0
+)

 watch(error, (message) => {
  if (!message) return
@@ -115,6 +128,15 @@ function setIconSize(nextSize) {
  iconSize.value = nextSize
 }

+function removeItemFromGroup(groupId, itemId) {
+  if (!canEdit.value || !groupId || !itemId) return
+  const targetGroup = groups.value.find((group) => group.id === groupId)
+  if (!targetGroup) return
+  if (!targetGroup.itemIds.includes(itemId)) return
+  targetGroup.itemIds = targetGroup.itemIds.filter((id) => id !== itemId)
+  pool.value = [itemId, ...pool.value.filter((id) => id !== itemId)]
+}
+
 function setGroupDropEl(groupId, el) {
  if (!el) {
    delete groupDropEls.value[groupId]
@@ -249,6 +271,18 @@ function addCustomImage(file) {
  pool.value = [id, ...pool.value]
 }

+function updateCustomItemLabel(itemId, nextLabel) {
+  const item = itemsById.value[itemId]
+  if (!item || item.origin !== 'custom') return
+  itemsById.value = {
+    ...itemsById.value,
+    [itemId]: {
+      ...item,
+      label: nextLabel.slice(0, 60),
+    },
+  }
+}
+
 function openFile() {
  if (!canEdit.value) return
  fileEl.value?.click()
@@ -390,21 +424,26 @@ function buildPayload(existingId) {
  }
 }

+async function persistTierList({ showModal = false } = {}) {
+  await uploadPendingCustomItems()
+  await uploadPendingThumbnail()
+  const payload = buildPayload(tierListId.value && tierListId.value !== 'new' ? tierListId.value : null)
+  const res = await api.saveTierList(payload)
+  if (tierListId.value === 'new') history.replaceState({}, '', `/editor/${gameId.value}/${res.tierList.id}`)
+  updatedAt.value = Number(res.tierList?.updatedAt || Date.now())
+  authorName.value = res.tierList?.authorName || effectiveAuthorName.value
+  authorAccountName.value = res.tierList?.authorAccountName || authorAccountName.value
+  favoriteCount.value = Number(res.tierList?.favoriteCount || favoriteCount.value || 0)
+  isFavorited.value = !!res.tierList?.isFavorited
+  if (showModal) isSaveModalOpen.value = true
+  return res
+}
+
 async function save() {
  error.value = ''
  isSaving.value = true
  try {
-    await uploadPendingCustomItems()
-    await uploadPendingThumbnail()
-    const payload = buildPayload(tierListId.value && tierListId.value !== 'new' ? tierListId.value : null)
-    const res = await api.saveTierList(payload)
-    if (tierListId.value === 'new') history.replaceState({}, '', `/editor/${gameId.value}/${res.tierList.id}`)
-    updatedAt.value = Number(res.tierList?.updatedAt || Date.now())
-    authorName.value = res.tierList?.authorName || effectiveAuthorName.value
-    authorAccountName.value = res.tierList?.authorAccountName || authorAccountName.value
-    favoriteCount.value = Number(res.tierList?.favoriteCount || favoriteCount.value || 0)
-    isFavorited.value = !!res.tierList?.isFavorited
-    isSaveModalOpen.value = true
+    await persistTierList({ showModal: true })
  } catch (e) {
    error.value = '저장 실패: 로그인 상태인지 확인해주세요.'
  } finally {
@@ -445,6 +484,32 @@ async function toggleFavorite() {
  }
 }

+async function requestTemplate(type) {
+  if (isNewTierList.value) {
+    toast.error('요청 전에 먼저 티어표를 저장해주세요.')
+    return
+  }
+
+  try {
+    isRequestingTemplate.value = true
+    await persistTierList({ showModal: false })
+    await api.requestTierListTemplate(tierListId.value, { type })
+    toast.success(type === 'create' ? '템플릿 등록 요청을 보냈어요.' : '템플릿 업데이트 요청을 보냈어요.')
+  } catch (e) {
+    if (e?.status === 409) {
+      toast.error('이미 처리 대기 중인 같은 요청이 있어요.')
+      return
+    }
+    if (e?.status === 400 && e?.data?.error === 'board_must_be_empty') {
+      toast.error('템플릿 등록 요청은 보드를 비운 상태에서만 보낼 수 있어요.')
+      return
+    }
+    toast.error(type === 'create' ? '템플릿 등록 요청에 실패했어요.' : '템플릿 업데이트 요청에 실패했어요.')
+  } finally {
+    isRequestingTemplate.value = false
+  }
+}
+
 onMounted(() => {
  ;(async () => {
    await auth.refresh()
@@ -560,6 +625,22 @@ onUnmounted(() => {
        <button v-if="canFavorite" class="btn btn--ghost" :disabled="isFavoriteBusy" @click="toggleFavorite">
          {{ isFavorited ? '★ 즐겨찾기' : '☆ 즐겨찾기' }} {{ favoriteCount }}
        </button>
+        <button
+          v-if="canRequestTemplateCreate"
+          class="btn btn--ghost"
+          :disabled="isRequestingTemplate"
+          @click="requestTemplate('create')"
+        >
+          {{ isRequestingTemplate ? '요청중...' : '템플릿 등록 요청' }}
+        </button>
+        <button
+          v-if="canRequestTemplateUpdate"
+          class="btn btn--ghost"
+          :disabled="isRequestingTemplate"
+          @click="requestTemplate('update')"
+        >
+          {{ isRequestingTemplate ? '요청중...' : '템플릿 업데이트 요청' }}
+        </button>
        <label class="toggle" :class="{ 'toggle--disabled': !canEdit }">
        <input v-model="isPublic" type="checkbox" :disabled="!canEdit" />
          <span>{{ isPublic ? '공개 ON' : '공개 OFF' }}</span>
@@ -624,6 +705,16 @@ onUnmounted(() => {
            <div v-if="!isExporting" class="row__empty" v-show="g.itemIds.length === 0">여기로 드래그해서 배치</div>
            <div v-for="id in g.itemIds" :key="id" class="cell" :data-item-id="id">
              <img :src="resolveItemSrc(itemsById[id])" class="thumb" :alt="itemsById[id]?.label || id" />
+              <button
+                v-if="canEdit && !isExporting"
+                class="cellRemoveBtn"
+                type="button"
+                title="아이템 빼내기"
+                @pointerdown.stop
+                @click.stop="removeItemFromGroup(g.id, id)"
+              >
+                ×
+              </button>
            </div>
          </div>
        </div>
@@ -646,6 +737,24 @@ onUnmounted(() => {
          <div class="poolItem__label">{{ itemsById[id]?.label || id }}</div>
        </div>
      </div>
+      <div v-if="canEdit && customItems.length" class="customItemEditor">
+        <div class="customItemEditor__title">추가한 커스텀 아이템 이름 정리</div>
+        <div class="customItemEditor__desc">
+          템플릿 요청 전에 이름을 정리해두면 관리자가 그대로 기본 템플릿으로 반영할 수 있어요.
+        </div>
+        <div class="customItemEditor__list">
+          <label v-for="item in customItems" :key="item.id" class="customItemEditor__row">
+            <img class="customItemEditor__thumb" :src="resolveItemSrc(item)" :alt="item.label" />
+            <input
+              class="customItemEditor__input"
+              :value="item.label"
+              maxlength="60"
+              placeholder="아이템 이름"
+              @input="updateCustomItemLabel(item.id, $event.target.value)"
+            />
+          </label>
+        </div>
+      </div>
      <div
        v-if="canEdit"
        class="dropzone"
@@ -1078,6 +1187,29 @@ onUnmounted(() => {
 .cell {
  display: inline-flex;
  flex: 0 0 auto;
+  position: relative;
+}
+.cellRemoveBtn {
+  position: absolute;
+  top: -6px;
+  right: -6px;
+  width: 24px;
+  height: 24px;
+  display: grid;
+  place-items: center;
+  border-radius: 999px;
+  border: 1px solid rgba(239, 68, 68, 0.32);
+  background: rgba(11, 18, 32, 0.92);
+  color: rgba(255, 255, 255, 0.92);
+  font-size: 16px;
+  line-height: 1;
+  font-weight: 900;
+  cursor: pointer;
+  z-index: 2;
+  box-shadow: 0 8px 18px rgba(0, 0, 0, 0.24);
+}
+.cellRemoveBtn:hover {
+  background: rgba(239, 68, 68, 0.9);
 }
 .thumb {
  width: var(--thumb-size, 80px);
@@ -1102,6 +1234,51 @@ onUnmounted(() => {
  font-size: 13px;
  margin-bottom: 10px;
 }
+.customItemEditor {
+  margin-top: 12px;
+  padding: 12px;
+  border-radius: 16px;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  background: rgba(255, 255, 255, 0.03);
+}
+.customItemEditor__title {
+  font-weight: 900;
+}
+.customItemEditor__desc {
+  margin-top: 6px;
+  font-size: 12px;
+  line-height: 1.5;
+  opacity: 0.72;
+}
+.customItemEditor__list {
+  margin-top: 12px;
+  display: grid;
+  gap: 10px;
+}
+.customItemEditor__row {
+  display: grid;
+  grid-template-columns: 44px minmax(0, 1fr);
+  gap: 10px;
+  align-items: center;
+}
+.customItemEditor__thumb {
+  width: 44px;
+  height: 44px;
+  border-radius: 10px;
+  object-fit: cover;
+  border: 1px solid rgba(255, 255, 255, 0.14);
+}
+.customItemEditor__input {
+  width: 100%;
+  min-width: 0;
+  padding: 9px 10px;
+  border-radius: 12px;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  background: rgba(0, 0, 0, 0.18);
+  color: rgba(255, 255, 255, 0.92);
+  outline: none;
+  box-sizing: border-box;
+}
 .dropzone {
  margin-top: 12px;
  padding: 14px;
Author	SHA1	Message	Date
zenn	3b314381a0	릴리스: v0.1.47 템플릿 요청과 관리자 승인 흐름 추가	2026-03-27 11:10:45 +09:00
zenn	e0eeaa01cd	릴리스: v0.1.46 에디터 아이템 제거와 회원 정보 보강	2026-03-27 10:54:31 +09:00
zenn	282e89b738	릴리스: v0.1.45 토스트와 즐겨찾기 상호작용 보정	2026-03-27 10:46:29 +09:00
zenn	7de5e96c4c	릴리스: v0.1.44 공개 목록 검색과 즐겨찾기 페이지 추가	2026-03-27 10:35:16 +09:00