#399

AGENTS.md

@@ -114,6 +114,9 @@ npm run preview
 - Ruby: `render` 系メソッド呼び出しでは、keyword 引数付きでも括弧を書かない。
 - Ruby: never put a line break immediately before `)`.
 - Ruby: do not use `%w` or `%i`.
+- Ruby: TypeScript / TSX の associative syntax に近い感覚で読むこと。
+  Hash の `}` は block の `}` ではない。call の `)` も function 定義の
+  parameter-list `)` ではない。delimiter の役割を見誤らないこと。
 - In Ruby, when an `if` condition is split across multiple lines and combines
   clauses with `&&` or `||`, wrap the whole condition in parentheses.
 - Ruby hashes are not blocks; keep `}` on the same line as the final pair.
@@ -127,6 +130,152 @@ npm run preview
 - Keep the first element on the same line as `[` by default.
 - If an array would exceed the line limit, break after `[` and indent
   elements by 4 spaces.
+
+### Ruby delimiter and wrapping rules
+
+- Ruby でも、closing delimiter は glyph ではなく syntax role で判定する。
+  `}` が block close なのか hash close なのか、`)` が method call なのか
+  grouping なのかを区別してから配置すること。
+- Ruby の multi-line method call では、receiver / method と opening `(` を
+  同じ行に保ち、closing `)` を単独行へ落とさない。
+- Ruby の multi-line hash literal / keyword-like argument hash では、opening
+  `{` を最初の pair と同じ行に置き、closing `}` を最後の pair と同じ行に
+  置く。Prettier 的な縦開き・縦閉じをしない。
+- Ruby の `if` / `unless` / `case` 条件で、複数行に分けるだけで安易に
+  `if ... end` へ展開しない。局所の既存コードが modifier 形式ならそれに
+  そろえる。
+- Ruby の guard 条件は、1 行で収まるなら modifier 形式を優先する。2 行以上に
+  なるなら通常の block 形式へ切り替へてよい。
+- Ruby の method chain や call argument を折り返す際、call-site の `)`
+  直前で行を空けたり、closing delimiter を block のやうに独立させない。
+
+Bad:
+
+```rb
+source =
+  if params[:format] == 'google_sheets'
+    PostImportGoogleSheetsFetcher.fetch!(params[:source],
+                                         rate_key: current_user.id)
+  else
+    params[:source]
+  end
+parsed = PostImportSourceParser.new(
+  source:,
+  format:,
+  has_header: params[:has_header],
+  json_path: params[:json_path],
+).parse
+```
+
+Good:
+
+```rb
+source =
+    if params[:format] == 'google_sheets'
+      PostImportGoogleSheetsFetcher.fetch!(params[:source],
+                                           rate_key: current_user.id)
+    else
+      params[:source]
+    end
+parsed = PostImportSourceParser.new(
+    source:,
+    format:,
+    has_header: params[:has_header],
+    json_path: params[:json_path]).parse
+```
+
+Bad:
+
+```rb
+result[field] = {
+  'kind' => kind,
+  'value' => value['value'].to_s,
+  'columns' => Array(columns).map { Integer(_1) },
+}
+```
+
+Good:
+
+```rb
+result[field] = {
+    'kind' => kind,
+    'value' => value['value'].to_s,
+    'columns' => Array(columns).map { Integer(_1) } }
+```
+
+Bad:
+
+```rb
+unless rows.all? { |row|
+         values = Array(row['values'])
+         values.length <= columns.length &&
+           values.all? { |value|
+             value.is_a?(String) &&
+               value.bytesize <= PostImportSourceParser::MAX_CELL_BYTES
+           }
+       }
+  raise ArgumentError, '解析結果のセルが不正です．'
+end
+```
+
+Good:
+
+```rb
+raise ArgumentError, '解析結果のセルが不正です．' unless rows.all? { |row|
+  values = Array(row['values'])
+  values.length <= columns.length && values.all? { |value|
+    value.is_a?(String) && value.bytesize <= PostImportSourceParser::MAX_CELL_BYTES
+  }
+}
+```
+
+Bad:
+
+```rb
+if row['url'].to_s.bytesize > PostImportSourceParser::MAX_CELL_BYTES
+  raise ArgumentError, 'URL が長すぎます．'
+end
+```
+
+Good:
+
+```rb
+raise ArgumentError, 'URL が長すぎます．' if row['url'].to_s.bytesize > PostImportSourceParser::MAX_CELL_BYTES
+```
+
+Bad:
+
+```rb
+parameters = row.is_a?(ActionController::Parameters) ? row :
+  ActionController::Parameters.new(row)
+```
+
+Good:
+
+```rb
+parameters =
+    row.is_a?(ActionController::Parameters) ? row : ActionController::Parameters.new(row)
+```
+
+Bad:
+
+```rb
+PostTagSection.create!(
+  post_id: post.id,
+  tag_id:,
+  begin_ms:,
+  end_ms:,
+)
+```
+
+Good:
+
+```rb
+PostTagSection.create!(post_id: post.id,
+                       tag_id:,
+                       begin_ms:,
+                       end_ms:)
+```
 - TypeScript and Python: use GNU-style spacing before parentheses where
   syntactically valid.
 - Never write Ruby, TypeScript, or TSX lines longer than 99 characters.

backend/app/controllers/post_imports_controller.rb

@@ -1,48 +1,30 @@
 class PostImportsController < ApplicationController
   before_action :require_member!
 
-  def parse
-    source =
-        if params[:format] == 'google_sheets'
-          PostImportGoogleSheetsFetcher.fetch!(params[:source], rate_key: current_user.id)
-        else
-          params[:source]
-        end
-    format = params[:format] == 'google_sheets' ? 'csv' : params[:format]
-    parsed = PostImportSourceParser.new(source:, format:,
-                                        has_header: params[:has_header], json_path: params[:json_path]).parse
-    render json: parsed
-  rescue ArgumentError => e
-    render_bad_request(e.message)
-  end
-
   def preview
-    parsed = parsed_params
+    rows = PostImportPreviewer.new(existing: params[:existing]).preview_rows(
-    url_column = params[:url_column].presence || (parsed[:columns].length == 1 ? 0 : nil)
+        rows: PostImportUrlListParser.parse(params[:source]))
-    return render_bad_request('URL 列を選択してください．') if url_column.nil?
+    render json: { rows: }
-
-    rows = PostImportPreviewer.new(parsed:, url_column:, mappings: mappings_params,
-                                   existing: params[:existing]).preview
-    render json: parsed.slice(:columns).merge(rows:)
   rescue ArgumentError => e
     render_bad_request(e.message)
   end
 
   def validate
-    rows = validate_rows_params
+    rows = normalised_import_rows(allow_warning_fields: true)
     changed_row = Integer(params[:changed_row], exception: false)
-    result = PostImportPreviewer.new(parsed: { columns: [], rows: [] }, url_column: 0,
+    result =
-                                     mappings: {}, existing: params[:existing]).preview_rows(
+        PostImportPreviewer.new(existing: params[:existing])
-                                         rows:, fetch_metadata: changed_row,
+          .preview_rows(rows:, fetch_metadata: changed_row, metadata_cache: {})
-                                         metadata_cache: { })
     render json: { rows: result }
   rescue ArgumentError => e
     render_bad_request(e.message)
   end
 
   def create
-    result = PostImportRunner.new(actor: current_user, rows: create_rows_params,
+    result = PostImportRunner.new(
-                                  existing: params[:existing]).run
+        actor: current_user,
+        rows: normalised_import_rows,
+        existing: params[:existing]).run
     render json: result, status: result[:created].positive? ? :created : :ok
   rescue ArgumentError => e
     render_bad_request(e.message)
@@ -57,120 +39,7 @@ class PostImportsController < ApplicationController
     head :forbidden
   end
 
-  def parsed_params
+  def normalised_import_rows allow_warning_fields: false
-    value = params.require(:parsed).to_unsafe_h.deep_transform_keys { _1.to_s.underscore }
+    PostImportRowNormaliser.normalise!(params[:rows], allow_warning_fields:)
-    columns = Array(value['columns'])
-    rows = Array(value['rows'])
-    raise ArgumentError, '解析結果の形式が不正です．' unless columns.all?(Hash) && rows.all?(Hash)
-    raise ArgumentError, '取込件数が多すぎます．' if rows.length > PostImportSourceParser::MAX_ROWS
-    raise ArgumentError, '列数が多すぎます．' if columns.length > 50
-    unless rows.all? { |row| Array(row['values']).length <= columns.length &&
-                               Array(row['values']).all? { _1.is_a?(String) && _1.bytesize <= PostImportSourceParser::MAX_CELL_BYTES } }
-      raise ArgumentError, '解析結果のセルが不正です．'
-    end
-    raise ArgumentError, '解析結果が大きすぎます．' if rows.sum { Array(_1['values']).sum(&:bytesize) } > PostImportSourceParser::MAX_BYTES
-
-    parsed_rows = rows.map do |row|
-      source_row = Integer(row['source_row'], exception: false)
-      raise ArgumentError, '元行番号が不正です．' if source_row.nil? || source_row <= 0
-
-      { source_row:, values: Array(row['values']) }
-    end
-    raise ArgumentError, '元行番号が重複しています．' if parsed_rows.map { _1[:source_row] }.uniq.length != parsed_rows.length
-
-    { columns: columns.map { |column| column.slice('key', 'label') }, rows: parsed_rows }
-  end
-
-  def mappings_params
-    mappings = params[:mappings]
-    return { } if mappings.blank?
-    raise ArgumentError, '列割当ての形式が不正です．' unless mappings.is_a?(ActionController::Parameters)
-
-    raw = mappings.to_unsafe_h
-    unknown_fields = raw.keys - PostImportPreviewer::FIELDS
-    raise ArgumentError, '列割当て先が不正です．' if unknown_fields.present?
-
-    permitted = mappings.permit(*PostImportPreviewer::FIELDS.map { |field|
-      { field => [:kind, :value, { columns: [] }] }
-    }).to_h
-
-    raw.each_with_object({ }) do |(field, value), result|
-      raise ArgumentError, '列割当ての形式が不正です．' unless value.is_a?(Hash)
-      raise ArgumentError, '列割当ての項目が不正です．' unless (value.keys - ['kind', 'value', 'columns']).empty?
-
-      value = permitted.fetch(field)
-      kind = value['kind'].presence || 'columns'
-      raise ArgumentError, '列割当ての種別が不正です．' unless kind.in?(['columns', 'fixed'])
-      columns = value['columns']
-      unless columns.nil? || (columns.is_a?(Array) && columns.all? { |index| Integer(index, exception: false)&.>= 0 })
-        raise ArgumentError, '列番号が不正です．'
-      end
-      raise ArgumentError, '固定値が不正です．' if kind == 'fixed' && !value['value'].is_a?(String)
-
-      result[field] = { 'kind' => kind, 'value' => value['value'].to_s,
-                        'columns' => Array(columns).map { Integer(_1) } }
-    end
-  end
-
-  def validate_rows_params
-    rows = Array(params[:rows])
-    raise ArgumentError, '取込件数が多すぎます．' if rows.length > PostImportSourceParser::MAX_ROWS
-
-    normalised_rows = rows.map do |row|
-      value = ActionController::Parameters.new(row).permit(:source_row, :sourceRow, :url, :metadata_url, :metadataUrl,
-                                                            attributes: {}, provenance: {}, tag_sources: {},
-                                                            fetch_warnings: [], validation_warnings: [])
-      normalised = value.to_h.deep_transform_keys { _1.to_s.underscore }
-      attributes = normalised.fetch('attributes', { })
-      provenance = normalised.fetch('provenance', { })
-      allowed = PostImportPreviewer::FIELDS
-      unless attributes.is_a?(Hash) && provenance.is_a?(Hash) &&
-             (attributes.keys - allowed).empty? &&
-             (provenance.keys - (allowed + ['url'])).empty?
-        raise ArgumentError, '行の形式が不正です．'
-      end
-      unless provenance.values.all? { _1.in?(['automatic', 'mapped', 'fixed', 'manual']) }
-        raise ArgumentError, '値の由来が不正です．'
-      end
-      raise ArgumentError, 'セルが大きすぎます．' if [normalised['url'], *attributes.values].any? { _1.to_s.bytesize > PostImportSourceParser::MAX_CELL_BYTES }
-      if normalised['tag_sources'].present? &&
-         (!normalised['tag_sources'].is_a?(Hash) ||
-          (normalised['tag_sources'].keys - ['automatic', 'mapped', 'fixed', 'manual']).present?)
-        raise ArgumentError, 'タグ由来の形式が不正です．'
-      end
-      if normalised['tag_sources'].present? &&
-         (!normalised['tag_sources'].values.all?(String) ||
-          normalised['tag_sources'].values.any? { _1.bytesize > PostImportSourceParser::MAX_CELL_BYTES } ||
-          normalised['tag_sources'].values.sum(&:bytesize) > PostImportSourceParser::MAX_CELL_BYTES)
-        raise ArgumentError, 'タグ由来が大きすぎます．'
-      end
-
-      source_row = Integer(normalised['source_row'], exception: false)
-      raise ArgumentError, '元行番号が不正です．' if source_row.nil? || source_row <= 0
-
-      normalised['source_row'] = source_row
-      normalised.symbolize_keys
-    end
-    source_rows = normalised_rows.map { _1[:source_row] }
-    if source_rows.uniq.length != source_rows.length
-      raise ArgumentError, '元行番号が不正です．'
-    end
-
-    normalised_rows
-  end
-
-  def create_rows_params
-    rows = params[:rows]
-    raise ArgumentError, '取込行の形式が不正です．' unless rows.is_a?(Array)
-
-    rows.map do |row|
-      unless row.is_a?(Hash) || row.is_a?(ActionController::Parameters)
-        raise ArgumentError, '取込行の形式が不正です．'
-      end
-
-      parameters = row.is_a?(ActionController::Parameters) ? row : ActionController::Parameters.new(row)
-      parameters.permit(:source_row, :sourceRow, :url, :metadata_url, :metadataUrl,
-                        attributes: {}, provenance: {}, tag_sources: {}, tagSources: {}).to_h
-    end
   end
 end

backend/app/services/post_creator.rb

@@ -90,9 +90,15 @@ class PostCreator
     end
     PostTagSection.where(post_id: post.id).destroy_all
     sections.each do |tag_id, ranges|
-      ranges.each { |begin_ms, end_ms| PostTagSection.create!(post_id: post.id, tag_id:, begin_ms:, end_ms:) }
+      ranges.each do |begin_ms, end_ms|
+        PostTagSection.create!(post_id: post.id,
+                               tag_id:,
+                               begin_ms:,
+                               end_ms:)
+      end
     end
-    PostTag.where(post_id: post.id, tag_id: (current_ids - desired_ids).to_a).kept.find_each do |post_tag|
+    PostTag.where(post_id: post.id,
+                  tag_id: (current_ids - desired_ids).to_a).kept.find_each do |post_tag|
       post_tag.discard_by!(@actor)
     end
   end

backend/app/services/post_import_google_sheets_fetcher.rb

@@ -1,61 +0,0 @@
-class PostImportGoogleSheetsFetcher
-  HOST = 'docs.google.com'.freeze
-  PUBLICATION_ID = /\A[A-Za-z0-9_-]+\z/
-  GID = /\A\d+\z/
-  RATE_LIMIT = 10
-  RATE_WINDOW = 1.minute
-
-  def self.fetch! raw_url, rate_key:
-    new(raw_url, rate_key:).fetch!
-  end
-
-  def initialize raw_url, rate_key:
-    @raw_url = raw_url.to_s
-    @rate_key = rate_key.to_s
-  end
-
-  def fetch!
-    publication_id, gid = parse!
-    throttle!
-    csv_url = "https://#{ HOST }/spreadsheets/d/e/#{ publication_id }/pub?gid=#{ gid }&single=true&output=csv"
-    response = Preview::HttpFetcher.fetch(csv_url,
-                                          max_bytes: PostImportSourceParser::MAX_BYTES,
-                                          allowed_hosts: [HOST])
-    raise ArgumentError, 'スプレッドシートを CSV として取得できませんでした．' unless csv?(response)
-
-    response.body
-  rescue Preview::UrlSafety::UnsafeUrl, Preview::HttpFetcher::FetchFailed,
-         Preview::HttpFetcher::ResponseTooLarge => e
-    Rails.logger.info("post_import_google_sheets_fetch_failure #{ { error: e.class.name, message: e.message }.to_json }")
-    raise ArgumentError, 'スプレッドシートを取得できませんでした．ウェブ公開 URL を確認するか、ファイル保存又はコピー貼付けを使用してください．'
-  end
-
-  private
-
-  def parse!
-    uri = URI.parse(@raw_url)
-    unless uri.scheme == 'https' && uri.host&.downcase == HOST && uri.query.blank?
-      raise ArgumentError, '公開 Google スプレッドシート URL を指定してください．'
-    end
-    match = uri.path.match(%r{\A/spreadsheets/d/e/([^/]+)/pubhtml\z})
-    gid = URI.decode_www_form(uri.fragment.to_s).to_h['gid']
-    unless match && PUBLICATION_ID.match?(match[1]) && GID.match?(gid.to_s)
-      raise ArgumentError, '公開 Google スプレッドシート URL の publication_id 又は gid が不正です．'
-    end
-
-    [match[1], gid]
-  rescue URI::InvalidURIError
-    raise ArgumentError, '公開 Google スプレッドシート URL が不正です．'
-  end
-
-  def throttle!
-    key = "post-import-google-sheets:#{ @rate_key }"
-    count = Rails.cache.increment(key, 1, expires_in: RATE_WINDOW, initial: 0)
-    raise ArgumentError, 'スプレッドシート取得の回数が多すぎます．しばらくしてから再試行してください．' if count > RATE_LIMIT
-  end
-
-  def csv? response
-    type = response.content_type.to_s.downcase
-    type.include?('text/csv') || type.include?('application/csv')
-  end
-end

