#306

backend/app/controllers/material_sync_suppressions_controller.rb

@@ -0,0 +1,49 @@
+class MaterialSyncSuppressionsController < ApplicationController
+  def index
+    return head :unauthorized unless current_user
+    return head :forbidden unless current_user.gte_member?
+
+    suppressions =
+        MaterialSyncSuppression
+        .includes(:created_by_user)
+        .order(created_at: :desc, id: :desc)
+
+    render json: { suppressions: suppressions.map { |s| repr(s) } }
+  end
+
+  def create
+    return head :unauthorized unless current_user
+    return head :forbidden unless current_user.gte_member?
+
+    suppression =
+        MaterialSyncSuppressionRegistrar.create!(suppression_params,
+                                                 created_by_user: current_user)
+
+    render json: repr(suppression), status: :created
+  rescue ActiveRecord::RecordInvalid => e
+    render_validation_error e.record
+  end
+
+  private
+
+  def suppression_params
+    params.permit(:source_kind,
+                  :source_uri,
+                  :drive_path,
+                  :drive_file_id,
+                  :reason)
+  end
+
+  def repr suppression
+    { id: suppression.id,
+      source_kind: suppression.source_kind,
+      source_uri: suppression.source_uri,
+      drive_path: suppression.drive_path,
+      drive_file_id: suppression.drive_file_id,
+      normalized_source_key: suppression.normalized_source_key,
+      reason: suppression.reason,
+      created_by_user: suppression.created_by_user&.as_json(UserRepr::BASE),
+      created_at: suppression.created_at,
+      updated_at: suppression.updated_at }
+  end
+end

backend/app/controllers/material_versions_controller.rb

@@ -0,0 +1,49 @@
+class MaterialVersionsController < ApplicationController
+  def index
+    page = (params[:page].presence || 1).to_i
+    limit = (params[:limit].presence || 20).to_i
+
+    page = 1 if page < 1
+    limit = 1 if limit < 1
+
+    offset = (page - 1) * limit
+
+    q = MaterialVersion.includes(:created_by_user)
+    q = q.where(material_id: params[:material_id]) if params[:material_id].present?
+    q = q.where(tag_name: params[:tag].to_s.strip) if params[:tag].present?
+    q = q.where(event_type: params[:event_type]) if params[:event_type].present?
+
+    count = q.except(:order, :limit, :offset).count
+    versions =
+        q
+        .order(Arel.sql('material_versions.created_at DESC, material_versions.id DESC'))
+        .limit(limit)
+        .offset(offset)
+
+    render json: { versions: serialise_versions(versions), count: }
+  end
+
+  private
+
+  def serialise_versions rows
+    rows.map do |row|
+      { id: row.id,
+        material_id: row.material_id,
+        version_no: row.version_no,
+        event_type: row.event_type,
+        tag_id: row.tag_id,
+        tag_name: row.tag_name,
+        tag_category: row.tag_category,
+        url: row.url,
+        file_blob_id: row.file_blob_id,
+        file_filename: row.file_filename,
+        file_content_type: row.file_content_type,
+        file_byte_size: row.file_byte_size,
+        file_sha256: row.file_sha256,
+        export_paths_json: row.export_paths_hash,
+        discarded_at: row.discarded_at,
+        created_by_user: row.created_by_user&.as_json(UserRepr::BASE),
+        created_at: row.created_at }
+    end
+  end
+end

backend/app/controllers/materials_controller.rb

@@ -17,8 +17,6 @@ class MaterialsController < ApplicationController
                           thumbnail_attachment: :blob,
                           file_attachment: :blob,
                           tag: :tag_name)
-    q = q.where(file_suppressed_at: nil) if filters[:suppression] == 'active'
-    q = q.where.not(file_suppressed_at: nil) if filters[:suppression] == 'suppressed'
     q = q.where(tag_id: nil) if filters[:tag_state] == 'untagged'
     q = q.where.not(tag_id: nil) if filters[:tag_state] == 'tagged'
     q = q.where('materials.created_at >= ?', filters[:created_from]) if filters[:created_from]
@@ -97,8 +95,7 @@ class MaterialsController < ApplicationController
     end
 
     if material
-      MaterialThumbnailGenerator.generate!(material)
-      material.reload
+      log_thumbnail_generation(material, MaterialThumbnailGenerator.generate!(material))
       render json: MaterialRepr.base(material, host: request.base_url), status: :created
     else
       render_validation_error material
@@ -136,7 +133,6 @@ class MaterialsController < ApplicationController
         material.assign_attributes(tag:, url:, updated_by_user: current_user)
         if uploaded_blob
           material.file.attach(uploaded_blob)
-          clear_file_suppression!(material)
         elsif params.key?(:url) && url.present? && file.blank?
           material.file.detach
         end
@@ -150,8 +146,7 @@ class MaterialsController < ApplicationController
       raise
     end
 
-    MaterialThumbnailGenerator.generate!(material)
-    material.reload
+    log_thumbnail_generation(material, MaterialThumbnailGenerator.generate!(material))
 
     render json: MaterialRepr.base(material, host: request.base_url)
   end
@@ -182,37 +177,6 @@ class MaterialsController < ApplicationController
               filename: "btrc-materials-#{ profile }.zip"
   end
 
-  def suppress_file
-    return head :unauthorized unless current_user
-    return head :forbidden unless current_user.admin?
-
-    material = Material.with_attached_file.find_by(id: params[:id])
-    return head :not_found unless material
-
-    reason = params[:reason].to_s.strip.presence
-    return render_unprocessable_entity('理由は必須です．', field: :reason) unless reason
-    purge = bool?(:purge)
-    file_snapshot = purge_material_file_snapshot(material) if purge
-    attachment = purge && material.file.attached? ? material.file.attachment : nil
-
-    Material.transaction do
-      MaterialVersionRecorder.ensure_snapshot!(material, created_by_user: current_user)
-      material.update!(file_suppressed_at: Time.current,
-                       file_suppressed_by_user: current_user,
-                       file_suppression_reason: reason,
-                       updated_by_user: current_user)
-      MaterialVersionRecorder.record!(material:, event_type: :suppress,
-                                      created_by_user: current_user,
-                                      file_snapshot:)
-    end
-    # Enqueue failure raises here after the suppress metadata has been committed.
-    # In that case the file remains suppressed in UI/ZIP and purge can be retried.
-    attachment&.purge_later
-    material.reload if purge
-
-    render json: MaterialRepr.base(material, host: request.base_url)
-  end
-
   private
 
   def material_index_filters
@@ -225,9 +189,6 @@ class MaterialsController < ApplicationController
       media_kind = 'all'
     end
 
-    suppression = params[:suppression].to_s.presence
-    suppression = 'active' unless ['active', 'suppressed', 'all'].include?(suppression)
-
     sort = params[:sort].to_s.presence
     unless ['created_at', 'updated_at', 'tag_name', 'media_kind', 'file_byte_size',
             'version_no', 'id'].include?(sort)
