#297

#295

#295

#295

#295

#295

#295

#295

Co-authored-by: miteruzo <miteruzo@naver.com>
Reviewed-on: #296

backend/app/controllers/posts_controller.rb

@@ -245,19 +245,41 @@ class PostsController < ApplicationController
   end
 
   def filter_posts_by_tags tag_names, match_type
-    tag_names = TagName.canonicalise(tag_names)
+    literals = tag_names.map do |raw_name|
+      { name: TagName.canonicalise(raw_name.sub(/\Anot:/i, '')).first,
+        negative: raw_name.downcase.start_with?('not:') }
+    end
 
-    posts = Post.joins(tags: :tag_name)
+    return Post.all if literals.empty?
 
     if match_type == 'any'
-      posts.where(tag_names: { name: tag_names }).distinct
+      literals.reduce(Post.none) do |posts, literal|
+        posts.or(tag_literal_relation(literal[:name], negative: literal[:negative]))
+      end
     else
-      posts.where(tag_names: { name: tag_names })
-           .group('posts.id')
-           .having('COUNT(DISTINCT tag_names.id) = ?', tag_names.uniq.size)
+      literals.reduce(Post.all) do |posts, literal|
+        ids = tagged_post_ids_for(literal[:name])
+        if literal[:negative]
+          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|
       t.save! if t.new_record?

backend/app/controllers/tags_controller.rb

@@ -17,8 +17,7 @@ class TagsController < ApplicationController
   end
 
   def autocomplete
-    q = params[:q].to_s.strip
-    return render json: [] if q.blank?
+    q = params[:q].to_s.strip.sub(/\Anot:/i, '')
 
     with_nico = bool?(:nico, default: true)
     present_only = bool?(:present, default: true)

backend/app/controllers/theatre_comments_controller.rb

@@ -0,0 +1,32 @@
+class TheatreCommentsController < ApplicationController
+  def index
+    no_gt = params[:no_gt].to_i
+    no_gt = 0 if no_gt.negative?
+
+    comments = TheatreComment
+               .where(theatre_id: params[:theatre_id])
+               .where('no > ?', no_gt)
+               .order(:no)
+
+    render json: comments.as_json(include: { user: { only: [:id, :name] } })
+  end
+
+  def create
+    return head :unauthorized unless current_user
+
+    content = params[:content]
+    return head :unprocessable_entity if content.blank?
+
+    theatre = Theatre.find_by(id: params[:theatre_id])
+    return head :not_found unless theatre
+
+    comment = nil
+    theatre.with_lock do
+      no = theatre.next_comment_no
+      comment = TheatreComment.create!(theatre:, no:, user: current_user, content:)
+      theatre.update!(next_comment_no: no + 1)
+    end
+
+    render json: comment, status: :created
+  end
+end

backend/app/controllers/theatres_controller.rb

@@ -0,0 +1,52 @@
+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_or_create_by!(name:)
+    tag_name = TagName.find_undiscard_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

@@ -0,0 +1,20 @@
+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,8 +1,12 @@
 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'
@@ -130,10 +134,10 @@ class Tag < ApplicationRecord
   end
 
   def self.find_or_create_by_tag_name! name, category:
-    tn = TagName.find_or_create_by!(name: name.to_s.strip)
+    tn = TagName.find_undiscard_or_create_by!(name: name.to_s.strip)
     tn = tn.canonical if tn.canonical_id?
 
-    Tag.find_or_create_by!(tag_name_id: tn.id) do |t|
+    Tag.find_undiscard_or_create_by!(tag_name_id: tn.id) do |t|
       t.category = category
     end
   rescue ActiveRecord::RecordNotUnique
@@ -144,25 +148,33 @@ class Tag < ApplicationRecord
     target_tag => Tag
 
     Tag.transaction do
-      Array(source_tags).compact.uniq.each do |st|
-        st => Tag
+      Array(source_tags).compact.uniq.each do |source_tag|
+        source_tag => Tag
 
-        next if st == target_tag
+        next if source_tag == target_tag
 
-        st.post_tags.find_each do |pt|
-          if PostTag.kept.exists?(post_id: pt.post_id, tag_id: target_tag.id)
-            pt.discard_by!(nil)
-            # discard 後の update! は禁止なので DB を直に更新
-            pt.update_columns(tag_id: target_tag.id, updated_at: Time.current)
-          else
-            pt.update!(tag: target_tag)
+        source_tag.post_tags.kept.find_each do |source_pt|
+          post_id = source_pt.post_id
+          source_pt.discard_by!(nil)
+          unless PostTag.kept.exists?(post_id:, tag: target_tag)
+            PostTag.create!(post_id:, tag: target_tag)
           end
         end
 
-        tag_name = st.tag_name
-        st.destroy!
-        tag_name.reload
-        tag_name.update!(canonical: target_tag.tag_name)
+        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,
+                                         updated_at: Time.current)
+        end
       end
 
       # 投稿件数を再集計