backend/app/services/post_import_previewer.rb

@@ -1,87 +1,22 @@
 class PostImportPreviewer
-  FIELDS = %w[title thumbnail_base original_created_from original_created_before duration tags parent_post_ids].freeze
+  FIELDS = [
-
+    'title',
-  def initialize parsed:, url_column:, mappings: { }, existing: 'skip'
+    'thumbnail_base',
-    @parsed = parsed
+    'original_created_from',
-    @url_column = url_column.to_i
+    'original_created_before',
-    @mappings = mappings.stringify_keys
+    'duration',
+    'tags',
+    'parent_post_ids',
+  ].freeze
+  def initialize existing: 'skip'
     @existing = existing == 'error' ? 'error' : 'skip'
   end
 
-  def preview
-    preview_rows(rows: @parsed[:rows])
-  end
-
   def preview_rows rows:, fetch_metadata: true, metadata_cache: { }
-    urls = { }
+    urls = {}
-    rows.map do |row|
+    rows.map { |row|
-      row = row.symbolize_keys
+      preview_row(row, urls:, fetch_metadata:, metadata_cache:)
-      values = row[:values] || []
+    }
-      attributes = row[:attributes]&.stringify_keys || FIELDS.to_h { |field| [field, mapped_value(field, values)] }
-      provenance = row[:provenance]&.stringify_keys || mapped_provenance(attributes)
-      tag_sources = row[:tag_sources]&.stringify_keys || initial_tag_sources(attributes, provenance)
-      tag_sources['manual'] = attributes['tags'].to_s if provenance['tags'] == 'manual'
-      url = row[:url].presence || values[@url_column].to_s.strip
-      url_for_metadata = normalised_url(url) || url
-      existing_post = normalised_url(url).present? && Post.exists?(url: normalised_url(url))
-      if existing_post && @existing == 'skip'
-        next { source_row: row[:source_row], url: normalised_url(url) || url, attributes:,
-               provenance:, tag_sources:, metadata_url: url_for_metadata,
-               fetch_warnings: [], validation_warnings: ['既存投稿のためスキップします．'],
-               warnings: ['既存投稿のためスキップします．'], validation_errors: { },
-               status: 'warning', existing: true }
-      end
-      url_changed = row[:metadata_url].present? && row[:metadata_url] != url_for_metadata
-      clear_automatic_values!(attributes, provenance, tag_sources) if url_changed
-      provenance['url'] ||= row[:url].present? ? 'manual' : 'mapped'
-      attributes['url'] = url
-      fetch_warnings = Array(row[:fetch_warnings]).dup
-      should_fetch =
-          case fetch_metadata
-          when true then true
-          when Integer then fetch_metadata == row[:source_row].to_i
-          when false, nil then false
-          else raise ArgumentError, 'メタデータ取得対象が不正です．'
-          end
-      metadata, fetch_warnings = metadata_for(url_for_metadata, should_fetch, metadata_cache, fetch_warnings)
-      metadata.each do |field, value|
-        if field == 'tags' && provenance[field] != 'manual'
-          tag_sources['automatic'] = value.to_s
-          attributes[field] = merged_tags(tag_sources)
-          next
-        end
-        next unless provenance[field] == 'automatic' || attributes[field].blank?
-
-        attributes[field] = value
-        provenance[field] = 'automatic'
-      end
-      normal_url = normalised_url(url)
-      errors = { }
-      errors[:url] = ['URL が不正です．'] if normal_url.blank?
-      validation_warnings = []
-      errors[:url] = ['URL が重複しています．'] if normal_url.present? && urls.key?(normal_url)
-      urls[normal_url] = true if normal_url.present?
-      if normal_url.present? && existing_post
-        @existing == 'error' ? errors[:url] = ['既存投稿です．'] : validation_warnings << '既存投稿のためスキップします．'
-      end
-      validate_basic_data(attributes, errors)
-      validate_preview_tags(merged_tags(tag_sources, provenance['tags']), errors, validation_warnings)
-      validate_parents(attributes['parent_post_ids'], errors)
-      attributes.delete('url')
-      attributes['tags'] = merged_tags(tag_sources, provenance['tags'])
-      { source_row: row[:source_row], url: normal_url || url, attributes:, provenance:, tag_sources:,
-        metadata_url: url_for_metadata,
-        fetch_warnings:, validation_warnings:, warnings: fetch_warnings + validation_warnings,
-        validation_errors: errors,
-        status: errors.present? ? 'error' : ((fetch_warnings + validation_warnings).present? ? 'warning' : 'ready'),
-        existing: normal_url.present? && Post.exists?(url: normal_url) }
-    end
-  end
-
-  def metadata_for url, fetch_metadata, cache, previous_warnings
-    return [{ }, previous_warnings] unless fetch_metadata
-
-    cache[url] ||= fetch_metadata(url)
   end
 
   def normalised_url value
@@ -90,59 +25,150 @@ class PostImportPreviewer
 
   private
 
-  def mapped_value field, values
+  def preview_row row, urls:, fetch_metadata:, metadata_cache:
-    mapping = @mappings[field]
+    row = row.symbolize_keys
-    return '' if mapping.blank?
+    attributes = initial_attributes(row)
-    return mapping['value'].to_s if mapping['kind'] == 'fixed'
+    provenance = initial_provenance(row)
+    tag_sources = initial_tag_sources(row, attributes, provenance)
+    url = row[:url].to_s.strip
+    provenance['url'] = 'manual'
+    normal_url = normalised_url(url)
+    url_for_metadata = normal_url || url
+    existing_post = normal_url.present? && Post.exists?(url: normal_url)
 
-    Array(mapping['columns']).filter_map { |index| values[index.to_i].to_s.presence }.join(field == 'tags' ? ' ' : '')
+    validation_warnings = []
-  end
+    validation_errors = {}
+    validation_errors[:url] = ['URL が不正です．'] if normal_url.blank?
+    validation_errors[:url] = ['URL が重複しています．'] if normal_url.present? && urls.key?(normal_url)
+    urls[normal_url] = true if normal_url.present?
+    if normal_url.present? && existing_post
+      if @existing == 'error'
+        validation_errors[:url] = ['既存投稿です．']
+      else
+        validation_warnings << '既存投稿のためスキップします．'
+      end
+    end
 