@@ -240,7 +201,6 @@ class MaterialsController < ApplicationController
     { q: params[:q].to_s.strip.presence,
       tag_state:,
       media_kind:,
-      suppression:,
       created_from: parse_time_param(:created_from),
       created_to: parse_time_param(:created_to),
       updated_from: parse_time_param(:updated_from),
@@ -410,27 +370,16 @@ class MaterialsController < ApplicationController
     file.tempfile.rewind if file&.tempfile
   end
 
-  def clear_file_suppression! material
-    material.file_suppressed_at = nil
-    material.file_suppressed_by_user = nil
-    material.file_suppression_reason = nil
-  end
-
-  def purge_material_file_snapshot material
-    return nil unless material.file.attached?
-
-    blob = material.file.blob
-
-    { file_blob_id: blob.id,
-      file_filename: blob.filename.to_s,
-      file_content_type: blob.content_type,
-      file_byte_size: blob.byte_size,
-      file_checksum: blob.checksum,
-      file_sha256: blob.metadata['sha256'] ||
-                   MaterialFileSha256.from_blob(blob, allow_download: true) }
-  end
-
   def render_material_import_block block
     render_validation_error fields: { file: ["抑止された素材です: #{ block.reason }"] }
   end
+
+  def log_thumbnail_generation material, result
+    material.reload
+    Rails.logger.info(
+        "Material thumbnail generation: material_id=#{ material.id } " \
+        "result=#{ result } " \
+        "thumbnail_attached=#{ material.thumbnail.attached? } " \
+        "content_type=#{ material.content_type }")
+  end
 end

backend/app/models/material.rb

@@ -9,7 +9,6 @@ class Material < ApplicationRecord
   belongs_to :tag, optional: true
   belongs_to :created_by_user, class_name: 'User', optional: true
   belongs_to :updated_by_user, class_name: 'User', optional: true
-  belongs_to :file_suppressed_by_user, class_name: 'User', optional: true
 
   has_many :material_versions, dependent: :destroy
   has_many :material_export_items, dependent: :destroy
@@ -17,13 +16,17 @@ class Material < ApplicationRecord
   has_one_attached :file, dependent: :purge
   has_one_attached :thumbnail, dependent: :purge
 
-  validates :tag_id, presence: true, uniqueness: true
+  before_validation :assign_normalized_source_key
+
+  validates :tag_id, uniqueness: true, allow_nil: true
+  validates :source_kind,
+            inclusion: { in: MaterialSyncSuppression::SOURCE_KINDS },
+            allow_blank: true
 
   validate :file_must_be_attached
   validate :tag_must_be_material_category
 
   def content_type
-    return nil if file_suppressed?
     return nil unless file&.attached?
 
     file.blob.content_type
@@ -41,14 +44,25 @@ class Material < ApplicationRecord
     file.blob.filename.to_s
   end
 
-  def file_suppressed? = file_suppressed_at.present?
-
   def snapshot_export_paths
     material_export_items.order(:profile).pluck(:profile, :export_path).to_h
   end
 
   private
 
+  def assign_normalized_source_key
+    if source_kind.blank?
+      self.normalized_source_key = nil
+      return
+    end
+
+    self.normalized_source_key =
+        MaterialSyncSuppression.normalize_source_key(source_kind:,
+                                                     source_uri:,
+                                                     drive_path: source_path,
+                                                     drive_file_id: source_file_id)
+  end
+
   def file_must_be_attached
     return if url.present? || file.attached?
 

backend/app/models/material_sync_source.rb

@@ -0,0 +1,43 @@
+class MaterialSyncSource < ApplicationRecord
+  belongs_to :created_by_user, class_name: 'User', optional: true
+  belongs_to :updated_by_user, class_name: 'User', optional: true
+
+  validates :name, presence: true
+  validates :source_kind,
+            presence: true,
+            inclusion: { in: MaterialSyncSuppression::SOURCE_KINDS }
+  validates :profile, presence: true, inclusion: { in: MaterialExportItem::VALID_PROFILES }
+  validate :source_value_must_be_present
+
+  scope :enabled, -> { where(enabled: true) }
+
+  def normalized_source_key
+    MaterialSyncSuppression.normalize_source_key(source_kind:,
+                                                 source_uri:,
+                                                 source_path:,
+                                                 source_file_id:)
+  end
+
+  private
+
+  def source_value_must_be_present
+    return if source_value_present?
+
+    errors.add(:base, '同期元を指定してください．')
+  end
+
+  def source_value_present?
+    case source_kind
+    when 'uri'
+      source_uri.present?
+    when 'google_drive_file'
+      source_file_id.present? || source_uri.present?
+    when 'google_drive_path'
+      source_file_id.present? || source_uri.present? || source_path.present?
+    when 'legacy_drive_path'
+      source_path.present?
+    else
+      normalized_source_key.present?
+    end
+  end
+end

backend/app/models/material_sync_suppression.rb

@@ -0,0 +1,105 @@
+class MaterialSyncSuppression < ApplicationRecord
+  SOURCE_KINDS = [
+    'uri',
+    'google_drive_path',
+    'google_drive_path_prefix',
+    'google_drive_file',
+    'legacy_drive_path',
+    'legacy_drive_path_prefix'
+  ].freeze
+
+  REASONS = [
+    'copyright_high_risk',
+    'copyright_takedown',
+    'adult_or_sensitive',
+    'personal_information',
+    'malware_or_dangerous_file',
+    'duplicate_or_low_quality',
+    'source_owner_request',
+    'other'
+  ].freeze
+
+  belongs_to :created_by_user, class_name: 'User', optional: true
+
+  before_validation :assign_normalized_source_key
+
+  validates :source_kind, presence: true, inclusion: { in: SOURCE_KINDS }
+  validates :reason, presence: true, inclusion: { in: REASONS }
+  validates :normalized_source_key, presence: true, uniqueness: true
+  validate :source_value_must_be_present
+  validate :drive_path_must_be_safe_relative_path
+
+  def self.normalize_source_key source_kind:,
+                                source_uri: nil,
+                                drive_path: nil,
+                                drive_file_id: nil,
+                                source_path: nil,
+                                source_file_id: nil
+    kind = source_kind.to_s
+    value =
+        case kind
+        when 'uri'
+          source_uri.to_s.strip
+        when 'google_drive_path', 'google_drive_path_prefix',
+             'legacy_drive_path', 'legacy_drive_path_prefix'
+          (source_path || drive_path).to_s.strip.gsub(%r{/+}, '/')
+        when 'google_drive_file'
+          (source_file_id || drive_file_id).to_s.strip
+        else
+          ''
+        end
+
+    return nil if kind.blank? || value.blank?
+
+    "#{ kind }:#{ value }"
+  end
+
+  private
+
+  def assign_normalized_source_key
+    normalize_path_fields!
+    self.normalized_source_key =
+        self.class.normalize_source_key(source_kind:,
+                                        source_uri:,
+                                        drive_path:,
+                                        drive_file_id:)
+  end
+
+  def source_value_must_be_present
+    return if normalized_source_key.present?
+
+    errors.add(:base, '同期元を指定してください．')
+  end
+
+  def drive_path_must_be_safe_relative_path
+    return unless source_kind.in?(
+        ['google_drive_path', 'google_drive_path_prefix',
+         'legacy_drive_path', 'legacy_drive_path_prefix'])
+
+    value = drive_path.to_s
+    return if value.blank?
+
+    if value.start_with?('/') || value.match?(/\A[A-Za-z]:\//)
+      errors.add(:drive_path, '相対 path を指定してください．')
+    end
+    if value.start_with?('My Drive/', 'マイドライブ/')
+      errors.add(:drive_path, '同期元フォルダからの相対 path を指定してください．')
+    end
+    errors.add(:drive_path, 'NUL は使へません．') if value.include?("\0")
+    errors.add(:drive_path, '連続スラッシュは使へません．') if value.include?('//')
+    errors.add(:drive_path, '末尾スラッシュは使へません．') if value.end_with?('/')
+
+    parts = value.split('/')
+    if parts.any? { |part| part.in?(['.', '..']) }
+      errors.add(:drive_path, '. や .. は使へません．')
+    end
+  end
+
+  def normalize_path_fields!
+    return unless source_kind.in?(
+        ['google_drive_path', 'google_drive_path_prefix',
+         'legacy_drive_path', 'legacy_drive_path_prefix'])
+
+    self.drive_path = drive_path.to_s.tr('\\', '/').strip.presence
+  end
+end

backend/app/models/material_version.rb

@@ -2,8 +2,7 @@ class MaterialVersion < ApplicationRecord
   EVENT_TYPE_MAP = { create: 'create',
                      update: 'update',
                      discard: 'discard',
-                     restore: 'restore',
-                     suppress: 'suppress' }.freeze
+                     restore: 'restore' }.freeze
 
   include VersionRecord
 

backend/app/representations/material_repr.rb

@@ -2,8 +2,9 @@
 
 
 module MaterialRepr
-  BASE = { only: [:id, :url, :version_no, :file_suppressed_at,
-                  :file_suppression_reason, :created_at, :updated_at],
+  BASE = { only: [:id, :url, :version_no, :source_kind, :source_uri,
+                  :source_path, :source_file_id, :normalized_source_key,
+                  :created_at, :updated_at],
            methods: [:content_type],
            include: { tag: TagRepr::BASE,
                       created_by_user: UserRepr::BASE,
@@ -13,7 +14,7 @@ module MaterialRepr
 
   def base material, host:
     material.as_json(BASE).merge(
-        file: if material.file.attached? && !material.file_suppressed?
+        file: if material.file.attached?
                 Rails.application.routes.url_helpers.rails_storage_proxy_url(
                     material.file, host:)
               end,
@@ -34,6 +35,11 @@ module MaterialRepr
     { id: material.id,
       version_no: material.version_no,
       url: material.url,
+      source_kind: material.source_kind,
+      source_uri: material.source_uri,
+      source_path: material.source_path,
+      source_file_id: material.source_file_id,
+      normalized_source_key: material.normalized_source_key,
       tag: compact_tag(material.tag),
       thumbnail: thumbnail_url(material, host:),
       thumbnail_fallback_text: thumbnail_fallback_text(material),
@@ -41,7 +47,6 @@ module MaterialRepr
       media_kind: media_kind(material),
       content_type: material.content_type,
       file_byte_size: material.file_byte_size,
-      file_suppressed_at: material.file_suppressed_at,
       created_at: material.created_at,
       updated_at: material.updated_at,
       export_paths: export_paths(material),
@@ -68,7 +73,6 @@ module MaterialRepr
   end
 
   def thumbnail_url material, host:
-    return nil if material.file_suppressed?
     return nil unless material.thumbnail.attached?
 
     Rails.application.routes.url_helpers.rails_storage_proxy_url(
@@ -84,7 +88,6 @@ module MaterialRepr
   end
 
   def media_kind material
-    return 'suppressed' if material.file_suppressed?
     return 'url_only' unless material.file.attached?
 
     content_type = material.file.blob.content_type.to_s

backend/app/services/google_drive/api_client.rb

@@ -0,0 +1,209 @@
+require 'json'
+require 'jwt'
+require 'net/http'
+require 'openssl'
+require 'tempfile'
+require 'uri'
+
+
+module GoogleDrive
+  class ApiClient
+    DRIVE_ENDPOINT = 'https://www.googleapis.com/drive/v3'
+    TOKEN_ENDPOINT = 'https://oauth2.googleapis.com/token'
+    FOLDER_MIME_TYPE = 'application/vnd.google-apps.folder'
+    DRIVE_SCOPE = 'https://www.googleapis.com/auth/drive.readonly'
+
+    def initialize service_account_email: ENV['GOOGLE_DRIVE_SERVICE_ACCOUNT_EMAIL'],
+                   private_key: ENV['GOOGLE_DRIVE_PRIVATE_KEY'],
+                   private_key_path: ENV['GOOGLE_DRIVE_PRIVATE_KEY_PATH'],
+                   subject: ENV['GOOGLE_DRIVE_SUBJECT']
+      @service_account_email = service_account_email.to_s
+      @private_key = load_private_key(private_key, private_key_path)
+      @subject = subject.to_s.presence
+      @access_token = nil
+    end
+
+    def list_material_files_under_folder folder_id
+      files = []
+      walk_folder(folder_id, nil) do |entry, relative_path|
+        next if entry['mimeType'] == FOLDER_MIME_TYPE
+
+        files << build_file_entry(entry, relative_path)
+      end
+      files
+    end
+
+    def fetch_material_file file_id
+      metadata = get_file(file_id)
+      build_file_entry(metadata, metadata['name'])
+    end
+
+    def download_to_tempfile file_id, filename:
+      tempfile = Tempfile.new(['material-sync', File.extname(filename.to_s)])
+      request_binary("/files/#{ file_id }",
+                     { alt: 'media', supportsAllDrives: true }) do |chunk|
+        tempfile.write(chunk)
+      end
+      tempfile.rewind
+      tempfile
+    rescue StandardError
+      tempfile&.close!
+      raise
+    end
+
+    def extract_file_id value
+      raw = value.to_s.strip
+      return nil if raw.blank?
+      return raw unless raw.include?('/')
+
+      uri = URI.parse(raw)
+      return uri.query.to_s[%r{(?:^|&)id=([^&]+)}, 1] if uri.query.present?
+      return uri.path[%r{/folders/([^/]+)}, 1] if uri.path.include?('/folders/')
+
+      uri.path[%r{/d/([^/]+)}, 1]
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    private
+
+    def walk_folder folder_id, prefix, &block
+      list_children(folder_id).each do |entry|
+        relative_path = MaterialSyncExportPath.build(prefix:,
+                                                     relative_path: entry['name'])
+        if entry['mimeType'] == FOLDER_MIME_TYPE
+          walk_folder(entry['id'], relative_path, &block)
+          next
+        end
+
+        block.call(entry, relative_path)
+      end
+    end
+
+    def build_file_entry entry, relative_path
+      { id: entry['id'],
+        name: entry['name'],
+        mime_type: entry['mimeType'],
+        relative_path: MaterialSyncExportPath.normalize_path(relative_path),
+        web_view_link: entry['webViewLink'],
+        web_content_link: entry['webContentLink'] }
+    end
+
+    def list_children folder_id
+      files = []
+      page_token = nil
+
+      loop do
+        response =
+            request_json('/files', {
+                q: "'#{ folder_id }' in parents and trashed = false",
+                fields: 'nextPageToken,files(id,name,mimeType,webViewLink,webContentLink)',
+                orderBy: 'folder,name',
+                pageSize: 1000,
+                supportsAllDrives: true,
+                includeItemsFromAllDrives: true,
+                pageToken: page_token }.compact)
+        files.concat(response.fetch('files'))
+        page_token = response['nextPageToken']
+        break if page_token.blank?
+      end
+
+      files
+    end
+
+    def get_file file_id
+      request_json("/files/#{ file_id }",
+                   fields: 'id,name,mimeType,webViewLink,webContentLink',
+                   supportsAllDrives: true)
+    end
+
+    def request_json path, params = {}
+      response = request(:get, path, params:)
+      unless response.is_a?(Net::HTTPSuccess)
+        raise "Google Drive API error: #{ response.code } #{ response.body }"
+      end
+
+      JSON.parse(response.body)
+    end
+
+    def request_binary path, params = {}
+      response = request(:get, path, params:)
+      unless response.is_a?(Net::HTTPSuccess)
+        raise "Google Drive download error: #{ response.code } #{ response.body }"
+      end
+
+      response.read_body do |chunk|
+        yield chunk
+      end
+    end
+
+    def request method, path, params: nil
+      uri = URI(DRIVE_ENDPOINT + path)
+      uri.query = URI.encode_www_form(params) if params.present?
+
+      klass =
+          case method
+          when :get
+            Net::HTTP::Get
+          else
+            raise ArgumentError, "Unsupported Google Drive request method: #{ method }"
+          end
+      request = klass.new(uri)
+      request['Authorization'] = "Bearer #{ access_token }"
+
+      Net::HTTP.start(uri.host,
+                      uri.port,
+                      use_ssl: true,
+                      open_timeout: 10,
+                      read_timeout: 60) do |http|
+        http.request(request)
+      end
+    end
+
+    def access_token
+      @access_token ||= fetch_access_token
+    end
+
+    def fetch_access_token
+      raise 'GOOGLE_DRIVE_SERVICE_ACCOUNT_EMAIL is required' if @service_account_email.blank?
+      raise 'Google Drive private key is required' if @private_key.blank?
+
+      payload = { iss: @service_account_email,
+                  scope: DRIVE_SCOPE,
+                  aud: TOKEN_ENDPOINT,
+                  exp: 1.hour.from_now.to_i,
+                  iat: Time.current.to_i }
+      payload[:sub] = @subject if @subject.present?
+
+      assertion = JWT.encode(payload, @private_key, 'RS256')
+      uri = URI(TOKEN_ENDPOINT)
+      request = Net::HTTP::Post.new(uri)
+      request.set_form_data(
+          grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+          assertion:)
+
+      response =
+          Net::HTTP.start(uri.host,
+                          uri.port,
+                          use_ssl: true,
+                          open_timeout: 10,
+                          read_timeout: 30) do |http|
+            http.request(request)
+          end
+      unless response.is_a?(Net::HTTPSuccess)
+        raise "Google OAuth error: #{ response.code } #{ response.body }"
+      end
+
+      JSON.parse(response.body).fetch('access_token')
+    end
+
+    def load_private_key private_key, private_key_path
+      raw = private_key.to_s
+      raw = raw.gsub('\n', "\n") if raw.present?
+      raw = File.read(private_key_path) if raw.blank? && private_key_path.present?
+      return nil if raw.blank?
+
+      OpenSSL::PKey::RSA.new(raw)
+    end
+  end
+end

backend/app/services/material_sync_export_path.rb

@@ -0,0 +1,56 @@
+class MaterialSyncExportPath
+  class << self
+    def build prefix: nil, relative_path: nil, filename: nil, source_file_id: nil
+      path = normalize_path(relative_path)
+      path = fallback_filename(filename, source_file_id) if path.blank?
+
+      normalized_prefix = normalize_path(prefix)
+      return path if normalized_prefix.blank?
+      return normalized_prefix if path.blank?
+
+      [normalized_prefix, path].join('/')
+    end
+
+    def normalize_path path
+      raw = path.to_s.delete("\0").tr('\\', '/').strip
+      raw = raw.sub(%r{\A[A-Za-z]:/+}, '')
+      raw = raw.sub(%r{\A/+}, '')
+      return nil if raw.blank?
+
+      segments = raw.split('/').filter_map do |segment|
+        normalized = normalize_segment(segment)
+        normalized.presence
+      end
+      return nil if segments.empty?
+
+      segments.join('/')
+    end
+
+    def uniquify path, source_file_id
+      normalized = normalize_path(path)
+      return normalized if normalized.blank? || source_file_id.blank?
+
+      ext = File.extname(normalized)
+      base = ext.present? ? normalized.delete_suffix(ext) : normalized
+      "#{ base }--#{ source_file_id }#{ ext }"
+    end
+
+    private
+
+    def fallback_filename filename, source_file_id
+      name = normalize_path(filename)
+      return name if name.present?
+      return nil if source_file_id.blank?
+
+      source_file_id.to_s
+    end
+
+    def normalize_segment segment
+      cleaned = segment.to_s.delete("\0").tr('\\/', '_').strip
+      return nil if cleaned.blank? || cleaned == '.'
+      return '__' if cleaned == '..'
+
+      cleaned
+    end
+  end
+end

backend/app/services/material_sync_importer.rb

@@ -0,0 +1,150 @@
+require 'digest'
+
+class MaterialSyncImporter
+  Result = Struct.new(:material, :action, :suppressed, :suppression, keyword_init: true)
+
+  def self.import! attributes
+    new(attributes).import!
+  end
+
+  def initialize attributes
+    @attributes = attributes
+  end
+
+  def import!
+    source = source_attributes
+    key = normalized_source_key(source)
+    raise ArgumentError, 'normalized_source_key is required for material sync' if key.blank?
+
+    suppression = suppression_for(source)
+    if suppression
+      return Result.new(material: nil,
+                        action: :suppressed,
+                        suppressed: true,
+                        suppression:)
+    end
+
+    material =
+        Material
+        .unscoped
+        .find_or_initialize_by(normalized_source_key: key)
+    event_type =
+        if material.new_record?
+          :create
+        elsif material.discarded?
+          :restore
+        else
+          :update
+        end
+    uploaded_blob = uploaded_blob!
+
+    Material.transaction do
+      if material.persisted?
+        MaterialVersionRecorder.ensure_snapshot!(material,
+                                                 created_by_user: @attributes[:updated_by_user])
+      end
+      material.assign_attributes(material_attributes.merge(source))
+      material.discarded_at = nil if material.respond_to?(:discarded_at=)
+      material.file.attach(uploaded_blob) if uploaded_blob
+      material.save!
+      upsert_export_item!(material)
+      MaterialVersionRecorder.record!(material:,
+                                      event_type:,
+                                      created_by_user: @attributes[:updated_by_user])
+    end
+    MaterialThumbnailGenerator.generate!(material)
+
+    Result.new(material:,
+               action: event_type == :create ? :imported : :updated,
+               suppressed: false,
+               suppression: nil)
+  rescue StandardError
+    uploaded_blob&.purge_later
+    raise
+  ensure
+    close_tempfile!
+  end
+
+  private
+
+  def source_attributes
+    { source_kind: @attributes[:source_kind],
+      source_uri: @attributes[:source_uri],
+      source_path: @attributes[:source_path],
+      source_file_id: @attributes[:source_file_id] }
+  end
+
+  def normalized_source_key source
+    MaterialSyncSuppression.normalize_source_key(source_kind: source[:source_kind],
+                                                 source_uri: source[:source_uri],
+                                                 source_path: source[:source_path],
+                                                 source_file_id: source[:source_file_id])
+  end
+
+  def material_attributes
+    @attributes.except(:source_kind, :source_uri, :source_path, :source_file_id,
+                       :file_blob, :file_tempfile, :filename, :content_type,
+                       :file_sha256, :export_path, :profile)
+  end
+
+  def suppression_for source
+    if source[:source_kind] == 'google_drive_file' && source[:source_path].present?
+      return MaterialSyncSuppressionMatcher.match_google_drive_candidate(
+          drive_file_id: source[:source_file_id],
+          relative_path: source[:source_path])
+    end
+
+    MaterialSyncSuppressionMatcher.match(**source)
+  end
+
+  def uploaded_blob!
+    return @attributes[:file_blob] if @attributes[:file_blob]
+
+    tempfile = @attributes[:file_tempfile]
+    return nil unless tempfile
+
+    tempfile.rewind
+    blob = ActiveStorage::Blob.create_and_upload!(
+        io: tempfile,
+        filename: @attributes[:filename],
+        content_type: @attributes[:content_type])
+    file_sha256 = @attributes[:file_sha256] || Digest::SHA256.file(tempfile.path).hexdigest
+    blob.metadata['sha256'] = file_sha256 if file_sha256.present?
+    blob.save! if blob.changed?
+    tempfile.rewind
+    blob
+  end
+
+  def upsert_export_item! material
+    export_path = @attributes[:export_path].to_s.strip
+    return if export_path.blank?
+
+    profile = @attributes[:profile].presence || 'legacy_drive'
+    path = export_path
+    if export_path_taken_by_other?(material, profile, path)
+      path = MaterialSyncExportPath.uniquify(path, @attributes[:source_file_id])
+    end
+
+    item = material.material_export_items.find_or_initialize_by(profile:)
+    item.export_path = path
+    item.enabled = true
+    item.created_by_user ||= @attributes[:created_by_user]
+    item.save!
+  end
+
+  def export_path_taken_by_other? material, profile, export_path
+    MaterialExportItem
+      .where(profile:, export_path:)
+      .where.not(material_id: material.id)
+      .exists?
+  end
+
+  def close_tempfile!
+    tempfile = @attributes[:file_tempfile]
+    return unless tempfile
+
+    tempfile.close! unless tempfile.closed?
+  rescue StandardError
+    nil
+  end
+end

backend/app/services/material_sync_runner.rb

@@ -0,0 +1,212 @@
+require 'digest'
+
+class MaterialSyncRunner
+  Result = Struct.new(:imported, :updated, :suppressed, :failed, :errors, keyword_init: true)
+
+  def self.sync_enabled!
+    results = MaterialSyncSource.enabled.order(:id).map { |source| new(source).sync! }
+
+    Result.new(imported: results.sum(&:imported),
+               updated: results.sum(&:updated),
+               suppressed: results.sum(&:suppressed),
+               failed: results.sum(&:failed),
+               errors: results.flat_map(&:errors))
+  end
+
+  def initialize source
+    @source = source
+  end
+
+  def sync!
+    result = Result.new(imported: 0, updated: 0, suppressed: 0, failed: 0, errors: [])
+
+    candidates.each do |candidate|
+      sync_candidate!(candidate, result)
+    end
+
+    @source.update!(last_synced_at: Time.current)
+    log_result(result)
+    result
+  rescue NotImplementedError, StandardError => e
+    result.failed += 1
+    result.errors << { source_id: @source.id, error: e.message }
+    log_result(result)
+    result
+  end
+
+  private
+
+  def candidates
+    case @source.source_kind
+    when 'uri'
+      [uri_candidate]
+    when 'google_drive_path'
+      google_drive_path_candidates
+    when 'google_drive_file'
+      [google_drive_file_candidate]
+    when 'legacy_drive_path'
+      raise NotImplementedError, 'legacy_drive_path material sync is not implemented'
+    else
+      raise NotImplementedError, "Unsupported material sync source_kind: #{ @source.source_kind }"
+    end
+  end
+
+  def uri_candidate
+    { source_kind: @source.source_kind,
+      source_uri: @source.source_uri,
+      source_path: @source.source_path,
+      source_file_id: @source.source_file_id,
+      url: @source.source_uri,
+      tag: nil,
+      created_by_user: @source.created_by_user,
+      updated_by_user: @source.updated_by_user || @source.created_by_user }
+  end
+
+  def sync_candidate! candidate, result
+    block = MaterialImportBlockMatcher.match_for_sha256(candidate[:file_sha256])
+    if block
+      result.suppressed += 1
+      Rails.logger.info(
+          material_sync_log(action: 'suppressed',
+                            reason: block.reason,
+                            normalized_source_key: candidate_normalized_source_key(candidate)))
+      return
+    end
+
+    suppression = suppression_for(candidate)
+
+    if suppression
+      result.suppressed += 1
+      Rails.logger.info(
+          material_sync_log(action: 'suppressed',
+                            normalized_source_key: suppression.normalized_source_key))
+      return
+    end
+
+    import = MaterialSyncImporter.import!(candidate)
+    result.public_send("#{ import.action }=", result.public_send(import.action) + 1)
+  rescue StandardError => e
+    result.failed += 1
+    result.errors << { source_id: @source.id,
+                       normalized_source_key: candidate_normalized_source_key(candidate),
+                       error: e.message }
+    Rails.logger.warn(
+        material_sync_log(action: 'failed',
+                          error: e.message,
+                          normalized_source_key: candidate_normalized_source_key(candidate)))
+  ensure
+    close_candidate_tempfile(candidate)
+  end
+
+  def google_drive_path_candidates
+    folder_id = google_drive_folder_id
+    Enumerator.new do |entries|
+      drive_client.list_material_files_under_folder(folder_id).each do |entry|
+        entries << build_google_drive_candidate(entry)
+      end
+    end
+  end
+
+  def google_drive_file_candidate
+    build_google_drive_candidate(drive_client.fetch_material_file(google_drive_file_id),
+                                 single_file: true)
+  end
+
+  def build_google_drive_candidate entry, single_file: false
+    relative_path =
+        if single_file
+          nil
+        else
+          entry[:relative_path]
+        end
+    export_path =
+        MaterialSyncExportPath.build(prefix: @source.export_path_prefix,
+                                     relative_path:,
+                                     filename: entry[:name],
+                                     source_file_id: entry[:id])
+    tempfile =
+        drive_client.download_to_tempfile(entry[:id], filename: entry[:name])
+    file_sha256 = Digest::SHA256.file(tempfile.path).hexdigest
+    tempfile.rewind
+
+    { source_kind: 'google_drive_file',
+      source_uri: entry[:web_view_link] || google_drive_file_url(entry[:id]),
+      source_path: relative_path.presence || MaterialSyncExportPath.normalize_path(entry[:name]),
+      source_file_id: entry[:id],
+      filename: entry[:name],
+      content_type: entry[:mime_type],
+      file_tempfile: tempfile,
+      file_sha256:,
+      export_path:,
+      profile: @source.profile,
+      tag: nil,
+      url: nil,
+      created_by_user: @source.created_by_user,
+      updated_by_user: @source.updated_by_user || @source.created_by_user }
+  end
+
+  def candidate_normalized_source_key candidate
+    MaterialSyncSuppression.normalize_source_key(source_kind: candidate[:source_kind],
+                                                 source_uri: candidate[:source_uri],
+                                                 source_path: candidate[:source_path],
+                                                 source_file_id: candidate[:source_file_id])
+  end
+
+  def suppression_for candidate
+    if candidate[:source_kind] == 'google_drive_file' && candidate[:source_path].present?
+      return MaterialSyncSuppressionMatcher.match_google_drive_candidate(
+          drive_file_id: candidate[:source_file_id],
+          relative_path: candidate[:source_path])
+    end
+
+    MaterialSyncSuppressionMatcher.match(source_kind: candidate[:source_kind],
+                                         source_uri: candidate[:source_uri],
+                                         source_path: candidate[:source_path],
+                                         source_file_id: candidate[:source_file_id])
+  end
+
+  def drive_client
+    @drive_client ||= GoogleDrive::ApiClient.new
+  end
+
+  def google_drive_folder_id
+    google_drive_target_id.tap do |id|
+      raise ArgumentError, 'google_drive_path source_file_id or source_uri is required' if id.blank?
+    end
+  end
+
+  def google_drive_file_id
+    google_drive_target_id.tap do |id|
+      raise ArgumentError, 'google_drive_file source_file_id or source_uri is required' if id.blank?
+    end
+  end
+
+  def google_drive_target_id
+    @source.source_file_id.presence || drive_client.extract_file_id(@source.source_uri)
+  end
+
+  def google_drive_file_url file_id
+    "https://drive.google.com/file/d/#{ file_id }/view"
+  end
+
+  def close_candidate_tempfile candidate
+    tempfile = candidate[:file_tempfile]
+    return unless tempfile
+
+    tempfile.close! unless tempfile.closed?
+  rescue StandardError
+    nil
+  end
+
+  def log_result result
+    Rails.logger.info(material_sync_log(imported: result.imported,
+                                        updated: result.updated,
+                                        suppressed: result.suppressed,
+                                        failed: result.failed))
+  end
+
+  def material_sync_log fields
+    { material_sync_source_id: @source.id,
+      material_sync_source_name: @source.name }.merge(fields).to_json
+  end
+end

backend/app/services/material_sync_suppression_matcher.rb

@@ -0,0 +1,68 @@
+class MaterialSyncSuppressionMatcher
+  def self.match source_kind:,
+                 source_uri: nil,
+                 drive_path: nil,
+                 drive_file_id: nil,
+                 source_path: nil,
+                 source_file_id: nil
+    key = MaterialSyncSuppression.normalize_source_key(source_kind:,
+                                                       source_uri:,
+                                                       drive_path:,
+                                                       drive_file_id:,
+                                                       source_path:,
+                                                       source_file_id:)
+    return nil if key.blank?
+
+    MaterialSyncSuppression.find_by(normalized_source_key: key)
+  end
+
+  def self.match_google_drive_candidate drive_file_id:, relative_path:
+    normalized_path = validate_relative_path!(relative_path)
+
+    exact = [
+      normalize_key('google_drive_file', drive_file_id),
+      normalize_key('google_drive_path', normalized_path),
+      normalize_key('legacy_drive_path', normalized_path),
+    ].compact
+
+    suppression =
+        MaterialSyncSuppression.find_by(normalized_source_key: exact)
+    return suppression if suppression
+
+    MaterialSyncSuppression
+      .where(source_kind: ['google_drive_path_prefix', 'legacy_drive_path_prefix'])
+      .where('drive_path = :path OR :path LIKE CONCAT(drive_path, "/%")', path: normalized_path)
+      .order(:id)
+      .first
+  end
+
+  def self.suppressed?(...)
+    match(...).present?
+  end
+
+  def self.validate_relative_path! relative_path
+    raw = relative_path.to_s.delete("\0").tr('\\', '/').strip
+    raise ArgumentError, 'relative_path is required' if raw.blank?
+    raise ArgumentError, 'relative_path must be relative' if raw.start_with?('/')
+    raise ArgumentError, 'relative_path must be relative' if raw.match?(/\A[A-Za-z]:\//)
+    if raw.start_with?('My Drive/', 'マイドライブ/')
+      raise ArgumentError, 'relative_path must be relative to source folder'
+    end
+    raise ArgumentError, 'relative_path must not contain //' if raw.include?('//')
+    raise ArgumentError, 'relative_path must not end with /' if raw.end_with?('/')
+
+    parts = raw.split('/')
+    if parts.any? { |part| part.in?(['.', '..']) }
+      raise ArgumentError, 'relative_path must not contain dot segments'
+    end
+
+    raw
+  end
+
+  def self.normalize_key source_kind, value
+    return nil if value.blank?
+
+    MaterialSyncSuppression.normalize_source_key(source_kind:, source_path: value,
+                                                 source_file_id: value)
+  end
+end

backend/app/services/material_sync_suppression_registrar.rb

@@ -0,0 +1,51 @@
+class MaterialSyncSuppressionRegistrar
+  def self.create! attributes, created_by_user:
+    new(attributes, created_by_user:).create!
+  end
+
+  def initialize attributes, created_by_user:
+    @attributes = attributes
+    @created_by_user = created_by_user
+  end
+
+  def create!
+    suppression = nil
+
+    MaterialSyncSuppression.transaction do
+      suppression = MaterialSyncSuppression.create!(
+          @attributes.merge(created_by_user: @created_by_user))
+      discard_existing_materials!(suppression)
+    end
+
+    suppression
+  end
+
+  private
+
+  def discard_existing_materials! suppression
+    matching_materials(suppression).find_each do |material|
+      MaterialVersionRecorder.ensure_snapshot!(material, created_by_user: @created_by_user)
+      material.discard!
+      MaterialVersionRecorder.record!(material:,
+                                      event_type: :discard,
+                                      created_by_user: @created_by_user)
+    end
+  end
+
+  def matching_materials suppression
+    materials = Material.unscoped.kept
+
+    case suppression.source_kind
+    when 'google_drive_path', 'legacy_drive_path'
+      materials.where(source_path: suppression.drive_path)
+    when 'google_drive_path_prefix', 'legacy_drive_path_prefix'
+      path = suppression.drive_path.to_s
+      materials.where(
+          'source_path = :path OR source_path LIKE :prefix',
+          path:,
+          prefix: "#{ path }/%")
+    else
+      materials.where(normalized_source_key: suppression.normalized_source_key)
+    end
+  end
+end

backend/app/services/material_thumbnail_generator.rb

@@ -11,25 +11,30 @@ class MaterialThumbnailGenerator
   class << self
     def generate! material
       new(material).generate!
-    rescue ActiveStorage::FileNotFoundError, ArgumentError, MiniMagick::Error => e
-      Rails.logger.warn("Material thumbnail generation skipped: #{ e.class }: #{ e.message }")
-      nil
     end
   end
 
   def initialize material
     @material = material
+    @ffmpeg_stderr = []
   end
 
   def generate!
-    @material.thumbnail.purge if @material.thumbnail.attached?
-    return unless @material.file.attached?
-    return unless image? || video?
+    return log_result(:no_file) unless @material.file.attached?
+    return log_result(:unsupported_content_type) unless image? || video?
 
     @material.file.blob.open do |file|
       thumbnail = image? ? image_thumbnail(file.path) : video_thumbnail(file.path)
-      attach_thumbnail(thumbnail) if thumbnail
+      return log_result(:generation_failed) unless thumbnail
+
+      return attach_thumbnail(thumbnail)
     end
+  rescue ActiveStorage::FileNotFoundError => e
+    log_result(:file_not_found, error: e)
+  rescue MiniMagick::Error => e
+    log_result(:mini_magick_error, error: e)
+  rescue ArgumentError, StandardError => e
+    log_result(:generation_failed, error: e)
   end
 
   private
@@ -38,7 +43,11 @@ class MaterialThumbnailGenerator
 
   def video? = content_type.start_with?('video/')
 
-  def content_type = @material.file.blob.content_type.to_s
+  def content_type
+    return nil unless @material.file.attached?
+
+    @material.file.blob.content_type.to_s
+  end
 
   def image_thumbnail path
     image = MiniMagick::Image.open(path)
@@ -71,16 +80,47 @@ class MaterialThumbnailGenerator
                        '-frames:v', '1',
                        '-f', 'image2',
                        output_path)
-    Rails.logger.warn("ffmpeg thumbnail failed: #{ stderr }") unless status.success?
+    @ffmpeg_stderr << stderr if stderr.present?
     status.success?
   rescue Errno::ENOENT => e
-    Rails.logger.warn("ffmpeg unavailable for material thumbnail: #{ e.message }")
+    @ffmpeg_stderr << "ffmpeg unavailable: #{ e.message }"
     false
   end
 
   def attach_thumbnail image
-    @material.thumbnail.attach(io: File.open(image.path),
-                               filename: 'material-thumbnail.jpg',
-                               content_type: 'image/jpeg')
+    blob = nil
+    File.open(image.path) do |io|
+      blob = ActiveStorage::Blob.create_and_upload!(
+          io:,
+          filename: 'material-thumbnail.jpg',
+          content_type: 'image/jpeg')
+    end
+    @material.thumbnail.attach(blob)
+    log_result(:attached)
+  rescue StandardError => e
+    blob&.purge_later
+    log_result(:attach_failed, error: e)
+  end
+
+  def log_result result, error: nil
+    log_payload = { material_id: @material.id,
+                    file_blob_id: file_blob_id,
+                    content_type:,
+                    result:,
+                    error_class: error&.class&.name,
+                    error_message: error&.message,
+                    ffmpeg_stderr: @ffmpeg_stderr.join("\n").presence }
+    if [:attached, :no_file, :unsupported_content_type].include?(result)
+      Rails.logger.info("Material thumbnail generation: #{ log_payload.to_json }")
+    else
+      Rails.logger.warn("Material thumbnail generation: #{ log_payload.to_json }")
+    end
+    result
+  end
+
+  def file_blob_id
+    return nil unless @material.file.attached?
+
+    @material.file.blob.id
   end
 end

backend/app/services/material_version_recorder.rb

@@ -1,5 +1,5 @@
 class MaterialVersionRecorder < VersionRecorder
-  EVENT_TYPES = ['create', 'update', 'discard', 'restore', 'suppress'].freeze
+  EVENT_TYPES = ['create', 'update', 'discard', 'restore'].freeze
 
   def self.record! material:, event_type:, created_by_user:, file_snapshot: nil
     new(material:, event_type:, created_by_user:, file_snapshot:).record!
@@ -40,9 +40,7 @@ class MaterialVersionRecorder < VersionRecorder
       file_content_type: file_snapshot[:file_content_type],
       file_byte_size: file_snapshot[:file_byte_size],
       file_checksum: file_snapshot[:file_checksum],
-      file_sha256: file_snapshot[:file_sha256],
-      file_suppressed_at: @record.file_suppressed_at,
-      file_suppression_reason: @record.file_suppression_reason }
+      file_sha256: file_snapshot[:file_sha256] }
   end
 
   def build_file_snapshot blob

backend/app/services/material_zip_exporter.rb

@@ -40,7 +40,6 @@ class MaterialZipExporter
            .joins(:material)
            .merge(Material.kept)
            .where(profile: @profile)
-           .where(materials: { file_suppressed_at: nil })
            .order(:export_path)
 
     rows = rows.where(materials: { tag_id: @tag_id }) if @tag_id

backend/config/routes.rb

@@ -114,9 +114,7 @@ Rails.application.routes.draw do
   end
 
   get 'materials/download.zip', to: 'materials#download'
-  resources :materials, only: [:index, :show, :create, :update, :destroy] do
-    member do
-      patch :suppress_file
-    end
-  end
+  get 'materials/versions', to: 'material_versions#index'
+  resources :material_sync_suppressions, path: 'materials/suppressions', only: [:index, :create]
+  resources :materials, only: [:index, :show, :create, :update, :destroy]
 end

backend/db/migrate/20260625000000_reconcile_material_sync_suppressions.rb

@@ -0,0 +1,118 @@
+class ReconcileMaterialSyncSuppressions < ActiveRecord::Migration[8.0]
+  MATERIAL_VERSION_EVENT_CONSTRAINT = 'material_versions_event_type_valid'
+
+  def up
+    ensure_material_sync_suppressions!
+    ensure_material_source_columns!
+    ensure_material_active_source_key!
+    remove_material_file_suppression!
+    remove_material_version_file_suppression!
+    reconcile_material_version_event_constraint!
+  end
+
+  def down
+    raise ActiveRecord::IrreversibleMigration
+  end
+
+  private
+
+  def ensure_material_sync_suppressions!
+    return if table_exists?(:material_sync_suppressions)
+
+    create_table :material_sync_suppressions do |t|
+      t.string :source_kind, null: false
+      t.string :source_uri
+      t.string :drive_path
+      t.string :drive_file_id
+      t.string :normalized_source_key, null: false
+      t.string :reason, null: false
+      t.references :created_by_user, foreign_key: { to_table: :users }
+      t.timestamps
+
+      t.index :normalized_source_key, unique: true
+      t.index :source_kind
+      t.index :drive_file_id
+    end
+  end
+
+  def ensure_material_source_columns!
+    add_column :materials, :source_kind, :string unless column_exists?(:materials, :source_kind)
+    add_column :materials, :source_uri, :string unless column_exists?(:materials, :source_uri)
+    add_column :materials, :source_path, :string unless column_exists?(:materials, :source_path)
+    unless column_exists?(:materials, :source_file_id)
+      add_column :materials, :source_file_id, :string
+    end
+    unless column_exists?(:materials, :normalized_source_key)
+      add_column :materials, :normalized_source_key, :string
+    end
+
+    if index_exists?(:materials, :normalized_source_key)
+      remove_index :materials, column: :normalized_source_key
+    end
+  end
+
+  def ensure_material_active_source_key!
+    unless column_exists?(:materials, :active_normalized_source_key)
+      change_table :materials do |t|
+        t.virtual :active_normalized_source_key,
+                  type: :string,
+                  as: 'IF(discarded_at IS NULL, normalized_source_key, NULL)',
+                  stored: false
+      end
+    end
+
+    return if index_exists?(:materials,
+                            :active_normalized_source_key,
+                            name: 'index_materials_on_active_normalized_source_key')
+
+    add_index :materials,
+              :active_normalized_source_key,
+              unique: true,
+              name: 'index_materials_on_active_normalized_source_key'
+  end
+
+  def remove_material_file_suppression!
+    if foreign_key_exists?(:materials, :users, column: :file_suppressed_by_user_id)
+      remove_foreign_key :materials, column: :file_suppressed_by_user_id
+    end
+
+    if index_exists?(:materials,
+                    :file_suppressed_by_user_id,
+                    name: 'index_materials_on_file_suppressed_by_user_id')
+      remove_index :materials, name: 'index_materials_on_file_suppressed_by_user_id'
+    end
+
+    remove_column :materials, :file_suppressed_at if column_exists?(
+        :materials,
+        :file_suppressed_at)
+    remove_column :materials, :file_suppressed_by_user_id if column_exists?(
+        :materials,
+        :file_suppressed_by_user_id)
+    remove_column :materials, :file_suppression_reason if column_exists?(
+        :materials,
+        :file_suppression_reason)
+  end
+
+  def remove_material_version_file_suppression!
+    remove_column :material_versions, :file_suppressed_at if column_exists?(
+        :material_versions,
+        :file_suppressed_at)
+    remove_column :material_versions, :file_suppression_reason if column_exists?(
+        :material_versions,
+        :file_suppression_reason)
+  end
+
+  def reconcile_material_version_event_constraint!
+    constraint = check_constraints(:material_versions).find do |candidate|
+      candidate.name == MATERIAL_VERSION_EVENT_CONSTRAINT
+    end
+    return if constraint && !constraint.expression.include?('suppress')
+
+    if constraint
+      remove_check_constraint :material_versions, name: MATERIAL_VERSION_EVENT_CONSTRAINT
+    end
+    add_check_constraint :material_versions,
+                         "event_type IN ('create', 'update', 'discard', 'restore')",
+                         name: MATERIAL_VERSION_EVENT_CONSTRAINT
+  end
+end

backend/db/migrate/20260625010000_create_material_sync_sources.rb

@@ -0,0 +1,22 @@
+class CreateMaterialSyncSources < ActiveRecord::Migration[8.0]
+  def change
+    create_table :material_sync_sources do |t|
+      t.string :name, null: false
+      t.string :source_kind, null: false
+      t.string :source_uri
+      t.string :source_path
+      t.string :source_file_id
+      t.string :profile, null: false, default: 'legacy_drive'
+      t.boolean :enabled, null: false, default: true
+      t.string :default_tag_name
+      t.string :export_path_prefix
+      t.datetime :last_synced_at
+      t.references :created_by_user, foreign_key: { to_table: :users }
+      t.references :updated_by_user, foreign_key: { to_table: :users }
+      t.timestamps
+
+      t.index :enabled
+      t.index :source_kind
+    end
+  end
+end

backend/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
+ActiveRecord::Schema[8.0].define(version: 2026_06_25_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
@@ -72,7 +72,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.index ["correct_post_id"], name: "index_gekanator_games_on_correct_post_id"
     t.index ["guessed_post_id"], name: "index_gekanator_games_on_guessed_post_id"
     t.index ["user_id"], name: "index_gekanator_games_on_user_id"
-    t.check_constraint "`question_count` >= 0", name: "chk_gekanator_games_question_count_nonnegative"
   end
 
   create_table "gekanator_question_examples", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
@@ -156,6 +155,43 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.index ["created_by_user_id"], name: "index_material_import_blocks_on_created_by_user_id"
   end
 
+  create_table "material_sync_sources", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
+    t.string "name", null: false
+    t.string "source_kind", null: false
+    t.string "source_uri"
+    t.string "source_path"
+    t.string "source_file_id"
+    t.string "profile", default: "legacy_drive", null: false
+    t.boolean "enabled", default: true, null: false
+    t.string "default_tag_name"
+    t.string "export_path_prefix"
+    t.datetime "last_synced_at"
+    t.bigint "created_by_user_id"
+    t.bigint "updated_by_user_id"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["created_by_user_id"], name: "index_material_sync_sources_on_created_by_user_id"
+    t.index ["enabled"], name: "index_material_sync_sources_on_enabled"
+    t.index ["source_kind"], name: "index_material_sync_sources_on_source_kind"
+    t.index ["updated_by_user_id"], name: "index_material_sync_sources_on_updated_by_user_id"
+  end
+
+  create_table "material_sync_suppressions", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
+    t.string "source_kind", null: false
+    t.string "source_uri"
+    t.string "drive_path"
+    t.string "drive_file_id"
+    t.string "normalized_source_key", null: false
+    t.string "reason", null: false
+    t.bigint "created_by_user_id"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["created_by_user_id"], name: "index_material_sync_suppressions_on_created_by_user_id"
+    t.index ["drive_file_id"], name: "index_material_sync_suppressions_on_drive_file_id"
+    t.index ["normalized_source_key"], name: "index_material_sync_suppressions_on_normalized_source_key", unique: true
+    t.index ["source_kind"], name: "index_material_sync_suppressions_on_source_kind"
+  end
+
   create_table "material_versions", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "material_id", null: false
     t.integer "version_no", null: false
@@ -177,8 +213,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.bigint "file_byte_size"
     t.string "file_checksum"
     t.string "file_sha256"
-    t.datetime "file_suppressed_at"
-    t.string "file_suppression_reason"
     t.index ["created_by_user_id"], name: "index_material_versions_on_created_by_user_id"
     t.index ["discarded_at"], name: "index_material_versions_on_discarded_at"
     t.index ["file_blob_id"], name: "index_material_versions_on_file_blob_id"
@@ -188,7 +222,7 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.index ["tag_id"], name: "index_material_versions_on_tag_id"
     t.index ["updated_by_user_id"], name: "index_material_versions_on_updated_by_user_id"
     t.index ["url"], name: "index_material_versions_on_url"
-    t.check_constraint "`event_type` in (_utf8mb4'create',_utf8mb4'update',_utf8mb4'discard',_utf8mb4'restore',_utf8mb4'suppress')", name: "material_versions_event_type_valid"
+    t.check_constraint "`event_type` in (_utf8mb4'create',_utf8mb4'update',_utf8mb4'discard',_utf8mb4'restore')", name: "material_versions_event_type_valid"
   end
 
   create_table "materials", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
@@ -202,13 +236,16 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.datetime "discarded_at"
     t.virtual "active_url", type: :string, as: "if((`discarded_at` is null),`url`,NULL)"
     t.integer "version_no", default: 1, null: false
-    t.datetime "file_suppressed_at"
-    t.bigint "file_suppressed_by_user_id"
-    t.string "file_suppression_reason"
+    t.string "source_kind"
+    t.string "source_uri"
+    t.string "source_path"
+    t.string "source_file_id"
+    t.string "normalized_source_key"
+    t.virtual "active_normalized_source_key", type: :string, as: "if((`discarded_at` is null),`normalized_source_key`,NULL)"
+    t.index ["active_normalized_source_key"], name: "index_materials_on_active_normalized_source_key", unique: true
     t.index ["active_url"], name: "index_materials_on_active_url", unique: true
     t.index ["created_by_user_id"], name: "index_materials_on_created_by_user_id"
     t.index ["discarded_at"], name: "index_materials_on_discarded_at"
-    t.index ["file_suppressed_by_user_id"], name: "index_materials_on_file_suppressed_by_user_id"
     t.index ["parent_id"], name: "index_materials_on_parent_id"
     t.index ["tag_id"], name: "index_materials_on_tag_id"
     t.index ["updated_by_user_id"], name: "index_materials_on_updated_by_user_id"
@@ -232,10 +269,9 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.datetime "created_at", null: false
     t.bigint "created_by_user_id"
     t.index ["created_at"], name: "index_nico_tag_versions_on_created_at"
-    t.index ["created_by_user_id", "created_at"], name: "index_nico_tag_versions_on_created_by_user_id_and_created_at", order: { created_at: :desc }
-    t.index ["tag_id", "created_at"], name: "index_nico_tag_versions_on_tag_id_and_created_at", order: { created_at: :desc }
+    t.index ["created_by_user_id", "created_at"], name: "index_nico_tag_versions_on_created_by_user_id_and_created_at"
+    t.index ["tag_id", "created_at"], name: "index_nico_tag_versions_on_tag_id_and_created_at"
     t.index ["tag_id", "version_no"], name: "index_nico_tag_versions_on_tag_id_and_version_no", unique: true
-    t.check_constraint "`version_no` > 0", name: "nico_tag_versions_version_no_positive"
   end
 
   create_table "post_implications", primary_key: ["post_id", "parent_post_id"], charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
@@ -244,14 +280,13 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.index ["parent_post_id"], name: "index_post_implications_on_parent_post_id"
-    t.check_constraint "`post_id` <> `parent_post_id`", name: "chk_post_implications_no_self"
   end
 
   create_table "post_similarities", primary_key: ["post_id", "target_post_id"], charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "post_id", null: false
     t.bigint "target_post_id", null: false
     t.float "cos", null: false
-    t.index ["post_id", "cos"], name: "index_post_similarities_on_post_id_and_cos", order: { cos: :desc }
+    t.index ["post_id", "cos"], name: "index_post_similarities_on_post_id_and_cos"
     t.index ["target_post_id"], name: "index_post_similarities_on_target_post_id"
   end
 
@@ -291,8 +326,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     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.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
 
   create_table "posts", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
@@ -307,7 +340,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.integer "version_no", null: false
     t.index ["uploaded_user_id"], name: "index_posts_on_uploaded_user_id"
     t.index ["url"], name: "index_posts_on_url", unique: true
-    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|
@@ -354,7 +386,7 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.bigint "tag_id", null: false
     t.bigint "target_tag_id", null: false
     t.float "cos", null: false
-    t.index ["tag_id", "cos"], name: "index_tag_similarities_on_tag_id_and_cos", order: { cos: :desc }
+    t.index ["tag_id", "cos"], name: "index_tag_similarities_on_tag_id_and_cos"
     t.index ["target_tag_id"], name: "index_tag_similarities_on_target_tag_id"
   end
 
@@ -364,32 +396,30 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_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"
-    t.index ["created_by_user_id", "created_at"], name: "index_tag_versions_on_created_by_user_id_and_created_at", order: { created_at: :desc }
-    t.index ["tag_id", "created_at"], name: "index_tag_versions_on_tag_id_and_created_at", order: { created_at: :desc }
+    t.index ["created_by_user_id", "created_at"], name: "index_tag_versions_on_created_by_user_id_and_created_at"
+    t.index ["tag_id", "created_at"], name: "index_tag_versions_on_tag_id_and_created_at"
     t.index ["tag_id", "version_no"], name: "index_tag_versions_on_tag_id_and_version_no", unique: true
-    t.check_constraint "`version_no` > 0", name: "tag_versions_version_no_positive"
   end
 
   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"
     t.index ["discarded_at"], name: "index_tags_on_discarded_at"
     t.index ["tag_name_id"], name: "index_tags_on_tag_name_id", unique: true
     t.check_constraint "(`deprecated_at` is null) or (`category` <> _utf8mb4'nico')", name: "chk_tags_deprecated_at_not_nico"
-    t.check_constraint "`version_no` > 0", name: "chk_tags_version_no_positive"
   end
 
   create_table "theatre_comments", primary_key: ["theatre_id", "no"], charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
@@ -514,19 +544,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_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
@@ -543,13 +560,11 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.datetime "discarded_at"
-    t.integer "next_asset_no", default: 1, null: false
     t.integer "version_no", null: false
     t.index ["created_user_id"], name: "index_wiki_pages_on_created_user_id"
     t.index ["discarded_at"], name: "index_wiki_pages_on_discarded_at"
     t.index ["tag_name_id"], name: "index_wiki_pages_on_tag_name_id", unique: true
     t.index ["updated_user_id"], name: "index_wiki_pages_on_updated_user_id"
-    t.check_constraint "`version_no` > 0", name: "chk_wiki_pages_version_no_positive"
   end
 
   create_table "wiki_revision_lines", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
@@ -594,8 +609,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
     t.index ["created_by_user_id"], name: "index_wiki_versions_on_created_by_user_id"
     t.index ["wiki_page_id", "version_no"], name: "index_wiki_versions_on_wiki_page_id_and_version_no", unique: true
     t.index ["wiki_page_id"], name: "index_wiki_versions_on_wiki_page_id"
-    t.check_constraint "`event_type` in (_utf8mb4'create',_utf8mb4'update',_utf8mb4'discard',_utf8mb4'restore')", name: "wiki_versions_event_type_valid"
-    t.check_constraint "`version_no` > 0", name: "wiki_versions_version_no_positive"
   end
 
   add_foreign_key "active_storage_attachments", "active_storage_blobs", column: "blob_id"
@@ -615,6 +628,9 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
   add_foreign_key "material_export_items", "materials"
   add_foreign_key "material_export_items", "users", column: "created_by_user_id"
   add_foreign_key "material_import_blocks", "users", column: "created_by_user_id"
+  add_foreign_key "material_sync_sources", "users", column: "created_by_user_id"
+  add_foreign_key "material_sync_sources", "users", column: "updated_by_user_id"
+  add_foreign_key "material_sync_suppressions", "users", column: "created_by_user_id"
   add_foreign_key "material_versions", "materials"
   add_foreign_key "material_versions", "materials", column: "parent_id"
   add_foreign_key "material_versions", "tags"
@@ -623,7 +639,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_000000) do
   add_foreign_key "materials", "materials", column: "parent_id"
   add_foreign_key "materials", "tags"
   add_foreign_key "materials", "users", column: "created_by_user_id"
-  add_foreign_key "materials", "users", column: "file_suppressed_by_user_id"
   add_foreign_key "materials", "users", column: "updated_by_user_id"
   add_foreign_key "nico_tag_relations", "tags"
   add_foreign_key "nico_tag_relations", "tags", column: "nico_tag_id"
@@ -672,8 +687,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_06_23_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 "wiki_assets", "users", column: "created_by_user_id"
-  add_foreign_key "wiki_assets", "wiki_pages"
   add_foreign_key "wiki_pages", "tag_names"
   add_foreign_key "wiki_pages", "users", column: "created_user_id"
   add_foreign_key "wiki_pages", "users", column: "updated_user_id"

backend/db/seeds.rb

@@ -7,3 +7,21 @@
 #   ["Action", "Comedy", "Drama", "Horror"].each do |genre_name|
 #     MovieGenre.find_or_create_by!(name: genre_name)
 #   end
+
+material_sync_source_uri = ENV['MATERIAL_SYNC_SOURCE_URI']
+material_sync_source_tag_name = ENV['MATERIAL_SYNC_SOURCE_TAG_NAME']
+
+if material_sync_source_uri.present? && material_sync_source_tag_name.present?
+  source = MaterialSyncSource.find_or_initialize_by(
+      name: ENV.fetch('MATERIAL_SYNC_SOURCE_NAME', 'Legacy URI material sync'))
+  source.assign_attributes(
+      source_kind: ENV.fetch('MATERIAL_SYNC_SOURCE_KIND', 'uri'),
+      source_uri: material_sync_source_uri,
+      source_path: ENV['MATERIAL_SYNC_SOURCE_PATH'],
+      source_file_id: ENV['MATERIAL_SYNC_SOURCE_FILE_ID'],
+      profile: ENV.fetch('MATERIAL_SYNC_SOURCE_PROFILE', 'legacy_drive'),
+      enabled: ENV.fetch('MATERIAL_SYNC_SOURCE_ENABLED', 'true') != 'false',
+      default_tag_name: material_sync_source_tag_name,
+      export_path_prefix: ENV['MATERIAL_SYNC_EXPORT_PATH_PREFIX'])
+  source.save!
+end

backend/lib/tasks/sync_materials.rake

@@ -0,0 +1,50 @@
+namespace :materials do
+  desc '素材同期'
+  task sync: :environment do
+    result = MaterialSyncRunner.sync_enabled!
+    message = [
+      "materials:sync imported=#{ result.imported }",
+      "updated=#{ result.updated }",
+      "suppressed=#{ result.suppressed }",
+      "failed=#{ result.failed }"
+    ].join(' ')
+
+    Rails.logger.info(message)
+    puts message
+
+    result.errors.each do |error|
+      Rails.logger.warn(error.to_json)
+      warn error.to_json
+    end
+  end
+
+  namespace :thumbnails do
+    desc '素材サムネールを補完'
+    task backfill: :environment do
+      counts = Hash.new(0)
+
+      Material
+        .with_attached_file
+        .with_attached_thumbnail
+        .find_each do |material|
+          next unless material.file.attached?
+          next if material.thumbnail.attached?
+
+          result = MaterialThumbnailGenerator.generate!(material)
+          counts[result] += 1
+        end
+
+      message =
+          "materials:thumbnails:backfill " \
+          "attached=#{ counts[:attached] } " \
+          "no_file=#{ counts[:no_file] } " \
+          "unsupported_content_type=#{ counts[:unsupported_content_type] } " \
+          "generation_failed=#{ counts[:generation_failed] } " \
+          "attach_failed=#{ counts[:attach_failed] } " \
+          "file_not_found=#{ counts[:file_not_found] } " \
+          "mini_magick_error=#{ counts[:mini_magick_error] }"
+      Rails.logger.info(message)
+      puts message
+    end
+  end
+end

docs/commands.md

@@ -10,6 +10,15 @@ bundle exec rspec
 bundle exec rails routes
 ```
 
+Material video thumbnail generation requires `ffmpeg` on the host. If `ffmpeg`
+is missing or frame extraction fails, `MaterialThumbnailGenerator` logs the
+result and stderr, then leaves the existing thumbnail unchanged.
+
+```sh
+cd backend
+bundle exec rails materials:thumbnails:backfill
+```
+
 ## Frontend
 
 ```sh

frontend/src/App.tsx

@@ -14,8 +14,10 @@ import { apiPost, isApiError } from '@/lib/api'
 import DeerjikistDetailPage from '@/pages/deerjikists/DeerjikistDetailPage'
 import MaterialBasePage from '@/pages/materials/MaterialBasePage'
 import MaterialDetailPage from '@/pages/materials/MaterialDetailPage'
+import MaterialHistoryPage from '@/pages/materials/MaterialHistoryPage'
 import MaterialListPage from '@/pages/materials/MaterialListPage'
 import MaterialNewPage from '@/pages/materials/MaterialNewPage'
+import MaterialSyncSuppressionsPage from '@/pages/materials/MaterialSyncSuppressionsPage'
 // import MaterialSearchPage from '@/pages/materials/MaterialSearchPage'
 import MorePage from '@/pages/MorePage'
 import GekanatorPage from '@/pages/GekanatorPage'
@@ -68,8 +70,10 @@ const RouteTransitionWrapper = ({ user, setUser }: {
 	  <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=":id" element ={<MaterialDetailPage user={user}/>}/>
+	    <Route path="suppressions" element={<MaterialSyncSuppressionsPage/>}/>
+	    <Route path=":id" element ={<MaterialDetailPage/>}/>
 	  </Route>
 	  {/* <Route path="/materials/search" element={<MaterialSearchPage/>}/> */}
 	  <Route path="/wiki" element={<WikiSearchPage/>}/>

frontend/src/lib/materials.ts

@@ -1,15 +1,16 @@
 import {
     apiGet,
     isApiError,
-    apiPatch,
     apiPost,
     apiPut,
 } from '@/lib/api'
 
 import type {
     Material,
+    MaterialVersion,
     FetchMaterialsParams,
     MaterialFilter,
+    MaterialSyncSuppression,
     MaterialSidebarTag,
     MaterialTagTree,
 } from '@/types'
@@ -24,6 +25,15 @@ export type MaterialIndexResponse = {
     count:     number
 }
 
+export type MaterialSyncSuppressionResponse = {
+    suppressions: MaterialSyncSuppression[]
+}
+
+export type MaterialChangesResponse = {
+    versions: MaterialVersion[]
+    count:    number
+}
+
 const MATERIAL_FILTERS: MaterialFilter[] = ['present', 'missing', 'any']
 
 
@@ -36,13 +46,13 @@ export const parseMaterialFilter = (
 
 
 export const fetchMaterials = async (
-    { q, tagState, mediaKind, suppression, createdFrom, createdTo,
-      updatedFrom, updatedTo, sort, direction, page, limit }: FetchMaterialsParams): Promise<MaterialIndexResponse> =>
+    { q, tagState, mediaKind, createdFrom, createdTo,
+      updatedFrom, updatedTo, sort, direction, page,
+      limit }: FetchMaterialsParams): Promise<MaterialIndexResponse> =>
     await apiGet ('/materials', { params: {
 	...(q && { q }),
 	tag_state:   tagState,
 	media_kind:  mediaKind,
-	suppression,
 	...(createdFrom && { created_from: createdFrom }),
 	...(createdTo && { created_to: createdTo }),
 	...(updatedFrom && { updated_from: updatedFrom }),
@@ -67,6 +77,22 @@ export const fetchMaterial = async (id: string): Promise<Material | null> => {
 }
 
 
+export const fetchMaterialChanges = async (
+    { materialId, tag, eventType, page, limit }: {
+	materialId?: string
+	tag?:        string
+	eventType?:  string
+	page:        number
+	limit:       number
+    }): Promise<MaterialChangesResponse> =>
+    await apiGet ('/materials/versions', { params: {
+	...(materialId && { material_id: materialId }),
+	...(tag && { tag }),
+	...(eventType && { event_type: eventType }),
+	page,
+	limit} })
+
+
 export const fetchMaterialTagTree = async (
     { parentId, materialFilter }: FetchMaterialTreeParams): Promise<MaterialSidebarTag[]> =>
     await apiGet ('/tags/with-depth', { params: {
@@ -101,7 +127,22 @@ export const updateMaterial = async (
     await apiPut (`/materials/${ id }`, formData)
 
 
-export const suppressMaterialFile = async (
-    id: string,
-    payload: { reason: string; purge?: boolean }): Promise<Material> =>
-    await apiPatch (`/materials/${ id }/suppress_file`, payload)
+export const fetchMaterialSyncSuppressions =
+    async (): Promise<MaterialSyncSuppressionResponse> =>
+        await apiGet ('/materials/suppressions')
+
+
+export const createMaterialSyncSuppression = async (
+    payload: {
+        sourceKind:   string
+        sourceUri?:   string
+        drivePath?:   string
+        driveFileId?: string
+        reason:       string
+    }): Promise<MaterialSyncSuppression> =>
+    await apiPost ('/materials/suppressions', {
+        source_kind:   payload.sourceKind,
+        source_uri:    payload.sourceUri,
+        drive_path:    payload.drivePath,
+        drive_file_id: payload.driveFileId,
+        reason:        payload.reason})

frontend/src/lib/queryKeys.ts

@@ -34,9 +34,17 @@ export const tagsKeys = {
 export const materialsKeys = {
     root:         ['materials'] as const,
     index:        (p: FetchMaterialsParams) => ['materials', 'index', p] as const,
+    changes:      (p: {
+	materialId?: string
+	tag?:        string
+	eventType?:  string
+	page:        number
+	limit:       number
+    }) => ['materials', 'changes', p] as const,
     byTagName:     (name: string, materialFilter: MaterialFilter) =>
 		      ['materials', 'tag', name, materialFilter] as const,
     show:         (id: string) => ['materials', id] as const,
+    suppressions: () => ['materials', 'suppressions'] as const,
     tree:         (p: {
 	parentId?:       number | null
 	materialFilter:  MaterialFilter

frontend/src/pages/materials/MaterialDetailPage.tsx

@@ -8,6 +8,7 @@ import WikiBody from '@/components/WikiBody'
 import FieldError from '@/components/common/FieldError'
 import FormField from '@/components/common/FormField'
 import PageTitle from '@/components/common/PageTitle'
+import PrefetchLink from '@/components/PrefetchLink'
 import TabGroup, { Tab } from '@/components/common/TabGroup'
 import TagInput from '@/components/common/TagInput'
 import MainArea from '@/components/layout/MainArea'
@@ -15,7 +16,6 @@ import { Button } from '@/components/ui/button'
 import { toast } from '@/components/ui/use-toast'
 import { SITE_TITLE } from '@/config'
 import {
-    suppressMaterialFile,
     fetchMaterial,
     updateMaterial,
 } from '@/lib/materials'
@@ -25,12 +25,10 @@ import { useValidationErrors } from '@/lib/useValidationErrors'
 
 import type { FC } from 'react'
 
-import type { User } from '@/types'
-
 type MaterialFormField = 'tag' | 'file' | 'url' | 'exportPaths'
 
 
-const MaterialDetailPage: FC<{ user: User | null }> = ({ user }) => {
+const MaterialDetailPage: FC = () => {
   const { id } = useParams ()
   const qc = useQueryClient ()
 
@@ -91,35 +89,11 @@ const MaterialDetailPage: FC<{ user: User | null }> = ({ user }) => {
 	toast ({ title: '更新失敗……', description: '入力を見直してください．' })
       }})
 
-  const suppressMutation = useMutation ({
-      mutationFn: async (reason: string) =>
-	  await suppressMaterialFile (id ?? '', { reason }),
-      onSuccess: async data => {
-	qc.setQueryData (materialsKeys.show (id ?? ''), data)
-	setFile (null)
-	setFilePreview ('')
-	await invalidateMaterialQueries ()
-	toast ({ title: '抑止しました' })
-      },
-      onError: () => {
-	toast ({ title: '抑止に失敗しました' })
-      }})
-
   const handleSubmit = () => {
     clearValidationErrors ()
     updateMutation.mutate ()
   }
 
-  const handleSuppress = () => {
-    const reason = window.prompt ('抑止理由を入力してください。')
-    if (reason == null || reason.trim () === '')
-      return
-    if (!window.confirm ('素材ファイルを抑止します。表示と ZIP export から除外されます。'))
-      return
-
-    suppressMutation.mutate (reason)
-  }
-
   return (
       <MainArea>
 	{material && (
@@ -145,16 +119,13 @@ const MaterialDetailPage: FC<{ user: User | null }> = ({ user }) => {
 		 : materialTitle}
 	      </PageTitle>
 
-	      {material.fileSuppressedAt && (
-		  <div className="mb-4 rounded border border-red-300 bg-red-50 p-3
-				  text-red-900 dark:border-red-800 dark:bg-red-950
-				  dark:text-red-100">
-		    <span>素材ファイルは抑止済みです。</span>
-		    {material.fileSuppressionReason && (
-			<span> 理由: {material.fileSuppressionReason}</span>)}
-		  </div>)}
+	      <PrefetchLink
+		  to={`/materials/changes?material_id=${ material.id }`}
+		  className="text-sm text-sky-700 underline underline-offset-2 dark:text-sky-300">
+		この素材の履歴
+	      </PrefetchLink>
 
-	      {(!material.fileSuppressedAt && material.file && material.contentType) && (
+	      {(material.file && material.contentType) && (
 		  (/image\/.*/.test (material.contentType) && (
 		      <img src={material.file} alt={material.tag?.name || undefined}/>))
 		  || (/video\/.*/.test (material.contentType) && (
@@ -256,14 +227,6 @@ const MaterialDetailPage: FC<{ user: User | null }> = ({ user }) => {
 			  disabled={updateMutation.isPending}>
 			更新
 		      </Button>
-		      {user?.role === 'admin' && !material.fileSuppressedAt && (
-			  <Button
-			      type="button"
-			      variant="destructive"
-			      onClick={handleSuppress}
-			      disabled={suppressMutation.isPending}>
-			    ファイルを抑止
-			  </Button>)}
 		    </div>
 		  </div>
 		</Tab>

frontend/src/pages/materials/MaterialHistoryPage.tsx

@@ -0,0 +1,213 @@
+import { useQuery } from '@tanstack/react-query'
+import { useEffect, useState } from 'react'
+import { Helmet } from 'react-helmet-async'
+import { useLocation, useNavigate } from 'react-router-dom'
+
+import PrefetchLink from '@/components/PrefetchLink'
+import FormField from '@/components/common/FormField'
+import PageTitle from '@/components/common/PageTitle'
+import Pagination from '@/components/common/Pagination'
+import MainArea from '@/components/layout/MainArea'
+import { SITE_TITLE } from '@/config'
+import { fetchMaterialChanges } from '@/lib/materials'
+import { materialsKeys } from '@/lib/queryKeys'
+import { dateString, inputClass } from '@/lib/utils'
+
+import type { FC, FormEvent } from 'react'
+
+
+const MaterialHistoryPage: FC = () => {
+  const location = useLocation ()
+  const navigate = useNavigate ()
+  const query = new URLSearchParams (location.search)
+
+  const materialId = query.get ('material_id') ?? ''
+  const tag = query.get ('tag') ?? ''
+  const eventType = query.get ('event_type') ?? ''
+  const page = Number (query.get ('page') ?? 1)
+  const limit = Number (query.get ('limit') ?? 20)
+
+  const [materialIdInput, setMaterialIdInput] = useState (materialId)
+  const [tagInput, setTagInput] = useState (tag)
+  const [eventTypeInput, setEventTypeInput] = useState (eventType)
+
+  useEffect (() => {
+    setMaterialIdInput (materialId)
+    setTagInput (tag)
+    setEventTypeInput (eventType)
+  }, [eventType, materialId, tag])
+
+  const { data, isLoading, isError } = useQuery ({
+      queryKey: materialsKeys.changes ({
+	  ...(materialId && { materialId }),
+	  ...(tag && { tag }),
+	  ...(eventType && { eventType }),
+	  page,
+	  limit }),
+      queryFn: () => fetchMaterialChanges ({
+	  ...(materialId && { materialId }),
+	  ...(tag && { tag }),
+	  ...(eventType && { eventType }),
+	  page,
+	  limit }) })
+
+  const versions = data?.versions ?? []
+  const totalPages = data ? Math.ceil (data.count / limit) : 0
+
+  useEffect (() => {
+    document.querySelector ('table')?.scrollIntoView ({ behavior: 'smooth' })
+  }, [location.search])
+
+  const handleSearch = (event: FormEvent) => {
+    event.preventDefault ()
+
+    const qs = new URLSearchParams ()
+    if (materialIdInput.trim ())
+      qs.set ('material_id', materialIdInput.trim ())
+    if (tagInput.trim ())
+      qs.set ('tag', tagInput.trim ())
+    if (eventTypeInput.trim ())
+      qs.set ('event_type', eventTypeInput.trim ())
+    qs.set ('page', '1')
+    qs.set ('limit', String (limit))
+    navigate (`/materials/changes?${ qs.toString () }`)
+  }
+
+  return (
+      <MainArea>
+	<Helmet>
+	  <title>{`素材履歴 | ${ SITE_TITLE }`}</title>
+	</Helmet>
+
+	<div className="space-y-5">
+	  <div className="flex flex-wrap items-center justify-between gap-3">
+	    <PageTitle>素材履歴</PageTitle>
+	    <PrefetchLink
+		to="/materials"
+		className="text-sm text-sky-700 underline underline-offset-2 dark:text-sky-300">
+	      素材一覧へ戻る
+	    </PrefetchLink>
+	  </div>
+
+	  <form
+	      onSubmit={handleSearch}
+	      className="max-w-3xl rounded-lg border border-stone-200 bg-white p-4
+			 text-stone-900 dark:border-stone-700 dark:bg-stone-900
+			 dark:text-stone-100">
+	    <div className="space-y-3">
+	      <FormField label="素材 ID">
+		{({ invalid }) => (
+		    <input
+			type="text"
+			value={materialIdInput}
+			onChange={e => setMaterialIdInput (e.target.value)}
+			className={inputClass (invalid)}/>)}
+	      </FormField>
+
+	      <FormField label="タグ名">
+		{({ invalid }) => (
+		    <input
+			type="text"
+			value={tagInput}
+			onChange={e => setTagInput (e.target.value)}
+			className={inputClass (invalid)}/>)}
+	      </FormField>
+
+	      <FormField label="イベント">
+		{({ invalid }) => (
+		    <select
+			value={eventTypeInput}
+			onChange={e => setEventTypeInput (e.target.value)}
+			className={inputClass (invalid)}>
+		      <option value="">すべて</option>
+		      <option value="create">create</option>
+		      <option value="update">update</option>
+		      <option value="discard">discard</option>
+		      <option value="restore">restore</option>
+		    </select>)}
+	      </FormField>
+	    </div>
+
+	    <button
+		type="submit"
+		className="mt-4 rounded-full border border-stone-300 bg-white px-4 py-2
+			   text-sm text-stone-900 hover:bg-stone-100 dark:border-stone-700
+			   dark:bg-stone-900 dark:text-stone-100 dark:hover:bg-stone-800">
+	      絞り込む
+	    </button>
+	  </form>
+
+	  {isLoading
+	   ? 'Loading...'
+	   : isError
+	   ? (
+	      <p className="text-red-600 dark:text-red-300">
+		素材履歴の取得に失敗しました．
+	      </p>)
+	   : (
+	      <>
+		<div className="overflow-x-auto">
+		  <table className="w-full min-w-[1200px] table-fixed border-collapse">
+		    <colgroup>
+		      <col className="w-48"/>
+		      <col className="w-32"/>
+		      <col className="w-28"/>
+		      <col className="w-24"/>
+		      <col className="w-64"/>
+		      <col className="w-64"/>
+		      <col className="w-80"/>
+		      <col className="w-80"/>
+		      <col className="w-48"/>
+		    </colgroup>
+
+		    <thead className="border-b-2 border-black dark:border-white">
+		      <tr>
+			<th className="p-2 text-left">日時</th>
+			<th className="p-2 text-left">event_type</th>
+			<th className="p-2 text-left">素材 ID</th>
+			<th className="p-2 text-left">版</th>
+			<th className="p-2 text-left">タグ名</th>
+			<th className="p-2 text-left">ファイル名</th>
+			<th className="p-2 text-left">URL</th>
+			<th className="p-2 text-left">export_path</th>
+			<th className="p-2 text-left">操作者</th>
+		      </tr>
+		    </thead>
+
+		    <tbody>
+		      {versions.map (version => (
+			  <tr
+			      key={version.id}
+			      className="even:bg-gray-100 dark:even:bg-gray-700">
+			    <td className="p-2">{dateString (version.createdAt)}</td>
+			    <td className="p-2">{version.eventType}</td>
+			    <td className="p-2">
+			      <PrefetchLink to={`/materials/${ version.materialId }`}>
+				#{version.materialId}
+			      </PrefetchLink>
+			    </td>
+			    <td className="p-2">{version.versionNo}</td>
+			    <td className="p-2 break-all">{version.tagName}</td>
+			    <td className="p-2 break-all">{version.fileFilename}</td>
+			    <td className="p-2 break-all">{version.url}</td>
+			    <td className="p-2 break-all">
+			      {version.exportPathsJson.legacy_drive}
+			    </td>
+			    <td className="p-2">
+			      {version.createdByUser
+			       ? version.createdByUser.name || `#${ version.createdByUser.id }`
+			       : 'bot 操作'}
+			    </td>
+			  </tr>))}
+		    </tbody>
+		  </table>
+		</div>
+
+		<Pagination page={page} totalPages={totalPages}/>
+	      </>)}
+	</div>
+      </MainArea>)
+}
+
+
+export default MaterialHistoryPage

frontend/src/pages/materials/MaterialListPage.tsx

@@ -23,7 +23,6 @@ import type {
     MaterialIndexDirection,
     MaterialIndexMediaKind,
     MaterialIndexSort,
-    MaterialIndexSuppression,
     MaterialIndexTagState,
     MaterialIndexView } from '@/types'
 
@@ -32,8 +31,7 @@ const MEDIA_KIND_LABELS: Record<Material['mediaKind'], string> = {
     video:      '動画',
     audio:      '音声',
     file_other: 'その他ファイル',
-    url_only:   'URL のみ',
-    suppressed: '抑止済み'}
+    url_only:   'URL のみ'}
 
 const MEDIA_FILTER_LABELS: Record<MaterialIndexMediaKind, string> = {
     all:        'すべて',
@@ -84,14 +82,9 @@ const materialTitle = (material: Material): string =>
 const MaterialThumb: FC<{ material: Material }> = ({ material }) => (
     <div
 	className={`flex aspect-square h-[180px] w-[180px] items-center justify-center
-		    overflow-hidden rounded-lg border text-center shadow-sm ${
-		    material.fileSuppressedAt
-		    ? [
-			'border-red-300 bg-red-50 text-red-900 dark:border-red-800',
-			'dark:bg-red-950 dark:text-red-100'].join (' ')
-		    : [
-			'border-stone-200 bg-white text-stone-900 dark:border-stone-700',
-			'dark:bg-stone-900 dark:text-stone-100'].join (' ') }`}>
+		    overflow-hidden rounded-lg border border-stone-200 bg-white text-center
+		    text-stone-900 shadow-sm dark:border-stone-700 dark:bg-stone-900
+		    dark:text-stone-100`}>
       {material.thumbnail
        ? <img src={material.thumbnail} alt="" className="h-full w-full object-contain"/>
        : (
@@ -123,14 +116,8 @@ const MaterialCard: FC<{ material: Material }> = ({ material }) => (
 
 const MaterialListItem: FC<{ material: Material }> = ({ material }) => (
     <article
-	className={`rounded-lg border p-3 shadow-sm ${
-		    material.fileSuppressedAt
-		    ? [
-			'border-red-200 bg-red-50 text-red-900 dark:border-red-900',
-			'dark:bg-red-950 dark:text-red-100'].join (' ')
-		    : [
-			'border-stone-200 bg-white text-stone-900 dark:border-stone-700',
-			'dark:bg-stone-900 dark:text-stone-100'].join (' ')}`}>
+	className="rounded-lg border border-stone-200 bg-white p-3 text-stone-900
+		   shadow-sm dark:border-stone-700 dark:bg-stone-900 dark:text-stone-100">
       <div className="flex gap-3">
 	<MaterialThumb material={material}/>
 	<div className="min-w-0 flex-1 space-y-2">
@@ -141,8 +128,6 @@ const MaterialListItem: FC<{ material: Material }> = ({ material }) => (
 			   dark:text-sky-300">
 	      {materialTitle (material)}
 	    </PrefetchLink>
-	    {material.fileSuppressedAt && (
-		<p className="mt-1 text-sm text-red-700 dark:text-red-200">抑止済み</p>)}
 	  </div>
 	  <dl className="space-y-1 text-sm text-stone-600 dark:text-stone-300">
 	    <div>
@@ -188,10 +173,6 @@ const MaterialListPage: FC = () => {
       query.get ('media_kind'),
       ['all', 'image', 'video', 'audio', 'file_other', 'url_only'],
       'all')
-  const suppression = parseOption<MaterialIndexSuppression> (
-      query.get ('suppression'),
-      ['active', 'suppressed', 'all'],
-      'active')
   const sort = parseOption<MaterialIndexSort> (
       query.get ('sort'),
       ['created_at', 'updated_at', 'tag_name', 'media_kind', 'file_byte_size',
@@ -210,8 +191,6 @@ const MaterialListPage: FC = () => {
   const [q, setQ] = useState ('')
   const [tagStateInput, setTagStateInput] = useState<MaterialIndexTagState> ('all')
   const [mediaKindInput, setMediaKindInput] = useState<MaterialIndexMediaKind> ('all')
-  const [suppressionInput, setSuppressionInput] =
-      useState<MaterialIndexSuppression> ('active')
   const [createdFrom, setCreatedFrom] = useState<string | null> (null)
   const [createdTo, setCreatedTo] = useState<string | null> (null)
   const [updatedFrom, setUpdatedFrom] = useState<string | null> (null)
@@ -221,7 +200,6 @@ const MaterialListPage: FC = () => {
       q: qQuery,
       tagState,
       mediaKind,
-      suppression,
       createdFrom: createdFromQuery,
       createdTo: createdToQuery,
       updatedFrom: updatedFromQuery,
@@ -241,12 +219,11 @@ const MaterialListPage: FC = () => {
     setQ (qQuery)
     setTagStateInput (tagState)
     setMediaKindInput (mediaKind)
-    setSuppressionInput (suppression)
     setCreatedFrom (createdFromQuery)
     setCreatedTo (createdToQuery)
     setUpdatedFrom (updatedFromQuery)
     setUpdatedTo (updatedToQuery)
-  }, [createdFromQuery, createdToQuery, mediaKind, qQuery, suppression, tagState,
+  }, [createdFromQuery, createdToQuery, mediaKind, qQuery, tagState,
       updatedFromQuery, updatedToQuery])
 
   const search = (e: FormEvent) => {
@@ -256,7 +233,6 @@ const MaterialListPage: FC = () => {
     setIf (qs, 'q', q)
     qs.set ('tag_state', tagStateInput)
     qs.set ('media_kind', mediaKindInput)
-    qs.set ('suppression', suppressionInput)
     setIf (qs, 'created_from', createdFrom)
     setIf (qs, 'created_to', createdTo)
     setIf (qs, 'updated_from', updatedFrom)
@@ -301,6 +277,20 @@ const MaterialListPage: FC = () => {
 			     dark:bg-stone-900 dark:text-stone-100 dark:hover:bg-stone-800">
 		新規素材を追加
 	      </PrefetchLink>
+	      <PrefetchLink
+		  to="/materials/suppressions"
+		  className="rounded-full border border-stone-300 bg-white px-4 py-2 text-sm
+			     text-stone-900 hover:bg-stone-100 dark:border-stone-700
+			     dark:bg-stone-900 dark:text-stone-100 dark:hover:bg-stone-800">
+		同期元抑止
+	      </PrefetchLink>
+	      <PrefetchLink
+		  to="/materials/changes"
+		  className="rounded-full border border-stone-300 bg-white px-4 py-2 text-sm
+			     text-stone-900 hover:bg-stone-100 dark:border-stone-700
+			     dark:bg-stone-900 dark:text-stone-100 dark:hover:bg-stone-800">
+		履歴
+	      </PrefetchLink>
 	      <a
 		  href={`${ API_BASE_URL }/materials/download.zip?profile=legacy_drive`}
 		  target="_blank"
@@ -363,19 +353,6 @@ const MaterialListPage: FC = () => {
 		    </select>)}
 	      </FormField>
 
-	      <FormField label="抑止状態">
-		{({ invalid }) => (
-		    <select
-			value={suppressionInput}
-			onChange={e => setSuppressionInput (
-			    e.target.value as MaterialIndexSuppression)}
-			className={inputClass (invalid)}>
-		      <option value="active">有効のみ</option>
-		      <option value="suppressed">抑止済みのみ</option>
-		      <option value="all">すべて</option>
-		    </select>)}
-	      </FormField>
-
 	      <FormField label="作成日時">
 		{() => (
 		    <div className="flex flex-wrap items-center gap-2">

frontend/src/pages/materials/MaterialSyncSuppressionsPage.tsx

@@ -0,0 +1,196 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { useState } from 'react'
+import { Helmet } from 'react-helmet-async'
+
+import PrefetchLink from '@/components/PrefetchLink'
+import FormField from '@/components/common/FormField'
+import PageTitle from '@/components/common/PageTitle'
+import MainArea from '@/components/layout/MainArea'
+import { Button } from '@/components/ui/button'
+import { toast } from '@/components/ui/use-toast'
+import { SITE_TITLE } from '@/config'
+import {
+    createMaterialSyncSuppression,
+    fetchMaterialSyncSuppressions,
+} from '@/lib/materials'
+import { materialsKeys } from '@/lib/queryKeys'
+import { dateString, inputClass } from '@/lib/utils'
+
+import type { FC, FormEvent } from 'react'
+
+import type { MaterialSyncSuppressionSourceKind } from '@/types'
+
+const SOURCE_KIND_LABELS: Record<MaterialSyncSuppressionSourceKind, string> = {
+    uri:               'URI',
+    google_drive_path: 'Google Drive path',
+    google_drive_path_prefix: 'Google Drive path prefix',
+    google_drive_file: 'Google Drive file ID',
+    legacy_drive_path: 'Legacy Drive path',
+    legacy_drive_path_prefix: 'Legacy Drive path prefix'}
+
+const REASONS = [
+    'copyright_high_risk',
+    'copyright_takedown',
+    'adult_or_sensitive',
+    'personal_information',
+    'malware_or_dangerous_file',
+    'duplicate_or_low_quality',
+    'source_owner_request',
+    'other']
+
+
+const MaterialSyncSuppressionsPage: FC = () => {
+  const qc = useQueryClient ()
+  const [sourceKind, setSourceKind] =
+      useState<MaterialSyncSuppressionSourceKind> ('uri')
+  const [sourceUri, setSourceUri] = useState ('')
+  const [drivePath, setDrivePath] = useState ('')
+  const [driveFileId, setDriveFileId] = useState ('')
+  const [reason, setReason] = useState (REASONS[0])
+
+  const { data, isError, isLoading } = useQuery ({
+      queryKey: materialsKeys.suppressions (),
+      queryFn:  fetchMaterialSyncSuppressions})
+
+  const createMutation = useMutation ({
+      mutationFn: async () =>
+	  await createMaterialSyncSuppression ({
+	      sourceKind,
+	      sourceUri,
+	      drivePath,
+	      driveFileId,
+	      reason}),
+      onSuccess: async () => {
+	await qc.invalidateQueries ({ queryKey: materialsKeys.suppressions () })
+	await qc.invalidateQueries ({ queryKey: materialsKeys.root })
+	setSourceUri ('')
+	setDrivePath ('')
+	setDriveFileId ('')
+	toast ({ title: '同期元抑止を登録しました' })
+      },
+      onError: () => {
+	toast ({ title: '同期元抑止の登録に失敗しました' })
+      }})
+
+  const handleSubmit = (event: FormEvent) => {
+    event.preventDefault ()
+    createMutation.mutate ()
+  }
+
+  const suppressions = data?.suppressions ?? []
+
+  return (
+      <MainArea>
+	<Helmet>
+	  <title>{`同期元抑止 | ${ SITE_TITLE }`}</title>
+	</Helmet>
+
+	<div className="space-y-5">
+	  <div className="flex flex-wrap items-center justify-between gap-3">
+	    <PageTitle>同期元抑止</PageTitle>
+	    <PrefetchLink
+		to="/materials"
+		className="text-sm text-sky-700 underline underline-offset-2 dark:text-sky-300">
+	      素材一覧へ戻る
+	    </PrefetchLink>
+	  </div>
+
+	  <form
+	      onSubmit={handleSubmit}
+	      className="max-w-3xl rounded-lg border border-stone-200 bg-white p-4
+			 text-stone-900 dark:border-stone-700 dark:bg-stone-900
+			 dark:text-stone-100">
+	    <div className="space-y-3">
+	      <FormField label="同期元種別">
+		{({ invalid }) => (
+		    <select
+			value={sourceKind}
+			onChange={e => setSourceKind (
+			    e.target.value as MaterialSyncSuppressionSourceKind)}
+			className={inputClass (invalid)}>
+		      {Object.entries (SOURCE_KIND_LABELS).map (([value, label]) => (
+			  <option key={value} value={value}>
+			    {label}
+			  </option>))}
+		    </select>)}
+	      </FormField>
+
+	      <FormField label="Source URI">
+		{({ invalid }) => (
+		    <input
+			type="text"
+			value={sourceUri}
+			onChange={e => setSourceUri (e.target.value)}
+			className={inputClass (invalid)}/>)}
+	      </FormField>
+
+	      <FormField label="Drive path">
+		{({ invalid }) => (
+		    <input
+			type="text"
+			value={drivePath}
+			onChange={e => setDrivePath (e.target.value)}
+			className={inputClass (invalid)}/>)}
+	      </FormField>
+
+	      <FormField label="Drive file ID">
+		{({ invalid }) => (
+		    <input
+			type="text"
+			value={driveFileId}
+			onChange={e => setDriveFileId (e.target.value)}
+			className={inputClass (invalid)}/>)}
+	      </FormField>
+
+	      <FormField label="理由">
+		{({ invalid }) => (
+		    <select
+			value={reason}
+			onChange={e => setReason (e.target.value)}
+			className={inputClass (invalid)}>
+		      {REASONS.map (value => (
+			  <option key={value} value={value}>
+			    {value}
+			  </option>))}
+		    </select>)}
+	      </FormField>
+	    </div>
+
+	    <Button
+		type="submit"
+		className="mt-4 rounded bg-blue-600 px-4 py-2 text-white
+			   disabled:bg-gray-400"
+		disabled={createMutation.isPending}>
+	      登録
+	    </Button>
+	  </form>
+
+	  {isLoading && <p>Loading...</p>}
+	  {isError && (
+	      <p className="text-red-600 dark:text-red-300">
+		同期元抑止一覧の取得に失敗しました．
+	      </p>)}
+
+	  <div className="space-y-3">
+	    {suppressions.map (suppression => (
+		<article
+		    key={suppression.id}
+		    className="rounded-lg border border-stone-200 bg-white p-3
+			       text-stone-900 shadow-sm dark:border-stone-700
+			       dark:bg-stone-900 dark:text-stone-100">
+		  <div className="font-medium">
+		    {SOURCE_KIND_LABELS[suppression.sourceKind]}
+		  </div>
+		  <div className="break-all text-sm text-stone-700 dark:text-stone-300">
+		    {suppression.normalizedSourceKey}
+		  </div>
+		  <div className="mt-2 text-sm text-stone-600 dark:text-stone-400">
+		    理由: {suppression.reason} / 登録: {dateString (suppression.createdAt)}
+		  </div>
+		</article>))}
+	  </div>
+	</div>
+      </MainArea>)
+}
+
+export default MaterialSyncSuppressionsPage

frontend/src/test/factories.ts

@@ -76,6 +76,11 @@ export const buildMaterial = (overrides: Partial<Material> = {}): Material => ({
   tag:                   buildTag (),
   file:                  null,
   url:                   null,
+  sourceKind:            null,
+  sourceUri:             null,
+  sourcePath:            null,
+  sourceFileId:          null,
+  normalizedSourceKey:   null,
   wikiPageBody:          null,
   thumbnail:             null,
   thumbnailFallbackText: 'テストタグ',
@@ -83,8 +88,6 @@ export const buildMaterial = (overrides: Partial<Material> = {}): Material => ({
   mediaKind:             'url_only',
   contentType:           null,
   fileByteSize:          null,
-  fileSuppressedAt:      null,
-  fileSuppressionReason: null,
   exportPaths:           {},
   exportItems:           [],
   createdAt:             '2026-01-02T03:04:05.000Z',

frontend/src/types.ts

@@ -86,8 +86,6 @@ export type MaterialIndexSort =
     | 'version_no'
     | 'id'
 
-export type MaterialIndexSuppression = 'active' | 'suppressed' | 'all'
-
 export type MaterialIndexTagState = 'all' | 'tagged' | 'untagged'
 
 export type MaterialIndexView = 'card' | 'list'
@@ -96,7 +94,6 @@ export type FetchMaterialsParams = {
     q:            string
     tagState:     MaterialIndexTagState
     mediaKind:    MaterialIndexMediaKind
-    suppression:  MaterialIndexSuppression
     createdFrom:  string
     createdTo:    string
     updatedFrom:  string
@@ -113,15 +110,18 @@ export type Material = {
     tag:                    Tag | null
     file:                   string | null
     url:                    string | null
+    sourceKind:             string | null
+    sourceUri:              string | null
+    sourcePath:             string | null
+    sourceFileId:           string | null
+    normalizedSourceKey:    string | null
     wikiPageBody?:          string | null
     thumbnail:              string | null
     thumbnailFallbackText:  string | null
     thumbnailFallbackKind:  'tag_name' | 'created_at'
-    mediaKind:              'image' | 'video' | 'audio' | 'file_other' | 'url_only' | 'suppressed'
+    mediaKind:              'image' | 'video' | 'audio' | 'file_other' | 'url_only'
     contentType:            string | null
     fileByteSize:           number | null
-    fileSuppressedAt:       string | null
-    fileSuppressionReason:  string | null
     exportPaths:            Record<string, string>
     exportItems:            MaterialExportItem[]
     createdAt:              string
@@ -129,6 +129,26 @@ export type Material = {
     updatedAt:              string
     updatedByUser:          { id: number; name: string } }
 
+export type MaterialSyncSuppressionSourceKind =
+    | 'uri'
+    | 'google_drive_path'
+    | 'google_drive_path_prefix'
+    | 'google_drive_file'
+    | 'legacy_drive_path'
+    | 'legacy_drive_path_prefix'
+
+export type MaterialSyncSuppression = {
+    id:                  number
+    sourceKind:          MaterialSyncSuppressionSourceKind
+    sourceUri:           string | null
+    drivePath:           string | null
+    driveFileId:         string | null
+    normalizedSourceKey: string
+    reason:              string
+    createdByUser:       { id: number; name: string } | null
+    createdAt:           string
+    updatedAt:           string }
+
 export type MaterialSidebarTag = {
     id:          number
     name:        string
@@ -150,6 +170,25 @@ export type MaterialExportItem = {
     exportPath:  string
     enabled:     boolean }
 
+export type MaterialVersion = {
+    id:               number
+    materialId:       number
+    versionNo:        number
+    eventType:        'create' | 'update' | 'discard' | 'restore'
+    tagId:            number | null
+    tagName:          string | null
+    tagCategory:      Category | null
+    url:              string | null
+    fileBlobId:       number | null
+    fileFilename:     string | null
+    fileContentType:  string | null
+    fileByteSize:     number | null
+    fileSha256:       string | null
+    exportPathsJson:  Record<string, string>
+    discardedAt:      string | null
+    createdByUser:    { id: number; name: string | null } | null
+    createdAt:        string }
+
 export type Menu = MenuItem[]
 
 export type MenuInvisibleItem = {