backend/app/models/tag_name.rb

@@ -1,4 +1,8 @@
 class TagName < ApplicationRecord
+  include MyDiscard
+
+  default_scope -> { kept }
+
   has_one :tag
   has_one :wiki_page
 
@@ -10,6 +14,7 @@ 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?)
@@ -39,4 +44,10 @@ 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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,13 @@
+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

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

backend/app/models/theatre_watching_user.rb

@@ -0,0 +1,13 @@
+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,6 +2,10 @@ 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/theatre_repr.rb

@@ -0,0 +1,17 @@
+# 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/config/routes.rb

@@ -72,4 +72,13 @@ Rails.application.routes.draw do
       end
     end
   end
+
+  resources :theatres, only: [:show] do
+    member do
+      put :watching
+      patch :next_post
+    end
+
+    resources :comments, controller: :theatre_comments, only: [:index, :create]
+  end
 end

backend/db/migrate/20260309123200_create_tag_name_sanitisation_rules.rb

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,12 @@
+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_03_122700) do
+ActiveRecord::Schema[8.0].define(version: 2026_03_17_015000) 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,12 +127,24 @@ ActiveRecord::Schema[8.0].define(version: 2026_03_03_122700) 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
 
@@ -150,9 +162,58 @@ ActiveRecord::Schema[8.0].define(version: 2026_03_03_122700) 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
@@ -192,7 +253,9 @@ ActiveRecord::Schema[8.0].define(version: 2026_03_03_122700) 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
@@ -246,6 +309,13 @@ ActiveRecord::Schema[8.0].define(version: 2026_03_03_122700) 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 = "nico:#{ raw }"
+        name = TagNameSanitisationRule.sanitise("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,12 +1,22 @@
 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 }
-      tag_name { association(:tag_name, name: "nico:#{ SecureRandom.hex(4) }") }
+      transient do
+        name { "nico:#{ SecureRandom.hex(4) }" }
+      end
     end
   end
 end

backend/spec/factories/theatre_comments.rb

@@ -0,0 +1,8 @@
+FactoryBot.define do
+  factory :theatre_comment do
+    association :theatre
+    association :user
+    sequence (:no) { |n| n }
+    content { 'test comment' }
+  end
+end

backend/spec/factories/theatres.rb

@@ -0,0 +1,11 @@
+FactoryBot.define do
+  factory :theatre do
+    name { 'Test Theatre' }
+    kind { 1 }
+    opens_at { Time.current }
+    closes_at { 1.day.from_now }
+    next_comment_no { 1 }
+
+    association :created_by_user, factory: :user
+  end
+end

backend/spec/models/tag_name_sanitisation_rule_spec.rb

@@ -0,0 +1,101 @@
+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,20 +2,31 @@ require 'rails_helper'
 
 RSpec.describe Tag, type: :model do
   describe '.merge_tags!' do
-    let!(:target_tag) { create(:tag) }
-    let!(:source_tag) { create(:tag) }
+    let!(:target_tag) { create(:tag, category: :general) }
+    let!(:source_tag) { create(:tag, category: :general) }
+    let!(:source_tag_name) { source_tag.tag_name }
 
-    let!(:post_record) { Post.create!(url: 'https://example.com/posts/1', title: 'test post') }
+    let!(:post_record) do
+      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 'moves the post_tag, deletes the source tag, and aliases the source tag_name' do
+      it 'discards the source post_tag, creates an active target post_tag, discards the source tag, and aliases the source tag_name' do
         described_class.merge_tags!(target_tag, [source_tag])
 
-        expect(source_post_tag.reload.tag_id).to eq(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)
+        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)
+
+        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
 
@@ -23,38 +34,84 @@ 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 duplicate source post_tag and keeps one active target post_tag' do
+      it 'discards the source post_tag, keeps one active target post_tag, discards 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)
         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(discarded_source.discarded_at).to be_present
-        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(active.first.id).to eq(target_post_tag.id)
+
+        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
 
     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 tag in source_tags' do
+      it 'ignores the target in source_tags while still merging the source tag' do
         described_class.merge_tags!(target_tag, [source_tag, target_tag])
 
-        expect(Tag.exists?(target_tag.id)).to be(true)
-        expect(Tag.exists?(source_tag.id)).to be(false)
-        expect(source_post_tag.reload.tag_id).to eq(target_tag.id)
+        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)
+
+        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 aliasing the source tag_name is invalid' do
+    context 'when the source tag_name is invalid under sanitisation rules' 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.tag_name,
-            created_user: create_admin_user!,
-            updated_user: create_admin_user!)
+          tag_name: source_tag_name,
+          created_user: create_admin_user!,
+          updated_user: create_admin_user!
+        )
       end
 
       it 'rolls back the transaction' do