-  def mapped_provenance attributes
+    if row[:metadata_url].present? && row[:metadata_url] != url_for_metadata
-    attributes.to_h.to_h { |field, value|
+      clear_automatic_values!(attributes, provenance, tag_sources)
-      mapping = @mappings[field.to_s]
+    end
-      origin =
+
-          if value.present? && mapping&.[]('kind') == 'fixed'
+    fetch_warnings = Array(row[:fetch_warnings]).dup
-            'fixed'
+    should_fetch = should_fetch_metadata?(fetch_metadata, row[:source_row].to_i)
-          elsif value.present?
+    if should_fetch && !(existing_post && @existing == 'skip')
-            'mapped'
+      metadata, fetch_warnings =
-          else
+        metadata_for(url_for_metadata, metadata_cache, fetch_warnings)
-            'automatic'
+      apply_metadata!(attributes, provenance, tag_sources, metadata)
-          end
+    end
-      [field.to_s, origin]
+
+    attributes['url'] = url
+    validate_basic_data(attributes, validation_errors)
+    validate_preview_tags(
+      merged_tags(tag_sources, provenance['tags']),
+      validation_errors,
+      validation_warnings,
+    )
+    validate_parents(attributes['parent_post_ids'], validation_errors)
+    attributes.delete('url')
+    attributes['tags'] = merged_tags(tag_sources, provenance['tags'])
+
+    {
+      source_row: row[:source_row],
+      url: normal_url || url,
+      attributes:,
+      provenance:,
+      tag_sources:,
+      metadata_url: url_for_metadata,
+      fetch_warnings:,
+      validation_warnings:,
+      warnings: fetch_warnings + validation_warnings,
+      validation_errors:,
+      status: validation_errors.present? \
+                ? 'error' \
+                : ((fetch_warnings + validation_warnings).present? ? 'warning' : 'ready'),
+      existing: existing_post,
     }
   end
 
-  def initial_tag_sources attributes, provenance
+  def should_fetch_metadata? fetch_metadata, source_row
-    origin = provenance['tags'] == 'fixed' ? 'fixed' : 'mapped'
+    case fetch_metadata
-    { 'automatic' => '', 'mapped' => origin == 'mapped' ? attributes['tags'].to_s : '',
+    when true then true
-      'fixed' => origin == 'fixed' ? attributes['tags'].to_s : '', 'manual' => '' }
+    when Integer then fetch_metadata == source_row
+    when false, nil then false
+    else raise ArgumentError, 'メタデータ取得対象が不正です．'
+    end
   end
 
-  def merged_tags sources, origin = nil
+  def initial_attributes row
-    return sources['manual'].to_s if origin == 'manual'
+    attributes = row[:attributes]&.stringify_keys || {}
+    FIELDS.to_h { |field| [field, attributes[field].to_s] }
+  end
 
-    %w[automatic mapped fixed manual].flat_map { sources[_1].to_s.split }.uniq.join(' ')
+  def initial_provenance row
+    provenance = row[:provenance]&.stringify_keys || {}
+    FIELDS.to_h { |field| [field, provenance[field].presence || 'automatic'] }
+      .merge('url' => 'manual')
+  end
+
+  def initial_tag_sources row, attributes, provenance
+    sources = row[:tag_sources]&.stringify_keys || { 'automatic' => '', 'manual' => '' }
+    sources['automatic'] = sources['automatic'].to_s
+    sources['manual'] =
+      provenance['tags'] == 'manual' ? attributes['tags'].to_s : sources['manual'].to_s
+    sources
   end
 
   def clear_automatic_values! attributes, provenance, tag_sources
-    %w[title thumbnail_base original_created_from original_created_before duration].each do |field|
+    ['title', 'thumbnail_base', 'original_created_from',
+     'original_created_before', 'duration'].each do |field|
       attributes[field] = '' if provenance[field] == 'automatic'
     end
     tag_sources['automatic'] = ''
+    attributes['tags'] = merged_tags(tag_sources, provenance['tags'])
+  end
+
+  def metadata_for url, cache, previous_warnings
+    cache[url] ||= fetch_metadata(url)
   end
 
   def fetch_metadata url
-    return [{ }, ['URL が空です．']] if url.blank?
+    return [{}, ['URL が空です．']] if url.blank?
 
     data = PostMetadataFetcher.fetch(url).stringify_keys
     warnings = []
     warnings << 'タイトルを取得できませんでした．' if data['title'].blank?
     warnings << 'サムネールを取得できませんでした．' if data['thumbnail_base'].blank?
     [data.compact, warnings]
-  rescue Preview::UrlSafety::UnsafeUrl, Preview::HttpFetcher::FetchFailed, Preview::HttpFetcher::ResponseTooLarge => e
+  rescue Preview::UrlSafety::UnsafeUrl,
-    Rails.logger.info("post_import_metadata_fetch_failure #{ { error: e.class.name, message: e.message }.to_json }")
+         Preview::HttpFetcher::FetchFailed,
-    [{ }, ['メタデータを取得できませんでした．']]
+         Preview::HttpFetcher::ResponseTooLarge => e
+    Rails.logger.info(
+      "post_import_metadata_fetch_failure "\
+      "#{ { error: e.class.name, message: e.message }.to_json }",
+    )
+    [{}, ['メタデータを取得できませんでした．']]
+  end
+
+  def apply_metadata! attributes, provenance, tag_sources, metadata
+    metadata.each do |field, value|
+      if field == 'tags'
+        next if provenance['tags'] == 'manual'
+
+        tag_sources['automatic'] = value.to_s
+        attributes['tags'] = merged_tags(tag_sources)
+        next
+      end
+      next unless provenance[field] == 'automatic' || attributes[field].blank?
+
+      attributes[field] = value
+      provenance[field] = 'automatic'
+    end
+  end
+
+  def merged_tags sources, origin = nil
+    return sources['manual'].to_s if origin == 'manual'
+
+    sources['automatic'].to_s
   end
 
   def validate_preview_tags raw, errors, warnings
@@ -152,6 +178,7 @@ class PostImportPreviewer
       errors[:tags] = ['ニコニコ・タグは直接指定できません．']
       return
     end
+
     parsed = names.map { |name| TagName.canonicalise(name.sub(/\[.*\]\z/, '')).first }
     existing = Tag.joins(:tag_name).where(tag_names: { name: parsed }).includes(:tag_name).to_a
     deprecated = existing.select(&:deprecated?).map(&:name)
@@ -190,7 +217,10 @@ class PostImportPreviewer
   def validate_parents raw, errors
     ids = raw.to_s.split.map { Integer(_1, exception: false) }
     return if ids.compact.empty? && raw.to_s.blank?
+
     errors[:parent_post_ids] = ['親投稿 Id. が不正です．'] and return if ids.any? { _1.nil? || _1 <= 0 }
-    errors[:parent_post_ids] = ['存在しない親投稿 Id. があります．'] if Post.where(id: ids).count != ids.uniq.length
+    if Post.where(id: ids).count != ids.uniq.length
+      errors[:parent_post_ids] = ['存在しない親投稿 Id. があります．']
+    end
   end
 end

backend/app/services/post_import_row_normaliser.rb

@@ -0,0 +1,162 @@
+class PostImportRowNormaliser
+  ORIGINS = ['automatic', 'manual'].freeze
+  STRING_FIELDS = [
+    'title',
+    'thumbnail_base',
+    'original_created_from',
+    'original_created_before',
+    'tags',
+    'parent_post_ids',
+  ].freeze
+  FLEXIBLE_FIELDS = ['duration', 'video_ms'].freeze
+  ATTRIBUTE_FIELDS = (STRING_FIELDS + FLEXIBLE_FIELDS).freeze
+
+  def self.normalise! rows, allow_warning_fields: false
+    raise ArgumentError, '取込行の形式が不正です．' unless rows.is_a?(Array)
+    raise ArgumentError, '取込件数が多すぎます．' if rows.length > PostImportUrlListParser::MAX_ROWS
+
+    normalised_rows = rows.map { normalise_row!(_1, allow_warning_fields:) }
+    source_rows = normalised_rows.map { _1['source_row'] }
+    raise ArgumentError, '元行番号が重複しています．' if source_rows.uniq.length != source_rows.length
+    if normalised_rows.sum { row_bytesize(_1) } > PostImportUrlListParser::MAX_BYTES
+      raise ArgumentError, '取込データが大きすぎます．'
+    end
+
+    normalised_rows
+  end
+
+  def self.normalise_row! row, allow_warning_fields:
+    unless row.is_a?(Hash) || row.is_a?(ActionController::Parameters)
+      raise ArgumentError, '取込行の形式が不正です．'
+    end
+
+    parameters =
+        row.is_a?(ActionController::Parameters) ? row : ActionController::Parameters.new(row)
+    permitted = parameters.permit(*permitted_keys(allow_warning_fields))
+    normalised = permitted.to_h.deep_transform_keys { _1.to_s.underscore }
+
+    normalised['source_row'] = normalise_source_row!(normalised['source_row'])
+    normalise_url!(normalised['url'])
+    normalise_metadata_url!(normalised['metadata_url'])
+    normalise_attributes!(normalised.fetch('attributes', { }))
+    normalise_provenance!(normalised.fetch('provenance', { }))
+    normalise_tag_sources!(normalised['tag_sources'])
+    normalise_warning_values!(normalised, allow_warning_fields:)
+    if row_bytesize(normalised) > PostImportUrlListParser::MAX_BYTES
+      raise ArgumentError, '取込行が大きすぎます．'
+    end
+
+    normalised
+  end
+
+  def self.permitted_keys allow_warning_fields
+    keys = [
+      :source_row,
+      :sourceRow,
+      :url,
+      :metadata_url,
+      :metadataUrl,
+      { attributes: {} },
+      { provenance: {} },
+      { tag_sources: {} },
+      { tagSources: {} },
+    ]
+    return keys unless allow_warning_fields
+
+    keys + [
+      { fetch_warnings: [] },
+      { fetchWarnings: [] },
+      { validation_warnings: [] },
+      { validationWarnings: [] },
+    ]
+  end
+  private_class_method :permitted_keys
+
+  def self.normalise_source_row! value
+    source_row = Integer(value, exception: false)
+    raise ArgumentError, '元行番号が不正です．' if source_row.nil? || source_row <= 0
+
+    source_row
+  end
+  private_class_method :normalise_source_row!
+
+  def self.normalise_url! value
+    raise ArgumentError, 'URL の形式が不正です．' unless value.is_a?(String)
+    raise ArgumentError, 'URL が長すぎます．' if value.bytesize > PostImportUrlListParser::MAX_URL_BYTES
+  end
+  private_class_method :normalise_url!
+
+  def self.normalise_metadata_url! value
+    raise ArgumentError, 'metadata_url の形式が不正です．' unless value.nil? || value.is_a?(String)
+    if value.to_s.bytesize > PostImportUrlListParser::MAX_URL_BYTES
+      raise ArgumentError, 'metadata_url が長すぎます．'
+    end
+  end
+  private_class_method :normalise_metadata_url!
+
+  def self.normalise_attributes! attributes
+    raise ArgumentError, 'attributes の形式が不正です．' unless attributes.is_a?(Hash)
+    raise ArgumentError, '取込項目が不正です．' unless (attributes.keys - ATTRIBUTE_FIELDS).empty?
+
+    attributes.each do |key, value|
+      case key
+      when *STRING_FIELDS
+        raise ArgumentError, '取込項目の型が不正です．' unless value.nil? || value.is_a?(String)
+      when *FLEXIBLE_FIELDS
+        unless value.nil? || value.is_a?(String) || value.is_a?(Numeric)
+          raise ArgumentError, '取込項目の型が不正です．'
+        end
+      end
+      if value.to_s.bytesize > PostImportUrlListParser::MAX_URL_BYTES
+        raise ArgumentError, '取込項目が大きすぎます．'
+      end
+    end
+  end
+  private_class_method :normalise_attributes!
+
+  def self.normalise_provenance! provenance
+    raise ArgumentError, 'provenance の形式が不正です．' unless provenance.is_a?(Hash)
+
+    allowed = ATTRIBUTE_FIELDS + ['url']
+    raise ArgumentError, '値の由来が不正です．' unless (provenance.keys - allowed).empty?
+    raise ArgumentError, '値の由来が不正です．' unless provenance.values.all? { ORIGINS.include?(_1) }
+  end
+  private_class_method :normalise_provenance!
+
+  def self.normalise_tag_sources! tag_sources
+    return if tag_sources.nil?
+
+    raise ArgumentError, 'タグ由来の形式が不正です．' unless tag_sources.is_a?(Hash)
+    raise ArgumentError, 'タグ由来の形式が不正です．' unless (tag_sources.keys - ORIGINS).empty?
+    raise ArgumentError, 'タグ由来の形式が不正です．' unless tag_sources.values.all? { _1.is_a?(String) }
+    if tag_sources.values.any? { _1.bytesize > PostImportUrlListParser::MAX_URL_BYTES }
+      raise ArgumentError, 'タグ由来が大きすぎます．'
+    end
+    if tag_sources.values.sum(&:bytesize) > PostImportUrlListParser::MAX_URL_BYTES
+      raise ArgumentError, 'タグ由来が大きすぎます．'
+    end
+  end
+  private_class_method :normalise_tag_sources!
+
+  def self.normalise_warning_values! normalised, allow_warning_fields:
+    return unless allow_warning_fields
+
+    %w[fetch_warnings validation_warnings].each do |field|
+      values = normalised[field]
+      next if values.nil?
+
+      unless values.is_a?(Array) && values.all? { _1.is_a?(String) }
+        raise ArgumentError, '警告の形式が不正です．'
+      end
+      if values.any? { _1.bytesize > PostImportUrlListParser::MAX_URL_BYTES }
+        raise ArgumentError, '警告が大きすぎます．'
+      end
+    end
+  end
+  private_class_method :normalise_warning_values!
+
+  def self.row_bytesize row
+    row.to_json.bytesize
+  end
+  private_class_method :row_bytesize
+end

backend/app/services/post_import_runner.rb

@@ -1,6 +1,4 @@
 class PostImportRunner
-  MAX_ROWS = PostImportSourceParser::MAX_ROWS
-  ATTRIBUTE_KEYS = %w[title thumbnail_base original_created_from original_created_before duration tags parent_post_ids video_ms].freeze
   def initialize actor:, rows:, existing: 'skip'
     @actor = actor
     @rows = rows
@@ -8,38 +6,43 @@ class PostImportRunner
   end
 
   def run
-    raise ArgumentError, "取込件数は #{ MAX_ROWS } 件までです．" if @rows.length > MAX_ROWS
+    normalised_rows = PostImportRowNormaliser.normalise!(@rows)
-    raise ArgumentError, '取込データが大きすぎます．' if @rows.sum { |row| row.to_json.bytesize } > PostImportSourceParser::MAX_BYTES
-
-    normalised_rows = @rows.map { |row| normalise_row(row) }
-    source_rows = normalised_rows.map { _1['source_row'] }
-    raise ArgumentError, '元行番号が重複しています．' if source_rows.uniq.length != source_rows.length
 
     results = normalised_rows.map { |row| run_row(row) }
-    { created: results.count { _1[:status] == 'created' }, skipped: results.count { _1[:status] == 'skipped' },
+    {
-      failed: results.count { _1[:status] == 'failed' }, rows: results }
+      created: results.count { _1[:status] == 'created' },
+      skipped: results.count { _1[:status] == 'skipped' },
+      failed: results.count { _1[:status] == 'failed' },
+      rows: results,
+    }
   end
 
   private
 
   def run_row row
-    validate_row_structure!(row)
+    attributes = row.fetch('attributes', { }).transform_keys { _1.to_s.underscore }
-    attributes = row.fetch('attributes', { }).to_h.transform_keys { _1.to_s.underscore }
+    preview = PostImportPreviewer.new(existing: @existing)
-    raise ArgumentError, '取込項目が不正です．' unless (attributes.keys - ATTRIBUTE_KEYS).empty?
+      .preview_rows(
-    raise ArgumentError, '取込項目が大きすぎます．' if attributes.values.any? { _1.to_s.bytesize > PostImportSourceParser::MAX_CELL_BYTES }
+        rows: [{
-    raise ArgumentError, 'URL が長すぎます．' if row['url'].to_s.bytesize > PostImportSourceParser::MAX_CELL_BYTES
+          source_row: row['source_row'],
-    validate_tag_sources!(row['tag_sources'])
+          url: row['url'],
-    preview = PostImportPreviewer.new(parsed: { columns: [], rows: [] }, url_column: 0,
+          attributes:,
-                                      mappings: {}, existing: @existing).preview_rows(
+          provenance: row['provenance'],
-                                          rows: [{ source_row: row['source_row'], url: row['url'],
+          tag_sources: row['tag_sources'],
-                                                   attributes:, provenance: row['provenance'],
+        }],
-                                                   tag_sources: row['tag_sources'] }],
+        fetch_metadata: false).first
-                                          fetch_metadata: false).first
+    if @existing == 'skip' && preview[:existing]
-    if preview[:validation_errors].present?
+      return row.slice('source_row').merge(status: 'skipped')
-      return { source_row: row['source_row'], status: 'failed',
-               errors: preview[:validation_errors] }
     end
-    return row.slice('source_row').merge(status: 'skipped') if @existing == 'skip' && preview[:existing]
+
+    if preview[:validation_errors].present?
+      return {
+        source_row: row['source_row'],
+        status: 'failed',
+        errors: preview[:validation_errors],
+      }
+    end
+
     attributes['tags'] = preview[:attributes]['tags']
     attributes['url'] = row['url']
     post = PostCreator.new(actor: @actor, attributes:).create!
@@ -53,48 +56,9 @@ class PostImportRunner
   rescue ArgumentError, PostCreator::VideoMsParseError
     { source_row: row['source_row'], status: 'failed', errors: { base: ['入力値が不正です．'] } }
   rescue StandardError => e
-    Rails.logger.error("post_import_runner_failure #{ { error: e.class.name, message: e.message }.to_json }")
+    Rails.logger.error(
+      "post_import_runner_failure #{ { error: e.class.name, message: e.message }.to_json }",
+    )
     { source_row: row['source_row'], status: 'failed', errors: { base: ['登録中にエラーが発生しました．'] } }
   end
-
-  def validate_tag_sources! sources
-    return if sources.blank?
-
-    sources = sources.to_h
-    raise ArgumentError unless (sources.keys - %w[automatic mapped fixed manual]).empty?
-    raise ArgumentError unless sources.values.all?(String)
-    raise ArgumentError if sources.values.any? { _1.bytesize > PostImportSourceParser::MAX_CELL_BYTES }
-    raise ArgumentError if sources.values.sum(&:bytesize) > PostImportSourceParser::MAX_CELL_BYTES
-  end
-
-  def validate_row_structure! row
-    raise ArgumentError unless row['source_row'].is_a?(Integer) && row['source_row'].positive?
-    raise ArgumentError unless row['url'].is_a?(String)
-    raise ArgumentError unless row['attributes'].is_a?(Hash)
-    raise ArgumentError unless row['attributes'].values.all? { _1.is_a?(String) || _1.is_a?(Numeric) || _1 == true || _1 == false || _1.nil? }
-    provenance = row['provenance']
-    raise ArgumentError unless provenance.is_a?(Hash)
-    allowed = ATTRIBUTE_KEYS + ['url']
-    raise ArgumentError unless (provenance.keys - allowed).empty?
-    raise ArgumentError unless provenance.values.all? { _1.in?(['automatic', 'mapped', 'fixed', 'manual']) }
-    metadata_url = row['metadata_url']
-    raise ArgumentError unless metadata_url.nil? || metadata_url.is_a?(String)
-    raise ArgumentError if metadata_url.to_s.bytesize > PostImportSourceParser::MAX_CELL_BYTES
-    raise ArgumentError if row.to_json.bytesize > PostImportSourceParser::MAX_BYTES
-    tag_sources = row['tag_sources']
-    raise ArgumentError unless tag_sources.nil? || tag_sources.is_a?(Hash)
-  end
-
-  def normalise_row row
-    unless row.is_a?(Hash)
-      raise ArgumentError, '取込行の形式が不正です．'
-    end
-
-    normalised = row.deep_transform_keys { _1.to_s.underscore }
-    source_row = Integer(normalised['source_row'], exception: false)
-    raise ArgumentError, '元行番号が不正です．' if source_row.nil? || source_row <= 0
-
-    normalised['source_row'] = source_row
-    normalised
-  end
 end

backend/app/services/post_import_source_parser.rb

@@ -1,100 +0,0 @@
-require 'csv'
-
-class PostImportSourceParser
-  MAX_ROWS = 100
-  MAX_BYTES = 1.megabyte
-  MAX_CELL_BYTES = 20.kilobytes
-  MAX_COLUMNS = 50
-
-  def initialize source:, format:, has_header: false, json_path: nil
-    @source = source.to_s
-    @format = format.to_s
-    @has_header = ActiveModel::Type::Boolean.new.cast(has_header)
-    @json_path = json_path.to_s
-  end
-
-  def parse
-    raise ArgumentError, '入力が大きすぎます．' if @source.bytesize > MAX_BYTES
-
-    @format == 'json' ? parse_json : parse_delimited
-  end
-
-  private
-
-  def parse_delimited
-    separator = @format == 'csv' ? ',' : "\t"
-    table = CSV.parse(@source, col_sep: separator).map { |row| row.map { _1.to_s.strip } }
-    raise ArgumentError, '入力が空です．' if table.empty?
-
-    headers = @has_header ? table.shift : nil
-    ensure_limits!(table)
-    width = table.map(&:length).max.to_i
-    raise ArgumentError, "列数は #{ MAX_COLUMNS } 列までです．" if width > MAX_COLUMNS
-    { columns: (0...width).map { |index| { key: index.to_s,
-                                          label: "#{ column_name(index) }：#{ headers&.[](index).presence || '列' }" } },
-      rows: table.each_with_index.map { |values, index| { source_row: index + (@has_header ? 2 : 1), values: } } }
-  rescue CSV::MalformedCSVError => e
-    raise ArgumentError, "CSV・TSV の形式が不正です: #{ e.message }"
-  end
-
-  def parse_json
-    value = JSON.parse(@source, max_nesting: 20)
-    @json_path.split('.').reject(&:blank?).each do |part|
-      value =
-          case value
-          when Array
-            index = Integer(part, exception: false)
-            raise ArgumentError if index.nil? || index.negative? || index >= value.length
-
-            value[index]
-          when Hash
-            raise ArgumentError unless value.key?(part) || value.key?(part.to_sym)
-
-            value.key?(part) ? value[part] : value[part.to_sym]
-          else
-            raise ArgumentError
-          end
-    end
-    raise ArgumentError, 'JSON の投稿候補は配列にしてください．' unless value.is_a?(Array)
-
-    ensure_limits!(value)
-    unless value.all?(Hash)
-      invalid = value.each_with_index.filter_map { |item, index| index + 1 unless item.is_a?(Hash) }
-      raise ArgumentError, "JSON の投稿候補は object の配列にしてください: 行 #{ invalid.join(', ') }"
-    end
-    keys = value.flat_map(&:keys).map(&:to_s).uniq
-    raise ArgumentError, "列数は #{ MAX_COLUMNS } 列までです．" if keys.length > MAX_COLUMNS
-    { columns: keys.each_with_index.map { |key, index| { key:, label: "#{ column_name(index) }：#{ key }" } },
-      rows: value.each_with_index.map { |item, index| { source_row: index + 1,
-                                                         values: keys.map { |key|
-                                                           value = item.key?(key) ? item[key] : item[key.to_sym]
-                                                           json_cell(value)
-                                                         } } } }
-  rescue JSON::ParserError, KeyError, ArgumentError => e
-    raise ArgumentError, "JSON の形式が不正です: #{ e.message }"
-  end
-
-  def ensure_limits! rows
-    raise ArgumentError, "取込件数は #{ MAX_ROWS } 件までです．" if rows.length > MAX_ROWS
-    raise ArgumentError, 'セルが大きすぎます．' if rows.flatten.any? { _1.to_s.bytesize > MAX_CELL_BYTES }
-  end
-
-  def json_cell value
-    case value
-    when nil then ''
-    when String, Numeric, TrueClass, FalseClass then value.to_s
-    when Array, Hash then JSON.generate(value)
-    else raise ArgumentError, 'JSON のセル値が不正です．'
-    end
-  end
-
-  def column_name index
-    name = +''
-    loop do
-      name.prepend((65 + (index % 26)).chr)
-      index = (index / 26) - 1
-      break if index < 0
-    end
-    name
-  end
-end

backend/app/services/post_import_url_list_parser.rb

@@ -0,0 +1,23 @@
+class PostImportUrlListParser
+  MAX_ROWS = 100
+  MAX_BYTES = 1.megabyte
+  MAX_URL_BYTES = 20.kilobytes
+
+  def self.parse source
+    raw = source.to_s
+    raise ArgumentError, '入力が大きすぎます．' if raw.bytesize > MAX_BYTES
+
+    rows = raw.split(/\r\n|\n|\r/).each_with_index.filter_map { |line, index|
+      url = line.strip
+      next if url.blank?
+
+      raise ArgumentError, 'URL が長すぎます．' if url.bytesize > MAX_URL_BYTES
+
+      { source_row: index + 1, url: }
+    }
+    raise ArgumentError, 'URL を入力してください．' if rows.empty?
+    raise ArgumentError, "取込件数は #{ MAX_ROWS } 件までです．" if rows.length > MAX_ROWS
+
+    rows
+  end
+end

backend/app/services/post_metadata_fetcher.rb

@@ -1,10 +1,19 @@
 class PostMetadataFetcher
   def self.fetch raw_url
     uri, = Preview::UrlSafety.validate(raw_url)
-    response = Preview::HttpFetcher.fetch(uri.to_s, max_bytes: Preview::ThumbnailFetcher::HTML_MAX_BYTES)
+    response = Preview::HttpFetcher.fetch(
+      uri.to_s,
+      max_bytes: Preview::ThumbnailFetcher::HTML_MAX_BYTES,
+    )
     metadata = Preview::HtmlMetadataExtractor.extract(response)
     document = Nokogiri::HTML.parse(response.body)
-    content = -> name { document.at_css("meta[property='#{ name }'], meta[name='#{ name }']")&.[]('content')&.strip.presence }
+    content = lambda { |name|
+      document
+        .at_css("meta[property='#{ name }'], meta[name='#{ name }']")
+        &.[]('content')
+        &.strip
+        &.presence
+    }
     duration = content.call('og:video:duration') || content.call('video:duration')
     published = content.call('article:published_time') || content.call('date')
     created_range = original_created_range(published)
@@ -30,17 +39,19 @@ class PostMetadataFetcher
     raw = value.to_s.strip
     from = Time.zone.parse(raw)
     zone = '(?:Z|[+-]\d{2}:?\d{2})?'
-    before = case raw
+    before =
-             when /\A\d{4}\z/ then from + 1.year
+      case raw
-             when /\A\d{4}-\d{2}\z/ then from + 1.month
+      when /\A\d{4}\z/ then from + 1.year
-             when /\A\d{4}-\d{2}-\d{2}\z/ then from + 1.day
+      when /\A\d{4}-\d{2}\z/ then from + 1.month
-             when /\A\d{4}-\d{2}-\d{2}T\d{2}#{ zone }\z/ then from + 1.hour
+      when /\A\d{4}-\d{2}-\d{2}\z/ then from + 1.day
-             when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}#{ zone }\z/ then from + 1.minute
+      when /\A\d{4}-\d{2}-\d{2}T\d{2}#{ zone }\z/ then from + 1.hour
-             when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}#{ zone }\z/ then from + 1.second
+      when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}#{ zone }\z/ then from + 1.minute
-             when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.(\d+)#{ zone }\z/
+      when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}#{ zone }\z/ then from + 1.second
-               from + (10**(-Regexp.last_match(1).length))
+      when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.(\d+)#{ zone }\z/
-             else return nil
+        from + (10**(-Regexp.last_match(1).length))
-             end
+      else
+        return nil
+      end
     [from, before]
   rescue ArgumentError, TypeError
     nil

