#306

backend/AGENTS.md

@@ -67,192 +67,6 @@ pass or the remaining failure is clearly blocked.
 Before changing behavior, inspect the matching route, controller, model,
 service, representation, and spec.
 
-## Shared backend systems
-
-Before adding backend behaviour, search the existing backend first. At minimum,
-check these locations:
-
-- `app/controllers`
-- `app/controllers/concerns`
-- `app/models`
-- `app/models/concerns`
-- `app/representations`
-- `app/services`
-- `app/services/*`
-- `app/jobs`
-- `lib`
-- `lib/tasks`
-- `config/initializers`
-
-Do not infer commonality from directory names alone. Read the actual
-responsibility and representative usage sites.
-
-### Controller reuse
-
-Before adding logic to a controller, inspect:
-
-- `ApplicationController` authentication, authorization, BAN, and IP BAN
-- existing render and validation-error helpers
-- existing param parsing
-- controller concerns
-- the controller for the same resource
-- existing services
-- existing representations
-
-Keep controllers focused on:
-
-- authentication and authorization
-- parameter intake
-- service and model invocation
-- HTTP status selection
-- representation selection
-
-Do not reimplement these per controller when an existing path already owns
-them:
-
-- authentication and role checks
-- validation error JSON
-- URL normalisation
-- tag normalisation
-- thumbnail handling
-- version recording
-- complex transactions
-- external HTTP fetching
-- response representation assembly
-
-### Authentication, authorization, and BAN
-
-Treat these as the canonical backend entrypoints:
-
-- `ApplicationController#authenticate_user`
-- `current_user`
-- `X-Transfer-Code`
-- `reject_banned_ip_address!`
-- `reject_banned_user!`
-- `gte_member?`
-- `admin?`
-
-Do not create feature-local permission services, role comparisons, or header
-parsing when the existing authentication boundary already owns the behaviour.
-If the current boundary is insufficient, extend it minimally instead of adding
-another permission path.
-
-### Representations
-
-If an endpoint for the same resource already uses `app/representations`, do not
-assemble a separate JSON shape directly inside the controller without first
-checking the existing representation contract.
-
-Inspect at least:
-
-- `PostRepr`
-- `TagRepr`
-- `MaterialRepr`
-- `TheatreRepr`
-- `UserRepr`
-- `WikiPageRepr`
-- `DeerjikistRepr`
-
-When a lightweight response is genuinely different in purpose, keep it
-deliberate and compatible with the surrounding contracts. Do not force every
-identifier list into a large representation, but do not fork the same resource
-shape casually either.
-
-### Domain services
-
-When work touches multiple models, transactions, external APIs, file handling,
-history creation, or multi-step workflow, search `app/services` first.
-
-At minimum, search for existing services in these responsibility areas:
-
-- version recorder and versioning
-- wiki commit
-- YouTube or Google Drive API client
-- material sync or ZIP export
-- similarity calculation
-- theatre selection or skip finalisation
-- metadata, thumbnail, or file processing
-- URL normaliser or sanitisation
-- import or export
-- preview safety or HTTP fetch
-
-Do not create a same-responsibility service under another namespace or another
-name. If an existing service is close, extend that API minimally instead of
-wrapping it in a feature-local service.
-
-### Versioning
-
-When a feature writes history, snapshots, or restore roots, search the existing
-versioning path first. At minimum, inspect:
-
-- `VersionRecorder`
-- `PostVersionRecorder`
-- `TagVersionRecorder`
-- `TagVersioning`
-- `MaterialVersionRecorder`
-- `NicoTagVersionRecorder`
-- `WikiVersionRecorder`
-
-Do not implement history writes in controllers, callbacks, or ad hoc feature
-services when the recorder layer already owns the transaction boundary and
-meaning.
-
-### Normalisation, sanitisation, and parsing
-
-For URLs, tag names, times, video durations, identifiers, and paths, search the
-existing normaliser, sanitisation rule, parser, and model-callback path first.
-
-Do not let frontend, controller, service, and model each invent different rules
-for the same value. Use one canonical normalisation path and keep input
-validation distinct from pre-persistence normalisation.
-
-### External HTTP and URL safety
-
-When fetching external URLs, reuse the existing preview-safety stack. Search at
-least for:
-
-- URL safety
-- redirect validation
-- response size limits
-- timeouts
-- network failure mapping
-- HTML metadata extraction
-- known-site extraction
-- thumbnail fetching
-
-Do not add direct `Net::HTTP`, `Faraday`, or equivalent feature-local HTTP code
-that reimplements SSRF checks, redirect restrictions, size limits, or timeouts.
-If the current fetcher is insufficient, extend its existing safety contract.
-
-### Storage, files, and Active Storage
-
-When handling files, thumbnails, ZIP output, object storage, or Active Storage
-blobs, inspect existing storage helpers, exporters, thumbnail generators, and
-checksum helpers first. Do not reimplement the same attach, export path,
-download, resize, or checksum flow in a controller or one-off service.
-
-### Concerns
-
-Do not create controller or model concerns merely because some code is shared.
-Use a concern only when multiple classes share the same lifecycle, macro,
-callback, or tightly cohesive behaviour. Utility collections belong in explicit
-objects or services, not in `CommonConcern`, `SharedMethods`, or `Utils`.
-
-### Model boundaries
-
-Model-specific invariants, associations, validations, and normalisation may
-live in the model. Multi-model workflow, external access, complex transaction
-flow, and feature orchestration belong in services. Do not hide feature
-workflow in model callbacks.
-
-### Transactions, locking, and race handling
-
-If transactions, locking, idempotency, or race recovery already exist in a
-service or model method, do not add a second implementation in a controller or
-new service. Inspect the existing transaction boundary first, avoid wrapping
-the same operation in needless nested transactions, and handle unique-constraint
-races according to the target constraint's business meaning.
-
 ## Ruby style
 
 - Prefer precise, minimal changes.

backend/app/controllers/materials_controller.rb

@@ -89,13 +89,15 @@ class MaterialsController < ApplicationController
 
     begin
       Material.transaction do
-        tag = resolve_material_tag!(tag_name_raw)
+        tag_name = TagName.find_undiscard_or_create_by!(name: tag_name_raw)
+        tag = tag_name.tag
+        tag = Tag.create!(tag_name:, category: :material) unless tag
+
         material = Material.new(tag:, url:,
                                 created_by_user: current_user,
                                 updated_by_user: current_user)
         material.file.attach(uploaded_blob) if uploaded_blob
         material.save!
-        TagVersioning.record_tag_snapshot!(tag, created_by_user: current_user)
         upsert_export_paths!(material)
         MaterialVersionRecorder.record!(material:, event_type: :create,
                                         created_by_user: current_user)
@@ -137,7 +139,10 @@ class MaterialsController < ApplicationController
     begin
       Material.transaction do
         MaterialVersionRecorder.ensure_snapshot!(material, created_by_user: current_user)
-        tag = resolve_material_tag!(tag_name_raw)
+        tag_name = TagName.find_undiscard_or_create_by!(name: tag_name_raw)
+        tag = tag_name.tag
+        tag = Tag.create!(tag_name:, category: :material) unless tag
+
         material.assign_attributes(tag:, url:, updated_by_user: current_user)
         if uploaded_blob
           material.file.attach(uploaded_blob)
@@ -145,7 +150,6 @@ class MaterialsController < ApplicationController
           material.file.detach
         end
         material.save!
-        TagVersioning.record_tag_snapshot!(tag, created_by_user: current_user)
         upsert_export_paths!(material)
         MaterialVersionRecorder.record!(material:, event_type: :update,
                                         created_by_user: current_user)
@@ -236,12 +240,6 @@ class MaterialsController < ApplicationController
     nil
   end
 
-  def resolve_material_tag! tag_name_raw
-    tag_name = TagName.find_undiscard_or_create_by!(name: tag_name_raw)
-    tag = tag_name.tag
-    tag || Tag.create!(tag_name:, category: :material)
-  end
-
   def material_index_needs_tag_name? filters
     filters[:q].present? || filters[:sort] == 'tag_name'
   end

backend/app/controllers/post_versions_controller.rb

@@ -25,7 +25,6 @@ class PostVersionsController < ApplicationController
         SQL
         .select('post_versions.*', 'prev.title AS prev_title', 'prev.url AS prev_url',
                 'prev.thumbnail_base AS prev_thumbnail_base', 'prev.tags AS prev_tags',
-                'prev.video_ms AS prev_video_ms',
                 'prev.original_created_from AS prev_original_created_from',
                 'prev.original_created_before AS prev_original_created_before')
     q = q.where('post_versions.post_id = ?', post_id) if post_id
@@ -75,10 +74,6 @@ class PostVersionsController < ApplicationController
           current: row.thumbnail_base,
           prev: row.attributes['prev_thumbnail_base']
         },
-        video_ms: {
-          current: row.video_ms,
-          prev: row.attributes['prev_video_ms']
-        },
         tags: build_version_tags(cur_tags, prev_tags),
         original_created_from: {
           current: row.original_created_from&.iso8601,

backend/app/controllers/posts_controller.rb

@@ -1,10 +1,5 @@
 class PostsController < ApplicationController
   Event = Struct.new(:post, :tag, :user, :change_type, :timestamp, keyword_init: true)
-  MAX_BULK_REQUEST_BYTES = 40 * 1024 * 1024
-
-  class VideoMsParseError < ArgumentError
-    ;
-  end
 
   def index
     url = params[:url].presence
@@ -50,9 +45,7 @@ class PostsController < ApplicationController
         .joins("LEFT JOIN (#{ pt_max_sql }) pt_max ON pt_max.post_id = posts.id")
         .reselect('posts.*', Arel.sql("#{ updated_at_all_sql } AS updated_at_all"))
         .preload(:uploaded_user, :parents, :children,
-                 active_post_tags: [:sections,
+                 tags: [:deerjikists, :materials, { tag_name: :wiki_page }])
-                                    { tag: [:deerjikists, :materials,
-                                            { tag_name: :wiki_page }] }])
         .with_attached_thumbnail
 
     q = q.where('posts.url LIKE ?', "%#{ url }%") if url
@@ -104,9 +97,7 @@ class PostsController < ApplicationController
 
   def random
     post = filtered_posts.preload(:uploaded_user, :parents, :children,
-                                  active_post_tags: [:sections,
+                                  tags: [:deerjikists, :materials, { tag_name: :wiki_page }])
-                                                     { tag: [:deerjikists, :materials,
-                                                             { tag_name: :wiki_page }] }])
                          .with_attached_thumbnail
                          .order('RAND()')
                          .first
@@ -115,84 +106,11 @@ class PostsController < ApplicationController
     render json: PostRepr.base(post, current_user)
   end
 
-  def metadata
-    return head :unauthorized unless current_user
-    return head :forbidden unless current_user.gte_member?
-    return render_bad_request('URL は必須です．') if params[:url].blank?
-
-    normal_url = PostUrlNormaliser.normalise(params[:url].to_s)
-    return render_validation_error(fields: { url: ['URL が不正です．'] }) if normal_url.blank?
-
-    Preview::UrlSafety.validate(normal_url)
-    existing_post = Post.with_attached_thumbnail.find_by(url: normal_url)
-    if existing_post.present?
-      return render json: {
-          url: normal_url,
-          title: nil,
-          thumbnail_base: nil,
-          tags: nil,
-          display_tags: [],
-          original_created_from: nil,
-          original_created_before: nil,
-          duration: nil,
-          video_ms: nil,
-          field_warnings: { },
-          base_warnings: [],
-          existing_post_id: existing_post.id,
-          existing_post: compact_post(existing_post.id) }
-    end
-
-    metadata = PostMetadataFetcher.fetch(normal_url)
-    field_warnings = { }
-    field_warnings[:title] = ['タイトルを取得できませんでした．'] if metadata[:title].blank?
-    if metadata[:thumbnail_base].blank?
-      field_warnings[:thumbnail_base] = ['サムネールを取得できませんでした．']
-    end
-
-    render json: {
-        url: normal_url,
-        title: metadata[:title],
-        thumbnail_base: metadata[:thumbnail_base],
-        tags: metadata[:tags],
-        display_tags: metadata[:display_tags],
-        original_created_from: metadata[:original_created_from],
-        original_created_before: metadata[:original_created_before],
-        duration: metadata[:duration],
-        video_ms: metadata[:video_ms],
-        field_warnings: field_warnings,
-        base_warnings: [],
-        existing_post_id: nil,
-        existing_post: nil }
-  rescue ArgumentError => e
-    render_bad_request e.message
-  rescue Preview::UrlSafety::UnsafeUrl => e
-    render_validation_error fields: { url: [e.message] }
-  rescue Preview::HttpFetcher::FetchFailed,
-         Preview::HttpFetcher::FetchTimeout,
-         Preview::HttpFetcher::ResponseTooLarge
-    render json: {
-        url: normal_url,
-        title: nil,
-        thumbnail_base: nil,
-        tags: nil,
-        display_tags: [],
-        original_created_from: nil,
-        original_created_before: nil,
-        duration: nil,
-        video_ms: nil,
-        field_warnings: { url: ['自動取得に失敗しました．'] },
-        base_warnings: [],
-        existing_post_id: nil,
-        existing_post: nil }
-  end
-
   def show
     post =
         Post
         .includes(:uploaded_user, :parents, :children,
-                  active_post_tags: [:sections,
+                  tags: [:deerjikists, :materials, { tag_name: :wiki_page }])
-                                     { tag: [:deerjikists, :materials,
-                                             { tag_name: :wiki_page }] }])
         .with_attached_thumbnail
         .find_by(id: params[:id])
     return head :not_found unless post
@@ -207,85 +125,54 @@ class PostsController < ApplicationController
                                  child_posts:,
                                  sibling_posts:,
                                  related:)
-                         .merge(tags: build_tag_tree_for(post))
+                         .merge(tags: build_tag_tree_for(post.tags))
   end
 
   def create
     return head :unauthorized unless current_user
     return head :forbidden unless current_user.gte_member?
 
-    preflight = PostCreatePreflight.new(
+    # TODO: サイトに応じて thumbnail_base 設定
-        attributes: post_create_attributes,
+    title = params[:title].presence
-        thumbnail: params[:thumbnail],
+    url = params[:url]
-        host: request.base_url).run
+    thumbnail = params[:thumbnail]
-    return render json: dry_run_json(preflight) if bool?(:dry)
+    tag_names = params[:tags].to_s.split
-    if preflight[:existing_post_id].present?
+    original_created_from = params[:original_created_from]
-      post = Post.new(url: preflight[:url])
+    original_created_before = params[:original_created_before]
-      post.errors.add :url, :taken
+    parent_post_ids = parse_parent_post_ids
-      return render_post_form_record_invalid post
-    end
 
-    post = PostCreator.new(actor: current_user,
+    post = Post.new(title:, url:, thumbnail_base: nil, uploaded_user: current_user,
-                           attributes: post_create_attributes.merge(
+                    original_created_from:, original_created_before:)
-                               preflight.slice(
+    post.thumbnail.attach(thumbnail) if thumbnail.present?
-                                   :url,
+
-                                   :title,
+    ApplicationRecord.transaction do
-                                   :thumbnail_base,
+      post.save!
-                                   :tags,
+
-                                   :parent_post_ids,
+      tags = Tag.normalise_tags!(tag_names, deny_deprecated: true)
-                                   :original_created_from,
+      TagVersioning.record_tag_snapshots!(tags, created_by_user: current_user)
-                                   :original_created_before,
+
-                                   :duration,
+      tags = Tag.expand_parent_tags(tags).reject(&:deprecated?)
-                                   :video_ms,
+      sync_post_tags!(post, tags)
-                                   :direct_tag_specs,
+
-                                   :default_tag_specs,
+      sync_parent_posts!(post, parent_post_ids)
-                                   :snapshot_tag_specs,
+
-                                   :post_tag_specs,
+      post.resized_thumbnail!
-                                   :tag_sections,
+
-                                   :normalised_parent_post_ids).symbolize_keys).merge(
+      PostVersionRecorder.record!(post:, event_type: :create, created_by_user: current_user)
-                               thumbnail: params[:thumbnail])).create!
+    end
 
     post.reload
     render json: PostRepr.base(post), status: :created
-  rescue PostCreatePreflight::ValidationFailed => e
-    render_validation_error fields: e.fields, base: e.base_errors
   rescue Tag::NicoTagNormalisationError
     render_validation_error fields: { tags: 'ニコニコ・タグは直接指定できません．' }
   rescue Tag::DeprecatedTagNormalisationError
     render_unprocessable_entity '廃止済みタグは付与できません．', field: :tags
-  rescue Tag::SectionLiteralParseError
-    render_validation_error fields: { tags: ['タグ区間の記法が不正です．'] }
-  rescue PostCreator::VideoMsParseError
-    render_validation_error fields: { video_ms: ['動画時間の記法が不正です．'] }
-  rescue Post::RemoteThumbnailFetchFailed
-    render_validation_error fields: { thumbnail_base: ['サムネイル画像の取得に失敗しました．'] }
-  rescue MiniMagick::Error
-    render_validation_error fields: { thumbnail: ['サムネイル画像の変換に失敗しました．'] }
   rescue ArgumentError => e
     render_validation_error fields: { parent_post_ids: [e.message] }
   rescue ActiveRecord::RecordInvalid => e
     render_post_form_record_invalid e.record
   end
 
-  def bulk
-    return head :unauthorized unless current_user
-    return head :forbidden unless current_user.gte_member?
-    return head :unsupported_media_type unless request.content_mime_type == Mime[:multipart_form]
-    return head :payload_too_large if request.content_length.to_i > MAX_BULK_REQUEST_BYTES
-    posts = parse_bulk_posts_manifest
-    thumbnails = parse_bulk_thumbnails(posts.length)
-    result = PostBulkCreator.new(
-        actor: current_user,
-        posts:,
-        thumbnails:,
-        host: request.base_url).run
-    render json: result
-  rescue JSON::ParserError
-    render_bad_request 'posts manifest の JSON が不正です．'
-  rescue ArgumentError => e
-    render_validation_error base: [e.message]
-  end
-
   def viewed
     return head :unauthorized unless current_user
 
@@ -336,8 +223,6 @@ class PostsController < ApplicationController
                                                  original_created_from:,
                                                  original_created_before:,
                                                  tag_names:,
-                                                 video_ms_param: params[:video_ms],
-                                                 duration_param: params[:duration],
                                                  parent_post_ids:)
 
       snapshot_to_apply =
@@ -368,16 +253,12 @@ class PostsController < ApplicationController
 
     post.reload
     json = PostRepr.base(post, current_user)
-    json['tags'] = build_tag_tree_for(post)
+    json['tags'] = build_tag_tree_for(post.tags)
     render json:, status: :ok
   rescue Tag::NicoTagNormalisationError
     render_validation_error fields: { tags: ['ニコニコ・タグは直接指定できません．'] }
   rescue Tag::DeprecatedTagNormalisationError
     render_unprocessable_entity '廃止済みタグは付与できません．', field: :tags
-  rescue Tag::SectionLiteralParseError
-    render_validation_error fields: { tags: ['タグ区間の記法が不正です．'] }
-  rescue VideoMsParseError
-    render_validation_error fields: { video_ms: ['動画時間の記法が不正です．'] }
   rescue ArgumentError => e
     render_validation_error fields: { parent_post_ids: [e.message] }
   rescue ActiveRecord::RecordInvalid => e
@@ -476,7 +357,7 @@ class PostsController < ApplicationController
   def tagged_post_ids_for(name) =
       Post.joins(tags: :tag_name).where(tag_names: { name: }).select(:id)
 
-  def sync_post_tags! post, desired_tags, sections
+  def sync_post_tags! post, desired_tags
     desired_tags.each do |t|
       t.save! if t.new_record?
     end
@@ -495,21 +376,13 @@ class PostsController < ApplicationController
       end
     end
 
-    PostTagSection.where(post_id: post.id).destroy_all
-    sections.each do |tag_id, ranges|
-      ranges.each do |begin_ms, end_ms|
-        PostTagSection.create!(post_id: post.id, tag_id:, begin_ms:, end_ms:)
-      end
-    end
-
     PostTag.where(post_id: post.id, tag_id: to_remove.to_a).kept.find_each do |pt|
       pt.discard_by!(current_user)
     end
   end
 
-  def build_tag_tree_for post
+  def build_tag_tree_for tags
-    post_tags = post.active_post_tags.reject { |post_tag| post_tag.tag.deprecated? }
+    tags = tags.reject(&:deprecated?).to_a
-    tags = post_tags.map(&:tag)
     tag_ids = tags.map(&:id)
 
     implications = TagImplication.where(parent_tag_id: tag_ids, tag_id: tag_ids)
@@ -524,9 +397,6 @@ class PostsController < ApplicationController
     root_ids = tag_ids - child_ids
 
     tags_by_id = tags.index_by(&:id)
-    sections_by_tag_id = post_tags.to_h { |post_tag|
-      [post_tag.tag_id, post_tag.sections.as_json(only: [:begin_ms, :end_ms])]
-    }
 
     memo = { }
 
@@ -534,10 +404,8 @@ class PostsController < ApplicationController
       tag = tags_by_id[tag_id]
       return nil unless tag
 
-      sections = sections_by_tag_id.fetch(tag_id, [])
-
       if path.include?(tag_id)
-        return TagRepr.inline(tag).merge(children: [], sections:)
+        return TagRepr.inline(tag).merge(children: [])
       end
 
       if memo.key?(tag_id)
@@ -549,7 +417,7 @@ class PostsController < ApplicationController
 
       children = child_ids.filter_map { |cid| build_node.(cid, new_path) }
 
-      memo[tag_id] = TagRepr.inline(tag).merge(children:, sections:)
+      memo[tag_id] = TagRepr.inline(tag).merge(children:)
     end
 
     root_ids.filter_map { |id| build_node.call(id, []) }
@@ -580,79 +448,6 @@ class PostsController < ApplicationController
     }.uniq
   end
 
-  def post_create_attributes
-    { title: params[:title],
-      url: params[:url],
-      thumbnail_base: params[:thumbnail_base],
-      tags: params[:tags],
-      original_created_from: params[:original_created_from],
-      original_created_before: params[:original_created_before],
-      parent_post_ids: parse_parent_post_ids,
-      video_ms: params[:video_ms],
-      duration: params[:duration] }
-  end
-
-  def parse_bulk_posts_manifest
-    manifest = params[:posts]
-    raise ArgumentError, 'posts は必須です．' if manifest.blank?
-    raise ArgumentError, 'posts は JSON 文字列で指定してください．' unless manifest.is_a?(String)
-
-    posts = JSON.parse(manifest)
-    raise ArgumentError, 'posts は配列で指定してください．' unless posts.is_a?(Array)
-    raise ArgumentError, '投稿件数は 1 件以上必要です．' if posts.empty?
-    raise ArgumentError, '投稿件数が多すぎます．' if posts.length > 100
-    raise ArgumentError, 'posts 要素の形式が不正です．' unless posts.all? { _1.is_a?(Hash) }
-
-    posts
-  end
-
-  def parse_bulk_thumbnails post_count
-    thumbnails = { }
-    raw = params[:thumbnails]
-    return thumbnails if raw.blank?
-    raise ArgumentError, 'thumbnail key が不正です．' unless raw.respond_to?(:to_unsafe_h)
-
-    raw.to_unsafe_h.each do |key, value|
-      raise ArgumentError, 'thumbnail key が不正です．' unless key.to_s.match?(/\A\d+\z/)
-
-      index = Integer(key, 10)
-      raise ArgumentError, 'thumbnail index が範囲外です．' if index.negative? || index >= post_count
-      raise ArgumentError, 'thumbnail index が重複しています．' if thumbnails.key?(index)
-      unless value.is_a?(ActionDispatch::Http::UploadedFile)
-        raise ArgumentError, 'thumbnail upload が不正です．'
-      end
-
-      thumbnails[index] = value
-    end
-
-    thumbnails
-  end
-
-  def compact_post post_id
-    return nil if post_id.blank?
-
-    post = Post.with_attached_thumbnail.find_by(id: post_id)
-    PostCompactRepr.base(post, host: request.base_url)
-  end
-
-  def dry_run_json preflight
-    preflight.slice(
-        :url,
-        :title,
-        :thumbnail_base,
-        :tags,
-        :display_tags,
-        :parent_post_ids,
-        :original_created_from,
-        :original_created_before,
-        :duration,
-        :video_ms,
-        :field_warnings,
-        :base_warnings,
-        :existing_post_id,
-        :existing_post)
-  end
-
   def sync_parent_posts! post, parent_post_ids
     if parent_post_ids.include?(post.id)
       post.errors.add :parent_post_ids, '自分自身を親投稿にはできません．'
@@ -691,7 +486,6 @@ class PostsController < ApplicationController
 
   def post_snapshot_from_version version
     { title: version.title,
-      video_ms: version.respond_to?(:video_ms) ? version.video_ms : nil,
       original_created_from: snapshot_time(version.original_created_from),
       original_created_before: snapshot_time(version.original_created_before),
       tag_names: editable_tag_names_from_version(version),
@@ -704,7 +498,6 @@ class PostsController < ApplicationController
 
   def post_snapshot_from_record post
     { title: post.title,
-      video_ms: post.video_ms,
       original_created_from: snapshot_time(post.original_created_from),
       original_created_before: snapshot_time(post.original_created_before),
       tag_names: editable_tag_names_from_post(post),
@@ -712,42 +505,16 @@ class PostsController < ApplicationController
   end
 
   def editable_tag_names_from_post post
-    post
+    post.tags.not_nico.where(deprecated_at: nil)
-        .post_tags
+        .joins(:tag_name).order('tag_names.name').pluck('tag_names.name')
-        .kept
-        .joins(tag: :tag_name)
-        .merge(Tag.not_nico)
-        .merge(Tag.where(deprecated_at: nil))
-        .includes(:sections, tag: :tag_name)
-        .order('tag_names.name')
-        .map do |post_tag|
-      name = post_tag.tag.tag_name.name
-      sections = post_tag.sections.sort_by(&:begin_ms)
-
-      next name if sections.empty?
-
-      "#{ name }#{ sections.map { Post.section_literal(_1) }.join }"
-    end
   end
 
   def post_incoming_snapshot title:, original_created_from:, original_created_before:,
-                             tag_names:, video_ms_param:, duration_param:, parent_post_ids:
+                             tag_names:, parent_post_ids:
-    validate_original_created_values!(original_created_from, original_created_before)
-    Tag.normalise_tags!(tag_names, with_tagme: false, deny_deprecated: true,
-                                        with_sections: true) =>
-        { tags:, sections: }
-
-    tags = Tag.expand_parent_tags(tags).reject(&:deprecated?)
-    video_ms = normalise_video_ms(tags, video_ms_param:, duration_param:)
-    validate_video_sections!(video_ms, sections)
-
     { title:,
-      video_ms:,
       original_created_from: snapshot_time(original_created_from),
       original_created_before: snapshot_time(original_created_before),
-      tag_names: tags.uniq(&:id).map { |tag|
+      tag_names: incoming_tag_names_for_snapshot(tag_names),
-        "#{ tag.name }#{ sections[tag.id].to_a.map { section_literal(_1) }.join }"
-      }.sort,
       parent_post_ids: parent_post_ids.sort }
   end
 
@@ -770,25 +537,11 @@ class PostsController < ApplicationController
     value.to_s
   end
 
-  def validate_original_created_values! original_created_from, original_created_before
+  def incoming_tag_names_for_snapshot raw_tag_names
-    candidate = Post.new(
+    tags = Tag.normalise_tags!(raw_tag_names, with_tagme: false,
-        url: 'https://example.invalid/original-created-validation',
+                                              deny_deprecated: true)
-        original_created_from:,
-        original_created_before:)
-    candidate.valid?
-    fields = [:original_created_from, :original_created_before, :original_created_at]
-    relevant_errors = candidate.errors.select { fields.include?(_1.attribute) }
-    return if relevant_errors.empty?
 
-    invalid_post = Post.new
+    Tag.expand_parent_tags(tags).reject(&:deprecated?).map(&:name).uniq.sort
-    relevant_errors.each { |error|
-      invalid_post.errors.add(error.attribute, error.message)
-    }
-    raise ActiveRecord::RecordInvalid, invalid_post
-  end
-
-  def section_literal section
-    "[#{ Post.ms_to_time(section[0]) }-#{ section[1] ? Post.ms_to_time(section[1]) : '' }]"
   end
 
   def post_conflict_json post:, base_version_no:, base_snapshot:,
@@ -809,8 +562,6 @@ class PostsController < ApplicationController
   def post_snapshot_changes base_snapshot, current_snapshot, incoming_snapshot
     [scalar_snapshot_change(:title, 'タイトル',
                             base_snapshot, current_snapshot, incoming_snapshot),
-     scalar_snapshot_change(:video_ms, '動画時間',
-                            base_snapshot, current_snapshot, incoming_snapshot),
      scalar_snapshot_change(:original_created_from, 'オリジナルの作成日時（以降）',
                             base_snapshot, current_snapshot, incoming_snapshot),
      scalar_snapshot_change(:original_created_before, 'オリジナルの作成日時（より前）',
@@ -874,14 +625,11 @@ class PostsController < ApplicationController
     PostVersionRecorder.ensure_snapshot!(post, created_by_user: current_user)
 
     post.update!(title: snapshot[:title],
-                 video_ms: snapshot[:video_ms],
                  original_created_from: snapshot[:original_created_from],
                  original_created_before: snapshot[:original_created_before])
 
-    Tag.normalise_tags!(snapshot[:tag_names], with_tagme: false,
+    editable_tags = Tag.normalise_tags!(snapshot[:tag_names], with_tagme: false,
-                                               deny_deprecated: true,
+                                                               deny_deprecated: true)
-                                               with_sections: true) =>
-        { tags: editable_tags, sections: }
     TagVersioning.record_tag_snapshots!(editable_tags, created_by_user: current_user)
 
     readonly_tags = post.tags.nico.to_a
@@ -889,17 +637,14 @@ class PostsController < ApplicationController
     tags = readonly_tags + editable_tags
     tags = Tag.expand_parent_tags(tags).reject(&:deprecated?)
 
-    post.video_ms = tags.any? { _1.id == Tag.video.id } ? snapshot[:video_ms] : nil
+    sync_post_tags!(post, tags)
-    validate_video_sections!(post.video_ms, sections)
-    post.save!
-    sync_post_tags!(post, tags, sections)
     sync_parent_posts!(post, snapshot[:parent_post_ids])
 
     PostVersionRecorder.record!(post:, event_type: :update, created_by_user: current_user)
   end
 
   def merge_post_snapshots base_snapshot, current_snapshot, incoming_snapshot
-    [:title, :video_ms, :original_created_from, :original_created_before].map {
+    [:title, :original_created_from, :original_created_before].map {
       [_1, merge_scalar_snapshot_value(base_snapshot[_1],
                                        current_snapshot[_1],
                                        incoming_snapshot[_1])]
@@ -943,44 +688,4 @@ class PostsController < ApplicationController
       render_validation_error record
     end
   end
-
-  def normalise_video_ms tags, video_ms_param: params[:video_ms], duration_param: params[:duration]
-    return nil unless tags.any? { _1.id == Tag.video.id }
-
-    if video_ms_param.present?
-      video_ms = Integer(video_ms_param, exception: false)
-      raise VideoMsParseError unless video_ms&.positive?
-
-      return video_ms
-    end
-
-    return nil if duration_param.blank?
-
-    video_ms = Tag.time_to_ms!(duration_param.to_s, tag_name: '動画時間')
-    raise VideoMsParseError unless video_ms.positive?
-
-    video_ms
-  rescue Tag::SectionLiteralParseError
-    raise VideoMsParseError
-  end
-
-  def validate_video_sections! video_ms, sections
-    return unless video_ms
-
-    sections.each_value do |ranges|
-      ranges.each do |begin_ms, end_ms|
-        if begin_ms >= video_ms
-          post = Post.new
-          post.errors.add :video_ms, 'タグ区間の開始が動画時間以上です．'
-          raise ActiveRecord::RecordInvalid, post
-        end
-
-        if end_ms && end_ms > video_ms
-          post = Post.new
-          post.errors.add :video_ms, 'タグ区間の終端が動画時間を超えてゐます．'
-          raise ActiveRecord::RecordInvalid, post
-        end
-      end
-    end
-  end
 end

backend/app/controllers/preview_controller.rb

@@ -1,55 +1,50 @@
 class PreviewController < ApplicationController
-  before_action :require_member!
-
   def title
-    return render_bad_request('URL は必須です．') if params[:url].blank?
+    # TODO: # 既知サイトなら決まったフォーマットで title 取得するやぅに．
+    return head :unauthorized unless current_user
 
-    render json: { title: Preview::ThumbnailFetcher.title(params[:url]) }
+    url = params[:url]
-  rescue Preview::UrlSafety::UnsafeUrl => e
+    return render_bad_request('URL は必須です．') unless url.present?
+
+    unless url.start_with?(/http(s)?:\/\//)
+      url = 'http://' + url
+    end
+
+    html = URI.open(url, open_timeout: 5, read_timeout: 5).read
+    doc = Nokogiri::HTML.parse(html)
+    title = doc.at('title')&.text&.strip
+
+    render json: { title: title }
+  rescue => e
     render_bad_request(e.message)
-  rescue Preview::HttpFetcher::FetchTimeout => e
-    render_preview_error(e.message, :gateway_timeout)
-  rescue Preview::HttpFetcher::ResponseTooLarge => e
-    render_preview_error(e.message, :payload_too_large)
-  rescue Preview::HttpFetcher::FetchFailed => e
-    render_preview_error(e.message, :bad_gateway)
   end
 
   def thumbnail
-    return render_bad_request('URL は必須です．') if params[:url].blank?
+    # TODO: 既知ドメインであれば指定のアドレスからサムネールを取得するやぅにする．
 
-    attachment =
-        Post.resized_thumbnail_attachment(
-            StringIO.new(Preview::ThumbnailFetcher.fetch(params[:url])))
-    send_data attachment[:io].read,
-              type: attachment[:content_type],
-              disposition: 'inline'
-  rescue Preview::UrlSafety::UnsafeUrl => e
-    render_bad_request(e.message)
-  rescue Preview::HttpFetcher::FetchTimeout => e
-    render_preview_error(e.message, :gateway_timeout)
-  rescue Preview::HttpFetcher::ResponseTooLarge => e
-    render_preview_error(e.message, :payload_too_large)
-  rescue Preview::HttpFetcher::FetchFailed => e
-    render_preview_error(e.message, :bad_gateway)
-  rescue Preview::ThumbnailFetcher::GenerationFailed, MiniMagick::Error => e
-    render_unprocessable_entity(e.message)
-  end
-
-  private
-
-  def require_member!
     return head :unauthorized unless current_user
-    return if current_user.gte_member?
 
-    head :forbidden
+    url = params[:url]
-  end
+    return render_bad_request('URL は必須です．') if url.blank?
 
-  def render_preview_error(message, status)
+    unless url.start_with?(/http(s)?:\/\//)
-    render json: { type: status.to_s,
+      url = 'http://' + url
-                   message:,
+    end
-                   errors: { },
+
-                   base_errors: [message] },
+    path = Rails.root.join('tmp', "thumb_#{ SecureRandom.hex }.png")
-           status:
+    system("node #{ Rails.root }/lib/screenshot.js #{ Shellwords.escape(url) } #{ path }")
+
+    if File.exist?(path)
+      image = MiniMagick::Image.open(path)
+      image.resize '180x180'
+      File.delete(path) rescue nil
+      send_file image.path, type: 'image/png', disposition: 'inline'
+    else
+      render json: { type: 'internal_server_error',
+                     message: 'サムネールを生成できませんでした．',
+                     errors: { },
+                     base_errors: ['サムネールを生成できませんでした．'] },
+             status: :internal_server_error
+    end
   end
 end

backend/app/controllers/tags_controller.rb

@@ -245,7 +245,10 @@ class TagsController < ApplicationController
     return render_unprocessable_entity('カテゴリは必須です．', field: :category) if category.blank?
     return render_unprocessable_entity '廃止状態は必須です．', field: :deprecated unless params.key?(:deprecated)
 
-    return unless validate_tag_rename(tag, name)
+    if (name != tag.name &&
+        tag.in?([Tag.tagme, Tag.bot, Tag.no_deerjikist, Tag.video, Tag.niconico]))
+      return render_unprocessable_entity 'システム・タグの名称は変更できません．', field: :name
+    end
 
     alias_names = params[:aliases].to_s.split.uniq
     parent_names = params[:parent_tags].to_s.split.uniq
@@ -271,7 +274,7 @@ class TagsController < ApplicationController
       else
         tag.update!(category:, deprecated_at: deprecated ? Time.current : nil)
       end
-      rename_tag_name!(tag, name) if name_changed
+      tag.tag_name.update!(name:)
 
       alias_names << old_name if name_changed
       alias_names.delete(name)
@@ -307,8 +310,6 @@ class TagsController < ApplicationController
       return render_unprocessable_entity 'ニコタグは廃止できません．', field: :deprecated
     end
 
-    return unless validate_tag_rename(tag, name)
-
     if tag.nico? || (category.present? && category == 'nico')
       return render_unprocessable_entity 'ニコタグは変更できません．', field: :category
     end
@@ -320,7 +321,7 @@ class TagsController < ApplicationController
       name_changed = name.present? && name != old_name
       wiki_page = tag.tag_name.wiki_page if name_changed
 
-      rename_tag_name!(tag, name) if name_changed
+      tag.tag_name.update!(name:) if name.present?
       tag.update!(category:) if category.present?
       if deprecated_given && tag.deprecated? != deprecated
         tag.update!(deprecated_at: deprecated ? Time.current : nil)
@@ -534,67 +535,6 @@ class TagsController < ApplicationController
         created_by_user:)
   end
 
-  def validate_tag_rename tag, name
-    return true if name.blank? || name == tag.name
-
-    if tag.in?([Tag.tagme, Tag.bot, Tag.no_deerjikist, Tag.video, Tag.niconico])
-      render_unprocessable_entity 'システム・タグの名称は変更できません．', field: :name
-      return false
-    end
-
-    target_tag_name = TagName.with_discarded.find_by(name:)
-    return true if target_tag_name.nil?
-    return true if target_tag_name.canonical_id?
-
-    render_unprocessable_entity 'その名前は既に使はれてゐます．', field: :name
-    false
-  end
-
-  def rename_tag_name! tag, name
-    return if name == tag.name
-
-    current_tag_name = tag.tag_name
-    target_tag_name = TagName.with_discarded.find_by(name:)
-
-    if target_tag_name.nil?
-      current_tag_name.update!(name:)
-      return
-    end
-
-    promote_tag_alias!(
-        tag,
-        current_tag_name:,
-        promoted_tag_name: target_tag_name)
-  end
-
-  def promote_tag_alias! tag, current_tag_name:, promoted_tag_name:
-    old_owner_tag = promoted_tag_name.canonical&.tag
-
-    if old_owner_tag && old_owner_tag != tag
-      TagVersioning.ensure_snapshot!(old_owner_tag, created_by_user: current_user)
-    end
-
-    promoted_tag_name.undiscard! if promoted_tag_name.discarded?
-    promoted_tag_name.update!(canonical: nil)
-
-    TagName.with_discarded
-           .where(canonical_id: current_tag_name.id)
-           .where.not(id: promoted_tag_name.id)
-           .find_each do |alias_tag_name|
-      alias_tag_name.update!(canonical: promoted_tag_name)
-    end
-
-    current_tag_name.wiki_page&.update!(tag_name: promoted_tag_name)
-    tag.update!(tag_name: promoted_tag_name)
-    current_tag_name.association(:wiki_page).reset
-    current_tag_name.association(:tag).reset
-    current_tag_name.reload.update!(canonical: promoted_tag_name)
-
-    return unless old_owner_tag && old_owner_tag != tag
-
-    record_tag_version!(old_owner_tag.reload, event_type: :update, created_by_user: current_user)
-  end
-
   def update_aliases! tag, alias_names
     alias_names = alias_names.uniq
 

backend/app/controllers/user_settings_controller.rb

@@ -1,61 +0,0 @@
-class UserSettingsController < ApplicationController
-  wrap_parameters false
-
-  def show
-    return head :unauthorized unless current_user
-
-    render json: current_setting.serializable_hash
-  end
-
-  def update
-    return head :unauthorized unless current_user
-
-    raw_attributes = editable_raw_attributes
-    field_errors = validate_raw_attributes(raw_attributes)
-    return render_validation_error fields: field_errors if field_errors.present?
-
-    setting = current_setting
-    setting.assign_attributes(raw_attributes)
-
-    if setting.save
-      render json: setting.serializable_hash, status: :ok
-    else
-      render_validation_error setting
-    end
-  end
-
-  private
-
-  def current_setting
-    Setting.find_or_create_by!(user: current_user) do |setting|
-      setting.assign_attributes(Setting.defaults)
-    end
-  rescue ActiveRecord::RecordNotUnique
-    Setting.find_by!(user: current_user)
-  end
-
-  def editable_raw_attributes
-    request.request_parameters.slice(*Setting::EDITABLE_ATTRIBUTES)
-  end
-
-  def validate_raw_attributes raw_attributes
-    raw_attributes.each_with_object({ }) do |(key, value), errors|
-      next if value_matches_type?(key, value)
-
-      errors[key.to_sym] = ['値の型が不正です．']
-    end
-  end
-
-  def value_matches_type? key, value
-    case Setting::TYPE_BY_ATTRIBUTE.fetch(key)
-    when :string
-      value.is_a?(String)
-    when :integer
-      value.is_a?(Integer)
-    when :boolean
-      value == true || value == false
-    else
-      false
-    end
-  end
-end

backend/app/controllers/user_theme_slots_controller.rb

@@ -1,38 +0,0 @@
-class UserThemeSlotsController < ApplicationController
-  wrap_parameters false
-
-  def index
-    return head :unauthorized unless current_user
-
-    render json: current_user
-                 .theme_slots
-                 .order(:base_theme, :slot_no)
-                 .map { |slot| slot.serializable_hash }
-  end
-
-  def update
-    return head :unauthorized unless current_user
-
-    base_theme = params[:base_theme].to_s
-    slot_no = params[:slot_no].to_i
-    tokens = params[:tokens]
-
-    unless UserThemeSlot::BASE_THEMES.include?(base_theme)
-      return render_validation_error fields: { base_theme: ['値が不正です．'] }
-    end
-    unless UserThemeSlot::SLOT_NOS.include?(slot_no)
-      return render_validation_error fields: { slot_no: ['値が不正です．'] }
-    end
-    unless tokens.is_a?(ActionController::Parameters) || tokens.is_a?(Hash)
-      return render_validation_error fields: { tokens: ['JSON object で指定してください．'] }
-    end
-
-    slot = UserThemeSlot.find_or_initialize_by(user: current_user,
-                                               base_theme:,
-                                               slot_no:)
-    slot.tokens = tokens.is_a?(ActionController::Parameters) ? tokens.to_unsafe_h : tokens
-    slot.save!
-
-    render json: slot.serializable_hash, status: :ok
-  end
-end

backend/app/models/post.rb

@@ -1,56 +1,5 @@
 class Post < ApplicationRecord
-  require 'date'
   require 'mini_magick'
-  require 'nokogiri'
-  require 'stringio'
-  require 'timeout'
-
-  class RemoteThumbnailFetchFailed < StandardError; end
-
-  ORIGINAL_CREATED_INVALID_MESSAGE = 'オリジナルの作成日時の形式が不正です．'.freeze
-  ORIGINAL_CREATED_MINUTE_PRECISION_MESSAGE =
-      'オリジナルの作成日時は分単位で入力してください．'.freeze
-  ORIGINAL_CREATED_ORDER_MESSAGE = 'オリジナルの作成日時の順番がをかしぃです．'.freeze
-  ORIGINAL_CREATED_MINIMUM_RANGE_MESSAGE =
-      'オリジナルの作成日時の範囲は1分以上必要です．'.freeze
-  REMOTE_SVG_CONTENT_TYPE = 'image/svg+xml'.freeze
-  MAX_SVG_DIMENSION = 4_096
-  MAX_SVG_PIXELS = 16_777_216
-  THUMBNAIL_PROCESS_TIMEOUT = 5.seconds
-  def self.resized_thumbnail_attachment(upload, content_type: nil)
-    upload.rewind
-    bytes = upload.read
-    blob = Timeout.timeout(THUMBNAIL_PROCESS_TIMEOUT) do
-      image = image_for_thumbnail_upload(bytes, content_type:)
-      image.auto_orient
-      image.resize '180x180'
-      image.format 'jpg'
-      image.to_blob
-    end
-
-    { io: StringIO.new(blob),
-      filename: 'resized_thumbnail.jpg',
-      content_type: 'image/jpeg' }
-  rescue Timeout::Error
-    raise MiniMagick::Error, 'サムネイル画像の変換に失敗しました．'
-  ensure
-    upload.rewind
-  end
-
-  def self.remote_thumbnail_attachment(raw_url)
-    response = Preview::ThumbnailFetcher.fetch_image_response(raw_url)
-    resized_thumbnail_attachment(
-        StringIO.new(response.body),
-        content_type: response.content_type)
-  rescue Preview::UrlSafety::UnsafeUrl,
-         Preview::ThumbnailFetcher::GenerationFailed,
-         Preview::HttpFetcher::FetchFailed,
-         Preview::HttpFetcher::FetchTimeout,
-         Preview::HttpFetcher::ResponseTooLarge,
-         Timeout::Error,
-         MiniMagick::Error => e
-    raise RemoteThumbnailFetchFailed, e.message
-  end
 
   belongs_to :uploaded_user, class_name: 'User', optional: true
 
@@ -94,10 +43,9 @@ class Post < ApplicationRecord
 
   attribute :version_no, :integer, default: 1
 
-  before_validation :normalise_url, if: :will_save_change_to_url?
+  before_validation :normalise_url
 
-  validates :url, presence: true, uniqueness: true, length: { maximum: 768 }
+  validates :url, presence: true, uniqueness: true
-  validates :video_ms, numericality: { only_integer: true, greater_than: 0 }, allow_nil: true
 
   validate :validate_original_created_range
   validate :url_must_be_http_url
@@ -121,49 +69,7 @@ class Post < ApplicationRecord
     super(options).merge(thumbnail: nil)
   end
 
-  def snapshot_tag_names
+  def snapshot_tag_names = tags.joins(:tag_name).order('tag_names.name').pluck('tag_names.name')
-    post_tags
-        .kept
-        .joins(tag: :tag_name)
-        .includes(:sections, tag: :tag_name)
-        .order('tag_names.name')
-        .map do |post_tag|
-      name = post_tag.tag.tag_name.name
-      sections = post_tag.sections.sort_by(&:begin_ms)
-
-      next name if sections.empty?
-
-      "#{ name }#{ sections.map { Post.section_literal(_1) }.join }"
-    end
-  end
-
-  def self.section_literal section
-    end_ms =
-        section.end_ms ? Post.ms_to_time(section.end_ms) : ''
-
-    "[#{ Post.ms_to_time(section.begin_ms) }-#{ end_ms }]"
-  end
-
-  def self.ms_to_time ms
-    total_s = ms / 1_000
-    s = total_s % 60
-    min = (total_s / 60) % 60
-    h = total_s / 3_600
-    remainder_ms = ms % 1_000
-
-    base =
-        if h.positive?
-          '%d:%02d:%02d' % [h, min, s]
-        else
-          '%d:%02d' % [min, s]
-        end
-
-    if remainder_ms.positive?
-      "#{ base }.#{ remainder_ms.to_s.rjust(3, '0') }"
-    else
-      base
-    end
-  end
 
   def snapshot_parent_post_ids = parents.order(:id).pluck(:id)
 
@@ -181,29 +87,27 @@ class Post < ApplicationRecord
   def resized_thumbnail!
     return unless thumbnail.attached?
 
-    thumbnail.attach(self.class.resized_thumbnail_attachment(StringIO.new(thumbnail.download)))
+    image = MiniMagick::Image.read(thumbnail.download)
-  end
+    image.resize '180x180'
-
+    thumbnail.purge
-  def attach_thumbnail_from_url! raw_url
+    thumbnail.attach(io:            File.open(image.path),
-    thumbnail.attach(self.class.remote_thumbnail_attachment(raw_url))
+                     filename:      'resized_thumbnail.jpg',
+                     content_type:  'image/jpeg')
   end
 
   private
 
   def validate_original_created_range
-    return if skip_original_created_validation?
+    f = original_created_from
+    b = original_created_before
+    return if f.blank? || b.blank?
 
-    f = parse_original_created_value(:original_created_from)
+    f = Time.zone.parse(f) if String === f
-    b = parse_original_created_value(:original_created_before)
+    b = Time.zone.parse(b) if String === b
-    return if f.nil? || b.nil?
+    return if !(f) || !(b)
 
-    if b <= f
+    if f >= b
-      errors.add :original_created_at, ORIGINAL_CREATED_ORDER_MESSAGE
+      errors.add :original_created_at, 'オリジナルの作成日時の順番がをかしぃです．'
-      return
-    end
-
-    if b - f < 1.minute
-      errors.add :original_created_at, ORIGINAL_CREATED_MINIMUM_RANGE_MESSAGE
     end
   end
 
@@ -224,307 +128,15 @@ class Post < ApplicationRecord
   def normalise_url
     return if url.blank?
 
-    self.url = PostUrlNormaliser.normalise(url) || url.strip
+    self.url = url.strip
-  end
 
-  def self.image_for_thumbnail_upload(bytes, content_type: nil)
+    u = URI.parse(url)
-    if svg_content_type?(content_type) || svg_document_bytes?(bytes)
+    return unless u in URI::HTTP
-      return decode_svg_thumbnail(bytes)
-    end
 
-    raise MiniMagick::Error, 'サムネイル画像の形式が不正です．' unless raster_thumbnail_bytes?(bytes)
+    u.host = u.host.downcase if u.host
-
+    u.path = u.path.sub(/\/\Z/, '') if u.path.present?
-    decode_raster_thumbnail(bytes)
+    self.url = u.to_s
-  end
+  rescue URI::InvalidURIError
-
+    ;
-  def self.raster_thumbnail_bytes?(bytes)
-    raster_thumbnail_format(bytes).present?
-  end
-
-  def self.remote_thumbnail_image_bytes?(bytes, content_type: nil)
-    return true if svg_content_type?(content_type) || svg_document_bytes?(bytes)
-
-    raster_thumbnail_bytes?(bytes)
-  end
-
-  def self.svg_content_type?(content_type)
-    content_type.to_s.split(';', 2).first.to_s.downcase.strip == REMOTE_SVG_CONTENT_TYPE
-  end
-
-  def self.svg_document_bytes?(bytes)
-    document = Nokogiri::XML(
-        bytes,
-        nil,
-        nil,
-        Nokogiri::XML::ParseOptions::STRICT |
-        Nokogiri::XML::ParseOptions::NONET)
-    document.root&.name == 'svg'
-  rescue Nokogiri::XML::SyntaxError
-    false
-  end
-
-  def self.decode_raster_thumbnail(bytes)
-    MiniMagick::Image.read(bytes)
-  end
-
-  def self.decode_svg_thumbnail(bytes)
-    MiniMagick::Image.read(sanitised_svg_bytes(bytes))
-  end
-
-  def self.raster_thumbnail_format(bytes)
-    binary = bytes.to_s.b
-    return 'jpeg' if binary.start_with?("\xFF\xD8\xFF".b)
-    return 'png' if binary.start_with?("\x89PNG\r\n\x1A\n".b)
-    return 'gif' if binary.start_with?('GIF87a'.b) || binary.start_with?('GIF89a'.b)
-    return 'webp' if binary.bytesize >= 12 &&
-                     binary.start_with?('RIFF'.b) &&
-                     binary.byteslice(8, 4) == 'WEBP'
-
-    nil
-  end
-
-  def self.sanitised_svg_bytes(bytes)
-    parse_options =
-        Nokogiri::XML::ParseOptions::STRICT |
-        Nokogiri::XML::ParseOptions::NONET
-    document = Nokogiri::XML(
-        bytes,
-        nil,
-        nil,
-        parse_options)
-    root = document.root
-    raise MiniMagick::Error, 'SVG が不正です．' if root == nil || root.name != 'svg'
-    raise MiniMagick::Error, 'SVG が不正です．' if document.internal_subset != nil
-    raise MiniMagick::Error, 'SVG が不正です．' if svg_uses_disallowed_features?(document)
-
-    width, height = svg_dimensions(root)
-    raise MiniMagick::Error, 'SVG が大きすぎます．' if width == nil || height == nil
-    if width > MAX_SVG_DIMENSION || height > MAX_SVG_DIMENSION || width * height > MAX_SVG_PIXELS
-      raise MiniMagick::Error, 'SVG が大きすぎます．'
-    end
-
-    document.to_xml
-  rescue Nokogiri::XML::SyntaxError
-    raise MiniMagick::Error, 'SVG が不正です．'
-  end
-
-  def self.svg_uses_disallowed_features?(document)
-    document.traverse.any? do |node|
-      next false unless node.element?
-
-      name = node.name.to_s.downcase
-      next true if name == 'script' || name == 'foreignobject'
-      next style_contains_disallowed_urls?(node.text.to_s) if name == 'style'
-
-      node.attribute_nodes.any? do |attribute|
-        attribute_name = attribute.name.to_s.downcase
-        attribute_value = attribute.value.to_s
-        attribute_name.start_with?('on') ||
-            external_svg_reference?(attribute_name, attribute_value)
-      end
-    end
-  end
-
-  def self.external_svg_reference?(attribute_name, attribute_value)
-    if ['href', 'xlink:href', 'src'].include?(attribute_name)
-      return external_svg_url?(attribute_value)
-    end
-    return style_contains_disallowed_urls?(attribute_value) if attribute_name == 'style'
-    return svg_url_function_disallowed?(attribute_value) if attribute_value.match?(/url\s*\(/i)
-
-    false
-  end
-
-  def self.external_svg_url?(value)
-    stripped = value.to_s.strip
-    return false if stripped.blank? || stripped.start_with?('#')
-
-    true
-  end
-
-  def self.style_contains_disallowed_urls?(value)
-    text = value.to_s
-    text.match?(/@import/i) || svg_url_function_disallowed?(text)
-  end
-
-  def self.svg_url_function_disallowed?(value)
-    value.to_s.scan(/url\s*\(([^)]*)\)/i).flatten.any? do |entry|
-      reference =
-          entry.to_s.strip
-               .delete_prefix("'")
-               .delete_prefix('"')
-               .delete_suffix("'")
-               .delete_suffix('"')
-      reference.present? && !(reference.start_with?('#'))
-    end
-  end
-
-  def self.svg_dimensions(root)
-    width = svg_length_to_pixels(root['width'])
-    height = svg_length_to_pixels(root['height'])
-    return [width, height] if width && height
-
-    view_box = root['viewBox'].to_s.strip.split(/\s+/).map { Float(_1) rescue nil }
-    return [nil, nil] if view_box.length != 4 || view_box.any?(&:nil?)
-    return [nil, nil] unless view_box[2].finite? && view_box[2].positive?
-    return [nil, nil] unless view_box[3].finite? && view_box[3].positive?
-
-    [view_box[2], view_box[3]]
-  end
-
-  def self.svg_length_to_pixels(value)
-    return nil if value.blank?
-
-    matched = /\A([0-9]+(?:\.[0-9]+)?)(px)?\z/i.match(value.to_s.strip)
-    return nil if matched == nil
-
-    pixels = Float(matched[1])
-    return nil unless pixels.finite? && pixels.positive?
-
-    pixels
-  rescue ArgumentError
-    nil
-  end
-
-  private_class_method :image_for_thumbnail_upload,
-                       :svg_content_type?,
-                       :decode_raster_thumbnail,
-                       :decode_svg_thumbnail,
-                       :raster_thumbnail_format,
-                       :sanitised_svg_bytes,
-                       :svg_uses_disallowed_features?,
-                       :external_svg_reference?,
-                       :external_svg_url?,
-                       :style_contains_disallowed_urls?,
-                       :svg_url_function_disallowed?,
-                       :svg_dimensions,
-                       :svg_length_to_pixels
-
-  def parse_original_created_value field
-    raw_value = public_send("#{ field }_before_type_cast")
-    value = public_send(field)
-    return nil if raw_value.blank? && value.blank?
-
-    time =
-        case raw_value
-        when String
-          parse_original_created_string(raw_value)
-        when Time, ActiveSupport::TimeWithZone
-          raw_value.in_time_zone
-        else
-          value&.in_time_zone
-        end
-    if time.nil?
-      errors.add field, ORIGINAL_CREATED_INVALID_MESSAGE
-      return nil
-    end
-    unless minute_precision_time?(time)
-      errors.add field, ORIGINAL_CREATED_MINUTE_PRECISION_MESSAGE
-      return nil
-    end
-    time
-  end
-
-  def parse_original_created_string raw_value
-    value = raw_value.to_s.strip
-    return nil if value.blank?
-
-    match = value.match(/\A(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})\z/)
-    if match
-      year = match[1].to_i
-      month = match[2].to_i
-      day = match[3].to_i
-      hour = match[4].to_i
-      minute = match[5].to_i
-      return nil unless valid_original_created_components?(year, month, day, hour, minute, 0)
-
-      return Time.zone.local(year, month, day, hour, minute)
-    end
-
-    match =
-        value.match(
-            /
-              \A(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})
-              (?::(\d{2})(?:\.(\d+))?)?
-              (Z|[+-]\d{2}:?\d{2})?
-              \z
-            /x)
-    return nil if match.nil?
-
-    year = match[1].to_i
-    month = match[2].to_i
-    day = match[3].to_i
-    hour = match[4].to_i
-    minute = match[5].to_i
-    second = match[6]&.to_i || 0
-    fraction = match[7]
-    offset = match[8]
-    return nil unless valid_original_created_components?(year, month, day, hour, minute, second)
-    return nil if offset.present? && !(valid_original_created_offset?(offset))
-
-    if offset.present?
-      return Time.new(
-          year,
-          month,
-          day,
-          hour,
-          minute,
-          second + Rational(parse_original_created_nanoseconds(fraction), 1_000_000_000),
-          normalise_original_created_offset(offset)).in_time_zone
-    end
-
-    Time.zone.local(
-        year,
-        month,
-        day,
-        hour,
-        minute,
-        second).change(nsec: parse_original_created_nanoseconds(fraction))
-  rescue ArgumentError, TypeError
-    nil
-  end
-
-  def minute_precision_time? value
-    value.sec.zero? && value.nsec.zero?
-  end
-
-  def valid_original_created_components? year, month, day, hour, minute, second
-    return false unless Date.valid_date?(year, month, day)
-    return false unless hour.between?(0, 23)
-    return false unless minute.between?(0, 59)
-    return false unless second.between?(0, 59)
-
-    true
-  end
-
-  def valid_original_created_offset? value
-    match = value.match(/\A([+-])(\d{2}):?(\d{2})\z/)
-    return true if value == 'Z'
-    return false if match.nil?
-
-    hours = match[2].to_i
-    minutes = match[3].to_i
-    hours.between?(0, 23) && minutes.between?(0, 59)
-  end
-
-  def parse_original_created_nanoseconds value
-    return 0 if value.blank?
-
-    digits = value[0, 9].ljust(9, '0')
-    Integer(digits, 10)
-  end
-
-  def normalise_original_created_offset value
-    return '+00:00' if value == 'Z'
-
-    value.match?(/\A[+-]\d{2}:\d{2}\z/) ? value : "#{ value[0, 3] }:#{ value[3, 2] }"
-  end
-
-  def skip_original_created_validation?
-    return false if new_record?
-    return false if will_save_change_to_original_created_from?
-    return false if will_save_change_to_original_created_before?
-
-    true
   end
 end

backend/app/models/post_tag.rb

@@ -10,12 +10,6 @@ class PostTag < ApplicationRecord
   belongs_to :created_user, class_name: 'User', optional: true
   belongs_to :deleted_user, class_name: 'User', optional: true
 
-  has_many :sections, -> { order(:begin_ms) }, class_name: 'PostTagSection',
-                                               foreign_key: [:post_id, :tag_id],
-                                               primary_key: [:post_id, :tag_id],
-                                               dependent: :delete_all,
-                                               inverse_of: :post_tag
-
   validates :post_id, presence: true
   validates :tag_id, presence: true
   validates :post_id, uniqueness: {

backend/app/models/post_tag_section.rb

@@ -1,20 +0,0 @@
-class PostTagSection < ApplicationRecord
-  self.primary_key = :post_id, :tag_id, :begin_ms
-
-  belongs_to :post
-  belongs_to :tag
-
-  belongs_to :post_tag, -> { kept }, foreign_key: [:post_id, :tag_id],
-                                     primary_key: [:post_id, :tag_id],
-                                     inverse_of: :sections,
-                                     optional: true
-
-  validates :post_id, presence: true
-  validates :tag_id, presence: true
-
-  validates :begin_ms, presence: true,
-                       numericality: { only_integer: true, greater_than_or_equal_to: 0 }
-
-  validates :end_ms, numericality: { only_integer: true, greater_than: :begin_ms },
-                     allow_nil: true
-end

backend/app/models/post_url_sanitisation_rule.rb

@@ -1,163 +0,0 @@
-class PostUrlSanitisationRule < ApplicationRecord
-  include Discard::Model
-
-  class InvalidUrlError < StandardError
-    attr_reader :invalid_rows
-
-    def initialize(invalid_rows)
-      @invalid_rows = invalid_rows
-      ids = invalid_rows.map { _1.fetch(:post_id) }.join(', ')
-      super("post URL sanitisation produced invalid URLs for posts #{ ids }")
-    end
-  end
-
-  class UrlConflictError < StandardError
-    attr_reader :conflicts
-
-    def initialize(conflicts)
-      @conflicts = conflicts
-      urls = conflicts.map { _1.fetch(:url) }.uniq.join(', ')
-      super("post URL sanitisation conflicts detected for #{ urls }")
-    end
-  end
-
-  self.primary_key = :priority
-
-  default_scope -> { kept }
-
-  validates :source_pattern, presence: true, uniqueness: true
-
-  validate :source_pattern_must_be_regexp
-
-  class << self
-    def sanitise(url) = sanitise_with_rules(url, rules)
-
-    def apply!
-      rewrites = nil
-
-      Post.transaction do
-        compiled_rules = rules
-
-        rewrites = Post.order(:id)
-                       .lock('FOR UPDATE')
-                       .pluck(:id, :url)
-                       .map do |post_id, original_url|
-          { post_id:,
-            original_url:,
-            sanitised_url: sanitise_with_rules(original_url, compiled_rules) }
-        end
-
-        invalid_rows = rewrites.filter { invalid_sanitised_url?(_1.fetch(:sanitised_url)) }
-                               .map { { post_id: _1.fetch(:post_id),
-                                        original_url: _1.fetch(:original_url),
-                                        sanitised_url: _1.fetch(:sanitised_url) } }
-        raise InvalidUrlError.new(invalid_rows) if invalid_rows.present?
-
-        conflicts = build_conflicts(rewrites)
-        raise UrlConflictError.new(conflicts) if conflicts.present?
-
-        changed = rewrites.filter { _1.fetch(:original_url) != _1.fetch(:sanitised_url) }
-        return if changed.empty?
-
-        token = SecureRandom.hex(6)
-
-        changed.each do |row|
-          Post.where(id: row.fetch(:post_id))
-              .update_all(url: temporary_url_for(row.fetch(:post_id), token))
-        end
-
-        changed.each do |row|
-          Post.where(id: row.fetch(:post_id))
-              .update_all(url: row.fetch(:sanitised_url))
-        end
-      end
-    rescue ActiveRecord::RecordNotUnique => error
-      conflicts = build_persisted_conflicts(rewrites)
-      raise error if conflicts.empty?
-
-      raise UrlConflictError.new(conflicts), cause: error
-    end
-
-    private
-
-    def rules = kept.order(:priority).map { |r| [Regexp.new(r.source_pattern), r.replacement] }
-
-    def sanitise_with_rules(url, compiled_rules)
-      compiled_rules.reduce(url.dup) do |value, (pattern, replacement)|
-        value.sub(pattern, replacement)
-      end
-    end
-
-    def temporary_url_for(post_id, token) =
-        "https://post-url-sanitising.invalid/#{ token }/#{ post_id }"
-
-    def invalid_sanitised_url?(url)
-      return true if url.blank?
-      return true if url.length > 768
-
-      parsed = URI.parse(url)
-      return true if !(parsed in URI::HTTP)
-      return true if parsed.host.blank?
-
-      false
-    rescue URI::InvalidURIError
-      true
-    end
-
-    def build_conflicts(rewrites)
-      rewrites
-          .group_by { _1.fetch(:sanitised_url).downcase }
-          .values
-          .filter { _1.size > 1 }
-          .flatten
-          .map { { url: _1.fetch(:sanitised_url),
-                   post_id: _1.fetch(:post_id),
-                   original_url: _1.fetch(:original_url) } }
-    end
-
-    def build_persisted_conflicts(rewrites)
-      return [] if rewrites.blank?
-
-      target_rows = rewrites.filter { _1.fetch(:original_url) != _1.fetch(:sanitised_url) }
-      target_keys = target_rows.map { _1.fetch(:sanitised_url).downcase }.uniq
-      return [] if target_keys.empty?
-
-      target_pairs = target_rows.to_h do |row|
-        [row.fetch(:post_id), row.fetch(:sanitised_url).downcase]
-      end
-
-      persisted_rows = Post.order(:id)
-                           .where('LOWER(url) IN (?)', target_keys)
-                           .pluck(:id, :url)
-                           .reject { |post_id, original_url| target_pairs[post_id] == original_url.downcase }
-                           .map { |post_id, original_url|
-        { url: original_url,
-          post_id:,
-          original_url:,
-          conflict_key: original_url.downcase }
-      }
-
-      target_conflicts = target_rows.map { { url: _1.fetch(:sanitised_url),
-                                             post_id: _1.fetch(:post_id),
-                                             original_url: _1.fetch(:original_url),
-                                             conflict_key: _1.fetch(:sanitised_url).downcase } }
-
-      (persisted_rows + target_conflicts)
-          .group_by { _1.fetch(:conflict_key) }
-          .values
-          .filter { _1.size > 1 }
-          .flatten
-          .map { _1.except(:conflict_key) }
-    end
-  end
-
-  private
-
-  def source_pattern_must_be_regexp
-    return if source_pattern.blank?
-
-    Regexp.new(source_pattern)
-  rescue RegexpError
-    errors.add :source_pattern, '変な正規表現だね〜（笑）'
-  end
-end

backend/app/models/post_version.rb

@@ -5,7 +5,6 @@ class PostVersion < ApplicationRecord
   belongs_to :parent, class_name: 'Post', optional: true
 
   validates :url, presence: true
-  validates :video_ms, numericality: { only_integer: true, greater_than: 0 }, allow_nil: true
 
   validate :validate_original_created_range
 

backend/app/models/setting.rb

@@ -1,52 +1,7 @@
 class Setting < ApplicationRecord
-  THEMES = ['system', 'light', 'dark'].freeze
-
-  # These remain in the typed settings schema to preserve existing backend
-  # work. The common `/users/settings` page currently surfaces only `theme`.
-  AUTO_FETCH_MODES = ['auto', 'manual', 'off'].freeze
-  WIKI_EDITOR_MODES = ['split', 'write', 'preview'].freeze
-
-  STRING_ATTRIBUTES = [
-    'theme',
-    'auto_fetch_title',
-    'auto_fetch_thumbnail',
-    'wiki_editor_mode',
-  ].freeze
-  INTEGER_ATTRIBUTES = [].freeze
-  BOOLEAN_ATTRIBUTES = [].freeze
-  EDITABLE_ATTRIBUTES =
-      (STRING_ATTRIBUTES + INTEGER_ATTRIBUTES + BOOLEAN_ATTRIBUTES).freeze
-  TYPE_BY_ATTRIBUTE = {
-    'theme' => :string,
-    'auto_fetch_title' => :string,
-    'auto_fetch_thumbnail' => :string,
-    'wiki_editor_mode' => :string,
-  }.freeze
-
   belongs_to :user
 
   validates :user_id, presence: true
-  validates :user_id, uniqueness: true
+  validates :key, presence: true, length: { maximum: 255 }
-
+  validates :value, presence: true
-  validates :theme, inclusion: { in: THEMES }
-  validates :auto_fetch_title, inclusion: { in: AUTO_FETCH_MODES }
-  validates :auto_fetch_thumbnail, inclusion: { in: AUTO_FETCH_MODES }
-  validates :wiki_editor_mode, inclusion: { in: WIKI_EDITOR_MODES }
-
-  def self.defaults
-    {
-      theme: 'system',
-      auto_fetch_title: 'manual',
-      auto_fetch_thumbnail: 'manual',
-      wiki_editor_mode: 'split',
-    }
-  end
-
-  def self.serializable_attributes
-    EDITABLE_ATTRIBUTES.map(&:to_sym)
-  end
-
-  def serializable_hash(options = nil)
-    super({ only: self.class.serializable_attributes }.merge(options || { }))
-  end
 end

backend/app/models/tag.rb

@@ -17,16 +17,6 @@ class Tag < ApplicationRecord
     end
   end
 
-  class SectionLiteralParseError < ArgumentError
-    attr_reader :tag_name, :literal
-
-    def initialize tag_name, literal
-      @tag_name = tag_name
-      @literal = literal
-      super("invalid section literal for tag #{ tag_name }: #{ literal }")
-    end
-  end
-
   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'
@@ -115,60 +105,26 @@ class Tag < ApplicationRecord
   def self.normalise_tags! tag_names, with_tagme: true,
                                       with_no_deerjikist: true,
                                       deny_nico: true,
-                                      deny_deprecated: false,
+                                      deny_deprecated: false
-                                      with_sections: false
     if deny_nico && tag_names.any? { |n| n.downcase.start_with?('nico:') }
       raise NicoTagNormalisationError
     end
 
-    sections = { }
     tags = tag_names.map do |name|
-      raw_name = name
       pf, cat = CATEGORY_PREFIXES.find { |p, _| name.downcase.start_with?(p) } || ['', nil]
-
+      name = TagName.canonicalise(name.sub(/\A#{ pf }/i, '')).first
-      name = name.sub(/\A#{ pf }/i, '')
-
-      sections_by_tag = []
-      while (match = name.match(/\A(\S*?)\[([^\[\]\s]*)-([^\[\]\s]*)\](\S*)\z/))
-        name = "#{ match[1] }#{ match[4] }"
-        next if match[2].empty? && match[3].empty?
-
-        sections_by_tag << normalise_section_range!(
-            begin_raw: match[2],
-            end_raw: match[3],
-            tag_name: name)
-      end
-
-      if name.include?('[') || name.include?(']')
-        raise SectionLiteralParseError.new(raw_name, raw_name)
-      end
-
-      name = TagName.canonicalise(name).first
-
       find_or_create_by_tag_name!(name, category: (cat || :general)).tap do |tag|
         if deny_deprecated && tag.deprecated?
           raise DeprecatedTagNormalisationError, [tag.name]
         end
 
         tag.update!(category: cat) if cat && tag.category != cat
-        next if sections_by_tag.empty?
-
-        sections[tag.id] ||= []
-        sections[tag.id].concat(sections_by_tag)
-        sections[tag.id] = merge_section_ranges(sections[tag.id])
-        sections.delete(tag.id) if sections[tag.id] == [[0, nil]]
       end
     end
 
     tags << Tag.tagme if with_tagme && tags.size < 10 && tags.none?(Tag.tagme)
     tags << Tag.no_deerjikist if with_no_deerjikist && tags.all? { |t| !(t.deerjikist?) }
-    tags.uniq!(&:id)
+    tags.uniq(&:id)
-
-    if with_sections
-      { tags:, sections: }
-    else
-      tags
-    end
   end
 
   def self.expand_parent_tags tags
@@ -194,45 +150,6 @@ class Tag < ApplicationRecord
     (result + tags).uniq { |t| t.id }
   end
 
-  def self.normalise_section_range! begin_raw:, end_raw:, tag_name:
-    begin_ms = begin_raw.empty? ? 0 : time_to_ms!(begin_raw, tag_name:)
-    end_ms = end_raw.empty? ? nil : time_to_ms!(end_raw, tag_name:)
-
-    if end_ms
-      begin_ms, end_ms = end_ms, begin_ms if begin_ms > end_ms
-      end_ms = begin_ms + 1 if begin_ms == end_ms
-    end
-
-    [begin_ms, end_ms]
-  end
-
-  def self.merge_section_ranges ranges
-    sorted_ranges = ranges.sort_by { |begin_ms, end_ms| [begin_ms, end_ms || Float::INFINITY] }
-    merged = []
-
-    sorted_ranges.each do |begin_ms, end_ms|
-      if merged.empty?
-        merged << [begin_ms, end_ms]
-        next
-      end
-
-      last_begin_ms, last_end_ms = merged[-1]
-      if last_end_ms.nil? || begin_ms <= last_end_ms
-        merged[-1] = [last_begin_ms, merge_section_end(last_end_ms, end_ms)]
-      else
-        merged << [begin_ms, end_ms]
-      end
-    end
-
-    merged
-  end
-
-  def self.merge_section_end left_end_ms, right_end_ms
-    return nil if left_end_ms.nil? || right_end_ms.nil?
-
-    [left_end_ms, right_end_ms].max
-  end
-
   def self.find_or_create_by_tag_name! name, category:
     tn = TagName.find_undiscard_or_create_by!(name: name.to_s.strip)
     tn = tn.canonical if tn.canonical_id?
@@ -329,32 +246,6 @@ class Tag < ApplicationRecord
     end
   end
 
-  def self.time_to_ms! str, tag_name:
-    match =
-        case str
-        when /\A(?<seconds>\d+)(?:\.(?<ms>\d{1,3}))?\z/
-          { hours: nil, minutes: nil, seconds: Regexp.last_match[:seconds],
-            ms: Regexp.last_match[:ms] }
-        when /\A(?<minutes>\d+):(?<seconds>[0-5]?\d)(?:\.(?<ms>\d{1,3}))?\z/
-          { hours: nil, minutes: Regexp.last_match[:minutes],
-            seconds: Regexp.last_match[:seconds],
-            ms: Regexp.last_match[:ms] }
-        when /\A(?<hours>\d+):(?<minutes>[0-5]?\d):(?<seconds>[0-5]?\d)(?:\.(?<ms>\d{1,3}))?\z/
-          { hours: Regexp.last_match[:hours],
-            minutes: Regexp.last_match[:minutes],
-            seconds: Regexp.last_match[:seconds],
-            ms: Regexp.last_match[:ms] }
-        end
-
-    raise SectionLiteralParseError.new(tag_name, str) unless match
-
-    total_s = match[:seconds].to_i
-    total_s += match[:minutes].to_i * 60 if match[:minutes]
-    total_s += match[:hours].to_i * 3_600 if match[:hours]
-
-    total_s * 1_000 + match[:ms].to_s.ljust(3, '0')[0, 3].to_i
-  end
-
   def nico_tags_cannot_be_deprecated
     if nico? && deprecated_at.present?
       errors.add :deprecated_at, 'ニコタグは廃止できません．'

backend/app/models/tag_implication.rb

@@ -6,7 +6,6 @@ class TagImplication < ApplicationRecord
   validates :parent_tag_id, presence: true
 
   validate :parent_tag_mustnt_be_itself
-  validate :parent_tag_mustnt_create_cycle
 
   private
 
@@ -15,27 +14,4 @@ class TagImplication < ApplicationRecord
       errors.add :parent_tag_id, '親タグは子タグと同一であってはなりません．'
     end
   end
-
-  def parent_tag_mustnt_create_cycle
-    return if tag_id.blank? || parent_tag_id.blank?
-    return if errors[:parent_tag_id].present?
-
-    seen = { }
-    stack = [parent_tag_id]
-
-    until stack.empty?
-      current_id = stack.pop
-      next if seen[current_id]
-
-      seen[current_id] = true
-
-      if current_id == tag_id
-        errors.add :parent_tag_id, '親タグに子孫タグを指定すると循環します．'
-        errors.add :base, 'タグの親子関係が循環します．'
-        return
-      end
-
-      stack.concat(TagImplication.where(tag_id: current_id).pluck(:parent_tag_id))
-    end
-  end
 end

backend/app/models/user.rb

@@ -7,8 +7,7 @@ class User < ApplicationRecord
 
   has_many :created_posts,
            class_name: 'Post', foreign_key: :uploaded_user_id, dependent: :nullify
-  has_one :setting, dependent: :destroy
+  has_many :settings
-  has_many :theme_slots, class_name: 'UserThemeSlot', dependent: :destroy
   has_many :user_ips, dependent: :destroy
   has_many :ip_addresses, through: :user_ips
   has_many :user_post_views, dependent: :destroy

backend/app/models/user_theme_slot.rb

@@ -1,27 +0,0 @@
-class UserThemeSlot < ApplicationRecord
-  BASE_THEMES = ['light', 'dark'].freeze
-  SLOT_NOS = [1, 2, 3].freeze
-
-  belongs_to :user
-
-  validates :user_id, presence: true
-  validates :base_theme, presence: true, inclusion: { in: BASE_THEMES }
-  validates :slot_no, presence: true, inclusion: { in: SLOT_NOS }
-  validates :tokens, presence: true
-  validates :user_id, uniqueness: { scope: [:base_theme, :slot_no] }
-
-  validate :tokens_must_be_object
-
-  def serializable_hash(options = nil)
-    hash = { only: [:base_theme, :slot_no, :tokens, :created_at, :updated_at] }
-    super(hash.merge(options || {}))
-  end
-
-  private
-
-  def tokens_must_be_object
-    return if tokens.is_a?(Hash)
-
-    errors.add(:tokens, 'は JSON object で指定してください．')
-  end
-end

backend/app/representations/post_compact_repr.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-
-module PostCompactRepr
-  module_function
-
-  def base post, host: nil
-    return nil if post.nil?
-
-    PostRepr
-        .common(post, host:)
-        .slice(
-            'id',
-            'title',
-            'url',
-            'thumbnail',
-            'thumbnail_base')
-  end
-end

backend/app/representations/post_repr.rb

@@ -8,7 +8,6 @@ module PostRepr
       :url,
       :title,
       :thumbnail_base,
-      :video_ms,
       :original_created_from,
       :original_created_before,
       :created_at,
@@ -17,103 +16,51 @@ module PostRepr
 
   module_function
 
-  def base post, current_user = nil, host: nil
+  def base post, current_user = nil
-    json =
+    json = common(post)
-        if host.present?
+    json['tags'] = tag_json(post.tags)
-          common(post, host:)
-        else
-          common(post)
-        end
-    json['tags'] = tag_json(post)
     json['uploaded_user'] = post.uploaded_user && UserRepr.base(post.uploaded_user)
     json['viewed'] = current_user ? current_user.viewed?(post) : false
     json
   end
 
   def detail post, current_user = nil, parent_posts: [], child_posts: [],
-             sibling_posts: { }, related: [], host: nil
+             sibling_posts: { }, related: []
-    if host.present?
+    base(post, current_user).merge(
-      base(post, current_user, host:).merge(
+        'parent_posts' => cards(parent_posts),
-          'parent_posts' => cards(parent_posts, host:),
+        'child_posts' => cards(child_posts),
-          'child_posts' => cards(child_posts, host:),
+        'sibling_posts' => sibling_posts.transform_keys(&:to_s).transform_values { |posts|
-          'sibling_posts' => sibling_posts.transform_keys(&:to_s).transform_values { |posts|
+          cards(posts)
-            cards(posts, host:)
+        },
-          },
+        'related' => cards(related))
-          'related' => cards(related, host:))
-    else
-      base(post, current_user).merge(
-          'parent_posts' => cards(parent_posts),
-          'child_posts' => cards(child_posts),
-          'sibling_posts' => sibling_posts.transform_keys(&:to_s).transform_values { |posts|
-            cards(posts)
-          },
-          'related' => cards(related))
-    end
   end
 
-  def card post, host: nil
+  def card post
-    if host.present?
+    common(post).merge('parent_posts' => [], 'child_posts' => [])
-      common(post, host:).merge('parent_posts' => [], 'child_posts' => [])
-    else
-      common(post).merge('parent_posts' => [], 'child_posts' => [])
-    end
   end
 
-  def cards posts, host: nil
+  def cards posts
-    if host.present?
+    posts.map { |post| card(post) }
-      posts.map { |post| card(post, host:) }
-    else
-      posts.map { |post| card(post) }
-    end
   end
 
-  def many posts, current_user = nil, host: nil
+  def many posts, current_user = nil
-    if host.present?
+    posts.map { |p| base(p, current_user) }
-      posts.map { |p| base(p, current_user, host:) }
-    else
-      posts.map { |p| base(p, current_user) }
-    end
   end
 
-  def common post, host: nil
+  def common post
     BASE_FIELDS.to_h { |field| [field.to_s, post.public_send(field)] }
-               .merge(
+               .merge('thumbnail' => thumbnail_url(post))
-                   'thumbnail' =>
-                       if host.present?
-                         thumbnail_url(post, host:)
-                       else
-                         thumbnail_url(post)
-                       end)
   end
 
-  def tag_json post
+  def tag_json tags
-    post
+    tags.reject(&:deprecated?).map { |tag| TagRepr.inline(tag) }
-        .active_post_tags
-        .reject { _1.tag.deprecated? }
-        .sort_by { _1.tag.name }
-        .map { |post_tag|
-      TagRepr.inline(post_tag.tag).merge(
-          'children' => [],
-          'sections' => post_tag.sections.as_json(only: [:begin_ms, :end_ms]))
-    }
   end
 
-  def thumbnail_url post, host: nil
+  def thumbnail_url post
     return nil unless post.thumbnail.attached?
 
-    options = { only_path: false }
+    Rails.application.routes.url_helpers.rails_blob_url(post.thumbnail, only_path: false)
-    options[:host] = host if host.present?
+  rescue
-
-    Rails.application.routes.url_helpers.rails_storage_proxy_url(post.thumbnail, **options)
-  rescue ActionController::UrlGenerationError, ArgumentError, URI::InvalidURIError => e
-    payload = {
-        post_id: post.id,
-        attachment_id: post.thumbnail.attachment&.id,
-        blob_id: post.thumbnail.blob&.id,
-        error_class: e.class,
-        message: e.message }
-
-    Rails.logger.warn("PostRepr.thumbnail_url failed #{ payload.to_json }")
     nil
   end
 end

backend/app/services/post_bulk_creator.rb

@@ -1,202 +0,0 @@
-class PostBulkCreator
-  def initialize actor:, posts:, thumbnails:, host: nil
-    @actor_id = actor.id
-    @posts = posts
-    @thumbnails = thumbnails
-    @host = host
-  end
-
-  def run
-    results = Array.new(@posts.length)
-    mutex = Mutex.new
-    next_index = 0
-
-    workers = Array.new(2) do
-      Thread.new do
-        Rails.application.executor.wrap do
-          ActiveRecord::Base.connection_pool.with_connection do
-            actor = User.find(@actor_id)
-            loop do
-              index = nil
-              begin
-                index = mutex.synchronize do
-                  current = next_index
-                  next_index += 1
-                  current
-                end
-                break if index >= @posts.length
-
-                attributes = @posts[index]
-                results[index] = create_row(actor, attributes, index)
-              rescue StandardError => e
-                Rails.logger.error(
-                    "post_bulk_creator_worker_failure #{ { error: e.class.name,
-                                                          message: e.message,
-                                                          index: }.to_json }")
-                results[index] = {
-                    status: 'failed',
-                    recoverable: false,
-                    errors: { base: ['登録中にエラーが発生しました．'] },
-                    base_errors: [] }
-              end
-            end
-          end
-        end
-      end
-    end
-    workers.each(&:join)
-
-    results.each_index do |index|
-      next if results[index].present?
-
-      results[index] = {
-          status: 'failed',
-          recoverable: false,
-          errors: { base: ['登録中にエラーが発生しました．'] },
-          base_errors: [] }
-    end
-
-    { results: }
-  end
-
-  private
-
-  def create_row actor, attributes, index
-    preflight =
-        PostCreatePreflight.new(
-            attributes: attributes,
-            thumbnail: thumbnail_for(index, attributes),
-            host: @host).run
-    if preflight[:existing_post_id].present?
-      return {
-          status: 'skipped',
-          existing_post_id: preflight[:existing_post_id],
-          existing_post: preflight[:existing_post] }
-    end
-
-    post = PostCreator.new(
-        actor: actor,
-        attributes: normalised_attributes(attributes, preflight, index)).create!
-    result = {
-        status: 'created',
-        post: { id: post.id } }
-    result[:field_warnings] = preflight[:field_warnings] if preflight[:field_warnings].present?
-    result[:base_warnings] = preflight[:base_warnings] if preflight[:base_warnings].present?
-    result
-  rescue PostCreatePreflight::ValidationFailed => e
-    {
-        status: 'failed',
-        recoverable: true,
-        errors: e.fields,
-        base_errors: e.base_errors }
-  rescue ActiveRecord::RecordInvalid => e
-    existing_post = existing_post_for_race(attributes, e.record)
-    if existing_post.present?
-      return {
-          status: 'skipped',
-          existing_post_id: existing_post[:id],
-          existing_post: existing_post }
-    end
-
-    {
-        status: 'failed',
-        recoverable: true,
-        errors: e.record.errors.to_hash,
-        base_errors: e.record.errors[:base] }
-  rescue ActiveRecord::RecordNotUnique => e
-    if e.message.include?('index_posts_on_url')
-      existing_post = existing_post_for_race(attributes)
-      return {
-          status: 'skipped',
-          existing_post_id: existing_post[:id],
-          existing_post: existing_post } if existing_post.present?
-    end
-
-    Rails.logger.error(
-        "post_bulk_creator_record_not_unique #{ { error: e.class.name,
-                                                 message: e.message }.to_json }")
-    {
-        status: 'failed',
-        recoverable: false,
-        errors: { base: ['登録中にエラーが発生しました．'] },
-        base_errors: [] }
-  rescue Tag::NicoTagNormalisationError
-    {
-        status: 'failed',
-        recoverable: true,
-        errors: { tags: ['ニコニコ・タグは直接指定できません．'] },
-        base_errors: [] }
-  rescue Tag::DeprecatedTagNormalisationError
-    {
-        status: 'failed',
-        recoverable: true,
-        errors: { tags: ['廃止済みタグは付与できません．'] },
-        base_errors: [] }
-  rescue PostCreator::VideoMsParseError
-    {
-        status: 'failed',
-        recoverable: true,
-        errors: { video_ms: ['動画時間の記法が不正です．'] },
-        base_errors: [] }
-  rescue Post::RemoteThumbnailFetchFailed
-    {
-        status: 'failed',
-        recoverable: true,
-        errors: { thumbnail_base: ['サムネイル画像の取得に失敗しました．'] },
-        base_errors: [] }
-  rescue ArgumentError => e
-    {
-        status: 'failed',
-        recoverable: true,
-        errors: { base: [e.message] },
-        base_errors: [] }
-  rescue StandardError => e
-    Rails.logger.error(
-        "post_bulk_creator_failure #{ { error: e.class.name,
-                                        message: e.message }.to_json }")
-    {
-        status: 'failed',
-        recoverable: false,
-        errors: { base: ['登録中にエラーが発生しました．'] },
-        base_errors: [] }
-  end
-
-  def normalised_attributes attributes, preflight, index
-    {
-        url: preflight[:url],
-        title: preflight[:title],
-        thumbnail_base: preflight[:thumbnail_base],
-        thumbnail: thumbnail_for(index, attributes),
-        tags: preflight[:tags],
-        parent_post_ids: preflight[:parent_post_ids],
-        original_created_from: preflight[:original_created_from],
-        original_created_before: preflight[:original_created_before],
-        duration: preflight[:duration],
-        video_ms: preflight[:video_ms],
-        direct_tag_specs: preflight[:direct_tag_specs],
-        default_tag_specs: preflight[:default_tag_specs],
-        snapshot_tag_specs: preflight[:snapshot_tag_specs],
-        post_tag_specs: preflight[:post_tag_specs],
-        tag_sections: preflight[:tag_sections],
-        normalised_parent_post_ids: preflight[:normalised_parent_post_ids] }
-  end
-
-  def thumbnail_for index, attributes
-    return nil if attributes['thumbnail_base'].present? || attributes[:thumbnail_base].present?
-
-    @thumbnails[index]
-  end
-
-  def existing_post_for_race attributes, record = nil
-    return nil if record.present? && !(record.errors.of_kind?(:url, :taken))
-
-    normal_url = PostUrlNormaliser.normalise(attributes['url'] || attributes[:url])
-    return nil if normal_url.blank?
-
-    compact_existing_post(Post.with_attached_thumbnail.find_by(url: normal_url))
-  end
-
-  def compact_existing_post post
-    PostCompactRepr.base(post, host: @host)
-  end
-end

backend/app/services/post_create_plan.rb

@@ -1,271 +0,0 @@
-class PostCreatePlan
-  VIDEO_TAG_NAME = '動画'.freeze
-  TAGME_TAG_NAME = 'タグ希望'.freeze
-  NO_DEERJIKIST_TAG_NAME = 'ニジラー情報不詳'.freeze
-
-  def initialize attributes:
-    @attributes = attributes.symbolize_keys
-    @existing_tags_by_name = nil
-  end
-
-  def build!
-    direct_tag_specs, tag_sections = parse_direct_tag_specs
-    default_tag_specs = build_default_tag_specs(direct_tag_specs)
-    snapshot_tag_specs = merge_tag_specs(direct_tag_specs + default_tag_specs)
-    preload_existing_tags_by_name!(snapshot_tag_specs.map { _1[:name] })
-    validate_new_tag_specs!(snapshot_tag_specs)
-    post_tag_specs = expand_parent_tag_specs(snapshot_tag_specs)
-    video_ms = normalise_video_ms(snapshot_tag_specs)
-    validate_video_sections!(video_ms, tag_sections)
-    parent_post_ids = normalise_parent_post_ids
-    validate_parent_post_ids!(parent_post_ids)
-
-    {
-        url: @attributes[:url],
-        title: @attributes[:title].to_s,
-        thumbnail_base: @attributes[:thumbnail_base].presence,
-        original_created_from: @attributes[:original_created_from].presence,
-        original_created_before: @attributes[:original_created_before].presence,
-        tags: serialised_tags(direct_tag_specs, tag_sections),
-        display_tags: display_tags(direct_tag_specs, tag_sections),
-        duration: @attributes[:duration].to_s,
-        video_ms: video_ms,
-        parent_post_ids: parent_post_ids.join(' '),
-        direct_tag_specs: direct_tag_specs,
-        default_tag_specs: default_tag_specs,
-        snapshot_tag_specs: snapshot_tag_specs,
-        post_tag_specs: post_tag_specs,
-        tag_sections: tag_sections,
-        normalised_parent_post_ids: parent_post_ids }
-  end
-
-  private
-
-  def tag_names = @attributes[:tags].to_s.split
-
-  def parse_direct_tag_specs
-    tag_sections = { }
-    direct_tag_specs = []
-
-    tag_names.each do |raw_name|
-      tag_name, category, sections = parse_raw_tag_name(raw_name)
-      existing_tag = existing_tags_by_name[tag_name]
-      raise Tag::NicoTagNormalisationError if existing_tag&.nico?
-      raise Tag::DeprecatedTagNormalisationError, [existing_tag.name] if existing_tag&.deprecated?
-
-      direct_tag_specs << {
-          name: tag_name,
-          category: (category || existing_tag&.category || 'general').to_sym }
-      if sections.present?
-        tag_sections[tag_name] ||= []
-        tag_sections[tag_name].concat(sections)
-        tag_sections[tag_name] = Tag.merge_section_ranges(tag_sections[tag_name])
-        tag_sections.delete(tag_name) if tag_sections[tag_name] == [[0, nil]]
-      end
-    end
-
-    [merge_tag_specs(direct_tag_specs), tag_sections]
-  end
-
-  def parse_raw_tag_name raw_name
-    name = raw_name.to_s
-    prefix, category =
-        Tag::CATEGORY_PREFIXES.find {
-          name.downcase.start_with?(_1[0])
-        } || ['', nil]
-    name = name.sub(/\A#{ prefix }/i, '')
-
-    sections = []
-    while (match = name.match(/\A(\S*?)\[([^\[\]\s]*)-([^\[\]\s]*)\](\S*)\z/))
-      name = "#{ match[1] }#{ match[4] }"
-      next if match[2].empty? && match[3].empty?
-
-      sections << Tag.normalise_section_range!(
-          begin_raw: match[2],
-          end_raw: match[3],
-          tag_name: name)
-    end
-    if name.include?('[') || name.include?(']')
-      raise Tag::SectionLiteralParseError.new(raw_name, raw_name)
-    end
-
-    [resolved_tag_name(name), category&.to_sym, sections]
-  end
-
-  def build_default_tag_specs direct_tag_specs
-    default_tag_specs = []
-    if direct_tag_specs.length < 10 && direct_tag_specs.none? { _1[:name] == TAGME_TAG_NAME }
-      default_tag_specs << {
-          name: TAGME_TAG_NAME,
-          category: :meta }
-    end
-    if direct_tag_specs.none? { deerjikist_tag_spec?(_1) }
-      default_tag_specs << {
-          name: NO_DEERJIKIST_TAG_NAME,
-          category: :meta }
-    end
-
-    default_tag_specs
-  end
-
-  def validate_new_tag_specs! specs
-    Array(specs).each do |spec|
-      next if existing_tags_by_name.key?(spec[:name])
-
-      validate_new_tag_spec!(spec)
-    end
-  end
-
-  def validate_new_tag_spec! spec
-    tag_name = TagName.new(name: spec[:name])
-    tag = Tag.new(category: spec[:category], tag_name:)
-    return if tag_name.valid? && tag.valid?
-
-    post = Post.new
-    tag_name.errors[:name].each do |message|
-      post.errors.add :tags, "#{ spec[:name] }: #{ message }"
-    end
-    tag.errors.each do |error|
-      next if error.attribute == :tag_name
-
-      post.errors.add :tags, "#{ spec[:name] }: #{ error.message }"
-    end
-    raise ActiveRecord::RecordInvalid, post
-  end
-
-  def expand_parent_tag_specs snapshot_tag_specs
-    existing_snapshot_tags = snapshot_tag_specs.filter_map { existing_tags_by_name[_1[:name]] }
-    expanded_parent_specs =
-        Tag.expand_parent_tags(existing_snapshot_tags)
-           .reject(&:deprecated?)
-           .map { |tag|
-             {
-                 name: tag.name,
-                 category: tag.category.to_sym } }
-    merge_tag_specs(snapshot_tag_specs + expanded_parent_specs)
-  end
-
-  def merge_tag_specs specs
-    specs.each_with_object({ }) do |spec, merged|
-      merged[spec[:name]] =
-          if merged.key?(spec[:name]) && merged[spec[:name]][:category] != :general
-            merged[spec[:name]]
-          else
-            {
-                name: spec[:name],
-                category: spec[:category] }
-          end
-    end.values.sort_by { _1[:name] }
-  end
-
-  def existing_tags_by_name
-    @existing_tags_by_name ||= begin
-      names = tag_names.map { canonical_tag_name_without_sections(_1) }.uniq
-      Tag.joins(:tag_name).where(tag_names: { name: names }).index_by(&:name)
-    end
-  end
-
-  def preload_existing_tags_by_name! names
-    wanted_names = Array(names).map { _1.to_s }.reject(&:blank?).uniq
-    missing_names = wanted_names - existing_tags_by_name.keys
-    return if missing_names.empty?
-
-    existing_tags_by_name.merge!(
-        Tag.joins(:tag_name)
-           .where(tag_names: { name: missing_names })
-           .index_by(&:name))
-  end
-
-  def canonical_tag_name_without_sections raw_name
-    name, = parse_raw_tag_name(raw_name)
-    name
-  end
-
-  def deerjikist_tag_spec? spec
-    return true if spec[:category] == :deerjikist
-
-    existing_tags_by_name[spec[:name]]&.deerjikist?
-  end
-
-  def normalise_parent_post_ids
-    Array(@attributes[:parent_post_ids]).flat_map { _1.to_s.split }.map { |token|
-      id = Integer(token, exception: false)
-      raise ArgumentError, "親投稿 Id. が不正です: #{ token }" if id.nil? || id <= 0
-
-      id
-    }.uniq.sort
-  end
-
-  def validate_parent_post_ids! ids
-    missing = ids - Post.where(id: ids).pluck(:id)
-    raise ArgumentError, "存在しない親投稿 Id. があります: #{ missing.join(' ') }" if missing.present?
-  end
-
-  def serialised_tags direct_tag_specs, tag_sections
-    direct_tag_specs.map { |spec|
-      "#{ spec[:name] }#{ tag_sections[spec[:name]].to_a.map { section_literal(_1) }.join }"
-    }.sort.join(' ')
-  end
-
-  def display_tags direct_tag_specs, tag_sections
-    direct_tag_specs.map { |spec|
-      {
-          name: spec[:name],
-          category: spec[:category].to_s,
-          section_literals: tag_sections[spec[:name]].to_a.map { section_literal(_1) } }
-    }.sort_by { _1[:name] }
-  end
-
-  def section_literal range
-    begin_ms, end_ms = range
-    "[#{ Post.ms_to_time(begin_ms) }-#{ end_ms ? Post.ms_to_time(end_ms) : '' }]"
-  end
-
-  def normalise_video_ms snapshot_tag_specs
-    return nil unless snapshot_tag_specs.any? { _1[:name] == VIDEO_TAG_NAME }
-
-    video_ms = @attributes[:video_ms]
-    if video_ms.present?
-      value = Integer(video_ms, exception: false)
-      raise PostCreator::VideoMsParseError unless value&.positive?
-
-      return value
-    end
-
-    duration = @attributes[:duration]
-    return nil if duration.blank?
-
-    value = Tag.time_to_ms!(duration.to_s, tag_name: '動画時間')
-    raise PostCreator::VideoMsParseError unless value.positive?
-
-    value
-  rescue Tag::SectionLiteralParseError
-    raise PostCreator::VideoMsParseError
-  end
-
-  def validate_video_sections! video_ms, tag_sections
-    return unless video_ms
-
-    tag_sections.each_value do |ranges|
-      ranges.each do |begin_ms, end_ms|
-        if begin_ms >= video_ms
-          post = Post.new
-          post.errors.add :video_ms, 'タグ区間の開始が動画時間以上です．'
-          raise ActiveRecord::RecordInvalid, post
-        end
-        if end_ms && end_ms > video_ms
-          post = Post.new
-          post.errors.add :video_ms, 'タグ区間の終端が動画時間を超えてゐます．'
-          raise ActiveRecord::RecordInvalid, post
-        end
-      end
-    end
-  end
-
-  def resolved_tag_name name
-    tag_name = TagName.includes(:canonical).find_by(name:)
-    return name if tag_name.nil?
-
-    (tag_name.canonical || tag_name).name
-  end
-end

backend/app/services/post_create_preflight.rb

@@ -1,141 +0,0 @@
-class PostCreatePreflight
-  class ValidationFailed < StandardError
-    attr_reader :fields, :base_errors
-
-    def initialize fields: { }, base_errors: []
-      super('入力内容を確認してください．')
-      @fields = fields
-      @base_errors = base_errors
-    end
-  end
-
-  def initialize attributes:, thumbnail: nil, host: nil
-    @attributes = attributes.symbolize_keys
-    @thumbnail = thumbnail
-    @host = host
-  end
-
-  def run
-    preview = PostImportPreviewer.new.preview_rows(
-        rows: [preview_row],
-        fetch_metadata: false).first
-    if preview[:existing_post_id].present?
-      return {
-          url: preview[:url],
-          title: preview[:attributes]['title'],
-          thumbnail_base: preview[:attributes]['thumbnail_base'],
-          tags: preview[:attributes]['tags'],
-          parent_post_ids: preview[:attributes]['parent_post_ids'],
-          original_created_from: preview[:attributes]['original_created_from'],
-          original_created_before: preview[:attributes]['original_created_before'],
-          duration: preview[:attributes]['duration'],
-          video_ms: preview[:attributes]['video_ms'],
-          display_tags: preview[:display_tags] || [],
-          field_warnings: final_field_warnings(preview[:field_warnings] || { }),
-          base_warnings: preview[:base_warnings],
-          existing_post_id: preview[:existing_post_id],
-          existing_post: existing_post_compact(preview[:existing_post_id]) }
-    end
-
-    if preview[:validation_errors].present?
-      raise ValidationFailed.new(fields: preview[:validation_errors])
-    end
-
-    validate_thumbnail_upload!
-
-    plan = PostCreatePlan.new(
-        attributes: {
-            url: preview[:url],
-            title: preview[:attributes]['title'],
-            thumbnail_base: preview[:attributes]['thumbnail_base'],
-            tags: preview[:attributes]['tags'],
-            parent_post_ids: preview[:attributes]['parent_post_ids'],
-            original_created_from: preview[:attributes]['original_created_from'],
-            original_created_before: preview[:attributes]['original_created_before'],
-            duration: preview[:attributes]['duration'],
-            video_ms: preview[:attributes]['video_ms'] }).build!
-
-    {
-        url: plan[:url],
-        title: plan[:title],
-        thumbnail_base: plan[:thumbnail_base],
-        tags: plan[:tags],
-        parent_post_ids: plan[:parent_post_ids],
-        original_created_from: plan[:original_created_from],
-        original_created_before: plan[:original_created_before],
-        duration: plan[:duration],
-        video_ms: plan[:video_ms],
-        display_tags: plan[:display_tags],
-        direct_tag_specs: plan[:direct_tag_specs],
-        default_tag_specs: plan[:default_tag_specs],
-        snapshot_tag_specs: plan[:snapshot_tag_specs],
-        post_tag_specs: plan[:post_tag_specs],
-        tag_sections: plan[:tag_sections],
-        normalised_parent_post_ids: plan[:normalised_parent_post_ids],
-        field_warnings: final_field_warnings(preview[:field_warnings] || { }),
-        base_warnings: preview[:base_warnings],
-        existing_post_id: preview[:existing_post_id],
-        existing_post: existing_post_compact(preview[:existing_post_id]) }
-  end
-
-  private
-
-  def preview_row
-    {
-        source_row: 1,
-        url: @attributes[:url].to_s,
-        attributes: {
-            'title' => @attributes[:title].to_s,
-            'thumbnail_base' => @attributes[:thumbnail_base].to_s,
-            'original_created_from' => @attributes[:original_created_from].to_s,
-            'original_created_before' => @attributes[:original_created_before].to_s,
-            'duration' => @attributes[:duration].to_s,
-            'video_ms' => @attributes[:video_ms],
-            'tags' => @attributes[:tags].to_s,
-            'parent_post_ids' => parent_post_ids_text },
-        provenance: {
-            'url' => 'manual',
-            'title' => 'manual',
-            'thumbnail_base' => 'manual',
-            'original_created_from' => 'manual',
-            'original_created_before' => 'manual',
-            'duration' => 'manual',
-            'video_ms' => 'manual',
-            'tags' => 'manual',
-            'parent_post_ids' => 'manual' },
-        tag_sources: {
-            'automatic' => '',
-            'manual' => @attributes[:tags].to_s } }
-  end
-
-  def parent_post_ids_text
-    Array(@attributes[:parent_post_ids]).flat_map { _1.to_s.split }.join(' ')
-  end
-
-  def validate_thumbnail_upload!
-    return if @attributes[:thumbnail_base].present?
-    return if @thumbnail.blank?
-
-    PostThumbnailUploadValidator.validate!(@thumbnail)
-  rescue PostThumbnailUploadValidator::InvalidUpload => e
-    raise ValidationFailed.new(fields: { thumbnail: [e.message] })
-  end
-
-  def existing_post_compact post_id
-    return nil if post_id.blank?
-
-    post = Post.with_attached_thumbnail.find_by(id: post_id)
-    PostCompactRepr.base(post, host: @host)
-  end
-
-  def final_field_warnings field_warnings
-    thumbnail_warnings = (field_warnings['thumbnail_base'] || []).reject { _1 == 'サムネールなし' }
-    if @attributes[:thumbnail_base].blank? && @thumbnail.blank?
-      thumbnail_warnings = (thumbnail_warnings + ['サムネールなし']).uniq
-    end
-
-    next_warnings = field_warnings.except('thumbnail_base')
-    next_warnings['thumbnail_base'] = thumbnail_warnings if thumbnail_warnings.present?
-    next_warnings
-  end
-end

backend/app/services/post_creator.rb

@@ -1,154 +0,0 @@
-class PostCreator
-  class VideoMsParseError < ArgumentError; end
-
-  attr_reader :field_warnings
-
-  def initialize actor:, attributes:
-    @actor = actor
-    @attributes = attributes.symbolize_keys
-    @field_warnings = { }
-  end
-
-  def create!
-    thumbnail_attachment = prepare_thumbnail_attachment
-    post = Post.new(title: @attributes[:title].presence,
-                    url: @attributes[:url],
-                    thumbnail_base: @attributes[:thumbnail_base].presence,
-                    uploaded_user: @actor,
-                    original_created_from: @attributes[:original_created_from].presence,
-                    original_created_before: @attributes[:original_created_before].presence)
-
-    ApplicationRecord.transaction do
-      post.save!
-      post.thumbnail.attach(thumbnail_attachment) if thumbnail_attachment.present?
-      snapshot_tags = planned_snapshot_tags
-      post_tags = planned_post_tags
-      sections = planned_sections
-      TagVersioning.record_tag_snapshots!(snapshot_tags, created_by_user: @actor)
-      post.video_ms = planned_video_ms
-      post.save!
-      sync_post_tags!(post, post_tags, sections)
-      sync_parent_posts!(post, planned_parent_post_ids)
-      PostVersionRecorder.record!(post:, event_type: :create, created_by_user: @actor)
-    end
-    post
-  rescue StandardError
-    post&.thumbnail&.purge if post&.thumbnail&.attached?
-    raise
-  end
-
-  private
-
-  def prepare_thumbnail_attachment
-    PostThumbnailAttachmentBuilder.build(
-        thumbnail: @attributes[:thumbnail],
-        thumbnail_base: @attributes[:thumbnail_base].presence)
-  end
-
-  def planned_snapshot_tags = planned_create_attributes[:snapshot_tags]
-
-  def planned_post_tags = planned_create_attributes[:post_tags]
-
-  def planned_sections = planned_create_attributes[:tag_sections]
-
-  def planned_parent_post_ids = planned_create_attributes[:normalised_parent_post_ids]
-
-  def planned_video_ms
-    planned_create_attributes[:video_ms]
-  end
-
-  def planned_create_attributes
-    @planned_create_attributes ||= begin
-      if @attributes.key?(:snapshot_tag_specs)
-        snapshot_tags = materialise_tags(@attributes[:snapshot_tag_specs] || [])
-        post_tags = materialise_tags(@attributes[:post_tag_specs] || [])
-        {
-            snapshot_tags: snapshot_tags,
-            post_tags: post_tags,
-            tag_sections: materialise_sections(
-                @attributes[:tag_sections] || { },
-                snapshot_tags,
-                post_tags),
-            normalised_parent_post_ids: @attributes[:normalised_parent_post_ids] || [],
-            video_ms: @attributes[:video_ms] }
-      else
-        build_materialised_plan
-      end
-    end
-  end
-
-  def build_materialised_plan
-    plan = PostCreatePlan.new(attributes: @attributes).build!
-    snapshot_tags = materialise_tags(plan[:snapshot_tag_specs] || [])
-    post_tags = materialise_tags(plan[:post_tag_specs] || [])
-    {
-        snapshot_tags: snapshot_tags,
-        post_tags: post_tags,
-        tag_sections: materialise_sections(
-            plan[:tag_sections] || { },
-            snapshot_tags,
-            post_tags),
-        normalised_parent_post_ids: plan[:normalised_parent_post_ids] || [],
-        video_ms: plan[:video_ms] }
-  end
-
-  def materialise_tags specs
-    Array(specs).each_with_object({ }) do |spec, tags|
-      name = spec[:name] || spec['name']
-      category = spec[:category] || spec['category']
-      next if name.blank? || category.blank?
-
-      tag = Tag.find_or_create_by_tag_name!(name, category:)
-      tag.update!(category:) if tag.category.to_sym != category.to_sym
-      tags[name] ||= tag
-    end.values
-  end
-
-  def materialise_sections sections_by_name, snapshot_tags, post_tags
-    tags_by_name = post_tags.index_by(&:name)
-    snapshot_tags.each do |tag|
-      tags_by_name[tag.name] ||= tag
-    end
-
-    sections_by_name.each_with_object({ }) do |(tag_name, ranges), sections|
-      tag = tags_by_name[tag_name.to_s]
-      next if tag.nil?
-
-      sections[tag.id] = Array(ranges).map { |range| [range[0], range[1]] }
-    end
-  end
-
-  def sync_post_tags! post, desired_tags, sections
-    desired_ids = desired_tags.map(&:id).to_set
-    current_ids = post.tags.pluck(:id).to_set
-    Tag.where(id: desired_ids - current_ids).find_each do |tag|
-      PostTag.create_or_find_by!(post:, tag:, created_user: @actor)
-    end
-    PostTagSection.where(post_id: post.id).destroy_all
-    sections.each do |tag_id, ranges|
-      ranges.each do |begin_ms, end_ms|
-        PostTagSection.create!(post_id: post.id,
-                               tag_id:,
-                               begin_ms:,
-                               end_ms:)
-      end
-    end
-    PostTag.where(post_id: post.id,
-                  tag_id: (current_ids - desired_ids).to_a).kept.find_each do |post_tag|
-      post_tag.discard_by!(@actor)
-    end
-  end
-
-  def sync_parent_posts! post, ids
-    if ids.include?(post.id)
-      post.errors.add :parent_post_ids, '自分自身を親投稿にはできません．'
-      raise ActiveRecord::RecordInvalid, post
-    end
-    missing = ids - Post.where(id: ids).pluck(:id)
-    if missing.present?
-      post.errors.add :parent_post_ids, "存在しない親投稿 Id. があります: #{ missing.join(' ') }"
-      raise ActiveRecord::RecordInvalid, post
-    end
-    ids.each { |parent_post_id| PostImplication.create_or_find_by!(post:, parent_post_id:) }
-  end
-end

backend/app/services/post_import_previewer.rb

@@ -1,522 +0,0 @@
-require 'time'
-require 'timeout'
-
-class PostImportPreviewer
-  FIELDS = [
-      'title',
-      'thumbnail_base',
-      'original_created_from',
-      'original_created_before',
-      'video_ms',
-      'duration',
-      'tags',
-      'parent_post_ids'].freeze
-  FETCH_WARNING_FIELDS = ['url', 'title', 'thumbnail_base'].freeze
-  TITLE_FETCH_WARNING = 'タイトルを取得できませんでした．'.freeze
-  THUMBNAIL_FETCH_WARNING = 'サムネールを取得できませんでした．'.freeze
-  METADATA_FETCH_WARNING = '自動取得に失敗しました．'.freeze
-
-  def preview_rows rows:, fetch_metadata: true, metadata_cache: { }
-    prepared_rows = rows.map { prepare_row(_1) }
-    url_counts = prepared_rows.filter_map { _1[:normal_url] }.tally
-    existing_posts =
-        Post.where(url: prepared_rows.map { _1[:normal_url] }.compact.uniq).index_by(&:url)
-    existing_parent_ids = preload_parent_ids(prepared_rows)
-    preload_metadata!(
-        prepared_rows,
-        fetch_metadata,
-        metadata_cache,
-        existing_posts,
-        url_counts)
-    known_tags =
-        preload_known_tags(
-            prepared_rows,
-            fetch_metadata,
-            metadata_cache,
-            existing_posts,
-            url_counts)
-    prepared_rows.map { |row|
-      preview_row(row,
-                  fetch_metadata:,
-                  metadata_cache:,
-                  existing_posts:,
-                  url_counts:,
-                  known_tags:,
-                  existing_parent_ids:)
-    }
-  end
-
-  def normalised_url value
-    PostUrlNormaliser.normalise(value)
-  end
-
-  private
-
-  def prepare_row row
-    source = row.symbolize_keys
-    url = source[:url].to_s.strip
-    normal_url = normalised_url(url)
-    source.merge(url_text: url, normal_url:, url_error: validate_url_safety(normal_url))
-  end
-
-  def preview_row row,
-                  fetch_metadata:,
-                  metadata_cache:,
-                  existing_posts:,
-                  url_counts:,
-                  known_tags:,
-                  existing_parent_ids:
-    attributes = initial_attributes(row)
-    provenance = initial_provenance(row)
-    tag_sources = initial_tag_sources(row, attributes, provenance)
-    field_warnings = initial_field_warnings(row)
-    base_warnings = initial_base_warnings(row)
-    url = row[:url_text]
-    provenance['url'] = 'manual'
-    normal_url = row[:normal_url]
-    url_for_metadata = normal_url || url
-    existing_post = normal_url.present? ? existing_posts[normal_url] : nil
-
-    validation_errors = {}
-    validation_errors[:url] = ['URL が不正です．'] if normal_url.blank?
-    if row[:url_error].present?
-      validation_errors[:url] = [row[:url_error]]
-    end
-    if normal_url.present? && url_counts[normal_url].to_i > 1
-      validation_errors[:url] = ['URL が重複しています．']
-    end
-
-    if row[:metadata_url].present? && row[:metadata_url] != url_for_metadata
-      clear_automatic_values!(attributes, provenance, tag_sources)
-      field_warnings = { }
-      base_warnings = [ ]
-    end
-
-    if validation_errors.blank? && normal_url.present? && existing_post
-      attributes['tags'] = merged_tags(tag_sources, provenance['tags'])
-      warnings_present = field_warnings.values.any?(&:present?) || base_warnings.present?
-      return { source_row: row[:source_row],
-               url: normal_url,
-               attributes:,
-               provenance:,
-               tag_sources:,
-               metadata_url: url_for_metadata,
-               skip_reason: 'existing',
-               existing_post_id: existing_post.id,
-               field_warnings:,
-               base_warnings:,
-               validation_errors:,
-               status: warnings_present ? 'warning' : 'ready' }
-    end
-
-    should_fetch = validation_errors.blank?
-    should_fetch &&= should_fetch_metadata?(fetch_metadata, row[:source_row].to_i)
-    if should_fetch
-      clear_fetch_warnings!(field_warnings)
-      metadata = metadata_for(url_for_metadata, metadata_cache)
-      if metadata[:validation_errors].present?
-        validation_errors.merge!(metadata[:validation_errors])
-      else
-        apply_metadata!(attributes, provenance, tag_sources, metadata[:data])
-        apply_fetch_warnings!(field_warnings, metadata[:warnings])
-      end
-    end
-
-    attributes['url'] = url
-    validate_basic_data(attributes, validation_errors)
-    validate_preview_tags(merged_tags(tag_sources, provenance['tags']),
-                          validation_errors,
-                          known_tags)
-    validate_parents(attributes['parent_post_ids'], validation_errors, existing_parent_ids)
-    attributes.delete('url')
-    attributes['tags'] = merged_tags(tag_sources, provenance['tags'])
-
-    warnings_present = field_warnings.values.any?(&:present?) || base_warnings.present?
-    { source_row: row[:source_row],
-      url: validation_errors[:url].present? ? url : (normal_url || url),
-      attributes:,
-      provenance:,
-      tag_sources:,
-      metadata_url: url_for_metadata,
-      skip_reason: nil,
-      existing_post_id: nil,
-      field_warnings:,
-      base_warnings:,
-      validation_errors:,
-      status: validation_errors.present? ? 'error' : (warnings_present ? 'warning' : 'ready') }
-  end
-
-  def should_fetch_metadata? fetch_metadata, source_row
-    case fetch_metadata
-    when true then true
-    when Integer then fetch_metadata == source_row
-    when false, nil then false
-    else raise ArgumentError, '取得対象が不正です．'
-    end
-  end
-
-  def initial_attributes row
-    attributes = row[:attributes]&.stringify_keys || { }
-    FIELDS.to_h { |field|
-      value = attributes[field]
-      normalised =
-          if field == 'duration'
-            normalise_duration_attribute(value)
-          elsif field == 'video_ms'
-            value.nil? ? '' : value.to_s
-          else
-            value.to_s
-          end
-      [field, normalised] }
-  end
-
-  def initial_provenance row
-    provenance = row[:provenance]&.stringify_keys || { }
-    FIELDS.to_h { |field| [field, provenance[field].presence || 'automatic'] }
-      .merge('url' => 'manual')
-  end
-
-  def initial_tag_sources row, attributes, provenance
-    sources = row[:tag_sources]&.stringify_keys || { 'automatic' => '', 'manual' => '' }
-    sources['automatic'] = sources['automatic'].to_s
-    sources['manual'] =
-      provenance['tags'] == 'manual' ? attributes['tags'].to_s : sources['manual'].to_s
-    sources
-  end
-
-  def initial_field_warnings row
-    (row[:field_warnings] || { })
-      .stringify_keys
-      .transform_values { |value| Array(value).map(&:to_s) }
-  end
-
-  def initial_base_warnings row
-    Array(row[:base_warnings]).map(&:to_s)
-  end
-
-  def clear_automatic_values! attributes, provenance, tag_sources
-    ['title', 'thumbnail_base', 'original_created_from',
-     'original_created_before', 'video_ms', 'duration'].each do |field|
-      attributes[field] = '' if provenance[field] == 'automatic'
-    end
-    tag_sources['automatic'] = ''
-    attributes['tags'] = merged_tags(tag_sources, provenance['tags'])
-  end
-
-  def clear_fetch_warnings! field_warnings
-    FETCH_WARNING_FIELDS.each do |field|
-      field_warnings.delete(field)
-    end
-  end
-
-  def metadata_for url, cache
-    cache[url] ||= fetch_metadata(url)
-  end
-
-  def fetch_metadata url
-    return { data: { }, warnings: { 'url' => ['URL が空です．'] },
-             validation_errors: { } } if url.blank?
-
-    data = sanitise_metadata(PostMetadataFetcher.fetch(url).stringify_keys.compact)
-    warnings = { }
-    add_field_warning!(warnings, 'title', TITLE_FETCH_WARNING) if data['title'].blank?
-    if data['thumbnail_base'].blank?
-      add_field_warning!(warnings, 'thumbnail_base', THUMBNAIL_FETCH_WARNING)
-    end
-    { data:, warnings:, validation_errors: { } }
-  rescue Preview::UrlSafety::UnsafeUrl => e
-    payload = { error: e.class.name, message: e.message }
-    Rails.logger.info(
-        "post_import_metadata_fetch_unsafe_url #{ payload.to_json }")
-    { data: { }, warnings: { }, validation_errors: { url: [e.message] } }
-  rescue Preview::HttpFetcher::FetchFailed,
-         Preview::HttpFetcher::ResponseTooLarge => e
-    payload = { error: e.class.name, message: e.message }
-    Rails.logger.info(
-        "post_import_metadata_fetch_failure #{ payload.to_json }")
-    { data: { }, warnings: { 'url' => [METADATA_FETCH_WARNING] }, validation_errors: { } }
-  end
-
-  def sanitise_metadata metadata
-    {
-        'title' => sanitise_metadata_title(metadata['title']),
-        'thumbnail_base' => sanitise_metadata_url(metadata['thumbnail_base']),
-        'original_created_from' => sanitise_metadata_time(metadata['original_created_from']),
-        'original_created_before' => sanitise_metadata_time(metadata['original_created_before']),
-        'duration' => sanitise_metadata_duration(metadata['duration']),
-        'tags' => metadata['tags'].to_s.presence }.compact
-  end
-
-  def sanitise_metadata_title value
-    value.is_a?(String) ? value.presence : nil
-  end
-
-  def sanitise_metadata_url value
-    return nil unless value.is_a?(String)
-
-    stripped = value.strip
-    return nil if stripped.blank?
-
-    uri = URI.parse(stripped)
-    return nil unless uri.is_a?(URI::HTTP) && uri.host.present?
-
-    stripped
-  rescue URI::InvalidURIError
-    nil
-  end
-
-  def sanitise_metadata_time value
-    return nil unless value.is_a?(String)
-
-    Time.iso8601(value).in_time_zone.change(sec: 0, nsec: 0).iso8601
-  rescue ArgumentError, TypeError
-    nil
-  end
-
-  def sanitise_metadata_duration value
-    return nil unless value.is_a?(String)
-
-    value.presence
-  end
-
-  def normalise_duration_attribute value
-    return '' if value.nil?
-    return value if value.is_a?(String)
-
-    milliseconds = Integer(value, exception: false)
-    return value.to_s if milliseconds.nil? || milliseconds <= 0
-
-    seconds_string = (milliseconds / 1_000.0).to_s
-    seconds_string.end_with?('.0') ? seconds_string.delete_suffix('.0') : seconds_string
-  end
-
-  def preload_metadata! prepared_rows, fetch_metadata, metadata_cache, existing_posts, url_counts
-    urls = prepared_rows.filter_map { |row|
-      next unless row[:normal_url].present?
-      next if row[:url_error].present?
-      next unless should_fetch_metadata?(fetch_metadata, row[:source_row].to_i)
-      next if url_counts[row[:normal_url]].to_i > 1
-      next if existing_posts.key?(row[:normal_url])
-
-      row[:normal_url]
-    }.uniq
-    urls = urls.reject { metadata_cache.key?(_1) }
-    return if urls.empty?
-
-    url_queue = Queue.new
-    result_queue = Queue.new
-    urls.each { url_queue << _1 }
-    workers = [urls.length, 4].min.times.map {
-      Thread.new {
-        Rails.application.executor.wrap do
-          loop do
-            url = url_queue.pop(true)
-            result_queue << [url, safe_fetch_metadata(url)]
-          rescue ThreadError
-            break
-          end
-        end
-      }
-    }
-    Timeout.timeout(15) { workers.each(&:join) }
-  rescue Timeout::Error
-    workers&.each(&:kill)
-  ensure
-    workers&.each(&:join)
-    while result_queue&.size.to_i.positive?
-      url, result = result_queue.pop
-      metadata_cache[url] = result
-    end
-    urls&.each do |url|
-      metadata_cache[url] ||= { data: { }, warnings: { 'url' => [METADATA_FETCH_WARNING] } }
-    end
-  end
-
-  def safe_fetch_metadata url
-    fetch_metadata(url)
-  rescue Preview::UrlSafety::UnsafeUrl => e
-    payload = { error: e.class.name, message: e.message }
-    Rails.logger.info(
-        "post_import_metadata_fetch_unsafe_url #{ payload.to_json }")
-    { data: { }, warnings: { }, validation_errors: { url: [e.message] } }
-  rescue StandardError => e
-    payload = { error: e.class.name, message: e.message }
-    Rails.logger.error(
-        "post_import_metadata_fetch_unexpected_failure #{ payload.to_json }")
-    { data: { }, warnings: { 'url' => [METADATA_FETCH_WARNING] }, validation_errors: { } }
-  end
-
-  def preload_known_tags prepared_rows, fetch_metadata, metadata_cache, existing_posts, url_counts
-    names = prepared_rows.flat_map { |row|
-      attributes = initial_attributes(row)
-      provenance = initial_provenance(row)
-      tag_sources = initial_tag_sources(row, attributes, provenance)
-      if metadata_url_changed?(row)
-        clear_automatic_values!(attributes, provenance, tag_sources)
-      end
-      if should_apply_metadata_to_row?(row, fetch_metadata, existing_posts, url_counts)
-        metadata = metadata_for(row[:normal_url], metadata_cache)
-        apply_metadata!(attributes, provenance, tag_sources, metadata[:data])
-      end
-      preview_tag_names(merged_tags(tag_sources, provenance['tags']))
-    }.compact.uniq
-    return { } if names.empty?
-
-    Tag.joins(:tag_name)
-      .where(tag_names: { name: names })
-      .includes(:tag_name)
-      .to_a
-      .index_by(&:name)
-  end
-
-  def preload_parent_ids prepared_rows
-    ids = prepared_rows.flat_map { |row|
-      attributes = initial_attributes(row)
-      preview_parent_ids(attributes['parent_post_ids'])
-    }.uniq
-    return { } if ids.empty?
-
-    Post.where(id: ids).pluck(:id).to_h { [_1, true] }
-  end
-
-  def metadata_url_changed? row
-    row[:metadata_url].present? && row[:metadata_url] != (row[:normal_url] || row[:url_text])
-  end
-
-  def should_apply_metadata_to_row? row, fetch_metadata, existing_posts, url_counts
-    normal_url = row[:normal_url]
-    return false if normal_url.blank?
-    return false if row[:url_error].present?
-    return false if url_counts[normal_url].to_i > 1
-    return false if existing_posts.key?(normal_url)
-
-    should_fetch_metadata?(fetch_metadata, row[:source_row].to_i)
-  end
-
-  def validate_url_safety normal_url
-    return nil if normal_url.blank?
-
-    Preview::UrlSafety.validate(normal_url)
-    nil
-  rescue Preview::UrlSafety::UnsafeUrl => e
-    e.message
-  end
-
-  def apply_metadata! attributes, provenance, tag_sources, metadata
-    metadata.each do |field, value|
-      if field == 'tags'
-        next if provenance['tags'] == 'manual'
-
-        tag_sources['automatic'] = value.to_s
-        attributes['tags'] = merged_tags(tag_sources)
-        next
-      end
-      next unless provenance[field] == 'automatic'
-
-      attributes[field] = value
-      provenance[field] = 'automatic'
-    end
-  end
-
-  def apply_fetch_warnings! field_warnings, warnings
-    warnings.each do |field, values|
-      values.each do |value|
-        add_field_warning!(field_warnings, field, value)
-      end
-    end
-  end
-
-  def add_field_warning! field_warnings, field, message
-    field_warnings[field] ||= []
-    field_warnings[field] << message unless field_warnings[field].include?(message)
-  end
-
-  def merged_tags sources, origin = nil
-    return sources['manual'].to_s if origin == 'manual'
-
-    sources['automatic'].to_s
-  end
-
-  def preview_tag_names raw
-    names = raw.to_s.split
-    return [] if names.empty?
-    if names.any? { _1.downcase.start_with?('nico:') }
-      return []
-    end
-
-    names.map { |name| TagName.canonicalise(name.sub(/\[.*\]\z/, '')).first }
-  rescue Tag::SectionLiteralParseError
-    []
-  end
-
-  def validate_preview_tags raw, errors, known_tags
-    names = raw.to_s.split
-    return if names.empty?
-    if names.any? { _1.downcase.start_with?('nico:') }
-      errors[:tags] = ['ニコニコ・タグは直接指定できません．']
-      return
-    end
-
-    parsed = names.map { |name| TagName.canonicalise(name.sub(/\[.*\]\z/, '')).first }
-    existing = parsed.filter_map { known_tags[_1] }
-    deprecated = existing.select(&:deprecated?).map(&:name)
-    errors[:tags] = ["廃止済みタグがあります: #{ deprecated.join(' ') }"] if deprecated.present?
-  rescue Tag::SectionLiteralParseError
-    errors[:tags] = ['タグ区間の記法が不正です．']
-  end
-
-  def validate_basic_data attributes, errors
-    post = Post.new(title: attributes['title'].presence,
-                    url: attributes['url'],
-                    thumbnail_base: attributes['thumbnail_base'].presence,
-                    original_created_from: attributes['original_created_from'].presence,
-                    original_created_before: attributes['original_created_before'].presence,
-                    video_ms: parse_video_ms(attributes, errors))
-    post.valid?
-    post.errors.each do |error|
-      next if error.attribute == :url && error.type == :taken
-
-      (errors[error.attribute] ||= []) << error.message
-    end
-  end
-
-  def parse_video_ms attributes, errors
-    return nil unless attributes['tags'].to_s.split.include?('動画')
-
-    video_ms = attributes['video_ms']
-    if video_ms.present?
-      value = Integer(video_ms, exception: false)
-      if value&.positive?
-        return value
-      end
-
-      errors[:video_ms] = ['動画時間の記法が不正です．']
-      return nil
-    end
-
-    value = attributes['duration']
-    return nil if value.blank?
-
-    Tag.time_to_ms!(value.to_s, tag_name: '動画時間')
-  rescue Tag::SectionLiteralParseError
-    errors[:video_ms] = ['動画時間の記法が不正です．']
-    nil
-  end
-
-  def preview_parent_ids raw
-    raw.to_s.split.map { Integer(_1, exception: false) }.compact
-  end
-
-  def validate_parents raw, errors, existing_parent_ids
-    ids = raw.to_s.split.map { Integer(_1, exception: false) }
-    return if ids.compact.empty? && raw.to_s.blank?
-
-    if ids.any? { _1.nil? || _1 <= 0 }
-      errors[:parent_post_ids] = ['親投稿 Id. が不正です．']
-      return
-    end
-    if ids.uniq.any? { !existing_parent_ids[_1] }
-      errors[:parent_post_ids] = ['存在しない親投稿 Id. があります．']
-    end
-  end
-end

backend/app/services/post_metadata_fetcher.rb

@@ -1,198 +0,0 @@
-require 'time'
-require 'date'
-
-class PostMetadataFetcher
-  TIMESTAMP_PATTERN =
-      /\A(\d{4})-(\d{2})-(\d{2})T(\d{2})
-        (?::(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?
-        (Z|[+-]\d{2}:?\d{2})?\z/x
-
-  def self.fetch raw_url
-    uri, = Preview::UrlSafety.validate(raw_url)
-    response = Preview::HttpFetcher.fetch(
-        uri.to_s,
-        max_bytes: Preview::ThumbnailFetcher::HTML_MAX_BYTES)
-    metadata = Preview::HtmlMetadataExtractor.extract(response)
-    document = Nokogiri::HTML.parse(response.body)
-    content = lambda { |name|
-      document
-        .at_css("meta[property='#{ name }'], meta[name='#{ name }']")
-        &.[]('content')
-        &.strip
-        &.presence
-    }
-    duration = content.call('og:video:duration') || content.call('video:duration')
-    published = content.call('article:published_time') || content.call('date')
-    created_range = original_created_range(published)
-    platform_tags = platform_tags(uri)
-    { title: metadata[:title],
-      thumbnail_base:
-          Preview::KnownSiteExtractor.thumbnail_url(uri) || metadata[:image_url],
-      original_created_from: serialise_time(created_range&.first),
-      original_created_before: serialise_time(created_range&.last),
-      duration: serialise_duration(duration),
-      display_tags: display_tags(platform_tags),
-      tags: platform_tags.join(' ') }
-  end
-
-  def self.platform_tags uri
-    return ['動画', 'YouTube'] if Preview::KnownSiteExtractor.youtube_video_id(uri)
-    return ['動画', 'ニコニコ'] if Preview::KnownSiteExtractor.niconico_video_id(uri)
-
-    []
-  end
-
-  def self.display_tags names
-    return [] if names.blank?
-
-    existing_tags =
-        Tag
-        .joins(:tag_name)
-        .where(tag_names: { name: names })
-        .index_by(&:name)
-
-    names.map { |name|
-      tag = existing_tags[name]
-      {
-          name: name,
-          category: (tag&.category || 'meta'),
-          section_literals: [] }
-    }
-  end
-
-  def self.original_created_range value
-    return nil if value.blank?
-
-    raw = value.to_s.strip
-    from, before =
-        case raw
-        when /\A(\d{4})\z/
-          year = Regexp.last_match(1).to_i
-          from = Time.zone.local(year, 1, 1)
-          [from, from + 1.year]
-        when /\A(\d{4})-(\d{2})\z/
-          year = Regexp.last_match(1).to_i
-          month = Regexp.last_match(2).to_i
-          return nil unless month.between?(1, 12)
-
-          from = Time.zone.local(year, month, 1)
-          [from, from + 1.month]
-        when /\A(\d{4})-(\d{2})-(\d{2})\z/
-          year = Regexp.last_match(1).to_i
-          month = Regexp.last_match(2).to_i
-          day = Regexp.last_match(3).to_i
-          return nil unless Date.valid_date?(year, month, day)
-
-          from = Time.zone.local(year, month, day)
-          [from, from + 1.day]
-        else
-          parse_timestamp_range(raw)
-        end
-    return nil if from.nil? || before.nil?
-
-    [from, before]
-  rescue ArgumentError, TypeError
-    nil
-  end
-
-  def self.parse_timestamp_range raw
-    match = raw.match(TIMESTAMP_PATTERN)
-    return nil unless match
-
-    year = match[1].to_i
-    month = match[2].to_i
-    day = match[3].to_i
-    hour = match[4].to_i
-    minute = match[5]&.to_i || 0
-    second = match[6]&.to_i || 0
-    fraction = match[7]
-    offset = match[8]
-    return nil unless valid_timestamp_components?(year, month, day, hour, minute, second)
-    return nil unless valid_offset?(offset)
-
-    nanoseconds = parse_nanoseconds(fraction)
-    timestamp =
-        if offset.present?
-          Time.new(
-              year,
-              month,
-              day,
-              hour,
-              minute,
-              second + Rational(nanoseconds, 1_000_000_000),
-              parse_offset(offset)).in_time_zone
-        else
-          Time.zone.local(year, month, day, hour, minute, second).change(nsec: nanoseconds)
-        end
-
-    from = timestamp.change(sec: 0, nsec: 0)
-    before =
-        if match[5].nil?
-          from + 1.hour
-        else
-          from + 1.minute
-        end
-    [from, before]
-  end
-
-  def self.parse_nanoseconds value
-    return 0 if value.blank?
-
-    digits = value[0, 9].ljust(9, '0')
-    Integer(digits, 10)
-  end
-
-  def self.parse_offset value
-    return '+00:00' if value == 'Z'
-
-    value.match?(/\A[+-]\d{2}:\d{2}\z/) ? value : "#{ value[0, 3] }:#{ value[3, 2] }"
-  end
-
-  def self.serialise_duration value
-    seconds = Float(value)
-    return nil unless seconds.positive?
-
-    milliseconds = (seconds * 1_000).round
-    seconds_string = (milliseconds / 1_000.0).to_s
-    seconds_string.end_with?('.0') ? seconds_string.delete_suffix('.0') : seconds_string
-  rescue ArgumentError, TypeError
-    nil
-  end
-
-  def self.valid_timestamp_components? year, month, day, hour, minute, second
-    return false unless Date.valid_date?(year, month, day)
-    return false unless hour.between?(0, 23)
-    return false unless minute.between?(0, 59)
-    return false unless second.between?(0, 59)
-
-    true
-  end
-
-  def self.valid_offset? value
-    return true if value.nil? || value == 'Z'
-
-    match = value.match(/\A([+-])(\d{2}):?(\d{2})\z/)
-    return false if match.nil?
-
-    hours = match[2].to_i
-    minutes = match[3].to_i
-    hours.between?(0, 23) && minutes.between?(0, 59)
-  end
-
-  def self.serialise_time value
-    return nil if value.nil?
-
-    value.nsec.zero? ? value.iso8601 : value.iso8601(9)
-  end
-
-  private_class_method :platform_tags,
-                       :display_tags,
-                       :original_created_range,
-                       :parse_timestamp_range,
-                       :parse_nanoseconds,
-                       :parse_offset,
-                       :serialise_duration,
-                       :valid_timestamp_components?,
-                       :valid_offset?,
-                       :serialise_time
-end

backend/app/services/post_thumbnail_attachment_builder.rb

@@ -1,11 +0,0 @@
-class PostThumbnailAttachmentBuilder
-  def self.build thumbnail:, thumbnail_base:
-    if thumbnail_base.present?
-      return Post.remote_thumbnail_attachment(thumbnail_base)
-    end
-
-    return nil if thumbnail.blank?
-
-    Post.resized_thumbnail_attachment(thumbnail)
-  end
-end

backend/app/services/post_thumbnail_upload_validator.rb

@@ -1,34 +0,0 @@
-class PostThumbnailUploadValidator
-  MAX_THUMBNAIL_BYTES = 20 * 1024 * 1024
-  ALLOWED_CONTENT_TYPES = Preview::ThumbnailFetcher::RASTER_IMAGE_CONTENT_TYPES.freeze
-
-  class InvalidUpload < StandardError; end
-
-  def self.validate! thumbnail
-    return if thumbnail.blank?
-    unless thumbnail.is_a?(ActionDispatch::Http::UploadedFile)
-      raise InvalidUpload, 'thumbnail upload が不正です．'
-    end
-    raise InvalidUpload, 'thumbnail file size が大きすぎます．' if thumbnail.size > MAX_THUMBNAIL_BYTES
-    raise InvalidUpload, 'サムネイル画像の形式が不正です．' unless allowed_content_type?(thumbnail.content_type)
-    bytes = thumbnail.read
-    raise InvalidUpload, 'サムネイル画像の形式が不正です．' if Post.svg_document_bytes?(bytes)
-    unless Post.raster_thumbnail_bytes?(bytes)
-      raise InvalidUpload, 'サムネイル画像の形式が不正です．'
-    end
-
-    attachment = Post.resized_thumbnail_attachment(
-        StringIO.new(bytes),
-        content_type: thumbnail.content_type)
-    attachment[:io].close if attachment[:io].respond_to?(:close)
-  rescue MiniMagick::Error, Timeout::Error
-    raise InvalidUpload, 'サムネイル画像の変換に失敗しました．'
-  ensure
-    thumbnail&.rewind if thumbnail.respond_to?(:rewind)
-  end
-
-  def self.allowed_content_type? content_type
-    mime_type = content_type.to_s.split(';', 2).first.to_s.downcase.strip
-    ALLOWED_CONTENT_TYPES.include?(mime_type)
-  end
-end

backend/app/services/post_url_normaliser.rb

@@ -1,13 +0,0 @@
-class PostUrlNormaliser
-  def self.normalise raw_url
-    value = raw_url.to_s.strip
-    uri = URI.parse(value)
-    return nil unless uri.is_a?(URI::HTTP) && uri.host.present?
-
-    uri.host = uri.host.downcase
-    uri.path = uri.path.sub(/\/\z/, '') if uri.path.present?
-    PostUrlSanitisationRule.sanitise(uri.to_s)
-  rescue URI::InvalidURIError
-    nil
-  end
-end

backend/app/services/post_version_recorder.rb

@@ -23,7 +23,6 @@ class PostVersionRecorder < VersionRecorder
     { title: @record.title,
       url: @record.url,
       thumbnail_base: @record.thumbnail_base,
-      video_ms: @record.video_ms,
       tags: @record.snapshot_tag_names.join(' '),
       parent_post_ids: @record.snapshot_parent_post_ids.join(' '),
       original_created_from: @record.original_created_from,

backend/app/services/preview/html_metadata_extractor.rb

@@ -1,21 +0,0 @@
-module Preview
-  class HtmlMetadataExtractor
-    IMAGE_SELECTORS = [
-      'meta[property="og:image"]',
-      'meta[name="twitter:image"]',
-      'meta[name="thumbnail"]'
-    ].freeze
-
-    def self.extract(response)
-      document = Nokogiri::HTML.parse(response.body)
-      image_url = IMAGE_SELECTORS.filter_map {
-        document.at_css(_1)&.[]('content')&.strip.presence
-      }.first
-
-      { title: document.at_css('title')&.text&.strip,
-        image_url: image_url ? URI.join(response.url, image_url).to_s : nil }
-    rescue URI::InvalidURIError
-      { title: document.at_css('title')&.text&.strip, image_url: nil }
-    end
-  end
-end

backend/app/services/preview/http_fetcher.rb

@@ -1,123 +0,0 @@
-require 'net/http'
-require 'json'
-
-module Preview
-  class HttpFetcher
-    class FetchFailed < StandardError; end
-    class FetchTimeout < FetchFailed; end
-    class ResponseTooLarge < FetchFailed; end
-
-    MAX_REDIRECTS = 5
-    DEFAULT_MAX_BYTES = 5.megabytes
-
-    Response = Data.define(:body, :content_type, :url)
-
-    def self.fetch(raw_url, max_bytes: DEFAULT_MAX_BYTES, redirects: MAX_REDIRECTS)
-      uri, addresses = UrlSafety.validate(raw_url)
-      response = request(uri, addresses.first, max_bytes)
-
-      if response.is_a?(Net::HTTPRedirection)
-        location = response['location']
-        if redirects.zero?
-          log_failure(:redirect_limit,
-                      url: uri.to_s,
-                      redirects:,
-                      location:,
-                      content_type: response['content-type'],
-                      content_length: response['content-length'])
-          raise FetchFailed, 'redirect が多すぎます．'
-        end
-
-        if location.blank?
-          log_failure(:blank_redirect_location,
-                      url: uri.to_s,
-                      redirects:,
-                      content_type: response['content-type'],
-                      content_length: response['content-length'])
-          raise FetchFailed, 'redirect 先が不正です．'
-        end
-
-        redirect_url =
-            begin
-              URI.join(uri, location).to_s
-            rescue URI::InvalidURIError => e
-              log_failure(:invalid_redirect_location,
-                          url: uri.to_s,
-                          redirects:,
-                          location:,
-                          error: e.class.name,
-                          message: e.message)
-              raise FetchFailed, 'redirect 先が不正です．'
-            end
-
-        return fetch(redirect_url, max_bytes:, redirects: redirects - 1)
-      end
-
-      unless response.is_a?(Net::HTTPSuccess)
-        log_failure(:http_status,
-                    url: uri.to_s,
-                    code: response.code,
-                    content_type: response['content-type'],
-                    content_length: response['content-length'])
-        raise FetchFailed, "外部サーバーが HTTP #{ response.code } を返しました．"
-      end
-
-      Response.new(response.body, response['content-type'].to_s, uri.to_s)
-    rescue Net::OpenTimeout, Net::ReadTimeout, Timeout::Error => e
-      log_failure(:timeout, url: uri&.to_s || raw_url, error: e.class.name, message: e.message)
-      raise FetchTimeout, e.message
-    rescue SocketError, SystemCallError, OpenSSL::SSL::SSLError, EOFError => e
-      log_failure(:network_error, url: uri&.to_s || raw_url, error: e.class.name,
-                  message: e.message)
-      raise FetchFailed, e.message
-    end
-
-    def self.request(uri, ip_address, max_bytes)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.ipaddr = ip_address
-      http.use_ssl = uri.scheme == 'https'
-      http.open_timeout = 5
-      http.read_timeout = 8
-      http.write_timeout = 5
-
-      request = Net::HTTP::Get.new(uri)
-      request['User-Agent'] = 'BTRC-Hub thumbnail preview'
-      request['Accept'] = 'text/html,image/*;q=0.9,*/*;q=0.1'
-
-      http.request(request) do |response|
-        length = response['content-length'].to_i
-        if length > max_bytes
-          log_failure(:response_too_large,
-                      url: uri.to_s,
-                      content_type: response['content-type'],
-                      content_length: response['content-length'],
-                      max_bytes:)
-          raise ResponseTooLarge, '外部データが大きすぎます．'
-        end
-
-        body = +''
-        response.read_body do |chunk|
-          body << chunk
-          next unless body.bytesize > max_bytes
-
-          log_failure(:response_too_large,
-                      url: uri.to_s,
-                      content_type: response['content-type'],
-                      content_length: response['content-length'],
-                      bytes_read: body.bytesize,
-                      max_bytes:)
-          raise ResponseTooLarge, '外部データが大きすぎます．'
-        end
-        response.instance_variable_set(:@body, body)
-        response.instance_variable_set(:@read, true)
-        return response
-      end
-    end
-
-    def self.log_failure(reason, **payload)
-      Rails.logger.warn("preview_http_fetcher_failure #{ { reason:, **payload }.to_json }")
-    end
-
-    private_class_method :request, :log_failure
-  end
-end

backend/app/services/preview/known_site_extractor.rb

@@ -1,34 +0,0 @@
-module Preview
-  class KnownSiteExtractor
-    def self.thumbnail_url(uri)
-      youtube_thumbnail(uri)
-    end
-
-    def self.youtube_video_id(uri)
-      case uri.host&.downcase
-      when 'youtu.be'
-        uri.path.split('/').reject(&:blank?).first
-      when 'www.youtube.com', 'youtube.com', 'm.youtube.com'
-        uri.path == '/watch' ? URI.decode_www_form(uri.query.to_s).to_h['v'] : nil
-      end&.then { _1 if _1.match?(/\A[A-Za-z0-9_-]{6,20}\z/) }
-    end
-
-    def self.niconico_video_id(uri)
-      case uri.host&.downcase
-      when 'www.nicovideo.jp', 'nicovideo.jp'
-        uri.path[%r{\A/watch/(sm\d+)\z}, 1]
-      when 'nico.ms'
-        uri.path[%r{\A/(sm\d+)\z}, 1]
-      end
-    end
-
-    def self.youtube_thumbnail(uri)
-      id = youtube_video_id(uri)
-      return unless id
-
-      "https://i.ytimg.com/vi/#{ id }/hqdefault.jpg"
-    end
-
-    private_class_method :youtube_thumbnail
-  end
-end

backend/app/services/preview/thumbnail_fetcher.rb

@@ -1,102 +0,0 @@
-module Preview
-  class ThumbnailFetcher
-    class GenerationFailed < StandardError; end
-    RASTER_IMAGE_CONTENT_TYPES = [
-      'image/jpeg', 'image/png', 'image/gif', 'image/webp'
-    ].freeze
-    HTML_MAX_BYTES = 1.megabyte
-    NICONICO_XML_MAX_BYTES = 256.kilobytes
-
-    def self.fetch(raw_url)
-      uri, = UrlSafety.validate(raw_url)
-
-      known_url = KnownSiteExtractor.thumbnail_url(uri)
-      image = fetch_image_or_nil(known_url) if known_url
-      return image if image
-
-      niconico_url = niconico_thumbnail_url(uri)
-      image = fetch_image_or_nil(niconico_url) if niconico_url
-      return image if image
-
-      page = HttpFetcher.fetch(uri.to_s, max_bytes: HTML_MAX_BYTES)
-      metadata = HtmlMetadataExtractor.extract(page)
-      raise GenerationFailed, 'サムネール画像が見つかりませんでした．' if metadata[:image_url].blank?
-
-      fetch_image!(metadata[:image_url])
-    end
-
-    def self.fetch_image_response(raw_url)
-      uri, = UrlSafety.validate(raw_url)
-      response = HttpFetcher.fetch(uri.to_s)
-      unless Post.remote_thumbnail_image_bytes?(
-                 response.body,
-                 content_type: response.content_type)
-        raise GenerationFailed, 'サムネール画像が見つかりませんでした．'
-      end
-
-      response
-    rescue HttpFetcher::FetchTimeout
-      raise
-    rescue HttpFetcher::ResponseTooLarge
-      raise
-    rescue HttpFetcher::FetchFailed
-      raise GenerationFailed, 'サムネール画像を取得できませんでした．'
-    end
-
-    def self.title(raw_url)
-      uri, = UrlSafety.validate(raw_url)
-      HtmlMetadataExtractor.extract(
-          HttpFetcher.fetch(uri.to_s, max_bytes: HTML_MAX_BYTES))[:title]
-    end
-
-    def self.fetch_image_or_nil(url)
-      return nil if url.blank?
-
-      response = HttpFetcher.fetch(url)
-      return nil unless Post.remote_thumbnail_image_bytes?(
-                            response.body,
-                            content_type: response.content_type)
-
-      response.body
-    rescue HttpFetcher::FetchTimeout
-      raise
-    rescue HttpFetcher::FetchFailed
-      nil
-    end
-
-    def self.fetch_image!(url)
-      fetch_image_response(url).body
-    end
-
-    def self.niconico_thumbnail_url(uri)
-      video_id = KnownSiteExtractor.niconico_video_id(uri)
-      return nil if video_id.blank?
-
-      response = HttpFetcher.fetch("https://ext.nicovideo.jp/api/getthumbinfo/#{ video_id }",
-                                   max_bytes: NICONICO_XML_MAX_BYTES)
-      xml = Nokogiri::XML(response.body)
-      return nil unless xml.at_xpath('/nicovideo_thumb_response/@status')&.value == 'ok'
-
-      xml.at_xpath('//thumbnail_url')&.text&.strip.presence
-    rescue HttpFetcher::FetchFailed, HttpFetcher::FetchTimeout => e
-      payload = {
-          url: uri.to_s,
-          video_id:,
-          error: e.class.name,
-          message: e.message }
-      Rails.logger.info("preview_niconico_getthumbinfo_fallback #{ payload.to_json }")
-      nil
-    rescue Nokogiri::XML::SyntaxError => e
-      payload = {
-          url: uri.to_s,
-          video_id:,
-          error: e.class.name,
-          message: e.message }
-      Rails.logger.info("preview_niconico_getthumbinfo_fallback #{ payload.to_json }")
-      nil
-    end
-
-    private_class_method :fetch_image_or_nil, :fetch_image!,
-                         :niconico_thumbnail_url
-  end
-end

backend/app/services/preview/url_safety.rb

@@ -1,55 +0,0 @@
-require 'resolv'
-require 'ipaddr'
-require 'uri'
-
-module Preview
-  class UrlSafety
-    class UnsafeUrl < StandardError; end
-
-    FORBIDDEN_NETWORKS = [
-      '0.0.0.0/8', '10.0.0.0/8', '100.64.0.0/10', '127.0.0.0/8',
-      '169.254.0.0/16', '172.16.0.0/12', '192.0.0.0/24',
-      '192.0.2.0/24', '192.168.0.0/16', '198.18.0.0/15',
-      '198.51.100.0/24', '203.0.113.0/24', '224.0.0.0/4',
-      '240.0.0.0/4', '::/128', '::1/128', 'fc00::/7', 'fe80::/10',
-      'ff00::/8', '2001:db8::/32', '::ffff:0:0/96'
-    ].map { IPAddr.new(_1) }.freeze
-
-    def self.validate(raw_url)
-      value = raw_url.to_s.strip
-      if value.match?(/\A[a-z][a-z0-9+\-.]*:/i)
-        unless value.match?(/\Ahttps?:\/\//i)
-          raise UnsafeUrl, 'http または https の URL を指定してください．'
-        end
-      else
-        value = "http://#{ value }"
-      end
-      uri = URI.parse(value)
-
-      unless ['http', 'https'].include?(uri.scheme&.downcase) && uri.host.present?
-        raise UnsafeUrl, 'http または https の URL を指定してください．'
-      end
-      raise UnsafeUrl, 'userinfo つき URL は使用できません．' if uri.userinfo.present?
-
-      addresses = Resolv.getaddresses(uri.host)
-      raise UnsafeUrl, 'URL のホストを解決できません．' if addresses.empty?
-
-      parsed_addresses = addresses.map { IPAddr.new(_1) }
-      if parsed_addresses.any? { |address| forbidden?(address) }
-        raise UnsafeUrl, '安全でない接続先は使用できません．'
-      end
-
-      [uri, parsed_addresses.map(&:to_s)]
-    rescue Resolv::ResolvError
-      raise UnsafeUrl, 'URL のホストを解決できません．'
-    rescue URI::InvalidURIError, IPAddr::InvalidAddressError
-      raise UnsafeUrl, 'URL が不正です．'
-    end
-
-    def self.forbidden?(address)
-      FORBIDDEN_NETWORKS.any? { _1.include?(address) }
-    end
-
-    private_class_method :forbidden?
-  end
-end

backend/app/services/youtube/sync.rb

@@ -1,3 +1,4 @@
+require 'open-uri'
 require 'set'
 require 'time'
 
@@ -126,12 +127,12 @@ module Youtube
       return if post.thumbnail.attached?
       return if thumbnail_url.blank?
 
-      post.attach_thumbnail_from_url!(thumbnail_url)
+      post.thumbnail.attach(
-    rescue Post::RemoteThumbnailFetchFailed => e
+          io:           URI.open(thumbnail_url),
-      Rails.logger.info("youtube_sync_thumbnail_fetch_failed #{ { post_id: post.id,
+          filename:     File.basename(URI.parse(thumbnail_url).path),
-                                                                  thumbnail_url:,
+          content_type: 'image/jpeg')
-                                                                  error: e.class.name,
+
-                                                                  message: e.message }.to_json }")
+      post.resized_thumbnail!
     end
 
     def youtube_url_regexp id

backend/config/environments/development.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/integer/time'
+require "active_support/core_ext/integer/time"
 
 Rails.application.configure do
   # Settings specified here will take precedence over those in config/application.rb.
@@ -17,8 +17,8 @@ Rails.application.configure do
 
   # Enable/disable Action Controller caching. By default Action Controller caching is disabled.
   # Run rails dev:cache to toggle Action Controller caching.
-  if Rails.root.join('tmp/caching-dev.txt').exist?
+  if Rails.root.join("tmp/caching-dev.txt").exist?
-    config.public_file_server.headers = { 'cache-control' => "public, max-age=#{2.days.to_i}" }
+    config.public_file_server.headers = { "cache-control" => "public, max-age=#{2.days.to_i}" }
   else
     config.action_controller.perform_caching = false
   end
@@ -36,11 +36,7 @@ Rails.application.configure do
   config.action_mailer.perform_caching = false
 
   # Set localhost to be used by links generated in mailer templates.
-  config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }
+  config.action_mailer.default_url_options = { host: "localhost", port: 3000 }
-  Rails.application.routes.default_url_options.merge!(
-      host: 'localhost',
-      port: 3002,
-      protocol: 'http')
 
   # Print deprecation notices to the Rails logger.
   config.active_support.deprecation = :log

backend/config/routes.rb

@@ -52,8 +52,6 @@ Rails.application.routes.draw do
 
   resources :posts, only: [:index, :show, :create, :update] do
     collection do
-      get :metadata
-      post :bulk
       get :random
       get :changes
       get :versions, to: 'post_versions#index'
@@ -83,11 +81,6 @@ Rails.application.routes.draw do
     end
   end
 
-  get 'users/settings', to: 'user_settings#show'
-  patch 'users/settings', to: 'user_settings#update'
-  get 'users/theme_slots', to: 'user_theme_slots#index'
-  put 'users/theme_slots/:base_theme/:slot_no', to: 'user_theme_slots#update'
-
   resources :users, only: [:create, :update] do
     collection do
       post :verify

backend/db/migrate/20260519013100_add_video_ms_to_posts.rb

@@ -1,9 +0,0 @@
-class AddVideoMsToPosts < ActiveRecord::Migration[8.0]
-  def change
-    add_column :posts, :video_ms, :integer
-    add_index :posts, [:video_ms, :id], name: 'idx_posts_video_ms_id'
-
-    add_check_constraint :posts, 'video_ms IS NULL OR video_ms > 0',
-                         name: 'chk_posts_video_ms_positive'
-  end
-end

backend/db/migrate/20260622010000_create_post_tag_sections.rb

@@ -1,19 +0,0 @@
-class CreatePostTagSections < ActiveRecord::Migration[8.0]
-  def change
-    create_table :post_tag_sections, primary_key: [:post_id, :tag_id, :begin_ms] do |t|
-      t.references :post, null: false, foreign_key: true, index: false
-      t.references :tag, null: false, foreign_key: true, index: false
-      t.integer :begin_ms, null: false
-      t.integer :end_ms, null: true
-      t.timestamps
-
-      t.index [:post_id, :begin_ms], name: 'idx_post_tag_sections_post_id_begin_ms'
-
-      t.check_constraint 'begin_ms >= 0',
-                         name: 'chk_post_tag_sections_begin_ms_natural'
-
-      t.check_constraint 'end_ms IS NULL OR begin_ms < end_ms',
-                         name: 'chk_post_tag_sections_end_ms_after_begin_ms'
-    end
-  end
-end

backend/db/migrate/20260622020000_add_video_ms_to_post_versions.rb

@@ -1,9 +0,0 @@
-class AddVideoMsToPostVersions < ActiveRecord::Migration[8.0]
-  def change
-    add_column :post_versions, :video_ms, :integer
-    add_index :post_versions, [:video_ms, :post_id], name: 'idx_post_versions_video_ms_post_id'
-
-    add_check_constraint :post_versions, 'video_ms IS NULL OR video_ms > 0',
-                         name: 'chk_post_versions_video_ms_positive'
-  end
-end

backend/db/migrate/20260704000000_rebuild_settings_as_typed_user_settings.rb

@@ -1,31 +0,0 @@
-class RebuildSettingsAsTypedUserSettings < ActiveRecord::Migration[8.0]
-  def change
-    remove_foreign_key :settings, :users if foreign_key_exists?(:settings, :users)
-    remove_index :settings, :user_id if index_exists?(:settings, :user_id)
-
-    remove_column :settings, :key, :string if column_exists?(:settings, :key)
-    remove_column :settings, :value, :json if column_exists?(:settings, :value)
-
-    change_column_null :settings, :user_id, false
-
-    add_column :settings, :theme, :string, null: false, default: 'system'
-    add_column :settings,
-               :auto_fetch_title,
-               :string,
-               null: false,
-               default: 'manual'
-    add_column :settings,
-               :auto_fetch_thumbnail,
-               :string,
-               null: false,
-               default: 'manual'
-    add_column :settings,
-               :wiki_editor_mode,
-               :string,
-               null: false,
-               default: 'split'
-
-    add_index :settings, :user_id, unique: true
-    add_foreign_key :settings, :users
-  end
-end

backend/db/migrate/20260705000000_create_user_theme_slots.rb

@@ -1,22 +0,0 @@
-class CreateUserThemeSlots < ActiveRecord::Migration[8.0]
-  def change
-    create_table :user_theme_slots do |t|
-      t.references :user, null: false, foreign_key: true
-      t.string :base_theme, null: false
-      t.integer :slot_no, null: false
-      t.json :tokens, null: false
-      t.timestamps
-    end
-
-    add_index :user_theme_slots,
-              [:user_id, :base_theme, :slot_no],
-              unique: true,
-              name: 'index_user_theme_slots_on_user_theme_and_slot'
-    add_check_constraint :user_theme_slots,
-                         "base_theme IN ('light', 'dark')",
-                         name: 'user_theme_slots_base_theme_valid'
-    add_check_constraint :user_theme_slots,
-                         'slot_no BETWEEN 1 AND 3',
-                         name: 'user_theme_slots_slot_no_valid'
-  end
-end

backend/db/migrate/20260713000000_create_post_url_sanitisation_rules.rb

@@ -1,61 +0,0 @@
-class CreatePostUrlSanitisationRules < ActiveRecord::Migration[8.0]
-  class PostUrlSanitisationRule < ActiveRecord::Base
-    self.table_name = 'post_url_sanitisation_rules'
-  end
-
-  def up
-    create_table :post_url_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 = Time.current
-
-    PostUrlSanitisationRule.insert_all!([
-        { priority: 10,
-          source_pattern: '\Ahttps?://youtu\.be/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 20,
-          source_pattern: '\Ahttps?://(?:www\.|m\.)?youtube\.com/live/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 30,
-          source_pattern: '\Ahttps?://(?:www\.|m\.)?youtube\.com/shorts/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 40,
-          source_pattern: '\Ahttps?://(?:www\.|m\.)?youtube\.com/embed/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 50,
-          source_pattern:
-              '\Ahttps?://(?:www\.|m\.)?youtube\.com/watch\?(?:[^#&]+&)*v=([^&#]+)(?:[&#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 60,
-          source_pattern: '\Ahttps?://nico\.ms/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.nicovideo.jp/watch/\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 70,
-          source_pattern: '\Ahttps?://(?:www\.)?nicovideo\.jp/watch/([^?#/]+)(?:[?#].*)?\z',
-          replacement: 'https://www.nicovideo.jp/watch/\1',
-          created_at: now,
-          updated_at: now }])
-  end
-
-  def down
-    drop_table :post_url_sanitisation_rules
-  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_07_13_000000) do
+ActiveRecord::Schema[8.0].define(version: 2026_06_26_010000) 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
@@ -298,19 +298,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
     t.index ["target_post_id"], name: "index_post_similarities_on_target_post_id"
   end
 
-  create_table "post_tag_sections", primary_key: ["post_id", "tag_id", "begin_ms"], charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    t.bigint "post_id", null: false
-    t.bigint "tag_id", null: false
-    t.integer "begin_ms", null: false
-    t.integer "end_ms"
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["post_id", "begin_ms"], name: "idx_post_tag_sections_post_id_begin_ms"
-    t.index ["tag_id"], name: "fk_rails_8be3847903"
-    t.check_constraint "(`end_ms` is null) or (`begin_ms` < `end_ms`)", name: "chk_post_tag_sections_end_ms_after_begin_ms"
-    t.check_constraint "`begin_ms` >= 0", name: "chk_post_tag_sections_begin_ms_natural"
-  end
-
   create_table "post_tags", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "post_id", null: false
     t.bigint "tag_id", null: false
@@ -331,16 +318,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
     t.index ["tag_id"], name: "index_post_tags_on_tag_id"
   end
 
-  create_table "post_url_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_post_url_sanitisation_rules_on_discarded_at"
-    t.index ["source_pattern"], name: "index_post_url_sanitisation_rules_on_source_pattern", unique: true
-  end
-
   create_table "post_versions", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "post_id", null: false
     t.integer "version_no", null: false
@@ -354,12 +331,9 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
     t.datetime "original_created_before"
     t.datetime "created_at", null: false
     t.bigint "created_by_user_id"
-    t.integer "video_ms"
     t.index ["created_by_user_id"], name: "index_post_versions_on_created_by_user_id"
     t.index ["post_id", "version_no"], name: "index_post_versions_on_post_id_and_version_no", unique: true
     t.index ["post_id"], name: "index_post_versions_on_post_id"
-    t.index ["video_ms", "post_id"], name: "idx_post_versions_video_ms_post_id"
-    t.check_constraint "(`video_ms` is null) or (`video_ms` > 0)", name: "chk_post_versions_video_ms_positive"
     t.check_constraint "`event_type` in (_utf8mb4'create',_utf8mb4'update',_utf8mb4'discard',_utf8mb4'restore')", name: "post_versions_event_type_valid"
     t.check_constraint "`version_no` > 0", name: "post_versions_version_no_positive"
   end
@@ -374,36 +348,18 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
     t.datetime "original_created_before"
     t.datetime "updated_at", null: false
     t.integer "version_no", null: false
-    t.integer "video_ms"
     t.index ["uploaded_user_id"], name: "index_posts_on_uploaded_user_id"
     t.index ["url"], name: "index_posts_on_url", unique: true
-    t.index ["video_ms", "id"], name: "idx_posts_video_ms_id"
-    t.check_constraint "(`video_ms` is null) or (`video_ms` > 0)", name: "chk_posts_video_ms_positive"
     t.check_constraint "`version_no` > 0", name: "chk_posts_version_no_positive"
   end
 
   create_table "settings", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "user_id", null: false
+    t.string "key", null: false
+    t.json "value", null: false
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
-    t.string "theme", default: "system", null: false
+    t.index ["user_id"], name: "index_settings_on_user_id"
-    t.string "auto_fetch_title", default: "manual", null: false
-    t.string "auto_fetch_thumbnail", default: "manual", null: false
-    t.string "wiki_editor_mode", default: "split", null: false
-    t.index ["user_id"], name: "index_settings_on_user_id", unique: true
-  end
-
-  create_table "wiki_assets", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    t.bigint "wiki_page_id", null: false
-    t.integer "no", null: false
-    t.string "alt_text"
-    t.binary "sha256", limit: 32, null: false
-    t.bigint "created_by_user_id", null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["created_by_user_id"], name: "index_wiki_assets_on_created_by_user_id"
-    t.index ["wiki_page_id", "no"], name: "index_wiki_assets_on_wiki_page_id_and_no", unique: true
-    t.index ["wiki_page_id", "sha256"], name: "index_wiki_assets_on_wiki_page_id_and_sha256", unique: true
   end
 
   create_table "tag_implications", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
@@ -451,9 +407,9 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
     t.string "event_type", null: false
     t.string "name", null: false
     t.string "category", null: false
+    t.datetime "deprecated_at"
     t.text "aliases", null: false
     t.text "parent_tag_ids", null: false
-    t.datetime "deprecated_at"
     t.datetime "created_at", null: false
     t.bigint "created_by_user_id"
     t.index ["created_at"], name: "index_tag_versions_on_created_at"
@@ -466,10 +422,10 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
   create_table "tags", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "tag_name_id", null: false
     t.string "category", default: "general", null: false
-    t.datetime "deprecated_at"
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.integer "post_count", default: 0, null: false
+    t.datetime "deprecated_at"
     t.datetime "discarded_at"
     t.integer "version_no", null: false
     t.index ["deprecated_at"], name: "index_tags_on_deprecated_at"
@@ -591,19 +547,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
     t.index ["post_id"], name: "index_user_post_views_on_post_id"
   end
 
-  create_table "user_theme_slots", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    t.bigint "user_id", null: false
-    t.string "base_theme", null: false
-    t.integer "slot_no", null: false
-    t.json "tokens", null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["user_id", "base_theme", "slot_no"], name: "index_user_theme_slots_on_user_theme_and_slot", unique: true
-    t.index ["user_id"], name: "index_user_theme_slots_on_user_id"
-    t.check_constraint "`base_theme` in (_utf8mb4'light',_utf8mb4'dark')", name: "user_theme_slots_base_theme_valid"
-    t.check_constraint "`slot_no` between 1 and 3", name: "user_theme_slots_slot_no_valid"
-  end
-
   create_table "users", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.string "name"
     t.string "inheritance_code", limit: 64, null: false
@@ -614,6 +557,19 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
     t.index ["banned_at"], name: "index_users_on_banned_at"
   end
 
+  create_table "wiki_assets", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
+    t.bigint "wiki_page_id", null: false
+    t.integer "no", null: false
+    t.string "alt_text"
+    t.binary "sha256", limit: 32, null: false
+    t.bigint "created_by_user_id", null: false
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["created_by_user_id"], name: "index_wiki_assets_on_created_by_user_id"
+    t.index ["wiki_page_id", "no"], name: "index_wiki_assets_on_wiki_page_id_and_no", unique: true
+    t.index ["wiki_page_id", "sha256"], name: "index_wiki_assets_on_wiki_page_id_and_sha256", unique: true
+  end
+
   create_table "wiki_lines", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.string "sha256", limit: 64, null: false
     t.text "body", null: false
@@ -722,8 +678,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
   add_foreign_key "post_implications", "posts", column: "parent_post_id"
   add_foreign_key "post_similarities", "posts"
   add_foreign_key "post_similarities", "posts", column: "target_post_id"
-  add_foreign_key "post_tag_sections", "posts"
-  add_foreign_key "post_tag_sections", "tags"
   add_foreign_key "post_tags", "posts"
   add_foreign_key "post_tags", "tags"
   add_foreign_key "post_tags", "users", column: "created_user_id"
@@ -763,7 +717,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
   add_foreign_key "user_ips", "users"
   add_foreign_key "user_post_views", "posts"
   add_foreign_key "user_post_views", "users"
-  add_foreign_key "user_theme_slots", "users"
   add_foreign_key "wiki_assets", "users", column: "created_by_user_id"
   add_foreign_key "wiki_assets", "wiki_pages"
   add_foreign_key "wiki_pages", "tag_names"

backend/db/seeds.rb

@@ -8,43 +8,6 @@
 #     MovieGenre.find_or_create_by!(name: genre_name)
 #   end
 
-post_url_sanitisation_rules = [
-  { priority: 10,
-    source_pattern: '\Ahttps?://youtu\.be/([^/?#]+)(?:[?#].*)?\z',
-    replacement: 'https://www.youtube.com/watch?v=\1' },
-  { priority: 20,
-    source_pattern: '\Ahttps?://(?:www\.|m\.)?youtube\.com/live/([^/?#]+)(?:[?#].*)?\z',
-    replacement: 'https://www.youtube.com/watch?v=\1' },
-  { priority: 30,
-    source_pattern: '\Ahttps?://(?:www\.|m\.)?youtube\.com/shorts/([^/?#]+)(?:[?#].*)?\z',
-    replacement: 'https://www.youtube.com/watch?v=\1' },
-  { priority: 40,
-    source_pattern: '\Ahttps?://(?:www\.|m\.)?youtube\.com/embed/([^/?#]+)(?:[?#].*)?\z',
-    replacement: 'https://www.youtube.com/watch?v=\1' },
-  { priority: 50,
-    source_pattern:
-        '\Ahttps?://(?:www\.|m\.)?youtube\.com/watch\?(?:[^#&]+&)*v=([^&#]+)(?:[&#].*)?\z',
-    replacement: 'https://www.youtube.com/watch?v=\1' },
-  { priority: 60,
-    source_pattern: '\Ahttps?://nico\.ms/([^/?#]+)(?:[?#].*)?\z',
-    replacement: 'https://www.nicovideo.jp/watch/\1' },
-  { priority: 70,
-    source_pattern: '\Ahttps?://(?:www\.)?nicovideo\.jp/watch/([^?#/]+)(?:[?#].*)?\z',
-    replacement: 'https://www.nicovideo.jp/watch/\1' }
-]
-
-post_url_sanitisation_rule_scope = PostUrlSanitisationRule.unscoped
-
-post_url_sanitisation_rules.each do |attributes|
-  priority = attributes.fetch(:priority)
-  source_pattern = attributes.fetch(:source_pattern)
-
-  next if post_url_sanitisation_rule_scope.exists?(priority:)
-  next if post_url_sanitisation_rule_scope.exists?(source_pattern:)
-
-  post_url_sanitisation_rule_scope.create!(attributes)
-end
-
 material_sync_source_uri = ENV['MATERIAL_SYNC_SOURCE_URI']
 material_sync_source_file_id = ENV['MATERIAL_SYNC_SOURCE_FILE_ID']
 

backend/lib/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "lib",
+  "version": "1.0.0",
+  "main": "screenshot.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "puppeteer": "^24.10.0"
+  }
+}

backend/lib/screenshot.js

@@ -0,0 +1,18 @@
+const puppeteer = require ('puppeteer')
+const fs = require ('fs')
+
+
+void (async () => {
+  const url = process.argv[2]
+  const output = process.argv[3]
+
+  const browser = await puppeteer.launch ({
+      args: ['--no-sandbox', '--disable-setuid-sandbox'] })
+
+  const page = await browser.newPage ()
+  await page.setViewport ({ width: 960, height: 960 })
+  await page.goto (url, { waitUntil: 'networkidle2', timeout: 15000 })
+
+  await page.screenshot ({ path: output })
+  await browser.close ()
+}) ()

backend/lib/tasks/sync_nico.rake

@@ -70,17 +70,11 @@ namespace :nico do
         unless post.thumbnail.attached?
           thumbnail_base = fetch_thumbnail.(post.url) rescue nil
           if thumbnail_base.present?
+            post.thumbnail.attach(
+                io:           URI.open(thumbnail_base),
+                filename:     File.basename(URI.parse(thumbnail_base).path),
+                content_type: 'image/jpeg')
             attrs[:thumbnail_base] = thumbnail_base
-            begin
-              post.attach_thumbnail_from_url!(thumbnail_base)
-            rescue Post::RemoteThumbnailFetchFailed => e
-              payload = {
-                  post_id: post.id,
-                  thumbnail_base:,
-                  error: e.class.name,
-                  message: e.message }
-              Rails.logger.info("nico_sync_thumbnail_fetch_failed #{ payload.to_json }")
-            end
           end
         end
 
@@ -88,6 +82,7 @@ namespace :nico do
         post_changed = post.changed?
         if post_changed
           post.save!
+          post.resized_thumbnail! if post.thumbnail.attached?
         end
       else
         post_created = true
@@ -96,18 +91,13 @@ namespace :nico do
         post = Post.new(title:, url:, thumbnail_base:, uploaded_user: nil,
                         original_created_from:, original_created_before:)
         if thumbnail_base.present?
-          begin
+          post.thumbnail.attach(
-            post.attach_thumbnail_from_url!(thumbnail_base)
+              io:           URI.open(thumbnail_base),
-          rescue Post::RemoteThumbnailFetchFailed => e
+              filename:     File.basename(URI.parse(thumbnail_base).path),
-            payload = {
+              content_type: 'image/jpeg')
-                post_id: nil,
-                thumbnail_base:,
-                error: e.class.name,
-                message: e.message }
-            Rails.logger.info("nico_sync_thumbnail_fetch_failed #{ payload.to_json }")
-          end
         end
         post.save!
+        post.resized_thumbnail!
         sync_post_tags!(post, [Tag.tagme.id, Tag.bot.id, Tag.niconico.id, Tag.video.id])
       end
 

backend/spec/db/seeds_spec.rb

@@ -1,65 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe 'database seeds' do
-  before do
-    PostUrlSanitisationRule.unscoped.delete_all
-  end
-
-  it 'registers the initial post URL sanitisation rules' do
-    load_seeds
-
-    urls = {
-      'https://youtu.be/abc123?si=share' => youtube_url('abc123'),
-      'https://www.youtube.com/live/abc123?t=10' => youtube_url('abc123'),
-      'https://youtube.com/shorts/abc123?feature=share' => youtube_url('abc123'),
-      'https://m.youtube.com/embed/abc123' => youtube_url('abc123'),
-      'https://youtube.com/watch?feature=share&v=abc123&t=10' => youtube_url('abc123'),
-      'https://nico.ms/sm123?from=share#fragment' => nico_url('sm123'),
-      'https://www.nicovideo.jp/watch/sm123?ref=share#fragment' => nico_url('sm123')
-    }
-
-    expect(PostUrlSanitisationRule.count).to eq(7)
-    urls.each do |url, canonical_url|
-      expect(PostUrlSanitisationRule.sanitise(url)).to eq(canonical_url)
-    end
-  end
-
-  it 'does not overwrite or restore an existing rule' do
-    rule = PostUrlSanitisationRule.create!(
-      priority: 10,
-      source_pattern: '\Ahttps://example\.com/custom\z',
-      replacement: 'https://example.com/replacement'
-    )
-    rule.discard!
-    original_attributes = rule.reload.attributes
-
-    2.times { load_seeds }
-
-    persisted_rule = PostUrlSanitisationRule.unscoped.find(10)
-    expect(persisted_rule.attributes).to eq(original_attributes)
-    expect(PostUrlSanitisationRule.unscoped.count).to eq(7)
-  end
-
-  it 'does not duplicate a rule moved to another priority' do
-    source_pattern = '\Ahttps?://youtu\.be/([^/?#]+)(?:[?#].*)?\z'
-    PostUrlSanitisationRule.create!(
-      priority: 80,
-      source_pattern:,
-      replacement: 'https://example.com/custom/\1'
-    )
-
-    load_seeds
-
-    rules = PostUrlSanitisationRule.unscoped
-    expect(rules.where(source_pattern:).count).to eq(1)
-    expect(rules.find(80).replacement).to eq('https://example.com/custom/\1')
-  end
-
-  def load_seeds
-    load Rails.root.join('db/seeds.rb')
-  end
-
-  def youtube_url(video_id) = "https://www.youtube.com/watch?v=#{ video_id }"
-
-  def nico_url(video_id) = "https://www.nicovideo.jp/watch/#{ video_id }"
-end

backend/spec/factories/post_tag_sections.rb

@@ -1,8 +0,0 @@
-FactoryBot.define do
-  factory :post_tag_section do
-    association :post
-    association :tag
-    begin_ms { 1_000 }
-    end_ms { 2_000 }
-  end
-end

backend/spec/factories/post_tags.rb

@@ -1,6 +0,0 @@
-FactoryBot.define do
-  factory :post_tag do
-    association :post
-    association :tag
-  end
-end

backend/spec/factories/posts.rb

@@ -1,8 +0,0 @@
-FactoryBot.define do
-  factory :post do
-    sequence(:url) { |n| "https://example.com/factory-post-#{ n }" }
-    title { 'factory post' }
-    thumbnail_base { nil }
-    uploaded_user { nil }
-  end
-end

backend/spec/models/post_spec.rb

@@ -1,361 +0,0 @@
-require 'rails_helper'
-require 'tempfile'
-
-RSpec.describe Post, type: :model do
-  before do
-    PostUrlSanitisationRule.unscoped.delete_all
-  end
-
-  describe 'URL normalisation' do
-    it 'normalises the HTTP URL before applying sanitisation rules' do
-      PostUrlSanitisationRule.create!(
-        priority: 10,
-        source_pattern: '\\Ahttps://example\\.com/videos/([^/]+)\\z',
-        replacement: 'https://example.com/watch/\\1'
-      )
-
-      post = described_class.create!(
-        title: 'normalised URL',
-        url: '  https://EXAMPLE.com/videos/123/  '
-      )
-
-      expect(post.url).to eq('https://example.com/watch/123')
-    end
-
-    it 'does not normalise an unchanged URL when another attribute changes' do
-      post = create(:post)
-      post.update_column(:url, 'https://EXAMPLE.com/unchanged/')
-
-      post.update!(title: 'updated title')
-
-      expect(post.reload.url).to eq('https://EXAMPLE.com/unchanged/')
-    end
-
-    it 'validates the sanitised URL length' do
-      path = 'a' * 375
-
-      PostUrlSanitisationRule.create!(
-        priority: 10,
-        source_pattern: '\\Ahttps://example\\.com/(a+)\\z',
-        replacement: 'https://example.com/\\1\\1'
-      )
-
-      post = described_class.new(
-        title: 'long URL',
-        url: "https://example.com/#{ path }"
-      )
-
-      expect(post).to be_invalid
-      expect(post.errors.details.fetch(:url)).to include(
-        error: :too_long,
-        count: 768
-      )
-    end
-
-    it 'validates uniqueness after sanitisation' do
-      PostUrlSanitisationRule.create!(
-        priority: 10,
-        source_pattern: '\\Ahttps://example\\.com/alias\\z',
-        replacement: 'https://example.com/canonical'
-      )
-      create(:post, url: 'https://example.com/canonical')
-
-      post = described_class.new(title: 'duplicate URL', url: 'https://example.com/alias')
-
-      expect(post).to be_invalid
-      expect(post.errors.details.fetch(:url)).to include(error: :taken, value: post.url)
-    end
-  end
-
-  describe 'thumbnail processing' do
-    def image_blob(width:, height:, background:, draw: nil)
-      Tempfile.create(['post-thumbnail', '.png']) do |file|
-        MiniMagick::Tool::Convert.new do |convert|
-          convert.size "#{ width }x#{ height }"
-          convert.xc background
-          draw&.call(convert)
-          convert << file.path
-        end
-        File.binread(file.path)
-      end
-    end
-
-    def upload_for(blob)
-      StringIO.new(blob).tap(&:rewind)
-    end
-
-    def read_image(attachment)
-      blob =
-          attachment.is_a?(Hash) ? attachment.fetch(:io).read : attachment.download
-      MiniMagick::Image.read(blob)
-    end
-
-    def colour_at(image, x, y)
-      image.get_pixels.fetch(y).fetch(x)
-    end
-
-    def expect_green(pixel)
-      expect(pixel[1]).to be > pixel[0] + 40
-      expect(pixel[1]).to be > pixel[2] + 40
-    end
-
-    def expect_red(pixel)
-      expect(pixel[0]).to be > pixel[1] + 40
-      expect(pixel[0]).to be > pixel[2] + 40
-    end
-
-    def expect_blue(pixel)
-      expect(pixel[2]).to be > pixel[0] + 40
-      expect(pixel[2]).to be > pixel[1] + 40
-    end
-
-    describe '.resized_thumbnail_attachment' do
-      it 'fits a wide image within 180x180 without distorting it' do
-        blob = image_blob(
-            width: 360,
-            height: 180,
-            background: 'red',
-            draw: -> convert {
-              convert.fill 'green'
-              convert.draw 'rectangle 90,0 269,179'
-            })
-
-        resized = described_class.resized_thumbnail_attachment(upload_for(blob))
-        image = read_image(resized)
-
-        expect(image.dimensions).to eq([180, 90])
-        expect_red(colour_at(image, 0, 45))
-        expect_green(colour_at(image, 90, 45))
-        expect_red(colour_at(image, 179, 45))
-      end
-
-      it 'fits a tall image within 180x180 without distorting it' do
-        blob = image_blob(
-            width: 180,
-            height: 360,
-            background: 'red',
-            draw: -> convert {
-              convert.fill 'green'
-              convert.draw 'rectangle 0,90 179,269'
-            })
-
-        resized = described_class.resized_thumbnail_attachment(upload_for(blob))
-        image = read_image(resized)
-
-        expect(image.dimensions).to eq([90, 180])
-        expect_red(colour_at(image, 45, 0))
-        expect_green(colour_at(image, 45, 90))
-        expect_red(colour_at(image, 45, 179))
-      end
-
-      it 'keeps a square image square without distortion' do
-        blob = image_blob(
-            width: 180,
-            height: 180,
-            background: 'red',
-            draw: -> convert {
-              convert.fill 'blue'
-              convert.draw 'rectangle 90,0 179,179'
-            })
-
-        resized = described_class.resized_thumbnail_attachment(upload_for(blob))
-        image = read_image(resized)
-
-        expect(image.dimensions).to eq([180, 180])
-        expect_red(colour_at(image, 20, 90))
-        expect_blue(colour_at(image, 160, 90))
-      end
-    end
-
-    describe '#attach_thumbnail_from_url!' do
-      it 'attaches a fetched remote image through the common resize path' do
-        blob = image_blob(
-            width: 240,
-            height: 180,
-            background: 'red',
-            draw: -> convert {
-              convert.fill 'green'
-              convert.draw 'rectangle 30,0 209,179'
-            })
-        response = Preview::HttpFetcher::Response.new(
-            blob,
-            'image/png',
-            'https://example.com/thumb.png')
-        allow(Preview::ThumbnailFetcher).to receive(:fetch_image_response)
-            .with('https://example.com/thumb.png')
-            .and_return(response)
-
-        post = described_class.create!(title: 'title', url: 'https://example.com/post')
-
-        expect(post.thumbnail).to receive(:attach).once.and_call_original
-        post.attach_thumbnail_from_url!('https://example.com/thumb.png')
-
-        expect(post.thumbnail).to be_attached
-        image = read_image(post.thumbnail)
-        expect(image.dimensions).to eq([180, 135])
-      end
-
-      it 'does not attach anything when thumbnail conversion fails' do
-        response = Preview::HttpFetcher::Response.new(
-            'not-an-image',
-            'image/png',
-            'https://example.com/thumb.png')
-        allow(Preview::ThumbnailFetcher).to receive(:fetch_image_response)
-            .with('https://example.com/thumb.png')
-            .and_return(response)
-        allow(described_class).to receive(:resized_thumbnail_attachment)
-            .and_raise(MiniMagick::Error, 'convert failed')
-
-        post = described_class.create!(title: 'title', url: 'https://example.com/post')
-
-        expect {
-          post.attach_thumbnail_from_url!('https://example.com/thumb.png')
-        }.to raise_error(Post::RemoteThumbnailFetchFailed, 'convert failed')
-
-        expect(post.thumbnail).not_to be_attached
-      end
-
-      it 'keeps an existing thumbnail when remote conversion fails' do
-        existing = described_class.create!(title: 'title', url: 'https://example.com/post')
-        existing.thumbnail.attach(
-            io: StringIO.new('existing'),
-            filename: 'existing.jpg',
-            content_type: 'image/jpeg')
-        blob_id = existing.thumbnail.blob.id
-        response = Preview::HttpFetcher::Response.new(
-            'not-an-image',
-            'image/png',
-            'https://example.com/thumb.png')
-        allow(Preview::ThumbnailFetcher).to receive(:fetch_image_response)
-            .with('https://example.com/thumb.png')
-            .and_return(response)
-        allow(described_class).to receive(:resized_thumbnail_attachment)
-            .and_raise(MiniMagick::Error, 'convert failed')
-
-        expect {
-          existing.attach_thumbnail_from_url!('https://example.com/thumb.png')
-        }.to raise_error(Post::RemoteThumbnailFetchFailed, 'convert failed')
-
-        existing.reload
-        expect(existing.thumbnail).to be_attached
-        expect(existing.thumbnail.blob.id).to eq(blob_id)
-      end
-    end
-  end
-
-  describe 'original created datetime validation' do
-    it 'allows unrelated updates on persisted posts with second-bearing datetimes' do
-      post = described_class.create!(title: 'title', url: 'https://example.com/post')
-      post.update_columns(
-        original_created_from: Time.zone.parse('2024-01-01T12:34:30Z'),
-        original_created_before: Time.zone.parse('2024-01-01T12:35:30Z')
-      )
-
-      post.title = 'updated title'
-
-      expect(post).to be_valid
-      expect { post.save! }.not_to raise_error
-    end
-
-    it 'rejects second-bearing updates when the datetime field changes' do
-      post = described_class.create!(title: 'title', url: 'https://example.com/post')
-
-      post.original_created_from = '2024-01-01T12:34:30Z'
-
-      expect(post).to be_invalid
-      expect(post.errors[:original_created_from]).to eq(
-        [described_class::ORIGINAL_CREATED_MINUTE_PRECISION_MESSAGE]
-      )
-    end
-
-    it 'accepts fixing persisted datetimes to minute precision' do
-      post = described_class.create!(title: 'title', url: 'https://example.com/post')
-      post.update_columns(
-        original_created_from: Time.zone.parse('2024-01-01T12:34:30Z'),
-        original_created_before: Time.zone.parse('2024-01-01T12:35:30Z')
-      )
-
-      post.original_created_from = '2024-01-01T12:34Z'
-      post.original_created_before = '2024-01-01T12:35Z'
-
-      expect(post).to be_valid
-      expect { post.save! }.not_to raise_error
-    end
-
-    it 'adds only the minute-precision error for second precision values' do
-      post = described_class.new(
-        title: 'title',
-        url: 'https://example.com/post',
-        original_created_from: '2024-01-01T12:34:30',
-        original_created_before: '2024-01-01T12:35'
-      )
-
-      expect(post).to be_invalid
-      expect(post.errors[:original_created_from]).to eq(
-        [described_class::ORIGINAL_CREATED_MINUTE_PRECISION_MESSAGE]
-      )
-      expect(post.errors[:original_created_at]).to be_empty
-    end
-
-    it 'adds only the minute-precision error for fractional-second values' do
-      post = described_class.new(
-        title: 'title',
-        url: 'https://example.com/post',
-        original_created_from: '2024-01-01T12:34:00.123',
-        original_created_before: '2024-01-01T12:35'
-      )
-
-      expect(post).to be_invalid
-      expect(post.errors[:original_created_from]).to eq(
-        [described_class::ORIGINAL_CREATED_MINUTE_PRECISION_MESSAGE]
-      )
-      expect(post.errors[:original_created_at]).to be_empty
-    end
-
-    it 'checks range rules only for valid minute-precision endpoints' do
-      post = described_class.new(
-        title: 'title',
-        url: 'https://example.com/post',
-        original_created_from: '2024-01-01T12:34',
-        original_created_before: '2024-01-01T12:34'
-      )
-
-      expect(post).to be_invalid
-      expect(post.errors[:original_created_at]).to eq(
-        [described_class::ORIGINAL_CREATED_ORDER_MESSAGE]
-      )
-    end
-
-    it 'accepts a one-minute range at minute precision' do
-      post = described_class.new(
-        title: 'title',
-        url: 'https://example.com/post',
-        original_created_from: '2024-01-01T12:34',
-        original_created_before: '2024-01-01T12:35'
-      )
-
-      expect(post).to be_valid
-    end
-
-    it 'rejects invalid calendar dates and invalid hours' do
-      invalid_dates = [
-        '2024-02-31T12:00',
-        '2023-02-29T12:00',
-        '2024-02-29T24:00'
-      ]
-
-      invalid_dates.each do |value|
-        post = described_class.new(
-          title: 'title',
-          url: 'https://example.com/post',
-          original_created_from: value
-        )
-
-        expect(post).to be_invalid
-        expect(post.errors[:original_created_from]).to eq(
-          [described_class::ORIGINAL_CREATED_INVALID_MESSAGE]
-        )
-      end
-    end
-  end
-end

backend/spec/models/post_tag_spec.rb

@@ -1,41 +0,0 @@
-RSpec.describe PostTag, type: :model do
-  describe '#sections' do
-    it 'loads sections by post_id and tag_id' do
-      post_tag = create(:post_tag)
-      section = create(:post_tag_section,
-                       post: post_tag.post,
-                       tag: post_tag.tag,
-                       begin_ms: 1000,
-                       end_ms: 2000)
-
-      expect(post_tag.sections).to contain_exactly(section)
-    end
-
-    it 'does not load sections for another tag on the same post' do
-      post = create(:post)
-      tag = create(:tag)
-      other_tag = create(:tag)
-
-      post_tag = create(:post_tag, post:, tag:)
-      create(:post_tag_section,
-             post:,
-             tag: other_tag,
-             begin_ms: 1000,
-             end_ms: 2000)
-
-      expect(post_tag.sections).to be_empty
-    end
-
-    it 'allows open-ended sections' do
-      post_tag = create(:post_tag)
-      section = create(:post_tag_section,
-                       post: post_tag.post,
-                       tag: post_tag.tag,
-                       begin_ms: 1000,
-                       end_ms: nil)
-
-      expect(section).to be_valid
-      expect(post_tag.sections).to contain_exactly(section)
-    end
-  end
-end

backend/spec/models/post_url_sanitisation_rule_spec.rb

@@ -1,265 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe PostUrlSanitisationRule, type: :model do
-  before do
-    described_class.unscoped.delete_all
-  end
-
-  describe 'validations' do
-    it 'requires a source pattern' do
-      rule = described_class.new(priority: 10, source_pattern: nil, replacement: '')
-
-      expect(rule).to be_invalid
-      expect(rule.errors.details.fetch(:source_pattern)).to eq([{ error: :blank }])
-    end
-
-    it 'requires a unique source pattern' do
-      described_class.create!(priority: 10, source_pattern: 'source', replacement: 'first')
-      rule = described_class.new(
-        priority: 20,
-        source_pattern: 'source',
-        replacement: 'second'
-      )
-
-      expect(rule).to be_invalid
-      expect(rule.errors.details.fetch(:source_pattern)).to include(
-        error: :taken,
-        value: 'source'
-      )
-    end
-
-    it 'rejects an invalid regexp' do
-      rule = described_class.new(priority: 10, source_pattern: '[', replacement: '')
-
-      expect(rule).to be_invalid
-      expect(rule.errors[:source_pattern]).to include('変な正規表現だね〜（笑）')
-    end
-  end
-
-  describe '.sanitise' do
-    it 'applies each active rule once in priority order' do
-      described_class.create!(priority: 30, source_pattern: 'c', replacement: 'd')
-      described_class.create!(priority: 10, source_pattern: 'a', replacement: 'aa')
-      described_class.create!(priority: 20, source_pattern: 'aa', replacement: 'c')
-      discarded = described_class.create!(
-        priority: 5,
-        source_pattern: '.',
-        replacement: 'discarded'
-      )
-      discarded.discard!
-
-      expect(described_class.sanitise('a')).to eq('d')
-    end
-
-    it 'canonicalises the initial YouTube and Nico URL forms' do
-      create_initial_rules
-
-      urls = {
-        'https://youtu.be/abc123?si=share' => youtube_url('abc123'),
-        'https://www.youtube.com/live/abc123?t=10' => youtube_url('abc123'),
-        'https://youtube.com/shorts/abc123?feature=share' => youtube_url('abc123'),
-        'https://m.youtube.com/embed/abc123' => youtube_url('abc123'),
-        'https://youtube.com/watch?feature=share&v=abc123&t=10' => youtube_url('abc123'),
-        'https://nico.ms/sm123?from=share#fragment' => nico_url('sm123'),
-        'https://www.nicovideo.jp/watch/sm123?ref=share#fragment' => nico_url('sm123')
-      }
-
-      urls.each do |url, canonical_url|
-        expect(described_class.sanitise(url)).to eq(canonical_url)
-      end
-    end
-  end
-
-  describe '.apply!' do
-    it 'locks posts in ID order and updates through temporary URLs' do
-      first = create(:post, url: 'https://example.com/source/1')
-      second = create(:post, url: 'https://example.com/source/2')
-      create_source_rule
-      sql = capture_sql { described_class.apply! }
-
-      lock_sql = sql.find { _1.match?(/SELECT .*posts.*FOR UPDATE/i) }
-      expect(lock_sql).to match(/ORDER BY .*posts.*id.* ASC/i)
-      expect(sql.grep(/post-url-sanitising\.invalid/).size).to eq(2)
-      expect(first.reload.url).to eq('https://example.com/canonical/1')
-      expect(second.reload.url).to eq('https://example.com/canonical/2')
-    end
-
-    it 'loads and compiles rules only once' do
-      create(:post, url: 'https://example.com/source/1')
-      create(:post, url: 'https://example.com/source/2')
-      create_source_rule
-
-      expect(described_class).to receive(:rules).once.and_call_original
-
-      described_class.apply!
-    end
-
-    it 'does not change post versions, version_no, or updated_at' do
-      post = create(:post, url: 'https://example.com/source/1')
-      post.update_columns(version_no: 7, updated_at: 1.day.ago)
-      original_updated_at = post.reload.updated_at
-      create_source_rule
-
-      expect { described_class.apply! }.not_to change(PostVersion, :count)
-
-      post.reload
-      expect(post.url).to eq('https://example.com/canonical/1')
-      expect(post.version_no).to eq(7)
-      expect(post.updated_at).to eq(original_updated_at)
-    end
-
-    invalid_urls = {
-      'a blank URL' => '',
-      'an unparseable URL' => 'https://[',
-      'a non-HTTP URL' => 'ftp://example.com/file',
-      'an HTTP URL without a host' => 'https:/path'
-    }
-
-    invalid_urls.each do |description, sanitised_url|
-      it "rolls back every update when sanitisation produces #{ description }" do
-        valid_post = create(:post, url: 'https://example.com/source/1')
-        invalid_post = create(:post, url: 'https://example.com/invalid')
-        create_source_rule
-        described_class.create!(
-          priority: 20,
-          source_pattern: '\\Ahttps://example\\.com/invalid\\z',
-          replacement: sanitised_url
-        )
-
-        expect { described_class.apply! }
-            .to raise_error(described_class::InvalidUrlError) { |error|
-          expect(error.invalid_rows).to eq([
-            { post_id: invalid_post.id,
-              original_url: 'https://example.com/invalid',
-              sanitised_url: }
-          ])
-        }
-        expect(valid_post.reload.url).to eq('https://example.com/source/1')
-        expect(invalid_post.reload.url).to eq('https://example.com/invalid')
-      end
-    end
-
-    it 'rolls back every update when sanitisation produces a URL longer than 768 characters' do
-      path = 'a' * 375
-      original_url = "https://example.com/#{ path }"
-      sanitised_url = "https://example.com/#{ path }#{ path }"
-      valid_post = create(:post, url: 'https://example.com/source/1')
-      invalid_post = create(:post, url: original_url)
-      create_source_rule
-      described_class.create!(
-        priority: 20,
-        source_pattern: '\\Ahttps://example\\.com/(a+)\\z',
-        replacement: 'https://example.com/\\1\\1'
-      )
-
-      expect { described_class.apply! }
-          .to raise_error(described_class::InvalidUrlError) { |error|
-        expect(error.invalid_rows).to eq([
-          { post_id: invalid_post.id,
-            original_url:,
-            sanitised_url: }
-        ])
-      }
-      expect(valid_post.reload.url).to eq('https://example.com/source/1')
-      expect(invalid_post.reload.url).to eq(original_url)
-    end
-
-    it 'rejects sanitised URL collisions case-insensitively without changing posts' do
-      source = create(:post, url: 'https://example.com/source/Foo')
-      canonical = create(:post, url: 'https://example.com/canonical/foo')
-      create_source_rule
-
-      expect { described_class.apply! }
-          .to raise_error(described_class::UrlConflictError) { |error|
-        expect(error.conflicts).to contain_exactly(
-          { url: 'https://example.com/canonical/Foo',
-            post_id: source.id,
-            original_url: 'https://example.com/source/Foo' },
-          { url: 'https://example.com/canonical/foo',
-            post_id: canonical.id,
-            original_url: 'https://example.com/canonical/foo' }
-        )
-      }
-      expect(source.reload.url).to eq('https://example.com/source/Foo')
-      expect(canonical.reload.url).to eq('https://example.com/canonical/foo')
-      expect(Post.count).to eq(2)
-    end
-
-    it 'converts a persisted URL constraint race into UrlConflictError' do
-      post = create(:post, url: 'https://example.com/source/1')
-      create_source_rule
-      conflict = { url: 'https://example.com/canonical/1',
-                   post_id: post.id,
-                   original_url: post.url }
-      database_error = ActiveRecord::RecordNotUnique.new('duplicate URL')
-      allow_any_instance_of(ActiveRecord::Relation)
-          .to receive(:update_all).and_raise(database_error)
-      allow(described_class).to receive(:build_persisted_conflicts).and_return([conflict])
-
-      expect { described_class.apply! }
-          .to raise_error(described_class::UrlConflictError) { |error|
-        expect(error.conflicts).to eq([conflict])
-        expect(error.cause).to equal(database_error)
-      }
-      expect(post.reload.url).to eq('https://example.com/source/1')
-    end
-
-    it 're-raises an unidentified RecordNotUnique error' do
-      post = create(:post, url: 'https://example.com/source/1')
-      create_source_rule
-      database_error = ActiveRecord::RecordNotUnique.new('another unique constraint')
-      allow_any_instance_of(ActiveRecord::Relation)
-          .to receive(:update_all).and_raise(database_error)
-      allow(described_class).to receive(:build_persisted_conflicts).and_return([])
-
-      expect { described_class.apply! }.to raise_error(database_error)
-      expect(post.reload.url).to eq('https://example.com/source/1')
-    end
-  end
-
-  def capture_sql
-    statements = []
-    subscriber = lambda do |_name, _start, _finish, _id, payload|
-      binds = payload.fetch(:binds, []).map { _1.value_for_database.to_s }
-      statements << ([payload.fetch(:sql)] + binds).join(' ')
-    end
-    ActiveSupport::Notifications.subscribed(subscriber, 'sql.active_record') { yield }
-    statements
-  end
-
-  def create_source_rule
-    described_class.create!(
-      priority: 10,
-      source_pattern: '\\Ahttps://example\\.com/source/(.+)\\z',
-      replacement: 'https://example.com/canonical/\\1'
-    )
-  end
-
-  def create_initial_rules
-    rules = [
-      ['\\Ahttps?://youtu\\.be/([^/?#]+)(?:[?#].*)?\\z', youtube_url('\\1')],
-      ['\\Ahttps?://(?:www\\.|m\\.)?youtube\\.com/live/([^/?#]+)(?:[?#].*)?\\z',
-       youtube_url('\\1')],
-      ['\\Ahttps?://(?:www\\.|m\\.)?youtube\\.com/shorts/([^/?#]+)(?:[?#].*)?\\z',
-       youtube_url('\\1')],
-      ['\\Ahttps?://(?:www\\.|m\\.)?youtube\\.com/embed/([^/?#]+)(?:[?#].*)?\\z',
-       youtube_url('\\1')],
-      ['\\Ahttps?://(?:www\\.|m\\.)?youtube\\.com/watch\\?(?:[^#&]+&)*' \
-       'v=([^&#]+)(?:[&#].*)?\\z', youtube_url('\\1')],
-      ['\\Ahttps?://nico\\.ms/([^/?#]+)(?:[?#].*)?\\z', nico_url('\\1')],
-      ['\\Ahttps?://(?:www\\.)?nicovideo\\.jp/watch/([^?#/]+)(?:[?#].*)?\\z',
-       nico_url('\\1')]
-    ]
-    rules.each_with_index do |(source_pattern, replacement), index|
-      described_class.create!(
-        priority: (index + 1) * 10,
-        source_pattern:,
-        replacement:
-      )
-    end
-  end
-
-  def youtube_url(video_id) = "https://www.youtube.com/watch?v=#{ video_id }"
-
-  def nico_url(video_id) = "https://www.nicovideo.jp/watch/#{ video_id }"
-end

backend/spec/models/setting_spec.rb

@@ -1,34 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Setting, type: :model do
-  it 'accepts the default typed user settings' do
-    setting = described_class.new({ user: create(:user) }.merge(described_class.defaults))
-
-    expect(setting).to be_valid
-  end
-
-  it 'requires one settings row per user' do
-    user = create(:user)
-    described_class.create!({ user: }.merge(described_class.defaults))
-
-    duplicate = described_class.new({ user: }.merge(described_class.defaults))
-
-    expect(duplicate).not_to be_valid
-    expect(duplicate.errors[:user_id]).to be_present
-  end
-
-  it 'validates enum-like settings columns' do
-    setting = described_class.new(
-        { user: create(:user),
-          theme: 'neon',
-          auto_fetch_title: 'sometimes',
-          auto_fetch_thumbnail: 'sometimes',
-          wiki_editor_mode: 'sideways' })
-
-    expect(setting).not_to be_valid
-    expect(setting.errors[:theme]).to be_present
-    expect(setting.errors[:auto_fetch_title]).to be_present
-    expect(setting.errors[:auto_fetch_thumbnail]).to be_present
-    expect(setting.errors[:wiki_editor_mode]).to be_present
-  end
-end

backend/spec/models/tag_implication_spec.rb

@@ -1,36 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe TagImplication, type: :model do
-  it 'rejects a parent tag that would create a cycle' do
-    child = create(:tag, name: 'tag_implication_cycle_child')
-    parent = create(:tag, name: 'tag_implication_cycle_parent')
-
-    described_class.create!(tag: child, parent_tag: parent)
-
-    implication = described_class.new(tag: parent, parent_tag: child)
-
-    expect(implication).not_to be_valid
-    expect(implication.errors[:parent_tag_id]).to include(
-      '親タグに子孫タグを指定すると循環します．'
-    )
-    expect(implication.errors[:base]).to be_present
-  end
-
-  it 'terminates even when existing data already contains a cycle' do
-    child = create(:tag, name: 'tag_implication_existing_cycle_child')
-    parent = create(:tag, name: 'tag_implication_existing_cycle_parent')
-    ancestor = create(:tag, name: 'tag_implication_existing_cycle_ancestor')
-
-    described_class.create!(tag: parent, parent_tag: ancestor)
-    described_class.insert_all!(
-      [
-        { tag_id: ancestor.id, parent_tag_id: parent.id,
-          created_at: Time.current, updated_at: Time.current }
-      ]
-    )
-
-    implication = described_class.new(tag: child, parent_tag: parent)
-
-    expect(implication).to be_valid
-  end
-end

backend/spec/models/tag_spec.rb

@@ -19,95 +19,6 @@ RSpec.describe Tag, type: :model do
         expect(error.tag_names).to eq([deprecated_tag.name])
       }
     end
-
-    it 'rejects invalid section literals instead of treating them as zero' do
-      expect {
-        described_class.normalise_tags!(
-          ['normalise_invalid_section[1:aa-2:00]'],
-          with_sections: true
-        )
-      }.to raise_error(Tag::SectionLiteralParseError)
-    end
-
-    it 'parses open-ended section literals' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[1:00-]'],
-        with_sections: true
-      )
-
-      tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
-      expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, nil]])
-    end
-
-    it 'parses omitted begin as zero' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[-1:00]'],
-        with_sections: true
-      )
-
-      tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
-      expect(result.fetch(:sections).fetch(tag.id)).to eq([[0, 60_000]])
-    end
-
-    it 'treats fully open section literals as plain tags' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[-]'],
-        with_sections: true
-      )
-
-      tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
-      expect(result.fetch(:sections)[tag.id]).to be_nil
-    end
-
-    it 'treats [0:00-] as a plain tag' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[0:00-]'],
-        with_sections: true
-      )
-
-      tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
-      expect(result.fetch(:sections)[tag.id]).to be_nil
-    end
-
-    it 'expands zero-width sections to one millisecond' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[1:00-1:00]'],
-        with_sections: true
-      )
-
-      tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
-      expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, 60_001]])
-    end
-
-    it 'swaps reversed section boundaries' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[2:00-1:00]'],
-        with_sections: true
-      )
-
-      tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
-      expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, 120_000]])
-    end
-
-    it 'merges open-ended sections over later bounded sections' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[1:00-][2:00-3:00]'],
-        with_sections: true
-      )
-
-      tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
-      expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, nil]])
-    end
-
-    it 'merges adjacent bounded and open-ended sections' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[1:00-3:00][3:00-]'],
-        with_sections: true
-      )
-
-      tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
-      expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, nil]])
-    end
   end
 
   describe '.expand_parent_tags' do
@@ -143,17 +54,7 @@ RSpec.describe Tag, type: :model do
       first = create(:tag, name: 'expand_cycle_first')
       second = create(:tag, name: 'expand_cycle_second')
       TagImplication.create!(tag: first, parent_tag: second)
-      now = Time.current
+      TagImplication.create!(tag: second, parent_tag: first)
-      TagImplication.insert_all!(
-        [
-          {
-            tag_id: second.id,
-            parent_tag_id: first.id,
-            created_at: now,
-            updated_at: now
-          }
-        ]
-      )
 
       expect(described_class.expand_parent_tags([first])).to contain_exactly(first, second)
     end

backend/spec/models/user_theme_slot_spec.rb

@@ -1,40 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe UserThemeSlot, type: :model do
-  it 'accepts a theme slot for one user, base theme, and slot number' do
-    slot = described_class.new(user: create(:user),
-                               base_theme: 'light',
-                               slot_no: 1,
-                               tokens: { 'background' => '0 0% 100%' })
-
-    expect(slot).to be_valid
-  end
-
-  it 'requires unique slot numbers per user and base theme' do
-    user = create(:user)
-    described_class.create!(user:,
-                            base_theme: 'dark',
-                            slot_no: 2,
-                            tokens: { 'background' => '222.2 84% 4.9%' })
-
-    duplicate = described_class.new(user:,
-                                    base_theme: 'dark',
-                                    slot_no: 2,
-                                    tokens: { 'background' => '0 0% 100%' })
-
-    expect(duplicate).not_to be_valid
-    expect(duplicate.errors[:user_id]).to be_present
-  end
-
-  it 'validates base theme, slot number, and token object shape' do
-    slot = described_class.new(user: create(:user),
-                               base_theme: 'system',
-                               slot_no: 4,
-                               tokens: 'not-object')
-
-    expect(slot).not_to be_valid
-    expect(slot.errors[:base_theme]).to be_present
-    expect(slot.errors[:slot_no]).to be_present
-    expect(slot.errors[:tokens]).to be_present
-  end
-end

backend/spec/requests/materials_spec.rb

@@ -287,25 +287,6 @@ RSpec.describe 'Materials API', type: :request do
         expect(json.dig('export_paths', 'legacy_drive')).to eq('伊地知ニジカ/created.png')
       end
 
-      it 'creates a create tag_version for a newly created material tag' do
-        expect do
-          post '/materials', params: {
-            tag: 'material_create_versioned_tag',
-            file: dummy_upload(filename: 'created.png')
-          }
-        end.to change(TagVersion, :count).by(1)
-
-        expect(response).to have_http_status(:created)
-
-        tag = Tag.joins(:tag_name).find_by!(tag_names: { name: 'material_create_versioned_tag' })
-        version = tag.tag_versions.order(:version_no).last
-
-        expect(version.event_type).to eq('create')
-        expect(version.name).to eq('material_create_versioned_tag')
-        expect(version.category).to eq('material')
-        expect(version.created_by_user).to eq(member_user)
-      end
-
       it 'snapshots attached file metadata and sha256' do
         post '/materials', params: {
           tag: 'material_create_file_version',
@@ -485,73 +466,6 @@ RSpec.describe 'Materials API', type: :request do
         expect(json.dig('tag', 'name')).to eq('material_update_new')
       end
 
-      it 'creates a create tag_version when update creates a new tag' do
-        expect do
-          put "/materials/#{ material.id }", params: {
-            tag: 'material_update_versioned_tag',
-            file: dummy_upload(filename: 'updated.png')
-          }
-        end.to change(Tag, :count).by(1)
-          .and change(TagName, :count).by(1)
-          .and change(TagVersion, :count).by(1)
-
-        expect(response).to have_http_status(:ok)
-
-        tag = Tag.joins(:tag_name).find_by!(tag_names: { name: 'material_update_versioned_tag' })
-        version = tag.tag_versions.order(:version_no).last
-
-        expect(version.event_type).to eq('create')
-        expect(version.name).to eq('material_update_versioned_tag')
-        expect(version.category).to eq('material')
-        expect(version.created_by_user).to eq(member_user)
-      end
-
-      it 'backfills a create tag_version for an existing material tag without history' do
-        existing_tag =
-            Tag.create!(tag_name: TagName.create!(name: 'material_update_existing_no_history'),
-                        category: :material)
-
-        expect(existing_tag.tag_versions).to be_empty
-
-        expect do
-          put "/materials/#{ material.id }", params: {
-            tag: 'material_update_existing_no_history',
-            file: dummy_upload(filename: 'updated.png')
-          }
-        end.to change(TagVersion, :count).by(1)
-
-        expect(response).to have_http_status(:ok)
-
-        version = existing_tag.reload.tag_versions.order(:version_no).last
-        expect(version.event_type).to eq('create')
-        expect(version.name).to eq('material_update_existing_no_history')
-        expect(version.category).to eq('material')
-        expect(version.created_by_user).to eq(member_user)
-      end
-
-      it 'backfills a create tag_version for an existing character tag without history' do
-        existing_tag =
-            Tag.create!(tag_name: TagName.create!(name: 'material_update_character_no_history'),
-                        category: :character)
-
-        expect(existing_tag.tag_versions).to be_empty
-
-        expect do
-          put "/materials/#{ material.id }", params: {
-            tag: 'material_update_character_no_history',
-            file: dummy_upload(filename: 'updated.png')
-          }
-        end.to change(TagVersion, :count).by(1)
-
-        expect(response).to have_http_status(:ok)
-
-        version = existing_tag.reload.tag_versions.order(:version_no).last
-        expect(version.event_type).to eq('create')
-        expect(version.name).to eq('material_update_character_no_history')
-        expect(version.category).to eq('character')
-        expect(version.created_by_user).to eq(member_user)
-      end
-
       it 'detaches the existing file without purging blob when url replaces file' do
         old_blob_id = material.file.blob.id
 
@@ -580,7 +494,6 @@ RSpec.describe 'Materials API', type: :request do
       it 'does not increase version for the same snapshot update' do
         MaterialVersionRecorder.record!(material:, event_type: :create,
                                         created_by_user: member_user)
-        TagVersioning.ensure_snapshot!(tag, created_by_user: member_user)
 
         expect do
           put "/materials/#{ material.id }", params: {
@@ -588,8 +501,6 @@ RSpec.describe 'Materials API', type: :request do
           }
         end.not_to change(MaterialVersion, :count)
 
-        expect(tag.reload.tag_versions.count).to eq(1)
-
         expect(response).to have_http_status(:ok)
         expect(material.reload.version_no).to eq(1)
       end

backend/spec/requests/posts_spec.rb

@@ -1,5 +1,4 @@
 require 'rails_helper'
-require 'base64'
 require 'set'
 
 include ActiveSupport::Testing::TimeHelpers
@@ -9,11 +8,6 @@ RSpec.describe 'Posts API', type: :request do
   # resized_thumbnail! が MiniMagick 依存でコケやすいので request spec ではスタブしとくのが無難。
   before do
     allow_any_instance_of(Post).to receive(:resized_thumbnail!).and_return(true)
-    allow(Post).to receive(:resized_thumbnail_attachment) do
-      { io: StringIO.new('dummy'),
-        filename: 'resized_thumbnail.jpg',
-        content_type: 'image/jpeg' }
-    end
   end
 
   def create_nico_tag!(name)
@@ -21,19 +15,8 @@ RSpec.describe 'Posts API', type: :request do
   end
 
   def dummy_upload
-    real_thumbnail_upload
+    # 中身は何でもいい（加工処理はスタブしてる）
-  end
+    Rack::Test::UploadedFile.new(StringIO.new('dummy'), 'image/jpeg', original_filename: 'dummy.jpg')
-
-  def real_thumbnail_upload
-    gif =
-        Base64.decode64(
-            'R0lGODdhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=')
-
-    Rack::Test::UploadedFile.new(
-      StringIO.new(gif),
-      'image/gif',
-      original_filename: 'thumbnail.gif'
-    )
   end
 
   def post_write_params params = { }
@@ -53,7 +36,6 @@ RSpec.describe 'Posts API', type: :request do
             title: post.title,
             url: post.url,
             thumbnail_base: post.thumbnail_base,
-            video_ms: post.video_ms,
             tags: post.snapshot_tag_names.join(' '),
             parent_post_ids: post.snapshot_parent_post_ids.join(' '),
             original_created_from: post.original_created_from,
@@ -101,34 +83,34 @@ RSpec.describe 'Posts API', type: :request do
     end
   end
 
-  describe 'GET /posts' do
+  describe "GET /posts" do
     let!(:user) { create_member_user! }
 
-    let!(:tag_name) { TagName.create!(name: 'spec_tag') }
+    let!(:tag_name) { TagName.create!(name: "spec_tag") }
     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!(:alias_tag_name) { TagName.create!(name: 'manko', canonical: tag_name) }
 
     let!(:hit_post) do
-      Post.create!(uploaded_user: user, title: 'hello spec world',
+      Post.create!(uploaded_user: user, title: "hello spec world",
                    url: 'https://example.com/spec2').tap do |p|
         PostTag.create!(post: p, tag:)
       end
     end
 
     let!(:miss_post) do
-      Post.create!(uploaded_user: user, title: 'unrelated title',
+      Post.create!(uploaded_user: user, title: "unrelated title",
                    url: 'https://example.com/spec3').tap do |p|
         PostTag.create!(post: p, tag: tag2)
       end
     end
 
-    it 'returns posts with tag name in JSON' do
+    it "returns posts with tag name in JSON" do
-      get '/posts'
+      get "/posts"
 
       expect(response).to have_http_status(:ok)
-      posts = json.fetch('posts')
+      posts = json.fetch("posts")
 
       # 全postの全tagが name を含むこと
       expect(posts).not_to be_empty
@@ -141,29 +123,13 @@ RSpec.describe 'Posts API', type: :request do
       expect(json['count']).to be_an(Integer)
 
       # spec_tag を含む投稿が存在すること
-      all_tag_names = posts.flat_map { |p| p['tags'].map { |t| t['name'] } }
+      all_tag_names = posts.flat_map { |p| p["tags"].map { |t| t["name"] } }
-      expect(all_tag_names).to include('spec_tag')
+      expect(all_tag_names).to include("spec_tag")
     end
 
-    it 'keeps children and sections keys in non-detail tag responses' do
+    context "when q is provided" do
-      PostTagSection.create!(post: hit_post, tag:, begin_ms: 1_000, end_ms: nil)
+      it "filters posts by q (hit case)" do
-
+        get "/posts", params: { tags: "spec_tag" }
-      get '/posts'
-
-      expect(response).to have_http_status(:ok)
-
-      hit_json = json.fetch('posts').find { |post| post['id'] == hit_post.id }
-      tag_json = hit_json.fetch('tags').find { |item| item['name'] == 'spec_tag' }
-
-      expect(tag_json.fetch('children')).to eq([])
-      expect(tag_json.fetch('sections')).to eq([
-        { 'begin_ms' => 1_000, 'end_ms' => nil }
-      ])
-    end
-
-    context 'when q is provided' do
-      it 'filters posts by q (hit case)' do
-        get '/posts', params: { tags: 'spec_tag' }
 
         expect(response).to have_http_status(:ok)
         posts = json.fetch('posts')
@@ -181,8 +147,8 @@ RSpec.describe 'Posts API', type: :request do
         end
       end
 
-      it 'filters posts by q (hit case by alias)' do
+      it "filters posts by q (hit case by alias)" do
-        get '/posts', params: { tags: 'manko' }
+        get "/posts", params: { tags: "manko" }
 
         expect(response).to have_http_status(:ok)
         posts = json.fetch('posts')
@@ -200,11 +166,11 @@ RSpec.describe 'Posts API', type: :request do
         end
       end
 
-      it 'returns empty posts when nothing matches' do
+      it "returns empty posts when nothing matches" do
-        get '/posts', params: { tags: 'no_such_keyword_12345' }
+        get "/posts", params: { tags: "no_such_keyword_12345" }
 
         expect(response).to have_http_status(:ok)
-        expect(json.fetch('posts')).to eq([])
+        expect(json.fetch("posts")).to eq([])
         expect(json.fetch('count')).to eq(0)
       end
     end
@@ -692,73 +658,6 @@ RSpec.describe 'Posts API', type: :request do
     end
   end
 
-  describe 'GET /posts/metadata' do
-    let(:member) { create(:user, :member) }
-
-    it 'returns compact existing post data without fetching external metadata' do
-      sign_in_as(member)
-      existing = create(
-          :post,
-          title: 'existing post',
-          url: 'https://example.com/existing')
-      existing.thumbnail.attach(
-          io: StringIO.new('thumbnail'),
-          filename: 'thumbnail.jpg',
-          content_type: 'image/jpeg')
-      expect(PostMetadataFetcher).not_to receive(:fetch)
-
-      get '/posts/metadata', params: { url: 'https://example.com/existing' }
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include(
-          'url' => existing.url,
-          'existing_post_id' => existing.id,
-          'field_warnings' => { })
-      expect(json.fetch('existing_post')).to include(
-          'id' => existing.id,
-          'title' => existing.title,
-          'url' => existing.url,
-          'thumbnail_base' => existing.thumbnail_base)
-      expect(json.dig('existing_post', 'thumbnail'))
-          .to include('/rails/active_storage/blobs/proxy/')
-    end
-
-    it 'returns fetched metadata and structured display tags' do
-      sign_in_as(member)
-      allow(Preview::UrlSafety).to receive(:validate)
-      allow(PostMetadataFetcher).to receive(:fetch).and_return(
-          title: 'fetched title',
-          thumbnail_base: 'https://example.com/thumbnail.jpg',
-          tags: 'character:虹夏',
-          display_tags: [{ name: '虹夏', category: 'character' }],
-          original_created_from: nil,
-          original_created_before: nil,
-          duration: '1:00',
-          video_ms: 60_000)
-
-      get '/posts/metadata', params: { url: 'https://example.com/new' }
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include(
-          'url' => 'https://example.com/new',
-          'title' => 'fetched title',
-          'duration' => '1:00',
-          'video_ms' => 60_000,
-          'field_warnings' => { })
-      expect(json.fetch('display_tags')).to eq(
-          [{ 'name' => '虹夏', 'category' => 'character' }])
-    end
-
-    it 'returns URL validation errors as 422' do
-      sign_in_as(member)
-
-      get '/posts/metadata', params: { url: 'file:///etc/passwd' }
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to have_key('url')
-    end
-  end
-
   describe 'POST /posts' do
     let(:member) { create(:user, :member) }
     let!(:alias_tag_name) { TagName.create!(name: 'manko', canonical: tag_name) }
@@ -778,46 +677,6 @@ RSpec.describe 'Posts API', type: :request do
       expect(response).to have_http_status(:forbidden)
     end
 
-    it 'dry-runs without persisting posts or new tags' do
-      sign_in_as(member)
-      counts = [Post.count, Tag.count, TagName.count]
-
-      post '/posts?dry=1', params: post_write_params(
-          title: 'dry-run post',
-          url: 'https://example.com/dry-run',
-          tags: 'character:new_dry_run_tag')
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include(
-          'url' => 'https://example.com/dry-run',
-          'tags' => 'new_dry_run_tag',
-          'existing_post_id' => nil)
-      expect(json.fetch('display_tags')).to eq(
-          [{ 'name' => 'new_dry_run_tag',
-             'category' => 'character',
-             'section_literals' => [] }])
-      expect([Post.count, Tag.count, TagName.count]).to eq(counts)
-    end
-
-    it 'dry-runs an existing URL without validating its upload' do
-      sign_in_as(member)
-      existing = create(:post, url: 'https://example.com/dry-existing')
-      invalid_upload = Rack::Test::UploadedFile.new(
-          StringIO.new('<svg></svg>'),
-          'image/png',
-          original_filename: 'thumbnail.png')
-
-      post '/posts?dry=1', params: post_write_params(
-          title: '',
-          url: existing.url,
-          tags: '',
-          thumbnail: invalid_upload)
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include('existing_post_id' => existing.id)
-      expect(json.fetch('field_warnings')).not_to have_key('thumbnail_base')
-    end
-
     it '201 and creates post + tags when member' do
       sign_in_as(member)
 
@@ -837,67 +696,6 @@ RSpec.describe 'Posts API', type: :request do
       expect(json['tags'][0]).to have_key('name')
     end
 
-    it '201 when posting manually with a thumbnail' do
-      sign_in_as(member)
-      allow(Post).to receive(:resized_thumbnail_attachment).and_call_original
-
-      post '/posts', params: post_write_params(
-        title: 'thumbnail post',
-        url: 'https://example.com/thumbnail-post',
-        tags: 'spec_tag',
-        thumbnail: real_thumbnail_upload
-      )
-
-      expect(response).to have_http_status(:created)
-      post_record = Post.find(json.fetch('id'))
-      expect(post_record.thumbnail).to be_attached
-      expect(post_record.thumbnail.blob.content_type).to eq('image/jpeg')
-      expect { post_record.thumbnail.download }.not_to raise_error
-    end
-
-    it 'resizes the thumbnail before the create transaction begins' do
-      sign_in_as(member)
-
-      open_transactions = []
-      baseline_open_transactions = Post.connection.open_transactions
-      allow(Post).to receive(:resized_thumbnail_attachment) do |_upload|
-        open_transactions << Post.connection.open_transactions
-        { io: StringIO.new('dummy'),
-          filename: 'resized_thumbnail.jpg',
-          content_type: 'image/jpeg' }
-      end
-
-      post '/posts', params: post_write_params(
-        title: 'transaction post',
-        url: 'https://example.com/transaction-post',
-        tags: 'spec_tag',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-      expect(open_transactions).to eq(
-          [baseline_open_transactions, baseline_open_transactions])
-    end
-
-    it 'returns 422 and does not create a post when thumbnail resize fails' do
-      sign_in_as(member)
-      allow(Post).to receive(:resized_thumbnail_attachment).and_raise(MiniMagick::Error)
-
-      expect {
-        post '/posts', params: post_write_params(
-          title: 'broken thumbnail post',
-          url: 'https://example.com/broken-thumbnail-post',
-          tags: 'spec_tag',
-          thumbnail: dummy_upload
-        )
-      }.not_to change(Post, :count)
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'thumbnail' => ['サムネイル画像の変換に失敗しました．']
-      )
-    end
-
     it '201 and creates post + tags when member and tags have aliases' do
       sign_in_as(member)
 
@@ -934,7 +732,7 @@ RSpec.describe 'Posts API', type: :request do
 
       expect(response).to have_http_status(:unprocessable_entity)
       expect(json.fetch('errors')).to include(
-        'tags' => ['廃止済みタグがあります: deprecated_direct_tag']
+        'tags' => ['廃止済みタグは付与できません．']
       )
     end
 
@@ -969,199 +767,7 @@ RSpec.describe 'Posts API', type: :request do
       expect(saved_names).not_to include('deprecated_parent', 'deprecated_grandparent')
     end
 
-    it 'returns validation error for an invalid section literal' do
+    context "when nico tag already exists in tags" do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'invalid section literal',
-        url: 'https://example.com/invalid-section-literal',
-        tags: 'spec_tag[1:aa-2:00]',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json).to include(
-        'type' => 'validation_error',
-        'message' => '入力内容を確認してください．'
-      )
-      expect(json.fetch('errors')).to include(
-        'tags' => ['タグ区間の記法が不正です．']
-      )
-    end
-
-    it 'creates a video post with duration' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'video post',
-        url: 'https://example.com/video-post',
-        tags: '動画 spec_tag',
-        duration: '3:00.500',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-      expect(Post.find(json.fetch('id')).video_ms).to eq(180_500)
-      expect(json.fetch('video_ms')).to eq(180_500)
-    end
-
-    it 'creates a video post with number input duration seconds' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'video post seconds',
-        url: 'https://example.com/video-post-seconds',
-        tags: '動画 spec_tag',
-        duration: '180.5',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-      expect(Post.find(json.fetch('id')).video_ms).to eq(180_500)
-      expect(json.fetch('video_ms')).to eq(180_500)
-    end
-
-    it 'clears video_ms when the saved tags do not include 動画' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'non video post',
-        url: 'https://example.com/non-video-post',
-        tags: 'spec_tag',
-        duration: '3:00',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-      expect(Post.find(json.fetch('id')).video_ms).to be_nil
-    end
-
-    it 'returns validation error when a bounded section exceeds duration' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'too long section',
-        url: 'https://example.com/too-long-section',
-        tags: '動画 伊地知ニジカ[2:50-3:10]',
-        duration: '3:00',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'video_ms' => ['タグ区間の終端が動画時間を超えてゐます．']
-      )
-    end
-
-    it 'saves open-ended sections with end_ms NULL' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'open ended section literal',
-        url: 'https://example.com/open-ended-section-literal',
-        tags: '動画 伊地知ニジカ[1:00-]',
-        duration: '3:00',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-
-      created_post = Post.find(json.fetch('id'))
-      tag = Tag.joins(:tag_name).find_by!(tag_names: { name: '伊地知ニジカ' })
-      section = PostTagSection.find_by!(post: created_post, tag:)
-
-      expect(section.begin_ms).to eq(60_000)
-      expect(section.end_ms).to be_nil
-    end
-
-    it 'does not save sections for [-]' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'fully open section literal',
-        url: 'https://example.com/fully-open-section-literal',
-        tags: '伊地知ニジカ[-]',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-
-      created_post = Post.find(json.fetch('id'))
-      tag = Tag.joins(:tag_name).find_by!(tag_names: { name: '伊地知ニジカ' })
-      expect(PostTagSection.find_by(post: created_post, tag:)).to be_nil
-    end
-
-    it 'does not save sections for [0:00-]' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'zero open ended section literal',
-        url: 'https://example.com/zero-open-ended-section-literal',
-        tags: '伊地知ニジカ[0:00-]',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-
-      created_post = Post.find(json.fetch('id'))
-      tag = Tag.joins(:tag_name).find_by!(tag_names: { name: '伊地知ニジカ' })
-      expect(PostTagSection.find_by(post: created_post, tag:)).to be_nil
-    end
-
-    it 'returns end_ms null for open-ended sections in show response' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'show open ended section literal',
-        url: 'https://example.com/show-open-ended-section-literal',
-        tags: '動画 伊地知ニジカ[1:00-]',
-        duration: '3:00',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-
-      get "/posts/#{ json.fetch('id') }"
-
-      expect(response).to have_http_status(:ok)
-      tag_json = json.fetch('tags').find { |item| item['name'] == '伊地知ニジカ' }
-      expect(tag_json.fetch('sections')).to eq([
-        { 'begin_ms' => 60_000, 'end_ms' => nil }
-      ])
-    end
-
-    it 'allows open-ended sections when begin is within duration' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'valid open ended section literal',
-        url: 'https://example.com/valid-open-ended-section-literal',
-        tags: '動画 伊地知ニジカ[1:00-]',
-        duration: '3:00',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:created)
-    end
-
-    it 'rejects open-ended sections when begin equals duration' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-        title: 'invalid open ended section literal',
-        url: 'https://example.com/invalid-open-ended-section-literal',
-        tags: '動画 伊地知ニジカ[3:00-]',
-        duration: '3:00',
-        thumbnail: dummy_upload
-      )
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'video_ms' => ['タグ区間の開始が動画時間以上です．']
-      )
-    end
-
-    context 'when nico tag already exists in tags' do
       before do
         Tag.find_undiscard_or_create_by!(
             tag_name: TagName.find_undiscard_or_create_by!(name: 'nico:nico_tag'),
@@ -1358,47 +964,6 @@ RSpec.describe 'Posts API', type: :request do
     end
   end
 
-  describe 'POST /posts/bulk' do
-    let(:member) { create(:user, :member) }
-
-    it 'parses the manifest and indexed thumbnail parts' do
-      sign_in_as(member)
-      manifest = [{ 'url' => 'https://example.com/bulk',
-                    'title' => 'bulk post',
-                    'tags' => 'spec_tag',
-                    'parent_post_ids' => '' }]
-      creator = instance_double(
-          PostBulkCreator,
-          run: { results: [{ status: 'created', post: { id: 123 } }] })
-      allow(PostBulkCreator).to receive(:new).and_return(creator)
-
-      post '/posts/bulk', params: {
-          posts: JSON.generate(manifest),
-          thumbnails: { '0' => real_thumbnail_upload } }
-
-      expect(response).to have_http_status(:ok)
-      expect(json.fetch('results')).to eq(
-          [{ 'status' => 'created', 'post' => { 'id' => 123 } }])
-      expect(PostBulkCreator).to have_received(:new) do |arguments|
-        expect(arguments[:actor]).to eq(member)
-        expect(arguments[:posts]).to eq(manifest)
-        expect(arguments[:thumbnails].keys).to eq([0])
-        expect(arguments[:host]).to eq('http://www.example.com')
-      end
-    end
-
-    it 'rejects malformed manifests as a request-level error' do
-      sign_in_as(member)
-
-      post '/posts/bulk', params: {
-          posts: '{',
-          thumbnails: { '0' => real_thumbnail_upload } }
-
-      expect(response).to have_http_status(:bad_request)
-      expect(json.fetch('message')).to eq('posts manifest の JSON が不正です．')
-    end
-  end
-
   describe 'PUT /posts/:id' do
     let(:member) { create(:user, :member) }
 
@@ -1455,7 +1020,7 @@ RSpec.describe 'Posts API', type: :request do
       )
     end
 
-    context 'when nico tag already exists in tags' do
+    context "when nico tag already exists in tags" do
       before do
         Tag.find_undiscard_or_create_by!(
             tag_name: TagName.find_undiscard_or_create_by!(name: 'nico:nico_tag'),
@@ -1712,10 +1277,7 @@ RSpec.describe 'Posts API', type: :request do
         expect(post_record.reload.title).to eq('updated by other user')
       end
 
-      it(
+      it 'returns 409 with mergeable true when stale tag changes do not conflict but merge is not requested' do
-          'returns 409 with mergeable true when stale tag changes '
-          'do not conflict but merge is not requested'
-      ) do
         sign_in_as(member)
 
         base_version = create_post_version_for!(post_record.reload)
@@ -2357,91 +1919,6 @@ RSpec.describe 'Posts API', type: :request do
 
       expect(response).to have_http_status(:unprocessable_entity)
     end
-
-    it 'rejects second-bearing original created timestamps on POST /posts' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-          title: 'invalid original created from',
-          url: 'https://example.com/invalid-original-created-from',
-          tags: 'spec_tag',
-          thumbnail: dummy_upload,
-          original_created_from: '2020-01-01T00:00:01Z')
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'original_created_from' => ['オリジナルの作成日時は分単位で入力してください．']
-      )
-      expect(json.fetch('errors')).not_to have_key('original_created_at')
-    end
-
-    it 'rejects fractional-second original created timestamps on POST /posts' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-          title: 'invalid original created before',
-          url: 'https://example.com/invalid-original-created-before',
-          tags: 'spec_tag',
-          thumbnail: dummy_upload,
-          original_created_before: '2020-01-01T00:00:00.123Z')
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'original_created_before' => ['オリジナルの作成日時は分単位で入力してください．']
-      )
-      expect(json.fetch('errors')).not_to have_key('original_created_at')
-    end
-
-    it 'rejects non-increasing original created ranges on POST /posts' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-          title: 'non-increasing original created range',
-          url: 'https://example.com/non-increasing-original-created-range',
-          tags: 'spec_tag',
-          thumbnail: dummy_upload,
-          original_created_from: '2020-01-01T00:00Z',
-          original_created_before: '2020-01-01T00:00Z')
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'original_created_at' => ['オリジナルの作成日時の順番がをかしぃです．']
-      )
-    end
-
-    it 'accepts original created ranges that are exactly one minute on POST /posts' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-          title: 'valid original created range',
-          url: 'https://example.com/valid-original-created-range',
-          tags: 'spec_tag',
-          thumbnail: dummy_upload,
-          original_created_from: '2020-01-01T00:00Z',
-          original_created_before: '2020-01-01T00:01Z')
-
-      expect(response).to have_http_status(:created)
-      expect(Time.iso8601(json.fetch('original_created_from')))
-          .to eq(Time.utc(2020, 1, 1, 0, 0))
-      expect(Time.iso8601(json.fetch('original_created_before')))
-          .to eq(Time.utc(2020, 1, 1, 0, 1))
-    end
-
-    it 'rejects unparseable original created timestamps on PUT /posts/:id' do
-      sign_in_as(member)
-      base_version = create_post_version_for!(post_record)
-
-      put "/posts/#{post_record.id}", params: post_write_params(
-          base_version_no: base_version.version_no,
-          title: 'updated title',
-          tags: 'spec_tag',
-          original_created_from: 'not-a-time')
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'original_created_from' => ['オリジナルの作成日時の形式が不正です．']
-      )
-    end
   end
 
   describe 'tag versioning from post write actions' do

backend/spec/requests/preview_spec.rb

@@ -1,46 +1,28 @@
-require 'rails_helper'
+require "rails_helper"
 
 
-RSpec.describe 'Preview', type: :request do
+RSpec.describe "Preview", type: :request do
-  describe 'GET /preview/title' do
+  describe "GET /preview/title" do
-    it '401 unless logged in' do
+    it "401 unless logged in" do
       sign_out
-      get '/preview/title', params: { url: 'example.com' }
+      get "/preview/title", params: { url: "example.com" }
       expect(response).to have_http_status(:unauthorized)
     end
 
-    it '403 when logged in as guest' do
+    it "400 when url blank" do
-      sign_in_as(create(:user, :guest))
+      sign_in_as(create(:user))
-      get '/preview/title', params: { url: 'example.com' }
+      get "/preview/title", params: { url: "" }
-      expect(response).to have_http_status(:forbidden)
-    end
-
-    it '400 when url blank' do
-      sign_in_as(create(:user, :member))
-      get '/preview/title', params: { url: '' }
       expect(response).to have_http_status(:bad_request)
     end
 
-    it 'returns parsed title' do
+    it "returns parsed title (stubbing URI.open)" do
-      sign_in_as(create(:user, :member))
+      sign_in_as(create(:user))
-      allow(Preview::ThumbnailFetcher)
+      fake_html = "<html><head><title>  Hello  </title></head></html>"
-          .to receive(:title)
+      allow(URI).to receive(:open).and_return(StringIO.new(fake_html))
-          .with('example.com')
-          .and_return('Hello')
 
-      get '/preview/title', params: { url: 'example.com' }
+      get "/preview/title", params: { url: "example.com" }
       expect(response).to have_http_status(:ok)
-      expect(json['title']).to eq('Hello')
+      expect(json["title"]).to eq("Hello")
-    end
-
-    it '413 when fetched response is too large' do
-      sign_in_as(create(:user, :member))
-      allow(Preview::ThumbnailFetcher)
-          .to receive(:title)
-          .and_raise(Preview::HttpFetcher::ResponseTooLarge, '外部データが大きすぎます．')
-
-      get '/preview/title', params: { url: 'example.com' }
-      expect(response).to have_http_status(:payload_too_large)
     end
   end
 end

backend/spec/requests/tag_children_spec.rb

@@ -56,17 +56,6 @@ RSpec.describe "TagChildren", type: :request do
 
         expect(response).to have_http_status(:no_content)
       end
-
-      it 'returns 422 and does not create relation when the new link makes a cycle' do
-        TagImplication.create!(tag: parent, parent_tag: child)
-
-        expect {
-          do_request
-        }.not_to change(TagImplication, :count)
-
-        expect(response).to have_http_status(:unprocessable_entity)
-        expect(TagImplication.where(tag: child, parent_tag: parent)).not_to exist
-      end
     end
 
     context "when Tag.find raises (invalid ids)" do

backend/spec/requests/tags_spec.rb

@@ -581,58 +581,6 @@ RSpec.describe 'Tags API', type: :request do
         expect(response).to have_http_status(:ok)
         expect(wiki_page.reload.wiki_versions.count).to eq(before_wiki_version_count)
       end
-
-      it 'full update で旧名 alias が残った tag を PATCH で旧名へ戻せる' do
-        put "/tags/#{ tag.id }", params: {
-          name: 'patch_roundtrip_target',
-          category: 'general',
-          aliases: 'unko',
-          parent_tags: '',
-          deprecated: '0',
-        }
-
-        expect(response).to have_http_status(:ok)
-        expect(TagName.find_by!(name: 'spec_tag').canonical).to eq(tag.reload.tag_name)
-
-        patch "/tags/#{ tag.id }", params: { name: 'spec_tag' }
-
-        expect(response).to have_http_status(:ok)
-
-        tag.reload
-
-        expect(tag.name).to eq('spec_tag')
-        expect(tag.tag_name.canonical_id).to be_nil
-        expect(TagName.find_by!(name: 'patch_roundtrip_target').canonical).to eq(tag.tag_name)
-      end
-
-      it '別 tag の正規名には変更できない' do
-        wiki_page =
-            Wiki::Commit.create_content!(
-                tag_name: tag.tag_name,
-                body: 'patch collision wiki',
-                created_by_user: member_user,
-                message: 'init')
-
-        patch "/tags/#{ tag.id }", params: { name: 'unknown' }
-
-        expect(response).to have_http_status(:unprocessable_entity)
-        expect(json.fetch('errors')).to include(
-          'name' => ['その名前は既に使はれてゐます．']
-        )
-
-        expect(tag.reload.name).to eq('spec_tag')
-        expect(tag.tag_name.aliases.map(&:name)).to contain_exactly('unko')
-        expect(wiki_page.reload.tag_name).to eq(tag.tag_name)
-      end
-
-      it 'system tag の name は変更できない' do
-        system_tag = Tag.bot
-
-        patch "/tags/#{ system_tag.id }", params: { name: 'patch_system_tag_renamed' }
-
-        expect(response).to have_http_status(:unprocessable_entity)
-        expect(system_tag.reload.name).to eq('bot操作')
-      end
     end
   end
 
@@ -797,17 +745,7 @@ RSpec.describe 'Tags API', type: :request do
       )
       TagImplication.create!(tag: first, parent_tag: root_material)
       TagImplication.create!(tag: second, parent_tag: first)
-      now = Time.current
+      TagImplication.create!(tag: first, parent_tag: second)
-      TagImplication.insert_all!(
-        [
-          {
-            tag_id: first.id,
-            parent_tag_id: second.id,
-            created_at: now,
-            updated_at: now
-          }
-        ]
-      )
 
       get '/tags/with-depth', params: { parent: root_material.id }
 
@@ -1091,42 +1029,6 @@ RSpec.describe 'Tags API', type: :request do
         expect(versions.second.created_by_user_id).to eq(member_user.id)
       end
 
-      it '同じ tag の旧 alias へ戻しても rename できる' do
-        put "/tags/#{ tag.id }", params: {
-          name: 'put_roundtrip_b',
-          category: 'general',
-          aliases: 'unko',
-          parent_tags: '',
-          deprecated: '0',
-        }
-
-        expect(response).to have_http_status(:ok)
-
-        put "/tags/#{ tag.id }", params: {
-          name: 'spec_tag',
-          category: 'general',
-          aliases: 'unko',
-          parent_tags: '',
-          deprecated: '0',
-        }
-
-        expect(response).to have_http_status(:ok)
-
-        tag.reload
-
-        expect(tag.name).to eq('spec_tag')
-        expect(TagName.find_by!(name: 'put_roundtrip_b').canonical).to eq(tag.tag_name)
-        expect(tag.tag_name.aliases.map(&:name)).to contain_exactly('put_roundtrip_b', 'unko')
-        expect(tag.tag_name.aliases.map(&:name)).not_to include('spec_tag')
-        expect(alias_tn.reload.canonical).to eq(tag.tag_name)
-
-        version = tag.tag_versions.order(:version_no).last
-
-        expect(version.event_type).to eq('update')
-        expect(version.name).to eq('spec_tag')
-        expect(version.aliases.split).to contain_exactly('put_roundtrip_b', 'unko')
-      end
-
       it 'parent tag の snapshot も作成する' do
         old_parent = Tag.create!(
           tag_name: TagName.create!(name: 'put_snapshot_old_parent'),
@@ -1251,48 +1153,6 @@ RSpec.describe 'Tags API', type: :request do
         )
       end
 
-      it 'wiki を持つ tag を旧 alias へ戻しても wiki を新 canonical へ移す' do
-        wiki_page =
-            Wiki::Commit.create_content!(
-                tag_name: tag.tag_name,
-                body: 'wiki body before',
-                created_by_user: member_user,
-                message: 'init')
-
-        expect {
-          put "/tags/#{ tag.id }", params: {
-            name: 'put_wiki_roundtrip_b',
-            category: 'general',
-            aliases: 'unko',
-            parent_tags: '',
-            deprecated: '0',
-          }
-
-          put "/tags/#{ tag.id }", params: {
-            name: 'spec_tag',
-            category: 'general',
-            aliases: 'unko',
-            parent_tags: '',
-            deprecated: '0',
-          }
-        }
-            .to change(TagVersion, :count).by(3)
-            .and change(WikiVersion, :count).by(2)
-
-        expect(response).to have_http_status(:ok)
-
-        tag.reload
-
-        expect(wiki_page.reload.tag_name).to eq(tag.tag_name)
-        expect(TagName.find_by!(name: 'put_wiki_roundtrip_b').wiki_page).to be_nil
-        expect(TagName.find_by!(name: 'put_wiki_roundtrip_b').canonical).to eq(tag.tag_name)
-
-        versions = wiki_page.wiki_versions.order(:version_no).last(2)
-
-        expect(versions.map(&:event_type)).to eq(['update', 'update'])
-        expect(versions.map(&:title)).to eq(['put_wiki_roundtrip_b', 'spec_tag'])
-      end
-
       it '別名を他 tag から奪った場合、奪はれた側の tag version も作成する' do
         old_owner = Tag.create!(
           tag_name: TagName.create!(name: 'put_alias_old_owner'),
@@ -1331,49 +1191,9 @@ RSpec.describe 'Tags API', type: :request do
         expect(old_owner_versions.second.aliases.split).not_to include('put_stolen_alias')
       end
 
-      it '別 tag の alias 名を rename で奪へる' do
-        old_owner = Tag.create!(
-          tag_name: TagName.create!(name: 'put_alias_collision_owner'),
-          category: :general
-        )
-        stolen_alias = TagName.create!(
-          name: 'put_alias_collision_name',
-          canonical: old_owner.tag_name
-        )
-        wiki_page =
-            Wiki::Commit.create_content!(
-                tag_name: tag.tag_name,
-                body: 'put collision wiki',
-                created_by_user: member_user,
-                message: 'init')
-
-        put "/tags/#{ tag.id }", params: {
-          name: 'put_alias_collision_name',
-          category: 'general',
-          aliases: 'unko',
-          parent_tags: '',
-          deprecated: '0',
-        }
-
-        expect(response).to have_http_status(:ok)
-
-        tag.reload
-        old_owner.reload
-        stolen_alias.reload
-
-        expect(tag.name).to eq('put_alias_collision_name')
-        expect(stolen_alias.canonical_id).to be_nil
-        expect(TagName.find_by!(name: 'spec_tag').canonical).to eq(tag.tag_name)
-        expect(old_owner.tag_name.aliases.map(&:name)).not_to include('put_alias_collision_name')
-
-        old_owner_versions = old_owner.tag_versions.order(:version_no)
-
-        expect(old_owner_versions.last.event_type).to eq('update')
-        expect(old_owner_versions.last.aliases.split).not_to include('put_alias_collision_name')
-        expect(wiki_page.reload.tag_name).to eq(tag.tag_name)
-      end
-
       it 'parent_tags に指定すると循環する tag は 422 にする' do
+        pending '#332 で対応予定'
+
         child = Tag.create!(
           tag_name: TagName.create!(name: 'put_cycle_child'),
           category: :general

backend/spec/requests/user_settings_spec.rb

@@ -1,98 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe 'user settings', type: :request do
-  describe 'GET /users/settings' do
-    it 'requires a current user' do
-      sign_out
-
-      get '/users/settings'
-
-      expect(response).to have_http_status(:unauthorized)
-    end
-
-    it 'returns defaults and creates a missing settings row' do
-      user = create(:user)
-      sign_in_as(user)
-
-      expect {
-        get '/users/settings'
-      }.to change(Setting, :count).by(1)
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to eq(
-          'theme' => 'system',
-          'auto_fetch_title' => 'manual',
-          'auto_fetch_thumbnail' => 'manual',
-          'wiki_editor_mode' => 'split')
-      expect(user.reload.setting).to be_present
-    end
-  end
-
-  describe 'PATCH /users/settings' do
-    it 'requires a current user' do
-      sign_out
-
-      patch '/users/settings', params: { theme: 'dark' }, as: :json
-
-      expect(response).to have_http_status(:unauthorized)
-    end
-
-    it 'updates multiple typed settings at once' do
-      user = create(:user)
-      sign_in_as(user)
-
-      patch '/users/settings',
-            params: {
-              theme: 'dark',
-              auto_fetch_title: 'auto',
-              auto_fetch_thumbnail: 'off',
-              wiki_editor_mode: 'preview' },
-            as: :json
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include(
-          'theme' => 'dark',
-          'auto_fetch_title' => 'auto',
-          'auto_fetch_thumbnail' => 'off',
-          'wiki_editor_mode' => 'preview')
-      expect(user.reload.setting).to have_attributes(
-          theme: 'dark',
-          auto_fetch_title: 'auto',
-          auto_fetch_thumbnail: 'off',
-          wiki_editor_mode: 'preview')
-    end
-
-    it 'does not treat Rails parameter wrapping as an editable setting' do
-      user = create(:user)
-      sign_in_as(user)
-
-      patch '/users/settings',
-            params: { theme: 'light', user_setting: { theme: 'dark' } },
-            as: :json
-
-      expect(response).to have_http_status(:ok)
-      expect(user.reload.setting.theme).to eq('light')
-    end
-
-    it 'returns validation_error for type mismatches' do
-      sign_in_as(create(:user))
-
-      patch '/users/settings', params: { theme: 1 }, as: :json
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json).to include('type' => 'validation_error')
-      expect(json.fetch('errors')).to include(
-          'theme' => ['値の型が不正です．'])
-    end
-
-    it 'returns validation_error for invalid enum values' do
-      sign_in_as(create(:user))
-
-      patch '/users/settings', params: { theme: 'neon' }, as: :json
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json).to include('type' => 'validation_error')
-      expect(json.fetch('errors').fetch('theme')).to be_present
-    end
-  end
-end

backend/spec/requests/user_theme_slots_spec.rb

@@ -1,104 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe 'user theme slots', type: :request do
-  describe 'GET /users/theme_slots' do
-    it 'requires a current user' do
-      sign_out
-
-      get '/users/theme_slots'
-
-      expect(response).to have_http_status(:unauthorized)
-    end
-
-    it 'returns only the current user slots in stable order' do
-      user = create(:user)
-      other_user = create(:user)
-      sign_in_as(user)
-      UserThemeSlot.create!(user:, base_theme: 'light', slot_no: 2, tokens: { 'a' => 1 })
-      UserThemeSlot.create!(user:, base_theme: 'dark', slot_no: 1, tokens: { 'b' => 2 })
-      UserThemeSlot.create!(user: other_user,
-                            base_theme: 'dark',
-                            slot_no: 3,
-                            tokens: { 'c' => 3 })
-
-      get '/users/theme_slots'
-
-      expect(response).to have_http_status(:ok)
-      expect(json.map { |slot| [slot.fetch('base_theme'), slot.fetch('slot_no')] }).to eq(
-          [['dark', 1], ['light', 2]])
-      expect(json.map { |slot| slot.fetch('tokens') }).to eq(
-          [{ 'b' => 2 }, { 'a' => 1 }])
-    end
-  end
-
-  describe 'PUT /users/theme_slots/:base_theme/:slot_no' do
-    it 'requires a current user' do
-      sign_out
-
-      put '/users/theme_slots/light/1',
-          params: { tokens: { background: '0 0% 100%' } },
-          as: :json
-
-      expect(response).to have_http_status(:unauthorized)
-    end
-
-    it 'creates a theme slot' do
-      user = create(:user)
-      sign_in_as(user)
-
-      expect {
-        put '/users/theme_slots/light/1',
-            params: { tokens: { background: '0 0% 100%', tagColours: { nico: '#ffffff' } } },
-            as: :json
-      }.to change(UserThemeSlot, :count).by(1)
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include('base_theme' => 'light', 'slot_no' => 1)
-      expect(json.fetch('tokens')).to include(
-          'background' => '0 0% 100%',
-          'tagColours' => { 'nico' => '#ffffff' })
-      expect(user.theme_slots.find_by!(base_theme: 'light', slot_no: 1).tokens).to include(
-          'background' => '0 0% 100%')
-    end
-
-    it 'updates an existing theme slot instead of creating a duplicate' do
-      user = create(:user)
-      sign_in_as(user)
-      UserThemeSlot.create!(user:, base_theme: 'dark', slot_no: 2, tokens: { 'old' => true })
-
-      expect {
-        put '/users/theme_slots/dark/2',
-            params: { tokens: { background: '222.2 84% 4.9%' } },
-            as: :json
-      }.not_to change(UserThemeSlot, :count)
-
-      expect(response).to have_http_status(:ok)
-      expect(user.theme_slots.find_by!(base_theme: 'dark', slot_no: 2).tokens).to eq(
-          'background' => '222.2 84% 4.9%')
-    end
-
-    it 'rejects invalid path parameters and token shapes' do
-      sign_in_as(create(:user))
-
-      put '/users/theme_slots/system/4',
-          params: { tokens: 'not-object' },
-          as: :json
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-          'base_theme' => ['値が不正です．'])
-    end
-
-    it 'rejects non-object tokens for valid slots' do
-      sign_in_as(create(:user))
-
-      put '/users/theme_slots/light/1',
-          params: { tokens: 'not-object' },
-          as: :json
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-          'tokens' => ['JSON object で指定してください．'])
-    end
-  end
-end

backend/spec/services/post_bulk_creator_spec.rb

@@ -1,59 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe PostBulkCreator do
-  it 'limits workers to two and keeps failures in their request slots' do
-    actor = instance_double(User, id: 123)
-    allow(User).to receive(:find).with(123) {
-      instance_double(User, id: 123)
-    }
-    mutex = Mutex.new
-    active = 0
-    maximum_active = 0
-
-    allow(PostCreatePreflight).to receive(:new) do |attributes:, **|
-      preflight = instance_double(PostCreatePreflight)
-      allow(preflight).to receive(:run) do
-        mutex.synchronize do
-          active += 1
-          maximum_active = [maximum_active, active].max
-        end
-        sleep 0.02
-        mutex.synchronize { active -= 1 }
-        attributes.symbolize_keys.merge(
-            existing_post_id: nil,
-            field_warnings: { },
-            base_warnings: [])
-      end
-      preflight
-    end
-    allow(PostCreator).to receive(:new) do |attributes:, **|
-      creator = instance_double(PostCreator)
-      if attributes[:title] == 'broken'
-        allow(creator).to receive(:create!).and_raise(StandardError, 'broken')
-      else
-        post = instance_double(Post, id: attributes[:title].delete_prefix('post ').to_i)
-        allow(creator).to receive(:create!).and_return(post)
-      end
-      creator
-    end
-    posts = [
-        { 'title' => 'post 1', 'url' => 'https://example.com/1' },
-        { 'title' => 'broken', 'url' => 'https://example.com/2' },
-        { 'title' => 'post 3', 'url' => 'https://example.com/3' },
-        { 'title' => 'post 4', 'url' => 'https://example.com/4' }]
-
-    results = described_class.new(
-        actor:,
-        posts:,
-        thumbnails: { }).run.fetch(:results)
-
-    expect(maximum_active).to eq(2)
-    expect(results.length).to eq(posts.length)
-    expect(results.map { _1[:status] }).to eq(
-        ['created', 'failed', 'created', 'created'])
-    expect(results[0].dig(:post, :id)).to eq(1)
-    expect(results[1]).to include(status: 'failed', recoverable: false)
-    expect(results[2].dig(:post, :id)).to eq(3)
-    expect(results[3].dig(:post, :id)).to eq(4)
-  end
-end

backend/spec/services/post_create_plan_spec.rb

@@ -1,82 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe PostCreatePlan do
-  def create_tag! name, category
-    Tag.create!(name:, category:)
-  end
-
-  before do
-    create_tag!('タグ希望', :meta)
-    create_tag!('ニジラー情報不詳', :meta)
-  end
-
-  it 'plans direct and existing default tags without persisting records' do
-    counts = [TagName.count, Tag.count]
-
-    plan = described_class.new(
-        attributes: {
-            url: 'https://example.com/post',
-            title: 'title',
-            tags: 'character:new_character',
-            parent_post_ids: '' }).build!
-
-    expect(plan[:tags]).to eq('new_character')
-    expect(plan[:direct_tag_specs]).to eq(
-        [{ name: 'new_character', category: :character }])
-    expect(plan[:default_tag_specs]).to include(
-        { name: 'タグ希望', category: :meta },
-        { name: 'ニジラー情報不詳', category: :meta })
-    expect([TagName.count, Tag.count]).to eq(counts)
-  end
-
-  it 'resolves aliases and keeps tag sections separate from canonical names' do
-    canonical = create_tag!('虹夏', :character)
-    TagName.create!(name: 'にじか', canonical: canonical.tag_name)
-    create_tag!('動画', :meta)
-
-    plan = described_class.new(
-        attributes: {
-            url: 'https://example.com/video',
-            title: 'video',
-            tags: '動画 にじか[0:10-0:20]',
-            duration: '1:00',
-            parent_post_ids: '' }).build!
-
-    expect(plan[:tags].split).to include('動画', '虹夏[0:10-0:20]')
-    expect(plan[:display_tags]).to include(
-        { name: '虹夏',
-          category: 'character',
-          section_literals: ['[0:10-0:20]'] })
-    expect(plan[:video_ms]).to eq(60_000)
-  end
-
-  it 'validates a new tag name without persisting it' do
-    long_name = 'a' * 256
-    counts = [TagName.count, Tag.count]
-
-    expect {
-      described_class.new(
-          attributes: {
-              url: 'https://example.com/post',
-              title: 'title',
-              tags: long_name,
-              parent_post_ids: '' }).build!
-    }.to raise_error(ActiveRecord::RecordInvalid) { |error|
-      expect(error.record.errors[:tags]).not_to be_empty
-    }
-    expect([TagName.count, Tag.count]).to eq(counts)
-  end
-
-  it 'ignores duration when the planned tags do not include video' do
-    plan = described_class.new(
-        attributes: {
-            url: 'https://example.com/post',
-            title: 'title',
-            tags: 'ordinary_tag',
-            duration: 'invalid',
-            parent_post_ids: '' }).build!
-
-    expect(plan[:duration]).to eq('invalid')
-    expect(plan[:video_ms]).to be_nil
-  end
-end

backend/spec/services/post_creator_spec.rb

@@ -1,78 +0,0 @@
-require 'rails_helper'
-require 'base64'
-
-RSpec.describe PostCreator do
-  let(:actor) { create(:user, :member) }
-
-  def real_thumbnail_upload
-    gif = Base64.decode64('R0lGODdhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=')
-
-    Rack::Test::UploadedFile.new(
-        StringIO.new(gif),
-        'image/gif',
-        original_filename: 'thumbnail.gif')
-  end
-
-  before do
-    allow(Tag).to receive(:normalise_tags!).and_return({ tags: [], sections: {} })
-    allow(TagVersioning).to receive(:record_tag_snapshots!)
-    allow(Tag).to receive(:expand_parent_tags).and_return([])
-    allow(PostVersionRecorder).to receive(:record!)
-  end
-
-  it 'prefers thumbnail_base over an explicit upload' do
-    expect(Post).not_to receive(:resized_thumbnail_attachment)
-    allow(Post).to receive(:remote_thumbnail_attachment).and_return(
-        io: StringIO.new('remote'),
-        filename: 'resized_thumbnail.jpg',
-        content_type: 'image/jpeg')
-
-    post = described_class.new(
-        actor:,
-        attributes: {
-          title: 'title',
-          url: 'https://example.com/post',
-          thumbnail: real_thumbnail_upload,
-          thumbnail_base: 'https://example.com/thumb.jpg',
-          tags: '' }).create!
-
-    expect(post.thumbnail).to be_attached
-    expect(post.thumbnail_base).to eq('https://example.com/thumb.jpg')
-  end
-
-  it 'uses the common remote thumbnail attach path when thumbnail_base is given' do
-    expect(Post).to receive(:remote_thumbnail_attachment)
-        .with('https://example.com/thumb.jpg')
-        .and_return(
-            io: StringIO.new('thumbnail'),
-            filename: 'thumbnail.jpg',
-            content_type: 'image/jpeg')
-
-    post = described_class.new(
-        actor:,
-        attributes: {
-          title: 'title',
-          url: 'https://example.com/post',
-          thumbnail_base: 'https://example.com/thumb.jpg',
-          tags: '' }).create!
-
-    expect(post.thumbnail_base).to eq('https://example.com/thumb.jpg')
-    expect(post.thumbnail).to be_attached
-  end
-
-  it 'does not create a post when remote thumbnail fetch fails' do
-    allow(Post).to receive(:remote_thumbnail_attachment)
-        .and_raise(Post::RemoteThumbnailFetchFailed, 'サムネール画像を取得できませんでした．')
-    creator = described_class.new(
-        actor:,
-        attributes: {
-          title: 'title',
-          url: 'https://example.com/post',
-          thumbnail_base: 'https://example.com/thumb.jpg',
-          tags: '' })
-
-    post_count = Post.count
-    expect { creator.create! }.to raise_error(Post::RemoteThumbnailFetchFailed)
-    expect(Post.count).to eq(post_count)
-  end
-end

backend/spec/services/post_import_previewer_spec.rb

@@ -1,187 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe PostImportPreviewer do
-  before do
-    allow(Preview::UrlSafety).to receive(:validate) do |url|
-      [URI.parse(url), ['8.8.8.8']]
-    end
-  end
-
-  def row(source_row:, url:, attributes: { }, provenance: { }, **values)
-    {
-      source_row:,
-      url:,
-      attributes:,
-      provenance:
-    }.merge(values)
-  end
-
-  describe '#preview_rows' do
-    it 'marks an existing post for skipping without fetching metadata' do
-      existing = create(:post, url: 'https://example.com/existing')
-      expect(PostMetadataFetcher).not_to receive(:fetch)
-
-      result = described_class.new.preview_rows(rows: [
-        row(source_row: 1, url: 'https://EXAMPLE.com/existing/')
-      ]).first
-
-      expect(result).to include(
-        url: 'https://example.com/existing',
-        skip_reason: 'existing',
-        existing_post_id: existing.id,
-        validation_errors: {}
-      )
-      expect(result.fetch(:field_warnings)).to eq({})
-    end
-
-    it 'reports list duplicates as URL errors instead of existing skips' do
-      create(:post, url: 'https://example.com/duplicate')
-      expect(PostMetadataFetcher).not_to receive(:fetch)
-
-      results = described_class.new.preview_rows(rows: [
-        row(source_row: 1, url: 'https://example.com/duplicate'),
-        row(source_row: 2, url: 'https://EXAMPLE.com/duplicate/')
-      ])
-
-      expect(results.map { _1[:validation_errors] }).to all(
-        include(url: ['URL が重複しています．'])
-      )
-      expect(results).to all(include(skip_reason: nil, existing_post_id: nil))
-    end
-
-    it 'does not fetch metadata for an unsafe URL' do
-      allow(Preview::UrlSafety).to receive(:validate)
-          .and_raise(Preview::UrlSafety::UnsafeUrl, '安全でない接続先は使用できません．')
-      expect(PostMetadataFetcher).not_to receive(:fetch)
-
-      result = described_class.new.preview_rows(rows: [
-        row(source_row: 1, url: 'https://unsafe.example/post')
-      ]).first
-
-      expect(result.fetch(:validation_errors)).to include(
-        url: ['安全でない接続先は使用できません．']
-      )
-    end
-
-    it 'applies metadata to automatic fields and recognises metadata tags' do
-      Tag.create!(name: 'known-tag', category: :general)
-      allow(PostMetadataFetcher).to receive(:fetch).and_return(
-        title: 'metadata title',
-        thumbnail_base: 'https://example.com/thumb.jpg',
-        duration: '2',
-        tags: 'known-tag'
-      )
-
-      result = described_class.new.preview_rows(rows: [
-        row(source_row: 1, url: 'https://example.com/new')
-      ]).first
-
-      expect(result.fetch(:attributes)).to include(
-        'title' => 'metadata title',
-        'thumbnail_base' => 'https://example.com/thumb.jpg',
-        'duration' => '2',
-        'tags' => 'known-tag'
-      )
-      expect(result.fetch(:field_warnings)).not_to have_key('tags')
-      expect(PostMetadataFetcher).to have_received(:fetch).once
-    end
-
-    it 'preserves manual empty values when metadata is available' do
-      allow(PostMetadataFetcher).to receive(:fetch).and_return(
-        title: 'metadata title',
-        tags: 'metadata-tag'
-      )
-
-      result = described_class.new.preview_rows(rows: [
-        row(
-          source_row: 1,
-          url: 'https://example.com/manual',
-          attributes: { title: '', tags: '' },
-          provenance: { title: 'manual', tags: 'manual' },
-          tag_sources: { automatic: 'old-tag', manual: '' }
-        )
-      ]).first
-
-      expect(result.fetch(:attributes)).to include('title' => '', 'tags' => '')
-      expect(result.fetch(:tag_sources)).to include('manual' => '')
-    end
-
-    it 'clears warnings derived from an old metadata URL' do
-      allow(PostMetadataFetcher).to receive(:fetch).and_return(
-        title: 'new title',
-        thumbnail_base: 'https://example.com/new-thumb.jpg',
-        tags: ''
-      )
-
-      result = described_class.new.preview_rows(rows: [
-        row(
-          source_row: 1,
-          url: 'https://example.com/new-url',
-          attributes: { title: 'old title', tags: 'old-tag' },
-          provenance: { title: 'automatic', tags: 'automatic' },
-          tag_sources: { automatic: 'old-tag', manual: '' },
-          metadata_url: 'https://example.com/old-url',
-          field_warnings: { tags: ['old tag warning'], url: ['old fetch warning'] },
-          base_warnings: ['old base warning']
-        )
-      ]).first
-
-      expect(result.fetch(:attributes)).to include('title' => 'new title', 'tags' => '')
-      expect(result.fetch(:base_warnings)).to eq([])
-      expect(result.fetch(:field_warnings).values.flatten)
-          .not_to include('old tag warning', 'old fetch warning')
-    end
-
-    it 'isolates an unexpected metadata failure to the affected URL' do
-      allow(PostMetadataFetcher).to receive(:fetch) do |url|
-        raise 'fetch failure' if url.include?('failure')
-
-        { title: 'successful title', tags: '' }
-      end
-      allow(Rails.logger).to receive(:error)
-
-      results = described_class.new.preview_rows(rows: [
-        row(source_row: 1, url: 'https://example.com/failure'),
-        row(source_row: 2, url: 'https://example.com/success')
-      ])
-
-      expect(results[0].fetch(:field_warnings)).to include(
-        'url' => [described_class::METADATA_FETCH_WARNING]
-      )
-      expect(results[1].fetch(:attributes)).to include('title' => 'successful title')
-    end
-
-    it 'turns an unsafe URL detected during metadata fetching into a URL error' do
-      allow(PostMetadataFetcher).to receive(:fetch)
-          .and_raise(Preview::UrlSafety::UnsafeUrl, '安全でない接続先です．')
-      allow(Rails.logger).to receive(:info)
-
-      result = described_class.new.preview_rows(rows: [
-        row(source_row: 1, url: 'https://example.com/redirects-to-private')
-      ]).first
-
-      expect(result.fetch(:validation_errors)).to include(
-        url: ['安全でない接続先です．']
-      )
-    end
-
-    it 'validates parent IDs from the preloaded set' do
-      parent = create(:post)
-
-      results = described_class.new.preview_rows(
-        rows: [
-          row(source_row: 1, url: 'https://example.com/valid-parent',
-              attributes: { parent_post_ids: parent.id.to_s }),
-          row(source_row: 2, url: 'https://example.com/missing-parent',
-              attributes: { parent_post_ids: '999999' })
-        ],
-        fetch_metadata: false
-      )
-
-      expect(results[0].fetch(:validation_errors)).not_to have_key(:parent_post_ids)
-      expect(results[1].fetch(:validation_errors)).to include(
-        parent_post_ids: ['存在しない親投稿 Id. があります．']
-      )
-    end
-  end
-end

backend/spec/services/post_metadata_fetcher_spec.rb

@@ -1,123 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe PostMetadataFetcher do
-  Response = Struct.new(:body)
-
-  def fetch_with_published_time(value, url: 'https://example.com/video')
-    html = <<~HTML
-      <html><head>
-        <meta property="article:published_time" content="#{ value }">
-      </head></html>
-    HTML
-    uri = URI.parse(url)
-    allow(Preview::UrlSafety).to receive(:validate).with(url).and_return([uri, ['8.8.8.8']])
-    allow(Preview::HttpFetcher).to receive(:fetch).and_return(Response.new(html))
-    allow(Preview::HtmlMetadataExtractor).to receive(:extract)
-        .and_return(title: 'title', image_url: nil)
-
-    described_class.fetch(url)
-  end
-
-  it 'builds ranges explicitly for year, month, and day precision' do
-    year = fetch_with_published_time('2024')
-    month = fetch_with_published_time('2024-02')
-    day = fetch_with_published_time('2024-02-03')
-
-    expect(year).to include(
-      original_created_from: Time.zone.local(2024, 1, 1).iso8601,
-      original_created_before: Time.zone.local(2025, 1, 1).iso8601
-    )
-    expect(month).to include(
-      original_created_from: Time.zone.local(2024, 2, 1).iso8601,
-      original_created_before: Time.zone.local(2024, 3, 1).iso8601
-    )
-    expect(day).to include(
-      original_created_from: Time.zone.local(2024, 2, 3).iso8601,
-      original_created_before: Time.zone.local(2024, 2, 4).iso8601
-    )
-  end
-
-  it 'rounds second and fractional-second timestamps down to one-minute ranges' do
-    result = fetch_with_published_time('2024-02-03T12:34:56.123+02:30')
-
-    expect(Time.iso8601(result.fetch(:original_created_from)))
-        .to eq(Time.iso8601('2024-02-03T12:34:00+02:30'))
-    expect(
-      Time.iso8601(result.fetch(:original_created_before)) -
-      Time.iso8601(result.fetch(:original_created_from))
-    ).to eq(60)
-    expect(result.fetch(:original_created_from)).not_to include('.')
-  end
-
-  it 'treats hour-precision timestamps as one-hour ranges with and without offsets' do
-    offset_result = fetch_with_published_time('2024-02-03T12+02:30')
-    local_result = fetch_with_published_time('2024-02-03T12')
-
-    expect(Time.iso8601(offset_result.fetch(:original_created_from)))
-        .to eq(Time.iso8601('2024-02-03T12:00:00+02:30'))
-    expect(
-      Time.iso8601(offset_result.fetch(:original_created_before)) -
-      Time.iso8601(offset_result.fetch(:original_created_from))
-    ).to eq(3600)
-    expect(local_result.fetch(:original_created_from)).to eq('2024-02-03T12:00:00Z')
-    expect(local_result.fetch(:original_created_before)).to eq('2024-02-03T13:00:00Z')
-  end
-
-  it 'adds platform tags for known video URLs' do
-    result = fetch_with_published_time('2024', url: 'https://youtu.be/abc123')
-
-    expect(result.fetch(:tags)).to eq('動画 YouTube')
-  end
-
-  it 'returns nil dates for an invalid timestamp' do
-    result = fetch_with_published_time('not-a-time')
-
-    expect(result.fetch(:original_created_from)).to be_nil
-    expect(result.fetch(:original_created_before)).to be_nil
-  end
-
-  it 'returns nil dates for an invalid timestamp second value' do
-    result = fetch_with_published_time('2024-02-03T12:34:99Z')
-
-    expect(result.fetch(:original_created_from)).to be_nil
-    expect(result.fetch(:original_created_before)).to be_nil
-  end
-
-  it 'returns nil dates for invalid calendar dates and invalid hour values' do
-    invalid_day = fetch_with_published_time('2024-02-31T12:00Z')
-    invalid_leap = fetch_with_published_time('2023-02-29T12:00Z')
-    invalid_hour = fetch_with_published_time('2024-02-29T24:00Z')
-
-    [invalid_day, invalid_leap, invalid_hour].each do |result|
-      expect(result.fetch(:original_created_from)).to be_nil
-      expect(result.fetch(:original_created_before)).to be_nil
-    end
-  end
-
-  it 'accepts a valid leap-day timestamp at minute precision' do
-    result = fetch_with_published_time('2024-02-29T12:34Z')
-
-    expect(result.fetch(:original_created_from)).to eq('2024-02-29T12:34:00Z')
-    expect(result.fetch(:original_created_before)).to eq('2024-02-29T12:35:00Z')
-  end
-
-  it 'serialises metadata duration as the same seconds string contract used by forms' do
-    html = <<~HTML
-      <html><head>
-        <meta property="article:published_time" content="2024-02-03T12:34:56.123+02:30">
-        <meta property="og:video:duration" content="2.5">
-      </head></html>
-    HTML
-    uri = URI.parse('https://example.com/video')
-    allow(Preview::UrlSafety).to receive(:validate)
-        .with('https://example.com/video')
-        .and_return([uri, ['8.8.8.8']])
-    allow(Preview::HttpFetcher).to receive(:fetch).and_return(Response.new(html))
-    allow(Preview::HtmlMetadataExtractor).to receive(:extract)
-        .and_return(title: 'title', image_url: nil)
-
-    result = described_class.fetch('https://example.com/video')
-
-    expect(result.fetch(:duration)).to eq('2.5')
-  end
-end

backend/spec/services/post_thumbnail_upload_validator_spec.rb

@@ -1,52 +0,0 @@
-require 'rails_helper'
-require 'base64'
-require 'tempfile'
-
-RSpec.describe PostThumbnailUploadValidator do
-  def with_upload bytes, content_type:, filename:
-    tempfile = Tempfile.new(['thumbnail-upload', File.extname(filename)])
-    tempfile.binmode
-    tempfile.write(bytes)
-    tempfile.rewind
-    upload = ActionDispatch::Http::UploadedFile.new(
-        tempfile:,
-        filename:,
-        type: content_type)
-    yield upload
-  ensure
-    tempfile&.close!
-  end
-
-  it 'accepts a raster upload after decoding and rewinds it' do
-    gif = Base64.decode64('R0lGODdhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=')
-
-    with_upload(gif, content_type: 'image/gif', filename: 'thumbnail.gif') do |upload|
-      expect { described_class.validate!(upload) }.not_to raise_error
-      expect(upload.read(6)).to eq('GIF87a')
-    end
-  end
-
-  it 'rejects SVG content disguised as a raster MIME type' do
-    with_upload(
-        '<svg width="10" height="10"></svg>',
-        content_type: 'image/png',
-        filename: 'thumbnail.png') do |upload|
-      expect { described_class.validate!(upload) }
-          .to raise_error(
-              described_class::InvalidUpload,
-              'サムネイル画像の形式が不正です．')
-    end
-  end
-
-  it 'rejects non-raster content disguised as an image' do
-    with_upload(
-        '%PDF-1.7',
-        content_type: 'image/png',
-        filename: 'thumbnail.png') do |upload|
-      expect { described_class.validate!(upload) }
-          .to raise_error(
-              described_class::InvalidUpload,
-              'サムネイル画像の形式が不正です．')
-    end
-  end
-end

backend/spec/services/post_url_normaliser_spec.rb

@@ -1,27 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe PostUrlNormaliser do
-  before do
-    PostUrlSanitisationRule.unscoped.delete_all
-  end
-
-  describe '.normalise' do
-    it 'normalises the host and trailing slash before applying sanitisation rules' do
-      PostUrlSanitisationRule.create!(
-        priority: 10,
-        source_pattern: '\\Ahttps://example\\.com/source\\z',
-        replacement: 'https://example.com/canonical'
-      )
-
-      result = described_class.normalise('  https://EXAMPLE.com/source/  ')
-
-      expect(result).to eq('https://example.com/canonical')
-    end
-
-    it 'returns nil for unsupported or malformed URLs' do
-      expect(described_class.normalise('ftp://example.com/file')).to be_nil
-      expect(described_class.normalise('https://[')).to be_nil
-      expect(described_class.normalise('https:/path')).to be_nil
-    end
-  end
-end

backend/spec/services/preview/http_fetcher_spec.rb

@@ -1,23 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Preview::HttpFetcher do
-  describe '.fetch' do
-    it 'raises FetchFailed when redirect location is invalid' do
-      redirect = Net::HTTPFound.new('1.1', '302', 'Found')
-      redirect['location'] = 'http://[invalid'
-
-      allow(Preview::UrlSafety).to receive(:validate)
-          .with('https://example.com/page')
-          .and_return([URI.parse('https://example.com/page'), ['203.0.113.10']])
-      allow(described_class).to receive(:request)
-          .and_return(redirect)
-      allow(Rails.logger).to receive(:warn)
-
-      expect {
-        described_class.fetch('https://example.com/page')
-      }.to raise_error(Preview::HttpFetcher::FetchFailed)
-      expect(Rails.logger).to have_received(:warn)
-          .with(/invalid_redirect_location/)
-    end
-  end
-end

backend/spec/services/preview/thumbnail_fetcher_spec.rb

@@ -1,104 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Preview::ThumbnailFetcher do
-  describe '.fetch' do
-    it 'accepts svg thumbnails for the common safe rasterisation path' do
-      page = Preview::HttpFetcher::Response.new(
-          '<meta property="og:image" content="https://example.com/thumb.svg">',
-          'text/html',
-          'https://example.com/page')
-      svg = Preview::HttpFetcher::Response.new(
-          '<svg></svg>',
-          'image/svg+xml',
-          'https://example.com/thumb.svg')
-
-      allow(Preview::UrlSafety).to receive(:validate) do |url|
-        [URI.parse(url), ['203.0.113.10']]
-      end
-      allow(Preview::HttpFetcher).to receive(:fetch)
-          .with('https://example.com/page', max_bytes: described_class::HTML_MAX_BYTES)
-          .and_return(page)
-      allow(Preview::HttpFetcher).to receive(:fetch)
-          .with('https://example.com/thumb.svg')
-          .and_return(svg)
-
-      expect(described_class.fetch('https://example.com/page')).to eq('<svg></svg>')
-    end
-
-    it 'accepts allowed image content type with parameters' do
-      page = Preview::HttpFetcher::Response.new(
-          '<meta property="og:image" content="https://example.com/thumb.jpg">',
-          'text/html',
-          'https://example.com/page')
-      image = Preview::HttpFetcher::Response.new(
-          "\xFF\xD8\xFFjpeg-bytes".b,
-          'image/jpeg; charset=binary',
-          'https://example.com/thumb.jpg')
-
-      allow(Preview::UrlSafety).to receive(:validate) do |url|
-        [URI.parse(url), ['203.0.113.10']]
-      end
-      allow(Preview::HttpFetcher).to receive(:fetch)
-          .with('https://example.com/page', max_bytes: described_class::HTML_MAX_BYTES)
-          .and_return(page)
-      allow(Preview::HttpFetcher).to receive(:fetch)
-          .with('https://example.com/thumb.jpg')
-          .and_return(image)
-
-      expect(described_class.fetch('https://example.com/page'))
-          .to eq("\xFF\xD8\xFFjpeg-bytes".b)
-    end
-  end
-
-  describe '.fetch_image_response' do
-    it 'rejects an unsafe input URL before HTTP fetch' do
-      allow(Preview::UrlSafety).to receive(:validate)
-          .and_raise(Preview::UrlSafety::UnsafeUrl, '安全でない接続先は使用できません．')
-      expect(Preview::HttpFetcher).not_to receive(:fetch)
-
-      expect {
-        described_class.fetch_image_response('https://unsafe.example.com/thumb.jpg')
-      }.to raise_error(Preview::UrlSafety::UnsafeUrl, '安全でない接続先は使用できません．')
-    end
-
-    it 'rejects an unsafe redirect target' do
-      allow(Preview::UrlSafety).to receive(:validate)
-          .and_return([URI.parse('https://example.com/thumb.jpg'), ['8.8.8.8']])
-      allow(Preview::HttpFetcher).to receive(:fetch)
-          .with('https://example.com/thumb.jpg')
-          .and_raise(Preview::UrlSafety::UnsafeUrl, '安全でない接続先は使用できません．')
-
-      expect {
-        described_class.fetch_image_response('https://example.com/thumb.jpg')
-      }.to raise_error(Preview::UrlSafety::UnsafeUrl, '安全でない接続先は使用できません．')
-    end
-
-    it 'rejects an oversized image response' do
-      allow(Preview::UrlSafety).to receive(:validate)
-          .and_return([URI.parse('https://example.com/thumb.jpg'), ['8.8.8.8']])
-      allow(Preview::HttpFetcher).to receive(:fetch)
-          .with('https://example.com/thumb.jpg')
-          .and_raise(Preview::HttpFetcher::ResponseTooLarge, 'too large')
-
-      expect {
-        described_class.fetch_image_response('https://example.com/thumb.jpg')
-      }.to raise_error(Preview::HttpFetcher::ResponseTooLarge)
-    end
-
-    it 'rejects a non-image content type' do
-      allow(Preview::UrlSafety).to receive(:validate)
-          .and_return([URI.parse('https://example.com/thumb.jpg'), ['8.8.8.8']])
-      allow(Preview::HttpFetcher).to receive(:fetch)
-          .with('https://example.com/thumb.jpg')
-          .and_return(
-              Preview::HttpFetcher::Response.new(
-                  '<html></html>',
-                  'text/html',
-                  'https://example.com/thumb.jpg'))
-
-      expect {
-        described_class.fetch_image_response('https://example.com/thumb.jpg')
-      }.to raise_error(Preview::ThumbnailFetcher::GenerationFailed)
-    end
-  end
-end

backend/spec/services/preview/url_safety_spec.rb

@@ -1,15 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Preview::UrlSafety do
-  describe '.validate' do
-    it 'raises UnsafeUrl when DNS resolution fails' do
-      allow(Resolv).to receive(:getaddresses)
-          .with('missing.example')
-          .and_raise(Resolv::ResolvError)
-
-      expect {
-        described_class.validate('https://missing.example')
-      }.to raise_error(Preview::UrlSafety::UnsafeUrl)
-    end
-  end
-end

backend/spec/services/youtube/sync_spec.rb

@@ -10,37 +10,6 @@ RSpec.describe Youtube::Sync do
     allow(sync).to receive(:attach_thumbnail_if_needed!)
   end
 
-  describe '#attach_thumbnail_if_needed!' do
-    it 'uses the common remote thumbnail attach path' do
-      post = create(:post, thumbnail_base: nil)
-      allow(sync).to receive(:attach_thumbnail_if_needed!).and_call_original
-
-      expect(post).to receive(:attach_thumbnail_from_url!)
-          .with('https://example.com/thumb.jpg')
-
-      sync.send(
-          :attach_thumbnail_if_needed!,
-          post,
-          'https://example.com/thumb.jpg')
-    end
-
-    it 'retries on a later sync when the previous remote attach failed' do
-      post = create(:post, thumbnail_base: nil)
-      allow(sync).to receive(:attach_thumbnail_if_needed!).and_call_original
-      expect(post).to receive(:attach_thumbnail_from_url!)
-          .with('https://example.com/thumb.jpg')
-          .twice
-          .and_raise(Post::RemoteThumbnailFetchFailed, 'failed')
-
-      2.times do
-        sync.send(
-            :attach_thumbnail_if_needed!,
-            post,
-            'https://example.com/thumb.jpg')
-      end
-    end
-  end
-
   describe '#sync!' do
     it 'returns without fetching video details when no video ids are discovered' do
       allow(sync).to receive(:query_terms).and_return([])
@@ -107,7 +76,7 @@ RSpec.describe Youtube::Sync do
       sync.sync!
     end
 
-    it 'creates a YouTube post with default tags when no deerjikist mapping exists' do
+    it 'creates a YouTube post with default tags and no_deerjikist when no deerjikist mapping exists' do
       Tag.tagme
       Tag.bot
       Tag.youtube

backend/spec/tasks/nico_export_spec.rb

@@ -62,7 +62,7 @@ RSpec.describe 'nico:export' do
 
     it 'deduplicates video ids' do
       create_post('https://www.nicovideo.jp/watch/sm12345')
-      create_post('https://sp.nicovideo.jp/watch/sm12345')
+      create_post('https://www.nicovideo.jp/watch/sm12345?from=1')
 
       expect(Open3).to receive(:capture3) do |_env, *args, **_kwargs|
         expect(args.drop(3)).to eq(['sm12345'])

backend/spec/tasks/nico_sync_spec.rb

@@ -1,10 +1,10 @@
-require 'rails_helper'
+require "rails_helper"
 
 
-RSpec.describe 'nico:sync' do
+RSpec.describe "nico:sync" do
   def stub_python(json_array)
     status = instance_double(Process::Status, success?: true)
-    allow(Open3).to receive(:capture3).and_return([json_array.to_json, '', status])
+    allow(Open3).to receive(:capture3).and_return([json_array.to_json, "", status])
   end
 
   def create_tag!(name, category:)
@@ -16,21 +16,17 @@ RSpec.describe 'nico:sync' do
     NicoTagRelation.create!(nico_tag_id: nico_tag.id, tag_id: tag.id)
   end
 
-  it '既存 post を見つけて、nico tag と linked tag を追加し、差分が出たら bot を付ける' do
+  it "既存 post を見つけて、nico tag と linked tag を追加し、差分が出たら bot を付ける" do
     # 既存 post（正規表現で拾われるURL）
-    post = Post.create!(
+    post = Post.create!(title: "old", url: "https://www.nicovideo.jp/watch/sm9", uploaded_user: nil)
-      title: 'old',
-      url: 'https://www.nicovideo.jp/watch/sm9',
-      uploaded_user: nil
-    )
 
     # 既存の非nicoタグ（kept_non_nico_ids）
-    kept_general = create_tag!('spec_kept', category: 'general')
+    kept_general = create_tag!("spec_kept", category: "general")
     PostTag.create!(post: post, tag: kept_general)
 
     # 追加される linked tag を準備（nico tag に紐付く一般タグ）
-    linked = create_tag!('spec_linked', category: 'general')
+    linked = create_tag!("spec_linked", category: "general")
-    nico = create_tag!('nico:AAA', category: 'nico')
+    nico = create_tag!("nico:AAA", category: "nico")
     link_nico_to_tag!(nico, linked)
 
     # bot / tagme は task 内で使うので作っておく（Tag.bot/tagme がある前提）
@@ -46,91 +42,43 @@ RSpec.describe 'nico:sync' do
         'deleted_at' => '2026-01-31 00:00:00' }])
 
     # 外部HTTPは今回「既存 post なので呼ばれない」はずだが、念のため塞ぐ
-    allow(URI).to receive(:open).and_return(StringIO.new('<html></html>'))
+    allow(URI).to receive(:open).and_return(StringIO.new("<html></html>"))
 
-    run_rake_task('nico:sync')
+    run_rake_task("nico:sync")
 
     post.reload
-    active_tag_names = post.tags.joins(:tag_name).pluck('tag_names.name')
+    active_tag_names = post.tags.joins(:tag_name).pluck("tag_names.name")
 
-    expect(active_tag_names).to include('spec_kept')
+    expect(active_tag_names).to include("spec_kept")
-    expect(active_tag_names).to include('nico:AAA')
+    expect(active_tag_names).to include("nico:AAA")
-    expect(active_tag_names).to include('spec_linked')
+    expect(active_tag_names).to include("spec_linked")
 
     expect(post.original_created_from).to eq(Time.iso8601('2026-01-01T03:34:00Z'))
     expect(post.original_created_before).to eq(Time.iso8601('2026-01-01T03:35:00Z'))
 
     # 差分が出るので bot が付く（kept_non_nico_ids != desired_non_nico_ids）
-    expect(active_tag_names).to include('bot操作')
+    expect(active_tag_names).to include("bot操作")
   end
 
-  it '既存 post のサムネール取得に共通 attach 経路を使ふ' do
+  it "既存 post にあった古い nico tag は active から外され、履歴として discard される" do
-    post = Post.create!(
+    post = Post.create!(title: "old", url: "https://www.nicovideo.jp/watch/sm9", uploaded_user: nil)
-        title: 'old',
-        url: 'https://www.nicovideo.jp/watch/sm9',
-        uploaded_user: nil)
-    Tag.bot
-    Tag.tagme
-
-    stub_python([{ 'code' => 'sm9', 'title' => 't', 'tags' => [] }])
-    allow(URI).to receive(:open) do
-      StringIO.new(
-          '<meta name="thumbnail" content="https://example.com/thumb.jpg">')
-    end
-    expect_any_instance_of(Post).to receive(:attach_thumbnail_from_url!)
-        .with('https://example.com/thumb.jpg')
-
-    run_rake_task('nico:sync')
-  end
-
-  it 'サムネール取得失敗後も次回同期で再試行できる' do
-    post = Post.create!(
-        title: 'old',
-        url: 'https://www.nicovideo.jp/watch/sm9',
-        uploaded_user: nil)
-    Tag.bot
-    Tag.tagme
-
-    stub_python([{ 'code' => 'sm9', 'title' => 't', 'tags' => [] }])
-    allow(URI).to receive(:open) do
-      StringIO.new(
-          '<meta name="thumbnail" content="https://example.com/thumb.jpg">')
-    end
-    calls = 0
-    allow_any_instance_of(Post).to receive(:attach_thumbnail_from_url!) do
-      calls += 1
-      raise Post::RemoteThumbnailFetchFailed, 'failed'
-    end
-
-    2.times do
-      run_rake_task('nico:sync')
-    end
-    expect(calls).to eq(2)
-  end
-
-  it '既存 post にあった古い nico tag は active から外され、履歴として discard される' do
-    post = Post.create!(
-      title: 'old',
-      url: 'https://www.nicovideo.jp/watch/sm9',
-      uploaded_user: nil
-    )
 
     # 旧nicoタグ（今回の同期結果に含まれない）
-    old_nico = create_tag!('nico:OLD', category: 'nico')
+    old_nico = create_tag!("nico:OLD", category: "nico")
     old_pt = PostTag.create!(post: post, tag: old_nico)
     expect(old_pt.discarded_at).to be_nil
 
     # 今回は NEW のみ欲しい
-    new_nico = create_tag!('nico:NEW', category: 'nico')
+    new_nico = create_tag!("nico:NEW", category: "nico")
 
     # bot/tagme 念のため
     Tag.bot
     Tag.tagme
 
-    stub_python([{ 'code' => 'sm9', 'title' => 't', 'tags' => ['NEW'] }])
+    stub_python([{ "code" => "sm9", "title" => "t", "tags" => ["NEW"] }])
-    allow(URI).to receive(:open).and_return(StringIO.new('<html></html>'))
+    allow(URI).to receive(:open).and_return(StringIO.new("<html></html>"))
 
-    run_rake_task('nico:sync')
+    run_rake_task("nico:sync")
 
     # OLD は active から外れる（discarded_at が入る）
     old_pts = PostTag.where(post_id: post.id, tag_id: old_nico.id).order(:id).to_a
@@ -138,9 +86,9 @@ RSpec.describe 'nico:sync' do
 
     # NEW は active にいる
     post.reload
-    active_names = post.tags.joins(:tag_name).pluck('tag_names.name')
+    active_names = post.tags.joins(:tag_name).pluck("tag_names.name")
-    expect(active_names).to include('nico:NEW')
+    expect(active_names).to include("nico:NEW")
-    expect(active_names).not_to include('nico:OLD')
+    expect(active_names).not_to include("nico:OLD")
   end
 
   def snapshot_tags(post)

frontend/AGENTS.md

@@ -50,27 +50,16 @@ pass or the remaining failure is clearly blocked.
 - Prefer single quotes for strings unless interpolation or escaping makes double quotes better.
 - Never write a TypeScript or TSX line longer than 99 characters.
 - Aim to keep TypeScript and TSX lines within 79 characters where practical.
-- Use 2-space block indentation in TypeScript and TSX.
+- Use 4-space logical indentation in TypeScript and TSX.
-- Use 4-space continuation indentation for wrapped expressions, arguments,
-  ternary branches, method chains, object pairs, arrays, and JSX attributes.
-- Treat the user's `PostImportSourcePage.tsx` and
-  `PostImportReviewPage.tsx` formatting as the local reference shape.
 - For arrays, never put whitespace or a line break immediately before `]`.
 - Keep the first element on the same line as `[` by default.
 - If an array would exceed the line limit, break after `[` and indent
   elements by 4 spaces.
-- In TypeScript and TSX only, use tabs for leading 8-column compression only.
+- In TypeScript and TSX only, replace every leading run of 8 spaces with a tab
-- A tab does not represent one indentation level.
+  to reduce bytes.
-- Determine visible indentation with 2-space block indentation and 4-space
-  continuation indentation first, then compress only complete leading runs of
-  8 spaces into tabs.
 - Treat one leading tab as exactly equivalent to 8 leading spaces.
 - Use tabs only for leading indentation. Never replace spaces that occur after
   a non-space character on the same line.
-- Keep residual leading 2, 4, or 6 spaces after any tab compression.
-- Examples: 2 columns = 2 spaces, 4 columns = 4 spaces, 6 columns = 6
-  spaces, 8 columns = 1 tab, 10 columns = 1 tab + 2 spaces, 12 columns = 1
-  tab + 4 spaces.
 
 ## React
 
@@ -108,35 +97,17 @@ pass or the remaining failure is clearly blocked.
   third-party request outside the Rails API.
 - For blob responses, pass `responseType: 'blob'` so the wrapper does not camelCase the body.
 
-## Dialogues
-
-- Dialogue work follows the shared-frontend reuse rules below.
-
 ## Imports and aliases
 
 - The `@` alias points to `frontend/src`.
 - Prefer `@/...` imports for app code instead of long relative paths.
 - Keep type imports separate with `import type`.
-- Do not mix runtime values and `type` specifiers in one named import
+- Match existing import grouping: external packages, app modules, then type imports.
-  declaration.
-- Do not write `import { value, type TypeName } from ...`.
-- Keep short value imports from one module on one line when they fit within
-  99 characters.
-- Order imports as four groups with a blank line between groups: external
-  value imports, `@/...` value imports, external type imports, `@/...`
-  type imports.
 
 ## Tailwind and UI
 
 - Tailwind scans `src/**/*.{html,js,ts,jsx,tsx,mdx}`.
 - Use `cn` from `src/lib/utils.ts` for conditional class names and class merging.
-- In JavaScript, JSX, TypeScript, and TSX, use `cn` from `@/lib/utils`
-  whenever `className` combines multiple values, conditional classes, or a
-  caller-provided `className` prop.
-- Do not construct `className` with template literals, `${ ... }`, string
-  concatenation, arrays joined with spaces, or feature-local class-merging
-  helpers.
-- A static `className="..."` containing only fixed classes does not need `cn`.
 - Reuse components from `src/components/common`, `src/components/layout`, and
   `src/components/ui` before adding new primitives.
 - Keep Tailwind classes consistent with nearby components.
@@ -147,816 +118,23 @@ pass or the remaining failure is clearly blocked.
   short Japanese labels that fit the control.
 - Preserve existing Japanese tone and orthography in nearby UI text, including
   old-kana wording where the file already uses it.
-- Do not add user-facing copy, helper text, descriptions, notes, tooltips,
+- When adding dynamic tag color classes, update `tailwind.config.js` safelist
-  placeholders, empty-state messages, loading messages, or explanatory text
-  unless the user explicitly specified the wording.
-- When new user-facing wording appears necessary, ask the user for the exact
-  wording and placement before implementing it.
-- Do not invent replacement copy when removing unrequested wording.
-- Do not use `タグなし` as user-facing copy for an empty tag state. When the
-  tag state is empty, show no copy. If actual data contains the tag name
-  `タグなし`, treat it as ordinary data and display it normally.
-- When adding dynamic tag colour classes, update `tailwind.config.js` safelist
   if the class cannot be statically detected.
 - Do not introduce new UI libraries or production dependencies without approval.
 
-## TypeScript and TSX formatting
+## TSX formatting
 
-- The delimiter-placement and line-breaking rules in this section apply to
-  both plain TypeScript `.ts` and TSX `.tsx`, unless a bullet explicitly says
-  it is JSX- or React-specific.
 - Preserve compact TSX expression shapes such as inline ternary branches and
   closing `</div>)` forms when nearby code uses them.
-- Block bodies for components, functions, callbacks, `if`, `try`, `catch`,
-  `finally`, loops, and JSX nesting use 2 spaces per level.
-- Put the opening brace of `try`, `catch`, and `finally` blocks on the next
-  line at the same indentation as the keyword.
-- Do not indent the opening `{` one level deeper than `try`, `catch`, or
-  `finally`.
-- Indent the block body 2 spaces deeper than the keyword and opening brace.
-- Put the closing `}` on its own line at the same indentation as the keyword.
-- Do not write `try {`, `catch {`, or `finally {`.
-- Wrapped expressions, arguments, ternary branches, method chains, and object
-  pairs use 4-space continuation indentation relative to the owning
-  expression. Do not confuse this with 2-space block indentation.
-- Tabs are leading 8-column compression only. They do not represent one
-  nesting level. Decide visible indentation first, then compress only
-  complete leading runs of 8 spaces into tabs.
-- Do not add braces around a single-line `if` body merely for formatting.
-- Use braces for multi-line `if`, `else`, and loop bodies.
-- Multi-stage ternary expressions must use explicit parentheses for each
-  condition group and nested branch. Do not rely on indentation alone to show
-  `?` / `:` pairing.
-- Keep short inline props types local when they remain readable and within the
-  line limit; do not mechanically extract a named type with no reuse benefit.
-- In JavaScript, JSX, TypeScript, and TSX, never use `_1`, `_2`, or similar
-  Ruby-style numbered parameter names. Reserve numbered parameters for Ruby.
-  Use a meaningful callback parameter name such as `row`, `item`, `value`,
-  `entry`, or `result`.
-- In multi-line object literals, keep the opening `{` with the first pair when
-  the line length allows it; do not mechanically explode short objects into
-  Prettier-style vertical blocks.
-- Method chains should align as a continuation under the receiver expression;
-  do not indent chains more deeply than the normal continuation depth.
-- `PostImportSourcePage.tsx` and `PostImportReviewPage.tsx` are the current
-  canonical examples for block indentation, continuation indentation, import
-  grouping, ternary grouping, method-chain placement, and local inline props
-  types.
-- Treat TypeScript and TSX formatting rules as hard constraints, not
-  preferences. Before finishing a TypeScript or TSX edit, inspect the edited
-  hunks for closing `)`, `]`, and `}` placement and fix violations instead of
-  relying on formatter defaults.
-- After every TypeScript or TSX edit, perform a style-only self-review of the
-  edited hunks before running verification or reporting completion. The task is
-  not complete while any edited TypeScript or TSX hunk violates these local
-  formatting rules.
-- The TypeScript/TSX self-review must classify every edited leading or trailing
-  `)`, `]`, and `}` by syntax role before deciding whether it is valid. Do not
-  apply a rule by glyph alone. A closing `)` for a function parameter list is
-  different from a closing `)` for a function call. A closing `}` for a block
-  is different from a closing `}` for an object, type literal, import list, or
-  destructuring pattern.
-- The TSX-specific self-review must confirm there are no common Prettier-style
-  React component declarations with a multi-line destructured parameter.
-- The TypeScript/TSX self-review must confirm multi-line function declaration
-  parameter `)` placement follows the detailed parameter-list rules below.
-- The TypeScript/TSX self-review must confirm call-expression `)` is never at
-  the beginning of a line.
-- The TypeScript/TSX self-review must confirm
-  object/type/import/destructuring `}` is not at the beginning of a line.
-- The TypeScript/TSX self-review must confirm multi-line
-  function/lambda/callback/block `}` is on its own line and never at the end
-  of the previous line.
-- The TypeScript/TSX self-review must confirm array `]` is not at the
-  beginning of a line.
-- The TSX-specific self-review must confirm JSX closing markers and closing
-  parentheses keep the surrounding compact style.
-- The TypeScript/TSX self-review must confirm leading block indentation uses
-  2 spaces per level, wrapped continuations use the repository's 4-space
-  continuation alignment, and complete leading runs of 8 spaces may be
-  compressed to tabs.
 - For long Tailwind `className` strings, wrap across lines only when needed.
-- Keep continuation indentation aligned with the repository's 4-space
+- Keep continuation indentation aligned with the 4-space logical indentation
-  continuation rule while keeping block indentation at 2 spaces.
+  rule, using tabs only as leading 8-space compression.
-- Keep short value imports from one module on one line when they fit within
-  99 characters.
-- In TypeScript and TSX function declarations, including `const` arrow
-  function declarations, classify the parameter list before placing the closing
-  `)`.
-- Block indentation example:
-
-```ts
-const Component = () => {
-  const value = loadValue ()
-
-  useEffect (() => {
-    if (value != null)
-      useValue (value)
-  }, [value])
-}
-```
-
-- `try` / `catch` / `finally` brace placement example:
-
-```ts
-try
-{
-  doWork ()
-}
-catch
-{
-  recover ()
-}
-finally
-{
-  cleanUp ()
-}
-```
-
-- Continuation indentation example:
-
-```ts
-const editingRow =
-    Number.isFinite (editingSourceRow)
-    ? rows.find (row => row.sourceRow === editingSourceRow) ?? null
-    : null
-```
-
-- Import grouping example:
-
-```ts
-import { useNavigate, useParams, useSearchParams } from 'react-router-dom'
-
-import { loadPostImportSession } from '@/lib/postImportSession'
-
-import type { FC } from 'react'
-
-import type { PostImportRow } from '@/lib/postImportSession'
-```
-
-- Inline props type example:
-
-```ts
-const Footer = (
-    { loading,
-      onSubmit }: { loading:  boolean
-		    onSubmit: () => void },
-) => null
-```
-
-- Ternary grouping example:
-
-```ts
-const rows =
-    repairMode === 'failed'
-    ? (
-	[...source].sort ((a, b) => {
-	  const aFailed = a.failed ? 0 : 1
-	  const bFailed = b.failed ? 0 : 1
-	  return aFailed - bFailed
-	}))
-    : source
-```
-
-- If the parameter list itself is given its own multi-line block after the
-  function's opening `(`, put the closing parameter `)` at the beginning of its
-  own line before the return type or `=>`.
-- If the only line break is inside a parameter's inline type, object type, or
-  destructuring shape, and the parameter list itself is not split as a separate
-  block, keep the closing parameter `)` on the same line as that parameter's
-  final `}`. In this case, moving `)` to a new line is wrong.
-- Do not write React component declarations in the common Prettier form
-  `const Component = ({ ... }) => (` when the destructured parameter spans
-  multiple lines. Use the project form with the opening `(` after `=`, the
-  destructured object as the argument, and the closing parameter `)` on its own
-  line before `=>`.
-- In TypeScript and TSX, never place a closing parenthesis at the beginning of
-  a line except for a multi-line function declaration parameter list.
-- Never place a closing square bracket at the beginning of a line.
-- For object literals, type literals, import/export named bindings, destructuring
-  patterns, and other associative-array-style braces, do not place the closing
-  brace at the beginning of a line. Keep `}` on the same line as the final
-  property, binding, or specifier unless that would violate the line limit.
-  Function, lambda, callback, and block closing braces are exempt and should
-  stay on their own line when that fits the local style. When a function,
-  lambda, callback, or block body spans multiple lines, do not put its closing
-  `}` at the end of the previous line.
-- For arrays and tuple-like lists, do not place the closing `]` at the
-  beginning of a line. Keep `]` on the same line as the final element unless
-  that would violate the line limit.
-- For function and method calls, do not place the closing `)` at the beginning
-  of a line. The only TypeScript/TSX exception is the closing parameter `)` of a
-  multi-line function declaration.
 - Do not add braces around `if`, `else`, or `for` bodies when the body is a
   single physical line.
 - Always add braces around `if`, `else`, or `for` bodies when the body spans
   two or more physical lines, even if it is one statement.
-- Use correct British English spelling for new identifiers, filenames,
-  component names, helper names, comments, and developer-facing prose unless
-  editing an already established American-English API that must keep its
-  existing spelling for compatibility.
-- Prefer British English spellings such as `behaviour`, `colour`, `realise`,
-  `theatre`, `centre`, `favourite`, `optimise`, and `catalogue`.
-- Avoid American or Canadian spellings such as `behavior`, `color`, `realize`,
-  `theater`, `center`, `favorite`, `optimize`, and `catalog`.
-- Even when an external library or API uses the wrong spelling, prefer to
-  correct it at the local boundary and use proper British English names in this
-  frontend codebase. For example, prefer
-  `import { color: colour } from '@external-lib'` over spreading `color`
-  through local code.
-- Apply the same boundary correction to object destructuring, wrapper helpers,
-  adapter layers, and local variable names when doing so does not break the
-  external contract.
-- In this frontend, prefer names such as `BehaviourSettingsSection.tsx`, not
-  `BehaviorSettingsSection.tsx`.
 - Avoid reformatting unrelated JSX.
 
-## Shared frontend systems
-
-Before creating a new component, hook, helper, store, context, or other
-frontend abstraction, search at least:
-
-- `src/components/common`
-- `src/components/layout`
-- `src/components/ui`
-- `src/components/dialogues`
-- `src/lib`
-- `src/lib/dialogues`
-- `src/stores`
-- `src/types.ts`
-
-Also inspect the existing pages and components in the same feature.
-
-Search by responsibility, not by filename alone. Check display, interaction,
-state, communication, validation, and permission behaviour before deciding that
-an existing implementation is unsuitable.
-
-### Component placement and reuse order
-
-When adding UI, use this order:
-
-1. reuse an existing feature component
-2. reuse an existing component from `components/common`
-3. reuse an existing layout component from `components/layout`
-4. use an existing primitive from `components/ui` through the established
-   common API
-5. extend an existing component minimally
-6. add a feature-local component in the feature area
-7. add a new common component only when multiple features clearly share a
-   stable visual contract
-
-Do not place a one-screen component in a common directory merely because its
-name starts with `Common`.
-
-### Low-level primitives
-
-Treat `components/ui` as low-level primitives. If a higher-level common API
-already exists for dialogues, toast, form validation, navigation, or similar
-behaviour, feature code must use that API instead of assembling primitives
-directly.
-
-Examples of existing preferred entrypoints include:
-
-- dialogue: `@/lib/dialogues/useDialogue`
-- toast: the existing toast API
-- internal navigation: `PrefetchLink`
-- form errors: `FieldError`, `FieldWarning`, `FormField`
-- buttons: `Button`
-- conditional class merge: `cn`
-
-Do not evade the rule with aliases or thin wrappers around the low-level
-primitive.
-
-### Dialogues
-
-Feature-facing dialogue work must use `@/lib/dialogues/useDialogue`.
-
-Reuse the existing common dialogue API and common dialogue component. Do not
-import `@/components/ui/dialog` directly in feature code to assemble bespoke
-dialogue shells, and do not evade this rule with aliases such as
-`Dialog as Dialogue`.
-
-Do not reimplement overlay, portal, close button, header, footer, focus
-handling, Escape handling, outside-click handling, or confirmation flow in
-feature code.
-
-Keep business-specific form content in feature code, and keep the visual and
-behavioural dialogue shell in common code.
-
-Use British spelling `Dialogue` for project-defined dialogue identifiers. Keep
-exact third-party spellings only at the external boundary where compatibility
-requires them.
-
-### API calls
-
-Rails API calls must use `src/lib/api.ts`.
-
-Do not create feature-local Axios instances, fetch wrappers, header injectors,
-camelCase converters, or generic error converters. If blob or other special
-transport behaviour is already supported by the common API, use the existing
-options instead of bypassing the wrapper.
-
-### Query keys, server state, and prefetch
-
-Before adding query state, inspect:
-
-- `src/lib/queryKeys.ts`
-- existing domain helpers
-- existing prefetchers
-- the root query-key hierarchy
-- current mutation invalidation patterns
-- the app-wide `QueryClient`
-
-Do not write ad hoc query-key arrays in feature code. Do not duplicate fetcher,
-prefetcher, or invalidation helpers for the same resource.
-
-### Domain helpers
-
-For posts, tags, wiki, materials, and other domain work, inspect the existing
-helpers in `src/lib/*.ts` before adding logic to a page component.
-
-Do not accumulate these in page components when an existing helper layer should
-own them:
-
-- API request construction
-- response-shape conversion
-- query-key construction
-- canonical URL generation
-- permission calculation
-- storage serialisation
-- domain-specific parsing
-
-Keep purely local one-screen display shaping local when that is the clearest
-place for it.
-
-### Permission helpers
-
-Use the existing permission helpers such as `src/lib/users.ts` when deciding
-editability, role checks, admin/member visibility, and similar UI behaviour.
-
-Do not scatter `user?.role`, numeric role comparisons, or string comparisons
-through components. Frontend visibility control should be consistent even though
-backend authorization remains the final gate.
-
-### Validation errors
-
-Before adding feature-local validation-error handling, inspect:
-
-- `useValidationErrors`
-- `apiErrors`
-- `FieldError`
-- `FieldWarning`
-- `FormField`
-- `inputClass`
-
-Do not create a new generic hook, field-error state shape, or error-rendering
-component for a pattern the shared error stack already covers. Keep only
-genuinely feature-specific business errors local.
-
-### Forms and fields
-
-Before creating a new input, textarea, date/time field, tag input, label, or
-error layout, inspect at least:
-
-- `Form`
-- `FormField`
-- `FieldError`
-- `FieldWarning`
-- `DateTimeField`
-- `TagInput`
-- `TextArea`
-- `Label`
-- `Button`
-
-Do not create a same-function field component merely because the spacing or
-surface styling is slightly different. Prefer feature-level composition over
-bloated common-field option lists.
-
-### Navigation and prefetch
-
-Use `PrefetchLink` and existing router helpers for internal navigation. Do not
-introduce feature-local `<a>`, `window.location`, or custom prefetch logic for
-internal routes. Keep path-segment encoding aligned with the existing rules.
-
-### State management
-
-Before adding state, decide whether the source of truth should be:
-
-- component-local state
-- URL search params
-- TanStack Query server state
-- an existing Zustand store
-- an existing event bus
-- an existing storage helper
-
-Do not create a new global store, context, or event bus for one screen when
-local state or an existing mechanism is enough. Do not create a second store
-for the same responsibility.
-
-### Storage and settings
-
-When touching localStorage, sessionStorage, or user settings, inspect existing
-settings helpers, storage helpers, expiry handling, versioning, and sanitisers.
-
-Do not reimplement per-component key naming, JSON parsing and serialisation,
-expiry, or schema checks when a shared helper already owns the pattern.
-
-### Hooks
-
-Before creating a custom hook, search existing `src/lib/use*.ts` and
-`src/lib/use*.tsx`.
-
-Hooks are for shared stateful behaviour or React lifecycle integration. Do not
-turn a pure function, one-off helper, or mere re-export shim into `useFoo`.
-
-### Stores, contexts, and event buses
-
-Add a new store, context, or event bus only when the current mechanisms cannot
-express the requirement and there are multiple genuinely separate consumers.
-
-Do not hold the same information redundantly across URL state, query cache,
-local component state, Zustand, and an event bus. Keep one source of truth.
-
-### Types
-
-If a domain type already exists in `src/types.ts` or a domain helper, reuse it
-instead of redefining the same shape in a feature file.
-
-Small local props and draft types may stay local. Do not create giant
-catch-all type files such as `CommonTypes.ts`.
-
-### Styling utilities
-
-Use existing styling utilities such as `cn` and `inputClass`.
-
-Do not add feature-local class-merge helpers, generic status-colour mappers, or
-responsive wrapper helpers when a shared utility already exists. Keep common
-tone names visual only; feature-specific state names stay in feature code.
-
-### Layout
-
-Before adding page shells, padding rules, viewport-height handling, sidebar
-offsets, or footer offsets, inspect existing layout components such as
-`MainArea`, top navigation, sidebar, page title, and section-title patterns.
-
-Do not create a second layout shell before checking whether the current layout
-can be reused or minimally extended.
-
-- Frontend のスマホ／PC表示境界は原則 `md` とする。
-- button stack、footer action、dialogue action は `md` 未満で縦並び、
-  `md` 以上で横並びとする。
-- 同じ画面内で `sm` と `md` を混在させて中間 layout を作らない。
-- 明確に別の responsive 要件がある component だけを例外とする。
-
-### Delimiter decision table
-
-Use this table before accepting any edited TypeScript or TSX hunk. The table is
-more authoritative than formatter habit. Unless a subsection explicitly
-mentions JSX, it applies equally to `.ts` and `.tsx`.
-
-#### Import and export named bindings
-
-Bad:
-
-```ts
-import {
-    Button,
-    Card,
-} from '@/components/ui'
-```
-
-Good:
-
-```ts
-import { Button,
-	 Card } from '@/components/ui'
-```
-
-Also acceptable when short:
-
-```ts
-import { Button, Card } from '@/components/ui'
-```
-
-Rule: named-binding `}` is associative-array-style syntax. It must not be alone
-at the beginning of a line. Prefer keeping `{` with the first binding and `}`
-with the final binding when this fits the line limit.
-
-#### Type literals
-
-Bad:
-
-```ts
-type Props = {
-    open: boolean
-    onOpenChange: (open: boolean) => void
-}
-```
-
-Good:
-
-```ts
-type Props = {
-    open: boolean
-    onOpenChange: (open: boolean) => void }
-```
-
-Rule: type-literal `}` is not a block close. It must stay on the same line as
-the final property unless that would break the hard line limit.
-
-#### Object literals
-
-Bad:
-
-```ts
-const value = {
-    open,
-    activeScope,
-}
-```
-
-Good:
-
-```ts
-const value = {
-    open,
-    activeScope }
-```
-
-Bad:
-
-```ts
-const value = useMemo (() => ({
-    open,
-    activeScope,
-}), [open, activeScope])
-```
-
-Good:
-
-```ts
-const value = useMemo (() => ({
-    open,
-    activeScope }), [open, activeScope])
-```
-
-Rule: object-literal `}` is associative-array-style syntax. It must not be on a
-line by itself. Keep it with the final property, and keep call `)` off the
-beginning of a line.
-
-#### Destructuring parameters
-
-Bad:
-
-```tsx
-const Component: FC<Props> = ({
-    open,
-    onOpenChange,
-}) => {
-  return null
-}
-```
-
-Good:
-
-```tsx
-const Component: FC<Props> = (
-    { open,
-      onOpenChange },
-) => {
-  return null
-}
-```
-
-Rule: when a React component or helper takes a destructured object parameter
-that spans multiple lines, do not use the Prettier-style `= ({ ... }) =>`
-shape. Put the function parameter list on its own lines. The destructuring `}`
-stays with the final binding. The parameter-list `)` is then allowed and
-required at the beginning of its own line.
-
-#### Inline typed destructuring parameter
-
-Good:
-
-```ts
-const RouteTransitionWrapper = ({ user, setUser }: {
-    user:     User | null
-    setUser:  Dispatch<SetStateAction<User | null>> }) => {
-  return null
-}
-```
-
-Bad:
-
-```ts
-const RouteTransitionWrapper = ({ user, setUser }: {
-    user:     User | null
-    setUser:  Dispatch<SetStateAction<User | null>>
-}) => {
-  return null
-}
-```
-
-Rule: this is not a separately split parameter-list block. The line break is
-inside the inline type. Keep the type-literal `}` and parameter-list `)` on the
-same line as the final type property.
-
-#### Multi-line normal parameter list
-
-Bad:
-
-```ts
-const updateDraft = <Key extends keyof Settings,> (
-    key: Key,
-    value: Settings[Key]) => {
-  return null
-}
-```
-
-Good:
-
-```ts
-const updateDraft = <Key extends keyof Settings,> (
-    key:    Key,
-    value:  Settings[Key],
-) => {
-  return null
-}
-```
-
-Rule: when the parameter list itself is split across multiple parameter lines,
-the closing parameter `)` goes at the beginning of its own line before `=>` or
-the return type.
-
-#### Function and callback blocks
-
-Bad:
-
-```ts
-const handleSave = () => { save ()
-}
-```
-
-Bad:
-
-```ts
-const handleSave = () => {
-  save () }
-```
-
-Good:
-
-```ts
-const handleSave = () => {
-  save ()
-}
-```
-
-Rule: block `}` closes executable code, not associative data. Multi-line
-function, lambda, callback, `if`, `for`, `switch`, and similar block braces
-belong on their own line.
-
-#### Function and method calls
-
-Bad:
-
-```ts
-const value = compute (
-    first,
-    second
-)
-```
-
-Good:
-
-```ts
-const value = compute (
-    first,
-    second)
-```
-
-Rule: call-expression `)` must not be at the beginning of a line. The exception
-for leading `)` applies only to function declaration parameter lists, never to
-calls.
-
-#### JSX closing markers
-
-Bad:
-
-```tsx
-<Button
-    type="button"
-    onClick={handleSave}
->
-  保存
-</Button>
-)
-```
-
-Good:
-
-```tsx
-<Button
-    type="button"
-    onClick={handleSave}>
-  保存
-</Button>)
-```
-
-Bad:
-
-```tsx
-<Input
-    value={value}
-    onChange={handleChange}
-/>
-```
-
-Good:
-
-```tsx
-<Input
-    value={value}
-    onChange={handleChange}/>
-```
-
-Rule: keep `>` or `/>` with the final prop, and keep JSX closing parentheses in
-the local compact form such as `</div>)`.
-
-#### Arrays and tuples
-
-Bad:
-
-```ts
-const items = [
-    first,
-    second,
-]
-```
-
-Good:
-
-```ts
-const items = [
-    first,
-    second]
-```
-
-Good when short:
-
-```ts
-const items = [first, second]
-```
-
-Rule: array and tuple `]` must not be at the beginning of a line. Keep it with
-the final element unless that would break the hard line limit.
-
-#### Single-line braces
-
-Good:
-
-```ts
-const next = { ...current, enabled: true }
-const tag = { id, name }
-```
-
-Bad:
-
-```tsx
-<Component prop={ value }/>
-```
-
-Good:
-
-```tsx
-<Component prop={value}/>
-```
-
-Rule: JavaScript object braces on one line get one inner space. JSX expression
-braces do not get inner spaces.
-
-#### Final TSX self-review checklist
-
-Before reporting completion after a TypeScript or TSX edit, check the edited
-hunks line by line:
-
-1. No import/export/type/object/destructuring `}` appears alone at the beginning
-   of a line.
-2. No call-expression `)` appears at the beginning of a line.
-3. Any leading `)` is definitely closing a function declaration parameter list,
-   not a call.
-4. Any parameter-list `)` at the end of a line is valid because the parameter
-   list itself was not split, only an inline type or destructuring shape was.
-5. No array or tuple `]` appears at the beginning of a line.
-6. Multi-line executable block `}` is on its own line.
-7. JSX `>` and `/>` stay with the final prop unless nearby code proves
-   otherwise.
-8. JSX closing parentheses keep the compact local style.
-9. Leading block indentation uses 2 spaces per level, wrapped continuations
-   use the repository's 4-space continuation alignment, and complete leading
-   runs of 8 spaces may be compressed to tabs.
-10. No line has trailing whitespace.
-
 ## Lint and build constraints
 
 - ESLint uses `@eslint/js`, `typescript-eslint`, `eslint-plugin-react-hooks`,

frontend/src/App.tsx

@@ -1,32 +1,16 @@
-import { AnimatePresence, LayoutGroup, MotionConfig, motion } from 'framer-motion'
+import { AnimatePresence, LayoutGroup, motion } from 'framer-motion'
-import { Fragment, useEffect, useMemo, useState } from 'react'
+import { useEffect, useState } from 'react'
-import { createBrowserRouter,
+import { BrowserRouter,
 	 Navigate,
 	 Route,
-	 RouterProvider,
 	 Routes,
 	 useLocation } from 'react-router-dom'
 
-import DevModeWatermark from '@/components/DevModeWatermark'
 import RouteBlockerOverlay from '@/components/RouteBlockerOverlay'
 import TopNav from '@/components/TopNav'
 import DialogueProvider from '@/components/dialogues/DialogueProvider'
 import { Toaster } from '@/components/ui/toaster'
 import { apiPost, isApiError } from '@/lib/api'
-import { applyClientAnimationMode,
-	 applyClientAppearance,
-	 type ClientAnimationMode,
-	 fetchUserThemeSlots,
-	 fetchUserSettings,
-	 getClientThemeMode,
-	 hasStoredClientThemeSelection,
-	 normaliseUserThemeSlots,
-	 setCachedUserThemeSlots,
-	 seedClientThemeMode } from '@/lib/settings'
-import { useClientBehaviourSettings } from '@/lib/useClientBehaviourSettings'
-import { UnsavedChangesGuardProvider } from '@/lib/useUnsavedChangesGuard'
-
-import { KeyboardShortcutsProvider } from '@/lib/useKeyboardShortcuts'
 import DeerjikistDetailPage from '@/pages/deerjikists/DeerjikistDetailPage'
 import MaterialBasePage from '@/pages/materials/MaterialBasePage'
 import MaterialDetailPage from '@/pages/materials/MaterialDetailPage'
@@ -42,8 +26,8 @@ import NotFound from '@/pages/NotFound'
 import TOSPage from '@/pages/TOSPage.mdx'
 import PostDetailPage from '@/pages/posts/PostDetailPage'
 import PostHistoryPage from '@/pages/posts/PostHistoryPage'
-import PostNewPage from '@/pages/posts/PostNewPage'
 import PostListPage from '@/pages/posts/PostListPage'
+import PostNewPage from '@/pages/posts/PostNewPage'
 import PostSearchPage from '@/pages/posts/PostSearchPage'
 import ServiceUnavailable from '@/pages/ServiceUnavailable'
 import SettingPage from '@/pages/users/SettingPage'
@@ -63,51 +47,11 @@ import type { Dispatch, FC, SetStateAction } from 'react'
 import type { User } from '@/types'
 
 
-const RouteTransitionWrapper = ({ animationMode, user, setUser }: {
+const RouteTransitionWrapper = ({ user, setUser }: {
-    animationMode: ClientAnimationMode
     user:     User | null
     setUser:  Dispatch<SetStateAction<User | null>> }) => {
   const location = useLocation ()
 
-  if (animationMode === 'off')
-    {
-      return (
-	  <Routes location={location}>
-	    <Route path="/" element={<Navigate to="/posts" replace/>}/>
-	    <Route path="/posts" element={<PostListPage/>}/>
-	    <Route path="/posts/new" element={<PostNewPage user={user}/>}/>
-	    <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/:id" element={<TagDetailPage/>}/>
-	    <Route path="/tags/:id/deerjikists" element={<DeerjikistDetailPage/>}/>
-	    <Route path="/tags/nico" element={<NicoTagListPage user={user}/>}/>
-	    <Route path="/nico/tags" element={<NicoTagListPage user={user}/>}/>
-	    <Route path="/tags/changes" element={<TagHistoryPage/>}/>
-	    <Route path="/theatres/:id" element={<TheatreDetailPage user={user}/>}/>
-	    <Route path="/materials" element={<MaterialBasePage/>}>
-	      <Route index element={<MaterialListPage/>}/>
-	      <Route path="changes" element={<MaterialHistoryPage/>}/>
-	      <Route path="new" element={<MaterialNewPage/>}/>
-	      <Route path="suppressions" element={<MaterialSyncSuppressionsPage/>}/>
-	      <Route path=":id" element ={<MaterialDetailPage/>}/>
-	    </Route>
-	    <Route path="/wiki" element={<WikiSearchPage/>}/>
-	    <Route path="/wiki/:title" element={<WikiDetailPage/>}/>
-	    <Route path="/wiki/new" element={<WikiNewPage user={user}/>}/>
-	    <Route path="/wiki/:id/edit" element={<WikiEditPage user={user}/>}/>
-	    <Route path="/wiki/:id/diff" element={<WikiDiffPage/>}/>
-	    <Route path="/wiki/changes" element={<WikiHistoryPage/>}/>
-	    <Route path="/users/settings" element={<SettingPage user={user} setUser={setUser}/>}/>
-	    <Route path="/settings" element={<Navigate to="/users/settings" replace/>}/>
-	    <Route path="/tos" element={<TOSPage/>}/>
-	    <Route path="/gekanator" element={<GekanatorPage user={user}/>}/>
-	    <Route path="/more" element={<MorePage/>}/>
-	    <Route path="*" element={<NotFound/>}/>
-	  </Routes>)
-    }
-
   return (
       <AnimatePresence mode="wait">
 	<Routes location={location}>
@@ -155,40 +99,9 @@ const PostDetailRoute = ({ user }: { user: User | null }) => {
 }
 
 
-const RoutedApp: FC = () => {
+const App: FC = () => {
   const [user, setUser] = useState<User | null> (null)
   const [status, setStatus] = useState (200)
-  const behaviourSettings = useClientBehaviourSettings ()
-  const animationMode = behaviourSettings.animation ?? 'normal'
-  const LayoutWrapper = animationMode === 'off' ? Fragment : LayoutGroup
-
-  const appLayoutTransition = useMemo (
-      () => (
-	  animationMode === 'off'
-	  ? { duration: 0 }
-	  : animationMode === 'reduced'
-	    ? { duration: .08, ease: 'linear' as const }
-	    : { duration: .2, ease: 'easeOut' as const }
-      ),
-      [animationMode],
-  )
-
-  useEffect (() => {
-    applyClientAppearance ()
-
-    const mediaQuery = window.matchMedia ('(prefers-color-scheme: dark)')
-    const handleThemeChange = () => {
-      if (getClientThemeMode () === 'system')
-	applyClientAppearance ()
-    }
-
-    mediaQuery.addEventListener ('change', handleThemeChange)
-    return () => mediaQuery.removeEventListener ('change', handleThemeChange)
-  }, [])
-
-  useEffect (() => {
-    applyClientAnimationMode (animationMode)
-  }, [animationMode])
 
   useEffect (() => {
     const createUser = async () => {
@@ -223,30 +136,6 @@ const RoutedApp: FC = () => {
       createUser ()
   }, [])
 
-  useEffect (() => {
-    if (!(user))
-      return
-
-    void (async () => {
-	try
-	{
-	  const [settings, themeSlots] = await Promise.all ([
-	      fetchUserSettings (),
-	      fetchUserThemeSlots (),
-	  ])
-	  const storedThemeSlots = normaliseUserThemeSlots (themeSlots)
-	  setCachedUserThemeSlots (storedThemeSlots)
-	  if (!(hasStoredClientThemeSelection ()))
-	    seedClientThemeMode (settings.theme)
-	  applyClientAppearance ()
-	}
-      catch
-      {
-	return
-      }
-    }) ()
-  }, [user])
-
   switch (status)
   {
   case 503:
@@ -254,46 +143,25 @@ const RoutedApp: FC = () => {
   }
 
   return (
-      <DialogueProvider>
+      <>
-	<UnsavedChangesGuardProvider>
+	<RouteBlockerOverlay/>
-	  <KeyboardShortcutsProvider>
-	  <MotionConfig
-	      reducedMotion={
-		  animationMode === 'normal'
-		  ? 'never'
-		  : animationMode === 'reduced'
-		    ? 'user'
-		    : 'always'
-	      }>
-	    <LayoutWrapper>
-	      <motion.div
-		  layout={animationMode === 'off' ? false : 'position'}
-		  transition={{ layout: appLayoutTransition }}
-		  className="relative flex h-dvh w-full flex-col overflow-y-hidden">
-		<TopNav user={user}/>
-		<RouteTransitionWrapper
-		    animationMode={animationMode}
-		    user={user}
-		    setUser={setUser}/>
-	      </motion.div>
-	    </LayoutWrapper>
-	  </MotionConfig>
 
-	  <Toaster/>
+	<BrowserRouter>
-	  </KeyboardShortcutsProvider>
+	  <DialogueProvider>
-	</UnsavedChangesGuardProvider>
+	    <LayoutGroup>
-      </DialogueProvider>)
+	      <motion.div
+		  layout="position"
+		  transition={{ layout: { duration: .2, ease: 'easeOut' } }}
+		  className="flex flex-col h-dvh w-full overflow-y-hidden">
+		<TopNav user={user}/>
+		<RouteTransitionWrapper user={user} setUser={setUser}/>
+	      </motion.div>
+	    </LayoutGroup>
+
+	    <Toaster/>
+	  </DialogueProvider>
+	</BrowserRouter>
+      </>)
 }
 
-const router = createBrowserRouter ([{
-    path: '*',
-    element: <RoutedApp/> }])
-
-const App: FC = () => (
-    <>
-      <RouteBlockerOverlay/>
-      {import.meta.env.DEV && <DevModeWatermark/>}
-      <RouterProvider router={router}/>
-    </>)
-
 export default App

frontend/src/components/DevModeWatermark.tsx

@@ -1,46 +0,0 @@
-import nikumaru from '@/assets/fonts/nikumaru.otf'
-
-import type { FC } from 'react'
-
-
-const ROW_COUNT = 8
-const COLUMN_COUNT = 12
-
-
-const DevModeWatermark: FC = () => {
-  return (
-      <div
-	  aria-hidden="true"
-	  className="pointer-events-none select-none fixed inset-0 overflow-hidden z-0">
-	<style>{`
-	  @font-face {
-	    font-family: 'Nikumaru';
-	    src: url(${nikumaru}) format('opentype');
-	  }
-	`}</style>
-	<div className="absolute -inset-32 flex flex-col justify-center gap-12 py-48">
-	  {Array.from ({ length: ROW_COUNT }, (_, rowIndex) => (
-	      <div
-		  key={rowIndex}
-		  className={
-		      'flex min-h-32 items-center gap-12 '
-		      + (rowIndex % 2 === 0 ? 'translate-x-0' : 'translate-x-32')
-		  }>
-		{Array.from ({ length: COLUMN_COUNT }, (_, columnIndex) => (
-		    <span
-			key={columnIndex}
-			className={
-			    'whitespace-nowrap text-3xl font-bold '
-			    + 'tracking-[0.3em] text-neutral-950/5 '
-			    + 'dark:text-white/10'
-			}
-			style={{ fontFamily: 'Nikumaru' }}>
-		      開発モード
-		    </span>))}
-	      </div>))}
-	</div>
-      </div>)
-}
-
-
-export default DevModeWatermark

frontend/src/components/DraggableDroppableTagRow.test.tsx

@@ -1,75 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import DraggableDroppableTagRow from '@/components/DraggableDroppableTagRow'
-import { buildTag } from '@/test/factories'
-import { renderWithProviders } from '@/test/render'
-
-const dndKit = vi.hoisted (() => ({
-  useDraggable: vi.fn (),
-  useDroppable: vi.fn (),
-}))
-
-vi.mock ('@dnd-kit/core', () => dndKit)
-
-const tag = buildTag ({ id: 7, name: 'ドラッグ元', postCount: 3 })
-
-const renderRow = (activeDndId?: string) => {
-  renderWithProviders (
-      <DraggableDroppableTagRow
-          activeDndId={activeDndId}
-          tag={tag}
-          nestLevel={2}
-          pathKey="cat-general-7"
-          suppressClickRef={{ current: false }}/>,
-  )
-}
-
-const tagBody = (): HTMLElement => {
-  const link = document.querySelector<HTMLElement> ('a[title="ドラッグ元"]')
-
-  if (link == null)
-    throw new Error ('tag link not found')
-
-  const body = link.closest ('div')
-
-  if (body == null)
-    throw new Error ('tag body not found')
-
-  return body
-}
-
-describe ('DraggableDroppableTagRow', () => {
-  beforeEach (() => {
-    vi.clearAllMocks ()
-    dndKit.useDraggable.mockReturnValue ({
-        attributes: { 'aria-describedby': 'drag-source' },
-        listeners:  { onPointerDown: vi.fn () },
-        setNodeRef: vi.fn (),
-        transform:  null })
-    dndKit.useDroppable.mockReturnValue ({
-        isOver:     false,
-        setNodeRef: vi.fn () })
-  })
-
-  it ('passes dndId through draggable data for active-row tracking', () => {
-    renderRow ()
-
-    expect (dndKit.useDraggable).toHaveBeenCalledWith (
-        expect.objectContaining ({
-            id:   'tag-node:cat-general-7',
-            data: expect.objectContaining ({
-                dndId:     'tag-node:cat-general-7',
-                nestLevel: 2,
-                tagId:     7 }) }))
-  })
-
-  it ('hides only the active drag source from the explicit active dnd id', () => {
-    renderRow ('tag-node:cat-general-7')
-    expect (tagBody ()).toHaveStyle ({ visibility: 'hidden' })
-  })
-
-  it ('keeps inactive tag rows visible while another tag is dragged', () => {
-    renderRow ('tag-node:other')
-    expect (tagBody ()).toHaveStyle ({ visibility: 'visible' })
-  })
-})

frontend/src/components/DraggableDroppableTagRow.tsx

@@ -4,8 +4,6 @@ import { motion } from 'framer-motion'
 import { useRef } from 'react'
 
 import TagLink from '@/components/TagLink'
-import { clientAnimationTransition } from '@/lib/clientAnimation'
-import { useClientBehaviourSettings } from '@/lib/useClientBehaviourSettings'
 import { cn } from '@/lib/utils'
 
 import type { CSSProperties, FC, MutableRefObject } from 'react'
@@ -13,7 +11,6 @@ import type { CSSProperties, FC, MutableRefObject } from 'react'
 import type { Tag } from '@/types'
 
 type Props = {
-    activeDndId?:      string
     tag:              Tag
     nestLevel:        number
     pathKey:          string
@@ -22,21 +19,7 @@ type Props = {
     sp?:              boolean }
 
 
-const DraggableDroppableTagRow: FC<Props> = ({
+const DraggableDroppableTagRow: FC<Props> = ({ tag, nestLevel, pathKey, parentTagId, suppressClickRef, sp }) => {
-    activeDndId,
-    tag,
-    nestLevel,
-    pathKey,
-    parentTagId,
-    suppressClickRef,
-    sp,
-}) => {
-  const behaviourSettings = useClientBehaviourSettings ()
-  const animationMode = behaviourSettings.animation ?? 'normal'
-  const layoutTransition = clientAnimationTransition (
-      animationMode,
-      { normal: { duration: .2, ease: 'easeOut' as const } },
-  )
   const dndId = `tag-node:${ pathKey }`
 
   const downPosRef = useRef<{ x: number; y: number } | null> (null)
@@ -62,23 +45,18 @@ const DraggableDroppableTagRow: FC<Props> = ({
   const { attributes,
 	  listeners,
 	  setNodeRef: setDragRef,
-	  transform } = useDraggable ({ id:    dndId,
+	  transform,
-					data:  { kind:   'tag',
+	  isDragging: dragging } = useDraggable ({ id:    dndId,
-						 dndId,
+						   data:  { kind:   'tag',
-						 tagId:  tag.id,
+							    tagId:  tag.id,
-						 parentTagId,
+							    parentTagId } })
-						 nestLevel } })
 
   const { setNodeRef: setDropRef, isOver: over } = useDroppable ({
       id:   dndId,
       data: { kind: 'tag', tagId: tag.id } })
 
-  const activeDragging = activeDndId === dndId
   const style: CSSProperties = { transform:   CSS.Translate.toString (transform),
-				 visibility:  activeDragging ? 'hidden' : 'visible' }
+				 visibility:  dragging ? 'hidden' : 'visible' }
-  const innerClassName = cn (
-      'inline-flex min-w-0 max-w-full items-baseline overflow-hidden',
-      sp && 'touch-pan-y')
 
   return (
       <div
@@ -91,16 +69,12 @@ const DraggableDroppableTagRow: FC<Props> = ({
 	      return
 	    const dx = e.clientX - p.x
 	    const dy = e.clientY - p.y
-
 	    if (dx * dx + dy * dy >= 9)
 	      armEatNextClick ()
 	  }}
 	  onPointerUpCapture={() => {
 	    downPosRef.current = null
 	  }}
-	  onPointerCancelCapture={() => {
-	    downPosRef.current = null
-	  }}
 	  onClickCapture={e => {
 	    if (suppressClickRef.current)
 	      {
@@ -108,36 +82,20 @@ const DraggableDroppableTagRow: FC<Props> = ({
 		e.stopPropagation ()
 	      }
 	  }}
-	  ref={setDropRef}
+	  ref={node => {
-	  className={cn (
+	    setDragRef (node)
-	      'min-w-0 max-w-full overflow-hidden rounded select-none',
+	    setDropRef (node)
-	      sp && 'touch-pan-y',
+	  }}
-	      over && 'ring-2 ring-offset-2')}
+	  style={style}
-	  >
+	  className={cn ('rounded select-none', over && 'ring-2 ring-offset-2')}
-	{activeDragging
+	  {...attributes}
-	 ? (
+	  {...listeners}>
-	    <div
+	<motion.div
-		ref={setDragRef}
+	    transition={{ layout: { duration: .2, ease: 'easeOut' } }}
-		style={style}
+	    layoutId={`tag-${ sp ? 'sp-' : '' }${ tag.id }`}>
-		className={innerClassName}
+	  <TagLink tag={tag} nestLevel={nestLevel}/>
-		{...attributes}
+	</motion.div>
-		{...listeners}>
-	      <TagLink tag={tag} nestLevel={nestLevel}/>
-	    </div>)
-	 : (
-	    <motion.div
-		ref={setDragRef}
-		style={style}
-		className={innerClassName}
-		{...attributes}
-		{...listeners}
-		transition={{ layout: layoutTransition }}
-		layoutId={animationMode === 'off'
-		    ? undefined
-		    : `tag-${ sp ? 'sp-' : '' }${ tag.id }`}>
-	      <TagLink tag={tag} nestLevel={nestLevel}/>
-	    </motion.div>)}
       </div>)
 }
 
-export default DraggableDroppableTagRow
+export default DraggableDroppableTagRow

frontend/src/components/MaterialSidebar.tsx

@@ -318,20 +318,12 @@ const MobileMaterialTreeNode: FC<{ depth?: number
 	    <TagLink
 		tag={sidebarTagToTag (tag)}
 		title={tag.name}
-		truncateOnMobile
 		withCount={false}
 		withWiki={false}
 		to={materialPath (tag.id, materialFilter)}
 		className="block overflow-hidden text-ellipsis whitespace-nowrap
 			   [max-inline-size:var(--tag-link-inline-size)]
-			   [max-height:var(--tag-link-inline-size)]
+			   [max-height:var(--tag-link-inline-size)]"/>
-			   [&_.tag-marquee]:block
-			   [&_.tag-marquee]:h-full
-			   [&_.tag-marquee]:overflow-hidden
-			   [&_.tag-marquee__static]:h-full
-			   [&_.tag-marquee__static]:overflow-hidden
-			   [&_.tag-marquee__static]:text-ellipsis
-			   [&_.tag-marquee__static]:[text-overflow:ellipsis]"/>
 	  </div>
 	  {tag.hasChildren && (
 	      <button
@@ -488,23 +480,25 @@ const MaterialSidebar: FC = () => {
 	  </div>
 	</div>
 
-	<SidebarComponent sidebarKey="materials" className="hidden md:block">
+	<div className="hidden md:block">
-	  <div className="space-y-4">
+	  <SidebarComponent>
-	    <MaterialFilterButtons
+	    <div className="space-y-4">
-		materialFilter={materialFilter}
+	      <MaterialFilterButtons
-		onChange={handleFilterChange}/>
+		  materialFilter={materialFilter}
-	    {isLoading && (
+		  onChange={handleFilterChange}/>
-		<p className="text-sm text-neutral-500 dark:text-stone-400">読込中……</p>)}
+	      {isLoading && (
-	    {isError && (
+		  <p className="text-sm text-neutral-500 dark:text-stone-400">読込中……</p>)}
-		<p className="text-sm text-red-600 dark:text-red-300">
+	      {isError && (
-		  タグ一覧の取得に失敗しました．
+		  <p className="text-sm text-red-600 dark:text-red-300">
-		</p>)}
+		    タグ一覧の取得に失敗しました．
-	    {(!isLoading && !isError) && (
+		  </p>)}
-		<ul>
+	      {(!isLoading && !isError) && (
-		  {renderDesktopTree (visibleRootTags)}
+		  <ul>
-		</ul>)}
+		    {renderDesktopTree (visibleRootTags)}
-	  </div>
+		  </ul>)}
-	</SidebarComponent>
+	    </div>
+	  </SidebarComponent>
+	</div>
       </>)
 }
 

frontend/src/components/PostEditForm.test.tsx

@@ -19,8 +19,8 @@ const toastApi = vi.hoisted (() => ({
 vi.mock ('@/lib/posts', () => postsApi)
 vi.mock ('@/lib/api', () => api)
 vi.mock ('@/components/ui/use-toast', () => toastApi)
-vi.mock ('@/lib/dialogues/useDialogue', () => ({
+vi.mock ('@/components/dialogues/DialogueProvider', () => ({
-  default: () => ({
+  useDialogue: () => ({
     choice: vi.fn (),
   }),
 }))
@@ -66,55 +66,4 @@ describe ('PostEditForm', () => {
     expect (onSave).toHaveBeenCalledWith (expect.objectContaining ({ versionNo: 5 }))
     expect (toastApi.toast).toHaveBeenCalledWith ({ description: '更新しました．' })
   })
-
-  it ('preserves duration while the video tag is temporarily removed', () => {
-    const post = buildPost ({
-      videoMs: 180_500,
-      tags:    [
-        buildTag ({ id: 1, name: '動画', category: 'general' }),
-        buildTag ({ id: 2, name: 'general-tag', category: 'general' }),
-      ],
-    })
-
-    render (<PostEditForm post={post} onSave={vi.fn ()}/>)
-
-    expect (screen.getByText ('動画時間').parentElement?.querySelector ('input'))
-	.toHaveValue ('180.5')
-
-    const tags = screen.getAllByRole ('textbox')[2]
-    fireEvent.change (tags, { target: { value: 'general-tag' } })
-    expect (screen.queryByText ('動画時間')).not.toBeInTheDocument ()
-
-    fireEvent.change (tags, {
-      target: { value: '動画 general-tag' },
-    })
-    expect (screen.getByText ('動画時間').parentElement?.querySelector ('input'))
-	.toHaveValue ('180.5')
-  })
-
-  it (
-      'shows deduplicated original-created endpoint errors on the shared datetime field',
-      async () => {
-    const post = buildPost ()
-    api.isApiError.mockReturnValue (true)
-    postsApi.updatePost.mockRejectedValueOnce ({
-      response: {
-        status: 422,
-        data:   {
-          type: 'validation_error',
-          errors: {
-            original_created_at: ['日時を確認してください．'],
-            original_created_from: ['日時を確認してください．'],
-            original_created_before: ['終了を確認してください．'] },
-        },
-      },
-    })
-
-    render (<PostEditForm post={post} onSave={vi.fn ()}/>)
-    fireEvent.submit (screen.getByRole ('button', { name: '更新' }).closest ('form')!)
-
-    expect (await screen.findByText ('日時を確認してください．')).toBeInTheDocument ()
-    expect (screen.getByText ('終了を確認してください．')).toBeInTheDocument ()
-    expect (screen.getAllByText ('日時を確認してください．')).toHaveLength (1)
-      })
 })

frontend/src/components/PostEditForm.tsx

@@ -1,48 +1,37 @@
-import { useEffect, useMemo, useState } from 'react'
+import { useEffect, useState } from 'react'
 
+import PostFormTagsArea from '@/components/PostFormTagsArea'
 import PostOriginalCreatedTimeField from '@/components/PostOriginalCreatedTimeField'
 import FieldError from '@/components/common/FieldError'
-import PostDurationField from '@/components/posts/PostDurationField'
+import FormField from '@/components/common/FormField'
-import PostTagsField from '@/components/posts/PostTagsField'
+import { useDialogue } from '@/components/dialogues/DialogueProvider'
-import PostTextField from '@/components/posts/PostTextField'
 import { Button } from '@/components/ui/button'
 import { toast } from '@/components/ui/use-toast'
 import { isApiError } from '@/lib/api'
-import useDialogue from '@/lib/dialogues/useDialogue'
 import { updatePost } from '@/lib/posts'
-import { msToTime } from '@/lib/utils'
+import { inputClass } from '@/lib/utils'
 import { useValidationErrors } from '@/lib/useValidationErrors'
 
 import type { FC, FormEvent } from 'react'
 
-import type { Post, TagWithSections } from '@/types'
+import type { Post, Tag } from '@/types'
 
 type PostFormField =
-    'parentPostIds' | 'tags' | 'videoMs'
+    'parentPostIds' | 'tags' | 'originalCreatedAt'
-    | 'originalCreatedAt' | 'originalCreatedFrom' | 'originalCreatedBefore'
-
-const groupedMessages = (...values: (string[] | undefined)[]): string[] =>
-    [...new Set (values.flatMap (value => value ?? []))]
-
-const videoMsToDurationValue = (videoMs: number | null): string =>
-    videoMs == null ? '' : String (videoMs / 1_000)
 
 
-const tagsToStr = (tags: TagWithSections[]): string => {
+const tagsToStr = (tags: Tag[]): string => {
-  const result: Omit<TagWithSections, 'children'>[] = []
+  const result: Tag[] = []
 
-  const walk = (tag: TagWithSections) => {
+  const walk = (tag: Tag) => {
     const { children, ...rest } = tag
     result.push (rest)
-    children.forEach (walk)
+    children?.forEach (walk)
   }
 
   tags.filter (t => t.category !== 'nico').forEach (walk)
 
-  return [...(new Set (result.map (t =>
+  return [...(new Set (result.map (t => t.name)))].join (' ')
-      `${ t.name }${ t.sections
-		     .map (s => `[${ msToTime (s.beginMs) }-${ s.endMs == null ? '' : msToTime (s.endMs) }]`)
-		     .join ('') }`)))].join (' ')
 }
 
 
@@ -52,7 +41,6 @@ type Props = { post:    Post
 
 const PostEditForm: FC<Props> = ({ post, onSave }) => {
   const [disabled, setDisabled] = useState (false)
-  const [duration, setDuration] = useState<string> (videoMsToDurationValue (post.videoMs))
   const { baseErrors, fieldErrors, clearValidationErrors, applyValidationError } =
       useValidationErrors<PostFormField> ()
   const [originalCreatedBefore, setOriginalCreatedBefore] =
@@ -64,10 +52,6 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
   const [tags, setTags] = useState<string> ('')
   const [title, setTitle] = useState (post.title)
 
-  const videoFlg =
-      useMemo (() => tags.split (/\s+/).some (tag => tag.replace (/\[.*\]$/, '') === '動画'),
-	       [tags])
-
   const dialogue = useDialogue ()
 
   const update = async (...args: Parameters<typeof updatePost>) => {
@@ -79,7 +63,6 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
       onSave ({ ...post,
 		versionNo:              data.versionNo,
 		title:                  data.title,
-		videoMs:                data.videoMs,
 		tags:                   data.tags,
 		parentPosts:            data.parentPosts,
 		childPosts:             data.childPosts,
@@ -119,7 +102,6 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
 	{
 	  // TODO: 差分 UI
 	  await update ({ id: post.id, title, tags, parentPostIds,
-			  duration: videoFlg ? duration : null,
 			  originalCreatedFrom, originalCreatedBefore },
 			{ baseVersionNo: post.versionNo, merge: true })
 	  return
@@ -128,7 +110,6 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
       if (action === 'overwrite')
 	{
 	  await update ({ id: post.id, title, tags, parentPostIds,
-			  duration: videoFlg ? duration : null,
 			  originalCreatedFrom, originalCreatedBefore },
 			{ baseVersionNo: post.versionNo, force: true })
 	  return
@@ -143,7 +124,6 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
     try
     {
       await update ({ id: post.id, title, tags, parentPostIds,
-		      duration: videoFlg ? duration : null,
 		      originalCreatedFrom, originalCreatedBefore },
 		    { baseVersionNo: post.versionNo })
     }
@@ -154,28 +134,39 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
   }
 
   useEffect (() => {
-    setTags (tagsToStr (post.tags))
+    setTags(tagsToStr (post.tags))
-    setDuration (videoMsToDurationValue (post.videoMs))
   }, [post])
 
   return (
       <form onSubmit={handleSubmit} className="max-w-xl pt-2 space-y-4">
 	<FieldError messages={baseErrors}/>
 
-	<PostTextField
+	{/* タイトル */}
-	    label="タイトル"
+	<FormField label="タイトル">
-	    value={title ?? ''}
+	  {({ invalid }) => (
-	    disabled={disabled}
+	      <input
-	    onChange={setTitle}/>
+		  type="text"
+		  disabled={disabled}
+		  className={inputClass (invalid)}
+		  value={title ?? ''}
+		  onChange={ev => setTitle (ev.target.value)}/>)}
+	</FormField>
 
-	<PostTextField
+	{/* 親投稿 */}
-	    label="親投稿"
+	<FormField label="親投稿" messages={fieldErrors.parentPostIds}>
-	    value={parentPostIds}
+	  {({ describedBy, invalid }) => (
-	    disabled={disabled}
+	      <input
-	    errors={fieldErrors.parentPostIds}
+		  type="text"
-	    onChange={setParentPostIds}/>
+		  disabled={disabled}
+		  value={parentPostIds}
+		  onChange={e => setParentPostIds (e.target.value)}
+		  aria-describedby={describedBy}
+		  aria-invalid={invalid}
+		  className={inputClass (invalid)}/>)}
+	</FormField>
 
-	<PostTagsField
+	{/* タグ */}
+	<PostFormTagsArea
 	    disabled={disabled}
 	    tags={tags}
 	    setTags={setTags}
@@ -188,17 +179,7 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
 	    setOriginalCreatedFrom={setOriginalCreatedFrom}
 	    originalCreatedBefore={originalCreatedBefore}
 	    setOriginalCreatedBefore={setOriginalCreatedBefore}
-	    errors={groupedMessages (
+	    errors={fieldErrors.originalCreatedAt}/>
-		fieldErrors.originalCreatedAt,
-		fieldErrors.originalCreatedFrom,
-		fieldErrors.originalCreatedBefore)}/>
-
-	{videoFlg && (
-	    <PostDurationField
-		value={duration}
-		disabled={disabled}
-		errors={fieldErrors.videoMs}
-		onChange={setDuration}/>)}
 
 	{/* 送信 */}
 	<Button type="submit" disabled={disabled}>
@@ -207,5 +188,4 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
       </form>)
 }
 
-
 export default PostEditForm

frontend/src/components/PostEmbed.tsx

@@ -4,8 +4,6 @@ import YoutubeEmbed from 'react-youtube'
 import NicoViewer from '@/components/NicoViewer'
 import TwitterEmbed from '@/components/TwitterEmbed'
 import { useDialogue } from '@/components/dialogues/DialogueProvider'
-import { Button } from '@/components/ui/button'
-import { useClientBehaviourSettings } from '@/lib/useClientBehaviourSettings'
 
 import type { FC, RefObject } from 'react'
 
@@ -26,19 +24,16 @@ type Props = {
     onError?:           (data: unknown) => void }
 
 
-const PostEmbed: FC<Props> = (
+const PostEmbed: FC<Props> = ({
-    { ref,
+    ref,
-      post,
+    post,
-      onLoadComplete,
+    onLoadComplete,
-      onMetadataChange,
+    onMetadataChange,
-      onVideoReady,
+    onVideoReady,
-      onPlaybackChange,
+    onPlaybackChange,
-      onError },
+    onError,
-) => {
+}) => {
   const dialogue = useDialogue ()
-  const behaviourSettings = useClientBehaviourSettings ()
-  const embedAutoLoadMode = behaviourSettings.embedAutoLoad ?? 'auto'
-  const [manualLoadRequested, setManualLoadRequested] = useState (false)
   const [framed, setFramed] = useState (false)
   const [youtubePlayer, setYoutubePlayer] = useState<YouTubePlayer | null> (null)
   const niconicoVideoReadyRef = useRef (false)
@@ -110,10 +105,6 @@ const PostEmbed: FC<Props> = (
     niconicoVideoReadyRef.current = false
   }, [post.url])
 
-  useEffect (() => {
-    setManualLoadRequested (false)
-  }, [embedAutoLoadMode, post.url])
-
   useEffect (() => {
     if (!(youtubePlayer) || !(onPlaybackChange))
       return
@@ -126,28 +117,6 @@ const PostEmbed: FC<Props> = (
   }, [onPlaybackChange, reportYoutubePlayback, youtubePlayer])
 
   const url = new URL (post.url)
-  const shouldLoadEmbed =
-      embedAutoLoadMode === 'auto'
-      || (
-	  embedAutoLoadMode === 'manual'
-	  && manualLoadRequested
-      )
-
-  const externalLink = (
-      <a href={post.url} target="_blank" rel="noreferrer">
-	外部ページを開く
-      </a>)
-
-  const manualLoadControl = (
-      <div className="flex flex-wrap items-center gap-3">
-	<Button
-	    type="button"
-	    variant="outline"
-	    onClick={() => setManualLoadRequested (true)}>
-	  埋め込みを読込
-	</Button>
-	{externalLink}
-      </div>)
 
   switch (url.hostname.split ('.').slice (-2).join ('.'))
   {
@@ -159,11 +128,6 @@ const PostEmbed: FC<Props> = (
 
       const [videoId] = mVideoId
 
-      if (embedAutoLoadMode === 'off')
-	return externalLink
-      if (shouldLoadEmbed === false)
-	return manualLoadControl
-
       return (
 	  <NicoViewer
 	      ref={ref}
@@ -186,11 +150,6 @@ const PostEmbed: FC<Props> = (
       const [userId] = mUserId
       const [statusId] = mStatusId
 
-      if (embedAutoLoadMode === 'off')
-	return externalLink
-      if (shouldLoadEmbed === false)
-	return manualLoadControl
-
       return <TwitterEmbed userId={userId} statusId={statusId}/>
     }
 
@@ -200,11 +159,6 @@ const PostEmbed: FC<Props> = (
       if (!(videoId))
 	break
 
-      if (embedAutoLoadMode === 'off')
-	return externalLink
-      if (shouldLoadEmbed === false)
-	return manualLoadControl
-
       return (
 	  <YoutubeEmbed videoId={videoId} opts={{ playerVars: {
 	      playsinline:  1,
@@ -230,11 +184,6 @@ const PostEmbed: FC<Props> = (
 		height={360}/>)
 	 : (
 	    <div>
-	      {embedAutoLoadMode === 'off'
-	       ? externalLink
-	       : embedAutoLoadMode === 'manual' && shouldLoadEmbed === false
-		 ? manualLoadControl
-		 : (
 	      <a href="#" onClick={async e => {
 		e.preventDefault ()
 
@@ -248,7 +197,7 @@ const PostEmbed: FC<Props> = (
 		    confirmText: '表示' }))
 	      }}>
 		外部ページを表示
-	      </a>)}
+	      </a>
 	    </div>)}
       </>)
 }

frontend/src/components/PostFormTagsArea.tsx

@@ -68,12 +68,9 @@ const PostFormTagsArea: FC<Props> = ({ tags, setTags, errors, ...rest }) => {
 
     setBounds ({ start, end })
 
-    const data = await apiGet<Tag[]> ('/tags/autocomplete', { params: {
+    const data = await apiGet<Tag[]> ('/tags/autocomplete', { params: { q: token, nico: '0' } })
-	q: token,
+    setSuggestions (data.filter (t => t.postCount > 0))
-	nico: '0' } })
+    setSuggestionsVsbl (suggestions.length > 0)
-    const nextSuggestions = data.filter (t => t.postCount > 0)
-    setSuggestions (nextSuggestions)
-    setSuggestionsVsbl (nextSuggestions.length > 0)
   }
 
   return (

frontend/src/components/PostList.tsx

@@ -3,7 +3,6 @@ import { useRef } from 'react'
 import { useLocation } from 'react-router-dom'
 
 import PrefetchLink from '@/components/PrefetchLink'
-import { useClientBehaviourSettings } from '@/lib/useClientBehaviourSettings'
 import { cn } from '@/lib/utils'
 import { useSharedTransitionStore } from '@/stores/sharedTransitionStore'
 
@@ -17,15 +16,6 @@ type Props = { posts:     Post[]
 
 const PostList: FC<Props> = ({ posts, onClick }) => {
   const location = useLocation ()
-  const behaviourSettings = useClientBehaviourSettings ()
-  const thumbnailMode = behaviourSettings.thumbnailMode ?? 'normal'
-  const animationMode = behaviourSettings.animation ?? 'normal'
-  const cardLayoutTransition =
-      animationMode === 'off'
-      ? { duration: 0 }
-      : animationMode === 'reduced'
-	? { duration: .08, ease: 'linear' as const }
-	: { duration: .2, ease: 'easeOut' as const }
 
   const setForLocationKey = useSharedTransitionStore (s => s.setForLocationKey)
 
@@ -49,8 +39,7 @@ const PostList: FC<Props> = ({ posts, onClick }) => {
 		  }}>
 		<motion.div
 		    ref={cardRef}
-		    layout={animationMode === 'off' ? false : true}
+		    layoutId={layoutId}
-		    layoutId={animationMode === 'off' ? undefined : layoutId}
 		    className={cn ('w-full h-full overflow-hidden rounded-xl shadow',
 				   'transform-gpu will-change-transform',
 				   (post.childPosts ?? []).length > 0 && 'ring-4 ring-green-500',
@@ -65,36 +54,22 @@ const PostList: FC<Props> = ({ posts, onClick }) => {
 		    }}
 		    onLayoutAnimationComplete={() => {
 		      if (!(cardRef.current))
-			return
+			return 
 
 		      cardRef.current.style.zIndex = ''
 		      cardRef.current.style.position = ''
 		    }}
-		    transition={{ layout: cardLayoutTransition }}>
+		    transition={{ layout: { duration: .2, ease: 'easeOut' } }}>
-		  {thumbnailMode === 'off'
+		  <img src={post.thumbnail || post.thumbnailBase || undefined}
-		   ? (
+		       alt={post.title || post.url}
-		      <div className="flex h-full w-full items-center justify-center
+		       title={post.title || post.url || undefined}
-				      bg-muted text-center text-xs text-muted-foreground">
+		       loading={i < 12 ? 'eager' : 'lazy'}
-			サムネイルなし
+		       decoding="async"
-		      </div>)
+		       className="object-cover w-full h-full"/>
-		   : (
-		      <img
-			  src={post.thumbnail || post.thumbnailBase || undefined}
-			  alt={post.title || post.url}
-			  title={post.title || post.url || undefined}
-			  loading={
-			      thumbnailMode === 'light'
-			      ? 'lazy'
-			      : i < 12
-				? 'eager'
-				: 'lazy'
-			  }
-			  decoding="async"
-			  className="object-cover w-full h-full"/>)}
 		</motion.div>
 	      </PrefetchLink>)
 	})}
       </div>)
 }
 
-export default PostList
+export default PostList

frontend/src/components/PostOriginalCreatedTimeField.test.tsx

@@ -20,10 +20,8 @@ describe ('PostOriginalCreatedTimeField', () => {
     fireEvent.change (inputs[0], { target: { value: '2026-01-02T03:04' } })
     fireEvent.change (inputs[1], { target: { value: '2026-01-03T03:04' } })
 
-    expect (setFrom).toHaveBeenCalledWith (expect.stringMatching (
+    expect (setFrom).toHaveBeenCalledWith (expect.any (String))
-	/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/))
+    expect (setBefore).toHaveBeenCalledWith (expect.any (String))
-    expect (setBefore).toHaveBeenCalledWith (expect.stringMatching (
-	/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/))
   })
 
   it ('infers an exclusive before value on blur', () => {
@@ -40,43 +38,7 @@ describe ('PostOriginalCreatedTimeField', () => {
     const input = screen.getAllByDisplayValue ('')[0]
     fireEvent.blur (input, { target: { value: '2026-01-02T03:04' } })
 
-    const value = setBefore.mock.calls.at (-1)?.[0]
+    expect (setBefore).toHaveBeenCalledWith (expect.any (String))
-    expect (value).toMatch (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/)
-    expect (new Date (value).getTime () - new Date ('2026-01-02T03:04').getTime ())
-	.toBe (60_000)
-  })
-
-  it ('does not rewrite mounted values that only differ by offset notation', () => {
-    const setFrom = vi.fn ()
-    const setBefore = vi.fn ()
-
-    render (
-        <PostOriginalCreatedTimeField
-            originalCreatedFrom="2024-01-01T12:34+09:00"
-            setOriginalCreatedFrom={setFrom}
-            originalCreatedBefore="2024-01-01T12:35+09:00"
-            setOriginalCreatedBefore={setBefore}/>,
-    )
-
-    expect (setFrom).not.toHaveBeenCalled ()
-    expect (setBefore).not.toHaveBeenCalled ()
-  })
-
-  it ('emits minute-precision UTC values only when the user edits the input', () => {
-    const setFrom = vi.fn ()
-
-    render (
-        <PostOriginalCreatedTimeField
-            originalCreatedFrom="2024-01-01T12:34+09:00"
-            setOriginalCreatedFrom={setFrom}
-            originalCreatedBefore={null}
-            setOriginalCreatedBefore={vi.fn ()}/>,
-    )
-
-    const input = screen.getByDisplayValue ('2024-01-01T12:34')
-    fireEvent.change (input, { target: { value: '2024-01-01T12:35' } })
-
-    expect (setFrom).toHaveBeenCalledWith ('2024-01-01T03:35Z')
   })
 
   it ('resets both values', () => {

frontend/src/components/PostOriginalCreatedTimeField.tsx

@@ -1,4 +1,4 @@
-import DateTimeField, { toMinutePrecisionIsoUtc } from '@/components/common/DateTimeField'
+import DateTimeField from '@/components/common/DateTimeField'
 import FormField from '@/components/common/FormField'
 import { Button } from '@/components/ui/button'
 
@@ -19,74 +19,70 @@ const PostOriginalCreatedTimeField: FC<Props> = (
       setOriginalCreatedFrom,
       originalCreatedBefore,
       setOriginalCreatedBefore,
-      errors }: Props) => {
+      errors }: Props) => (
-  return (
+    <FormField label="オリジナルの作成日時" messages={errors}>
-      <FormField label="オリジナルの作成日時" messages={errors}>
+      {({ describedBy, invalid }) => (
-	  {({ describedBy, invalid }) => (
+	  <>
-	      <>
+	    <div className="my-1 flex">
-		<div className="my-1 flex">
+	      <div className="w-80">
-		  <div className="w-80">
+		<DateTimeField
-		    <DateTimeField
+		    className="mr-2"
-			className="mr-2"
+		    disabled={disabled ?? false}
-			disabled={disabled ?? false}
+		    aria-describedby={describedBy}
-			aria-describedby={describedBy}
+		    aria-invalid={invalid}
-			aria-invalid={invalid}
+		    invalid={invalid}
-			invalid={invalid}
+		    value={originalCreatedFrom ?? undefined}
-			value={originalCreatedFrom ?? undefined}
+		    onChange={setOriginalCreatedFrom}
-			onChange={setOriginalCreatedFrom}
+		    onBlur={ev => {
-			onBlur={ev => {
+		      const v = ev.target.value
-			  const v = ev.target.value
+		      if (!(v))
-			  if (!(v))
+			return
-			    return
 
-			  const d = new Date (v)
+		      const d = new Date (v)
-			  if (d.getMinutes () === 0 && d.getHours () === 0)
+		      if (d.getMinutes () === 0 && d.getHours () === 0)
-			    d.setDate (d.getDate () + 1)
+			d.setDate (d.getDate () + 1)
-			  else
+		      else
-			    d.setMinutes (d.getMinutes () + 1)
+			d.setMinutes (d.getMinutes () + 1)
-			  setOriginalCreatedBefore (toMinutePrecisionIsoUtc (d.toISOString ()))
+		      setOriginalCreatedBefore (d.toISOString ())
-			}}/>
+		    }}/>
-		    以降
+		以降
-		  </div>
+	      </div>
-		  <div>
+	      <div>
-		    <Button
+		<Button
-			type="button"
+		    className="bg-gray-600 text-white rounded"
-			className="bg-gray-600 text-white rounded"
+		    disabled={disabled}
-			disabled={disabled}
+		    onClick={() => {
-			onClick={() => {
+		      setOriginalCreatedFrom (null)
-			  setOriginalCreatedFrom (null)
+		    }}>
-			}}>
+		  リセット
-		      リセット
+		</Button>
-		    </Button>
+	      </div>
-		  </div>
+	    </div>
-		</div>
 
-		<div className="my-1 flex">
+	    <div className="my-1 flex">
-		  <div className="w-80">
+	      <div className="w-80">
-		    <DateTimeField
+		<DateTimeField
-			className="mr-2"
+		    className="mr-2"
-			disabled={disabled}
+		    disabled={disabled}
-			aria-describedby={describedBy}
+		    aria-describedby={describedBy}
-			aria-invalid={invalid}
+		    aria-invalid={invalid}
-			invalid={invalid}
+		    invalid={invalid}
-			value={originalCreatedBefore ?? undefined}
+		    value={originalCreatedBefore ?? undefined}
-			onChange={setOriginalCreatedBefore}/>
+		    onChange={setOriginalCreatedBefore}/>
-		    より前
+		より前
-		  </div>
+	      </div>
-		  <div>
+	      <div>
-		    <Button
+		<Button
-			type="button"
+		    className="bg-gray-600 text-white rounded"
-			className="bg-gray-600 text-white rounded"
+		    disabled={disabled}
-			disabled={disabled}
+		    onClick={() => {
-			onClick={() => {
+		      setOriginalCreatedBefore (null)
-			  setOriginalCreatedBefore (null)
+		    }}>
-			}}>
+		  リセット
-		      リセット
+		</Button>
-		    </Button>
+	      </div>
-		  </div>
+	    </div>
-		</div>
+	  </>)}
-	      </>)}
+    </FormField>)
-      </FormField>)
-}
 
 export default PostOriginalCreatedTimeField

frontend/src/components/PrefetchLink.tsx

@@ -5,7 +5,6 @@ import { createPath, useNavigate } from 'react-router-dom'
 
 import { useOverlayStore } from '@/components/RouteBlockerOverlay'
 import { prefetchForURL } from '@/lib/prefetchers'
-import { useClientBehaviourSettings } from '@/lib/useClientBehaviourSettings'
 import { cn } from '@/lib/utils'
 
 import type { AnchorHTMLAttributes, MouseEvent, TouchEvent } from 'react'
@@ -34,15 +33,10 @@ export default forwardRef<HTMLAnchorElement, Props> (({
 
   const navigate = useNavigate ()
   const qc = useQueryClient ()
-  const behaviourSettings = useClientBehaviourSettings ()
-  const linkPreloadMode = behaviourSettings.linkPreload ?? 'intent'
-  const path = useMemo (
-      () => typeof to === 'string' ? to : createPath (to),
-      [to],
-  )
   const url = useMemo (() => {
-    return (new URL (path, window.location.origin)).toString ()
+    const path = (typeof to === 'string') ? to : createPath (to)
-  }, [path])
+    return (new URL (path, location.origin)).toString ()
+  }, [to])
   const setOverlay = useOverlayStore (s => s.setActive)
 
   const doPrefetch = async () => {
@@ -60,15 +54,11 @@ export default forwardRef<HTMLAnchorElement, Props> (({
 
   const handleMouseEnter = async (ev: MouseEvent<HTMLAnchorElement>) => {
     onMouseEnter?.(ev)
-    if (ev.defaultPrevented || linkPreloadMode !== 'intent')
-      return
     await doPrefetch ()
   }
 
   const handleTouchStart = async (ev: TouchEvent<HTMLAnchorElement>) => {
     onTouchStart?.(ev)
-    if (ev.defaultPrevented || linkPreloadMode !== 'intent')
-      return
     await doPrefetch ()
   }
 
@@ -109,7 +99,7 @@ export default forwardRef<HTMLAnchorElement, Props> (({
 
   return (
       <a ref={ref}
-	 href={path}
+	 href={typeof to === 'string' ? to : createPath (to)}
 	 onMouseEnter={handleMouseEnter}
 	 onTouchStart={handleTouchStart}
 	 onClick={handleClick}

frontend/src/components/ResponsiveMarqueeText.tsx

@@ -1,254 +0,0 @@
-import { useClientBehaviourSettings } from '@/lib/useClientBehaviourSettings'
-import { cn } from '@/lib/utils'
-import { useEffect, useRef, useState } from 'react'
-
-import type { FC } from 'react'
-
-type Props = {
-    text:      string
-    className?: string
-    truncateOnMobile?: boolean
-    title?:    string }
-
-const DESKTOP_MARQUEE_MEDIA =
-    '(min-width: 768px) and (hover: hover) and (pointer: fine) and (prefers-reduced-motion: no-preference)'
-const MARQUEE_START_DELAY_MS = 1600
-const MARQUEE_END_HOLD_MS = 2400
-const MARQUEE_SCROLL_PX_PER_SECOND = 43
-const MIN_MARQUEE_OVERFLOW_PX = 1
-
-
-const ResponsiveMarqueeText: FC<Props> = (
-    { text, className, truncateOnMobile = false, title },
-) => {
-  const behaviourSettings = useClientBehaviourSettings ()
-  const animationMode = behaviourSettings.animation ?? 'normal'
-  const outerRef = useRef<HTMLSpanElement | null> (null)
-  const staticRef = useRef<HTMLSpanElement | null> (null)
-  const animatedRef = useRef<HTMLSpanElement | null> (null)
-  const animationRef = useRef<Animation | null> (null)
-  const timeoutRef = useRef<number | null> (null)
-  const rafRef = useRef<number | null> (null)
-  const [overflowPx, setOverflowPx] = useState (0)
-  const [desktopMarqueeEnabled, setDesktopMarqueeEnabled] = useState (false)
-  const [active, setActive] = useState (false)
-  const [marqueeVisible, setMarqueeVisible] = useState (false)
-
-  useEffect (() => {
-    const outer = outerRef.current
-    const inner = staticRef.current
-
-    if (!(outer) || !(inner))
-      return
-
-    const measure = () => {
-      const nextOverflow = Math.max (0, Math.ceil (inner.scrollWidth - outer.clientWidth))
-      setOverflowPx (prev => Math.abs (prev - nextOverflow) <= 1 ? prev : nextOverflow)
-    }
-
-    measure ()
-
-    const resizeObserver =
-	typeof ResizeObserver === 'undefined'
-	? null
-	: new ResizeObserver (() => {
-	    measure ()
-	  })
-
-    resizeObserver?.observe (outer)
-    resizeObserver?.observe (inner)
-    addEventListener ('resize', measure)
-
-    return () => {
-      resizeObserver?.disconnect ()
-      removeEventListener ('resize', measure)
-    }
-  }, [text])
-
-  useEffect (() => {
-    if (typeof window === 'undefined' || typeof window.matchMedia !== 'function')
-      return
-
-    const media = window.matchMedia (DESKTOP_MARQUEE_MEDIA)
-    const update = () => {
-      setDesktopMarqueeEnabled (media.matches)
-    }
-
-    update ()
-    media.addEventListener ('change', update)
-
-    return () => {
-      media.removeEventListener ('change', update)
-    }
-  }, [])
-
-  useEffect (() => {
-    const clearScheduled = () => {
-      if (timeoutRef.current != null)
-        {
-          clearTimeout (timeoutRef.current)
-          timeoutRef.current = null
-        }
-      if (rafRef.current != null)
-        {
-          cancelAnimationFrame (rafRef.current)
-          rafRef.current = null
-        }
-      animationRef.current?.cancel ()
-      animationRef.current = null
-    }
-
-    const animated = animatedRef.current
-    const canMarquee = (
-        active
-        && animationMode !== 'off'
-        && desktopMarqueeEnabled
-        && overflowPx >= MIN_MARQUEE_OVERFLOW_PX
-        && animated != null)
-
-    const resetAnimated = () => {
-      const node = animatedRef.current
-
-      animationRef.current?.cancel ()
-      animationRef.current = null
-      node?.getAnimations?.().forEach (animation => {
-        animation.cancel ()
-      })
-
-      if (!(node))
-        return
-
-      node.style.transition = 'none'
-      node.style.transform = 'translateX(0)'
-    }
-
-    if (!canMarquee)
-      {
-        clearScheduled ()
-        resetAnimated ()
-        setMarqueeVisible (false)
-        return
-      }
-
-    let cancelled = false
-
-    const sleep = (ms: number) =>
-	new Promise<void> (resolve => {
-	  timeoutRef.current = window.setTimeout (() => {
-	    timeoutRef.current = null
-	    resolve ()
-	  }, ms)
-	})
-
-    const runLoop = async () => {
-      while (!cancelled)
-        {
-          resetAnimated ()
-          setMarqueeVisible (true)
-
-          await sleep (MARQUEE_START_DELAY_MS)
-          if (cancelled || !(animatedRef.current))
-            break
-
-          const moveDurationMs =
-	      overflowPx / MARQUEE_SCROLL_PX_PER_SECOND * 1000
-          const node = animatedRef.current
-
-          if (typeof node.animate === 'function')
-            {
-              const animation = node.animate (
-		  [
-		    { transform: 'translateX(0)' },
-		    { transform: `translateX(-${ overflowPx }px)` },
-		  ],
-		  { duration: moveDurationMs, easing: 'linear', fill: 'forwards' })
-              animationRef.current = animation
-              try
-              {
-                await animation.finished
-              }
-              catch
-              {
-                break
-              }
-
-              node.style.transform = `translateX(-${ overflowPx }px)`
-              animation.cancel ()
-              if (animationRef.current === animation)
-                animationRef.current = null
-            }
-          else
-            {
-              node.style.transition = `transform ${ moveDurationMs }ms linear`
-              await new Promise<void> (resolve => {
-                rafRef.current = requestAnimationFrame (() => {
-                  rafRef.current = null
-                  node.style.transform = `translateX(-${ overflowPx }px)`
-                  resolve ()
-                })
-              })
-              await sleep (moveDurationMs)
-              node.style.transition = 'none'
-              node.style.transform = `translateX(-${ overflowPx }px)`
-            }
-
-          if (cancelled)
-            break
-
-          await sleep (MARQUEE_END_HOLD_MS)
-          if (cancelled)
-            break
-
-          resetAnimated ()
-        }
-    }
-
-    void runLoop ()
-
-    return () => {
-      cancelled = true
-      clearScheduled ()
-      resetAnimated ()
-      setMarqueeVisible (false)
-    }
-  }, [active, animationMode, desktopMarqueeEnabled, overflowPx, text])
-
-  return (
-      <span
-	  ref={outerRef}
-	  title={title ?? text}
-	  onMouseEnter={() => setActive (true)}
-	  onMouseLeave={() => setActive (false)}
-	  onFocus={() => setActive (true)}
-	  onBlur={() => setActive (false)}
-	  className={cn (
-	      'tag-marquee inline-block max-w-full min-w-0 align-bottom',
-	      (truncateOnMobile
-	       ? 'overflow-hidden text-ellipsis whitespace-nowrap'
-	       : 'whitespace-normal [overflow-wrap:anywhere]'),
-	      'md:overflow-hidden md:whitespace-nowrap',
-	      className)}>
-	<span
-	    ref={staticRef}
-	    className={cn (
-		'tag-marquee__static block max-w-full',
-		(truncateOnMobile
-		 ? 'overflow-hidden text-ellipsis whitespace-nowrap'
-		 : 'whitespace-normal [overflow-wrap:anywhere]'),
-		'md:overflow-hidden md:text-ellipsis md:whitespace-nowrap',
-		marqueeVisible && 'md:opacity-0')}>
-	  {text}
-	</span>
-	{overflowPx >= MIN_MARQUEE_OVERFLOW_PX && (
-	    <span
-		ref={animatedRef}
-		aria-hidden="true"
-		className={cn (
-		    'tag-marquee__animated hidden md:block',
-		    marqueeVisible ? 'md:opacity-100' : 'md:opacity-0')}>
-	      {text}
-	    </span>)}
-      </span>)
-}
-
-export default ResponsiveMarqueeText

frontend/src/components/TagDetailSidebar.tsx

@@ -1,13 +1,11 @@
 import { DndContext,
 	 DragOverlay,
-	 MeasuringStrategy,
 	 MouseSensor,
 	 TouchSensor,
-	 pointerWithin,
 	 useDroppable,
 	 useSensor,
 	 useSensors } from '@dnd-kit/core'
-import { restrictToWindowEdges, snapCenterToCursor } from '@dnd-kit/modifiers'
+import { restrictToWindowEdges } from '@dnd-kit/modifiers'
 import { useQueryClient } from '@tanstack/react-query'
 import { motion } from 'framer-motion'
 import { useEffect, useMemo, useRef, useState } from 'react'
@@ -22,29 +20,19 @@ import SidebarComponent from '@/components/layout/SidebarComponent'
 import { toast } from '@/components/ui/use-toast'
 import { CATEGORIES, CATEGORY_NAMES } from '@/consts'
 import { apiDelete, apiGet, apiPatch, apiPost } from '@/lib/api'
-import { clientAnimationTransition } from '@/lib/clientAnimation'
 import { postsKeys, tagsKeys } from '@/lib/queryKeys'
-import { useClientBehaviourSettings } from '@/lib/useClientBehaviourSettings'
 import { dateString, originalCreatedAtString } from '@/lib/utils'
 
-import type { CollisionDetection, DragEndEvent } from '@dnd-kit/core'
+import type { DragEndEvent } from '@dnd-kit/core'
 import type { FC, MutableRefObject, ReactNode } from 'react'
 
-import type { Category, Post, TagWithSections } from '@/types'
+import type { Category, Post, Tag } from '@/types'
 
-type TagByCategory = { [key in Category]: TagWithSections[] }
+type TagByCategory = { [key in Category]: Tag[] }
-
-const tagCollisionDetection: CollisionDetection = args => {
-  return pointerWithin (args)
-}
-
-const alwaysMeasureDroppables = {
-    droppable: { strategy: MeasuringStrategy.Always } } as const
 
 
 const renderTagTree = (
-    activeDndId:       string | undefined,
+    tag:              Tag,
-    tag:              TagWithSections,
     nestLevel:        number,
     path:             string,
     suppressClickRef: MutableRefObject<boolean>,
@@ -55,7 +43,6 @@ const renderTagTree = (
   const self = (
       <li key={key} className="mb-1">
 	<DraggableDroppableTagRow
-	    activeDndId={activeDndId}
 	    tag={tag}
 	    nestLevel={nestLevel}
 	    pathKey={key}
@@ -69,21 +56,14 @@ const renderTagTree = (
       ...((tag.children
 	   ?.sort ((a, b) => a.name < b.name ? -1 : 1)
 	   .flatMap (child =>
-	      renderTagTree (
+	      renderTagTree (child, nestLevel + 1, key, suppressClickRef, tag.id, sp)))
-		  activeDndId,
-		  child,
-		  nestLevel + 1,
-		  key,
-		  suppressClickRef,
-		  tag.id,
-		  sp)))
 	  ?? [])]
 }
 
+
 const isDescendant = (
-    root:     TagWithSections,
+    root:     Tag,
-    targetId: number,
+    targetId: number): boolean => {
-): boolean => {
   if (!(root.children))
     return false
 
@@ -101,9 +81,8 @@ const isDescendant = (
 
 const findTag = (
     byCat:  TagByCategory,
-    id:     number,
+    id:     number): Tag | undefined => {
-): TagWithSections | undefined => {
+  const walk = (nodes: Tag[]): Tag | undefined => {
-  const walk = (nodes: TagWithSections[]): TagWithSections | undefined => {
     for (const t of nodes)
       {
 	if (t.id === id)
@@ -146,37 +125,6 @@ const buildTagByCategory = (post: Post): TagByCategory => {
 }
 
 
-const buildFlatTagByCategory = (
-    byCategory: TagByCategory,
-): TagByCategory => {
-  const tagsTmp = { } as TagByCategory
-  const seen = new Set<number> ()
-
-  for (const category of CATEGORIES)
-    tagsTmp[category] = []
-
-  const visit = (tag: TagWithSections) => {
-    if (seen.has (tag.id))
-      return
-
-    seen.add (tag.id)
-    tagsTmp[tag.category].push ({ ...tag, children: [] })
-
-    for (const child of tag.children ?? [])
-      visit (child)
-  }
-
-  for (const category of CATEGORIES)
-    for (const tag of byCategory[category] ?? [])
-      visit (tag)
-
-  for (const category of CATEGORIES)
-    tagsTmp[category].sort ((tagA, tagB) => tagA.name < tagB.name ? -1 : 1)
-
-  return tagsTmp
-}
-
-
 const changeCategory = async (
     tagId:    number,
     category: Category): Promise<void> => {
@@ -195,47 +143,14 @@ const DropSlot = ({ cat }: { cat: Category }) => {
       </li>)
 }
 
-const EmptyCategoryDropSection = (
-    { cat, children }: { cat: Category
-			 children: ReactNode }) => {
-  const { setNodeRef, isOver: over } = useDroppable ({
-      id:   `slot:${ cat }`,
-      data: { kind: 'slot', cat } })
 
-  return (
+type Props = { post: Post; sp?: boolean }
-      <div ref={setNodeRef} className="my-3">
-	{children}
-	<ul>
-	  <li className="h-1">
-	    {over && <div className="h-0.5 w-full rounded bg-sky-400"/>}
-	  </li>
-	</ul>
-      </div>)
-}
 
 
-type Props = {
+const TagDetailSidebar: FC<Props> = ({ post, sp }) => {
-    className?: string
-    post:       Post
-    sp?:        boolean }
-
-type ActiveTagDrag = {
-    dndId:       string
-    tagId:      number
-    nestLevel:  number }
-
-
-const TagDetailSidebar: FC<Props> = ({ className, post, sp }) => {
   sp = Boolean (sp)
 
   const qc = useQueryClient ()
-  const behaviourSettings = useClientBehaviourSettings ()
-  const tagRelationDisplay = behaviourSettings.tagRelationDisplay ?? 'grouped'
-  const animationMode = behaviourSettings.animation ?? 'normal'
-  const layoutTransition = clientAnimationTransition (
-      animationMode,
-      { normal: { duration: .2, ease: 'easeOut' as const } },
-  )
 
   const baseTags = useMemo<TagByCategory> (() => {
     const tagsTmp = { } as TagByCategory
@@ -248,20 +163,15 @@ const TagDetailSidebar: FC<Props> = ({ className, post, sp }) => {
       }
 
     for (const cat of Object.keys (tagsTmp) as (keyof typeof tagsTmp)[])
-      tagsTmp[cat].sort ((tagA: TagWithSections, tagB: TagWithSections) => tagA.name < tagB.name ? -1 : 1)
+      tagsTmp[cat].sort ((tagA: Tag, tagB: Tag) => tagA.name < tagB.name ? -1 : 1)
 
     return tagsTmp
   }, [post])
 
-  const [activeTagDrag, setActiveTagDrag] = useState<ActiveTagDrag | null> (null)
+  const [activeTagId, setActiveTagId] = useState<number | null> (null)
   const [dragging, setDragging] = useState (false)
   const [saving, setSaving] = useState (false)
   const [tags, setTags] = useState (baseTags)
-  const flatTagsByCategory = useMemo<TagByCategory> (
-      () => buildFlatTagByCategory (tags),
-      [tags],
-  )
-  const activeDndId = activeTagDrag?.dndId
 
   const suppressClickRef = useRef (false)
 
@@ -366,23 +276,13 @@ const TagDetailSidebar: FC<Props> = ({ className, post, sp }) => {
   }, [baseTags])
 
   return (
-      <SidebarComponent sidebarKey="post-detail-tags" className={className}>
+      <SidebarComponent>
 	<TagSearch/>
 	<DndContext
 	    sensors={sensors}
-	    collisionDetection={tagCollisionDetection}
-	    measuring={alwaysMeasureDroppables}
 	    onDragStart={e => {
 	      if (e.active.data.current?.kind === 'tag')
-		{
+		setActiveTagId (e.active.data.current?.tagId ?? null)
-		  const tagId = e.active.data.current?.tagId
-		  const nestLevel = e.active.data.current?.nestLevel
-		  const dndId = e.active.data.current?.dndId
-		  setActiveTagDrag (
-		      tagId == null || nestLevel == null || dndId == null
-		      ? null
-		      : { dndId, tagId, nestLevel })
-		}
 	      setDragging (true)
 	      suppressClickRef.current = true
 	      document.body.style.userSelect = 'none'
@@ -393,80 +293,38 @@ const TagDetailSidebar: FC<Props> = ({ className, post, sp }) => {
 		suppressClickRef.current = false}, { capture: true, once: true })
 	    }}
 	    onDragCancel={() => {
-	      setActiveTagDrag (null)
+	      setActiveTagId (null)
 	      setDragging (false)
 	      document.body.style.userSelect = ''
 	      suppressClickRef.current = false
 	    }}
 	    onDragEnd={async e => {
-	      setActiveTagDrag (null)
+	      setActiveTagId (null)
 	      setDragging (false)
 	      await onDragEnd (e)
 	      document.body.style.userSelect = ''
 	    }}
 	    modifiers={[restrictToWindowEdges]}>
-	  {CATEGORIES.map ((cat: Category) => {
+	  {CATEGORIES.map ((cat: Category) => ((tags[cat] ?? []).length > 0 || dragging) && (
-	    const categoryTags =
+	      <div className="my-3" key={cat}>
-		tagRelationDisplay === 'grouped'
-		? (tags[cat] ?? [])
-		: (flatTagsByCategory[cat] ?? [])
-
-	    if (!(categoryTags.length > 0 || dragging))
-	      return null
-
-	    const sectionTitle = (
 		<SubsectionTitle>
 		  <motion.div
-		      layoutId={animationMode === 'off'
+		      layoutId={`tag-${ sp ? 'sp-' : '' }${ cat }`}
-			  ? undefined
+		      transition={{ layout: { duration: .2, ease: 'easeOut' } }}>
-			  : `tag-${ sp ? 'sp-' : '' }${ cat }`}
-		      transition={{ layout: layoutTransition }}>
 		    {CATEGORY_NAMES[cat]}
 		  </motion.div>
-		</SubsectionTitle>)
+		</SubsectionTitle>
 
-	    if (!(categoryTags.length > 0))
+		<ul>
-	      return (
+		  {(tags[cat] ?? []).flatMap (tag => (
-		  <EmptyCategoryDropSection cat={cat} key={cat}>
+		      renderTagTree (tag, 0, `cat-${ cat }`, suppressClickRef, undefined, sp)))}
-		    {sectionTitle}
+		  <DropSlot cat={cat}/>
-		  </EmptyCategoryDropSection>)
+		</ul>
-
+	      </div>))}
-	    return (
-		<div className="my-3" key={cat}>
-		  {sectionTitle}
-		  <ul>
-		    {(tagRelationDisplay === 'grouped'
-		      ? (tags[cat] ?? []).flatMap (tag =>
-			    renderTagTree (
-				activeDndId,
-				tag,
-				0,
-				`cat-${ cat }`,
-				suppressClickRef,
-				undefined,
-				sp,
-			    ),
-			)
-		      : (flatTagsByCategory[cat] ?? []).map (tag => (
-			  <li key={`flat-${ cat }-${ tag.id }`} className="mb-1">
-			    <DraggableDroppableTagRow
-				activeDndId={activeDndId}
-				tag={tag}
-				nestLevel={0}
-				pathKey={`flat-${ cat }-${ tag.id }`}
-				suppressClickRef={suppressClickRef}
-				sp={sp}/>
-			  </li>)))}
-		    <DropSlot cat={cat}/>
-		  </ul>
-		</div>)
-	  })}
 	  {post && (
 	      <motion.div
-		  layoutId={animationMode === 'off'
+		  layoutId={`post-info-${ sp }`}
-		      ? undefined
+		  transition={{ layout: { duration: .2, ease: 'easeOut' } }}>
-		      : `post-info-${ sp }`}
-		  transition={{ layout: layoutTransition }}>
 		<SectionTitle>情報</SectionTitle>
 		<ul>
 		  <li>Id.: {post.id}</li>
@@ -503,14 +361,11 @@ const TagDetailSidebar: FC<Props> = ({ className, post, sp }) => {
 		</ul>
 	      </motion.div>)}
 
-	  <DragOverlay
+	  <DragOverlay adjustScale={false}>
-	      adjustScale={false}
-	      modifiers={[snapCenterToCursor]}
-	      dropAnimation={animationMode === 'off' ? null : undefined}>
 	    <div className="pointer-events-none">
-	      {activeTagDrag != null && (() => {
+	      {activeTagId != null && (() => {
-		const tag = findTag (tags, activeTagDrag.tagId)
+		const tag = findTag (tags, activeTagId)
-		return tag && <TagLink tag={tag} nestLevel={activeTagDrag.nestLevel}/>
+		return tag && <TagLink tag={tag}/>
 	      }) ()}
 	    </div>
 	  </DragOverlay>
@@ -518,4 +373,4 @@ const TagDetailSidebar: FC<Props> = ({ className, post, sp }) => {
       </SidebarComponent>)
 }
 
-export default TagDetailSidebar
+export default TagDetailSidebar

frontend/src/components/TagLink.tsx

@@ -1,101 +1,58 @@
 import PrefetchLink from '@/components/PrefetchLink'
-import ResponsiveMarqueeText from '@/components/ResponsiveMarqueeText'
+import { LIGHT_COLOUR_SHADE, DARK_COLOUR_SHADE, TAG_COLOUR } from '@/consts'
 import { cn } from '@/lib/utils'
 
-import type { ComponentProps, CSSProperties, FC, HTMLAttributes } from 'react'
+import type { ComponentProps, FC, HTMLAttributes } from 'react'
 
-import type { Category, Tag } from '@/types'
+import type { Tag } from '@/types'
 
-type LightweightTag = {
+type CommonProps = { 
-    name:     string
-    category: Category }
-
-type FullCommonProps = {
     tag:        Tag
     nestLevel?: number
-    truncateOnMobile?: boolean
     withWiki?:  boolean
     withCount?: boolean }
 
 type PropsWithLink =
-    & FullCommonProps
+    & CommonProps
     & { linkFlg?: true }
     & Partial<ComponentProps<typeof PrefetchLink>>
 
 type PropsWithoutLink =
-    & FullCommonProps
+    & CommonProps
     & { linkFlg: false }
     & Partial<HTMLAttributes<HTMLSpanElement>>
 
-type LightweightPropsWithLink =
-    & {
-	tag:              LightweightTag
-	nestLevel?:       number
-	truncateOnMobile?: boolean
-	withWiki:         false
-	withCount:        false
-	linkFlg?:         true }
-    & Partial<ComponentProps<typeof PrefetchLink>>
-
-type LightweightPropsWithoutLink =
-    & {
-	tag:              LightweightTag
-	nestLevel?:       number
-	truncateOnMobile?: boolean
-	withWiki:         false
-	withCount:        false
-	linkFlg:          false }
-    & Partial<HTMLAttributes<HTMLSpanElement>>
-
 type Props =
     | PropsWithLink
     | PropsWithoutLink
-    | LightweightPropsWithLink
-    | LightweightPropsWithoutLink
-
-const isFullTag = (tag: Tag | LightweightTag): tag is Tag =>
-    'id' in tag
 
 
 const TagLink: FC<Props> = ({ tag,
 			      nestLevel = 0,
 			      linkFlg   = true,
-			      truncateOnMobile = false,
 			      withWiki  = true,
 			      withCount = true,
 			      className,
-			      style,
-			      title,
 			      ...props }) => {
-  const colourStyle = {
+  const spanClass = cn (
-      '--tag-link-colour': `var(--tag-colour-${ tag.category })`,
+      `text-${ TAG_COLOUR[tag.category] }-${ LIGHT_COLOUR_SHADE }`,
-      '--tag-link-hover-colour': `var(--tag-colour-${ tag.category }-hover)`,
+      `dark:text-${ TAG_COLOUR[tag.category] }-${ DARK_COLOUR_SHADE }`)
-      ...style,
+  const linkClass = cn (
-  } as CSSProperties
+      spanClass,
-  const spanClass = 'tag-link-colour'
+      `hover:text-${ TAG_COLOUR[tag.category] }-${ LIGHT_COLOUR_SHADE - 200 }`,
-  const linkClass = 'tag-link-colour tag-link-hover-colour'
+      `dark:hover:text-${ TAG_COLOUR[tag.category] }-${ DARK_COLOUR_SHADE - 200 }`)
-  const textClass = 'group min-w-0 max-w-full overflow-hidden align-bottom'
-  const markerWrapClass = 'shrink-0 self-start md:self-auto'
-  const countClass = 'shrink-0 self-end md:self-auto'
-  const matchedAlias = isFullTag (tag) ? tag.matchedAlias : null
-  const textTitle = title
-      ?? (matchedAlias == null ? tag.name : `${ matchedAlias } → ${ tag.name }`)
 
   return (
-      <span
+      <>
-	  className={cn (
+	{(linkFlg && withWiki) && (
-	      'inline-flex min-w-0 max-w-full flex-nowrap items-stretch align-baseline',
+	    <span className="mr-1">
-	      'gap-x-1 md:items-baseline')}>
-	{(linkFlg && withWiki && isFullTag (tag)) && (
-	    <span className={markerWrapClass}>
 	      {(tag.materialId != null || tag.hasWiki || tag.hasDeerjikists)
 	       ? (
 		  tag.materialId == null && !(tag.hasDeerjikists)
 		  ? (
 		      <PrefetchLink
 			  to={`/wiki/${ encodeURIComponent (tag.name) }`}
-			  className={linkClass}
+			  className={linkClass}>
-			  style={colourStyle}>
 			?
 		      </PrefetchLink>)
 		  : (
@@ -103,15 +60,13 @@ const TagLink: FC<Props> = ({ tag,
 		      ? (
 			  <PrefetchLink
 			      to={`/materials/${ tag.materialId }`}
-			      className={linkClass}
+			      className={linkClass}>
-			      style={colourStyle}>
 			    ?
 			  </PrefetchLink>)
 		      : (
 			  <PrefetchLink
 			      to={`/tags/${ tag.id }/deerjikists`}
-			      className={linkClass}
+			      className={linkClass}>
-			      style={colourStyle}>
 			    ?
 			  </PrefetchLink>)))
 	       : (
@@ -145,51 +100,33 @@ const TagLink: FC<Props> = ({ tag,
 	    </span>)}
 	{nestLevel > 0 && (
 	    <span
-		className="ml-1 mr-1 shrink-0"
+		className="ml-1 mr-1"
 		style={{ paddingLeft: `${ (nestLevel - 1) }rem` }}>
 	      ↳
 	    </span>)}
-	{matchedAlias != null && (
+	{tag.matchedAlias != null && (
 	    <>
-	      <span
+	      <span className={cn (spanClass, className)} {...props}>
-		  title={textTitle}
+		{tag.matchedAlias}
-		  className={cn (spanClass, textClass, className)}
-		  style={colourStyle}
-		  {...props}>
-		<ResponsiveMarqueeText
-		    text={matchedAlias}
-		    title={textTitle}
-		    truncateOnMobile={truncateOnMobile}/>
 	      </span>
-	      <span className="shrink-0"> → </span>
+	      <> → </>
 	    </>)}
 	{linkFlg
 	 ? (
 	    <PrefetchLink
 		to={`/posts?${ (new URLSearchParams ({ tags: tag.name })).toString () }`}
-		title={textTitle}
+		className={cn (linkClass, className)}
-		className={cn (linkClass, textClass, className)}
-		style={colourStyle}
 		{...props}>
-	      <ResponsiveMarqueeText
+	      {tag.name}
-		  text={tag.name}
-		  title={textTitle}
-		  truncateOnMobile={truncateOnMobile}/>
 	    </PrefetchLink>)
 	 : (
-	    <span
+	    <span className={cn (spanClass, className)}
-		  title={textTitle}
-		  className={cn (spanClass, textClass, className)}
-		  style={colourStyle}
 		  {...props}>
-	      <ResponsiveMarqueeText
+	      {tag.name}
-		  text={tag.name}
-		  title={textTitle}
-		  truncateOnMobile={truncateOnMobile}/>
 	    </span>)}
-	{(withCount && isFullTag (tag)) && (
+	{withCount && (
-	    <span className={countClass}>{tag.postCount}</span>)}
+	    <span className="ml-1">{tag.postCount}</span>)}
-      </span>)
+      </>)
 }
 
 export default TagLink

frontend/src/components/TagSearch.tsx

@@ -105,7 +105,6 @@ const TagSearch: FC = () => {
   return (
       <div className="relative w-full">
 	<input type="text"
-	       data-shortcut-focus-search="true"
 	       placeholder="タグ検索..."
 	       value={search}
 	       onChange={whenChanged}