@@ -62,9 +119,30 @@ RSpec.describe Tag, type: :model do
           described_class.merge_tags!(target_tag, [source_tag])
         }.to raise_error(ActiveRecord::RecordInvalid)
 
-        expect(Tag.exists?(source_tag.id)).to be(true)
-        expect(source_post_tag.reload.tag_id).to eq(source_tag.id)
-        expect(source_tag.tag_name.reload.canonical_id).to be_nil
+        expect(Tag.with_discarded.find(source_tag.id)).not_to be_discarded
+        expect(TagName.with_discarded.find(source_tag_name.id)).not_to be_discarded
+        expect(PostTag.kept.find(source_post_tag.id).tag_id).to eq(source_tag.id)
+        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,6 +116,123 @@ 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',
@@ -408,8 +525,9 @@ RSpec.describe 'Posts API', type: :request do
 
     context "when nico tag already exists in tags" do
       before do
-        Tag.find_or_create_by!(tag_name: TagName.find_or_create_by!(name: 'nico:nico_tag'),
-                               category: 'nico')
+        Tag.find_undiscard_or_create_by!(
+            tag_name: TagName.find_undiscard_or_create_by!(name: 'nico:nico_tag'),
+            category: :nico)
       end
 
       it 'return 400' do
@@ -475,7 +593,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',
@@ -493,8 +611,9 @@ RSpec.describe 'Posts API', type: :request do
 
     context "when nico tag already exists in tags" do
       before do
-        Tag.find_or_create_by!(tag_name: TagName.find_or_create_by!(name: 'nico:nico_tag'),
-                               category: 'nico')
+        Tag.find_undiscard_or_create_by!(
+            tag_name: TagName.find_undiscard_or_create_by!(name: 'nico:nico_tag'),
+            category: :nico)
       end
 
       it 'return 400' do
@@ -531,7 +650,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)

backend/spec/requests/theatre_comments_spec.rb

@@ -0,0 +1,150 @@
+require 'rails_helper'
+
+RSpec.describe 'TheatreComments', type: :request do
+  def sign_in_as(user)
+    allow_any_instance_of(ApplicationController).to receive(:current_user).and_return(user)
+  end
+
+  describe 'GET /theatres/:theatre_id/comments' do
+    let(:theatre) { create(:theatre) }
+    let(:other_theatre) { create(:theatre) }
+    let(:alice) { create(:user, name: 'Alice') }
+    let(:bob) { create(:user, name: 'Bob') }
+
+    let!(:comment_3) do
+      create(
+        :theatre_comment,
+        theatre: theatre,
+        no: 3,
+        user: alice,
+        content: 'third comment'
+      )
+    end
+
+    let!(:comment_1) do
+      create(
+        :theatre_comment,
+        theatre: theatre,
+        no: 1,
+        user: alice,
+        content: 'first comment'
+      )
+    end
+
+    let!(:comment_2) do
+      create(
+        :theatre_comment,
+        theatre: theatre,
+        no: 2,
+        user: bob,
+        content: 'second comment'
+      )
+    end
+
+    let!(:other_comment) do
+      create(
+        :theatre_comment,
+        theatre: other_theatre,
+        no: 1,
+        user: bob,
+        content: 'other theatre comment'
+      )
+    end
+
+    it 'theatre_id で絞り込み、no_gt より大きいものを no 昇順で返す' do
+      get "/theatres/#{theatre.id}/comments", params: { no_gt: 1 }
+
+      expect(response).to have_http_status(:ok)
+      expect(response.parsed_body.map { |row| row['no'] }).to eq([2, 3])
+      expect(response.parsed_body.map { |row| row['content'] }).to eq([
+        'second comment',
+        'third comment'
+      ])
+    end
+
+    it 'user は id と name だけを含む' do
+      get "/theatres/#{theatre.id}/comments", params: { no_gt: 1 }
+
+      expect(response).to have_http_status(:ok)
+
+      expect(response.parsed_body.first['user']).to eq({
+        'id' => bob.id,
+        'name' => 'Bob'
+      })
+      expect(response.parsed_body.first['user'].keys).to contain_exactly('id', 'name')
+    end
+
+    it 'no_gt が負数なら 0 として扱う' do
+      get "/theatres/#{theatre.id}/comments", params: { no_gt: -100 }
+
+      expect(response).to have_http_status(:ok)
+      expect(response.parsed_body.map { |row| row['no'] }).to eq([1, 2, 3])
+    end
+  end
+
+  describe 'POST /theatres/:theatre_id/comments' do
+    let(:user) { create(:user, name: 'Alice') }
+    let(:theatre) { create(:theatre, next_comment_no: 2) }
+
+    before do
+      create(
+        :theatre_comment,
+        theatre: theatre,
+        no: 1,
+        user: user,
+        content: 'existing comment'
+      )
+    end
+
+    it '未ログインなら 401 を返す' do
+      expect {
+        post "/theatres/#{theatre.id}/comments", params: { content: 'hello' }
+      }.not_to change(TheatreComment, :count)
+
+      expect(response).to have_http_status(:unauthorized)
+    end
+
+    it 'content が blank なら 422 を返す' do
+      sign_in_as(user)
+
+      expect {
+        post "/theatres/#{theatre.id}/comments", params: { content: '   ' }
+      }.not_to change(TheatreComment, :count)
+
+      expect(response).to have_http_status(:unprocessable_entity)
+    end
+
+    it 'theatre が存在しなければ 404 を返す' do
+      sign_in_as(user)
+
+      expect {
+        post '/theatres/999999/comments', params: { content: 'hello' }
+      }.not_to change(TheatreComment, :count)
+
+      expect(response).to have_http_status(:not_found)
+    end
+
+    it 'コメントを作成し、user を紐づけ、next_comment_no を進める' do
+      sign_in_as(user)
+
+      expect {
+        post "/theatres/#{theatre.id}/comments", params: { content: 'new comment' }
+      }.to change(TheatreComment, :count).by(1)
+
+      expect(response).to have_http_status(:created)
+
+      comment = TheatreComment.find_by!(theatre: theatre, no: 2)
+
+      expect(comment.user).to eq(user)
+      expect(comment.content).to eq('new comment')
+      expect(theatre.reload.next_comment_no).to eq(3)
+
+      expect(response.parsed_body.slice('theatre_id', 'no', 'user_id', 'content')).to eq({
+        'theatre_id' => theatre.id,
+        'no' => 2,
+        'user_id' => user.id,
+        'content' => 'new comment'
+      })
+    end
+  end
+end

