Merge remote-tracking branch 'origin/main' into feature/206

backend/app/controllers/posts_controller.rb

@@ -75,7 +75,7 @@ class PostsController < ApplicationController
         else
           "posts.#{ order[0] }"
         end
-    posts = q.order(Arel.sql("#{ sort_sql } #{ order[1] }, posts.id #{ order[1] }"))
+    posts = q.order(Arel.sql("#{ sort_sql } #{ order[1] }, id #{ order[1] }"))
              .limit(limit)
              .offset(offset)
              .to_a
@@ -100,16 +100,23 @@ class PostsController < ApplicationController
                          .first
     return head :not_found unless post
 
-    render json: PostRepr.base(post, current_user)
+    viewed = current_user&.viewed?(post) || false
+
+    render json: PostRepr.base(post).merge(viewed:)
   end
 
   def show
     post = Post.includes(tags: { tag_name: :wiki_page }).find_by(id: params[:id])
     return head :not_found unless post
 
-    render json: PostRepr.base(post, current_user)
+    viewed = current_user&.viewed?(post) || false
-                         .merge(tags: build_tag_tree_for(post.tags),
+
-                                related: post.related(limit: 20))
+    json = post.as_json
+    json['tags'] = build_tag_tree_for(post.tags)
+    json['related'] = post.related(limit: 20)
+    json['viewed'] = viewed
+
+    render json:
   end
 
   def create
@@ -185,7 +192,6 @@ class PostsController < ApplicationController
 
   def changes
     id = params[:id].presence
-    tag_id = params[:tag].presence
     page = (params[:page].presence || 1).to_i
     limit = (params[:limit].presence || 20).to_i
 
@@ -196,7 +202,6 @@ class PostsController < ApplicationController
 
     pts = PostTag.with_discarded
     pts = pts.where(post_id: id) if id.present?
-    pts = pts.where(tag_id:) if tag_id.present?
     pts = pts.includes(:post, :created_user, :deleted_user,
                        tag: { tag_name: :wiki_page })
 
@@ -240,40 +245,18 @@ class PostsController < ApplicationController
   end
 
   def filter_posts_by_tags tag_names, match_type
-    literals = tag_names.map do |raw_name|
+    tag_names = TagName.canonicalise(tag_names)
-      { name: TagName.canonicalise(raw_name.sub(/\Anot:/i, '')).first,
-        negative: raw_name.downcase.start_with?('not:') }
-    end
 
-    return Post.all if literals.empty?
+    posts = Post.joins(tags: :tag_name)
 
     if match_type == 'any'
-      literals.reduce(Post.none) do |posts, literal|
+      posts.where(tag_names: { name: tag_names }).distinct
-        posts.or(tag_literal_relation(literal[:name], negative: literal[:negative]))
-      end
     else
-      literals.reduce(Post.all) do |posts, literal|
+      posts.where(tag_names: { name: tag_names })
-        ids = tagged_post_ids_for(literal[:name])
+           .group('posts.id')
-        if literal[:negative]
+           .having('COUNT(DISTINCT tag_names.id) = ?', tag_names.uniq.size)
-          posts.where.not(id: ids)
-        else
-          posts.where(id: ids)
     end
   end
-    end
-  end
-
-  def tag_literal_relation name, negative:
-    ids = tagged_post_ids_for(name)
-    if negative
-      Post.where.not(id: ids)
-    else
-      Post.where(id: ids)
-    end
-  end
-
-  def tagged_post_ids_for(name) =
-      Post.joins(tags: :tag_name).where(tag_names: { name: }).select(:id)
 
   def sync_post_tags! post, desired_tags
     desired_tags.each do |t|

backend/app/controllers/tags_controller.rb

@@ -2,84 +2,30 @@ class TagsController < ApplicationController
   def index
     post_id = params[:post]
 
-    name = params[:name].to_s.strip.presence
+    tags =
-    category = params[:category].to_s.strip.presence
-    post_count_between = (params[:post_count_gte].presence || -1).to_i,
-                         (params[:post_count_lte].presence || -1).to_i
-    post_count_between[0] = nil if post_count_between[0] < 0
-    post_count_between[1] = nil if post_count_between[1] < 0
-    created_between = params[:created_from].presence, params[:created_to].presence
-    updated_between = params[:updated_from].presence, params[:updated_to].presence
-
-    order = params[:order].to_s.split(':', 2).map(&:strip)
-    unless order[0].in?(['name', 'category', 'post_count', 'created_at', 'updated_at'])
-      order[0] = 'post_count'
-    end
-    unless order[1].in?(['asc', 'desc'])
-      order[1] = order[0].in?(['name', 'category']) ? 'asc' : 'desc'
-    end
-
-    page = (params[:page].presence || 1).to_i
-    limit = (params[:limit].presence || 20).to_i
-
-    page = 1 if page < 1
-    limit = 1 if limit < 1
-
-    offset = (page - 1) * limit
-
-    q =
         if post_id.present?
           Tag.joins(:posts, :tag_name)
         else
           Tag.joins(:tag_name)
         end
         .includes(:tag_name, tag_name: :wiki_page)
-    q = q.where(posts: { id: post_id }) if post_id.present?
+    if post_id.present?
-
+      tags = tags.where(posts: { id: post_id })
-    if name
-      q = q.where('tag_names.name LIKE ?', "%#{ ActiveRecord::Base.sanitize_sql_like(name) }%")
     end
-    q = q.where(category: category) if category
-    q = q.where('tags.post_count >= ?', post_count_between[0]) if post_count_between[0]
-    q = q.where('tags.post_count <= ?', post_count_between[1]) if post_count_between[1]
-    q = q.where('tags.created_at >= ?', created_between[0]) if created_between[0]
-    q = q.where('tags.created_at <= ?', created_between[1]) if created_between[1]
-    q = q.where('tags.updated_at >= ?', updated_between[0]) if updated_between[0]
-    q = q.where('tags.updated_at <= ?', updated_between[1]) if updated_between[1]
 
-    sort_sql =
+    render json: TagRepr.base(tags)
-        case order[0]
-        when 'name'
-          'tag_names.name'
-        when 'category'
-          'CASE tags.category ' +
-          "WHEN 'deerjikist' THEN 0 " +
-          "WHEN 'meme' THEN 1 " +
-          "WHEN 'character' THEN 2 " +
-          "WHEN 'general' THEN 3 " +
-          "WHEN 'material' THEN 4 " +
-          "WHEN 'meta' THEN 5 " +
-          "WHEN 'nico' THEN 6 END"
-        else
-          "tags.#{ order[0] }"
-        end
-    tags = q.order(Arel.sql("#{ sort_sql } #{ order[1] }, tags.id #{ order[1] }"))
-            .limit(limit)
-            .offset(offset)
-            .to_a
-
-    render json: { tags: TagRepr.base(tags), count: q.size }
   end
 
   def autocomplete
-    q = params[:q].to_s.strip.sub(/\Anot:/i, '')
+    q = params[:q].to_s.strip
+    return render json: [] if q.blank?
 
     with_nico = bool?(:nico, default: true)
     present_only = bool?(:present, default: true)
 
     alias_rows =
         TagName
-        .where('name LIKE ?', "#{ ActiveRecord::Base.sanitize_sql_like(q) }%")
+        .where('name LIKE ?', "#{ q }%")
         .where.not(canonical_id: nil)
         .pluck(:canonical_id, :name)
 
@@ -99,8 +45,7 @@ class TagsController < ApplicationController
         base
         .where(((with_nico ? '(tags.category = ? AND tag_names.name LIKE ?) OR ' : '') +
                 'tag_names.name LIKE ?'),
-               *(with_nico ? ['nico', "nico:#{ ActiveRecord::Base.sanitise_sql_like(q) }%"] : []),
+               *(with_nico ? ['nico', "nico:#{ q }%"] : []), "#{ q }%")
-               "#{ ActiveRecord::Base.sanitise_sql_like(q) }%")
 
     tags =
         if canonical_ids.present?

backend/app/controllers/theatres_controller.rb

@@ -1,52 +0,0 @@
-class TheatresController < ApplicationController
-  def show
-    theatre = Theatre.find_by(id: params[:id])
-    return head :not_found unless theatre
-
-    render json: TheatreRepr.base(theatre)
-  end
-
-  def watching
-    return head :unauthorized unless current_user
-
-    theatre = Theatre.find_by(id: params[:id])
-    return head :not_found unless theatre
-
-    host_flg = false
-    post_id = nil
-    post_started_at = nil
-
-    theatre.with_lock do
-      TheatreWatchingUser.find_or_initialize_by(theatre:, user: current_user).tap {
-        _1.expires_at = 30.seconds.from_now
-      }.save!
-
-      if (!(theatre.host_user_id?) ||
-          !(theatre.watching_users.exists?(id: theatre.host_user_id)))
-        theatre.update!(host_user_id: current_user.id)
-      end
-
-      host_flg = theatre.host_user_id == current_user.id
-      post_id = theatre.current_post_id
-      post_started_at = theatre.current_post_started_at
-    end
-
-    render json: { host_flg:, post_id:, post_started_at: }
-  end
-
-  def next_post
-    return head :unauthorized unless current_user
-
-    theatre = Theatre.find_by(id: params[:id])
-    return head :not_found unless theatre
-    return head :forbidden if theatre.host_user != current_user
-
-    post = Post.where("url LIKE '%nicovideo.jp%'")
-           .or(Post.where("url LIKE '%youtube.com%'"))
-           .order('RAND()')
-           .first
-    theatre.update!(current_post: post, current_post_started_at: Time.current)
-
-    head :no_content
-  end
-end

backend/app/controllers/wiki_pages_controller.rb

@@ -90,7 +90,7 @@ class WikiPagesController < ApplicationController
 
     return head :unprocessable_entity if name.blank? || body.blank?
 
-    tag_name = TagName.find_undiscard_or_create_by!(name:)
+    tag_name = TagName.find_or_create_by!(name:)
     page = WikiPage.new(tag_name:, created_user: current_user, updated_user: current_user)
     if page.save
       message = params[:message].presence

backend/app/models/my_discard.rb

@@ -1,20 +0,0 @@
-module MyDiscard
-  extend ActiveSupport::Concern
-
-  included { include Discard::Model }
-
-  class_methods do
-    def find_undiscard_or_create_by! attrs, &block
-      record = with_discarded.find_by(attrs)
-
-      if record&.discarded?
-        record.undiscard!
-        record.update_columns(created_at: record.reload.updated_at)
-      end
-
-      record or create!(attrs, &block)
-    rescue ActiveRecord::RecordNotUnique
-      retry
-    end
-  end
-end

backend/app/models/tag.rb

@@ -1,12 +1,8 @@
 class Tag < ApplicationRecord
-  include MyDiscard
-
   class NicoTagNormalisationError < ArgumentError
     ;
   end
 
-  default_scope -> { kept }
-
   has_many :post_tags, inverse_of: :tag
   has_many :active_post_tags, -> { kept }, class_name: 'PostTag', inverse_of: :tag
   has_many :post_tags_with_discarded, -> { with_discarded }, class_name: 'PostTag'
@@ -134,10 +130,10 @@ class Tag < ApplicationRecord
   end
 
   def self.find_or_create_by_tag_name! name, category:
-    tn = TagName.find_undiscard_or_create_by!(name: name.to_s.strip)
+    tn = TagName.find_or_create_by!(name: name.to_s.strip)
     tn = tn.canonical if tn.canonical_id?
 
-    Tag.find_undiscard_or_create_by!(tag_name_id: tn.id) do |t|
+    Tag.find_or_create_by!(tag_name_id: tn.id) do |t|
       t.category = category
     end
   rescue ActiveRecord::RecordNotUnique
@@ -148,35 +144,27 @@ class Tag < ApplicationRecord
     target_tag => Tag
 
     Tag.transaction do
-      Array(source_tags).compact.uniq.each do |source_tag|
+      Array(source_tags).compact.uniq.each do |st|
-        source_tag => Tag
+        st => Tag
 
-        next if source_tag == target_tag
+        next if st == target_tag
 
-        source_tag.post_tags.kept.find_each do |source_pt|
+        st.post_tags.find_each do |pt|
-          post_id = source_pt.post_id
+          if PostTag.kept.exists?(post_id: pt.post_id, tag_id: target_tag.id)
-          source_pt.discard_by!(nil)
+            pt.discard_by!(nil)
-          unless PostTag.kept.exists?(post_id:, tag: target_tag)
+            # discard 後の update! は禁止なので DB を直に更新
-            PostTag.create!(post_id:, tag: target_tag)
+            pt.update_columns(tag_id: target_tag.id, updated_at: Time.current)
-          end
-        end
-
-        source_tag_name = source_tag.tag_name
-
-        if source_tag_name.wiki_page.present?
-          raise ActiveRecord::RecordInvalid.new(source_tag_name)
-        end
-
-        source_tag.discard!
-
-        if source_tag.nico?
-          source_tag_name.discard!
           else
-          source_tag_name.update_columns(canonical_id: target_tag.tag_name_id,
+            pt.update!(tag: target_tag)
-                                         updated_at: Time.current)
           end
         end
 
+        tag_name = st.tag_name
+        st.destroy!
+        tag_name.reload
+        tag_name.update!(canonical: target_tag.tag_name)
+      end
+
       # 投稿件数を再集計
       target_tag.update_columns(post_count: PostTag.kept.where(tag: target_tag).count)
     end

backend/app/models/tag_name.rb

@@ -1,8 +1,4 @@
 class TagName < ApplicationRecord
-  include MyDiscard
-
-  default_scope -> { kept }
-
   has_one :tag
   has_one :wiki_page
 
@@ -14,7 +10,6 @@ class TagName < ApplicationRecord
   validate :canonical_must_be_canonical
   validate :alias_name_must_not_have_prefix
   validate :canonical_must_not_be_present_with_tag_or_wiki_page
-  validate :name_must_be_sanitised
 
   def self.canonicalise names
     names = Array(names).map { |n| n.to_s.strip }.reject(&:blank?)
@@ -44,10 +39,4 @@ class TagName < ApplicationRecord
       errors.add :canonical, 'タグもしくは Wiki の参照がある名前はエーリアスになれません．'
     end
   end
-
-  def name_must_be_sanitised
-    if name? && name != TagNameSanitisationRule.sanitise(name)
-      errors.add :name, '名前に使用できない文字が含まれてゐます．'
-    end
-  end
 end

backend/app/models/tag_name_sanitisation_rule.rb

@@ -1,58 +0,0 @@
-class TagNameSanitisationRule < ApplicationRecord
-  include Discard::Model
-
-  self.primary_key = :priority
-
-  default_scope -> { kept }
-
-  validates :source_pattern, presence: true, uniqueness: true
-
-  validate :source_pattern_must_be_regexp
-
-  class << self
-    def sanitise(name) =
-        rules.reduce(name.dup) { |name, (pattern, replacement)| name.gsub(pattern, replacement) }
-
-    def apply!
-      TagName.find_each do |tn|
-        name = sanitise(tn.name)
-        next if name == tn.name
-
-        TagName.transaction do
-          existing_tn = TagName.find_by(name:)
-          if existing_tn
-            existing_tn = existing_tn.canonical || existing_tn
-            next if existing_tn.id == tn.id
-
-            existing_tag = Tag.find_by(tag_name_id: existing_tn.id)
-            source_tag = Tag.find_by(tag_name_id: tn.id)
-
-            if existing_tag
-              Tag.merge_tags!(existing_tag, source_tag) if tn.tag
-            elsif source_tag
-              source_tag.update_columns(tag_name_id: existing_tn.id, updated_at: Time.current)
-            end
-            tn.discard!
-
-            next
-          end
-
-          # TagName 側の自動サニタイズを回避
-          tn.update_columns(name:, updated_at: Time.current)
-        end
-      end
-    end
-
-    private
-
-    def rules = kept.order(:priority).map { |r| [Regexp.new(r.source_pattern), r.replacement] }
-  end
-
-  private
-
-  def source_pattern_must_be_regexp
-    Regexp.new(source_pattern)
-  rescue RegexpError
-    errors.add :source_pattern, '変な正規表現だね〜（笑）'
-  end
-end

backend/app/models/theatre.rb

@@ -1,13 +0,0 @@
-class Theatre < ApplicationRecord
-  include MyDiscard
-
-  has_many :comments, class_name: 'TheatreComment'
-  has_many :theatre_watching_users, dependent: :delete_all
-  has_many :active_theatre_watching_users, -> { active },
-           class_name: 'TheatreWatchingUser', inverse_of: :theatre
-  has_many :watching_users, through: :active_theatre_watching_users, source: :user
-
-  belongs_to :host_user, class_name: 'User', optional: true
-  belongs_to :current_post, class_name: 'Post', optional: true
-  belongs_to :created_by_user, class_name: 'User'
-end

backend/app/models/theatre_comment.rb

@@ -1,8 +0,0 @@
-class TheatreComment < ApplicationRecord
-  include MyDiscard
-
-  self.primary_key = :theatre_id, :no
-
-  belongs_to :theatre
-end
-

backend/app/models/theatre_watching_user.rb

@@ -1,13 +0,0 @@
-class TheatreWatchingUser < ApplicationRecord
-  self.primary_key = :theatre_id, :user_id
-
-  belongs_to :theatre
-  belongs_to :user
-
-  scope :active, -> { where('expires_at >= ?', Time.current) }
-  scope :expired, -> { where('expires_at < ?', Time.current) }
-
-  def active? = expires_at >= Time.current
-
-  def refresh! = update!(expires_at: 30.seconds.from_now)
-end

backend/app/models/wiki_page.rb

@@ -2,10 +2,6 @@ require 'set'
 
 
 class WikiPage < ApplicationRecord
-  include MyDiscard
-
-  default_scope -> { kept }
-
   has_many :wiki_revisions, dependent: :destroy
   belongs_to :created_user, class_name: 'User'
   belongs_to :updated_user, class_name: 'User'

backend/app/representations/post_repr.rb

@@ -2,19 +2,15 @@
 
 
 module PostRepr
-  BASE = { include: { tags: TagRepr::BASE, uploaded_user: UserRepr::BASE } }.freeze
+  BASE = { include: { tags: TagRepr::BASE } }.freeze
 
   module_function
 