backend/app/services/preview/http_fetcher.rb

@@ -71,7 +71,10 @@ module Preview
       log_failure(:timeout, url: uri&.to_s || raw_url, error: e.class.name, message: e.message)
       raise FetchTimeout, e.message
     rescue SocketError, SystemCallError, OpenSSL::SSL::SSLError, EOFError => e
-      log_failure(:network_error, url: uri&.to_s || raw_url, error: e.class.name, message: e.message)
+      log_failure(:network_error,
+                  url: uri&.to_s || raw_url,
+                  error: e.class.name,
+                  message: e.message)
       raise FetchFailed, e.message
     end
 

backend/config/routes.rb

@@ -34,7 +34,6 @@ Rails.application.routes.draw do
   end
 
   scope 'posts/import', controller: :post_imports do
-    post :parse
     post :preview
     post :validate
     post '', action: :create

frontend/src/App.tsx

@@ -41,9 +41,11 @@ import NotFound from '@/pages/NotFound'
 import TOSPage from '@/pages/TOSPage.mdx'
 import PostDetailPage from '@/pages/posts/PostDetailPage'
 import PostHistoryPage from '@/pages/posts/PostHistoryPage'
+import PostImportResultPage from '@/pages/posts/PostImportResultPage'
+import PostImportReviewPage from '@/pages/posts/PostImportReviewPage'
+import PostImportSourcePage from '@/pages/posts/PostImportSourcePage'
 import PostListPage from '@/pages/posts/PostListPage'
 import PostNewPage from '@/pages/posts/PostNewPage'
-import PostImportPage from '@/pages/posts/PostImportPage'
 import PostSearchPage from '@/pages/posts/PostSearchPage'
 import ServiceUnavailable from '@/pages/ServiceUnavailable'
 import SettingPage from '@/pages/users/SettingPage'