backend/spec/requests/theatres_spec.rb

@@ -0,0 +1,289 @@
+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_or_create_by!(name: name.to_s.strip)
-    Tag.find_or_create_by!(tag_name_id: tn.id) { |t| t.category = category }
+    tn = TagName.find_undiscard_or_create_by!(name: name.to_s.strip)
+    Tag.find_undiscard_or_create_by!(tag_name_id: tn.id) { |t| t.category = category }
   end
 
   def link_nico_to_tag!(nico_tag, tag)

frontend/src/App.tsx

@@ -19,6 +19,7 @@ import PostNewPage from '@/pages/posts/PostNewPage'
 import PostSearchPage from '@/pages/posts/PostSearchPage'
 import ServiceUnavailable from '@/pages/ServiceUnavailable'
 import SettingPage from '@/pages/users/SettingPage'
+import TheatreDetailPage from '@/pages/theatres/TheatreDetailPage'
 import WikiDetailPage from '@/pages/wiki/WikiDetailPage'
 import WikiDiffPage from '@/pages/wiki/WikiDiffPage'
 import WikiEditPage from '@/pages/wiki/WikiEditPage'
@@ -47,6 +48,7 @@ const RouteTransitionWrapper = ({ user, setUser }: {
 	    <Route path="/posts/:id" element={<PostDetailRoute user={user}/>}/>
 	    <Route path="/posts/changes" element={<PostHistoryPage/>}/>
 	    <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/NicoViewer.tsx

@@ -1,78 +1,204 @@
-import { useRef, useLayoutEffect, useEffect, useState } from 'react'
-type Props = { id:      string,
-	       width:   number,
-	       height:  number,
-	       style?:  CSSProperties }
+import { forwardRef,
+         useCallback,
+         useEffect,
+         useImperativeHandle,
+         useLayoutEffect,
+         useMemo,
+         useRef,
+         useState } from 'react'
 
-import type { CSSProperties, FC } from 'react'
+import type { CSSProperties, ForwardedRef } 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 ((props: Props) => {
-  const { id, width, height, style = { } } = props
+export default forwardRef ((props: Props, ref: ForwardedRef<NiconicoViewerHandle>) => {
+  const { id, width, height, style = { }, onLoadComplete, onMetadataChange } = 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 = `https://embed.nicovideo.jp/watch/${id}?persistence=1&oldScript=1&referer=&from=0&allowProgrammaticFullScreen=1`;
+  const src =
+      `${ EMBED_ORIGIN }/watch/${ id }`
+      + '?jsapi=1'
+      + `&playerId=${ encodeURIComponent (playerId) }`
+      + '&persistence=1'
+      + '&oldScript=1'
+      + '&referer='
+      + '&from=0'
+      + '&allowProgrammaticFullScreen=1'
 
-  const styleFullScreen: CSSProperties = fullScreen ? {
-      top:  0,
-      left: landscape ? 0 : '100%',
-      position: 'fixed',
-      width: screenWidth,
-      height: screenHeight,
-      zIndex: 2147483647,
-      maxWidth: 'none',
-      transformOrigin: '0% 0%',
-      transform: landscape ? 'none' : 'rotate(90deg)',
-      WebkitTransformOrigin: '0% 0%',
-      WebkitTransform: landscape ? 'none' : 'rotate(90deg)' } : {};
+  const styleFullScreen: CSSProperties =
+      fullScreen
+      ? { top: 0,
+          left: landscape ? 0 : '100%',
+          position: 'fixed',
+          width: screenWidth,
+          height: screenHeight,
+          zIndex: 2_147_483_647,
+          maxWidth: 'none',
+          transformOrigin: '0% 0%',
+          transform: landscape ? 'none' : 'rotate(90deg)',
+          WebkitTransformOrigin: '0% 0%',
+          WebkitTransform: landscape ? 'none' : 'rotate(90deg)' }
+      : { }
 
-  const margedStyle = {
-      border:   'none',
-      maxWidth: '100%',
-      ...style,
-      ...styleFullScreen }
+  const margedStyle: CSSProperties =
+      { border: 'none', maxWidth: '100%', ...style, ...styleFullScreen }
+
+  const postToPlayer = useCallback ((message: NiconicoCommand) => {
+    const win = iframeRef.current?.contentWindow
+    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<any>) => {
+    const onMessage = (event: MessageEvent<NiconicoPlayerMessage>) => {
       if (!(iframeRef.current)
-	  || (event.source !== iframeRef.current.contentWindow))
-	return
+          || (event.source !== iframeRef.current.contentWindow)
+          || (event.origin !== EMBED_ORIGIN))
+        return
 
-      if (event.data.eventName === 'enterProgrammaticFullScreen')
-	setFullScreen (true)
-      else if (event.data.eventName === 'exitProgrammaticFullScreen')
-	setFullScreen (false)
+      const data = event.data
+
+      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
+	}
+
+      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(() => {
+  useLayoutEffect (() => {
     if (!(fullScreen))
       return
 
     const initialScrollX = scrollX
     const initialScrollY = scrollY
-    let timer: NodeJS.Timeout
+    let timer: ReturnType<typeof setTimeout>
     let ended = false
 
     const pollingResize = () => {
       if (ended)
-	return
+        return
 
-      const landscape = innerWidth >= innerHeight
-      const windowWidth = `${landscape ? innerWidth : innerHeight}px`
-      const windowHeight = `${landscape ? innerHeight : innerWidth}px`
+      const isLandscape = innerWidth >= innerHeight
+      const windowWidth = `${ isLandscape ? innerWidth : innerHeight }px`
+      const windowHeight = `${ isLandscape ? innerHeight : innerWidth }px`
 
-      setLandscape (landscape)
+      setLandscape (isLandscape)
       setScreenWidth (windowWidth)
       setScreenHeight (windowHeight)
       timer = setTimeout (startPollingResize, 200)
@@ -80,9 +206,9 @@ export default ((props: Props) => {
 
     const startPollingResize = () => {
       if (requestAnimationFrame)
-	requestAnimationFrame (pollingResize)
+        requestAnimationFrame (pollingResize)
       else
-	pollingResize ()
+        pollingResize ()
     }
 
     startPollingResize ()
@@ -97,15 +223,17 @@ export default ((props: Props) => {
   useEffect (() => {
     if (!(fullScreen))
       return
+
     scrollTo (0, 0)
   }, [screenWidth, screenHeight, fullScreen])
 
   return (
-      <iframe ref={iframeRef}
-	      src={src}
-	      width={width}
-	      height={height}
-	      style={margedStyle}
-	      allowFullScreen
-	      allow="autoplay"/>)
-}) satisfies FC<Props>
+      <iframe
+	  ref={iframeRef}
+	  src={src}
+	  width={width}
+	  height={height}
+	  style={margedStyle}
+	  allowFullScreen
+	  allow="autoplay"/>)
+})

frontend/src/components/PostEmbed.tsx

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

frontend/src/components/TagSearch.tsx

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

frontend/src/components/TopNav.tsx

@@ -79,6 +79,11 @@ export default (({ user }: Props) => {
 	  { name: '上位タグ', to: '/tags/implications', visible: false },
 	  { name: 'ニコニコ連携', to: '/tags/nico' },
 	  { name: 'ヘルプ', to: '/wiki/ヘルプ:タグ' }] },
+      { name: '上映会', to: '/theatres/1', base: '/theatres', subMenu: [
+          { name: <>第&thinsp;1&thinsp;会場</>, to: '/theatres/1' },
+          { name: 'CyTube', to: '//cytube.mm428.net/r/deernijika' },
+	  { name: <>ニジカ放送局第&thinsp;1&thinsp;チャンネル</>,
+	    to: '//www.youtube.com/watch?v=DCU3hL4Uu6A' }] },
       { name: 'Wiki', to: '/wiki/ヘルプ:ホーム', base: '/wiki', subMenu: [
 	  { name: '検索', to: '/wiki' },
 	  { name: '新規', to: '/wiki/new' },
@@ -89,7 +94,7 @@ export default (({ user }: Props) => {
 	    visible: wikiPageFlg },
 	  { name: '履歴', to: `/wiki/changes?id=${ wikiId }`, visible: wikiPageFlg },
 	  { name: '編輯', to: `/wiki/${ wikiId || wikiTitle }/edit`, visible: wikiPageFlg }] },
-      { name: 'ユーザ', to: '/users', subMenu: [
+      { name: 'ユーザ', to: '/users/settings', subMenu: [
 	  { name: '一覧', to: '/users', visible: false },
 	  { name: 'お前', to: `/users/${ user?.id }`, visible: false },
 	  { name: '設定', to: '/users/settings', visible: Boolean (user) }] }]

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, useState } from 'react'
+import { useEffect, useRef, useState } from 'react'
 import { Helmet } from 'react-helmet-async'
 import { useParams } from 'react-router-dom'
 
@@ -21,7 +21,7 @@ import ServiceUnavailable from '@/pages/ServiceUnavailable'
 
 import type { FC } from 'react'
 
-import type { User } from '@/types'
+import type { NiconicoViewerHandle, User } from '@/types'
 
 type Props = { user: User | null }
 
@@ -38,6 +38,8 @@ export default (({ user }: Props) => {
 
   const qc = useQueryClient ()
 
+  const embedRef = useRef<NiconicoViewerHandle> (null)
+
   const [status, setStatus] = useState (200)
 
   const changeViewedFlg = useMutation ({
@@ -120,7 +122,10 @@ export default (({ user }: Props) => {
 			   className="object-cover w-full h-full"/>
 		    </motion.div>)}
 
-		<PostEmbed post={post}/>
+		<PostEmbed
+		    ref={embedRef}
+		    post={post}
+		    onLoadComplete={() => embedRef.current?.play ()}/>
 		<Button onClick={() => changeViewedFlg.mutate ()}
 			disabled={changeViewedFlg.isPending}
 			className={cn ('text-white', viewedClass)}>

frontend/src/pages/posts/PostHistoryPage.tsx

@@ -37,6 +37,8 @@ export default (() => {
     document.querySelector ('table')?.scrollIntoView ({ behavior: 'smooth' })
   }, [location.search])
 
+  const layoutIds: string[] = []
+
   return (
       <MainArea>
 	<Helmet>
@@ -60,7 +62,7 @@ export default (() => {
 		</thead>
 		<tbody>
 		  {changes.map ((change, i) => {
-		    let withPost = i === 0 || change.post.id !== changes[i - 1].post.id
+		    const withPost = i === 0 || change.post.id !== changes[i - 1].post.id
 		    if (withPost)
 		      {
 			rowsCnt = 1
@@ -70,8 +72,15 @@ 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 && (
@@ -79,12 +88,14 @@ export default (() => {
 				  rowSpan={rowsCnt}>
 				<PrefetchLink to={`/posts/${ change.post.id }`}>
 				  <motion.div
-				      layoutId={`page-${ change.post.id }`}
+				      layoutId={layoutId}
 				      transition={{ type: 'spring',
 						    stiffness: 500,
 						    damping: 40,
 						    mass: .5 }}>
-				    <img src={change.post.thumbnail || change.post.thumbnailBase || undefined}
+				    <img src={change.post.thumbnail
+					      || change.post.thumbnailBase
+					      || undefined}
 					 alt={change.post.title || change.post.url}
 					 title={change.post.title || change.post.url || undefined}
 					 className="w-40"/>
@@ -92,7 +103,9 @@ export default (() => {
 				</PrefetchLink>
 			      </td>)}
 			  <td className="p-2">
-			    <TagLink tag={change.tag} withWiki={false} withCount={false}/>
+			    {change.tag
+			     ? <TagLink tag={change.tag} withWiki={false} withCount={false}/>
+			     : '(マスタ削除済のタグ) '}
 			    {`を${ change.changeType === 'add' ? '記載' : '消除' }`}
 			  </td>
 			  <td className="p-2">

frontend/src/pages/theatres/TheatreDetailPage.tsx

@@ -0,0 +1,319 @@
+import { useEffect, useRef, useState } from 'react'
+import { Helmet } from 'react-helmet-async'
+import { useParams } from 'react-router-dom'
+
+import PostEmbed from '@/components/PostEmbed'
+import PrefetchLink from '@/components/PrefetchLink'
+import TagDetailSidebar from '@/components/TagDetailSidebar'
+import MainArea from '@/components/layout/MainArea'
+import SidebarComponent from '@/components/layout/SidebarComponent'
+import { SITE_TITLE } from '@/config'
+import { apiGet, apiPatch, apiPost, apiPut } from '@/lib/api'
+import { fetchPost } from '@/lib/posts'
+import { dateString } from '@/lib/utils'
+
+import type { FC } from 'react'
+
+import type { NiconicoMetadata,
+	      NiconicoViewerHandle,
+	      Post,
+	      Theatre,
+	      TheatreComment } from '@/types'
+
+type TheatreInfo = {
+    hostFlg:        boolean
+    postId:         number | null
+    postStartedAt:  string | null }
+
+const INITIAL_THEATRE_INFO = { hostFlg: false, postId: null, postStartedAt: null } as const
+
+
+export default (() => {
+  const { id } = useParams ()
+
+  const commentsRef = useRef<HTMLDivElement> (null)
+  const embedRef = useRef<NiconicoViewerHandle> (null)
+  const theatreInfoRef = useRef<TheatreInfo> (INITIAL_THEATRE_INFO)
+  const videoLengthRef = useRef (0)
+  const lastCommentNoRef = useRef (0)
+
+  const [comments, setComments] = useState<TheatreComment[]> ([])
+  const [content, setContent] = useState ('')
+  const [loading, setLoading] = useState (false)
+  const [sending, setSending] = useState (false)
+  const [theatre, setTheatre] = useState<Theatre | null> (null)
+  const [theatreInfo, setTheatreInfo] = useState<TheatreInfo> (INITIAL_THEATRE_INFO)
+  const [post, setPost] = useState<Post | null> (null)
+  const [videoLength, setVideoLength] = useState (0)
+
+  useEffect (() => {
+    theatreInfoRef.current = theatreInfo
+  }, [theatreInfo])
+
+  useEffect (() => {
+    videoLengthRef.current = videoLength
+  }, [videoLength])
+
+  useEffect (() => {
+    lastCommentNoRef.current = comments.at (-1)?.no ?? 0
+  }, [comments])
+
+  useEffect (() => {
+    if (!(id))
+      return
+
+    let cancelled = false
+
+    setComments ([])
+    setTheatre (null)
+    setPost (null)
+    setTheatreInfo (INITIAL_THEATRE_INFO)
+    setVideoLength (0)
+    lastCommentNoRef.current = 0
+
+    void (async () => {
+      try
+      {
+	const data = await apiGet<Theatre> (`/theatres/${ id }`)
+	if (!(cancelled))
+	  setTheatre (data)
+      }
+      catch (error)
+      {
+	console.error (error)
+      }
+    }) ()
+
+    return () => {
+      cancelled = true
+    }
+  }, [id])
+
+  useEffect (() => {
+    commentsRef.current?.scrollTo ({
+	top: commentsRef.current.scrollHeight,
+	behavior: 'smooth' })
+  }, [commentsRef])
+
+  useEffect (() => {
+    if (!(id))
+      return
+
+    let cancelled = false
+    let running = false
+
+    const tick = async () => {
+      if (running)
+	return
+
+      running = true
+
+      try
+      {
+	const newComments = await apiGet<TheatreComment[]> (
+	    `/theatres/${ id }/comments`,
+	    { params: { no_gt: lastCommentNoRef.current } })
+
+	if (!(cancelled) && newComments.length > 0)
+	  {
+	    lastCommentNoRef.current = newComments[newComments.length - 1].no
+	    setComments (prev => [...prev, ...newComments])
+	  }
+
+	const currentInfo = theatreInfoRef.current
+	const ended =
+	    currentInfo.hostFlg
+	    && currentInfo.postStartedAt
+	    && ((Date.now () - (new Date (currentInfo.postStartedAt)).getTime ())
+	        > videoLengthRef.current + 3_000)
+
+	if (ended)
+	  {
+	    if (!(cancelled))
+	      setTheatreInfo (prev => ({ ...prev, postId: null, postStartedAt: null }))
+
+	    return
+	  }
+
+	const nextInfo = await apiPut<TheatreInfo> (`/theatres/${ id }/watching`)
+	if (!(cancelled))
+	  setTheatreInfo (nextInfo)
+      }
+      catch (error)
+      {
+	console.error (error)
+      }
+      finally
+      {
+	running = false
+      }
+    }
+
+    tick ()
+    const interval = setInterval (() => tick (), 1_500)
+
+    return () => {
+      cancelled = true
+      clearInterval (interval)
+    }
+  }, [id])
+
+  useEffect (() => {
+    if (!(id) || !(theatreInfo.hostFlg) || loading || theatreInfo.postId != null)
+      return
+
+    let cancelled = false
+
+    void (async () => {
+      setLoading (true)
+
+      try
+      {
+	await apiPatch<void> (`/theatres/${ id }/next_post`)
+      }
+      catch (error)
+      {
+	console.error (error)
+      }
+      finally
+      {
+	if (!(cancelled))
+	  setLoading (false)
+      }
+    }) ()
+
+    return () => {
+      cancelled = true
+    }
+  }, [id, theatreInfo.hostFlg, theatreInfo.postId])
+
+  useEffect (() => {
+    setVideoLength (0)
+
+    if (theatreInfo.postId == null)
+      return
+
+    let cancelled = false
+
+    void (async () => {
+      try
+      {
+	const nextPost = await fetchPost (String (theatreInfo.postId))
+	if (!(cancelled))
+	  setPost (nextPost)
+      }
+      catch (error)
+      {
+	console.error (error)
+      }
+    }) ()
+
+    return () => {
+      cancelled = true
+    }
+  }, [theatreInfo.postId])
+
+  const syncPlayback = (meta: NiconicoMetadata) => {
+    if (!(theatreInfo.postStartedAt))
+      return
+
+    const targetTime = Math.min (
+	Math.max (0, Date.now () - (new Date (theatreInfo.postStartedAt)).getTime ()),
+	videoLength)
+
+    const drift = Math.abs (meta.currentTime - targetTime)
+
+    if (drift > 5_000)
+      embedRef.current?.seek (targetTime)
+  }
+
+  return (
+      <div className="md:flex md:flex-1">
+	<Helmet>
+	  {theatre && (
+	      <title>
+		{'上映会場'
+		 + (theatre.name ? `『${ theatre.name }』` : ` #${ theatre.id }`)
+		 + ` | ${ SITE_TITLE }`}
+	      </title>)}
+	</Helmet>
+
+	<div className="hidden md:block">
+	  <TagDetailSidebar post={post ?? null}/>
+	</div>
+
+	<MainArea>
+	  {post ? (
+	      <>
+		<PostEmbed
+		    key={post.id}
+		    ref={embedRef}
+		    post={post}
+		    onLoadComplete={info => {
+		      embedRef.current?.play ()
+		      setVideoLength (info.lengthInSeconds * 1_000)
+		    }}
+		    onMetadataChange={syncPlayback}/>
+		<div className="m-2">
+		  <>再生中：</>
+		  <PrefetchLink to={`/posts/${ post.id }`} className="font-bold">
+		    {post.title || post.url}
+		  </PrefetchLink>
+		</div>
+	      </>) : 'Loading...'}
+	</MainArea>
+
+	<SidebarComponent>
+	  <form
+	      className="w-full h-5/6"
+	      onSubmit={async e => {
+		e.preventDefault ()
+
+		if (!(content))
+		  return
+
+		try
+		{
+		  setSending (true)
+		  await apiPost (`/theatres/${ id }/comments`, { content })
+		  setContent ('')
+		  commentsRef.current?.scrollTo ({
+		      top: commentsRef.current.scrollHeight,
+		      behavior: 'smooth' })
+		}
+		finally
+		{
+		  setSending (false)
+		}
+	      }}>
+	    <div
+		ref={commentsRef}
+		className="overflow-x-hidden overflow-y-scroll text-wrap
+			   border border-black dark:border-white w-full h-[80vh]">
+	      {comments.map (comment => (
+		  <div key={comment.no} className="p-2">
+		    <div className="w-full">
+		      {comment.content}
+		    </div>
+		    <div className="w-full text-sm text-right">
+		      by {comment.user ? (comment.user.name || '名もなきニジラー') : '運営'}
+		    </div>
+		    <div className="w-full text-sm text-right">
+		      {dateString (comment.createdAt)}
+		    </div>
+		  </div>))}
+	    </div>
+	    <input
+		className="w-full p-2 border border-black dark:border-white"
+		type="text"
+		value={content}
+		onChange={e => setContent (e.target.value)}
+		disabled={sending}/>
+	  </form>
+	</SidebarComponent>
+
+	<div className="md:hidden">
+	  <TagDetailSidebar post={post ?? null}/>
+	</div>
+      </div>)
+}) satisfies FC

frontend/src/types.ts

@@ -29,7 +29,7 @@ export type FetchPostsParams = {
 export type Menu = MenuItem[]
 
 export type MenuItem = {
-    name:     string
+    name:     ReactNode
     to:       string
     base?:    string
     subMenu:  SubMenuItem[] }
@@ -38,6 +38,37 @@ 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
@@ -54,15 +85,15 @@ export type Post = {
 
 export type PostTagChange = {
     post:       Post
-    tag:        Tag
-    user?:      User
+    tag:        Tag | null
+    user:       User | null
     changeType: 'add' | 'remove'
     timestamp:  string }
 
 export type SubMenuItem =
     | { component:  ReactNode
 	visible:    boolean }
-    | { name:     string
+    | { name:     ReactNode
 	to:       string
 	visible?: boolean }
 
@@ -75,6 +106,22 @@ export type Tag = {
     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 TheatreComment = {
+    theatreId:  number,
+    no:         number,
+    user:       { id: number, name: string } | null
+    content:    string
+    createdAt:  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'],
+		allowedHosts: ['hub.nizika.monster', 'localhost', 'nico-dev.test'],
 		proxy:        { '/api': { target:       'http://localhost:3002',
 					  changeOrigin: true,
 					  secure:       false } },