-  def base post, current_user = nil
+  def base post
-    json = post.as_json(BASE)
+    post.as_json(BASE)
-    return json.merge(viewed: false) unless current_user
-
-    viewed = current_user.viewed?(post)
-    json.merge(viewed:)
   end
 
-  def many posts, current_user = nil
+  def many posts
-    posts.map { |p| base(p, current_user) }
+    posts.map { |p| base(p) }
   end
 end

backend/app/representations/tag_repr.rb

@@ -2,8 +2,7 @@
 
 
 module TagRepr
-  BASE = { only: [:id, :category, :post_count, :created_at, :updated_at],
+  BASE = { only: [:id, :category, :post_count], methods: [:name, :has_wiki] }.freeze
-           methods: [:name, :has_wiki] }.freeze
 
   module_function
 

backend/app/representations/theatre_repr.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-
-module TheatreRepr
-  BASE = { only: [:id, :name, :opens_at, :closes_at, :created_at, :updated_at],
-           include: { created_by_user: { only: [:id, :name] } } }.freeze
-
-  module_function
-
-  def base theatre
-    theatre.as_json(BASE)
-  end
-
-  def many theatre
-    theatre.map { |t| base(t) }
-  end
-end

backend/app/representations/user_repr.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-
-module UserRepr
-  BASE = { only: [:id, :name] }.freeze
-
-  module_function
-
-  def base user
-    user.as_json(BASE)
-  end
-
-  def many users
-    users.map { |u| base(u) }
-  end
-end

backend/config/routes.rb

@@ -72,11 +72,4 @@ Rails.application.routes.draw do
       end
     end
   end
-
-  resources :theatres, only: [:show] do
-    member do
-      put :watching
-      patch :next_post
-    end
-  end
 end

backend/db/migrate/20260309123200_create_tag_name_sanitisation_rules.rb