@@ -76,7 +78,9 @@ const RouteTransitionWrapper = ({ animationMode, user, setUser }: {
 	    <Route path="/" element={<Navigate to="/posts" replace/>}/>
 	    <Route path="/posts" element={<PostListPage/>}/>
 	    <Route path="/posts/new" element={<PostNewPage user={user}/>}/>
-	    <Route path="/posts/import" element={<PostImportPage user={user}/>}/>
+	    <Route path="/posts/import" element={<PostImportSourcePage user={user}/>}/>
+	    <Route path="/posts/import/:sessionId/review" element={<PostImportReviewPage user={user}/>}/>
+	    <Route path="/posts/import/:sessionId/result" element={<PostImportResultPage user={user}/>}/>
 	    <Route path="/posts/search" element={<PostSearchPage/>}/>
 	    <Route path="/posts/:id" element={<PostDetailRoute user={user}/>}/>
 	    <Route path="/posts/changes" element={<PostHistoryPage/>}/>
@@ -115,7 +119,9 @@ const RouteTransitionWrapper = ({ animationMode, user, setUser }: {
 	  <Route path="/" element={<Navigate to="/posts" replace/>}/>
 	  <Route path="/posts" element={<PostListPage/>}/>
 	  <Route path="/posts/new" element={<PostNewPage user={user}/>}/>
-	  <Route path="/posts/import" element={<PostImportPage user={user}/>}/>
+	  <Route path="/posts/import" element={<PostImportSourcePage user={user}/>}/>
+	  <Route path="/posts/import/:sessionId/review" element={<PostImportReviewPage user={user}/>}/>
+	  <Route path="/posts/import/:sessionId/result" element={<PostImportResultPage user={user}/>}/>
 	  <Route path="/posts/search" element={<PostSearchPage/>}/>
 	  <Route path="/posts/:id" element={<PostDetailRoute user={user}/>}/>
 	  <Route path="/posts/changes" element={<PostHistoryPage/>}/>

frontend/src/components/TopNav.tsx

@@ -26,7 +26,7 @@ export const menuOutline = (
 	tag?: Tag | null
 	material?: Material | null
 	wikiId: number | null
-	user: User | null,
+	user: User | null
 	pathName: string },
 ): Menu => {
   const postCount = tag?.postCount ?? material?.tag?.postCount ?? 0
@@ -43,7 +43,7 @@ export const menuOutline = (
 	  { name: '一覧', to: '/posts' },
 	  { name: '検索', to: '/posts/search' },
 	  { name: '追加', to: '/posts/new' },
-	  { name: 'インポート', to: '/posts/import' },
+	  { name: '取込', to: '/posts/import' },
 	  { name: '全体履歴', to: '/posts/changes' },
 	  { name: 'ヘルプ', to: '/wiki/ヘルプ:広場' }] },
       { name: 'タグ', to: '/tags', subMenu: [

frontend/src/components/posts/import/PostImportRowDialog.tsx

@@ -0,0 +1,203 @@
+import FieldError from '@/components/common/FieldError'
+import PostImportStatusBadge from '@/components/posts/import/PostImportStatusBadge'
+import ThumbnailPreview from '@/components/posts/import/ThumbnailPreview'
+import { Button } from '@/components/ui/button'
+import { Dialog,
+	 DialogContent,
+	 DialogDescription,
+	 DialogFooter,
+	 DialogHeader,
+	 DialogTitle } from '@/components/ui/dialog'
+import { inputClass } from '@/lib/utils'
+
+import type { FC } from 'react'
+import { useEffect, useState } from 'react'
+
+import type { PostImportOrigin,
+	      PostImportRow } from '@/lib/postImportSession'
+
+type Draft = {
+    url:                   string
+    title:                 string
+    thumbnailBase:         string
+    originalCreatedFrom:   string
+    originalCreatedBefore: string
+    duration:              string
+    tags:                  string
+    parentPostIds:         string }
+
+type Props = {
+    open:         boolean
+    row:          PostImportRow | null
+    saving:       boolean
+    onOpenChange: (open: boolean) => void
+    onSave:       (draft: Draft) => Promise<boolean> }
+
+const originOf = (
+    row:   PostImportRow,
+    field: string,
+): PostImportOrigin =>
+    row.provenance[field] ?? 'automatic'
+
+const buildDraft = (row: PostImportRow): Draft => ({
+    url: row.url,
+    title: String (row.attributes.title ?? ''),
+    thumbnailBase: String (row.attributes.thumbnailBase ?? ''),
+    originalCreatedFrom: String (row.attributes.originalCreatedFrom ?? ''),
+    originalCreatedBefore: String (row.attributes.originalCreatedBefore ?? ''),
+    duration: String (row.attributes.duration ?? ''),
+    tags: String (row.attributes.tags ?? ''),
+    parentPostIds: String (row.attributes.parentPostIds ?? '') })
+
+
+const PostImportRowDialog: FC<Props> = (
+    { open, row, saving, onOpenChange, onSave },
+) => {
+    const [draft, setDraft] = useState<Draft | null> (null)
+
+    useEffect (() => {
+	if (open && row)
+	  setDraft (buildDraft (row))
+    }, [open, row])
+
+    if (!(row) || !(draft))
+      return null
+
+    const update = <Key extends keyof Draft,> (
+	key:   Key,
+	value: Draft[Key],
+    ) => {
+	setDraft (current =>
+	    current ? { ...current, [key]: value } : current)
+    }
+
+    const save = async () => {
+	if (await onSave (draft))
+	  onOpenChange (false)
+    }
+
+    return (
+	<Dialog open={open} onOpenChange={onOpenChange}>
+	  <DialogContent className="max-w-3xl px-6 pb-6 pt-7">
+	    <DialogHeader className="pl-8">
+	      <DialogTitle>投稿 {row.sourceRow} を編集</DialogTitle>
+	      <DialogDescription>
+		自動取得結果を確認し、必要な項目だけ修正してください．
+	      </DialogDescription>
+	    </DialogHeader>
+
+	    <div className="grid gap-6 md:grid-cols-[7rem_minmax(0,1fr)]">
+	      <div className="space-y-3">
+		<ThumbnailPreview
+		    url={draft.thumbnailBase}
+		    className="h-28 w-28"/>
+		<div className="flex flex-wrap gap-2">
+		  <PostImportStatusBadge value={row.status}/>
+		  <PostImportStatusBadge value={row.importStatus ?? 'pending'}/>
+		</div>
+	      </div>
+
+	      <div className="space-y-4">
+		<DialogField
+		    label="URL"
+		    value={draft.url}
+		    origin={originOf (row, 'url')}
+		    onChange={value => update ('url', value)}/>
+		<DialogField
+		    label="タイトル"
+		    value={draft.title}
+		    origin={originOf (row, 'title')}
+		    onChange={value => update ('title', value)}/>
+		<DialogField
+		    label="サムネール基底 URL"
+		    value={draft.thumbnailBase}
+		    origin={originOf (row, 'thumbnailBase')}
+		    onChange={value => update ('thumbnailBase', value)}/>
+		<div className="grid gap-4 md:grid-cols-2">
+		  <DialogField
+		      label="作成日時 From"
+		      value={draft.originalCreatedFrom}
+		      origin={originOf (row, 'originalCreatedFrom')}
+		      onChange={value => update ('originalCreatedFrom', value)}/>
+		  <DialogField
+		      label="作成日時 Before"
+		      value={draft.originalCreatedBefore}
+		      origin={originOf (row, 'originalCreatedBefore')}
+		      onChange={value => update ('originalCreatedBefore', value)}/>
+		</div>
+		<DialogField
+		    label="動画時間"
+		    value={draft.duration}
+		    origin={originOf (row, 'duration')}
+		    onChange={value => update ('duration', value)}/>
+		<DialogArea
+		    label="タグ"
+		    value={draft.tags}
+		    origin={originOf (row, 'tags')}
+		    onChange={value => update ('tags', value)}/>
+		<DialogField
+		    label="親投稿"
+		    value={draft.parentPostIds}
+		    origin={originOf (row, 'parentPostIds')}
+		    onChange={value => update ('parentPostIds', value)}/>
+		<FieldError messages={Object.values (row.validationErrors ?? { }).flat ()}/>
+		<FieldError messages={Object.values (row.importErrors ?? { }).flat ()}/>
+	      </div>
+	    </div>
+
+	    <DialogFooter>
+	      <Button
+		  type="button"
+		  variant="outline"
+		  onClick={() => onOpenChange (false)}>
+		取消し
+	      </Button>
+	      <Button
+		  type="button"
+		  onClick={save}
+		  disabled={saving}>
+		保存
+	      </Button>
+	    </DialogFooter>
+	  </DialogContent>
+	</Dialog>)
+}
+
+const DialogField = (
+    { label, value, origin, onChange }: {
+	label:    string
+	value:    string
+	origin:   PostImportOrigin
+	onChange: (value: string) => void },
+) => (
+    <label className="block space-y-1">
+      <span className="flex items-center gap-2 text-sm font-medium">
+	{label}
+	<PostImportStatusBadge value={origin}/>
+      </span>
+      <input
+	  value={value}
+	  onChange={ev => onChange (ev.target.value)}
+	  className={inputClass (false)}/>
+    </label>)
+
+const DialogArea = (
+    { label, value, origin, onChange }: {
+	label:    string
+	value:    string
+	origin:   PostImportOrigin
+	onChange: (value: string) => void },
+) => (
+    <label className="block space-y-1">
+      <span className="flex items-center gap-2 text-sm font-medium">
+	{label}
+	<PostImportStatusBadge value={origin}/>
+      </span>
+      <textarea
+	  value={value}
+	  rows={4}
+	  onChange={ev => onChange (ev.target.value)}
+	  className={inputClass (false)}/>
+    </label>)
+
+export default PostImportRowDialog

frontend/src/components/posts/import/PostImportRowSummary.tsx

@@ -0,0 +1,149 @@
+import { Button } from '@/components/ui/button'
+import { cn } from '@/lib/utils'
+
+import PostImportStatusBadge from '@/components/posts/import/PostImportStatusBadge'
+import ThumbnailPreview from '@/components/posts/import/ThumbnailPreview'
+
+import type { FC } from 'react'
+
+import type { PostImportRow } from '@/lib/postImportSession'
+
+type Props = {
+    row:     PostImportRow
+    onEdit:  () => void }
+
+const toneClass = (row: PostImportRow): string[] => {
+    const value = row.importStatus ?? row.status
+    switch (value)
+      {
+      case 'created':
+	return [
+	    'border-sky-200 bg-sky-50',
+	    'dark:border-sky-900 dark:bg-sky-950/30']
+      case 'skipped':
+	return [
+	    'border-stone-200 bg-stone-50',
+	    'dark:border-stone-800 dark:bg-stone-900/60']
+      case 'failed':
+      case 'error':
+	return [
+	    'border-rose-200 bg-rose-50',
+	    'dark:border-rose-900 dark:bg-rose-950/30']
+      case 'warning':
+	return [
+	    'border-amber-200 bg-amber-50',
+	    'dark:border-amber-900 dark:bg-amber-950/30']
+      default:
+	return [
+	    'border-border bg-white',
+	    'dark:border-neutral-700 dark:bg-neutral-900']
+      }
+}
+
+const summaryError = (row: PostImportRow): string | null => {
+    const validation = Object.values (row.validationErrors ?? { }).flat ()[0]
+    if (validation)
+      return validation
+
+    return Object.values (row.importErrors ?? { }).flat ()[0] ?? null
+}
+
+const summaryDate = (row: PostImportRow): string =>
+    [row.attributes.originalCreatedFrom, row.attributes.originalCreatedBefore]
+	.filter (_1 => typeof _1 === 'string' && _1 !== '')
+	.join (' ～ ')
+
+
+const PostImportRowSummary: FC<Props> = ({ row, onEdit }) => {
+    const error = summaryError (row)
+    const importStatus = row.importStatus ?? 'pending'
+
+    return (
+	<>
+	  <div
+	      className={cn (
+		  'hidden items-center gap-4 rounded-lg border p-4 md:grid',
+		  'md:grid-cols-[4rem_5rem_minmax(0,1fr)_auto_auto_auto]',
+		  toneClass (row),
+		  'hover:bg-slate-50',
+		  'dark:hover:bg-neutral-800',
+	      )}>
+	    <div className="space-y-1">
+	      <div className="text-sm font-medium">#{row.sourceRow}</div>
+	      <PostImportStatusBadge value={row.status}/>
+	    </div>
+	    <ThumbnailPreview
+		url={String (row.attributes.thumbnailBase ?? '')}
+		className="h-16 w-16"/>
+	    <div className="min-w-0 space-y-1">
+	      <div className="line-clamp-2 text-sm font-medium">
+		{String (row.attributes.title ?? '') || '（タイトル未取得）'}
+	      </div>
+	      <div className="truncate text-xs text-neutral-600 dark:text-neutral-300">
+		{row.url}
+	      </div>
+	      <div className="truncate text-xs text-neutral-500 dark:text-neutral-400">
+		{String (row.attributes.tags ?? '') || 'タグなし'}
+	      </div>
+	      <div className="text-xs text-neutral-500 dark:text-neutral-400">
+		{summaryDate (row) || '日時未取得'}
+		{row.attributes.duration ? ` / ${ row.attributes.duration }` : ''}
+	      </div>
+	    </div>
+	    <div className="space-y-1">
+	      <PostImportStatusBadge value={importStatus}/>
+	    </div>
+	    <div className="space-y-1">
+	      {error
+	       ? <PostImportStatusBadge value="error"/>
+	       : <PostImportStatusBadge value="ready"/>}
+	    </div>
+	    <div className="flex justify-end">
+	      <Button
+		  type="button"
+		  variant="outline"
+		  onClick={onEdit}
+		  disabled={row.importStatus === 'created'}>
+		編集
+	      </Button>
+	    </div>
+	  </div>
+
+	  <div
+	      className={cn (
+		  'space-y-3 rounded-lg border p-4 md:hidden',
+		  toneClass (row),
+	      )}>
+	    <div className="flex items-start gap-3">
+	      <ThumbnailPreview
+		  url={String (row.attributes.thumbnailBase ?? '')}
+		  className="h-20 w-20 shrink-0"/>
+	      <div className="min-w-0 flex-1 space-y-2">
+		<div className="line-clamp-2 text-sm font-medium">
+		  {String (row.attributes.title ?? '') || '（タイトル未取得）'}
+		</div>
+		<div className="truncate text-xs text-neutral-600 dark:text-neutral-300">
+		  {row.url}
+		</div>
+		<div className="flex flex-wrap gap-2">
+		  <PostImportStatusBadge value={row.status}/>
+		  <PostImportStatusBadge value={importStatus}/>
+		</div>
+		{error && (
+		    <div className="text-xs text-red-700 dark:text-red-200">
+		      {error}
+		    </div>)}
+	      </div>
+	    </div>
+	    <Button
+		type="button"
+		variant="outline"
+		onClick={onEdit}
+		disabled={row.importStatus === 'created'}>
+	      編集
+	    </Button>
+	  </div>
+	</>)
+}
+
+export default PostImportRowSummary

frontend/src/components/posts/import/PostImportStatusBadge.tsx

@@ -0,0 +1,70 @@
+import { cn } from '@/lib/utils'
+
+import type { FC } from 'react'
+
+import type { PostImportOrigin } from '@/lib/postImportSession'
+
+type BadgeValue =
+    'ready'
+    | 'warning'
+    | 'error'
+    | 'pending'
+    | 'created'
+    | 'skipped'
+    | 'failed'
+    | PostImportOrigin
+
+type Props = {
+    value: BadgeValue }
+
+const LABELS: Record<BadgeValue, string> = {
+    ready:     '登録可能',
+    warning:   '警告',
+    error:     '要修正',
+    pending:   '未登録',
+    created:   '登録済み',
+    skipped:   'スキップ',
+    failed:    '失敗',
+    automatic: '自動取得',
+    manual:    '手修正' }
+
+const STYLES: Record<BadgeValue, string[]> = {
+    ready: [
+	'border-emerald-300 bg-emerald-50 text-emerald-700',
+	'dark:border-emerald-900 dark:bg-emerald-950 dark:text-emerald-200'],
+    warning: [
+	'border-amber-300 bg-amber-50 text-amber-700',
+	'dark:border-amber-900 dark:bg-amber-950 dark:text-amber-200'],
+    error: [
+	'border-red-300 bg-red-50 text-red-700',
+	'dark:border-red-900 dark:bg-red-950 dark:text-red-200'],
+    pending: [
+	'border-slate-300 bg-slate-50 text-slate-700',
+	'dark:border-slate-700 dark:bg-slate-900 dark:text-slate-200'],
+    created: [
+	'border-sky-300 bg-sky-50 text-sky-700',
+	'dark:border-sky-900 dark:bg-sky-950 dark:text-sky-200'],
+    skipped: [
+	'border-stone-300 bg-stone-50 text-stone-700',
+	'dark:border-stone-700 dark:bg-stone-900 dark:text-stone-200'],
+    failed: [
+	'border-rose-300 bg-rose-50 text-rose-700',
+	'dark:border-rose-900 dark:bg-rose-950 dark:text-rose-200'],
+    automatic: [
+	'border-slate-300 bg-slate-50 text-slate-700',
+	'dark:border-slate-700 dark:bg-slate-900 dark:text-slate-200'],
+    manual: [
+	'border-purple-300 bg-purple-50 text-purple-700',
+	'dark:border-purple-900 dark:bg-purple-950 dark:text-purple-200'] }
+
+
+const PostImportStatusBadge: FC<Props> = ({ value }) => (
+    <span
+	className={cn (
+	    'inline-flex items-center rounded-full border px-2.5 py-1 text-xs font-medium',
+	    STYLES[value],
+	)}>
+      {LABELS[value]}
+    </span>)
+
+export default PostImportStatusBadge

frontend/src/components/posts/import/ThumbnailPreview.tsx

@@ -0,0 +1,48 @@
+import { useEffect, useState } from 'react'
+
+import type { FC } from 'react'
+
+
+type Props = {
+    url:       string
+    alt?:      string
+    className?: string }
+
+
+const ThumbnailPreview: FC<Props> = ({ url, alt = 'サムネール', className = 'h-16 w-16' }) => {
+    const [failed, setFailed] = useState (false)
+
+    useEffect (() => {
+	setFailed (false)
+    }, [url])
+
+    if (!(url))
+      {
+	return (
+	    <div
+		className={`${ className } flex items-center justify-center rounded border
+			    border-border bg-muted text-xs text-muted-foreground`}>
+	      なし
+	    </div>)
+      }
+
+    if (failed)
+      {
+	return (
+	    <div
+		className={`${ className } flex items-center justify-center rounded border
+			    border-red-300 bg-red-50 p-2 text-center text-xs text-red-700
+			    dark:border-red-900 dark:bg-red-950 dark:text-red-200`}>
+	      表示不可
+	    </div>)
+      }
+
+    return (
+	<img
+	    src={url}
+	    alt={alt}
+	    className={`${ className } rounded border border-border object-cover`}
+	    onError={() => setFailed (true)}/>)
+}
+
+export default ThumbnailPreview

frontend/src/lib/postImportSession.ts

@@ -0,0 +1,221 @@
+export type PostImportOrigin = 'automatic' | 'manual'
+export type PostImportRepairMode = 'all' | 'failed'
+export type PostImportStatus =
+    'pending'
+    | 'created'
+    | 'skipped'
+    | 'failed'
+export type PostImportResultStatus = 'created' | 'skipped' | 'failed'
+export type PostImportAttributeValue = string | number
+
+export type PostImportRow = {
+    sourceRow:         number
+    url:               string
+    attributes:        Record<string, PostImportAttributeValue>
+    warnings:          string[]
+    validationErrors:  Record<string, string[]>
+    importErrors?:     Record<string, string[]>
+    provenance:        Record<string, PostImportOrigin>
+    tagSources?:       Record<PostImportOrigin, string>
+    status:            'ready' | 'warning' | 'error'
+    existing:          boolean
+    metadataUrl?:      string
+    createdPostId?:    number
+    importStatus?:     PostImportStatus }
+
+export type PostImportResultRow = {
+    sourceRow: number
+    status:    PostImportResultStatus
+    post?:     { id: number }
+    errors?:   Record<string, string[]> }
+
+export type PostImportSession = {
+    version:    number
+    savedAt:    string
+    source:     string
+    existing:   'skip' | 'error'
+    rows:       PostImportRow[]
+    repairMode: PostImportRepairMode }
+
+const SESSION_VERSION = 1
+const SESSION_PREFIX = 'post-import-session:'
+const SOURCE_DRAFT_KEY = 'post-import-source-draft'
+
+
+export const createPostImportSessionId = (): string =>
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+    ? crypto.randomUUID ()
+    : `${ Date.now () }-${ Math.random ().toString (36).slice (2) }`
+
+
+export const loadPostImportSourceDraft = (): {
+    source:   string
+    existing: 'skip' | 'error' } => {
+    if (typeof window === 'undefined')
+      return { source: '', existing: 'skip' }
+
+    try
+    {
+	const raw = sessionStorage.getItem (SOURCE_DRAFT_KEY)
+	if (raw == null)
+	  return { source: '', existing: 'skip' }
+
+	const value = JSON.parse (raw) as {
+	    source?: string
+	    existing?: 'skip' | 'error' }
+	return {
+	    source: typeof value.source === 'string' ? value.source : '',
+	    existing: value.existing === 'error' ? 'error' : 'skip' }
+    }
+    catch
+    {
+	return { source: '', existing: 'skip' }
+    }
+}
+
+
+export const savePostImportSourceDraft = (
+    source:   string,
+    existing: 'skip' | 'error',
+) => {
+    if (typeof window === 'undefined')
+      return
+
+    sessionStorage.setItem (SOURCE_DRAFT_KEY, JSON.stringify ({ source, existing }))
+}
+
+
+const sessionKey = (sessionId: string): string => `${ SESSION_PREFIX }${ sessionId }`
+
+
+export const savePostImportSession = (
+    sessionId: string,
+    session:   Omit<PostImportSession, 'version' | 'savedAt'>,
+) => {
+    if (typeof window === 'undefined')
+      return
+
+    sessionStorage.setItem (sessionKey (sessionId), JSON.stringify ({
+	...session,
+	version: SESSION_VERSION,
+	savedAt: new Date ().toISOString () }))
+}
+
+
+export const loadPostImportSession = (
+    sessionId: string,
+): PostImportSession | null => {
+    if (typeof window === 'undefined')
+      return null
+
+    try
+    {
+	const raw = sessionStorage.getItem (sessionKey (sessionId))
+	if (raw == null)
+	  return null
+
+	const value = JSON.parse (raw) as Partial<PostImportSession>
+	if (value.version !== SESSION_VERSION || !(Array.isArray (value.rows)))
+	  return null
+
+	return {
+	    version: SESSION_VERSION,
+	    savedAt: typeof value.savedAt === 'string' ? value.savedAt : '',
+	    source: typeof value.source === 'string' ? value.source : '',
+	    existing: value.existing === 'error' ? 'error' : 'skip',
+	    rows: value.rows as PostImportRow[],
+	    repairMode: value.repairMode === 'failed' ? 'failed' : 'all' }
+    }
+    catch
+    {
+	return null
+    }
+}
+
+
+export const mergeValidatedImportRows = (
+    current:   PostImportRow[],
+    validated: PostImportRow[],
+): PostImportRow[] =>
+    current
+	.map (previous => {
+	    if (previous.importStatus === 'created')
+	      return previous
+
+	    const row = validated.find (_1 => _1.sourceRow === previous.sourceRow)
+	    return row
+		? {
+		    ...row,
+		    importStatus: previous.importStatus,
+		    createdPostId: previous.createdPostId,
+		    importErrors: previous.importErrors,
+		    validationErrors: row.validationErrors ?? { } }
+		: previous
+	})
+	.concat (validated.filter (row =>
+	    !(current.some (_1 => _1.sourceRow === row.sourceRow))))
+
+
+export const mergeImportResults = (
+    rows:    PostImportRow[],
+    results: PostImportResultRow[],
+): PostImportRow[] =>
+    rows.map (row => {
+	const result = results.find (_1 => _1.sourceRow === row.sourceRow)
+	return result
+	    ? {
+		...row,
+		importStatus: result.status,
+		createdPostId: result.post?.id,
+		importErrors: result.errors,
+		validationErrors: row.validationErrors }
+	    : row
+    })
+
+
+export const retryImportRow = (
+    rows:      PostImportRow[],
+    sourceRow: number,
+): PostImportRow[] =>
+    rows.map (row =>
+	row.sourceRow === sourceRow && row.importStatus === 'failed'
+	? { ...row, importStatus: 'pending', importErrors: undefined }
+	: row)
+
+
+export const rowMessages = (row: PostImportRow): string[] => [
+    ...row.warnings,
+    ...Object.values (row.validationErrors ?? { }).flat (),
+    ...Object.values (row.importErrors ?? { }).flat ()]
+
+
+export const countImportSourceLines = (source: string): number =>
+    source
+	.split (/\r\n|\n|\r/)
+	.map (_1 => _1.trim ())
+	.filter (_1 => _1 !== '')
+	.length
+
+
+export const countImportSourceValidLines = (source: string): number =>
+    source
+	.split (/\r\n|\n|\r/)
+	.map (_1 => _1.trim ())
+	.filter (_1 => /^https?:\/\//.test (_1))
+	.length
+
+
+export const submittableImportRows = (rows: PostImportRow[]): PostImportRow[] =>
+    rows.filter (row => row.importStatus == null || row.importStatus === 'pending')
+
+
+export const reviewSummaryCounts = (rows: PostImportRow[]) => ({
+    total: rows.length,
+    submittable: rows.filter (row =>
+	(row.importStatus == null || row.importStatus === 'pending')
+	&& Object.keys (row.validationErrors ?? { }).length === 0).length,
+    invalid: rows.filter (row => Object.keys (row.validationErrors ?? { }).length > 0).length,
+    skipPlanned: rows.filter (row =>
+	row.existing && row.importStatus !== 'created' && row.status !== 'error').length,
+    created: rows.filter (row => row.importStatus === 'created').length,
+    failed: rows.filter (row => row.importStatus === 'failed').length })

frontend/src/pages/posts/PostImportPage.tsx

@@ -1,402 +0,0 @@
-import { useEffect, useRef, useState } from 'react'
-import { Helmet } from 'react-helmet-async'
-
-import FieldError from '@/components/common/FieldError'
-import PrefetchLink from '@/components/PrefetchLink'
-import Form from '@/components/common/Form'
-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 { apiPost, isApiError } from '@/lib/api'
-import { canEditContent } from '@/lib/users'
-import { inputClass } from '@/lib/utils'
-import Forbidden from '@/pages/Forbidden'
-
-import type { FC } from 'react'
-
-import type { User } from '@/types'
-
-type Props = { user: User | null }
-type Column = { key: string, label: string }
-type ImportRow = {
-    sourceRow: number
-    url: string
-    attributes: Record<string, string>
-    warnings: string[]
-    validationErrors: Record<string, string[]>
-    importErrors?: Record<string, string[]>
-    provenance: Record<string, 'automatic' | 'mapped' | 'fixed' | 'manual'>
-    tagSources?: Record<'automatic' | 'mapped' | 'fixed' | 'manual', string>
-    status: 'ready' | 'warning' | 'error'
-    existing: boolean
-    metadataUrl?: string
-    createdPostId?: number
-    importStatus?: 'pending' | 'created' | 'skipped' | 'failed' }
-type ParsedImport = { columns: Column[], rows: { sourceRow: number, values: string[] }[] }
-type Phase = 'source' | 'mapping' | 'preview' | 'result'
-type ImportResultStatus = 'created' | 'skipped' | 'failed'
-
-
-const detectFormat = (source: string): 'csv' | 'tsv' =>
-    source.includes ('\t') ? 'tsv' : (source.includes (',') ? 'csv' : 'tsv')
-
-const publicGoogleSheetURL = (source: string): boolean =>
-    /^https:\/\/docs\.google\.com\/spreadsheets\/d\/e\/[A-Za-z0-9_-]+\/pubhtml#gid=\d+$/.test (
-        source.trim ())
-
-
-const PostImportPage: FC<Props> = ({ user }) => {
-  const [source, setSource] = useState ('')
-  const [phase, setPhase] = useState<Phase> ('source')
-  const [format, setFormat] = useState<'csv' | 'tsv' | 'json' | 'google_sheets'> ('tsv')
-  const [hasHeader, setHasHeader] = useState (false)
-  const [jsonPath, setJsonPath] = useState ('')
-  const [urlColumn, setUrlColumn] = useState ('')
-  const [parsed, setParsed] = useState<ParsedImport | null> (null)
-  const [columns, setColumns] = useState<Column[]> ([])
-  const [rows, setRows] = useState<ImportRow[]> ([])
-  const [results, setResults] = useState<{ sourceRow: number, status: ImportResultStatus, post?: { id: number }, errors?: Record<string, string[]> }[]> ([])
-  const [mappings, setMappings] = useState<Record<string, { columns: string[] }>> ({ })
-  const [existing, setExisting] = useState<'skip' | 'error'> ('skip')
-  const [loading, setLoading] = useState (false)
-  const validationGeneration = useRef (0)
-  const editable = canEditContent (user)
-
-  const parseSource = async () => {
-    setLoading (true)
-    try
-    {
-      const data = await apiPost<ParsedImport> ('/posts/import/parse', {
-        source,
-        format,
-        has_header: hasHeader,
-        json_path: jsonPath,
-        existing })
-      setColumns (data.columns)
-      setParsed (data)
-      setMappings ({ })
-      setRows ([])
-      setResults ([])
-      setUrlColumn ('')
-      if (data.columns.length === 1)
-        setUrlColumn ('0')
-      else
-        {
-          const candidate = data.columns.map ((_, index) => ({ index,
-              count: data.rows.filter (row => /^https?:\/\//.test (row.values[index] ?? '')).length }))
-                                      .sort ((a, b) => b.count - a.count)[0]
-          if (candidate?.count)
-            setUrlColumn (String (candidate.index))
-        }
-      setPhase ('mapping')
-    }
-    catch
-    {
-      toast ({ title: '読込みに失敗しました', description: '入力形式を確認してください。' })
-    }
-    finally
-    {
-      setLoading (false)
-    }
-  }
-
-  const preview = async () => {
-    if (!parsed || urlColumn === '')
-      return
-    setLoading (true)
-    try
-    {
-      const data = await apiPost<{ rows: ImportRow[] }> ('/posts/import/preview', {
-        parsed: { columns: parsed.columns, rows: parsed.rows },
-        url_column: urlColumn,
-        mappings,
-        existing })
-      setRows (current => mergeValidatedRows (current, data.rows))
-      setPhase ('preview')
-    }
-    catch (error)
-    {
-      const message =
-          isApiError<{ message?: string, baseErrors?: string[] }> (error)
-          ? error.response?.data?.message ?? error.response?.data?.baseErrors?.[0]
-          : undefined
-      toast ({ title: '投稿プレビューに失敗しました', description: message ?? '入力を確認してください。' })
-    }
-    finally
-    {
-      setLoading (false)
-    }
-  }
-
-  const mergeValidatedRows = (current: ImportRow[], validated: ImportRow[]): ImportRow[] =>
-      current.map (previous => {
-        if (previous.importStatus === 'created')
-          return previous
-        const row = validated.find (_1 => _1.sourceRow === previous.sourceRow)
-        return row ? { ...row,
-                       importStatus: previous.importStatus,
-                       createdPostId: previous.createdPostId,
-                       importErrors: previous.importErrors,
-                       validationErrors: row.validationErrors ?? { } } : previous
-      }).concat (validated.filter (row => !current.some (_1 => _1.sourceRow === row.sourceRow)))
-
-  const updateAttribute = async (index: number, field: string, value: string) => {
-    const row = rows[index]
-    const next = { ...row,
-                   attributes: { ...row.attributes, [field]: value },
-                   provenance: { ...row.provenance, [field]: 'manual' },
-                   importStatus: 'pending' as const,
-                   importErrors: undefined }
-    const nextRows = rows.map ((currentRow, rowIndex) => rowIndex === index ? next : currentRow)
-    setRows (nextRows)
-    const generation = ++validationGeneration.current
-    setLoading (true)
-    try
-    {
-      const validated = await apiPost<{ rows: ImportRow[] }> ('/posts/import/validate',
-                                                                { rows: nextRows.filter (row => row.importStatus !== 'created'), existing,
-                                                                  changed_row: -1 })
-      if (generation === validationGeneration.current)
-        setRows (current => mergeValidatedRows (current, validated.rows))
-    }
-    catch
-    {
-      toast ({ title: '行の再検証に失敗しました' })
-    }
-    finally
-    {
-      if (generation === validationGeneration.current)
-        setLoading (false)
-    }
-  }
-
-  const updateURL = async (index: number, value: string) => {
-    const row = rows[index]
-    const next = { ...row, url: value, provenance: { ...row.provenance, url: 'manual' },
-                   importStatus: 'pending' as const, importErrors: undefined }
-    const nextRows = rows.map ((currentRow, rowIndex) => rowIndex === index ? next : currentRow)
-    setRows (nextRows)
-    const generation = ++validationGeneration.current
-    setLoading (true)
-    try
-    {
-      const validated = await apiPost<{ rows: ImportRow[] }> ('/posts/import/validate',
-                                                                { rows: nextRows.filter (row => row.importStatus !== 'created'), existing,
-                                                                  changed_row: row.sourceRow })
-      if (generation === validationGeneration.current)
-        setRows (current => mergeValidatedRows (current, validated.rows))
-    }
-    catch
-    {
-      toast ({ title: 'URL の再検証に失敗しました' })
-    }
-    finally
-    {
-      if (generation === validationGeneration.current)
-        setLoading (false)
-    }
-  }
-
-  const updateExisting = async (value: 'skip' | 'error') => {
-    setExisting (value)
-    const pendingRows = rows.map (row => row.importStatus === 'created' ? row :
-        { ...row, importStatus: 'pending' as const, importErrors: undefined })
-    setRows (pendingRows)
-    const generation = ++validationGeneration.current
-    setLoading (true)
-    try
-    {
-      const validated = await apiPost<{ rows: ImportRow[] }> ('/posts/import/validate',
-                                                                { rows: pendingRows.filter (row => row.importStatus !== 'created'), existing: value, changed_row: -1 })
-      if (generation === validationGeneration.current)
-        setRows (current => mergeValidatedRows (current, validated.rows))
-    }
-    finally
-    {
-      if (generation === validationGeneration.current)
-        setLoading (false)
-    }
-  }
-
-  const submit = async () => {
-    const targets = rows.filter (row => row.importStatus == null || row.importStatus === 'pending')
-    if (targets.length === 0)
-      return
-    setLoading (true)
-    try
-    {
-      const result = await apiPost<{ created: number, skipped: number, failed: number,
-                                     rows: { sourceRow: number, status: ImportResultStatus, post?: { id: number }, errors?: Record<string, string[]> }[] }> ('/posts/import', {
-        rows: targets.map (row => ({ sourceRow: row.sourceRow,
-                                     url: row.url,
-                                     attributes: row.attributes,
-                                     provenance: row.provenance,
-                                     tagSources: row.tagSources,
-                                     metadataUrl: row.metadataUrl })),
-        existing })
-      if (result.rows.some (row => !(['created', 'skipped', 'failed'] as string[]).includes (row.status)))
-        throw new Error ('不正な登録結果です。')
-      toast ({ title: `登録完了: ${result.created} 件`,
-              description: `スキップ ${result.skipped} 件、失敗 ${result.failed} 件` })
-      setPhase ('result')
-      setResults (result.rows)
-      setRows (current => current.map (row => {
-        const resultRow = result.rows.find (_1 => _1.sourceRow === row.sourceRow)
-        return resultRow ? { ...row, importStatus: resultRow.status,
-                             createdPostId: resultRow.post?.id,
-                             importErrors: resultRow.errors,
-                             validationErrors: row.validationErrors } : row
-      }))
-    }
-    catch
-    {
-      toast ({ title: '登録に失敗しました' })
-    }
-    finally
-    {
-      setLoading (false)
-    }
-  }
-
-  if (!(editable))
-    return <Forbidden/>
-
-  return (
-      <MainArea>
-	<Helmet><title>{`投稿インポート | ${SITE_TITLE}`}</title></Helmet>
-	<PageTitle>投稿インポート</PageTitle>
-	{phase === 'source' ? (
-	    <Form>
-	      <p className="text-sm text-neutral-600 dark:text-neutral-300">
-		URL を一行に一件ずつ貼り付けるか、CSV・TSV・JSON を入力してください。
-	      </p>
-	      {publicGoogleSheetURL (source) && (
-		<fieldset className="space-y-1 rounded border p-3 dark:border-neutral-700">
-		  <legend>公開 Google スプレッドシート URL</legend>
-		  <label className="mr-3"><input type="radio" checked={format === 'google_sheets'}
-				 onChange={() => setFormat ('google_sheets')}/>シート内データを読み込む</label>
-		  <label><input type="radio" checked={format !== 'google_sheets'}
-				 onChange={() => setFormat ('tsv')}/>URL 自体を投稿として扱う</label>
-		</fieldset>)}
-	      <FormField label="入力形式">
-		{() => <select value={format} onChange={ev => setFormat (ev.target.value as typeof format)}
-				 className={inputClass (false)}>
-		  <option value="tsv">テキスト・TSV</option><option value="csv">CSV</option>
-		  <option value="json">JSON</option>
-		  <option value="google_sheets">公開 Google スプレッドシート</option>
-		</select>}
-	      </FormField>
-	      <FormField label="入力データ">
-		{() => <textarea value={source} rows={12} className={inputClass (false)}
-			 onChange={ev => { setSource (ev.target.value); if (format !== 'json' && format !== 'google_sheets') setFormat (detectFormat (ev.target.value)) }}/>} 
-	      </FormField>
-	      <input type="file" accept=".txt,.csv,.tsv,.json" onChange={ev => {
-		const file = ev.target.files?.[0]
-		if (file) file.text ().then (text => { setSource (text); setFormat (file.name.endsWith ('.json') ? 'json' : detectFormat (text)) })
-	      }}/>
-	      {format !== 'json' && <label className="flex gap-2"><input type="checkbox" checked={hasHeader}
-				 onChange={ev => setHasHeader (ev.target.checked)}/>見出し行を使用する</label>}
-	      {format === 'json' && <FormField label="投稿候補の位置（例: data.posts）">
-		{() => <input value={jsonPath} onChange={ev => setJsonPath (ev.target.value)} className={inputClass (false)}/>} 
-	      </FormField>}
-	      {format === 'google_sheets' && <p className="text-sm text-neutral-600 dark:text-neutral-300">
-		非公開シートには対応していません。ウェブ公開 URL を使用するか、CSV を保存して選択、又は内容を貼り付けてください。
-	      </p>}
-	      <Button type="button" onClick={parseSource} disabled={loading || !(source)}>列を解析</Button>
-	    </Form>) : phase === 'mapping' && parsed ? (
-	    <Form>
-	      <PageTitle>列の割当て</PageTitle>
-	      <p>URL 列と補助列を指定してから、投稿情報を取得します。</p>
-	      <label>URL 列 <select value={urlColumn} onChange={ev => setUrlColumn (ev.target.value)}>
-		<option value="">選択してください</option>
-		{columns.map ((column, index) => <option key={column.key} value={index}>{column.label}</option>)}
-	      </select></label>
-	      {['title', 'thumbnail_base', 'original_created_from', 'original_created_before', 'duration', 'tags', 'parent_post_ids'].map (field =>
-		<label key={field}>{field}<select value={mappings[field]?.columns?.[0] ?? ''}
-		  onChange={ev => setMappings (current => ({ ...current, [field]: { columns: ev.target.value === '' ? [] : [ev.target.value] } }))}>
-		  <option value="">指定なし</option>
-		  {columns.map ((column, index) => <option key={column.key} value={index}>{column.label}</option>)}
-		</select></label>)}
-	      <div className="overflow-x-auto"><table className="text-sm"><thead><tr>{columns.map (column => <th key={column.key}>{column.label}</th>)}</tr></thead><tbody>{parsed.rows.slice (0, 5).map (row => <tr key={row.sourceRow}>{row.values.map ((value, index) => <td key={index}>{value}</td>)}</tr>)}</tbody></table></div>
-	      <Button type="button" variant="outline" onClick={() => setPhase ('source')}>入力元へ戻る</Button>
-	      <Button type="button" onClick={preview} disabled={loading || urlColumn === ''}>投稿情報を取得して確認</Button>
-	    </Form>) : phase === 'preview' ? (
-	    <div className="space-y-4">
-	      <div className="flex flex-wrap gap-3 rounded border p-3 dark:border-neutral-700">
-		<label>URL 列 <select value={urlColumn} onChange={ev => setUrlColumn (ev.target.value)}>
-		  {columns.map ((column, index) => <option key={column.key} value={index}>{column.label}</option>)}
-		</select></label>
-        <label>既存投稿 <select value={existing} onChange={ev => updateExisting (ev.target.value as typeof existing)}>
-		  <option value="skip">スキップ</option><option value="error">エラー</option>
-		</select></label>
-		{['title', 'thumbnail_base', 'original_created_from', 'original_created_before', 'duration', 'tags', 'parent_post_ids'].map (field =>
-		    <label key={field}>{field}<select value={mappings[field]?.columns?.[0] ?? ''}
-			 onChange={ev => setMappings (current => ({ ...current, [field]: { columns: ev.target.value === '' ? [] : [ev.target.value] } }))}>
-		      <option value="">指定なし</option>{columns.map ((column, index) => <option key={column.key} value={index}>{column.label}</option>)}
-		    </select></label>)}
-		<Button type="button" variant="outline" onClick={preview} disabled={loading}>自動取得を更新</Button>
-	      </div>
-	      <div className="grid gap-3 md:grid-cols-2">{rows.map ((row, index) => <RowCard key={row.sourceRow} row={row} index={index} update={updateAttribute} updateURL={updateURL}/>)}</div>
-	      <Button type="button" variant="outline" onClick={() => setPhase ('mapping')}>列割当てへ戻る</Button>
-	      <Button type="button" onClick={submit} disabled={loading}>有効な投稿を一括登録</Button>
-	    </div>) : (
-	    <div className="space-y-3"><p>インポート処理が完了しました。</p>
-	      {results.map (result => <div key={result.sourceRow} className="rounded border p-2 dark:border-neutral-700">行 {result.sourceRow}：{result.status} {result.post && <PrefetchLink to={`/posts/${result.post.id}`}>投稿を開く</PrefetchLink>}<FieldError messages={Object.values (result.errors ?? { }).flat ()}/></div>)}
-	      <Button type="button" onClick={() => setPhase ('preview')}>結果を確認</Button>
-	      <Button type="button" variant="outline" onClick={() => setPhase ('preview')}>失敗行を修正</Button>
-	      <Button type="button" variant="outline" onClick={() => setPhase ('source')}>新しい入力元を選ぶ</Button>
-	    </div>)}
-	</MainArea>)
-}
-
-
-const RowCard = ({ row, index, update, updateURL }: { row: ImportRow, index: number, update: (index: number, field: string, value: string) => void, updateURL: (index: number, value: string) => void }) => (
-    <article className="space-y-2 rounded border bg-white p-3 text-neutral-900 dark:border-neutral-700 dark:bg-neutral-900 dark:text-neutral-100">
-	<p>行 {row.sourceRow}・{row.status}</p>
-	{row.importStatus === 'created' ? <p className="rounded bg-green-100 p-2 dark:bg-green-900">登録済み。この行は編集・再登録できません。{row.createdPostId && <PrefetchLink to={`/posts/${row.createdPostId}`}>投稿を開く</PrefetchLink>}</p> : <>
-	<EditableValue label="URL" value={row.url} origin={row.provenance.url} onCommit={value => updateURL (index, value)}/>
-	<EditableValue label="タイトル" value={row.attributes.title ?? ''} origin={row.provenance.title} onCommit={value => update (index, 'title', value)}/>
-	<EditableValue label="サムネール基底 URL" value={row.attributes.thumbnailBase ?? ''} origin={row.provenance.thumbnailBase} onCommit={value => update (index, 'thumbnailBase', value)}/>
-	<ThumbnailPreview url={row.attributes.thumbnailBase ?? ''}/>
-	<EditableValue label="作成日時 From" value={row.attributes.originalCreatedFrom ?? ''} origin={row.provenance.originalCreatedFrom} onCommit={value => update (index, 'originalCreatedFrom', value)}/>
-	<EditableValue label="作成日時 Before" value={row.attributes.originalCreatedBefore ?? ''} origin={row.provenance.originalCreatedBefore} onCommit={value => update (index, 'originalCreatedBefore', value)}/>
-	<EditableValue label="動画時間" value={String (row.attributes.duration ?? '')} origin={row.provenance.duration} onCommit={value => update (index, 'duration', value)}/>
-	<EditableValue label="タグ" value={row.attributes.tags ?? ''} origin={row.provenance.tags} onCommit={value => update (index, 'tags', value)}/>
-	<EditableValue label="親投稿" value={row.attributes.parentPostIds ?? ''} origin={row.provenance.parentPostIds} onCommit={value => update (index, 'parentPostIds', value)}/>
-	</>}
-	<FieldError messages={[...row.warnings,
-				 ...Object.values (row.validationErrors ?? { }).flat (),
-				 ...Object.values (row.importErrors ?? { }).flat ()]}/>
-    </article>)
-
-const EditableValue = ({ label, value, origin, onCommit }: { label: string, value: string, origin: string | undefined, onCommit: (value: string) => void }) => {
-  const [editing, setEditing] = useState (false)
-  const [draft, setDraft] = useState (value)
-  const finished = useRef (false)
-  useEffect (() => { if (!editing) setDraft (value) }, [editing, value])
-  const originLabel = { automatic: '自動取得', mapped: '入力データ', fixed: '固定値', manual: '手修正' }[origin ?? 'automatic']
-  const begin = () => { finished.current = false; setDraft (value); setEditing (true) }
-  const commit = () => { if (finished.current) return; finished.current = true; setEditing (false); if (draft !== value) onCommit (draft) }
-  const cancel = () => { if (finished.current) return; finished.current = true; setDraft (value); setEditing (false) }
-  return <div className={origin === 'manual' ? 'rounded bg-amber-100 p-1 dark:bg-amber-900' : 'p-1'}>
-    <span className="text-xs">{label}・{originLabel}</span>
-    {editing ? <input autoFocus value={draft} onChange={ev => setDraft (ev.target.value)} onBlur={commit}
-      onKeyDown={ev => { if (ev.key === 'Escape') cancel (); if (ev.key === 'Enter') { ev.preventDefault (); commit () } } } className={inputClass (false)}/>
-      : <button type="button" className="block w-full text-left" onDoubleClick={begin} onClick={begin}>{value || '（未指定）'}　編輯</button>}
-  </div>
-}
-
-const ThumbnailPreview = ({ url }: { url: string }) => {
-  const [failed, setFailed] = useState (false)
-  useEffect (() => setFailed (false), [url])
-  if (!url)
-    return <p className="text-sm">サムネール未指定</p>
-  if (failed)
-    return <p className="text-sm text-red-600 dark:text-red-300">サムネールを表示できません</p>
-  return <img src={url} alt="サムネール" className="max-h-32" onError={() => setFailed (true)}/>
-}
-
-export default PostImportPage

frontend/src/pages/posts/PostImportResultPage.tsx

@@ -0,0 +1,253 @@
+import { useEffect, useMemo, useState } from 'react'
+import { Helmet } from 'react-helmet-async'
+import { useNavigate,
+	 useParams } from 'react-router-dom'
+
+import FieldError from '@/components/common/FieldError'
+import PageTitle from '@/components/common/PageTitle'
+import PrefetchLink from '@/components/PrefetchLink'
+import MainArea from '@/components/layout/MainArea'
+import PostImportStatusBadge from '@/components/posts/import/PostImportStatusBadge'
+import { Button } from '@/components/ui/button'
+import { toast } from '@/components/ui/use-toast'
+import { SITE_TITLE } from '@/config'
+import { apiPost } from '@/lib/api'
+import { canEditContent } from '@/lib/users'
+import { loadPostImportSession,
+	 mergeImportResults,
+	 retryImportRow,
+	 savePostImportSession,
+	 type PostImportResultRow,
+	 type PostImportSession } from '@/lib/postImportSession'
+import Forbidden from '@/pages/Forbidden'
+
+import type { FC } from 'react'
+
+import type { User } from '@/types'
+
+type Props = { user: User | null }
+
+const resultToneClass = (status: string | undefined): string[] => {
+    switch (status)
+      {
+      case 'created':
+	return [
+	    'border-sky-200 bg-sky-50',
+	    'dark:border-sky-900 dark:bg-sky-950/30']
+      case 'skipped':
+	return [
+	    'border-stone-200 bg-stone-50',
+	    'dark:border-stone-800 dark:bg-stone-900/60']
+      case 'failed':
+	return [
+	    'border-rose-200 bg-rose-50',
+	    'dark:border-rose-900 dark:bg-rose-950/30']
+      default:
+	return [
+	    'border-border bg-white',
+	    'dark:border-neutral-700 dark:bg-neutral-900']
+      }
+}
+
+
+const PostImportResultPage: FC<Props> = ({ user }) => {
+    const editable = canEditContent (user)
+    const navigate = useNavigate ()
+    const { sessionId } = useParams ()
+
+    const [session, setSession] = useState<PostImportSession | null> (null)
+    const [missing, setMissing] = useState (false)
+    const [loadingRow, setLoadingRow] = useState<number | null> (null)
+
+    useEffect (() => {
+	if (!(sessionId))
+	  return
+
+	const loaded = loadPostImportSession (sessionId)
+	setSession (loaded)
+	setMissing (loaded == null)
+    }, [sessionId])
+
+    useEffect (() => {
+	if (!(sessionId) || !(session))
+	  return
+
+	savePostImportSession (sessionId, session)
+    }, [session, sessionId])
+
+    const counts = useMemo (() => ({
+	created: session?.rows.filter (_1 => _1.importStatus === 'created').length ?? 0,
+	skipped: session?.rows.filter (_1 => _1.importStatus === 'skipped').length ?? 0,
+	failed: session?.rows.filter (_1 => _1.importStatus === 'failed').length ?? 0 }), [session])
+
+    const retry = async (sourceRow: number) => {
+	if (!(session))
+	  return
+
+	setLoadingRow (sourceRow)
+	try
+	{
+	    const pendingRows = retryImportRow (session.rows, sourceRow)
+	    setSession ({ ...session, rows: pendingRows })
+	    const target = pendingRows.find (_1 => _1.sourceRow === sourceRow)
+	    if (target == null)
+	      return
+
+	    const result = await apiPost<{
+		created: number
+		skipped: number
+		failed:  number
+		rows:    PostImportResultRow[] }> ('/posts/import', {
+		    rows: [{
+			sourceRow: target.sourceRow,
+			url: target.url,
+			attributes: target.attributes,
+			provenance: target.provenance,
+			tagSources: target.tagSources,
+			metadataUrl: target.metadataUrl }],
+		    existing: session.existing })
+	    setSession (current =>
+		current
+		? { ...current, rows: mergeImportResults (current.rows, result.rows) }
+		: current)
+	}
+	catch
+	{
+	    setSession (session)
+	    toast ({ title: '再試行に失敗しました' })
+	}
+	finally
+	{
+	    setLoadingRow (null)
+	}
+    }
+
+    const openRepair = (sourceRow: number) => {
+	const nextSession = { ...session, repairMode: 'failed' as const }
+	setSession (nextSession)
+	if (sessionId)
+	  savePostImportSession (sessionId, nextSession)
+	navigate (`/posts/import/${ sessionId }/review?edit=${ sourceRow }`)
+    }
+
+    if (!(editable))
+      return <Forbidden/>
+
+    if (missing || !(sessionId) || !(session))
+      {
+	return (
+	    <MainArea>
+	      <div className="mx-auto max-w-4xl space-y-4 p-4">
+		<PageTitle>投稿インポート結果</PageTitle>
+		<FieldError messages={['取込状態が見つかりません．']}/>
+		<Button type="button" onClick={() => navigate ('/posts/import')}>
+		  URL リスト入力へ戻る
+		</Button>
+	      </div>
+	    </MainArea>)
+      }
+
+    return (
+	<MainArea>
+	  <Helmet>
+	    <title>{`投稿インポート結果 | ${ SITE_TITLE }`}</title>
+	  </Helmet>
+
+	  <div className="mx-auto max-w-5xl space-y-4 p-4">
+	    <PageTitle>登録結果</PageTitle>
+
+	    <div className="rounded-lg border bg-white p-4 dark:border-neutral-700
+			    dark:bg-neutral-900">
+	      <div className="flex flex-wrap gap-2">
+		<SummaryChip label="登録成功" value={counts.created} badge="created"/>
+		<SummaryChip label="スキップ" value={counts.skipped} badge="skipped"/>
+		<SummaryChip label="失敗" value={counts.failed} badge="failed"/>
+	      </div>
+	    </div>
+
+	    <div className="space-y-3">
+	      {session.rows.map (row => (
+		  <div
+		      key={row.sourceRow}
+		      className={[
+			  'rounded-lg border p-4',
+			  ...resultToneClass (row.importStatus)].join (' ')}>
+		    <div className="flex flex-col gap-3 md:flex-row md:items-start
+				    md:justify-between">
+		      <div className="space-y-2">
+			<div className="flex flex-wrap items-center gap-2">
+			  <span className="text-sm font-medium">行 {row.sourceRow}</span>
+			  <PostImportStatusBadge value={row.importStatus ?? 'pending'}/>
+			</div>
+			<div className="text-sm text-neutral-700 dark:text-neutral-200">
+			  {String (row.attributes.title ?? '') || row.url}
+			</div>
+			<div className="text-xs text-neutral-500 dark:text-neutral-400">
+			  {row.url}
+			</div>
+			<FieldError messages={Object.values (row.importErrors ?? { }).flat ()}/>
+		      </div>
+
+		      <div className="flex flex-col gap-2 sm:flex-row">
+			{row.createdPostId && (
+			    <Button type="button" variant="outline" asChild>
+			      <PrefetchLink to={`/posts/${ row.createdPostId }`}>
+				投稿を開く
+			      </PrefetchLink>
+			    </Button>)}
+			{row.importStatus === 'failed' && (
+			    <>
+			      <Button
+				  type="button"
+				  variant="outline"
+				  onClick={() => openRepair (row.sourceRow)}>
+				修正
+			      </Button>
+			      <Button
+				  type="button"
+				  onClick={() => retry (row.sourceRow)}
+				  disabled={loadingRow === row.sourceRow}>
+				再試行
+			      </Button>
+			    </>)}
+		      </div>
+		    </div>
+		  </div>))}
+	    </div>
+
+	    <div className="flex flex-col gap-2 sm:flex-row">
+	      <Button
+		  type="button"
+		  variant="outline"
+		  onClick={() => {
+		      const nextSession = { ...session, repairMode: 'all' as const }
+		      setSession (nextSession)
+		      savePostImportSession (sessionId, nextSession)
+		      navigate (`/posts/import/${ sessionId }/review`)
+		  }}>
+		確認画面へ戻る
+	      </Button>
+	      <Button
+		  type="button"
+		  variant="outline"
+		  onClick={() => navigate ('/posts/import')}>
+		新しい URL リストを入力
+	      </Button>
+	    </div>
+	  </div>
+	</MainArea>)
+}
+
+const SummaryChip = (
+    { label, value, badge }: {
+	label: string
+	value: number
+	badge: 'created' | 'skipped' | 'failed' },
+) => (
+    <div className="flex items-center gap-2 rounded-full border border-border
+		    bg-background px-3 py-1 text-sm">
+      <PostImportStatusBadge value={badge}/>
+      <span>{label} {value}</span>
+    </div>)
+
+export default PostImportResultPage

frontend/src/pages/posts/PostImportReviewPage.tsx

@@ -0,0 +1,363 @@
+import { useEffect, useMemo, useState } from 'react'
+import { Helmet } from 'react-helmet-async'
+import { useNavigate,
+	 useParams,
+	 useSearchParams } from 'react-router-dom'
+
+import FieldError from '@/components/common/FieldError'
+import PageTitle from '@/components/common/PageTitle'
+import MainArea from '@/components/layout/MainArea'
+import PostImportRowDialog from '@/components/posts/import/PostImportRowDialog'
+import PostImportRowSummary from '@/components/posts/import/PostImportRowSummary'
+import PostImportStatusBadge from '@/components/posts/import/PostImportStatusBadge'
+import { Button } from '@/components/ui/button'
+import { toast } from '@/components/ui/use-toast'
+import { SITE_TITLE } from '@/config'
+import { apiPost } from '@/lib/api'
+import { canEditContent } from '@/lib/users'
+import { loadPostImportSession,
+	 mergeImportResults,
+	 mergeValidatedImportRows,
+	 reviewSummaryCounts,
+	 rowMessages,
+	 savePostImportSession,
+	 submittableImportRows,
+	 type PostImportResultRow,
+	 type PostImportRow,
+	 type PostImportSession } from '@/lib/postImportSession'
+import Forbidden from '@/pages/Forbidden'
+
+import type { FC } from 'react'
+
+import type { User } from '@/types'
+
+type Props = { user: User | null }
+
+type Draft = {
+    url:                   string
+    title:                 string
+    thumbnailBase:         string
+    originalCreatedFrom:   string
+    originalCreatedBefore: string
+    duration:              string
+    tags:                  string
+    parentPostIds:         string }
+
+
+const PostImportReviewPage: FC<Props> = ({ user }) => {
+    const editable = canEditContent (user)
+    const navigate = useNavigate ()
+    const { sessionId } = useParams ()
+    const [searchParams, setSearchParams] = useSearchParams ()
+
+    const [session, setSession] = useState<PostImportSession | null> (null)
+    const [loading, setLoading] = useState (false)
+    const [missing, setMissing] = useState (false)
+    const [savingRow, setSavingRow] = useState<number | null> (null)
+
+    useEffect (() => {
+	if (!(sessionId))
+	  return
+
+	const loaded = loadPostImportSession (sessionId)
+	setSession (loaded)
+	setMissing (loaded == null)
+    }, [sessionId])
+
+    useEffect (() => {
+	if (!(sessionId) || !(session))
+	  return
+
+	savePostImportSession (sessionId, session)
+    }, [session, sessionId])
+
+    const rows = session?.rows ?? []
+    const editingSourceRow = Number (searchParams.get ('edit') ?? '')
+    const editingRow =
+	Number.isFinite (editingSourceRow)
+	? rows.find (_1 => _1.sourceRow === editingSourceRow) ?? null
+	: null
+    const counts = useMemo (() => reviewSummaryCounts (rows), [rows])
+    const submittable = useMemo (
+	() => submittableImportRows (rows).filter (row =>
+	    Object.keys (row.validationErrors ?? { }).length === 0),
+	[rows],
+    )
+    const reviewRows =
+	session?.repairMode === 'failed'
+	? [...rows].sort ((a, b) => {
+	    const aFailed = a.importStatus === 'failed' ? 0 : 1
+	    const bFailed = b.importStatus === 'failed' ? 0 : 1
+	    return aFailed - bFailed || a.sourceRow - b.sourceRow
+	})
+	: rows
+
+    useEffect (() => {
+	if (editingRow == null || session?.repairMode !== 'failed')
+	  return
+
+	const element = document.getElementById (`post-import-row-${ editingRow.sourceRow }`)
+	element?.scrollIntoView ({ block: 'center', behaviour: 'smooth' })
+    }, [editingRow, session?.repairMode])
+
+    const updateSessionRows = (nextRows: PostImportRow[]) =>
+	setSession (current =>
+	    current ? { ...current, rows: nextRows } : current)
+
+    const saveDraft = async (draft: Draft): Promise<boolean> => {
+	if (!(session))
+	  return false
+	if (editingRow == null)
+	  return false
+
+	const urlChanged = draft.url !== editingRow.url
+	const nextProvenance = { ...editingRow.provenance }
+	const nextAttributes = { ...editingRow.attributes }
+	const nextTagSources = {
+	    automatic: editingRow.tagSources?.automatic ?? '',
+	    manual: editingRow.tagSources?.manual ?? '' }
+	const draftFields = [
+	    ['title', draft.title],
+	    ['thumbnailBase', draft.thumbnailBase],
+	    ['originalCreatedFrom', draft.originalCreatedFrom],
+	    ['originalCreatedBefore', draft.originalCreatedBefore],
+	    ['duration', draft.duration],
+	    ['parentPostIds', draft.parentPostIds],
+	] as const
+	draftFields.forEach (([field, value]) => {
+	    nextAttributes[field] = value
+	    nextProvenance[field] =
+		value !== String (editingRow.attributes[field] ?? '')
+		? 'manual'
+		: (editingRow.provenance[field] ?? 'automatic')
+	})
+	nextAttributes.tags = draft.tags
+	if (draft.tags !== String (editingRow.attributes.tags ?? ''))
+	  {
+	    nextProvenance.tags = 'manual'
+	    nextTagSources.manual = draft.tags
+	  }
+	else
+	  {
+	    nextProvenance.tags = editingRow.provenance.tags ?? 'automatic'
+	    nextTagSources.manual = editingRow.tagSources?.manual ?? ''
+	  }
+
+	setSavingRow (editingRow.sourceRow)
+	const nextRows = session.rows.map (row =>
+	    row.sourceRow === editingRow.sourceRow
+	    ? {
+		...row,
+		url: draft.url,
+		attributes: nextAttributes,
+		provenance: {
+		    ...nextProvenance,
+		    url: urlChanged ? 'manual' : (editingRow.provenance.url ?? 'manual') },
+		tagSources: nextTagSources,
+		importStatus: row.importStatus === 'created' ? 'created' : 'pending',
+		importErrors: undefined }
+	    : row)
+	try
+	{
+	    const validated = await apiPost<{ rows: PostImportRow[] }> ('/posts/import/validate', {
+		rows: nextRows.filter (row => row.importStatus !== 'created'),
+		existing: session.existing,
+		changed_row: urlChanged ? editingRow.sourceRow : -1 })
+	    updateSessionRows (mergeValidatedImportRows (nextRows, validated.rows))
+	    setSearchParams ({ })
+	    return true
+	}
+	catch
+	{
+	    toast ({ title: '行の再検証に失敗しました' })
+	    return false
+	}
+	finally
+	{
+	    setSavingRow (null)
+	}
+    }
+
+    const updateExisting = async (value: 'skip' | 'error') => {
+	if (!(session))
+	  return
+
+	const pendingRows = session.rows.map (row =>
+	    row.importStatus === 'created'
+	    ? row
+	    : {
+		...row,
+		importStatus: 'pending' as const,
+		importErrors: undefined })
+	setSession ({ ...session, existing: value, rows: pendingRows })
+	setLoading (true)
+	try
+	{
+	    const validated = await apiPost<{ rows: PostImportRow[] }> ('/posts/import/validate', {
+		rows: pendingRows.filter (row => row.importStatus !== 'created'),
+		existing: value,
+		changed_row: -1 })
+	    updateSessionRows (mergeValidatedImportRows (pendingRows, validated.rows))
+	}
+	finally
+	{
+	    setLoading (false)
+	}
+    }
+
+    const submit = async () => {
+	if (!(sessionId) || !(session) || submittable.length === 0)
+	  return
+
+	setLoading (true)
+	try
+	{
+	    const result = await apiPost<{
+		created: number
+		skipped: number
+		failed:  number
+		rows:    PostImportResultRow[] }> ('/posts/import', {
+		    rows: submittable.map (row => ({
+			sourceRow: row.sourceRow,
+			url: row.url,
+			attributes: row.attributes,
+			provenance: row.provenance,
+			tagSources: row.tagSources,
+			metadataUrl: row.metadataUrl })),
+		    existing: session.existing })
+	    const nextRows = mergeImportResults (session.rows, result.rows)
+	    const nextSession = { ...session, rows: nextRows, repairMode: 'all' as const }
+	    setSession (nextSession)
+	    savePostImportSession (sessionId, nextSession)
+	    navigate (`/posts/import/${ sessionId }/result`)
+	}
+	catch
+	{
+	    toast ({ title: '登録に失敗しました' })
+	}
+	finally
+	{
+	    setLoading (false)
+	}
+    }
+
+    if (!(editable))
+      return <Forbidden/>
+
+    if (missing || !(sessionId) || !(session))
+      {
+	return (
+	    <MainArea>
+	      <div className="mx-auto max-w-4xl space-y-4 p-4">
+		<PageTitle>投稿インポート</PageTitle>
+		<FieldError messages={['取込状態が見つかりません．']}/>
+		<Button type="button" onClick={() => navigate ('/posts/import')}>
+		  URL リスト入力へ戻る
+		</Button>
+	      </div>
+	    </MainArea>)
+      }
+
+    return (
+	<MainArea>
+	  <Helmet>
+	    <title>{`投稿インポート確認 | ${ SITE_TITLE }`}</title>
+	  </Helmet>
+
+	  <div className="mx-auto max-w-6xl space-y-4 p-4 pb-28">
+	    <PageTitle>投稿情報の確認</PageTitle>
+
+	    <div className="rounded-lg border bg-white p-4 dark:border-neutral-700
+			    dark:bg-neutral-900">
+	      <div className="flex flex-wrap items-center gap-2">
+		<SummaryChip label="全件" value={counts.total}/>
+		<SummaryChip label="登録対象" value={counts.submittable}/>
+		<SummaryChip label="要修正" value={counts.invalid}/>
+		<SummaryChip label="スキップ予定" value={counts.skipPlanned}/>
+		<SummaryChip label="登録済み" value={counts.created}/>
+		<SummaryChip label="失敗" value={counts.failed}/>
+	      </div>
+	    </div>
+
+	    <div className="rounded-lg border bg-white p-4 dark:border-neutral-700
+			    dark:bg-neutral-900">
+	      <div className="flex flex-wrap items-center justify-between gap-3">
+		<div className="text-sm text-neutral-600 dark:text-neutral-300">
+		  URL {rows.length} 件
+		</div>
+		<label className="flex items-center gap-2 text-sm">
+		  <span>既存投稿</span>
+		  <select
+		      value={session.existing}
+		      onChange={ev => updateExisting (ev.target.value as 'skip' | 'error')}
+		      className="rounded border border-border bg-background px-3 py-2">
+		    <option value="skip">スキップ</option>
+		    <option value="error">エラー</option>
+		  </select>
+		</label>
+	      </div>
+	    </div>
+
+	    <div className="space-y-3">
+	      {reviewRows.map (row => (
+		  <div key={row.sourceRow} id={`post-import-row-${ row.sourceRow }`}>
+		    <PostImportRowSummary
+			row={row}
+			onEdit={() => {
+			    setSearchParams ({ edit: String (row.sourceRow) })
+			}}/>
+		    {rowMessages (row).length > 0 && (
+			<div className="mt-2 md:max-w-3xl">
+			  <FieldError messages={rowMessages (row)}/>
+			</div>)}
+		  </div>))}
+	    </div>
+	  </div>
+
+	  <div
+	      className="fixed inset-x-0 bottom-0 border-t bg-white/95 p-4 backdrop-blur
+			 dark:border-neutral-700 dark:bg-neutral-950/95">
+	    <div className="mx-auto flex max-w-6xl flex-col gap-3 md:flex-row
+			    md:items-center md:justify-between">
+	      <div className="flex flex-wrap items-center gap-2 text-sm">
+		<PostImportStatusBadge value="pending"/>
+		<span>登録対象 {submittable.length} 件</span>
+		<PostImportStatusBadge value="error"/>
+		<span>要修正 {counts.invalid} 件</span>
+	      </div>
+	      <div className="flex flex-col gap-2 sm:flex-row">
+		<Button
+		    type="button"
+		    variant="outline"
+		    onClick={() => navigate ('/posts/import')}>
+		  URL リスト入力へ戻る
+		</Button>
+		<Button
+		    type="button"
+		    onClick={submit}
+		    disabled={loading || submittable.length === 0}>
+		  有効な投稿を一括登録
+		</Button>
+	      </div>
+	    </div>
+	  </div>
+
+	  <PostImportRowDialog
+	      open={editingRow != null}
+	      row={editingRow}
+	      saving={savingRow != null}
+	      onOpenChange={open => {
+		  if (!(open))
+		    setSearchParams ({ })
+	      }}
+	      onSave={saveDraft}/>
+	</MainArea>)
+}
+
+const SummaryChip = ({ label, value }: { label: string
+					  value: number }) => (
+    <div className="rounded-full border border-border bg-background px-3 py-1 text-sm">
+      {label} {value}
+    </div>)
+
+export default PostImportReviewPage

frontend/src/pages/posts/PostImportSourcePage.tsx

@@ -0,0 +1,153 @@
+import { useEffect, useMemo, useState } from 'react'
+import { Helmet } from 'react-helmet-async'
+import { useNavigate } from 'react-router-dom'
+
+import FieldError from '@/components/common/FieldError'
+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 { apiPost, isApiError } from '@/lib/api'
+import { canEditContent } from '@/lib/users'
+import { inputClass } from '@/lib/utils'
+import { countImportSourceLines,
+	 countImportSourceValidLines,
+	 createPostImportSessionId,
+	 loadPostImportSourceDraft,
+	 savePostImportSession,
+	 savePostImportSourceDraft,
+	 type PostImportRow } from '@/lib/postImportSession'
+import Forbidden from '@/pages/Forbidden'
+
+import type { FC } from 'react'
+
+import type { User } from '@/types'
+
+type Props = { user: User | null }
+
+const MAX_ROWS = 100
+
+
+const PostImportSourcePage: FC<Props> = ({ user }) => {
+    const editable = canEditContent (user)
+    const navigate = useNavigate ()
+    const draft = useMemo (() => loadPostImportSourceDraft (), [])
+
+    const [source, setSource] = useState (draft.source)
+    const [existing, setExisting] = useState<'skip' | 'error'> (draft.existing)
+    const [loading, setLoading] = useState (false)
+    const [error, setError] = useState<string | null> (null)
+
+    const lineCount = countImportSourceLines (source)
+    const validLineCount = countImportSourceValidLines (source)
+    const messages = [
+	...(lineCount === 0 ? ['URL を入力してください．'] : []),
+	...(lineCount > MAX_ROWS ? [`最大 ${ MAX_ROWS } 件までです．`] : []),
+	...(error ? [error] : [])]
+
+    useEffect (() => {
+	savePostImportSourceDraft (source, existing)
+    }, [existing, source])
+
+    const preview = async () => {
+	setLoading (true)
+	setError (null)
+	try
+	{
+	    const data = await apiPost<{ rows: PostImportRow[] }> ('/posts/import/preview', {
+		source,
+		existing })
+	    const sessionId = createPostImportSessionId ()
+	    savePostImportSession (sessionId, {
+		source,
+		existing,
+		rows: data.rows,
+		repairMode: 'all' })
+	    navigate (`/posts/import/${ sessionId }/review`)
+	}
+	catch (requestError)
+	{
+	    const message =
+		isApiError<{ message?: string, baseErrors?: string[] }> (requestError)
+		? requestError.response?.data?.message
+		    ?? requestError.response?.data?.baseErrors?.[0]
+		: undefined
+	    setError (message ?? '入力を確認してください．')
+	    toast ({
+		title: '投稿情報の取得に失敗しました',
+		description: message ?? '入力を確認してください．' })
+	}
+	finally
+	{
+	    setLoading (false)
+	}
+    }
+
+    if (!(editable))
+      return <Forbidden/>
+
+    return (
+	<MainArea>
+	  <Helmet>
+	    <title>{`投稿インポート | ${ SITE_TITLE }`}</title>
+	  </Helmet>
+
+	  <div className="mx-auto max-w-4xl space-y-4 p-4">
+	    <PageTitle>投稿インポート</PageTitle>
+	    <div className="rounded-lg border bg-white p-4 dark:border-neutral-700
+			    dark:bg-neutral-900 md:p-6">
+	      <div className="space-y-4">
+		<div className="space-y-2">
+		  <h2 className="text-lg font-semibold">URL リストを入力</h2>
+		  <p className="text-sm text-neutral-600 dark:text-neutral-300">
+		    一行につき一つの URL を入力してください．
+		  </p>
+		</div>
+
+		<FormField label="URL リスト">
+		  {() => (
+		      <textarea
+			  value={source}
+			  rows={14}
+			  className={inputClass (
+			      messages.length > 0,
+			      'font-mono text-sm',
+			  )}
+			  onChange={ev => setSource (ev.target.value)}/>)}
+		</FormField>
+		<FieldError messages={messages}/>
+
+		<div className="flex flex-wrap items-center justify-between gap-3 text-sm
+				text-neutral-600 dark:text-neutral-300">
+		  <div>有効行数: {validLineCount}</div>
+		  <div>最大 {MAX_ROWS} 件</div>
+		</div>
+
+		<label className="block space-y-1">
+		  <span className="text-sm font-medium">既存投稿</span>
+		  <select
+		      value={existing}
+		      onChange={ev => setExisting (ev.target.value as typeof existing)}
+		      className={inputClass (false, 'w-full md:w-auto')}>
+		    <option value="skip">スキップ</option>
+		    <option value="error">エラー</option>
+		  </select>
+		</label>
+
+		<div className="flex justify-end">
+		  <Button
+		      type="button"
+		      onClick={preview}
+		      disabled={loading || lineCount === 0 || lineCount > MAX_ROWS}>
+		    投稿情報を取得
+		  </Button>
+		</div>
+	      </div>
+	    </div>
+	  </div>
+	</MainArea>)
+}
+
+export default PostImportSourcePage

frontend/src/pages/posts/PostNewPage.tsx

@@ -25,7 +25,13 @@ import type { User } from '@/types'
 type Props = { user: User | null }
 
 type PostFormField =
-    'url' | 'title' | 'tags' | 'parentPostIds' | 'videoMs' | 'originalCreatedAt' | 'thumbnail'
+    'url'
+    | 'title'
+    | 'tags'
+    | 'parentPostIds'
+    | 'videoMs'
+    | 'originalCreatedAt'
+    | 'thumbnail'
 
 
 const PostNewPage: FC<Props> = ({ user }) => {
@@ -36,8 +42,10 @@ const PostNewPage: FC<Props> = ({ user }) => {
   const { baseErrors, fieldErrors, clearValidationErrors, applyValidationError } =
       useValidationErrors<PostFormField> ()
 
-  const [originalCreatedBefore, setOriginalCreatedBefore] = useState<string | null> (null)
+  const [originalCreatedBefore, setOriginalCreatedBefore] =
-  const [originalCreatedFrom, setOriginalCreatedFrom] = useState<string | null> (null)
+      useState<string | null> (null)
+  const [originalCreatedFrom, setOriginalCreatedFrom] =
+      useState<string | null> (null)
   const [parentPostIds, setParentPostIds] = useState ('')
   const [tags, setTags] = useState ('')
   const [duration, setDuration] = useState ('')
@@ -49,10 +57,11 @@ const PostNewPage: FC<Props> = ({ user }) => {
   const [url, setURL] = useState ('')
 
   const thumbnailPreviewRef = useRef ('')
-  const urlRef = useRef ('')
   const videoFlg =
-      useMemo (() => tags.split (/\s+/).some (tag => tag.replace (/\[.*\]$/, '') === '動画'),
+      useMemo (() =>
-               [tags])
+	  tags.split (/\s+/).some (
+	      tag => tag.replace (/\[.*\]$/, '') === '動画'),
+	       [tags])
 
   const handleSubmit = async () => {
     clearValidationErrors ()
@@ -73,25 +82,25 @@ const PostNewPage: FC<Props> = ({ user }) => {
 
     try
     {
-      await apiPost ('/posts', formData, { headers: { 'Content-Type': 'multipart/form-data' } })
+      await apiPost ('/posts', formData,
+		     { headers: { 'Content-Type': 'multipart/form-data' } })
       toast ({ title: '投稿成功!' })
       navigate ('/posts')
     }
     catch (e)
     {
       applyValidationError (e)
-      toast ({ title: '投稿失敗', description: '入力を確認してください。' })
+      toast ({ title: '投稿失敗', description: '入力を確認してください．' })
     }
   }
 
   const fetchTitle = useCallback (async () => {
-	const requestedURL = url
+    setTitleLoading (true)
-	setTitleLoading (true)
     try
     {
-      const data = await apiGet<{ title: string }> ('/preview/title', { params: { url } })
+      const data = await apiGet<{ title: string }> ('/preview/title',
-	  if (requestedURL === urlRef.current)
+						    { params: { url } })
-	    setTitle (current => current || data.title || '')
+      setTitle (data.title || '')
     }
     finally
     {
@@ -100,7 +109,6 @@ const PostNewPage: FC<Props> = ({ user }) => {
   }, [url])
 
   const fetchThumbnail = useCallback (async () => {
-	const requestedURL = url
     setThumbnailPreview ('')
     setThumbnailFile (null)
     setThumbnailLoading (true)
@@ -109,15 +117,13 @@ const PostNewPage: FC<Props> = ({ user }) => {
     try
     {
       const data = await apiGet<Blob> ('/preview/thumbnail',
-				       { params: { url }, responseType: 'blob' })
+				       { params: { url },
+					 responseType: 'blob' })
       const imageURL = URL.createObjectURL (data)
-	  if (requestedURL === urlRef.current)
+      setThumbnailPreview (imageURL)
-	    {
+      setThumbnailFile (new File ([data],
-	      setThumbnailPreview (current => current || imageURL)
+				  'thumbnail.png',
-	      setThumbnailFile (current => current || new File ([data],
+				  { type: data.type || 'image/png' }))
-								  'thumbnail.png',
-								  { type: data.type || 'image/png' }))
-	    }
     }
     finally
     {
@@ -129,20 +135,6 @@ const PostNewPage: FC<Props> = ({ user }) => {
     thumbnailPreviewRef.current = thumbnailPreview
   }, [thumbnailPreview])
 
-  useEffect (() => {
-	urlRef.current = url
-  }, [url])
-
-  useEffect (() => {
-	if (!(url))
-	  return
-	const timer = window.setTimeout (() => {
-	  fetchTitle ().catch (() => undefined)
-	  fetchThumbnail ().catch (() => undefined)
-	}, 500)
-    return () => window.clearTimeout (timer)
-  }, [fetchThumbnail, fetchTitle, url])
-
   if (!(editable))
     return <Forbidden/>
 
@@ -180,11 +172,11 @@ const PostNewPage: FC<Props> = ({ user }) => {
 			 onChange={ev => setTitle (ev.target.value)}
 			 disabled={titleLoading}/>
 		  <div className="flex flex-wrap items-center gap-2 text-sm">
-		    <span>URL 入力後に自動取得します．</span>
+		    <span>必要なタイミングで URL から取得できます．</span>
 		    <Button
 			type="button"
 			variant="outline"
-			onClick={() => void fetchTitle ()}
+			onClick={fetchTitle}
 			disabled={!(url) || titleLoading}>
 		      取得
 		    </Button>
@@ -197,11 +189,11 @@ const PostNewPage: FC<Props> = ({ user }) => {
 	    {({ describedBy, invalid }) => (
 		<>
 		  <div className="mb-2 flex flex-wrap items-center gap-2 text-sm">
-		    <span>URL 入力後に自動取得します．</span>
+		    <span>必要なタイミングで URL から取得できます．</span>
 		    <Button
 			type="button"
 			variant="outline"
-			onClick={() => void fetchThumbnail ()}
+			onClick={fetchThumbnail}
 			disabled={!(url) || thumbnailLoading}>
 		      取得
 		    </Button>