@@ -1,31 +0,0 @@
-class CreateTagNameSanitisationRules < ActiveRecord::Migration[8.0]
-  def up
-    create_table :tag_name_sanitisation_rules, id: :integer, primary_key: :priority do |t|
-      t.string :source_pattern, null: false
-      t.string :replacement, null: false
-      t.timestamps
-      t.datetime :discarded_at
-      t.index :source_pattern, unique: true
-      t.index :discarded_at
-    end
-
-    now = ActiveRecord::Base.connection.quote(Time.current)
-    execute <<~SQL
-      INSERT INTO
-        tag_name_sanitisation_rules(priority, source_pattern, replacement, created_at, updated_at)
-      VALUES
-        (10, '\\\\*',           '_',         #{ now }, #{ now })
-      , (20, '\\\\?',           '_',         #{ now }, #{ now })
-      , (25, '\\\\/',           '_',         #{ now }, #{ now })
-      , (30, '_+',              '_',         #{ now }, #{ now })
-      , (40, '_$',              '',          #{ now }, #{ now })
-      , (45, '^([^:]+\\\\:)?_', '\\\\1',     #{ now }, #{ now })
-      , (50, '^([^:]+\\\\:)?$', '\\\\1null', #{ now }, #{ now })
-      ;
-    SQL
-  end
-
-  def down
-    drop_table :tag_name_sanitisation_rules
-  end
-end

backend/db/migrate/20260311123100_add_discarded_at_to_tags.rb

@@ -1,6 +0,0 @@
-class AddDiscardedAtToTags < ActiveRecord::Migration[8.0]
-  def change
-    add_column :tags, :discarded_at, :datetime
-    add_index :tags, :discarded_at
-  end
-end

backend/db/migrate/20260311232100_add_discarded_at_to_tag_names.rb

@@ -1,6 +0,0 @@
-class AddDiscardedAtToTagNames < ActiveRecord::Migration[8.0]
-  def change
-    add_column :tag_names, :discarded_at, :datetime
-    add_index :tag_names, :discarded_at
-  end
-end

backend/db/migrate/20260311232300_add_discarded_at_to_wiki_pages.rb

@@ -1,6 +0,0 @@
-class AddDiscardedAtToWikiPages < ActiveRecord::Migration[8.0]
-  def change
-    add_column :wiki_pages, :discarded_at, :datetime
-    add_index :wiki_pages, :discarded_at
-  end
-end

backend/db/migrate/20260316082500_create_theatres.rb

@@ -1,17 +0,0 @@
-class CreateTheatres < ActiveRecord::Migration[8.0]
-  def change
-    create_table :theatres do |t|
-      t.string :name
-      t.datetime :opens_at, null: false, index: true
-      t.datetime :closes_at, index: true
-      t.integer :kind, null: false, index: true
-      t.references :current_post, foreign_key: { to_table: :posts }, index: true
-      t.datetime :current_post_started_at
-      t.integer :next_comment_no, null: false, default: 1
-      t.references :host_user, foreign_key: { to_table: :users }
-      t.references :created_by_user, null: false, foreign_key: { to_table: :users }, index: true
-      t.timestamps
-      t.datetime :discarded_at, index: true
-    end
-  end
-end

backend/db/migrate/20260316083500_create_theatre_comments.rb

@@ -1,12 +0,0 @@
-class CreateTheatreComments < ActiveRecord::Migration[8.0]
-  def change
-    create_table :theatre_comments, primary_key: [:theatre_id, :no] do |t|
-      t.references :theatre, null: false, foreign_key: { to_table: :theatres }
-      t.integer :no, null: false
-      t.references :user, foreign_key: { to_table: :users }
-      t.text :content, null: false
-      t.timestamps
-      t.datetime :discarded_at, index: true
-    end
-  end
-end

backend/db/migrate/20260317015000_create_theatre_watching_users.rb

@@ -1,12 +0,0 @@
-class CreateTheatreWatchingUsers < ActiveRecord::Migration[8.0]
-  def change
-    create_table :theatre_watching_users, primary_key: [:theatre_id, :user_id] do |t|
-      t.references :theatre, null: false, foreign_key: { to_table: :theatres }
-      t.references :user, null: false, foreign_key: { to_table: :users }, index: true
-      t.datetime :expires_at, null: false, index: true
-      t.timestamps
-
-      t.index [:theatre_id, :expires_at]
-    end
-  end
-end

backend/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.0].define(version: 2026_03_17_015000) do
+ActiveRecord::Schema[8.0].define(version: 2026_03_03_122700) do
   create_table "active_storage_attachments", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.string "name", null: false
     t.string "record_type", null: false
@@ -127,24 +127,12 @@ ActiveRecord::Schema[8.0].define(version: 2026_03_17_015000) do
     t.index ["tag_id"], name: "index_tag_implications_on_tag_id"
   end
 
-  create_table "tag_name_sanitisation_rules", primary_key: "priority", id: :integer, charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    t.string "source_pattern", null: false
-    t.string "replacement", null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.datetime "discarded_at"
-    t.index ["discarded_at"], name: "index_tag_name_sanitisation_rules_on_discarded_at"
-    t.index ["source_pattern"], name: "index_tag_name_sanitisation_rules_on_source_pattern", unique: true
-  end
-
   create_table "tag_names", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.string "name", null: false
     t.bigint "canonical_id"
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
-    t.datetime "discarded_at"
     t.index ["canonical_id"], name: "index_tag_names_on_canonical_id"
-    t.index ["discarded_at"], name: "index_tag_names_on_discarded_at"
     t.index ["name"], name: "index_tag_names_on_name", unique: true
   end
 
@@ -162,58 +150,9 @@ ActiveRecord::Schema[8.0].define(version: 2026_03_17_015000) do
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.integer "post_count", default: 0, null: false
-    t.datetime "discarded_at"
-    t.index ["discarded_at"], name: "index_tags_on_discarded_at"
     t.index ["tag_name_id"], name: "index_tags_on_tag_name_id", unique: true
   end
 
-  create_table "theatre_comments", primary_key: ["theatre_id", "no"], charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    t.bigint "theatre_id", null: false
-    t.integer "no", null: false
-    t.bigint "user_id"
-    t.text "content", null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.datetime "discarded_at"
-    t.index ["discarded_at"], name: "index_theatre_comments_on_discarded_at"
-    t.index ["theatre_id"], name: "index_theatre_comments_on_theatre_id"
-    t.index ["user_id"], name: "index_theatre_comments_on_user_id"
-  end
-
-  create_table "theatre_watching_users", primary_key: ["theatre_id", "user_id"], charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    t.bigint "theatre_id", null: false
-    t.bigint "user_id", null: false
-    t.datetime "expires_at", null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["expires_at"], name: "index_theatre_watching_users_on_expires_at"
-    t.index ["theatre_id", "expires_at"], name: "index_theatre_watching_users_on_theatre_id_and_expires_at"
-    t.index ["theatre_id"], name: "index_theatre_watching_users_on_theatre_id"
-    t.index ["user_id"], name: "index_theatre_watching_users_on_user_id"
-  end
-
-  create_table "theatres", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    t.string "name"
-    t.datetime "opens_at", null: false
-    t.datetime "closes_at"
-    t.integer "kind", null: false
-    t.bigint "current_post_id"
-    t.datetime "current_post_started_at"
-    t.integer "next_comment_no", default: 1, null: false
-    t.bigint "host_user_id"
-    t.bigint "created_by_user_id", null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.datetime "discarded_at"
-    t.index ["closes_at"], name: "index_theatres_on_closes_at"
-    t.index ["created_by_user_id"], name: "index_theatres_on_created_by_user_id"
-    t.index ["current_post_id"], name: "index_theatres_on_current_post_id"
-    t.index ["discarded_at"], name: "index_theatres_on_discarded_at"
-    t.index ["host_user_id"], name: "index_theatres_on_host_user_id"
-    t.index ["kind"], name: "index_theatres_on_kind"
-    t.index ["opens_at"], name: "index_theatres_on_opens_at"
-  end
-
   create_table "user_ips", primary_key: ["user_id", "ip_address_id"], charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "user_id", null: false
     t.bigint "ip_address_id", null: false
@@ -253,9 +192,7 @@ ActiveRecord::Schema[8.0].define(version: 2026_03_17_015000) do
     t.bigint "updated_user_id", null: false
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
-    t.datetime "discarded_at"
     t.index ["created_user_id"], name: "index_wiki_pages_on_created_user_id"
-    t.index ["discarded_at"], name: "index_wiki_pages_on_discarded_at"
     t.index ["tag_name_id"], name: "index_wiki_pages_on_tag_name_id", unique: true
     t.index ["updated_user_id"], name: "index_wiki_pages_on_updated_user_id"
   end
@@ -309,13 +246,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_03_17_015000) do
   add_foreign_key "tag_similarities", "tags"
   add_foreign_key "tag_similarities", "tags", column: "target_tag_id"
   add_foreign_key "tags", "tag_names"
-  add_foreign_key "theatre_comments", "theatres"
-  add_foreign_key "theatre_comments", "users"
-  add_foreign_key "theatre_watching_users", "theatres"
-  add_foreign_key "theatre_watching_users", "users"
-  add_foreign_key "theatres", "posts", column: "current_post_id"
-  add_foreign_key "theatres", "users", column: "created_by_user_id"
-  add_foreign_key "theatres", "users", column: "host_user_id"
   add_foreign_key "user_ips", "ip_addresses"
   add_foreign_key "user_ips", "users"
   add_foreign_key "user_post_views", "posts"

backend/lib/tasks/sync_nico.rake

@@ -108,7 +108,7 @@ namespace :nico do
       desired_non_nico_tag_ids = []
 
       datum['tags'].each do |raw|
-        name = TagNameSanitisationRule.sanitise("nico:#{ raw }")
+        name = "nico:#{ raw }"
         tag = Tag.find_or_create_by_tag_name!(name, category: :nico)
         desired_nico_tag_based_ids << tag.id
 

backend/spec/factories/tags.rb

@@ -1,22 +1,12 @@
 FactoryBot.define do
   factory :tag do
-    transient do
-      name { nil }
-    end
-
     category { :general }
     post_count { 0 }
     association :tag_name
 
-    after(:build) do |tag, evaluator|
-      tag.name = evaluator.name if evaluator.name.present?
-    end
-
     trait :nico do
       category { :nico }
-      transient do
+      tag_name { association(:tag_name, name: "nico:#{ SecureRandom.hex(4) }") }
-        name { "nico:#{ SecureRandom.hex(4) }" }
-      end
     end
   end
 end

backend/spec/models/tag_name_sanitisation_rule_spec.rb

@@ -1,101 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe TagNameSanitisationRule, type: :model do
-  describe '.sanitise' do
-    before do
-      described_class.create!(priority: 10, source_pattern: '_', replacement: '')
-      described_class.create!(priority: 20, source_pattern: 'ABC', replacement: 'abc')
-    end
-
-    it 'applies sanitisation rules sequentially in priority order' do
-      expect(described_class.sanitise('A_B_C')).to eq('abc')
-    end
-
-    it 'does not fail when a rule does not match' do
-      expect { described_class.sanitise('xyz') }.not_to raise_error
-      expect(described_class.sanitise('xyz')).to eq('xyz')
-    end
-  end
-
-  describe 'validations' do
-    it 'is invalid when source_pattern is not a valid regexp' do
-      rule = described_class.new(priority: 10, source_pattern: '[', replacement: '')
-      expect(rule).to be_invalid
-      expect(rule.errors[:source_pattern]).to be_present
-    end
-  end
-
-  describe '.apply!' do
-    before do
-      described_class.create!(priority: 10, source_pattern: '_', replacement: '')
-    end
-
-    context 'when no conflicting tag_name exists' do
-      let!(:tag_name) do
-        TagName.create!(name: 'tmp').tap do |tn|
-          tn.update_columns(name: 'foo_bar', updated_at: Time.current)
-        end
-      end
-
-      it 'renames the tag_name' do
-        described_class.apply!
-        expect(tag_name.reload.name).to eq('foobar')
-      end
-    end
-
-    context 'when a conflicting canonical tag_name exists' do
-      let!(:existing) { TagName.create!(name: 'foobar') }
-      let!(:source) do
-        TagName.create!(name: 'tmp').tap do |tn|
-          tn.update_columns(name: 'foo_bar', updated_at: Time.current)
-        end
-      end
-
-      it 'deletes the source tag_name' do
-        described_class.apply!
-        expect(TagName.exists?(source.id)).to be(false)
-        expect(existing.reload.name).to eq('foobar')
-      end
-    end
-
-    context 'when the source tag_name has a tag and the existing one has no tag' do
-      let!(:existing) { TagName.create!(name: 'foobar') }
-      let!(:source_tag) { create(:tag, name: 'tmp', category: :general) }
-      let!(:source_tag_name_id) { source_tag.tag_name_id }
-
-      before do
-        source_tag.tag_name.update_columns(name: 'foo_bar', updated_at: Time.current)
-      end
-
-      it 'moves the tag to the existing tag_name' do
-        described_class.apply!
-        expected_tag_name_id = existing.canonical_id || existing.id
-        expect(source_tag.reload.tag_name_id).to eq(expected_tag_name_id)
-        expect(TagName.exists?(source_tag_name_id)).to be(false)
-      end
-    end
-
-    context 'when both source and existing tag_names have tags' do
-      let!(:existing_tn) { TagName.create!(name: 'foobar') }
-      let!(:existing_tag) { Tag.create!(tag_name: existing_tn, category: :general) }
-
-      let!(:source_tn) { TagName.create!(name: 'tmp') }
-      let!(:source_tag) { Tag.create!(tag_name: source_tn, category: :general) }
-      let!(:source_tag_name_id) { source_tn.id }
-
-      before do
-        source_tn.update_columns(name: 'foo_bar', updated_at: Time.current)
-      end
-
-      it 'merges the source tag into the existing tag and deletes the source tag_name' do
-        expect(TagName.find_by(name: 'foobar')&.tag&.id).to eq(existing_tag.id)
-        expect(TagName.find_by(name: 'foo_bar')&.tag&.id).to eq(source_tag.id)
-
-        described_class.apply!
-
-        expect(Tag.exists?(source_tag.id)).to be(false)
-        expect(TagName.exists?(source_tag.tag_name_id)).to be(false)
-      end
-    end
-  end
-end

backend/spec/models/tag_spec.rb

@@ -2,31 +2,20 @@ require 'rails_helper'
 
 RSpec.describe Tag, type: :model do
   describe '.merge_tags!' do
-    let!(:target_tag) { create(:tag, category: :general) }
+    let!(:target_tag) { create(:tag) }
-    let!(:source_tag) { create(:tag, category: :general) }
+    let!(:source_tag) { create(:tag) }
-    let!(:source_tag_name) { source_tag.tag_name }
 
-    let!(:post_record) do
+    let!(:post_record) { Post.create!(url: 'https://example.com/posts/1', title: 'test post') }
-      Post.create!(url: 'https://example.com/posts/1', title: 'test post')
-    end
 
     context 'when merging a simple source tag' do
       let!(:source_post_tag) { PostTag.create!(post: post_record, tag: source_tag) }
 
-      it 'discards the source post_tag, creates an active target post_tag, discards the source tag, and aliases the source tag_name' do
+      it 'moves the post_tag, deletes the source tag, and aliases the source tag_name' do
         described_class.merge_tags!(target_tag, [source_tag])
 
-        source_pt = PostTag.with_discarded.find(source_post_tag.id)
+        expect(source_post_tag.reload.tag_id).to eq(target_tag.id)
-        active_target = PostTag.kept.find_by(post_id: post_record.id, tag_id: target_tag.id)
+        expect(Tag.exists?(source_tag.id)).to be(false)
-
+        expect(source_tag.tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
-        expect(source_pt.discarded_at).to be_present
-        expect(source_pt.tag_id).to eq(source_tag.id)
-        expect(active_target).to be_present
-
-        expect(Tag.with_discarded.find(source_tag.id)).to be_discarded
-        expect(TagName.with_discarded.find(source_tag_name.id)).not_to be_discarded
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
-        expect(target_tag.reload.post_count).to eq(1)
       end
     end
 
@@ -34,84 +23,38 @@ RSpec.describe Tag, type: :model do
       let!(:target_post_tag) { PostTag.create!(post: post_record, tag: target_tag) }
       let!(:source_post_tag) { PostTag.create!(post: post_record, tag: source_tag) }
 
-      it 'discards the source post_tag, keeps one active target post_tag, discards the source tag, and aliases the source tag_name' do
+      it 'discards the duplicate source post_tag and keeps one active target post_tag' do
         described_class.merge_tags!(target_tag, [source_tag])
 
-        source_pt = PostTag.with_discarded.find(source_post_tag.id)
         active = PostTag.kept.where(post_id: post_record.id, tag_id: target_tag.id)
+        discarded_source = PostTag.with_discarded.find(source_post_tag.id)
 
-        expect(source_pt.discarded_at).to be_present
-        expect(source_pt.tag_id).to eq(source_tag.id)
         expect(active.count).to eq(1)
-        expect(active.first.id).to eq(target_post_tag.id)
+        expect(discarded_source.discarded_at).to be_present
-
+        expect(Tag.exists?(source_tag.id)).to be(false)
-        expect(Tag.with_discarded.find(source_tag.id)).to be_discarded
+        expect(source_tag.tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
-        expect(TagName.with_discarded.find(source_tag_name.id)).not_to be_discarded
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
-        expect(target_tag.reload.post_count).to eq(1)
       end
     end
 
     context 'when source_tags includes the target itself' do
       let!(:source_post_tag) { PostTag.create!(post: post_record, tag: source_tag) }
 
-      it 'ignores the target in source_tags while still merging the source tag' do
+      it 'ignores the target tag in source_tags' do
         described_class.merge_tags!(target_tag, [source_tag, target_tag])
 
-        source_pt = PostTag.with_discarded.find(source_post_tag.id)
+        expect(Tag.exists?(target_tag.id)).to be(true)
-        active_target = PostTag.kept.find_by(post_id: post_record.id, tag_id: target_tag.id)
+        expect(Tag.exists?(source_tag.id)).to be(false)
-
+        expect(source_post_tag.reload.tag_id).to eq(target_tag.id)
-        expect(Tag.find(target_tag.id)).to be_present
-        expect(Tag.with_discarded.find(source_tag.id)).to be_discarded
-        expect(source_pt.discarded_at).to be_present
-        expect(source_pt.tag_id).to eq(source_tag.id)
-        expect(active_target).to be_present
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
-        expect(target_tag.reload.post_count).to eq(1)
       end
     end
 
-    context 'when the source tag_name is invalid under sanitisation rules' do
+    context 'when aliasing the source tag_name is invalid' do
-      let!(:source_post_tag) { PostTag.create!(post: post_record, tag: source_tag) }
-      let!(:sanitisation_rule) do
-        TagNameSanitisationRule.create!(
-          priority: 99_999,
-          source_pattern: 'INVALIDTOKEN',
-          replacement: ''
-        )
-      end
-
-      before do
-        source_tag_name.update_columns(
-          name: "#{ source_tag_name.name }INVALIDTOKEN",
-          updated_at: Time.current
-        )
-      end
-
-      it 'still merges, but discards the source tag_name instead of aliasing it' do
-        described_class.merge_tags!(target_tag, [source_tag])
-
-        source_pt = PostTag.with_discarded.find(source_post_tag.id)
-        active_target = PostTag.kept.find_by(post_id: post_record.id, tag_id: target_tag.id)
-        discarded_source_tag_name = TagName.with_discarded.find(source_tag_name.id)
-
-        expect(source_pt.discarded_at).to be_present
-        expect(source_pt.tag_id).to eq(source_tag.id)
-        expect(active_target).to be_present
-
-        expect(Tag.with_discarded.find(source_tag.id)).to be_discarded
-        expect(target_tag.reload.post_count).to eq(1)
-      end
-    end
-
-    context 'when the source tag_name has a wiki_page' do
       let!(:source_post_tag) { PostTag.create!(post: post_record, tag: source_tag) }
       let!(:wiki_page) do
         WikiPage.create!(
-          tag_name: source_tag_name,
+            tag_name: source_tag.tag_name,
             created_user: create_admin_user!,
-          updated_user: create_admin_user!
+            updated_user: create_admin_user!)
-        )
       end
 
       it 'rolls back the transaction' do
@@ -119,30 +62,9 @@ RSpec.describe Tag, type: :model do
           described_class.merge_tags!(target_tag, [source_tag])
         }.to raise_error(ActiveRecord::RecordInvalid)
 
-        expect(Tag.with_discarded.find(source_tag.id)).not_to be_discarded
+        expect(Tag.exists?(source_tag.id)).to be(true)
-        expect(TagName.with_discarded.find(source_tag_name.id)).not_to be_discarded
+        expect(source_post_tag.reload.tag_id).to eq(source_tag.id)
-        expect(PostTag.kept.find(source_post_tag.id).tag_id).to eq(source_tag.id)
+        expect(source_tag.tag_name.reload.canonical_id).to be_nil
-        expect(PostTag.kept.find_by(post_id: post_record.id, tag_id: target_tag.id)).to be_nil
-        expect(source_tag_name.reload.canonical_id).to be_nil
-        expect(target_tag.reload.post_count).to eq(0)
-      end
-    end
-
-    context 'when merging a nico source tag' do
-      let!(:target_tag) { create(:tag, category: :nico, name: 'nico:foo') }
-      let!(:source_tag) { create(:tag, category: :nico, name: 'nico:bar') }
-      let!(:source_tag_name_id) { source_tag.tag_name_id }
-
-      it 'discards the source tag_name instead of aliasing it' do
-        described_class.merge_tags!(target_tag, [source_tag])
-
-        discarded_source_tag = Tag.with_discarded.find(source_tag.id)
-        discarded_source_tag_name = TagName.with_discarded.find(source_tag_name_id)
-
-        expect(discarded_source_tag).to be_discarded
-        expect(discarded_source_tag_name).to be_discarded
-        expect(discarded_source_tag_name.canonical_id).to be_nil
-        expect(target_tag.reload.post_count).to eq(0)
       end
     end
   end

backend/spec/requests/posts_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe 'Posts API', type: :request do
   end
 
   let!(:tag_name) { TagName.create!(name: 'spec_tag') }
-  let!(:tag)      { Tag.create!(tag_name: tag_name, category: :general) }
+  let!(:tag)      { Tag.create!(tag_name: tag_name, category: 'general') }
 
   let!(:post_record) do
     Post.create!(title: 'spec post', url: 'https://example.com/spec').tap do |p|
@@ -28,9 +28,9 @@ RSpec.describe 'Posts API', type: :request do
     let!(:user) { create_member_user! }
 
     let!(:tag_name) { TagName.create!(name: "spec_tag") }
-    let!(:tag) { Tag.create!(tag_name:, category: :general) }
+    let!(:tag) { Tag.create!(tag_name:, category: "general") }
     let!(:tag_name2) { TagName.create!(name: 'unko') }
-    let!(:tag2) { Tag.create!(tag_name: tag_name2, category: :deerjikist) }
+    let!(:tag2) { Tag.create!(tag_name: tag_name2, category: 'deerjikist') }
     let!(:alias_tag_name) { TagName.create!(name: 'manko', canonical: tag_name) }
 
     let!(:hit_post) do
@@ -116,123 +116,6 @@ RSpec.describe 'Posts API', type: :request do
       end
     end
 
-    context 'when tags contain not:' do
-      let!(:foo_tag_name) { TagName.create!(name: 'not_spec_foo') }
-      let!(:foo_tag) { Tag.create!(tag_name: foo_tag_name, category: :general) }
-
-      let!(:bar_tag_name) { TagName.create!(name: 'not_spec_bar') }
-      let!(:bar_tag) { Tag.create!(tag_name: bar_tag_name, category: :general) }
-
-      let!(:baz_tag_name) { TagName.create!(name: 'not_spec_baz') }
-      let!(:baz_tag) { Tag.create!(tag_name: baz_tag_name, category: :general) }
-
-      let!(:foo_alias_tag_name) do
-        TagName.create!(name: 'not_spec_foo_alias', canonical: foo_tag_name)
-      end
-
-      let!(:foo_only_post) do
-        Post.create!(uploaded_user: user, title: 'foo only',
-                     url: 'https://example.com/not-spec-foo').tap do |p|
-          PostTag.create!(post: p, tag: foo_tag)
-        end
-      end
-
-      let!(:bar_only_post) do
-        Post.create!(uploaded_user: user, title: 'bar only',
-                     url: 'https://example.com/not-spec-bar').tap do |p|
-          PostTag.create!(post: p, tag: bar_tag)
-        end
-      end
-
-      let!(:baz_only_post) do
-        Post.create!(uploaded_user: user, title: 'baz only',
-                     url: 'https://example.com/not-spec-baz').tap do |p|
-          PostTag.create!(post: p, tag: baz_tag)
-        end
-      end
-
-      let!(:foo_bar_post) do
-        Post.create!(uploaded_user: user, title: 'foo bar',
-                     url: 'https://example.com/not-spec-foo-bar').tap do |p|
-          PostTag.create!(post: p, tag: foo_tag)
-          PostTag.create!(post: p, tag: bar_tag)
-        end
-      end
-
-      let!(:foo_baz_post) do
-        Post.create!(uploaded_user: user, title: 'foo baz',
-                     url: 'https://example.com/not-spec-foo-baz').tap do |p|
-          PostTag.create!(post: p, tag: foo_tag)
-          PostTag.create!(post: p, tag: baz_tag)
-        end
-      end
-
-      let(:controlled_ids) do
-        [foo_only_post.id, bar_only_post.id, baz_only_post.id,
-         foo_bar_post.id, foo_baz_post.id]
-      end
-
-      it 'supports not search' do
-        get '/posts', params: { tags: 'not:not_spec_foo' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [bar_only_post.id, baz_only_post.id]
-        )
-      end
-
-      it 'supports alias in not search' do
-        get '/posts', params: { tags: 'not:not_spec_foo_alias' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [bar_only_post.id, baz_only_post.id]
-        )
-      end
-
-      it 'treats multiple not terms as AND when match is omitted' do
-        get '/posts', params: { tags: 'not:not_spec_foo not:not_spec_bar' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [baz_only_post.id]
-        )
-      end
-
-      it 'treats multiple not terms as OR when match=any' do
-        get '/posts', params: { tags: 'not:not_spec_foo not:not_spec_bar', match: 'any' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [foo_only_post.id, bar_only_post.id, baz_only_post.id, foo_baz_post.id]
-        )
-      end
-
-      it 'supports mixed positive and negative search with AND' do
-        get '/posts', params: { tags: 'not_spec_foo not:not_spec_bar' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [foo_only_post.id, foo_baz_post.id]
-        )
-      end
-
-      it 'supports mixed positive and negative search with OR when match=any' do
-        get '/posts', params: { tags: 'not_spec_foo not:not_spec_bar', match: 'any' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [foo_only_post.id, baz_only_post.id, foo_bar_post.id, foo_baz_post.id]
-        )
-      end
-    end
-
     context 'when url is provided' do
       let!(:url_hit_post) do
         Post.create!(uploaded_user: user, title: 'url hit',
@@ -525,9 +408,8 @@ RSpec.describe 'Posts API', type: :request do
 
     context "when nico tag already exists in tags" do
       before do
-        Tag.find_undiscard_or_create_by!(
+        Tag.find_or_create_by!(tag_name: TagName.find_or_create_by!(name: 'nico:nico_tag'),
-            tag_name: TagName.find_undiscard_or_create_by!(name: 'nico:nico_tag'),
+                               category: 'nico')
-            category: :nico)
       end
 
       it 'return 400' do
@@ -593,7 +475,7 @@ RSpec.describe 'Posts API', type: :request do
 
       # 追加で別タグも作って、更新時に入れ替わることを見る
       tn2 = TagName.create!(name: 'spec_tag_2')
-      Tag.create!(tag_name: tn2, category: :general)
+      Tag.create!(tag_name: tn2, category: 'general')
 
       put "/posts/#{post_record.id}", params: {
         title: 'updated title',
@@ -611,9 +493,8 @@ RSpec.describe 'Posts API', type: :request do
 
     context "when nico tag already exists in tags" do
       before do
-        Tag.find_undiscard_or_create_by!(
+        Tag.find_or_create_by!(tag_name: TagName.find_or_create_by!(name: 'nico:nico_tag'),
-            tag_name: TagName.find_undiscard_or_create_by!(name: 'nico:nico_tag'),
+                               category: 'nico')
-            category: :nico)
       end
 
       it 'return 400' do
@@ -650,7 +531,7 @@ RSpec.describe 'Posts API', type: :request do
     it 'returns add/remove events (history) for a post' do
       # add
       tn2 = TagName.create!(name: 'spec_tag2')
-      tag2 = Tag.create!(tag_name: tn2, category: :general)
+      tag2 = Tag.create!(tag_name: tn2, category: 'general')
       pt = PostTag.create!(post: post_record, tag: tag2, created_user: member)
 
       # remove (discard)
@@ -667,93 +548,6 @@ RSpec.describe 'Posts API', type: :request do
       expect(types).to include('add')
       expect(types).to include('remove')
     end
-
-    it 'filters history by tag' do
-      tn2 = TagName.create!(name: 'history_tag_hit')
-      tag2 = Tag.create!(tag_name: tn2, category: :general)
-
-      tn3 = TagName.create!(name: 'history_tag_miss')
-      tag3 = Tag.create!(tag_name: tn3, category: :general)
-
-      other_post = Post.create!(
-        title: 'other post',
-        url: 'https://example.com/history-other'
-      )
-
-      # hit: add
-      PostTag.create!(post: post_record, tag: tag2, created_user: member)
-
-      # hit: add + remove
-      pt2 = PostTag.create!(post: other_post, tag: tag2, created_user: member)
-      pt2.discard_by!(member)
-
-      # miss: add + remove
-      pt3 = PostTag.create!(post: post_record, tag: tag3, created_user: member)
-      pt3.discard_by!(member)
-
-      get '/posts/changes', params: { tag: tag2.id }
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include('changes', 'count')
-      expect(json['count']).to eq(3)
-
-      changes = json.fetch('changes')
-
-      expect(changes.map { |e| e.dig('tag', 'id') }.uniq).to eq([tag2.id])
-      expect(changes.map { |e| e['change_type'] }).to match_array(%w[add add remove])
-      expect(changes.map { |e| e.dig('post', 'id') }).to match_array([
-        post_record.id,
-        other_post.id,
-        other_post.id
-      ])
-    end
-
-    it 'filters history by post and tag together' do
-      tn2 = TagName.create!(name: 'history_tag_combo_hit')
-      tag2 = Tag.create!(tag_name: tn2, category: :general)
-
-      tn3 = TagName.create!(name: 'history_tag_combo_miss')
-      tag3 = Tag.create!(tag_name: tn3, category: :general)
-
-      other_post = Post.create!(
-        title: 'other combo post',
-        url: 'https://example.com/history-combo-other'
-      )
-
-      # hit
-      PostTag.create!(post: post_record, tag: tag2, created_user: member)
-
-      # miss by post
-      pt2 = PostTag.create!(post: other_post, tag: tag2, created_user: member)
-      pt2.discard_by!(member)
-
-      # miss by tag
-      pt3 = PostTag.create!(post: post_record, tag: tag3, created_user: member)
-      pt3.discard_by!(member)
-
-      get '/posts/changes', params: { id: post_record.id, tag: tag2.id }
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include('changes', 'count')
-      expect(json['count']).to eq(1)
-
-      changes = json.fetch('changes')
-      expect(changes.size).to eq(1)
-      expect(changes[0]['change_type']).to eq('add')
-      expect(changes[0].dig('post', 'id')).to eq(post_record.id)
-      expect(changes[0].dig('tag', 'id')).to eq(tag2.id)
-    end
-
-    it 'returns empty history when tag does not match' do
-      tn2 = TagName.create!(name: 'history_tag_no_hit')
-      tag2 = Tag.create!(tag_name: tn2, category: :general)
-
-      get '/posts/changes', params: { tag: tag2.id }
-
-      expect(response).to have_http_status(:ok)
-      expect(json.fetch('changes')).to eq([])
-      expect(json.fetch('count')).to eq(0)
-    end
   end
 
   describe 'POST /posts/:id/viewed' do

backend/spec/requests/tags_spec.rb

@@ -11,180 +11,16 @@ RSpec.describe 'Tags API', type: :request do
   let!(:tn2) { TagName.create!(name: 'unknown') }
   let!(:tag2) { Tag.create!(tag_name: tn2, category: :general) }
 
-  def response_tags
-    json.fetch('tags')
-  end
-
-  def response_names
-    response_tags.map { |t| t.fetch('name') }
-  end
-
   describe 'GET /tags' do
-    it 'returns tags with count and metadata' do
+    it 'returns tags with name' do
       get '/tags'
 
       expect(response).to have_http_status(:ok)
-      expect(json).to include('tags', 'count')
-      expect(response_tags).to be_an(Array)
-      expect(json['count']).to be_an(Integer)
-      expect(json['count']).to be >= response_tags.size
 
-      row = response_tags.find { |t| t['name'] == 'spec_tag' }
+      expect(json).to be_an(Array)
-      expect(row).to include(
+      expect(json).not_to be_empty
-          'id' => tag.id,
+      expect(json[0]).to have_key('name')
-          'name' => 'spec_tag',
+      expect(json.map { |t| t['name'] }).to include('spec_tag')
-          'category' => 'general',
-          'post_count' => 1,
-          'has_wiki' => false)
-      expect(row).to have_key('created_at')
-      expect(row).to have_key('updated_at')
-    end
-
-    it 'filters tags by post id' do
-      get '/tags', params: { post: post.id }
-
-      expect(response).to have_http_status(:ok)
-      expect(json['count']).to eq(1)
-      expect(response_names).to eq(['spec_tag'])
-    end
-
-    it 'filters tags by partial name' do
-      get '/tags', params: { name: 'spec' }
-
-      expect(response).to have_http_status(:ok)
-      expect(response_names).to include('spec_tag')
-      expect(response_names).not_to include('unknown')
-    end
-
-    it 'filters tags by category' do
-      meme = Tag.create!(tag_name: TagName.create!(name: 'meme_only'), category: :meme)
-
-      get '/tags', params: { category: 'meme' }
-
-      expect(response).to have_http_status(:ok)
-      expect(response_names).to eq(['meme_only'])
-      expect(response_tags.first['id']).to eq(meme.id)
-    end
-
-    it 'filters tags by post_count range' do
-      low = Tag.create!(tag_name: TagName.create!(name: 'pc_low'), category: :general)
-      mid = Tag.create!(tag_name: TagName.create!(name: 'pc_mid'), category: :general)
-      high = Tag.create!(tag_name: TagName.create!(name: 'pc_high'), category: :general)
-
-      low.update_columns(post_count: 1)
-      mid.update_columns(post_count: 3)
-      high.update_columns(post_count: 5)
-
-      get '/tags', params: {
-          name: 'pc_',
-          post_count_gte: 2,
-          post_count_lte: 4,
-          order: 'post_count:asc',
-      }
-
-      expect(response).to have_http_status(:ok)
-      expect(response_names).to eq(['pc_mid'])
-    end
-
-    it 'filters tags by created_at range' do
-      old_tag = Tag.create!(tag_name: TagName.create!(name: 'created_old'), category: :general)
-      new_tag = Tag.create!(tag_name: TagName.create!(name: 'created_new'), category: :general)
-
-      old_time = Time.zone.local(2024, 1, 1, 0, 0, 0)
-      new_time = Time.zone.local(2024, 2, 1, 0, 0, 0)
-
-      old_tag.update_columns(created_at: old_time, updated_at: old_time)
-      new_tag.update_columns(created_at: new_time, updated_at: new_time)
-
-      get '/tags', params: {
-          name: 'created_',
-          created_from: Time.zone.local(2024, 1, 15, 0, 0, 0).iso8601,
-          order: 'created_at:asc',
-      }
-
-      expect(response).to have_http_status(:ok)
-      expect(response_names).to eq(['created_new'])
-    end
-
-    it 'filters tags by updated_at range' do
-      old_tag = Tag.create!(tag_name: TagName.create!(name: 'updated_old'), category: :general)
-      new_tag = Tag.create!(tag_name: TagName.create!(name: 'updated_new'), category: :general)
-
-      old_time = Time.zone.local(2024, 3, 1, 0, 0, 0)
-      new_time = Time.zone.local(2024, 4, 1, 0, 0, 0)
-
-      old_tag.update_columns(created_at: old_time, updated_at: old_time)
-      new_tag.update_columns(created_at: new_time, updated_at: new_time)
-
-      get '/tags', params: {
-          name: 'updated_',
-          updated_to: Time.zone.local(2024, 3, 15, 0, 0, 0).iso8601,
-          order: 'updated_at:asc',
-      }
-
-      expect(response).to have_http_status(:ok)
-      expect(response_names).to eq(['updated_old'])
-    end
-
-    it 'orders tags by custom category order' do
-      Tag.create!(tag_name: TagName.create!(name: 'cat_deerjikist'), category: :deerjikist)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_meme'), category: :meme)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_character'), category: :character)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_general'), category: :general)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_material'), category: :material)
-      Tag.create!(tag_name: TagName.create!(name: 'cat_meta'), category: :meta)
-      Tag.create!(tag_name: TagName.create!(name: 'nico:cat_nico'), category: :nico)
-
-      get '/tags', params: { name: 'cat_', order: 'category:asc', limit: 20 }
-
-      expect(response).to have_http_status(:ok)
-      expect(response_names).to eq(%w[
-          cat_deerjikist
-          cat_meme
-          cat_character
-          cat_general
-          cat_material
-          cat_meta
-          nico:cat_nico
-      ])
-    end
-
-    it 'paginates and keeps total count' do
-      %w[pag_a pag_b pag_c].each do |name|
-        Tag.create!(tag_name: TagName.create!(name:), category: :general)
-      end
-
-      get '/tags', params: { name: 'pag_', order: 'name:asc', page: 2, limit: 2 }
-
-      expect(response).to have_http_status(:ok)
-      expect(json['count']).to eq(3)
-      expect(response_names).to eq(%w[pag_c])
-    end
-
-    it 'falls back to default ordering when order is invalid' do
-      low = Tag.create!(tag_name: TagName.create!(name: 'fallback_low'), category: :general)
-      high = Tag.create!(tag_name: TagName.create!(name: 'fallback_high'), category: :general)
-
-      low.update_columns(post_count: 1)
-      high.update_columns(post_count: 9)
-
-      get '/tags', params: { name: 'fallback_', order: 'nope:sideways' }
-
-      expect(response).to have_http_status(:ok)
-      expect(response_names.first).to eq('fallback_high')
-    end
-
-    it 'normalises invalid page and limit' do
-      %w[norm_a norm_b].each do |name|
-        Tag.create!(tag_name: TagName.create!(name:), category: :general)
-      end
-
-      get '/tags', params: { name: 'norm_', order: 'name:asc', page: 0, limit: 0 }
-
-      expect(response).to have_http_status(:ok)
-      expect(json['count']).to eq(2)
-      expect(response_tags.size).to eq(1)
-      expect(response_names).to eq(['norm_a'])
     end
   end
 
@@ -203,11 +39,7 @@ RSpec.describe 'Tags API', type: :request do
         expect(json).to include(
             'id'        => tag.id,
             'name'      => 'spec_tag',
-            'category' => 'general',
+            'category'  => 'general')
-            'post_count' => 1,
-            'has_wiki' => false)
-        expect(json).to have_key('created_at')
-        expect(json).to have_key('updated_at')
       end
     end
 
@@ -229,7 +61,7 @@ RSpec.describe 'Tags API', type: :request do
 
       expect(json).to be_an(Array)
       expect(json.map { |t| t['name'] }).to include('spec_tag')
-      t = json.find { |x| x['name'] == 'spec_tag' }
+      t = json.find { |t| t['name'] == 'spec_tag' }
       expect(t).to have_key('matched_alias')
       expect(t['matched_alias']).to be(nil)
     end
@@ -241,9 +73,9 @@ RSpec.describe 'Tags API', type: :request do
 
       expect(json).to be_an(Array)
       expect(json.map { |t| t['name'] }).to include('spec_tag')
-      t = json.find { |x| x['name'] == 'spec_tag' }
+      t = json.find { |t| t['name'] == 'spec_tag' }
       expect(t['matched_alias']).to eq('unko')
-      expect(json.map { |x| x['name'] }).not_to include('unknown')
+      expect(json.map { |t| t['name'] }).not_to include('unknown')
     end
   end
 
@@ -253,14 +85,10 @@ RSpec.describe 'Tags API', type: :request do
 
       expect(response).to have_http_status(:ok)
 
-      expect(json).to include(
+      expect(json).to have_key('id')
-          'id' => tag.id,
+      expect(json).to have_key('name')
-          'name' => 'spec_tag',
+      expect(json['id']).to eq(tag.id)
-          'category' => 'general',
+      expect(json['name']).to eq('spec_tag')
-          'post_count' => 1,
-          'has_wiki' => false)
-      expect(json).to have_key('created_at')
-      expect(json).to have_key('updated_at')
     end
 
     it 'returns 404 when not found' do
@@ -269,6 +97,7 @@ RSpec.describe 'Tags API', type: :request do
     end
   end
 
+  # member? を持つ user を想定（Factory 側で trait 作ってもOK）
   let(:member_user) { create(:user) }
   let(:non_member_user) { create(:user) }
 
@@ -281,80 +110,87 @@ RSpec.describe 'Tags API', type: :request do
     allow(non_member_user).to receive(:gte_member?).and_return(false)
   end
 
-  describe 'PATCH /tags/:id' do
+  describe "PATCH /tags/:id" do
-    context '未ログイン' do
+    context "未ログイン" do
       before { stub_current_user(nil) }
 
-      it '401 を返す' do
+      it "401 を返す" do
-        patch "/tags/#{ tag.id }", params: { name: 'new' }
+        patch "/tags/#{tag.id}", params: { name: "new" }
         expect(response).to have_http_status(:unauthorized)
       end
     end
 
-    context 'ログインしてゐるが member でない' do
+    context "ログインしてゐるが member でない" do
       before { stub_current_user(non_member_user) }
 
-      it '403 を返す' do
+      it "403 を返す" do
-        patch "/tags/#{ tag.id }", params: { name: 'new' }
+        patch "/tags/#{tag.id}", params: { name: "new" }
         expect(response).to have_http_status(:forbidden)
       end
     end
 
-    context 'member' do
+    context "member" do
       before { stub_current_user(member_user) }
 
-      it 'name だけ更新できる' do
+      it "name だけ更新できる" do
-        patch "/tags/#{ tag.id }", params: { name: 'new' }
+        patch "/tags/#{tag.id}", params: { name: "new" }
 
         expect(response).to have_http_status(:ok)
 
         tag.reload
-        expect(tag.name).to eq('new')
+        expect(tag.name).to eq("new")
-        expect(tag.category).to eq('general')
+        expect(tag.category).to eq("general")
 
-        body = JSON.parse(response.body)
+        json = JSON.parse(response.body)
-        expect(body['id']).to eq(tag.id)
+        expect(json["id"]).to eq(tag.id)
-        expect(body['name']).to eq('new')
+        expect(json["name"]).to eq("new")
-        expect(body['category']).to eq('general')
+        expect(json["category"]).to eq("general")
       end
 
-      it 'category だけ更新できる' do
+      it "category だけ更新できる" do
-        patch "/tags/#{ tag.id }", params: { category: 'meme' }
+        patch "/tags/#{tag.id}", params: { category: "meme" }
 
         expect(response).to have_http_status(:ok)
 
         tag.reload
-        expect(tag.name).to eq('spec_tag')
+        expect(tag.name).to eq("spec_tag")
-        expect(tag.category).to eq('meme')
+        expect(tag.category).to eq("meme")
       end
 
-      it '空文字は presence により無視され、更新は走らない（値が変わらない）' do
+      it "空文字は presence により無視され、更新は走らない（値が変わらない）" do
-        patch "/tags/#{ tag.id }", params: { name: '', category: '   ' }
+        patch "/tags/#{tag.id}", params: { name: "", category: "   " }
 
         expect(response).to have_http_status(:ok)
 
         tag.reload
-        expect(tag.name).to eq('spec_tag')
+        expect(tag.name).to eq("spec_tag")
-        expect(tag.category).to eq('general')
+        expect(tag.category).to eq("general")
       end
 
-      it '両方更新できる' do
+      it "両方更新できる" do
-        patch "/tags/#{ tag.id }", params: { name: 'n', category: 'meta' }
+        patch "/tags/#{tag.id}", params: { name: "n", category: "meta" }
 
         expect(response).to have_http_status(:ok)
 
         tag.reload
-        expect(tag.name).to eq('n')
+        expect(tag.name).to eq("n")
-        expect(tag.category).to eq('meta')
+        expect(tag.category).to eq("meta")
       end
 
-      it '存在しない id だと RecordNotFound になる（通常は 404）' do
+      it "存在しない id だと RecordNotFound になる（通常は 404）" do
-        patch '/tags/999999999', params: { name: 'x' }
+        # Rails 設定次第で例外がそのまま上がる/404になる
+        # APIなら rescue_from で 404 にしてることが多いので、その場合は 404 を期待。
+        patch "/tags/999999999", params: { name: "x" }
+
         expect(response.status).to be_in([404, 500])
       end
 
-      it 'バリデーションで update! が失敗したら（通常は 422 か 500）' do
+      it "バリデーションで update! が失敗したら（通常は 422 か 500）" do
         patch "/tags/#{tag.id}", params: { name: 'new', category: 'nico' }
+
+        # rescue_from の実装次第で変はる:
+        # - RecordInvalid を 422 にしてるなら 422
+        # - 未処理なら 500
         expect(response.status).to be_in([422, 500])
       end
     end

backend/spec/requests/theatres_spec.rb

@@ -1,289 +0,0 @@
-require 'rails_helper'
-require 'active_support/testing/time_helpers'
-
-
-RSpec.describe 'Theatres API', type: :request do
-  include ActiveSupport::Testing::TimeHelpers
-
-  around do |example|
-    travel_to(Time.zone.parse('2026-03-18 21:00:00')) do
-      example.run
-    end
-  end
-
-  let(:member) { create(:user, :member, name: 'member user') }
-  let(:other_user) { create(:user, :member, name: 'other user') }
-
-  let!(:youtube_post) do
-    Post.create!(
-      title: 'youtube post',
-      url: 'https://www.youtube.com/watch?v=spec123'
-    )
-  end
-
-  let!(:other_post) do
-    Post.create!(
-      title: 'other post',
-      url: 'https://example.com/posts/1'
-    )
-  end
-
-  let!(:theatre) do
-    Theatre.create!(
-      name: 'spec theatre',
-      opens_at: Time.zone.parse('2026-03-18 20:00:00'),
-      kind: 0,
-      created_by_user: member
-    )
-  end
-
-  describe 'GET /theatres/:id' do
-    subject(:do_request) do
-      get "/theatres/#{theatre_id}"
-    end
-
-    context 'when theatre exists' do
-      let(:theatre_id) { theatre.id }
-
-      it 'returns theatre json' do
-        do_request
-
-        expect(response).to have_http_status(:ok)
-        expect(json).to include(
-          'id' => theatre.id,
-          'name' => 'spec theatre'
-        )
-        expect(json).to have_key('opens_at')
-        expect(json).to have_key('closes_at')
-        expect(json).to have_key('created_at')
-        expect(json).to have_key('updated_at')
-
-        expect(json['created_by_user']).to include(
-          'id' => member.id,
-          'name' => 'member user'
-        )
-      end
-    end
-
-    context 'when theatre does not exist' do
-      let(:theatre_id) { 999_999_999 }
-
-      it 'returns 404' do
-        do_request
-        expect(response).to have_http_status(:not_found)
-      end
-    end
-  end
-
-  describe 'PUT /theatres/:id/watching' do
-    subject(:do_request) do
-      put "/theatres/#{theatre_id}/watching"
-    end
-
-    let(:theatre_id) { theatre.id }
-
-    context 'when not logged in' do
-      it 'returns 401' do
-        sign_out
-        do_request
-        expect(response).to have_http_status(:unauthorized)
-      end
-    end
-
-    context 'when theatre does not exist' do
-      let(:theatre_id) { 999_999_999 }
-
-      it 'returns 404' do
-        sign_in_as(member)
-        do_request
-        expect(response).to have_http_status(:not_found)
-      end
-    end
-
-    context 'when theatre has no host yet' do
-      before do
-        sign_in_as(member)
-      end
-
-      it 'creates watching row, assigns current user as host, and returns current theatre info' do
-        expect { do_request }
-          .to change { TheatreWatchingUser.count }.by(1)
-
-        expect(response).to have_http_status(:ok)
-
-        theatre.reload
-        watch = TheatreWatchingUser.find_by!(theatre: theatre, user: member)
-
-        expect(theatre.host_user_id).to eq(member.id)
-        expect(watch.expires_at).to be_within(1.second).of(30.seconds.from_now)
-
-        expect(json).to eq(
-          'host_flg' => true,
-          'post_id' => nil,
-          'post_started_at' => nil
-        )
-      end
-    end
-
-    context 'when current user is already watching' do
-      let!(:watching_row) do
-        TheatreWatchingUser.create!(
-          theatre: theatre,
-          user: member,
-          expires_at: 5.seconds.from_now
-        )
-      end
-
-      before do
-        sign_in_as(member)
-      end
-
-      it 'refreshes expires_at without creating another row' do
-        expect { do_request }
-          .not_to change { TheatreWatchingUser.count }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(watching_row.reload.expires_at)
-          .to be_within(1.second).of(30.seconds.from_now)
-      end
-    end
-
-    context 'when another active host exists' do
-      before do
-        TheatreWatchingUser.create!(
-          theatre: theatre,
-          user: other_user,
-          expires_at: 10.minutes.from_now
-        )
-        theatre.update!(host_user: other_user)
-        sign_in_as(member)
-      end
-
-      it 'does not steal host and returns host_flg false' do
-        expect { do_request }
-          .to change { TheatreWatchingUser.count }.by(1)
-
-        expect(response).to have_http_status(:ok)
-        expect(theatre.reload.host_user_id).to eq(other_user.id)
-
-        expect(json).to eq(
-          'host_flg' => false,
-          'post_id' => nil,
-          'post_started_at' => nil
-        )
-      end
-    end
-
-    context 'when host is set but no longer actively watching' do
-      let(:started_at) { 2.minutes.ago }
-
-      before do
-        TheatreWatchingUser.create!(
-          theatre: theatre,
-          user: other_user,
-          expires_at: 1.second.ago
-        )
-        theatre.update!(
-          host_user: other_user,
-          current_post: youtube_post,
-          current_post_started_at: started_at
-        )
-        sign_in_as(member)
-      end
-
-      it 'reassigns host to current user and returns current post info' do
-        expect { do_request }
-          .to change { TheatreWatchingUser.count }.by(1)
-
-        expect(response).to have_http_status(:ok)
-
-        theatre.reload
-        expect(theatre.host_user_id).to eq(member.id)
-
-        expect(json['host_flg']).to eq(true)
-        expect(json['post_id']).to eq(youtube_post.id)
-        expect(Time.zone.parse(json['post_started_at']))
-          .to be_within(1.second).of(started_at)
-      end
-    end
-  end
-
-  describe 'PATCH /theatres/:id/next_post' do
-    subject(:do_request) do
-      patch "/theatres/#{theatre_id}/next_post"
-    end
-
-    let(:theatre_id) { theatre.id }
-
-    context 'when not logged in' do
-      it 'returns 401' do
-        sign_out
-        do_request
-        expect(response).to have_http_status(:unauthorized)
-      end
-    end
-
-    context 'when theatre does not exist' do
-      let(:theatre_id) { 999_999_999 }
-
-      it 'returns 404' do
-        sign_in_as(member)
-        do_request
-        expect(response).to have_http_status(:not_found)
-      end
-    end
-
-    context 'when logged in but not host' do
-      before do
-        theatre.update!(host_user: other_user)
-        sign_in_as(member)
-      end
-
-      it 'returns 403' do
-        do_request
-        expect(response).to have_http_status(:forbidden)
-      end
-    end
-
-    context 'when current user is host' do
-      before do
-        theatre.update!(host_user: member)
-        sign_in_as(member)
-      end
-
-      it 'sets current_post to an eligible post and updates current_post_started_at' do
-        expect { do_request }
-          .to change { theatre.reload.current_post_id }
-          .from(nil).to(youtube_post.id)
-
-        expect(response).to have_http_status(:no_content)
-        expect(theatre.reload.current_post_started_at)
-          .to be_within(1.second).of(Time.current)
-      end
-    end
-
-    context 'when current user is host and no eligible post exists' do
-      before do
-        youtube_post.destroy!
-        theatre.update!(
-          host_user: member,
-          current_post: other_post,
-          current_post_started_at: 1.hour.ago
-        )
-        sign_in_as(member)
-      end
-
-      it 'still returns 204 and clears current_post' do
-        do_request
-
-        expect(response).to have_http_status(:no_content)
-
-        theatre.reload
-        expect(theatre.current_post_id).to be_nil
-        expect(theatre.current_post_started_at)
-          .to be_within(1.second).of(Time.current)
-      end
-    end
-  end
-end

backend/spec/tasks/nico_sync_spec.rb

@@ -8,8 +8,8 @@ RSpec.describe "nico:sync" do
   end
 
   def create_tag!(name, category:)
-    tn = TagName.find_undiscard_or_create_by!(name: name.to_s.strip)
+    tn = TagName.find_or_create_by!(name: name.to_s.strip)
-    Tag.find_undiscard_or_create_by!(tag_name_id: tn.id) { |t| t.category = category }
+    Tag.find_or_create_by!(tag_name_id: tn.id) { |t| t.category = category }
   end
 
   def link_nico_to_tag!(nico_tag, tag)

frontend/scripts/generate-sitemap.js

@@ -20,7 +20,7 @@ const fetchPosts = async tagName => (await axios.get (`${ API_BASE_URL }/posts`,
                                  match: 'all',
                                  limit: '20' }) } })).data.posts
 
-const fetchTags = async () => (await axios.get (`${ API_BASE_URL }/tags`)).data.tags
+const fetchTags = async () => (await axios.get (`${ API_BASE_URL }/tags`)).data
 const fetchTagNames = async () => (await fetchTags ()).map (tag => tag.name)
 
 const fetchWikiPages = async () => (await axios.get (`${ API_BASE_URL }/wiki`)).data

frontend/src/App.tsx

@@ -19,8 +19,6 @@ import PostNewPage from '@/pages/posts/PostNewPage'
 import PostSearchPage from '@/pages/posts/PostSearchPage'
 import ServiceUnavailable from '@/pages/ServiceUnavailable'
 import SettingPage from '@/pages/users/SettingPage'
-import TagListPage from '@/pages/tags/TagListPage'
-import TheatreDetailPage from '@/pages/theatres/TheatreDetailPage'
 import WikiDetailPage from '@/pages/wiki/WikiDetailPage'
 import WikiDiffPage from '@/pages/wiki/WikiDiffPage'
 import WikiEditPage from '@/pages/wiki/WikiEditPage'
@@ -48,9 +46,7 @@ const RouteTransitionWrapper = ({ user, setUser }: {
 	    <Route path="/posts/search" element={<PostSearchPage/>}/>
 	    <Route path="/posts/:id" element={<PostDetailRoute user={user}/>}/>
 	    <Route path="/posts/changes" element={<PostHistoryPage/>}/>
-	    <Route path="/tags" element={<TagListPage/>}/>
 	    <Route path="/tags/nico" element={<NicoTagListPage user={user}/>}/>
-	    <Route path="/theatres/:id" element={<TheatreDetailPage/>}/>
 	    <Route path="/wiki" element={<WikiSearchPage/>}/>
 	    <Route path="/wiki/:title" element={<WikiDetailPage/>}/>
 	    <Route path="/wiki/new" element={<WikiNewPage user={user}/>}/>

frontend/src/components/DraggableDroppableTagRow.tsx

@@ -1,6 +1,5 @@
 import { useDraggable, useDroppable } from '@dnd-kit/core'
 import { CSS } from '@dnd-kit/utilities'
-import { motion } from 'framer-motion'
 import { useRef } from 'react'
 
 import TagLink from '@/components/TagLink'
@@ -15,11 +14,10 @@ type Props = {
     nestLevel:        number
     pathKey:          string
     parentTagId?:     number
-    suppressClickRef: MutableRefObject<boolean>
+    suppressClickRef: MutableRefObject<boolean> }
-    sp?:              boolean }
 
 
-export default (({ tag, nestLevel, pathKey, parentTagId, suppressClickRef, sp }: Props) => {
+export default (({ tag, nestLevel, pathKey, parentTagId, suppressClickRef }: Props) => {
   const dndId = `tag-node:${ pathKey }`
 
   const downPosRef = useRef<{ x: number; y: number } | null> (null)
@@ -90,8 +88,6 @@ export default (({ tag, nestLevel, pathKey, parentTagId, suppressClickRef, sp }:
 	  className={cn ('rounded select-none', over && 'ring-2 ring-offset-2')}
 	  {...attributes}
 	  {...listeners}>
-	<motion.div layoutId={`tag-${ sp ? 'sp-' : '' }${ tag.id }`}>
 	<TagLink tag={tag} nestLevel={nestLevel}/>
-	</motion.div>
       </div>)
 }) satisfies FC<Props>

frontend/src/components/NicoViewer.tsx

@@ -1,185 +1,59 @@
-import { forwardRef,
+import { useRef, useLayoutEffect, useEffect, useState } from 'react'
-         useCallback,
+type Props = { id:      string,
-         useEffect,
+	       width:   number,
-         useImperativeHandle,
+	       height:  number,
-         useLayoutEffect,
+	       style?:  CSSProperties }
-         useMemo,
-         useRef,
-         useState } from 'react'
 
-import type { CSSProperties, ForwardedRef } from 'react'
+import type { CSSProperties, FC } from 'react'
-
-import type { NiconicoMetadata, NiconicoVideoInfo, NiconicoViewerHandle } from '@/types'
-
-type NiconicoPlayerMessage =
-    | { eventName: 'enterProgrammaticFullScreen' }
-    | { eventName: 'exitProgrammaticFullScreen' }
-    | { eventName: 'loadComplete'; playerId?: string; data: { videoInfo: NiconicoVideoInfo } }
-    | { eventName: 'playerMetadataChange'; playerId?: string; data: NiconicoMetadata }
-    | { eventName: 'playerStatusChange' | 'statusChange'; playerId?: string; data?: unknown }
-    | { eventName: 'error'; playerId?: string; data?: unknown; code?: string; message?: string }
-
-type NiconicoCommand =
-    | { eventName: 'play'; sourceConnectorType: 1; playerId: string }
-    | { eventName: 'pause'; sourceConnectorType: 1; playerId: string }
-    | { eventName: 'seek'; sourceConnectorType: 1; playerId: string; data: { time: number } }
-    | { eventName: 'mute'; sourceConnectorType: 1; playerId: string; data: { mute: boolean } }
-    | { eventName: 'volumeChange'; sourceConnectorType: 1; playerId: string;
-	data: { volume: number } }
-    | { eventName: 'commentVisibilityChange'; sourceConnectorType: 1; playerId: string;
-	data: { commentVisibility: boolean } }
-
-const EMBED_ORIGIN = 'https://embed.nicovideo.jp'
-
-type Props = {
-    id:                 string
-    width:              number
-    height:             number
-    style?:             CSSProperties
-    onLoadComplete?:    (info: NiconicoVideoInfo) => void
-    onMetadataChange?:  (meta: NiconicoMetadata) => void }
 
 
-export default forwardRef ((props: Props, ref: ForwardedRef<NiconicoViewerHandle>) => {
+export default ((props: Props) => {
-  const { id, width, height, style = { }, onLoadComplete, onMetadataChange } = props
+  const { id, width, height, style = { } } = props
 
   const iframeRef = useRef<HTMLIFrameElement> (null)
-  const playerId = useMemo (() => `nico-${ id }-${ Math.random ().toString (36).slice (2) }`, [id])
 
   const [screenWidth, setScreenWidth] = useState<CSSProperties['width']> ()
   const [screenHeight, setScreenHeight] = useState<CSSProperties['height']> ()
   const [landscape, setLandscape] = useState<boolean> (false)
   const [fullScreen, setFullScreen] = useState<boolean> (false)
 
-  const src =
+  const src = `https://embed.nicovideo.jp/watch/${id}?persistence=1&oldScript=1&referer=&from=0&allowProgrammaticFullScreen=1`;
-      `${ EMBED_ORIGIN }/watch/${ id }`
-      + '?jsapi=1'
-      + `&playerId=${ encodeURIComponent (playerId) }`
-      + '&persistence=1'
-      + '&oldScript=1'
-      + '&referer='
-      + '&from=0'
-      + '&allowProgrammaticFullScreen=1'
 
-  const styleFullScreen: CSSProperties =
+  const styleFullScreen: CSSProperties = fullScreen ? {
-      fullScreen
+      top:  0,
-      ? { top: 0,
       left: landscape ? 0 : '100%',
       position: 'fixed',
       width: screenWidth,
       height: screenHeight,
-          zIndex: 2_147_483_647,
+      zIndex: 2147483647,
       maxWidth: 'none',
       transformOrigin: '0% 0%',
       transform: landscape ? 'none' : 'rotate(90deg)',
       WebkitTransformOrigin: '0% 0%',
-          WebkitTransform: landscape ? 'none' : 'rotate(90deg)' }
+      WebkitTransform: landscape ? 'none' : 'rotate(90deg)' } : {};
-      : { }
 
-  const margedStyle: CSSProperties =
+  const margedStyle = {
-      { border: 'none', maxWidth: '100%', ...style, ...styleFullScreen }
+      border:   'none',
-
+      maxWidth: '100%',
-  const postToPlayer = useCallback ((message: NiconicoCommand) => {
+      ...style,
-    const win = iframeRef.current?.contentWindow
+      ...styleFullScreen }
-    if (!(win))
-      return
-
-    win.postMessage (message, EMBED_ORIGIN)
-  }, [])
-
-  const play = useCallback (() => {
-    postToPlayer ({ eventName: 'play', sourceConnectorType: 1, playerId })
-  }, [playerId, postToPlayer])
-
-  const pause = useCallback (() => {
-    postToPlayer ({ eventName: 'pause', sourceConnectorType: 1, playerId })
-  }, [playerId, postToPlayer])
-
-  const seek = useCallback ((time: number) => {
-    postToPlayer ({ eventName: 'seek', sourceConnectorType: 1, playerId, data: { time } })
-  }, [playerId, postToPlayer])
-
-  const mute = useCallback (() => {
-    postToPlayer ({ eventName: 'mute', sourceConnectorType: 1, playerId, data: { mute: true } })
-  }, [playerId, postToPlayer])
-
-  const unmute = useCallback (() => {
-    postToPlayer ({ eventName: 'mute', sourceConnectorType: 1, playerId, data: { mute: false } })
-  }, [playerId, postToPlayer])
-
-  const setVolume = useCallback ((volume: number) => {
-    postToPlayer (
-	{ eventName: 'volumeChange', sourceConnectorType: 1, playerId, data: { volume } })
-  }, [playerId, postToPlayer])
-
-  const showComments = useCallback (() => {
-    postToPlayer (
-	{ eventName: 'commentVisibilityChange', sourceConnectorType: 1, playerId,
-	  data: { commentVisibility: true } })
-  }, [playerId, postToPlayer])
-
-  const hideComments = useCallback (() => {
-    postToPlayer (
-	{ eventName: 'commentVisibilityChange', sourceConnectorType: 1, playerId,
-	  data: { commentVisibility: false } })
-  }, [playerId, postToPlayer])
-
-  useImperativeHandle (
-      ref,
-      () => ({ play, pause, seek, mute, unmute, setVolume, showComments, hideComments }),
-      [play, pause, seek, mute, unmute, setVolume, showComments, hideComments])
 
   useEffect (() => {
-    const onMessage = (event: MessageEvent<NiconicoPlayerMessage>) => {
+    const onMessage = (event: MessageEvent<any>) => {
       if (!(iframeRef.current)
-          || (event.source !== iframeRef.current.contentWindow)
+	  || (event.source !== iframeRef.current.contentWindow))
-          || (event.origin !== EMBED_ORIGIN))
 	return
 
-      const data = event.data
+      if (event.data.eventName === 'enterProgrammaticFullScreen')
-
-      if (!(data)
-	  || typeof data !== 'object'
-	  || !('eventName' in data))
-        return
-
-      if (('playerId' in data)
-	  && data.playerId
-	  && data.playerId !== playerId)
-        return
-
-      if (data.eventName === 'enterProgrammaticFullScreen')
-	{
 	setFullScreen (true)
-	  return
+      else if (event.data.eventName === 'exitProgrammaticFullScreen')
-	}
-
-      if (data.eventName === 'exitProgrammaticFullScreen')
-	{
 	setFullScreen (false)
-	  return
-	}
-
-      if (data.eventName === 'loadComplete')
-	{
-	  onLoadComplete?.(data.data.videoInfo)
-	  return
-	}
-
-      if (data.eventName === 'playerMetadataChange')
-	{
-	  onMetadataChange?.(data.data)
-	  return
-	}
-
-      if (data.eventName === 'error')
-        console.error ('niconico player error:', data)
     }
 
     addEventListener ('message', onMessage)
 
     return () => removeEventListener ('message', onMessage)
-  }, [onLoadComplete, onMetadataChange, playerId])
+  }, [])
 
   useLayoutEffect(() => {
     if (!(fullScreen))
@@ -187,18 +61,18 @@ export default forwardRef ((props: Props, ref: ForwardedRef<NiconicoViewerHandle
 
     const initialScrollX = scrollX
     const initialScrollY = scrollY
-    let timer: ReturnType<typeof setTimeout>
+    let timer: NodeJS.Timeout
     let ended = false
 
     const pollingResize = () => {
       if (ended)
 	return
 
-      const isLandscape = innerWidth >= innerHeight
+      const landscape = innerWidth >= innerHeight
-      const windowWidth = `${ isLandscape ? innerWidth : innerHeight }px`
+      const windowWidth = `${landscape ? innerWidth : innerHeight}px`
-      const windowHeight = `${ isLandscape ? innerHeight : innerWidth }px`
+      const windowHeight = `${landscape ? innerHeight : innerWidth}px`
 
-      setLandscape (isLandscape)
+      setLandscape (landscape)
       setScreenWidth (windowWidth)
       setScreenHeight (windowHeight)
       timer = setTimeout (startPollingResize, 200)
@@ -223,17 +97,15 @@ export default forwardRef ((props: Props, ref: ForwardedRef<NiconicoViewerHandle
   useEffect (() => {
     if (!(fullScreen))
       return
-
     scrollTo (0, 0)
   }, [screenWidth, screenHeight, fullScreen])
 
   return (
-      <iframe
+      <iframe ref={iframeRef}
-	  ref={iframeRef}
 	      src={src}
 	      width={width}
 	      height={height}
 	      style={margedStyle}
 	      allowFullScreen
 	      allow="autoplay"/>)
-})
+}) satisfies FC<Props>

frontend/src/components/PostEmbed.tsx

@@ -4,18 +4,14 @@ import YoutubeEmbed from 'react-youtube'
 import NicoViewer from '@/components/NicoViewer'
 import TwitterEmbed from '@/components/TwitterEmbed'
 
-import type { FC, RefObject } from 'react'
+import type { FC } from 'react'
 
-import type { NiconicoMetadata, NiconicoVideoInfo, NiconicoViewerHandle, Post } from '@/types'
+import type { Post } from '@/types'
 
-type Props = {
+type Props = { post: Post }
-    ref?:               RefObject<NiconicoViewerHandle | null>
-    post:               Post
-    onLoadComplete?:    (info: NiconicoVideoInfo) => void
-    onMetadataChange?:  (meta: NiconicoMetadata) => void }
 
 
-export default (({ ref, post, onLoadComplete, onMetadataChange }: Props) => {
+export default (({ post }: Props) => {
   const url = new URL (post.url)
 
   switch (url.hostname.split ('.').slice (-2).join ('.'))
@@ -28,14 +24,7 @@ export default (({ ref, post, onLoadComplete, onMetadataChange }: Props) => {
 
       const [videoId] = mVideoId
 
-      return (
+      return <NicoViewer id={videoId} width={640} height={360}/>
-	  <NicoViewer
-	      ref={ref}
-	      id={videoId}
-	      width={640}
-	      height={360}
-	      onLoadComplete={onLoadComplete}
-	      onMetadataChange={onMetadataChange}/>)
     }
 
   case 'twitter.com':

frontend/src/components/SortHeader.tsx

@@ -1,31 +0,0 @@
-import { useLocation } from 'react-router-dom'
-
-import PrefetchLink from '@/components/PrefetchLink'
-
-
-export default <T extends string,>({ by, label, currentOrder, defaultDirection }: {
-    by:               T
-    label:            string
-    currentOrder:     `${ T }:${ 'asc' | 'desc' }`
-    defaultDirection: Record<T, 'asc' | 'desc'> }) => {
-  const [fld, dir] = currentOrder.split (':')
-
-  const location = useLocation ()
-  const qs = new URLSearchParams (location.search)
-  const nextDir =
-      (by === fld)
-      ? (dir === 'asc' ? 'desc' : 'asc')
-      : (defaultDirection[by] || 'desc')
-  qs.set ('order', `${ by }:${ nextDir }`)
-  qs.set ('page', '1')
-
-  return (
-      <PrefetchLink
-	  className="text-inherit visited:text-inherit hover:text-inherit"
-	  to={`${ location.pathname }?${ qs.toString () }`}>
-	<span className="font-bold">
-	  {label}
-	  {by === fld && (dir === 'asc' ? ' ▲' : ' ▼')}
-	</span>
-      </PrefetchLink>)
-}

frontend/src/components/TagDetailSidebar.tsx

@@ -6,9 +6,8 @@ import { DndContext,
 	 useSensor,
 	 useSensors } from '@dnd-kit/core'
 import { restrictToWindowEdges } from '@dnd-kit/modifiers'
-import { useQueryClient } from '@tanstack/react-query'
+import { AnimatePresence, motion } from 'framer-motion'
-import { motion } from 'framer-motion'
+import { useEffect, useRef, useState } from 'react'
-import { useEffect, useMemo, useRef, useState } from 'react'
 
 import DraggableDroppableTagRow from '@/components/DraggableDroppableTagRow'
 import PrefetchLink from '@/components/PrefetchLink'
@@ -18,9 +17,8 @@ import SectionTitle from '@/components/common/SectionTitle'
 import SubsectionTitle from '@/components/common/SubsectionTitle'
 import SidebarComponent from '@/components/layout/SidebarComponent'
 import { toast } from '@/components/ui/use-toast'
-import { CATEGORIES, CATEGORY_NAMES } from '@/consts'
+import { CATEGORIES } from '@/consts'
 import { apiDelete, apiGet, apiPatch, apiPost } from '@/lib/api'
-import { postsKeys, tagsKeys } from '@/lib/queryKeys'
 import { dateString, originalCreatedAtString } from '@/lib/utils'
 
 import type { DragEndEvent } from '@dnd-kit/core'
@@ -37,27 +35,28 @@ const renderTagTree = (
     path:             string,
     suppressClickRef: MutableRefObject<boolean>,
     parentTagId?:     number,
-    sp?:              boolean,
 ): ReactNode[] => {
   const key = `${ path }-${ tag.id }`
 
   const self = (
-      <li key={key} className="mb-1">
+      <motion.li
+	  key={key}
+	  layout
+	  transition={{ duration: .2, ease: 'easeOut' }}
+	  className="mb-1">
 	<DraggableDroppableTagRow
 	    tag={tag}
 	    nestLevel={nestLevel}
 	    pathKey={key}
 	    parentTagId={parentTagId}
-	    suppressClickRef={suppressClickRef}
+	    suppressClickRef={suppressClickRef}/>
-	    sp={sp}/>
+      </motion.li>)
-      </li>)
 
   return [
       self,
       ...((tag.children
 	   ?.sort ((a, b) => a.name < b.name ? -1 : 1)
-	   .flatMap (child =>
+	   .flatMap (child => renderTagTree (child, nestLevel + 1, key, suppressClickRef, tag.id)))
-	      renderTagTree (child, nestLevel + 1, key, suppressClickRef, tag.id, sp)))
 	  ?? [])]
 }
 
@@ -148,34 +147,14 @@ const DropSlot = ({ cat }: { cat: Category }) => {
 }
 
 
-type Props = { post: Post; sp?: boolean }
+type Props = { post: Post | null }
 
 
-export default (({ post, sp }: Props) => {
+export default (({ post }: Props) => {
-  sp = Boolean (sp)
-
-  const qc = useQueryClient ()
-
-  const baseTags = useMemo<TagByCategory> (() => {
-    const tagsTmp = { } as TagByCategory
-
-    for (const tag of post.tags)
-      {
-	if (!(tag.category in tagsTmp))
-	  tagsTmp[tag.category] = []
-	tagsTmp[tag.category].push (tag)
-      }
-
-    for (const cat of Object.keys (tagsTmp) as (keyof typeof tagsTmp)[])
-      tagsTmp[cat].sort ((tagA: Tag, tagB: Tag) => tagA.name < tagB.name ? -1 : 1)
-
-    return tagsTmp
-  }, [post])
-
   const [activeTagId, setActiveTagId] = useState<number | null> (null)
   const [dragging, setDragging] = useState (false)
   const [saving, setSaving] = useState (false)
-  const [tags, setTags] = useState (baseTags)
+  const [tags, setTags] = useState ({ } as TagByCategory)
 
   const suppressClickRef = useRef (false)
 
@@ -184,9 +163,10 @@ export default (({ post, sp }: Props) => {
       useSensor (TouchSensor, { activationConstraint: { delay: 250, tolerance: 8 } }))
 
   const reloadTags = async (): Promise<void> => {
+    if (!(post))
+      return
+
     setTags (buildTagByCategory (await apiGet<Post> (`/posts/${ post.id }`)))
-    qc.invalidateQueries ({ queryKey: postsKeys.root })
-    qc.invalidateQueries ({ queryKey: tagsKeys.root })
   }
 
   const onDragEnd = async (e: DragEndEvent) => {
@@ -275,9 +255,33 @@ export default (({ post, sp }: Props) => {
     }
   }
 
+  const categoryNames: Record<Category, string> = {
+      deerjikist: 'ニジラー',
+      meme:       '原作・ネタ元・ミーム等',
+      character:  'キャラクター',
+      general:    '一般',
+      material:   '素材',
+      meta:       'メタタグ',
+      nico:       'ニコニコタグ' }
+
   useEffect (() => {
-    setTags (baseTags)
+    if (!(post))
-  }, [baseTags])
+      return
+
+    const tagsTmp = { } as TagByCategory
+
+    for (const tag of post.tags)
+      {
+	if (!(tag.category in tagsTmp))
+	  tagsTmp[tag.category] = []
+	tagsTmp[tag.category].push (tag)
+      }
+
+    for (const cat of Object.keys (tagsTmp) as (keyof typeof tagsTmp)[])
+      tagsTmp[cat].sort ((tagA: Tag, tagB: Tag) => tagA.name < tagB.name ? -1 : 1)
+
+    setTags (tagsTmp)
+  }, [post])
 
   return (
       <SidebarComponent>
@@ -310,25 +314,26 @@ export default (({ post, sp }: Props) => {
 	      document.body.style.userSelect = ''
 	    }}
 	    modifiers={[restrictToWindowEdges]}>
+	  <motion.div key={post?.id ?? 0} layout>
 	    {CATEGORIES.map ((cat: Category) => ((tags[cat] ?? []).length > 0 || dragging) && (
-	      <div className="my-3" key={cat}>
+		<motion.div layout className="my-3" key={cat}>
-		<SubsectionTitle>
+		  <SubsectionTitle>{categoryNames[cat]}</SubsectionTitle>
-		  <motion.div layoutId={`tag-${ sp ? 'sp-' : '' }${ cat }`}>
-		    {CATEGORY_NAMES[cat]}
-		  </motion.div>
-		</SubsectionTitle>
 
-		<ul>
+		  <motion.ul layout>
+		    <AnimatePresence initial={false}>
 		      {(tags[cat] ?? []).flatMap (tag => (
-		      renderTagTree (tag, 0, `cat-${ cat }`, suppressClickRef, undefined, sp)))}
+			  renderTagTree (tag, 0, `cat-${ cat }`, suppressClickRef, undefined)))}
 		      <DropSlot cat={cat}/>
-		</ul>
+		    </AnimatePresence>
-	      </div>))}
+		  </motion.ul>
+		</motion.div>))}
 	    {post && (
-	      <motion.div layoutId={`post-info-${ sp }`}>
+		<div>
 		  <SectionTitle>情報</SectionTitle>
 		  <ul>
 		    <li>Id.: {post.id}</li>
+		    {/* TODO: uploadedUser の取得を対応したらコメント外す */}
+		    {/*
 		    <li>
 		      <>耕作者: </>
 		      {post.uploadedUser
@@ -338,6 +343,7 @@ export default (({ post, sp }: Props) => {
 			  </PrefetchLink>)
 		       : 'bot操作'}
 		    </li>
+		    */}
 		    <li>耕作日時: {dateString (post.createdAt)}</li>
 		    <li>
 		      <>リンク: </>
@@ -360,7 +366,8 @@ export default (({ post, sp }: Props) => {
 		      </PrefetchLink>
 		    </li>
 		  </ul>
-	      </motion.div>)}
+		</div>)}
+	  </motion.div>
 
 	  <DragOverlay adjustScale={false}>
 	    <div className="pointer-events-none">

frontend/src/components/TagSearch.tsx

@@ -56,11 +56,8 @@ export default (() => {
       if (activeIndex < 0)
 	break
       ev.preventDefault ()
-      {
       const selected = suggestions[activeIndex]
-	if (selected)
+      selected && handleTagSelect (selected)
-	  handleTagSelect (selected)
-      }
       break
 
     case 'Escape':
@@ -70,25 +67,14 @@ export default (() => {
     }
     if (ev.key === 'Enter' && (!(suggestionsVsbl) || activeIndex < 0))
       {
-	const parts = search.split (' ')
+	navigate (`/posts?${ (new URLSearchParams ({ tags: search })).toString () }`)
-	const match = parts.map (t => t.toLowerCase ()).includes ('type:or') ? 'any' : 'all'
-	navigate (`/posts?${
-	    (new URLSearchParams ({
-		tags: parts.map (t => t.toLowerCase ())
-			   .filter (t => t !== 'type:or')
-			   .join (' '),
-		match }))
-	    .toString () }`)
 	setSuggestionsVsbl (false)
       }
   }
 
   const handleTagSelect = (tag: Tag) => {
     const parts = search.split (' ')
-    parts[parts.length - 1] = (
+    parts[parts.length - 1] = tag.name
-	(parts[parts.length - 1].slice(0, 4).toLowerCase () === 'not:')
-	? ('not:' + tag.name)
-	: tag.name)
     setSearch (parts.join (' ') + ' ')
     setSuggestions ([])
     setActiveIndex (-1)
@@ -96,8 +82,7 @@ export default (() => {
 
   useEffect (() => {
     const query = new URLSearchParams (location.search)
-    const anyFlg = query.get ('match') === 'any'
+    const tagsQuery = query.get ('tags') ?? ''
-    const tagsQuery = `${ query.get ('tags') ?? '' }${ anyFlg ? ' type:or' : '' }`
     setSearch (tagsQuery)
   }, [location.search])
 

frontend/src/components/TagSidebar.tsx

@@ -65,12 +65,11 @@ export default (({ posts, onClick }: Props) => {
 	  {CATEGORIES.flatMap (cat => cat in tags ? (
 	      tags[cat].map (tag => (
 		  <li key={tag.id} className="mb-1">
-		    <motion.div layoutId={`tag-${ tag.id }`}>
 		    <TagLink tag={tag} prefetch onClick={onClick}/>
-		    </motion.div>
 		  </li>))) : [])}
 	</ul>
 	<SectionTitle>関聯</SectionTitle>
+	{posts.length > 0 && (
 	    <a href="#"
 	       onClick={ev => {
 		 ev.preventDefault ()
@@ -89,7 +88,7 @@ export default (({ posts, onClick }: Props) => {
 		 }) ())
 	       }}>
 	      ランダム
-	</a>
+	    </a>)}
       </>)
 
   return (
@@ -97,19 +96,23 @@ export default (({ posts, onClick }: Props) => {
 	<TagSearch/>
 
 	<div className="hidden md:block mt-4">
-	  {posts.length > 0 && TagBlock}
+	  {TagBlock}
 	</div>
 
 	<AnimatePresence initial={false}>
 	  {tagsVsbl && (
 	      <motion.div
 		  key="sptags"
-		  className="md:hidden overflow-hidden"
+		  className="md:hidden mt-4"
-		  initial={{ height: 0 }}
+		  variants={{ hidden:   { clipPath: 'inset(0 0 100% 0)',
-		  animate={{ height: 'auto' }}
+					  height:   0 },
-		  exit={{ height: 0 }}
+			      visible:  { clipPath: 'inset(0 0 0% 0)',
+					  height:   'auto'} }}
+		  initial="hidden"
+		  animate="visible"
+		  exit="hidden"
 		  transition={{ duration: .2, ease: 'easeOut' }}>
-		{posts.length > 0 && TagBlock}
+		{TagBlock}
 	      </motion.div>)}
 	</AnimatePresence>
 

frontend/src/components/TopNav.tsx

@@ -74,14 +74,11 @@ export default (({ user }: Props) => {
 	  { name: '履歴', to: '/posts/changes' },
 	  { name: 'ヘルプ', to: '/wiki/ヘルプ:広場' }] },
       { name: 'タグ', to: '/tags', subMenu: [
-	  { name: 'タグ一覧', to: '/tags', visible: true },
+	  { name: 'タグ一覧', to: '/tags', visible: false },
 	  { name: '別名タグ', to: '/tags/aliases', visible: false },
 	  { name: '上位タグ', to: '/tags/implications', visible: false },
 	  { name: 'ニコニコ連携', to: '/tags/nico' },
 	  { name: 'ヘルプ', to: '/wiki/ヘルプ:タグ' }] },
-      // TODO: 本実装時に消す．
-      // { name: '上映会', to: '/theatres/1', base: '/theatres', subMenu: [
-      //     { name: '一覧', to: '/theatres' }] },
       { name: 'Wiki', to: '/wiki/ヘルプ:ホーム', base: '/wiki', subMenu: [
 	  { name: '検索', to: '/wiki' },
 	  { name: '新規', to: '/wiki/new' },

frontend/src/components/common/Pagination.tsx

@@ -48,7 +48,7 @@ const getPages = (
 }
 
 
-export default (({ page, totalPages, siblingCount = 3 }) => {
+export default (({ page, totalPages, siblingCount = 4 }) => {
   const location = useLocation ()
 
   const buildTo = (p: number) => {
@@ -63,65 +63,19 @@ export default (({ page, totalPages, siblingCount = 3 }) => {
       <nav className="mt-4 flex justify-center" aria-label="Pagination">
 	<div className="flex items-center gap-2">
 	  {(page > 1)
-	   ? (
+	   ? <PrefetchLink to={buildTo (page - 1)} aria-label="前のページ">&lt;</PrefetchLink>
-	      <>
+	   : <span aria-hidden>&lt;</span>}
-		<PrefetchLink
-		    className="md:hidden p-2"
-		    to={buildTo (1)}
-		    aria-label="最初のページ">
-		  |&lt;
-		</PrefetchLink>
-		<PrefetchLink
-		    className="p-2"
-		    to={buildTo (page - 1)}
-		    aria-label="前のページ">
-		  &lt;
-		</PrefetchLink>
-	      </>)
-	   : (
-	      <>
-		<span className="md:hidden p-2" aria-hidden>
-		  |&lt;
-		</span>
-		<span className="p-2" aria-hidden>
-		  &lt;
-		</span>
-	      </>)}
 
 	  {pages.map ((p, idx) => (
 	      (p === '…')
-	      ? <span key={`dots-${ idx }`} className="hidden md:block p-2">…</span>
+	      ? <span key={`dots-${ idx }`}>…</span>
 	      : ((p === page)
-		 ? <span key={p} className="font-bold p-2" aria-current="page">{p}</span>
+		 ? <span key={p} className="font-bold" aria-current="page">{p}</span>
-		 : (
+		 : <PrefetchLink key={p} to={buildTo (p)}>{p}</PrefetchLink>)))}
-		    <PrefetchLink
-			key={p}
-			className="hidden md:block p-2"
-			to={buildTo (p)}>
-		      {p}
-		    </PrefetchLink>))))}
 
 	  {(page < totalPages)
-	   ? (
+	   ? <PrefetchLink to={buildTo (page + 1)} aria-label="次のページ">&gt;</PrefetchLink>
-	      <>
+	   : <span aria-hidden>&gt;</span>}
-		<PrefetchLink
-		    className="p-2"
-		    to={buildTo (page + 1)}
-		    aria-label="次のページ">
-		  &gt;
-		</PrefetchLink>
-		<PrefetchLink
-		    className="md:hidden p-2"
-		    to={buildTo (totalPages)}
-		    aria-label="最後のページ">
-		  &gt;|
-		</PrefetchLink>
-	      </>)
-	   : (
-	      <>
-		<span className="p-2" aria-hidden>&gt;</span>
-		<span className="md:hidden p-2" aria-hidden>&gt;|</span>
-	      </>)}
 	</div>
       </nav>)
 }) satisfies FC<Props>

frontend/src/consts.ts

@@ -13,16 +13,6 @@ export const CATEGORIES = [
     'nico',
     ] as const
 
-export const CATEGORY_NAMES: Record<Category, string> = {
-    deerjikist: 'ニジラー',
-    meme:       '原作・ネタ元・ミーム等',
-    character:  'キャラクター',
-    general:    '一般',
-    material:   '素材',
-    meta:       'メタタグ',
-    nico:       'ニコニコタグ',
-    } as const
-
 export const FETCH_POSTS_ORDER_FIELDS = [
     'title',
     'url',

frontend/src/lib/posts.ts

@@ -5,7 +5,7 @@ import type { FetchPostsParams, Post, PostTagChange } from '@/types'
 
 export const fetchPosts = async (
     { url, title, tags, match, createdFrom, createdTo, updatedFrom, updatedTo,
-      originalCreatedFrom, originalCreatedTo, page, limit, order }: FetchPostsParams,
+      originalCreatedFrom, originalCreatedTo, page, limit, order }: FetchPostsParams
 ): Promise<{
     posts:  Post[]
     count:  number }> =>
@@ -29,17 +29,14 @@ export const fetchPost = async (id: string): Promise<Post> => await apiGet (`/po
 
 
 export const fetchPostChanges = async (
-    { id, tag, page, limit }: {
+    { id, page, limit }: {
 	id?:    string
-	tag?:   string
 	page:   number
 	limit:  number },
 ): Promise<{
     changes:  PostTagChange[]
     count:    number }> =>
-	await apiGet ('/posts/changes', { params: { ...(id && { id }),
+	await apiGet ('/posts/changes', { params: { ...(id && { id }), page, limit } })
-						    ...(tag && { tag }),
-						    page, limit } })
 
 
 export const toggleViewedFlg = async (id: string, viewed: boolean): Promise<void> => {

frontend/src/lib/prefetchers.ts

@@ -3,12 +3,12 @@ import { match } from 'path-to-regexp'
 
 import { fetchPost, fetchPosts, fetchPostChanges } from '@/lib/posts'
 import { postsKeys, tagsKeys, wikiKeys } from '@/lib/queryKeys'
-import { fetchTagByName, fetchTag, fetchTags } from '@/lib/tags'
+import { fetchTagByName } from '@/lib/tags'
 import { fetchWikiPage,
 	 fetchWikiPageByTitle,
 	 fetchWikiPages } from '@/lib/wiki'
 
-import type { Category, FetchPostsOrder, FetchTagsOrder } from '@/types'
+import type { FetchPostsOrder } from '@/types'
 
 type Prefetcher = (qc: QueryClient, url: URL) => Promise<void>
 
@@ -122,50 +122,12 @@ const prefetchPostShow: Prefetcher = async (qc, url) => {
 
 const prefetchPostChanges: Prefetcher = async (qc, url) => {
   const id = url.searchParams.get ('id')
-  const tag = url.searchParams.get ('tag')
   const page = Number (url.searchParams.get ('page') || 1)
   const limit = Number (url.searchParams.get ('limit') || 20)
 
-  if (tag)
-    {
   await qc.prefetchQuery ({
-	  queryKey: tagsKeys.show (tag),
+      queryKey: postsKeys.changes ({ ...(id && { id }), page, limit }),
-	  queryFn: () => fetchTag (tag) })
+      queryFn:  () => fetchPostChanges ({ ...(id && { id }), page, limit }) })
-    }
-
-  await qc.prefetchQuery ({
-      queryKey: postsKeys.changes ({ ...(id && { id }),
-				     ...(tag && { tag }),
-				     page, limit }),
-      queryFn:  () => fetchPostChanges ({ ...(id && { id }),
-					  ...(tag && { tag }),
-					  page, limit }) })
-}
-
-
-const prefetchTagsIndex: Prefetcher = async (qc, url) => {
-  const postRaw = url.searchParams.get ('post')
-  const post = postRaw ? Number (postRaw) : null
-  const name = url.searchParams.get ('name') ?? ''
-  const category = (url.searchParams.get ('category') || null) as Category | null
-  const postCountGTE = Number (url.searchParams.get ('post_count_gte') || 1)
-  const postCountLTERaw = url.searchParams.get ('post_count_lte')
-  const postCountLTE = postCountLTERaw ? Number (postCountLTERaw) : null
-  const createdFrom = url.searchParams.get ('created_from') ?? ''
-  const createdTo = url.searchParams.get ('created_to') ?? ''
-  const updatedFrom = url.searchParams.get ('updated_from') ?? ''
-  const updatedTo = url.searchParams.get ('updated_to') ?? ''
-  const page = Number (url.searchParams.get ('page') || 1)
-  const limit = Number (url.searchParams.get ('limit') || 20)
-  const order = (url.searchParams.get ('order') ?? 'post_count:desc') as FetchTagsOrder
-
-  const keys = {
-      post, name, category, postCountGTE, postCountLTE, createdFrom, createdTo,
-      updatedFrom, updatedTo, page, limit, order }
-
-  await qc.prefetchQuery ({
-      queryKey: tagsKeys.index (keys),
-      queryFn:  () => fetchTags (keys) })
 }
 
 
@@ -179,8 +141,7 @@ export const routePrefetchers: { test: (u: URL) => boolean; run: Prefetcher }[]
     { test: u => u.pathname === '/wiki', run: prefetchWikiPagesIndex },
     { test: u => (!(['/wiki/new', '/wiki/changes'].includes (u.pathname))
 		  && Boolean (mWiki (u.pathname))),
-      run: prefetchWikiPageShow },
+      run: prefetchWikiPageShow }]
-    { test: u => u.pathname === '/tags', run: prefetchTagsIndex }]
 
 
 export const prefetchForURL = async (qc: QueryClient, urlLike: string): Promise<void> => {

frontend/src/lib/queryKeys.ts

@@ -1,16 +1,15 @@
-import type { FetchPostsParams, FetchTagsParams } from '@/types'
+import type { FetchPostsParams } from '@/types'
 
 export const postsKeys = {
     root:     ['posts'] as const,
     index:    (p: FetchPostsParams) => ['posts', 'index', p] as const,
     show:     (id: string) => ['posts', id] as const,
     related:  (id: string) => ['related', id] as const,
-    changes:  (p: { id?: string; tag?: string; page: number; limit: number }) =>
+    changes:  (p: { id?: string; page: number; limit: number }) =>
 		  ['posts', 'changes', p] as const }
 
 export const tagsKeys = {
     root: ['tags'] as const,
-    index:  (p: FetchTagsParams) => ['tags', 'index', p] as const,
     show: (name: string) => ['tags', name] as const }
 
 export const wikiKeys = {

frontend/src/lib/tags.ts

@@ -1,38 +1,6 @@
 import { apiGet } from '@/lib/api'
 
-import type { FetchTagsParams, Tag } from '@/types'
+import type { Tag } from '@/types'
-
-
-export const fetchTags = async (
-    { post, name, category, postCountGTE, postCountLTE, createdFrom, createdTo,
-      updatedFrom, updatedTo, page, limit, order }: FetchTagsParams,
-): Promise<{ tags:  Tag[]
-	     count: number }> =>
-    await apiGet ('/tags', { params: {
-	...(post != null && { post }),
-	...(name && { name }),
-	...(category && { category }),
-	...(postCountGTE != null && { post_count_gte: postCountGTE }),
-	...(postCountLTE != null && { post_count_lte: postCountLTE }),
-	...(createdFrom && { created_from: createdFrom }),
-	...(createdTo && { created_to: createdTo }),
-	...(updatedFrom && { updated_from: updatedFrom }),
-	...(updatedTo && { updated_to: updatedTo }),
-	...(page && { page }),
-	...(limit && { limit }),
-	...(order && { order }) } })
-
-
-export const fetchTag = async (id: string): Promise<Tag | null> => {
-  try
-  {
-    return await apiGet (`/tags/${ id }`)
-  }
-  catch
-  {
-    return null
-  }
-}
 
 
 export const fetchTagByName = async (name: string): Promise<Tag | null> => {

frontend/src/lib/utils.ts

@@ -10,64 +10,17 @@ export const toDate = (d: string | Date): Date => typeof d === 'string' ? new Da
 export const cn = (...inputs: ClassValue[]) => twMerge (clsx (...inputs))
 
 
-export const dateString = (
+export const dateString = (d: string | Date): string =>
-    d:        string | Date,
+    toDate (d).toLocaleString ('ja-JP-u-ca-japanese')
-    unknown:  'month' | 'day' | 'hour' | 'minute' | 'second' | null = null,
-): string =>
-    toDate (d).toLocaleString (
-	'ja-JP-u-ca-japanese',
-	{ era: 'long',
-	  year: 'numeric',
-	  month: (unknown === 'month' ? undefined : 'long'),
-	  day: unknown != null && ['month', 'day'].includes (unknown) ? undefined : 'numeric',
-	  weekday: unknown != null && ['month', 'day'].includes (unknown) ? undefined : 'short',
-	  hour: unknown == null || ['second', 'minute'].includes (unknown) ? 'numeric' : undefined,
-	  minute: unknown == null || unknown === 'second' ? 'numeric' : undefined,
-	  second: unknown == null ? 'numeric' : undefined })
 
 
+// TODO: 表示形式きしょすぎるので何とかする
 export const originalCreatedAtString = (
     f:  string | Date | null,
     b:  string | Date | null,
-): string => {
+): string =>
-  const from = f ? toDate (f) : null
+    ([f ? `${ dateString (f) } 以降` : '',
-  const before = b ? toDate (b) : null
+      b ? `${ dateString (b) } より前` : '']
-
-  if (from && before)
-    {
-      const diff = before.getTime () - from.getTime ()
-
-      if (diff <= 60_000 /* 1 分 */)
-	return dateString (from, 'second')
-
-      if (from.getMinutes () === 0 && before.getMinutes () === 0)
-	{
-	  if (Math.abs (diff - 3_600_000 /* 1 時間 */) < 60_000)
-	    return dateString (from, 'minute') + ' (分不詳)'
-
-	  if (from.getHours () === 0 && before.getHours () === 0)
-	    {
-	      if (Math.abs (diff - 86_400_000 /* 1 日 */) < 60_000)
-		return dateString (from, 'hour') + ' (時刻不詳)'
-
-	      if (from.getDate () === 1 && before.getDate () === 1)
-		{
-		  if (2_332_800_000 /* 27 日 */ < diff && diff < 2_764_800_000 /* 32 日 */)
-		    return dateString (from, 'day') + ' (日不詳)'
-
-		  if (from.getMonth () === 0 && before.getMonth () === 0
-		      && (31_449_600_000 /* 364 日 */ <= diff
-			  && diff < 31_708_800_000 /* 367 日 */))
-		    return dateString (from, 'month') + ' (月日不詳)'
-		}
-	    }
-	}
-    }
-
-  const rtn = ([from ? `${ dateString (from, 'second') }` : '',
-		'〜',
-		before ? `${ dateString (new Date (before.getTime () - 60_000), 'second') }` : '']
      .filter (Boolean)
      .join (' '))
-  return rtn === '〜' ? '年月日不詳' : rtn
+    || '不明'
-}

frontend/src/pages/posts/PostDetailPage.tsx

@@ -1,6 +1,6 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
 import { motion } from 'framer-motion'
-import { useEffect, useRef, useState } from 'react'
+import { useEffect, useState } from 'react'
 import { Helmet } from 'react-helmet-async'
 import { useParams } from 'react-router-dom'
 
@@ -14,14 +14,14 @@ import { Button } from '@/components/ui/button'
 import { toast } from '@/components/ui/use-toast'
 import { SITE_TITLE } from '@/config'
 import { fetchPost, toggleViewedFlg } from '@/lib/posts'
-import { postsKeys, tagsKeys } from '@/lib/queryKeys'
+import { postsKeys } from '@/lib/queryKeys'
 import { cn } from '@/lib/utils'
 import NotFound from '@/pages/NotFound'
 import ServiceUnavailable from '@/pages/ServiceUnavailable'
 
 import type { FC } from 'react'
 
-import type { NiconicoViewerHandle, User } from '@/types'
+import type { User } from '@/types'
 
 type Props = { user: User | null }
 
@@ -38,8 +38,6 @@ export default (({ user }: Props) => {
 
   const qc = useQueryClient ()
 
-  const embedRef = useRef<NiconicoViewerHandle> (null)
-
   const [status, setStatus] = useState (200)
 
   const changeViewedFlg = useMutation ({
@@ -101,7 +99,7 @@ export default (({ user }: Props) => {
 	</Helmet>
 
 	<div className="hidden md:block">
-	  {post && <TagDetailSidebar post={post}/>}
+	  <TagDetailSidebar post={post ?? null}/>
 	</div>
 
 	<MainArea className="relative">
@@ -122,10 +120,7 @@ export default (({ user }: Props) => {
 			   className="object-cover w-full h-full"/>
 		    </motion.div>)}
 
-		<PostEmbed
+		<PostEmbed post={post}/>
-		    ref={embedRef}
-		    post={post}
-		    onLoadComplete={() => embedRef.current?.play ()}/>
 		<Button onClick={() => changeViewedFlg.mutate ()}
 			disabled={changeViewedFlg.isPending}
 			className={cn ('text-white', viewedClass)}>
@@ -145,7 +140,6 @@ export default (({ user }: Props) => {
 			      qc.setQueryData (postsKeys.show (postId),
 					       (prev: any) => newPost ?? prev)
 			      qc.invalidateQueries ({ queryKey: postsKeys.root })
-			      qc.invalidateQueries ({ queryKey: tagsKeys.root })
 			      toast ({ description: '更新しました．' })
 			    }}/>
 		      </Tab>)}
@@ -155,7 +149,7 @@ export default (({ user }: Props) => {
 	</MainArea>
 
 	<div className="md:hidden">
-	  {post && <TagDetailSidebar post={post} sp/>}
+	  <TagDetailSidebar post={post ?? null}/>
 	</div>
       </div>)
 }) satisfies FC<Props>

frontend/src/pages/posts/PostHistoryPage.tsx

@@ -11,8 +11,7 @@ import Pagination from '@/components/common/Pagination'
 import MainArea from '@/components/layout/MainArea'
 import { SITE_TITLE } from '@/config'
 import { fetchPostChanges } from '@/lib/posts'
-import { postsKeys, tagsKeys } from '@/lib/queryKeys'
+import { postsKeys } from '@/lib/queryKeys'
-import { fetchTag } from '@/lib/tags'
 import { cn, dateString } from '@/lib/utils'
 
 import type { FC } from 'react'
@@ -22,26 +21,15 @@ export default (() => {
   const location = useLocation ()
   const query = new URLSearchParams (location.search)
   const id = query.get ('id')
-  const tagId = query.get ('tag')
   const page = Number (query.get ('page') ?? 1)
   const limit = Number (query.get ('limit') ?? 20)
 
   // 投稿列の結合で使用
   let rowsCnt: number
 
-  const { data: tag } =
-      tagId
-      ? useQuery ({ queryKey: tagsKeys.show (tagId),
-		    queryFn: () => fetchTag (tagId) })
-      : { data: null }
-
   const { data, isLoading: loading } = useQuery ({
-      queryKey: postsKeys.changes ({ ...(id && { id }),
+      queryKey: postsKeys.changes ({ ...(id && { id }), page, limit }),
-				     ...(tagId && { tag: tagId }),
+      queryFn:  () => fetchPostChanges ({ ...(id && { id }), page, limit }) })
-				     page, limit }),
-      queryFn:  () => fetchPostChanges ({ ...(id && { id }),
-					  ...(tagId && { tag: tagId }),
-					  page, limit }) })
   const changes = data?.changes ?? []
   const totalPages = data ? Math.ceil (data.count / limit) : 0
 
@@ -49,8 +37,6 @@ export default (() => {
     document.querySelector ('table')?.scrollIntoView ({ behavior: 'smooth' })
   }, [location.search])
 
-  const layoutIds: string[] = []
-
   return (
       <MainArea>
 	<Helmet>
@@ -60,7 +46,6 @@ export default (() => {
 	<PageTitle>
 	  耕作履歴
 	  {id && <>: 投稿 {<PrefetchLink to={`/posts/${ id }`}>#{id}</PrefetchLink>}</>}
-	  {tag && <>（<TagLink tag={tag} withWiki={false} withCount={false}/>）</>}
 	</PageTitle>
 
 	{loading ? 'Loading...' : (
@@ -75,7 +60,7 @@ export default (() => {
 		</thead>
 		<tbody>
 		  {changes.map ((change, i) => {
-		    const withPost = i === 0 || change.post.id !== changes[i - 1].post.id
+		    let withPost = i === 0 || change.post.id !== changes[i - 1].post.id
 		    if (withPost)
 		      {
 			rowsCnt = 1
@@ -85,15 +70,8 @@ export default (() => {
 			     ++j)
 			  ++rowsCnt
 		      }
-
-		    let layoutId: string | undefined = `page-${ change.post.id }`
-		    if (layoutIds.includes (layoutId))
-		      layoutId = undefined
-		    else
-		      layoutIds.push (layoutId)
-
 		    return (
-			<tr key={`${ change.timestamp }-${ change.post.id }-${ change.tag?.id }`}
+			<tr key={`${ change.timestamp }-${ change.post.id }-${ change.tag.id }`}
 			    className={cn ('even:bg-gray-100 dark:even:bg-gray-700',
 					   withPost && 'border-t')}>
 			  {withPost && (
@@ -101,14 +79,12 @@ export default (() => {
 				  rowSpan={rowsCnt}>
 				<PrefetchLink to={`/posts/${ change.post.id }`}>
 				  <motion.div
-				      layoutId={layoutId}
+				      layoutId={`page-${ change.post.id }`}
 				      transition={{ type: 'spring',
 						    stiffness: 500,
 						    damping: 40,
 						    mass: .5 }}>
-				    <img src={change.post.thumbnail
+				    <img src={change.post.thumbnail || change.post.thumbnailBase || undefined}
-					      || change.post.thumbnailBase
-					      || undefined}
 					 alt={change.post.title || change.post.url}
 					 title={change.post.title || change.post.url || undefined}
 					 className="w-40"/>
@@ -116,9 +92,7 @@ export default (() => {
 				</PrefetchLink>
 			      </td>)}
 			  <td className="p-2">
-			    {change.tag
+			    <TagLink tag={change.tag} withWiki={false} withCount={false}/>
-			     ? <TagLink tag={change.tag} withWiki={false} withCount={false}/>
-			     : '(マスタ削除済のタグ) '}
 			    {`を${ change.changeType === 'add' ? '記載' : '消除' }`}
 			  </td>
 			  <td className="p-2">

frontend/src/pages/posts/PostSearchPage.tsx

@@ -5,7 +5,6 @@ import { Helmet } from 'react-helmet-async'
 import { useLocation, useNavigate } from 'react-router-dom'
 
 import PrefetchLink from '@/components/PrefetchLink'
-import SortHeader from '@/components/SortHeader'
 import TagLink from '@/components/TagLink'
 import TagSearchBox from '@/components/TagSearchBox'
 import DateTimeField from '@/components/common/DateTimeField'
@@ -103,6 +102,28 @@ export default (() => {
     document.querySelector ('table')?.scrollIntoView ({ behavior: 'smooth' })
   }, [location.search])
 
+  const SortHeader = ({ by, label }: { by: FetchPostsOrderField; label: string }) => {
+    const [fld, dir] = order.split (':')
+
+    const qs = new URLSearchParams (location.search)
+    const nextDir =
+	(by === fld)
+	? (dir === 'asc' ? 'desc' : 'asc')
+	: (['title', 'url'].includes (by) ? 'asc' : 'desc')
+    qs.set ('order', `${ by }:${ nextDir }`)
+    qs.set ('page', '1')
+
+    return (
+	<PrefetchLink
+	    className="text-inherit visited:text-inherit hover:text-inherit"
+	    to={`${ location.pathname }?${ qs.toString () }`}>
+	  <span className="font-bold">
+	    {label}
+	    {by === fld && (dir === 'asc' ? ' ▲' : ' ▼')}
+	  </span>
+	</PrefetchLink>)
+  }
+
   // TODO: TagSearch からのコピペのため，共通化を考へる．
   const whenChanged = async (ev: ChangeEvent<HTMLInputElement>) => {
     setTagsStr (ev.target.value)
@@ -167,7 +188,7 @@ export default (() => {
     setIf (qs, 'updated_from', updatedFrom)
     setIf (qs, 'updated_to', updatedTo)
     qs.set ('match', matchType)
-    qs.set ('page', '1')
+    qs.set ('page', String ('1'))
     qs.set ('order', order)
     navigate (`${ location.pathname }?${ qs.toString () }`)
   }
@@ -186,12 +207,6 @@ export default (() => {
     search ()
   }
 
-  const defaultDirection = { title: 'asc',
-			     url: 'asc',
-			     original_created_at: 'desc',
-			     created_at: 'desc',
-			     updated_at: 'desc' } as const
-
   return (
       <MainArea>
 	<Helmet>
@@ -324,46 +339,26 @@ export default (() => {
 		    <tr>
 		      <th className="p-2 text-left whitespace-nowrap">投稿</th>
 		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchPostsOrderField>
+			<SortHeader by="title" label="タイトル"/>
-			    by="title"
-			    label="タイトル"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
 		      </th>
 		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchPostsOrderField>
+			<SortHeader by="url" label="URL"/>
-			    by="url"
-			    label="URL"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
 		      </th>
 		      <th className="p-2 text-left whitespace-nowrap">タグ</th>
 		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchPostsOrderField>
+			<SortHeader by="original_created_at" label="オリジナルの投稿日時"/>
-			    by="original_created_at"
-			    label="オリジナルの投稿日時"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
 		      </th>
 		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchPostsOrderField>
+			<SortHeader by="created_at" label="投稿日時"/>
-			    by="created_at"
-			    label="投稿日時"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
 		      </th>
 		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchPostsOrderField>
+			<SortHeader by="updated_at" label="更新日時"/>
-			    by="updated_at"
-			    label="更新日時"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
 		      </th>
 		    </tr>
 		  </thead>
 		  <tbody>
 		    {results.map (row => (
-			<tr key={row.id} className="even:bg-gray-100 dark:even:bg-gray-700">
+			<tr key={row.id} className={'even:bg-gray-100 dark:even:bg-gray-700'}>
 			  <td className="p-2">
 			    <PrefetchLink to={`/posts/${ row.id }`} title={row.title}>
 			      <motion.div

frontend/src/pages/tags/TagListPage.tsx

@@ -1,282 +0,0 @@
-import { useQuery } from '@tanstack/react-query'
-import { useEffect, useMemo, useState } from 'react'
-import { Helmet } from 'react-helmet-async'
-import { useLocation, useNavigate } from 'react-router-dom'
-
-import PrefetchLink from '@/components/PrefetchLink'
-import SortHeader from '@/components/SortHeader'
-import TagLink from '@/components/TagLink'
-import DateTimeField from '@/components/common/DateTimeField'
-import Label from '@/components/common/Label'
-import PageTitle from '@/components/common/PageTitle'
-import Pagination from '@/components/common/Pagination'
-import MainArea from '@/components/layout/MainArea'
-import { SITE_TITLE } from '@/config'
-import { CATEGORIES, CATEGORY_NAMES } from '@/consts'
-import { tagsKeys } from '@/lib/queryKeys'
-import { fetchTags } from '@/lib/tags'
-import { dateString } from '@/lib/utils'
-
-import type { FC, FormEvent } from 'react'
-
-import type { Category, FetchTagsOrder, FetchTagsOrderField } from '@/types'
-
-
-const setIf = (qs: URLSearchParams, k: string, v: string | null) => {
-  const t = v?.trim ()
-  if (t)
-    qs.set (k, t)
-}
-
-
-export default (() => {
-  const location = useLocation ()
-
-  const navigate = useNavigate ()
-
-  const query = useMemo (() => new URLSearchParams (location.search), [location.search])
-
-  const page = Number (query.get ('page') ?? 1)
-  const limit = Number (query.get ('limit') ?? 20)
-
-  const qName = query.get ('name') ?? ''
-  const qCategory = (query.get ('category') || null) as Category | null
-  const qPostCountGTE = Number (query.get ('post_count_gte') ?? 1)
-  const qPostCountLTERaw = query.get ('post_count_lte')
-  const qPostCountLTE = qPostCountLTERaw ? Number (qPostCountLTERaw) : null
-  const qCreatedFrom = query.get ('created_from') ?? ''
-  const qCreatedTo = query.get ('created_to') ?? ''
-  const qUpdatedFrom = query.get ('updated_from') ?? ''
-  const qUpdatedTo = query.get ('updated_to') ?? ''
-  const order = (query.get ('order') || 'post_count:desc') as FetchTagsOrder
-
-  const [name, setName] = useState ('')
-  const [category, setCategory] = useState<Category | null> (null)
-  const [postCountGTE, setPostCountGTE] = useState (1)
-  const [postCountLTE, setPostCountLTE] = useState<number | null> (null)
-  const [createdFrom, setCreatedFrom] = useState<string | null> (null)
-  const [createdTo, setCreatedTo] = useState<string | null> (null)
-  const [updatedFrom, setUpdatedFrom] = useState<string | null> (null)
-  const [updatedTo, setUpdatedTo] = useState<string | null> (null)
-
-  const keys = {
-      page, limit, order,
-      post: null,
-      name: qName,
-      category: qCategory,
-      postCountGTE: qPostCountGTE,
-      postCountLTE: qPostCountLTE,
-      createdFrom: qCreatedFrom,
-      createdTo: qCreatedTo,
-      updatedFrom: qUpdatedFrom,
-      updatedTo: qUpdatedTo }
-  const { data, isLoading: loading } = useQuery ({
-      queryKey: tagsKeys.index (keys),
-      queryFn: () => fetchTags (keys) })
-  const results = data?.tags ?? []
-  const totalPages = data ? Math.ceil (data.count / limit) : 0
-
-  useEffect (() => {
-    setName (qName)
-    setCategory (qCategory)
-    setPostCountGTE (qPostCountGTE)
-    setPostCountLTE (qPostCountLTE)
-    setCreatedFrom (qCreatedFrom)
-    setCreatedTo (qCreatedTo)
-    setUpdatedFrom (qUpdatedFrom)
-    setUpdatedTo (qUpdatedTo)
-
-    document.querySelector ('table')?.scrollIntoView ({ behavior: 'smooth' })
-  }, [location.search])
-
-  const handleSearch = (e: FormEvent) => {
-    e.preventDefault ()
-
-    const qs = new URLSearchParams ()
-    setIf (qs, 'name', name)
-    setIf (qs, 'category', category)
-    if (postCountGTE !== 1)
-      qs.set ('post_count_gte', String (postCountGTE))
-    if (postCountLTE != null)
-      qs.set ('post_count_lte', String (postCountLTE))
-    setIf (qs, 'created_from', createdFrom)
-    setIf (qs, 'created_to', createdTo)
-    setIf (qs, 'updated_from', updatedFrom)
-    setIf (qs, 'updated_to', updatedTo)
-    qs.set ('page', '1')
-    qs.set ('order', order)
-
-    navigate (`${ location.pathname }?${ qs.toString () }`)
-  }
-
-  const defaultDirection = { name: 'asc',
-			     category: 'asc',
-			     post_count: 'desc',
-			     created_at: 'desc',
-			     updated_at: 'desc' } as const
-
-  return (
-      <MainArea>
-	<Helmet>
-	  <title>タグ | {SITE_TITLE}</title>
-	</Helmet>
-
-	<div className="max-w-xl">
-	  <PageTitle>タグ</PageTitle>
-
-	  <form onSubmit={handleSearch} className="space-y-2">
-	    {/* 名前 */}
-	    <div>
-	      <Label>名前</Label>
-	      <input
-		  type="text"
-		  value={name}
-		  onChange={e => setName (e.target.value)}
-		  className="w-full border p-2 rounded"/>
-	    </div>
-
-	    {/* カテゴリ */}
-	    <div>
-	      <Label>カテゴリ</Label>
-	      <select
-		  value={category ?? ''}
-		  onChange={e => setCategory((e.target.value || null) as Category | null)}
-		  className="w-full border p-2 rounded">
-		<option value="">&nbsp;</option>
-		{CATEGORIES.map (cat => (
-		    <option key={cat} value={cat}>
-		      {CATEGORY_NAMES[cat]}
-		    </option>))}
-	      </select>
-	    </div>
-
-	    {/* 広場の投稿数 */}
-	    <div>
-	      <Label>広場の投稿数</Label>
-	      <input
-		  type="number"
-		  min="0"
-		  value={postCountGTE < 0 ? 0 : String (postCountGTE)}
-		  onChange={e => setPostCountGTE (Number (e.target.value || 0))}
-		  className="border rounded p-2"/>
-	      <span className="mx-1">〜</span>
-	      <input
-		  type="number"
-		  min="0"
-		  value={postCountLTE == null ? '' : String (postCountLTE)}
-		  onChange={e => setPostCountLTE (e.target.value ? Number (e.target.value) : null)}
-		  className="border rounded p-2"/>
-	    </div>
-
-	    {/* はじめて記載された日時 */}
-	    <div>
-	      <Label>はじめて記載された日時</Label>
-	      <DateTimeField
-		  value={createdFrom ?? undefined}
-		  onChange={setCreatedFrom}/>
-	      <span className="mx-1">〜</span>
-	      <DateTimeField
-		  value={createdTo ?? undefined}
-		  onChange={setCreatedTo}/>
-	    </div>
-
-	    {/* 定義の更新日時 */}
-	    <div>
-	      <Label>定義の更新日時</Label>
-	      <DateTimeField
-		  value={updatedFrom ?? undefined}
-		  onChange={setUpdatedFrom}/>
-	      <span className="mx-1">〜</span>
-	      <DateTimeField
-		  value={updatedTo ?? undefined}
-		  onChange={setUpdatedTo}/>
-	    </div>
-
-	    <div className="py-3">
-	      <button
-		  type="submit"
-		  className="bg-blue-500 text-white px-4 py-2 rounded">
-		検索
-	      </button>
-	    </div>
-	  </form>
-	</div>
-
-	{loading ? 'Loading...' : (results.length > 0 ? (
-	    <div className="mt-4">
-	      <div className="overflow-x-auto">
-		<table className="w-full min-w-[1200px] table-fixed border-collapse">
-		  <colgroup>
-		    <col className="w-72"/>
-		    <col className="w-48"/>
-		    <col className="w-16"/>
-		    <col className="w-44"/>
-		    <col className="w-44"/>
-		    <col className="w-16"/>
-		  </colgroup>
-
-		  <thead className="border-b-2 border-black dark:border-white">
-		    <tr>
-		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchTagsOrderField>
-			    by="name"
-			    label="タグ"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
-		      </th>
-		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchTagsOrderField>
-			    by="category"
-			    label="カテゴリ"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
-		      </th>
-		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchTagsOrderField>
-			    by="post_count"
-			    label="件数"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
-		      </th>
-		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchTagsOrderField>
-			    by="created_at"
-			    label="最初の記載日時"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
-		      </th>
-		      <th className="p-2 text-left whitespace-nowrap">
-			<SortHeader<FetchTagsOrderField>
-			    by="updated_at"
-			    label="更新日時"
-			    currentOrder={order}
-			    defaultDirection={defaultDirection}/>
-		      </th>
-		      <th className="p-2 text-left whitespace-nowrap"/>
-		    </tr>
-		  </thead>
-
-		  <tbody>
-		    {results.map (row => (
-			<tr key={row.id} className="even:bg-gray-100 dark:even:bg-gray-700">
-			  <td className="p-2">
-			    <TagLink tag={row} withCount={false}/>
-			  </td>
-			  <td className="p-2">{CATEGORY_NAMES[row.category]}</td>
-			  <td className="p-2 text-right">{row.postCount}</td>
-			  <td className="p-2">{dateString (row.createdAt)}</td>
-			  <td className="p-2">{dateString (row.updatedAt)}</td>
-			  <td className="p-2">
-			    <PrefetchLink to={`/posts/changes?tag=${ row.id }`}>
-			      耕作履歴
-			    </PrefetchLink>
-			  </td>
-			</tr>))}
-		  </tbody>
-		</table>
-	      </div>
-
-	      <Pagination page={page} totalPages={totalPages}/>
-	    </div>) : '結果ないよ（笑）')}
-      </MainArea>)
-}) satisfies FC

frontend/src/pages/theatres/TheatreDetailPage.tsx

@@ -1,114 +0,0 @@
-import { useEffect, useRef, useState } from 'react'
-import { Helmet } from 'react-helmet-async'
-import { useParams } from 'react-router-dom'
-
-import PostEmbed from '@/components/PostEmbed'
-import MainArea from '@/components/layout/MainArea'
-import { SITE_TITLE } from '@/config'
-import { apiGet, apiPatch, apiPut } from '@/lib/api'
-import { fetchPost } from '@/lib/posts'
-
-import type { FC } from 'react'
-
-import type { NiconicoMetadata, NiconicoViewerHandle, Post, Theatre } from '@/types'
-
-type TheatreInfo = {
-    hostFlg:        boolean
-    postId:         number | null
-    postStartedAt:  string | null }
-
-
-export default (() => {
-  const { id } = useParams ()
-
-  const embedRef = useRef<NiconicoViewerHandle> (null)
-
-  const [loading, setLoading] = useState (false)
-  const [theatre, setTheatre] = useState<Theatre | null> (null)
-  const [theatreInfo, setTheatreInfo] =
-      useState<TheatreInfo> ({ hostFlg: false, postId: null, postStartedAt: null })
-  const [post, setPost] = useState<Post | null> (null)
-  const [videoLength, setVideoLength] = useState (9_999_999_999)
-
-  useEffect (() => {
-    if (!(id))
-      return
-
-    void (async () => {
-      setTheatre (await apiGet<Theatre> (`/theatres/${ id }`))
-    }) ()
-
-    const interval = setInterval (async () => {
-      if (theatreInfo.hostFlg
-	  && theatreInfo.postStartedAt
-	  && ((new Date).getTime () - (new Date (theatreInfo.postStartedAt)).getTime ()
-	      > videoLength))
-	setTheatreInfo ({ hostFlg: true, postId: null, postStartedAt: null })
-      else
-	setTheatreInfo (await apiPut<TheatreInfo> (`/theatres/${ id }/watching`))
-    }, 1_000)
-
-    return () => clearInterval (interval)
-  }, [id, theatreInfo.hostFlg, theatreInfo.postStartedAt, videoLength])
-
-  useEffect (() => {
-    if (!(theatreInfo.hostFlg) || loading)
-      return
-
-    if (theatreInfo.postId == null)
-      {
-	void (async () => {
-	  setLoading (true)
-	  await apiPatch<void> (`/theatres/${ id }/next_post`)
-	  setLoading (false)
-	}) ()
-	return
-      }
-  }, [id, loading, theatreInfo.hostFlg, theatreInfo.postId])
-
-  useEffect (() => {
-    if (theatreInfo.postId == null)
-      return
-
-    void (async () => {
-      setPost (await fetchPost (String (theatreInfo.postId)))
-    }) ()
-  }, [theatreInfo.postId, theatreInfo.postStartedAt])
-
-  const syncPlayback = (meta: NiconicoMetadata) => {
-    if (!(theatreInfo.postStartedAt))
-      return
-
-    const targetTime =
-	((new Date).getTime () - (new Date (theatreInfo.postStartedAt)).getTime ())
-
-    const drift = Math.abs (meta.currentTime - targetTime)
-
-    if (drift > 5_000)
-      embedRef.current?.seek (targetTime)
-  }
-
-  return (
-      <MainArea>
-	<Helmet>
-	  {theatre && (
-	      <title>
-		{'上映会場'
-		 + (theatre.name ? `『${ theatre.name }』` : ` #${ theatre.id }`)
-		 + ` | ${ SITE_TITLE }`}
-	      </title>)}
-	</Helmet>
-
-	{post && (
-	    <PostEmbed
-		ref={embedRef}
-		post={post}
-		onLoadComplete={info => {
-		  embedRef.current?.play ()
-		  setVideoLength (info.lengthInSeconds * 1_000)
-		}}
-		onMetadataChange={meta => {
-		  syncPlayback (meta)
-		}}/>)}
-      </MainArea>)
-}) satisfies FC

frontend/src/types.ts

@@ -26,29 +26,6 @@ export type FetchPostsParams = {
     limit:                number
     order:                FetchPostsOrder }
 
-export type FetchTagsOrder = `${ FetchTagsOrderField }:${ 'asc' | 'desc' }`
-
-export type FetchTagsOrderField =
-    | 'name'
-    | 'category'
-    | 'post_count'
-    | 'created_at'
-    | 'updated_at'
-
-export type FetchTagsParams = {
-    post:         number | null
-    name:         string
-    category:     Category | null
-    postCountGTE: number
-    postCountLTE: number | null
-    createdFrom:  string
-    createdTo:    string
-    updatedFrom:  string
-    updatedTo:    string
-    page:         number
-    limit:        number
-    order:        FetchTagsOrder }
-
 export type Menu = MenuItem[]
 
 export type MenuItem = {
@@ -61,37 +38,6 @@ export type NicoTag = Tag & {
     category:   'nico'
     linkedTags: Tag[] }
 
-export type NiconicoMetadata = {
-    currentTime:            number
-    duration:               number
-    isVideoMetaDataLoaded:  boolean
-    maximumBuffered:        number
-    muted:                  boolean
-    showComment:            boolean
-    volume:                 number }
-
-export type NiconicoVideoInfo = {
-    title:            string
-    videoId:          string
-    lengthInSeconds:  number
-    thumbnailUrl:     string
-    description:      string
-    viewCount:        number
-    commentCount:     number
-    mylistCount:      number
-    postedAt:         string
-    watchId:          number }
-
-export type NiconicoViewerHandle = {
-    play:         () => void
-    pause:        () => void
-    seek:         (time: number) => void
-    mute:         () => void
-    unmute:       () => void
-    setVolume:    (volume: number) => void
-    showComments: () => void
-    hideComments: () => void }
-
 export type Post = {
     id:                     number
     url:                    string
@@ -104,13 +50,12 @@ export type Post = {
     originalCreatedFrom:    string | null
     originalCreatedBefore:  string | null
     createdAt:              string
-    updatedAt:              string
+    updatedAt:              string }
-    uploadedUser:           { id: number; name: string } | null }
 
 export type PostTagChange = {
     post:       Post
-    tag:        Tag | null
+    tag:        Tag
-    user:       User | null
+    user?:      User
     changeType: 'add' | 'remove'
     timestamp:  string }
 
@@ -126,21 +71,10 @@ export type Tag = {
     name:           string
     category:       Category
     postCount:      number
-    createdAt:      string
-    updatedAt:      string
     hasWiki:        boolean
     children?:      Tag[]
     matchedAlias?:  string | null }
 
-export type Theatre = {
-    id:             number
-    name:           string | null
-    opensAt:        string
-    closesAt:       string | null
-    createdByUser:  { id: number; name: string }
-    createdAt:      string
-    updatedAt:      string }
-
 export type User = {
     id:               number
     name:             string | null

frontend/vite.config.ts

@@ -10,7 +10,7 @@ export default defineConfig ({
     server:   { host:         true,
 		port:         5173,
 		strictPort:   true,
-		allowedHosts: ['hub.nizika.monster', 'localhost', 'nico-dev.test'],
+		allowedHosts: ['hub.nizika.monster', 'localhost'],
 		proxy:        { '/api': { target:       'http://localhost:3002',
 					  changeOrigin: true,
 					  secure:       false } },