#399

AGENTS.md

@@ -114,28 +114,135 @@ 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.
+- Ruby hash / block / call delimiter の詳細は、下の
-- Ruby hashes keep the first pair on the same line as `{` unless line length
+  `Ruby delimiter and wrapping rules` を正本として扱ふこと。
-  requires a break.
-- Short Ruby hashes may stay visually compact across two lines with the first
-  pair kept on the opening line and aligned continuation pairs below it.
-- Ruby blocks use separate `{ ... }` rules from hashes, with 2-space body
-  indentation.
 - For arrays, never put whitespace or a line break immediately before `]`.
 - Keep the first element on the same line as `[` by default.
 - If an array would exceed the line limit, break after `[` and indent
   elements by 4 spaces.
+
+### 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 の guard 条件は、1 行で収まるなら modifier 形式を優先する。
+  99 文字を超えるなら block 形式へ切り替へるか、message 定数化などで縮める。
+- Ruby の method chain や call argument を折り返す際、call-site の `)` を
+  block close のやうに独立させない。
+
+Bad:
+
+```rb
+response = Example.fetch(
+  value,
+  option: option,
+)
+```
+
+Good:
+
+```rb
+response = Example.fetch(
+    value,
+    option: option)
+```
+
+Bad:
+
+```rb
+payload = {
+  title: title,
+  url: url,
+}
+```
+
+Good:
+
+```rb
+payload = {
+    title: title,
+    url: url }
+```
+
+Bad:
+
+```rb
+raise ArgumentError, 'URL が長すぎます．' if url.bytesize > MAX_URL_BYTES && flag.present?
+```
+
+Good:
+
+```rb
+if url.bytesize > MAX_URL_BYTES && flag.present?
+  raise ArgumentError, 'URL が長すぎます．'
+end
+```
+
+Bad:
+
+```rb
+records.each {
+  do_work(_1) }
+```
+
+Good:
+
+```rb
+records.each {
+  do_work(_1)
+}
+```
 - TypeScript and Python: use GNU-style spacing before parentheses where
   syntactically valid.
 - Never write Ruby, TypeScript, or TSX lines longer than 99 characters.
 - Aim to keep Ruby, TypeScript, and TSX lines within 79 characters where practical.
-- TypeScript and TSX use 4-space logical indentation.
+- In TypeScript and TSX, use 2-space block indentation.
-- In TypeScript and TSX only, replace every leading run of 8 spaces with a tab.
+- In TypeScript and TSX, block bodies for components, functions, callbacks,
-- Tabs are only for leading indentation, never for spaces after non-space text.
+  `if`, `try`, `catch`, `finally`, loops, and JSX nesting use 2 spaces per
+  level.
+- In TypeScript and TSX, use 4-space continuation indentation for wrapped
+  expressions, arguments, conditions, arrays, object literals, JSX
+  attributes, and similar continuations.
+- Treat the user's `PostImportSourcePage.tsx` and `PostImportReviewPage.tsx`
+  formatting as the local reference shape: component and callback bodies use
+  2-space block indentation, single-line bodies do not gain unnecessary
+  braces, wrapped expressions use 4-space continuation indentation, multi-
+  stage ternaries use explicit parentheses, and only complete leading runs
+  of 8 spaces are compressed to tabs.
+- In TypeScript and TSX only, tabs are for leading 8-column compression only.
+- A tab does not represent one indentation level.
+- Do not replace 2-space or 4-space indentation with tabs.
+- First determine visible indentation using 2-space block indentation and
+  4-space continuation indentation, then compress only complete leading runs
+  of 8 spaces into tabs.
+- Tabs are only for leading indentation, never for spaces after non-space
+  text.
+- Keep residual leading 2, 4, or 6 spaces after any tab compression.
+- Examples: 2 columns = 2 spaces, 4 columns = 4 spaces, 6 columns = 6
+  spaces, 8 columns = 1 tab, 10 columns = 1 tab + 2 spaces, 12 columns = 1
+  tab + 4 spaces, 16 columns = 2 tabs.
 - TypeScript and TSX imports may stay on one line if they remain within the
   line limit; do not expand short type-only imports mechanically.
+- Keep runtime value imports and type imports in separate declarations.
+- Do not write `import { value, type TypeName } from ...`.
+- Type-only declarations must use `import type`.
+- Do not merge type imports into value imports merely to save lines.
+- In TypeScript and TSX, order imports as four groups with a blank line
+  between groups: external value imports, `@/...` value imports, external
+  type imports, `@/...` type imports.
+- Do not mechanically split a short value import from one module across
+  multiple lines when it still fits within 99 characters.
 - In TypeScript and TSX, when breaking a line at an operator, break before the
   operator and put the operator at the beginning of the next line. A trailing
   operator at end of line is unacceptable. This rule does not apply to Ruby,
@@ -190,6 +297,151 @@ const value =
   value selection. Do not replace a clear ternary with `if` statements, and do
   not introduce immediately invoked functions just to avoid or reformat a
   ternary expression.
+- In TypeScript and TSX, multi-stage ternary expressions must make branch
+  boundaries explicit. Wrap each condition group in parentheses instead of
+  relying on indentation alone to show which `?` matches which `:`.
+- In TypeScript and TSX, wrap nested ternary expressions in parentheses. Do
+  not write flat vertical chains of `?` and `:` without explicit grouping.
+- In TypeScript and TSX, when a ternary condition contains `&&` or `||`, wrap
+  the whole condition in parentheses before `?`.
+- In TypeScript and TSX, if a ternary reaches three or more stages and still
+  reads poorly after explicit grouping, extract a helper function or use `if`
+  statements instead of keeping a flat multi-stage ternary.
+
+Bad:
+
+```ts
+row.skipReason === 'existing' || row.importStatus === 'skipped'
+? 'skipped'
+: Object.keys (row.validationErrors ?? { }).length > 0
+  || row.importStatus === 'failed'
+  || row.importStatus === 'created'
+? null
+: hasWarnings (row) || row.status === 'warning'
+? 'warning'
+: 'ready'
+```
+
+Good:
+
+```ts
+(row.skipReason === 'existing' || row.importStatus === 'skipped')
+? 'skipped'
+: ((Object.keys (row.validationErrors ?? { }).length > 0
+    || row.importStatus === 'failed'
+    || row.importStatus === 'created')
+   ? null
+   : ((hasWarnings (row) || row.status === 'warning')
+      ? 'warning'
+      : 'ready'))
+```
+
+## Shared-system discovery and reuse
+
+Before creating a new component, hook, service, helper, utility, concern,
+representation, normaliser, validator, parser, fetcher, store, context, event
+bus, API client, query key, permission helper, dialogue, toast, form field, or
+version recorder, search the existing repository first.
+
+Do not search by name alone. Search by responsibility, behaviour, and usage
+intent as well. Typical search themes include:
+
+- dialogue, modal, confirm, alert, choice
+- validation error, field error, unprocessable entity
+- permission, role, member, admin, editable
+- URL normalise, sanitise, canonicalise
+- API call, query key, prefetch, cache invalidation
+- version, snapshot, history, restore
+- thumbnail, metadata, HTTP fetch, URL safety
+- form, field, input, textarea, warning, status badge
+- file storage, Active Storage, ZIP, export
+- transaction, locking, race, idempotency
+
+Before deciding that something new is needed, confirm at least:
+
+1. the existing definition
+2. its public API
+3. representative call sites
+4. other implementations with similar responsibility
+5. the nearest directory-level `AGENTS.md`
+
+Do not reject an existing implementation by name alone. Read the code and its
+usage first.
+
+When new behaviour is needed, make the decision in this order:
+
+1. use the existing common API as-is
+2. use the existing extension points of that API
+3. extend the existing common API minimally
+4. keep the implementation local when the meaning is feature-specific
+5. add a new common system only when multiple real users and a stable contract
+   are already clear
+
+Do not create a parallel foundation merely because the existing one feels
+slightly awkward, because a new one seems faster, or because the current task
+looks special.
+
+Do not create a second common platform with names such as `CommonFoo`,
+`SharedFoo`, `BaseFoo`, `FooManager`, `FooService`, `FooProvider`,
+`FooWrapper`, `FooUtils`, or `useFoo` when an existing system already owns the
+same responsibility. Judge by responsibility, not by spelling.
+
+Wrapper aliases, barrel exports, and re-export shims do not count as reuse.
+Using a different import path that merely forwards to the existing system does
+not satisfy a reuse requirement.
+
+Keep this boundary explicit:
+
+- business meaning stays in feature code
+- visual and mechanical shell stays in common code
+
+Common code may hold generic primitives, interaction shells, API transport,
+auth and permission helpers, query-key and prefetch conventions, validation
+error conversion, shared normalisation, version-recording mechanisms, storage
+helpers, HTTP safety, and other contracts that carry the same meaning across
+multiple features.
+
+Feature code should keep feature-specific states, labels, input fields,
+workflow steps, payload shapes, validation rules, and business decisions.
+
+Do not commonise business logic merely because the visuals look similar or two
+code fragments resemble each other.
+
+Create a new common system only when all of the following are true:
+
+- no existing implementation already owns the responsibility
+- there are multiple real consumers, or a clearly defined platform contract
+- the differences between consumers do not require option bloat
+- feature-specific vocabulary does not leak into common types, props, tones, or
+  state names
+- the location matches the existing directory structure
+- the new abstraction does not compete with an existing common system
+- it is not just a one-off wrapper for a single task
+
+Do not add unused tones, variants, options, callbacks, states, or abstractions
+for speculative future use.
+
+Before finishing work that touches shared systems, verify:
+
+- you searched for an existing implementation with the same responsibility
+- you are using the canonical import path or entrypoint
+- feature code is not reaching directly for a low-level primitive that already
+  has a higher-level common API
+- you did not bypass an existing common API
+- any new wrapper or shim is genuinely necessary
+- feature-specific vocabulary did not leak into common code
+- the feature did not reimplement a common shell
+- existing unrelated consumers were not changed without need
+- one task did not trigger a needless redesign of the whole foundation
+- any newly introduced common system really has multiple consumers
+
+For backend-specific discovery, Rails structure, services, representation
+selection, versioning, normalisation, and HTTP safety, follow
+`backend/AGENTS.md`.
+
+For frontend-specific component hierarchy, low-level primitive reuse, dialogue
+entrypoints, API/query helpers, validation/form infrastructure, state/storage,
+and layout reuse, follow `frontend/AGENTS.md`.
 - In TypeScript and TSX, do not write `let` followed by later `if` assignments
   when the value can be expressed as a single `const` initializer. Prefer
   `const` because it prevents accidental later reassignment.
@@ -265,6 +517,20 @@ const value =
 - For user-facing Japanese kanji spelling, do not normalize to
   《当用漢字による書きかえ》; prefer original forms such as `編輯`.
 - For user-facing Japanese ellipses, prefer `……` over ASCII `...`.
+- Frontend dialogue work must use `@/lib/dialogues/useDialogue` as the
+  feature-facing entrypoint.
+- Reuse the existing common dialogue API and common dialogue component
+  instead of building feature-local overlay, close button, header, footer,
+  focus handling, outside click handling, Escape handling, or confirmation
+  flows.
+- Do not import `@/components/ui/dialog` directly in feature code to build a
+  one-off dialogue, and do not evade this rule with aliases such as
+  `Dialog as Dialogue`.
+- Keep business-specific form content in feature code, and keep the visual
+  and behavioural dialogue shell in common code.
+- Use British spelling `Dialogue` for project-defined dialogue identifiers.
+  Keep an exact third-party API spelling only at the external boundary where
+  compatibility requires it.
 
 ### Frontend TypeScript and TSX style
 
@@ -303,14 +569,17 @@ const value =
   beginning of a line.
 - The TSX-specific self-review must confirm JSX closing markers and closing
   parentheses keep the surrounding compact style.
-- The TypeScript/TSX self-review must confirm leading indentation follows
+- The TypeScript/TSX self-review must confirm leading block indentation uses
-  4-space logical indentation with tabs only as leading 8-space compression.
+  2 spaces per level, wrapped continuations use the repository's 4-space
+  continuation alignment, and complete leading runs of 8 spaces may be
+  compressed to tabs.
 - Prefer `const` arrow functions for TypeScript/TSX component and helper declarations.
 - Put two blank lines before and after top-level `const` function
   declarations, unless imports, exports, or file boundaries make that awkward.
-- In TSX, indent with 4-space logical indentation.
+- In TSX, use 2-space block indentation and 4-space continuation
-- In TypeScript and TSX, convert every leading run of 8 spaces to a tab
+  indentation.
-  character.
+- In TypeScript and TSX, convert every complete leading run of 8 spaces to a
+  tab character.
 - A leading tab is exactly equivalent to 8 leading spaces.
 - In TypeScript and TSX function declarations, including `const` arrow
   function declarations, classify the parameter list before placing the closing
@@ -938,8 +1207,9 @@ to `.ts` and `.tsx`:
 7. JSX `>` and `/>` stay with the final prop unless nearby code proves
    otherwise.
 8. JSX closing parentheses keep the compact local style.
-9. Leading indentation is 4-space logical indentation with tabs used only as
+9. Leading block indentation uses 2 spaces per level, wrapped continuations
-   leading 8-space compression.
+   use the repository's 4-space continuation alignment, and complete leading
+   runs of 8 spaces may be compressed to tabs.
 10. No line has trailing whitespace.
 
 Preferred:

backend/AGENTS.md

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

backend/app/controllers/post_imports_controller.rb

@@ -0,0 +1,44 @@
+class PostImportsController < ApplicationController
+  before_action :require_member!
+
+  def preview
+    rows = PostImportPreviewer.new.preview_rows(
+        rows: PostImportUrlListParser.parse(params[:source]))
+    render json: { rows: }
+  rescue ArgumentError => e
+    render_bad_request e.message
+  end
+
+  def validate
+    rows = normalised_import_rows allow_warning_fields: true
+    changed_row = Integer(params[:changed_row], exception: false)
+    result =
+        PostImportPreviewer.new.preview_rows(rows:,
+                                             fetch_metadata: changed_row,
+                                             metadata_cache: { })
+    render json: { rows: result }
+  rescue ArgumentError => e
+    render_bad_request e.message
+  end
+
+  def create
+    result = PostImportRunner.new(actor: current_user,
+                                  rows: normalised_import_rows).run
+    render json: result, status: result[:created].positive? ? :created : :ok
+  rescue ArgumentError => e
+    render_bad_request e.message
+  end
+
+  private
+
+  def require_member!
+    return head :unauthorized unless current_user
+    return if current_user.gte_member?
+
+    head :forbidden
+  end
+
+  def normalised_import_rows allow_warning_fields: false
+    PostImportRowNormaliser.normalise!(params[:rows], allow_warning_fields:)
+  end
+end

backend/app/controllers/posts_controller.rb

@@ -142,37 +142,14 @@ class PostsController < ApplicationController
     return head :unauthorized unless current_user
     return head :forbidden unless current_user.gte_member?
 
-    # TODO: サイトに応じて thumbnail_base 設定
+    post = PostCreator.new(actor: current_user,
-    title = params[:title].presence
+                           attributes: { title: params[:title], url: params[:url],
-    url = params[:url]
+                                         thumbnail: params[:thumbnail], tags: params[:tags],
-    thumbnail = params[:thumbnail]
+                                         original_created_from: params[:original_created_from],
-    tag_names = params[:tags].to_s.split
+                                         original_created_before: params[:original_created_before],
-    original_created_from = params[:original_created_from]
+                                         parent_post_ids: parse_parent_post_ids,
-    original_created_before = params[:original_created_before]
+                                         video_ms: params[:video_ms],
-    parent_post_ids = parse_parent_post_ids
+                                         duration: params[:duration] }).create!
-    resized_thumbnail = thumbnail.present? ? Post.resized_thumbnail_attachment(thumbnail) : nil
-
-    post = Post.new(title:, url:, thumbnail_base: nil, uploaded_user: current_user,
-                    original_created_from:, original_created_before:)
-    post.thumbnail.attach(resized_thumbnail) if resized_thumbnail
-
-    ApplicationRecord.transaction do
-      post.save!
-
-      Tag.normalise_tags!(tag_names, deny_deprecated: true, with_sections: true) =>
-          { tags:, sections: }
-      TagVersioning.record_tag_snapshots!(tags, created_by_user: current_user)
-
-      tags = Tag.expand_parent_tags(tags).reject(&:deprecated?)
-      post.video_ms = normalise_video_ms(tags)
-      validate_video_sections!(post.video_ms, sections)
-      post.save!
-      sync_post_tags!(post, tags, sections)
-
-      sync_parent_posts!(post, parent_post_ids)
-
-      PostVersionRecorder.record!(post:, event_type: :create, created_by_user: current_user)
-    end
 
     post.reload
     render json: PostRepr.base(post), status: :created
@@ -182,7 +159,7 @@ class PostsController < ApplicationController
     render_unprocessable_entity '廃止済みタグは付与できません．', field: :tags
   rescue Tag::SectionLiteralParseError
     render_validation_error fields: { tags: ['タグ区間の記法が不正です．'] }
-  rescue VideoMsParseError
+  rescue PostCreator::VideoMsParseError
     render_validation_error fields: { video_ms: ['動画時間の記法が不正です．'] }
   rescue MiniMagick::Error
     render_validation_error fields: { thumbnail: ['サムネイル画像の変換に失敗しました．'] }

backend/app/models/post.rb

@@ -173,15 +173,6 @@ class Post < ApplicationRecord
   def normalise_url
     return if url.blank?
 
-    self.url = url.strip
+    self.url = PostUrlNormaliser.normalise(url) || url.strip
-
-    u = URI.parse(url)
-    return unless u in URI::HTTP
-
-    u.host = u.host.downcase if u.host
-    u.path = u.path.sub(/\/\Z/, '') if u.path.present?
-    self.url = PostUrlSanitisationRule.sanitise(u.to_s)
-  rescue URI::InvalidURIError
-    ;
   end
 end

backend/app/services/post_creator.rb

@@ -0,0 +1,122 @@
+class PostCreator
+  class VideoMsParseError < ArgumentError; end
+
+  def initialize actor:, attributes:
+    @actor = actor
+    @attributes = attributes.symbolize_keys
+  end
+
+  def create!
+    post = Post.new(title: @attributes[:title].presence,
+                    url: @attributes[:url],
+                    thumbnail_base: @attributes[:thumbnail_base].presence,
+                    uploaded_user: @actor,
+                    original_created_from: @attributes[:original_created_from].presence,
+                    original_created_before: @attributes[:original_created_before].presence)
+    thumbnail = @attributes[:thumbnail]
+    post.thumbnail.attach(Post.resized_thumbnail_attachment(thumbnail)) if thumbnail.present?
+
+    ApplicationRecord.transaction do
+      post.save!
+      Tag.normalise_tags!(tag_names, deny_deprecated: true, with_sections: true) =>
+          { tags:, sections: }
+      TagVersioning.record_tag_snapshots!(tags, created_by_user: @actor)
+      tags = Tag.expand_parent_tags(tags).reject(&:deprecated?)
+      post.video_ms = normalise_video_ms(tags)
+      validate_video_sections!(post.video_ms, sections)
+      post.save!
+      sync_post_tags!(post, tags, sections)
+      sync_parent_posts!(post, parent_post_ids)
+      PostVersionRecorder.record!(post:, event_type: :create, created_by_user: @actor)
+    end
+    post
+  end
+
+  private
+
+  def tag_names = @attributes[:tags].to_s.split
+
+  def parent_post_ids
+    Array(@attributes[:parent_post_ids]).flat_map { _1.to_s.split }.map { |token|
+      id = Integer(token, exception: false)
+      raise ArgumentError, "親投稿 Id. が不正です: #{ token }" if id.nil? || id <= 0
+
+      id
+    }.uniq
+  end
+
+  def normalise_video_ms tags
+    return nil unless tags.any? { _1.id == Tag.video.id }
+
+    video_ms = @attributes[:video_ms]
+    if video_ms.present?
+      value = Integer(video_ms, exception: false)
+      raise VideoMsParseError unless value&.positive?
+
+      return value
+    end
+    duration = @attributes[:duration]
+    return nil if duration.blank?
+
+    return duration.to_i if duration.is_a?(Numeric) && duration.to_i.positive?
+
+    value = Tag.time_to_ms!(duration.to_s, tag_name: '動画時間')
+    raise VideoMsParseError unless value.positive?
+
+    value
+  rescue Tag::SectionLiteralParseError
+    raise VideoMsParseError
+  end
+
+  def validate_video_sections! video_ms, sections
+    return unless video_ms
+
+    sections.each_value do |ranges|
+      ranges.each do |begin_ms, end_ms|
+        post = Post.new
+        if begin_ms >= video_ms
+          post.errors.add :video_ms, 'タグ区間の開始が動画時間以上です．'
+          raise ActiveRecord::RecordInvalid, post
+        end
+        if end_ms && end_ms > video_ms
+          post.errors.add :video_ms, 'タグ区間の終端が動画時間を超えてゐます．'
+          raise ActiveRecord::RecordInvalid, post
+        end
+      end
+    end
+  end
+
+  def sync_post_tags! post, desired_tags, sections
+    desired_ids = desired_tags.map(&:id).to_set
+    current_ids = post.tags.pluck(:id).to_set
+    Tag.where(id: desired_ids - current_ids).find_each do |tag|
+      PostTag.create_or_find_by!(post:, tag:, created_user: @actor)
+    end
+    PostTagSection.where(post_id: post.id).destroy_all
+    sections.each do |tag_id, ranges|
+      ranges.each do |begin_ms, end_ms|
+        PostTagSection.create!(post_id: post.id,
+                               tag_id:,
+                               begin_ms:,
+                               end_ms:)
+      end
+    end
+    PostTag.where(post_id: post.id,
+                  tag_id: (current_ids - desired_ids).to_a).kept.find_each do |post_tag|
+      post_tag.discard_by!(@actor)
+    end
+  end
+
+  def sync_parent_posts! post, ids
+    if ids.include?(post.id)
+      post.errors.add :parent_post_ids, '自分自身を親投稿にはできません．'
+      raise ActiveRecord::RecordInvalid, post
+    end
+    missing = ids - Post.where(id: ids).pluck(:id)
+    if missing.present?
+      post.errors.add :parent_post_ids, "存在しない親投稿 Id. があります: #{ missing.join(' ') }"
+      raise ActiveRecord::RecordInvalid, post
+    end
+    ids.each { |parent_post_id| PostImplication.create_or_find_by!(post:, parent_post_id:) }
+  end
+end

backend/app/services/post_import_previewer.rb

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

backend/app/services/post_import_row_normaliser.rb

@@ -0,0 +1,189 @@
+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 + [
+      { field_warnings: {} },
+      { fieldWarnings: {} },
+      { base_warnings: [] },
+      { baseWarnings: [] }]
+  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
+    unless value.is_a?(String)
+      raise ArgumentError, 'URL の形式が不正です．'
+    end
+    if value.bytesize > PostImportUrlListParser::MAX_URL_BYTES
+      raise ArgumentError, 'URL が長すぎます．'
+    end
+  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
+    unless provenance.is_a?(Hash)
+      raise ArgumentError, 'provenance の形式が不正です．'
+    end
+
+    allowed = ATTRIBUTE_FIELDS + ['url']
+    unless (provenance.keys - allowed).empty?
+      raise ArgumentError, '値の由来が不正です．'
+    end
+    unless provenance.values.all? { ORIGINS.include?(_1) }
+      raise ArgumentError, '値の由来が不正です．'
+    end
+  end
+  private_class_method :normalise_provenance!
+
+  def self.normalise_tag_sources! tag_sources
+    return if tag_sources.nil?
+
+    unless tag_sources.is_a?(Hash)
+      raise ArgumentError, 'タグ由来の形式が不正です．'
+    end
+    unless (tag_sources.keys - ORIGINS).empty?
+      raise ArgumentError, 'タグ由来の形式が不正です．'
+    end
+    unless tag_sources.values.all? { _1.is_a?(String) }
+      raise ArgumentError, 'タグ由来の形式が不正です．'
+    end
+    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
+
+    field_warnings = normalised['field_warnings']
+    unless field_warnings.nil? || field_warnings.is_a?(Hash)
+      raise ArgumentError, '警告の形式が不正です．'
+    end
+    field_warnings&.each do |key, values|
+      unless ATTRIBUTE_FIELDS.include?(key) || key == 'url'
+        raise ArgumentError, '警告の形式が不正です．'
+      end
+      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
+
+    base_warnings = normalised['base_warnings']
+    return if base_warnings.nil?
+
+    unless base_warnings.is_a?(Array) && base_warnings.all? { _1.is_a?(String) }
+      raise ArgumentError, '警告の形式が不正です．'
+    end
+    if base_warnings.any? { _1.bytesize > PostImportUrlListParser::MAX_URL_BYTES }
+      raise ArgumentError, '警告が大きすぎます．'
+    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

@@ -0,0 +1,104 @@
+class PostImportRunner
+  def initialize actor:, rows:
+    @actor = actor
+    @rows = rows
+  end
+
+  def run
+    normalised_rows = PostImportRowNormaliser.normalise!(@rows)
+    previews = PostImportPreviewer.new.preview_rows(rows: normalised_rows,
+                                                    fetch_metadata: false)
+    preview_map = previews.index_by { _1[:source_row] }
+
+    results = normalised_rows.map do |row|
+      run_row(row, preview_map.fetch(row['source_row']))
+    end
+
+    { 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, preview
+    attributes = row.fetch('attributes', { }).transform_keys { _1.to_s.underscore }
+    return { source_row: row['source_row'],
+             status: 'failed',
+             errors: preview[:validation_errors],
+             recoverable: true } if preview[:validation_errors].present?
+    if preview[:skip_reason] == 'existing'
+      return { source_row: row['source_row'],
+               status: 'skipped',
+               existing_post_id: preview[:existing_post_id] }
+    end
+
+    attributes['tags'] = preview[:attributes]['tags']
+    attributes['url'] = row['url']
+    post = PostCreator.new(actor: @actor, attributes:).create!
+    { source_row: row['source_row'], status: 'created', post: PostRepr.base(post) }
+  rescue ActiveRecord::RecordInvalid => e
+    existing_post = existing_post_for_race(row, e.record)
+    if existing_post
+      return { source_row: row['source_row'],
+               status: 'skipped',
+               existing_post_id: existing_post.id }
+    end
+
+    { source_row: row['source_row'],
+      status: 'failed',
+      errors: e.record.errors.to_hash,
+      recoverable: true }
+  rescue ActiveRecord::RecordNotUnique => e
+    raise unless url_record_not_unique?(e)
+
+    existing_post = existing_post_for_race(row)
+    raise unless existing_post
+
+    { source_row: row['source_row'],
+      status: 'skipped',
+      existing_post_id: existing_post.id }
+  rescue Tag::NicoTagNormalisationError
+    { source_row: row['source_row'],
+      status: 'failed',
+      errors: { tags: ['ニコニコ・タグは直接指定できません．'] },
+      recoverable: true }
+  rescue Tag::DeprecatedTagNormalisationError
+    { source_row: row['source_row'],
+      status: 'failed',
+      errors: { tags: ['廃止済みタグは付与できません．'] },
+      recoverable: true }
+  rescue PostCreator::VideoMsParseError
+    { source_row: row['source_row'],
+      status: 'failed',
+      errors: { duration: ['動画時間の記法が不正です．'] },
+      recoverable: true }
+  rescue ArgumentError
+    { source_row: row['source_row'],
+      status: 'failed',
+      errors: { base: ['入力値が不正です．'] },
+      recoverable: true }
+  rescue StandardError => e
+    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 existing_post_for_race row, record = nil
+    if record && !(record.errors.of_kind?(:url, :taken))
+      return nil
+    end
+
+    normal_url = PostUrlNormaliser.normalise(row['url'])
+    return nil if normal_url.blank?
+
+    Post.find_by(url: normal_url)
+  end
+
+  def url_record_not_unique? error
+    error.message.include?('index_posts_on_url')
+  end
+end

backend/app/services/post_import_url_list_parser.rb

@@ -0,0 +1,25 @@
+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?
+
+      if url.bytesize > MAX_URL_BYTES
+        raise ArgumentError, "#{ index + 1 } 行目: URL が長すぎます．"
+      end
+
+      { 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

@@ -0,0 +1,131 @@
+require 'time'
+
+class PostMetadataFetcher
+  TIMESTAMP_PATTERN =
+      Regexp.new(
+          '\A(\d{4})-(\d{2})-(\d{2})T(\d{2})' \
+          '(?::(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?' \
+          '(Z|[+-]\d{2}:?\d{2})?\z')
+
+  def self.fetch raw_url
+    uri, = Preview::UrlSafety.validate(raw_url)
+    response = Preview::HttpFetcher.fetch(
+        uri.to_s,
+        max_bytes: Preview::ThumbnailFetcher::HTML_MAX_BYTES)
+    metadata = Preview::HtmlMetadataExtractor.extract(response)
+    document = Nokogiri::HTML.parse(response.body)
+    content = lambda { |name|
+      document
+        .at_css("meta[property='#{ name }'], meta[name='#{ name }']")
+        &.[]('content')
+        &.strip
+        &.presence
+    }
+    duration = content.call('og:video:duration') || content.call('video:duration')
+    published = content.call('article:published_time') || content.call('date')
+    created_range = original_created_range(published)
+    platform_tags = platform_tags(uri)
+    { title: metadata[:title],
+      thumbnail_base:
+          Preview::KnownSiteExtractor.thumbnail_url(uri) || metadata[:image_url],
+      original_created_from: serialise_time(created_range&.first),
+      original_created_before: serialise_time(created_range&.last),
+      duration: duration&.to_f&.then { _1.positive? ? (_1 * 1_000).round : nil },
+      tags: platform_tags.join(' ') }
+  end
+
+  def self.platform_tags uri
+    return ['動画', 'YouTube'] if Preview::KnownSiteExtractor.youtube_video_id(uri)
+    return ['動画', 'ニコニコ'] if Preview::KnownSiteExtractor.niconico_video_id(uri)
+
+    []
+  end
+
+  def self.original_created_range value
+    return nil if value.blank?
+
+    raw = value.to_s.strip
+    from, before =
+        case raw
+        when /\A(\d{4})\z/
+          year = Regexp.last_match(1).to_i
+          from = Time.zone.local(year, 1, 1)
+          [from, from + 1.year]
+        when /\A(\d{4})-(\d{2})\z/
+          year = Regexp.last_match(1).to_i
+          month = Regexp.last_match(2).to_i
+          from = Time.zone.local(year, month, 1)
+          [from, from + 1.month]
+        when /\A(\d{4})-(\d{2})-(\d{2})\z/
+          year = Regexp.last_match(1).to_i
+          month = Regexp.last_match(2).to_i
+          day = Regexp.last_match(3).to_i
+          from = Time.zone.local(year, month, day)
+          [from, from + 1.day]
+        else
+          parse_timestamp_range(raw)
+        end
+    return nil if from.nil? || before.nil?
+
+    [from, before]
+  rescue ArgumentError, TypeError
+    nil
+  end
+
+  def self.parse_timestamp_range raw
+    match = raw.match(TIMESTAMP_PATTERN)
+    return nil unless match
+
+    year = match[1].to_i
+    month = match[2].to_i
+    day = match[3].to_i
+    hour = match[4].to_i
+    minute = match[5]&.to_i || 0
+    second = match[6]&.to_i || 0
+    fraction = match[7]
+    offset = match[8]
+    whole_second = second + fractional_seconds(fraction)
+    from =
+        if offset.present?
+          Time.new(year, month, day, hour, minute, whole_second, parse_offset(offset)).in_time_zone
+        else
+          Time.zone.local(year, month, day, hour, minute, whole_second)
+        end
+    before =
+        if fraction.present?
+          from + (10**(-fraction.length))
+        elsif match[6].present?
+          from + 1.second
+        elsif match[5].present?
+          from + 1.minute
+        else
+          from + 1.hour
+        end
+    [from, before]
+  end
+
+  def self.parse_offset value
+    return '+00:00' if value == 'Z'
+
+    value.match?(/\A[+-]\d{2}:\d{2}\z/) ? value : "#{ value[0, 3] }:#{ value[3, 2] }"
+  end
+
+  def self.fractional_seconds value
+    return 0 if value.blank?
+
+    Rational(value.to_i, 10**value.length)
+  end
+
+  def self.serialise_time value
+    return nil if value.nil?
+
+    value.nsec.zero? ? value.iso8601 : value.iso8601(9)
+  end
+
+  private_class_method :platform_tags,
+                       :original_created_range,
+                       :parse_timestamp_range,
+                       :parse_offset,
+                       :fractional_seconds,
+                       :serialise_time
+end

backend/app/services/post_url_normaliser.rb

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

backend/app/services/preview/http_fetcher.rb

@@ -12,7 +12,9 @@ module Preview
 
     Response = Data.define(:body, :content_type, :url)
 
-    def self.fetch(raw_url, max_bytes: DEFAULT_MAX_BYTES, redirects: MAX_REDIRECTS)
+    def self.fetch(raw_url,
+                   max_bytes: DEFAULT_MAX_BYTES,
+                   redirects: MAX_REDIRECTS)
       uri, addresses = UrlSafety.validate(raw_url)
       response = request(uri, addresses.first, max_bytes)
 
@@ -67,7 +69,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/app/services/preview/known_site_extractor.rb

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

backend/config/routes.rb

@@ -33,6 +33,12 @@ Rails.application.routes.draw do
     get :thumbnail
   end
 
+  scope 'posts/import', controller: :post_imports do
+    post :preview
+    post :validate
+    post '', action: :create
+  end
+
   resources :wiki_pages, path: 'wiki', only: [:index, :show, :create, :update] do
     collection do
       get :search

backend/spec/requests/post_imports_spec.rb

@@ -0,0 +1,112 @@
+require 'rails_helper'
+
+RSpec.describe 'Post imports API', type: :request do
+  let(:member) { create(:user, :member) }
+
+  before do
+    allow(Preview::UrlSafety).to receive(:validate) do |url|
+      [URI.parse(url), ['8.8.8.8']]
+    end
+    allow(PostMetadataFetcher).to receive(:fetch).and_return(
+      title: 'fetched title',
+      thumbnail_base: nil,
+      tags: ''
+    )
+  end
+
+  describe 'POST /posts/import/preview' do
+    it 'requires a member' do
+      sign_out
+      post '/posts/import/preview', params: { source: 'https://example.com/post' }
+      expect(response).to have_http_status(:unauthorized)
+
+      sign_in_as(create(:user, :guest))
+      post '/posts/import/preview', params: { source: 'https://example.com/post' }
+      expect(response).to have_http_status(:forbidden)
+    end
+
+    it 'parses a URL list and returns preview rows' do
+      sign_in_as(member)
+
+      post '/posts/import/preview', params: {
+        source: " https://example.com/one \r\n\r\nhttps://example.com/two"
+      }
+
+      expect(response).to have_http_status(:ok)
+      expect(json.fetch('rows').map { _1.fetch('source_row') }).to eq([1, 3])
+      expect(json.fetch('rows').map { _1.fetch('url') }).to eq([
+        'https://example.com/one',
+        'https://example.com/two'
+      ])
+    end
+
+    it 'returns a safe 400 response for an invalid source' do
+      sign_in_as(member)
+
+      post '/posts/import/preview', params: { source: '' }
+
+      expect(response).to have_http_status(:bad_request)
+      expect(json.fetch('message')).to eq('URL を入力してください．')
+    end
+  end
+
+  describe 'POST /posts/import/validate' do
+    it 'accepts camel-case row properties and returns their warnings' do
+      sign_in_as(member)
+
+      post '/posts/import/validate', params: {
+        rows: [{
+          sourceRow: '1',
+          url: 'https://example.com/post',
+          metadataUrl: 'https://example.com/post',
+          attributes: { title: 'manual title' },
+          provenance: { url: 'manual', title: 'manual' },
+          tagSources: { automatic: '', manual: '' },
+          fieldWarnings: { title: ['old warning'] },
+          baseWarnings: ['base warning']
+        }],
+        changed_row: -1
+      }
+
+      expect(response).to have_http_status(:ok)
+      result = json.fetch('rows').first
+      expect(result.fetch('source_row')).to eq(1)
+      expect(result.fetch('tag_sources')).to eq('automatic' => '', 'manual' => '')
+      expect(result.fetch('field_warnings')).to eq('title' => ['old warning'])
+      expect(result.fetch('base_warnings')).to eq(['base warning'])
+    end
+
+    it 'rejects a non-array rows value with 400' do
+      sign_in_as(member)
+
+      post '/posts/import/validate', params: { rows: { sourceRow: 1 }, changed_row: -1 }
+
+      expect(response).to have_http_status(:bad_request)
+      expect(json.fetch('message')).to eq('取込行の形式が不正です．')
+    end
+  end
+
+  describe 'POST /posts/import' do
+    it 'returns a formal skipped result for an existing post' do
+      existing = create(:post, url: 'https://example.com/existing')
+      sign_in_as(member)
+
+      post '/posts/import', params: {
+        rows: [{
+          sourceRow: 1,
+          url: existing.url,
+          attributes: { title: 'ignored' },
+          provenance: { url: 'manual', title: 'manual' },
+          tagSources: { automatic: '', manual: '' }
+        }]
+      }
+
+      expect(response).to have_http_status(:ok)
+      expect(json).to include('created' => 0, 'skipped' => 1, 'failed' => 0)
+      expect(json.fetch('rows').first).to include(
+        'status' => 'skipped',
+        'existing_post_id' => existing.id
+      )
+    end
+  end
+end

backend/spec/services/post_import_previewer_spec.rb

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

backend/spec/services/post_import_row_normaliser_spec.rb

@@ -0,0 +1,77 @@
+require 'rails_helper'
+
+RSpec.describe PostImportRowNormaliser do
+  def valid_row(overrides = { })
+    {
+      sourceRow: '1',
+      url: 'https://example.com/post',
+      metadataUrl: 'https://example.com/post',
+      attributes: { title: 'title', duration: 1_000 },
+      provenance: { url: 'manual', title: 'automatic' },
+      tagSources: { automatic: 'tag', manual: '' }
+    }.deep_merge(overrides)
+  end
+
+  describe '.normalise!' do
+    it 'normalises aliases and source rows into a permitted plain hash' do
+      row = ActionController::Parameters.new(valid_row)
+
+      expect(described_class.normalise!([row])).to eq([
+        {
+          'source_row' => 1,
+          'url' => 'https://example.com/post',
+          'metadata_url' => 'https://example.com/post',
+          'attributes' => { 'title' => 'title', 'duration' => 1_000 },
+          'provenance' => { 'url' => 'manual', 'title' => 'automatic' },
+          'tag_sources' => { 'automatic' => 'tag', 'manual' => '' }
+        }
+      ])
+    end
+
+    it 'normalises source rows before checking duplicates' do
+      rows = [valid_row, valid_row(sourceRow: 1, url: 'https://example.com/other')]
+
+      expect { described_class.normalise!(rows) }
+          .to raise_error(ArgumentError, '元行番号が重複しています．')
+    end
+
+    it 'rejects non-array batches and non-hash rows' do
+      expect { described_class.normalise!({}) }
+          .to raise_error(ArgumentError, '取込行の形式が不正です．')
+      expect { described_class.normalise!(['row']) }
+          .to raise_error(ArgumentError, '取込行の形式が不正です．')
+    end
+
+    it 'rejects unknown attributes and invalid field types' do
+      expect { described_class.normalise!([valid_row(attributes: { unknown: 'x' })]) }
+          .to raise_error(ArgumentError, '取込項目が不正です．')
+      expect { described_class.normalise!([valid_row(attributes: { title: [] })]) }
+          .to raise_error(ArgumentError, '取込項目の型が不正です．')
+      expect { described_class.normalise!([valid_row(attributes: { duration: false })]) }
+          .to raise_error(ArgumentError, '取込項目の型が不正です．')
+    end
+
+    it 'rejects unknown provenance and tag-source values' do
+      expect { described_class.normalise!([valid_row(provenance: { title: 'mapped' })]) }
+          .to raise_error(ArgumentError, '値の由来が不正です．')
+      expect { described_class.normalise!([valid_row(tagSources: { mapped: 'tag' })]) }
+          .to raise_error(ArgumentError, 'タグ由来の形式が不正です．')
+    end
+
+    it 'accepts warning fields only at the validation boundary' do
+      row = valid_row.merge(
+        fieldWarnings: { title: ['取得できませんでした．'] },
+        baseWarnings: ['確認してください．']
+      )
+
+      without_warnings = described_class.normalise!([row]).first
+      with_warnings = described_class.normalise!([row], allow_warning_fields: true).first
+
+      expect(without_warnings).not_to include('field_warnings', 'base_warnings')
+      expect(with_warnings).to include(
+        'field_warnings' => { 'title' => ['取得できませんでした．'] },
+        'base_warnings' => ['確認してください．']
+      )
+    end
+  end
+end

backend/spec/services/post_import_runner_spec.rb

@@ -0,0 +1,133 @@
+require 'rails_helper'
+
+RSpec.describe PostImportRunner do
+  let(:actor) { create(:user, :member) }
+
+  def row(source_row: 1, url: 'https://example.com/post')
+    {
+      sourceRow: source_row,
+      url:,
+      attributes: { title: 'title', tags: '' },
+      provenance: { url: 'manual', title: 'manual', tags: 'manual' },
+      tagSources: { automatic: '', manual: '' }
+    }
+  end
+
+  def preview(source_row: 1, errors: { }, skip_reason: nil, existing_post_id: nil)
+    {
+      source_row:,
+      attributes: { 'title' => 'title', 'tags' => '' },
+      validation_errors: errors,
+      skip_reason:,
+      existing_post_id:
+    }
+  end
+
+  it 'previews the whole batch once before processing individual rows' do
+    rows = [row, row(source_row: 2, url: 'https://example.com/two')]
+    previewer = instance_double(PostImportPreviewer)
+    allow(PostImportPreviewer).to receive(:new).and_return(previewer)
+    expect(previewer).to receive(:preview_rows)
+        .with(
+          rows: satisfy { _1.map { |row_value| row_value['source_row'] } == [1, 2] },
+          fetch_metadata: false
+        )
+        .and_return([preview, preview(source_row: 2)])
+    allow(PostCreator).to receive(:new).and_return(
+      instance_double(PostCreator, create!: create(:post))
+    )
+
+    result = described_class.new(actor:, rows:).run
+
+    expect(result).to include(created: 2, skipped: 0, failed: 0)
+  end
+
+  it 'treats validation errors as failures before an existing skip' do
+    existing = create(:post)
+    previewer = instance_double(PostImportPreviewer)
+    allow(PostImportPreviewer).to receive(:new).and_return(previewer)
+    allow(previewer).to receive(:preview_rows).and_return([
+      preview(errors: { url: ['URL が重複しています．'] },
+              skip_reason: 'existing', existing_post_id: existing.id)
+    ])
+    expect(PostCreator).not_to receive(:new)
+
+    result = described_class.new(actor:, rows: [row]).run.fetch(:rows).first
+
+    expect(result).to include(
+      status: 'failed',
+      errors: { url: ['URL が重複しています．'] },
+      recoverable: true
+    )
+  end
+
+  it 'returns the existing post ID for skipped rows' do
+    existing = create(:post)
+    previewer = instance_double(PostImportPreviewer)
+    allow(PostImportPreviewer).to receive(:new).and_return(previewer)
+    allow(previewer).to receive(:preview_rows).and_return([
+      preview(skip_reason: 'existing', existing_post_id: existing.id)
+    ])
+
+    result = described_class.new(actor:, rows: [row]).run.fetch(:rows).first
+
+    expect(result).to eq(
+      source_row: 1,
+      status: 'skipped',
+      existing_post_id: existing.id
+    )
+  end
+
+  it 'converts a URL uniqueness validation race into a skip' do
+    existing = create(:post, url: 'https://example.com/race')
+    invalid = Post.new(url: existing.url)
+    invalid.errors.add(:url, :taken)
+    previewer = instance_double(PostImportPreviewer)
+    allow(PostImportPreviewer).to receive(:new).and_return(previewer)
+    allow(previewer).to receive(:preview_rows).and_return([preview])
+    creator = instance_double(PostCreator)
+    allow(PostCreator).to receive(:new).and_return(creator)
+    allow(creator).to receive(:create!).and_raise(ActiveRecord::RecordInvalid.new(invalid))
+
+    result = described_class.new(
+      actor:,
+      rows: [row(url: 'https://EXAMPLE.com/race/')]
+    ).run.fetch(:rows).first
+
+    expect(result).to include(status: 'skipped', existing_post_id: existing.id)
+  end
+
+  it 're-raises RecordNotUnique errors unrelated to the posts URL index' do
+    previewer = instance_double(PostImportPreviewer)
+    allow(PostImportPreviewer).to receive(:new).and_return(previewer)
+    allow(previewer).to receive(:preview_rows).and_return([preview])
+    creator = instance_double(PostCreator)
+    allow(PostCreator).to receive(:new).and_return(creator)
+    allow(creator).to receive(:create!)
+        .and_raise(ActiveRecord::RecordNotUnique, 'other_unique_index')
+
+    expect {
+      described_class.new(actor:, rows: [row]).run
+    }.to raise_error(ActiveRecord::RecordNotUnique)
+  end
+
+  it 'converts a posts URL index race into a skip' do
+    existing = create(:post, url: 'https://example.com/index-race')
+    previewer = instance_double(PostImportPreviewer)
+    allow(PostImportPreviewer).to receive(:new).and_return(previewer)
+    allow(previewer).to receive(:preview_rows).and_return([preview])
+    creator = instance_double(PostCreator)
+    allow(PostCreator).to receive(:new).and_return(creator)
+    allow(creator).to receive(:create!).and_raise(
+      ActiveRecord::RecordNotUnique,
+      'duplicate key index_posts_on_url'
+    )
+
+    result = described_class.new(
+      actor:,
+      rows: [row(url: 'https://EXAMPLE.com/index-race/')]
+    ).run.fetch(:rows).first
+
+    expect(result).to include(status: 'skipped', existing_post_id: existing.id)
+  end
+end

backend/spec/services/post_import_url_list_parser_spec.rb

@@ -0,0 +1,40 @@
+require 'rails_helper'
+
+RSpec.describe PostImportUrlListParser do
+  describe '.parse' do
+    it 'trims URLs, ignores blank lines, and preserves source line numbers' do
+      source = "  https://example.com/one  \r\n\r\nhttps://example.com/two\n"
+
+      expect(described_class.parse(source)).to eq([
+        { source_row: 1, url: 'https://example.com/one' },
+        { source_row: 3, url: 'https://example.com/two' }
+      ])
+    end
+
+    it 'rejects an empty URL list' do
+      expect { described_class.parse(" \n\r\n") }
+          .to raise_error(ArgumentError, 'URL を入力してください．')
+    end
+
+    it 'rejects more than 100 non-empty rows' do
+      source = 101.times.map { |index| "https://example.com/#{ index }" }.join("\n")
+
+      expect { described_class.parse(source) }
+          .to raise_error(ArgumentError, '取込件数は 100 件までです．')
+    end
+
+    it 'includes the original line number in an oversized URL error' do
+      source = "\n#{ 'a' * (described_class::MAX_URL_BYTES + 1) }"
+
+      expect { described_class.parse(source) }
+          .to raise_error(ArgumentError, '2 行目: URL が長すぎます．')
+    end
+
+    it 'rejects an oversized request before parsing rows' do
+      source = 'a' * (described_class::MAX_BYTES + 1)
+
+      expect { described_class.parse(source) }
+          .to raise_error(ArgumentError, '入力が大きすぎます．')
+    end
+  end
+end

backend/spec/services/post_metadata_fetcher_spec.rb

@@ -0,0 +1,64 @@
+require 'rails_helper'
+
+RSpec.describe PostMetadataFetcher do
+  Response = Struct.new(:body)
+
+  def fetch_with_published_time(value, url: 'https://example.com/video')
+    html = <<~HTML
+      <html><head>
+        <meta property="article:published_time" content="#{ value }">
+      </head></html>
+    HTML
+    uri = URI.parse(url)
+    allow(Preview::UrlSafety).to receive(:validate).with(url).and_return([uri, ['8.8.8.8']])
+    allow(Preview::HttpFetcher).to receive(:fetch).and_return(Response.new(html))
+    allow(Preview::HtmlMetadataExtractor).to receive(:extract)
+        .and_return(title: 'title', image_url: nil)
+
+    described_class.fetch(url)
+  end
+
+  it 'builds ranges explicitly for year, month, and day precision' do
+    year = fetch_with_published_time('2024')
+    month = fetch_with_published_time('2024-02')
+    day = fetch_with_published_time('2024-02-03')
+
+    expect(year).to include(
+      original_created_from: Time.zone.local(2024, 1, 1).iso8601,
+      original_created_before: Time.zone.local(2025, 1, 1).iso8601
+    )
+    expect(month).to include(
+      original_created_from: Time.zone.local(2024, 2, 1).iso8601,
+      original_created_before: Time.zone.local(2024, 3, 1).iso8601
+    )
+    expect(day).to include(
+      original_created_from: Time.zone.local(2024, 2, 3).iso8601,
+      original_created_before: Time.zone.local(2024, 2, 4).iso8601
+    )
+  end
+
+  it 'preserves an input offset and fractional-second precision' do
+    result = fetch_with_published_time('2024-02-03T12:34:56.123+02:30')
+
+    expect(Time.iso8601(result.fetch(:original_created_from)))
+        .to eq(Time.iso8601('2024-02-03T12:34:56.123+02:30'))
+    expect(
+      Time.iso8601(result.fetch(:original_created_before)) -
+      Time.iso8601(result.fetch(:original_created_from))
+    ).to eq(0.001)
+    expect(result.fetch(:original_created_from)).to include('.123000000')
+  end
+
+  it 'adds platform tags for known video URLs' do
+    result = fetch_with_published_time('2024', url: 'https://youtu.be/abc123')
+
+    expect(result.fetch(:tags)).to eq('動画 YouTube')
+  end
+
+  it 'returns nil dates for an invalid timestamp' do
+    result = fetch_with_published_time('not-a-time')
+
+    expect(result.fetch(:original_created_from)).to be_nil
+    expect(result.fetch(:original_created_before)).to be_nil
+  end
+end

backend/spec/services/post_url_normaliser_spec.rb

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

frontend/AGENTS.md

@@ -50,16 +50,27 @@ pass or the remaining failure is clearly blocked.
 - Prefer single quotes for strings unless interpolation or escaping makes double quotes better.
 - Never write a TypeScript or TSX line longer than 99 characters.
 - Aim to keep TypeScript and TSX lines within 79 characters where practical.
-- Use 4-space logical indentation in TypeScript and TSX.
+- Use 2-space block indentation in TypeScript and TSX.
+- Use 4-space continuation indentation for wrapped expressions, arguments,
+  ternary branches, method chains, object pairs, arrays, and JSX attributes.
+- Treat the user's `PostImportSourcePage.tsx` and
+  `PostImportReviewPage.tsx` formatting as the local reference shape.
 - For arrays, never put whitespace or a line break immediately before `]`.
 - Keep the first element on the same line as `[` by default.
 - If an array would exceed the line limit, break after `[` and indent
   elements by 4 spaces.
-- In TypeScript and TSX only, replace every leading run of 8 spaces with a tab
+- In TypeScript and TSX only, use tabs for leading 8-column compression only.
-  to reduce bytes.
+- A tab does not represent one indentation level.
+- Determine visible indentation with 2-space block indentation and 4-space
+  continuation indentation first, then compress only complete leading runs of
+  8 spaces into tabs.
 - Treat one leading tab as exactly equivalent to 8 leading spaces.
 - Use tabs only for leading indentation. Never replace spaces that occur after
   a non-space character on the same line.
+- Keep residual leading 2, 4, or 6 spaces after any tab compression.
+- Examples: 2 columns = 2 spaces, 4 columns = 4 spaces, 6 columns = 6
+  spaces, 8 columns = 1 tab, 10 columns = 1 tab + 2 spaces, 12 columns = 1
+  tab + 4 spaces.
 
 ## React
 
@@ -97,12 +108,23 @@ pass or the remaining failure is clearly blocked.
   third-party request outside the Rails API.
 - For blob responses, pass `responseType: 'blob'` so the wrapper does not camelCase the body.
 
+## Dialogues
+
+- Dialogue work follows the shared-frontend reuse rules below.
+
 ## Imports and aliases
 
 - The `@` alias points to `frontend/src`.
 - Prefer `@/...` imports for app code instead of long relative paths.
 - Keep type imports separate with `import type`.
-- Match existing import grouping: external packages, app modules, then type imports.
+- Do not mix runtime values and `type` specifiers in one named import
+  declaration.
+- Do not write `import { value, type TypeName } from ...`.
+- Keep short value imports from one module on one line when they fit within
+  99 characters.
+- Order imports as four groups with a blank line between groups: external
+  value imports, `@/...` value imports, external type imports, `@/...`
+  type imports.
 
 ## Tailwind and UI
 
@@ -129,6 +151,30 @@ pass or the remaining failure is clearly blocked.
   it is JSX- or React-specific.
 - Preserve compact TSX expression shapes such as inline ternary branches and
   closing `</div>)` forms when nearby code uses them.
+- Block bodies for components, functions, callbacks, `if`, `try`, `catch`,
+  `finally`, loops, and JSX nesting use 2 spaces per level.
+- Wrapped expressions, arguments, ternary branches, method chains, and object
+  pairs use 4-space continuation indentation relative to the owning
+  expression. Do not confuse this with 2-space block indentation.
+- Tabs are leading 8-column compression only. They do not represent one
+  nesting level. Decide visible indentation first, then compress only
+  complete leading runs of 8 spaces into tabs.
+- Do not add braces around a single-line `if` body merely for formatting.
+- Use braces for multi-line `if`, `else`, and loop bodies.
+- Multi-stage ternary expressions must use explicit parentheses for each
+  condition group and nested branch. Do not rely on indentation alone to show
+  `?` / `:` pairing.
+- Keep short inline props types local when they remain readable and within the
+  line limit; do not mechanically extract a named type with no reuse benefit.
+- In multi-line object literals, keep the opening `{` with the first pair when
+  the line length allows it; do not mechanically explode short objects into
+  Prettier-style vertical blocks.
+- Method chains should align as a continuation under the receiver expression;
+  do not indent chains more deeply than the normal continuation depth.
+- `PostImportSourcePage.tsx` and `PostImportReviewPage.tsx` are the current
+  canonical examples for block indentation, continuation indentation, import
+  grouping, ternary grouping, method-chain placement, and local inline props
+  types.
 - Treat TypeScript and TSX formatting rules as hard constraints, not
   preferences. Before finishing a TypeScript or TSX edit, inspect the edited
   hunks for closing `)`, `]`, and `}` placement and fix violations instead of
@@ -158,14 +204,76 @@ pass or the remaining failure is clearly blocked.
   beginning of a line.
 - The TSX-specific self-review must confirm JSX closing markers and closing
   parentheses keep the surrounding compact style.
-- The TypeScript/TSX self-review must confirm leading indentation follows
+- The TypeScript/TSX self-review must confirm leading block indentation uses
-  4-space logical indentation with tabs only as leading 8-space compression.
+  2 spaces per level, wrapped continuations use the repository's 4-space
+  continuation alignment, and complete leading runs of 8 spaces may be
+  compressed to tabs.
 - For long Tailwind `className` strings, wrap across lines only when needed.
-- Keep continuation indentation aligned with the 4-space logical indentation
+- Keep continuation indentation aligned with the repository's 4-space
-  rule, using tabs only as leading 8-space compression.
+  continuation rule while keeping block indentation at 2 spaces.
+- Keep short value imports from one module on one line when they fit within
+  99 characters.
 - In TypeScript and TSX function declarations, including `const` arrow
   function declarations, classify the parameter list before placing the closing
   `)`.
+- Block indentation example:
+
+```ts
+const Component = () => {
+  const value = loadValue ()
+
+  useEffect (() => {
+    if (value != null)
+      useValue (value)
+  }, [value])
+}
+```
+
+- Continuation indentation example:
+
+```ts
+const editingRow =
+    Number.isFinite (editingSourceRow)
+    ? rows.find (_1 => _1.sourceRow === editingSourceRow) ?? null
+    : null
+```
+
+- Import grouping example:
+
+```ts
+import { useNavigate, useParams, useSearchParams } from 'react-router-dom'
+
+import { loadPostImportSession } from '@/lib/postImportSession'
+
+import type { FC } from 'react'
+
+import type { PostImportRow } from '@/lib/postImportSession'
+```
+
+- Inline props type example:
+
+```ts
+const Footer = (
+    { loading,
+      onSubmit }: { loading:  boolean
+		    onSubmit: () => void },
+) => null
+```
+
+- Ternary grouping example:
+
+```ts
+const rows =
+    repairMode === 'failed'
+    ? (
+	[...source].sort ((a, b) => {
+	  const aFailed = a.failed ? 0 : 1
+	  const bFailed = b.failed ? 0 : 1
+	  return aFailed - bFailed
+	}))
+    : source
+```
+
 - If the parameter list itself is given its own multi-line block after the
   function's opening `(`, put the closing parameter `)` at the beginning of its
   own line before the return type or `=>`.
@@ -219,6 +327,237 @@ pass or the remaining failure is clearly blocked.
   `BehaviorSettingsSection.tsx`.
 - Avoid reformatting unrelated JSX.
 
+## Shared frontend systems
+
+Before creating a new component, hook, helper, store, context, or other
+frontend abstraction, search at least:
+
+- `src/components/common`
+- `src/components/layout`
+- `src/components/ui`
+- `src/components/dialogues`
+- `src/lib`
+- `src/lib/dialogues`
+- `src/stores`
+- `src/types.ts`
+
+Also inspect the existing pages and components in the same feature.
+
+Search by responsibility, not by filename alone. Check display, interaction,
+state, communication, validation, and permission behaviour before deciding that
+an existing implementation is unsuitable.
+
+### Component placement and reuse order
+
+When adding UI, use this order:
+
+1. reuse an existing feature component
+2. reuse an existing component from `components/common`
+3. reuse an existing layout component from `components/layout`
+4. use an existing primitive from `components/ui` through the established
+   common API
+5. extend an existing component minimally
+6. add a feature-local component in the feature area
+7. add a new common component only when multiple features clearly share a
+   stable visual contract
+
+Do not place a one-screen component in a common directory merely because its
+name starts with `Common`.
+
+### Low-level primitives
+
+Treat `components/ui` as low-level primitives. If a higher-level common API
+already exists for dialogues, toast, form validation, navigation, or similar
+behaviour, feature code must use that API instead of assembling primitives
+directly.
+
+Examples of existing preferred entrypoints include:
+
+- dialogue: `@/lib/dialogues/useDialogue`
+- toast: the existing toast API
+- internal navigation: `PrefetchLink`
+- form errors: `FieldError`, `FieldWarning`, `FormField`
+- buttons: `Button`
+- conditional class merge: `cn`
+
+Do not evade the rule with aliases or thin wrappers around the low-level
+primitive.
+
+### Dialogues
+
+Feature-facing dialogue work must use `@/lib/dialogues/useDialogue`.
+
+Reuse the existing common dialogue API and common dialogue component. Do not
+import `@/components/ui/dialog` directly in feature code to assemble bespoke
+dialogue shells, and do not evade this rule with aliases such as
+`Dialog as Dialogue`.
+
+Do not reimplement overlay, portal, close button, header, footer, focus
+handling, Escape handling, outside-click handling, or confirmation flow in
+feature code.
+
+Keep business-specific form content in feature code, and keep the visual and
+behavioural dialogue shell in common code.
+
+Use British spelling `Dialogue` for project-defined dialogue identifiers. Keep
+exact third-party spellings only at the external boundary where compatibility
+requires them.
+
+### API calls
+
+Rails API calls must use `src/lib/api.ts`.
+
+Do not create feature-local Axios instances, fetch wrappers, header injectors,
+camelCase converters, or generic error converters. If blob or other special
+transport behaviour is already supported by the common API, use the existing
+options instead of bypassing the wrapper.
+
+### Query keys, server state, and prefetch
+
+Before adding query state, inspect:
+
+- `src/lib/queryKeys.ts`
+- existing domain helpers
+- existing prefetchers
+- the root query-key hierarchy
+- current mutation invalidation patterns
+- the app-wide `QueryClient`
+
+Do not write ad hoc query-key arrays in feature code. Do not duplicate fetcher,
+prefetcher, or invalidation helpers for the same resource.
+
+### Domain helpers
+
+For posts, tags, wiki, materials, and other domain work, inspect the existing
+helpers in `src/lib/*.ts` before adding logic to a page component.
+
+Do not accumulate these in page components when an existing helper layer should
+own them:
+
+- API request construction
+- response-shape conversion
+- query-key construction
+- canonical URL generation
+- permission calculation
+- storage serialisation
+- domain-specific parsing
+
+Keep purely local one-screen display shaping local when that is the clearest
+place for it.
+
+### Permission helpers
+
+Use the existing permission helpers such as `src/lib/users.ts` when deciding
+editability, role checks, admin/member visibility, and similar UI behaviour.
+
+Do not scatter `user?.role`, numeric role comparisons, or string comparisons
+through components. Frontend visibility control should be consistent even though
+backend authorization remains the final gate.
+
+### Validation errors
+
+Before adding feature-local validation-error handling, inspect:
+
+- `useValidationErrors`
+- `apiErrors`
+- `FieldError`
+- `FieldWarning`
+- `FormField`
+- `inputClass`
+
+Do not create a new generic hook, field-error state shape, or error-rendering
+component for a pattern the shared error stack already covers. Keep only
+genuinely feature-specific business errors local.
+
+### Forms and fields
+
+Before creating a new input, textarea, date/time field, tag input, label, or
+error layout, inspect at least:
+
+- `Form`
+- `FormField`
+- `FieldError`
+- `FieldWarning`
+- `DateTimeField`
+- `TagInput`
+- `TextArea`
+- `Label`
+- `Button`
+
+Do not create a same-function field component merely because the spacing or
+surface styling is slightly different. Prefer feature-level composition over
+bloated common-field option lists.
+
+### Navigation and prefetch
+
+Use `PrefetchLink` and existing router helpers for internal navigation. Do not
+introduce feature-local `<a>`, `window.location`, or custom prefetch logic for
+internal routes. Keep path-segment encoding aligned with the existing rules.
+
+### State management
+
+Before adding state, decide whether the source of truth should be:
+
+- component-local state
+- URL search params
+- TanStack Query server state
+- an existing Zustand store
+- an existing event bus
+- an existing storage helper
+
+Do not create a new global store, context, or event bus for one screen when
+local state or an existing mechanism is enough. Do not create a second store
+for the same responsibility.
+
+### Storage and settings
+
+When touching localStorage, sessionStorage, or user settings, inspect existing
+settings helpers, storage helpers, expiry handling, versioning, and sanitisers.
+
+Do not reimplement per-component key naming, JSON parsing and serialisation,
+expiry, or schema checks when a shared helper already owns the pattern.
+
+### Hooks
+
+Before creating a custom hook, search existing `src/lib/use*.ts` and
+`src/lib/use*.tsx`.
+
+Hooks are for shared stateful behaviour or React lifecycle integration. Do not
+turn a pure function, one-off helper, or mere re-export shim into `useFoo`.
+
+### Stores, contexts, and event buses
+
+Add a new store, context, or event bus only when the current mechanisms cannot
+express the requirement and there are multiple genuinely separate consumers.
+
+Do not hold the same information redundantly across URL state, query cache,
+local component state, Zustand, and an event bus. Keep one source of truth.
+
+### Types
+
+If a domain type already exists in `src/types.ts` or a domain helper, reuse it
+instead of redefining the same shape in a feature file.
+
+Small local props and draft types may stay local. Do not create giant
+catch-all type files such as `CommonTypes.ts`.
+
+### Styling utilities
+
+Use existing styling utilities such as `cn` and `inputClass`.
+
+Do not add feature-local class-merge helpers, generic status-colour mappers, or
+responsive wrapper helpers when a shared utility already exists. Keep common
+tone names visual only; feature-specific state names stay in feature code.
+
+### Layout
+
+Before adding page shells, padding rules, viewport-height handling, sidebar
+offsets, or footer offsets, inspect existing layout components such as
+`MainArea`, top navigation, sidebar, page title, and section-title patterns.
+
+Do not create a second layout shell before checking whether the current layout
+can be reused or minimally extended.
+
 ### Delimiter decision table
 
 Use this table before accepting any edited TypeScript or TSX hunk. The table is
@@ -563,8 +902,9 @@ hunks line by line:
 7. JSX `>` and `/>` stay with the final prop unless nearby code proves
    otherwise.
 8. JSX closing parentheses keep the compact local style.
-9. Leading indentation is 4-space logical indentation with tabs used only as
+9. Leading block indentation uses 2 spaces per level, wrapped continuations
-   leading 8-space compression.
+   use the repository's 4-space continuation alignment, and complete leading
+   runs of 8 spaces may be compressed to tabs.
 10. No line has trailing whitespace.
 
 ## Lint and build constraints

frontend/src/App.tsx

@@ -41,6 +41,9 @@ 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 PostSearchPage from '@/pages/posts/PostSearchPage'
@@ -75,6 +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={<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/>}/>
@@ -113,6 +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={<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/PostOriginalCreatedTimeField.tsx

@@ -23,10 +23,10 @@ const PostOriginalCreatedTimeField: FC<Props> = (
     <FormField label="オリジナルの作成日時" messages={errors}>
       {({ describedBy, invalid }) => (
 	  <>
-	    <div className="my-1 flex">
+	    <div className="my-1 flex flex-col gap-2 sm:flex-row sm:items-start">
-	      <div className="w-80">
+	      <div className="min-w-0 flex-1">
 		<DateTimeField
-		    className="mr-2"
+		    className="w-full"
 		    disabled={disabled ?? false}
 		    aria-describedby={describedBy}
 		    aria-invalid={invalid}
@@ -49,6 +49,7 @@ const PostOriginalCreatedTimeField: FC<Props> = (
 	      </div>
 	      <div>
 		<Button
+		    type="button"
 		    className="bg-gray-600 text-white rounded"
 		    disabled={disabled}
 		    onClick={() => {
@@ -59,10 +60,10 @@ const PostOriginalCreatedTimeField: FC<Props> = (
 	      </div>
 	    </div>
 
-	    <div className="my-1 flex">
+	    <div className="my-1 flex flex-col gap-2 sm:flex-row sm:items-start">
-	      <div className="w-80">
+	      <div className="min-w-0 flex-1">
 		<DateTimeField
-		    className="mr-2"
+		    className="w-full"
 		    disabled={disabled}
 		    aria-describedby={describedBy}
 		    aria-invalid={invalid}
@@ -73,6 +74,7 @@ const PostOriginalCreatedTimeField: FC<Props> = (
 	      </div>
 	      <div>
 		<Button
+		    type="button"
 		    className="bg-gray-600 text-white rounded"
 		    disabled={disabled}
 		    onClick={() => {

frontend/src/components/TopNav.test.tsx

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest'
+
+import { menuOutline } from '@/components/TopNav'
+import { buildUser } from '@/test/factories'
+
+const submenuItem = (role: 'guest' | 'member' | 'admin', section: string, item: string) => {
+  const menu = menuOutline ({
+    user: buildUser ({ role }),
+    wikiId: section === 'Wiki' ? 10 : null,
+    pathName: section === 'Wiki' ? '/wiki/page' : '/posts' })
+  return menu.find (_1 => _1.name === section)?.subMenu.find (_1 => _1.name === item)
+}
+
+describe ('menuOutline', () => {
+  it ('uses content-edit permission for post, material, and Wiki actions', () => {
+    for (const role of ['member', 'admin'] as const)
+      {
+	expect (submenuItem (role, '広場', '追加')?.visible).toBe (true)
+	expect (submenuItem (role, '広場', '取込')?.visible).toBe (true)
+	expect (submenuItem (role, '素材', '追加')?.visible).toBe (true)
+	expect (submenuItem (role, 'Wiki', '新規')?.visible).toBe (true)
+	expect (submenuItem (role, 'Wiki', '編輯')?.visible).toBe (true)
+      }
+
+    expect (submenuItem ('guest', '広場', '追加')?.visible).toBe (false)
+    expect (submenuItem ('guest', '広場', '取込')?.visible).toBe (false)
+    expect (submenuItem ('guest', '素材', '追加')?.visible).toBe (false)
+    expect (submenuItem ('guest', 'Wiki', '新規')?.visible).toBe (false)
+    expect (submenuItem ('guest', 'Wiki', '編輯')?.visible).toBe (false)
+  })
+
+  it ('keeps material suppression admin-only', () => {
+    expect (submenuItem ('member', '素材', '抑止')?.visible).toBe (false)
+    expect (submenuItem ('admin', '素材', '抑止')?.visible).toBe (true)
+  })
+})

frontend/src/components/TopNav.tsx

@@ -9,6 +9,7 @@ import TopNavUser from '@/components/TopNavUser'
 import { WikiIdBus } from '@/lib/eventBus/WikiIdBus'
 import { materialsKeys, tagsKeys, wikiKeys } from '@/lib/queryKeys'
 import { useClientBehaviourSettings } from '@/lib/useClientBehaviourSettings'
+import { canEditContent } from '@/lib/users'
 import { fetchTag, fetchTagByName } from '@/lib/tags'
 import { fetchMaterial } from '@/lib/materials'
 import { cn } from '@/lib/utils'
@@ -18,7 +19,7 @@ import type { FC, MouseEvent } from 'react'
 
 import type { Material, Menu, MenuVisibleItem, Tag, User } from '@/types'
 
-type Props = { user: User | null }
+type Props = { user: User | null, }
 
 
 export const menuOutline = (
@@ -26,10 +27,11 @@ 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
+  const editable = canEditContent (user)
 
   const wikiPageFlg = Boolean (/^\/wiki\/(?!new|changes)[^/]+/.test (pathName) && wikiId)
   const wikiTitle = pathName.split ('/')[2] ?? ''
@@ -42,7 +44,8 @@ export const menuOutline = (
       { name: '広場', to: '/posts', subMenu: [
 	  { name: '一覧', to: '/posts' },
 	  { name: '検索', to: '/posts/search' },
-	  { name: '追加', to: '/posts/new' },
+	  { name: '追加', to: '/posts/new', visible: editable },
+	  { name: '取込', to: '/posts/import', visible: editable },
 	  { name: '全体履歴', to: '/posts/changes' },
 	  { name: 'ヘルプ', to: '/wiki/ヘルプ:広場' }] },
       { name: 'タグ', to: '/tags', subMenu: [
@@ -58,8 +61,9 @@ export const menuOutline = (
 	    visible: tagFlg && tag?.category !== 'nico' }] },
       { name: '素材', to: '/materials', visible: true, subMenu: [
 	  { name: '一覧', to: '/materials' },
-	  { name: '追加', to: '/materials/new' },
+	  { name: '追加', to: '/materials/new', visible: editable },
-	  { name: '抑止', to: '/materials/suppressions' },
+	  { name: '抑止', to: '/materials/suppressions',
+	    visible: user?.role === 'admin' },
 	  { name: '全体履歴', to: '/materials/changes' },
 	  { name: 'ヘルプ', to: '/wiki/ヘルプ:素材管理' },
 	  { component: <Separator/>, visible: materialFlg },
@@ -70,14 +74,15 @@ export const menuOutline = (
 	    visible: materialFlg }] },
       { name: 'Wiki', to: '/wiki/ヘルプ:ホーム', base: '/wiki', subMenu: [
 	  { name: '検索', to: '/wiki' },
-	  { name: '新規', to: '/wiki/new' },
+	  { name: '新規', to: '/wiki/new', visible: editable },
 	  { name: '全体履歴', to: '/wiki/changes' },
 	  { name: 'ヘルプ', to: '/wiki/ヘルプ:Wiki' },
 	  { component: <Separator/>, visible: wikiPageFlg },
 	  { name: `広場 (${ postCount || 0 })`, to: `/posts?tags=${ wikiTitle }`,
 	    visible: wikiPageFlg },
 	  { name: '履歴', to: `/wiki/changes?id=${ wikiId }`, visible: wikiPageFlg },
-	  { name: '編輯', to: `/wiki/${ wikiId || wikiTitle }/edit`, visible: wikiPageFlg }] },
+	  { name: '編輯', to: `/wiki/${ wikiId || wikiTitle }/edit`,
+	    visible: wikiPageFlg && editable }] },
       { name: 'おたのしみ', visible: false, subMenu: [
 	  { name: '上映会 (β)', to: '/theatres/1' },
 	  { name: 'グカネータ (β)', to: '/gekanator' }] },

frontend/src/components/common/FieldWarning.tsx

@@ -0,0 +1,18 @@
+import type { FC } from 'react'
+
+type Props = { id?:        string
+	       messages?:  string[] }
+
+
+export const FieldWarning: FC<Props> = ({ id, messages }: Props) => {
+  if (messages == null || messages.length === 0)
+    return null
+
+  return (
+      <ul id={id} className="mt-1 space-y-1 text-amber-700 dark:text-amber-200">
+	{messages.map ((message, i) => <li key={i}>{message}</li>)}
+      </ul>)
+}
+
+
+export default FieldWarning

frontend/src/components/common/Form.tsx

@@ -1,10 +1,14 @@
+import { cn } from '@/lib/utils'
+
 import type { FC, ReactNode } from 'react'
 
-type Props = { children: ReactNode }
+type Props = {
+    children:   ReactNode
+    className?: string }
 
 
-const Form: FC<Props> = ({ children }) => (
+const Form: FC<Props> = ({ children, className }) => (
-    <div className="max-w-xl mx-auto p-4 space-y-4">
+    <div className={cn ('mx-auto max-w-xl space-y-4 p-4', className)}>
       {children}
     </div>)
 

frontend/src/components/common/StatusBadge.tsx

@@ -0,0 +1,34 @@
+import { cn } from '@/lib/utils'
+
+import type { FC, ReactNode } from 'react'
+
+export type StatusBadgeTone =
+    'success'
+    | 'neutral'
+    | 'warning'
+
+type Props = {
+    children: ReactNode
+    tone:     StatusBadgeTone }
+
+const TONES: Record<StatusBadgeTone, string[]> = {
+    success: [
+	'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'],
+    neutral: [
+	'border-stone-300 bg-stone-50 text-stone-700',
+	'dark:border-stone-700 dark:bg-stone-900 dark:text-stone-200'] }
+
+
+const StatusBadge: FC<Props> = ({ children, tone }) => (
+    <span
+	className={cn (
+	    'inline-flex items-center rounded-full border px-2.5 py-1 text-xs font-medium',
+	    TONES[tone])}>
+      {children}
+    </span>)
+
+export default StatusBadge

frontend/src/components/dialogues/DialogueProvider.test.tsx

@@ -0,0 +1,114 @@
+import { useCallback, useEffect } from 'react'
+import { fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+import DialogueProvider from '@/components/dialogues/DialogueProvider'
+import useDialogue from '@/lib/dialogues/useDialogue'
+
+import type { DialogueFormControls } from '@/lib/dialogues/useDialogue'
+
+const FormBody = (
+    { controls,
+      onSelect }: { controls: DialogueFormControls
+		    onSelect: () => Promise<boolean> | boolean },
+) => {
+  useEffect (() => {
+    controls.setActions ([{
+      label: '左操作',
+      placement: 'start',
+      onSelect }, {
+      label: '保存',
+      onSelect: () => true }])
+  }, [controls, onSelect])
+
+  return <div>長いフォーム本文</div>
+}
+
+const NestedConfirmFormBody = ({ controls }: { controls: DialogueFormControls }) => {
+  const reset = useCallback (async () => {
+    await controls.confirm ({
+      title: '変更をリセットしますか?',
+      confirmText: 'リセット' })
+    return false
+  }, [controls])
+
+  return <FormBody controls={controls} onSelect={reset}/>
+}
+
+describe ('DialogueProvider', () => {
+  it ('keeps ordinary dialogues in FIFO order', async () => {
+    const Launcher = () => {
+      const dialogue = useDialogue ()
+      return (
+	  <button
+	      onClick={() => {
+		void dialogue.confirm ({ title: '一件目' })
+		void dialogue.confirm ({ title: '二件目' })
+	      }}>
+	    開く
+	  </button>)
+    }
+
+    render (<DialogueProvider><Launcher/></DialogueProvider>)
+    fireEvent.click (screen.getByRole ('button', { name: '開く' }))
+
+    expect (screen.getByText ('一件目')).toBeInTheDocument ()
+    expect (screen.queryByText ('二件目')).not.toBeInTheDocument ()
+    fireEvent.click (screen.getByRole ('button', { name: '確定' }))
+    expect (await screen.findByText ('二件目')).toBeInTheDocument ()
+  })
+
+  it ('keeps a large form open when an action returns false', async () => {
+    const action = vi.fn ().mockResolvedValue (false)
+    const Launcher = () => {
+      const dialogue = useDialogue ()
+      return (
+	  <button
+	      onClick={() => void dialogue.form ({
+		title: '投稿を編輯',
+		description: '説明',
+		size: 'large',
+		body: controls => <FormBody controls={controls} onSelect={action}/> })}>
+	    開く
+	  </button>)
+    }
+
+    render (<DialogueProvider><Launcher/></DialogueProvider>)
+    fireEvent.click (screen.getByRole ('button', { name: '開く' }))
+
+    const dialogue = screen.getByRole ('dialog')
+    expect (dialogue).toHaveClass ('max-h-[calc(100dvh-1rem)]', 'flex-col', 'max-w-3xl')
+    await waitFor (() => expect (screen.getByRole ('button', { name: '左操作' }))
+	.toBeInTheDocument ())
+    expect (screen.getByRole ('button', { name: '左操作' })).toHaveClass ('w-full', 'sm:w-auto')
+    fireEvent.click (screen.getByRole ('button', { name: '左操作' }))
+
+    await waitFor (() => expect (action).toHaveBeenCalledTimes (1))
+    expect (screen.getByText ('投稿を編輯')).toBeInTheDocument ()
+  })
+
+  it ('opens a nested confirmation over a form and returns to the same form', async () => {
+    const Launcher = () => {
+      const dialogue = useDialogue ()
+      return (
+	  <button
+	      onClick={() => void dialogue.form ({
+		title: '投稿を編輯',
+		body: controls => <NestedConfirmFormBody controls={controls}/> })}>
+	    開く
+	  </button>)
+    }
+
+    render (<DialogueProvider><Launcher/></DialogueProvider>)
+    fireEvent.click (screen.getByRole ('button', { name: '開く' }))
+    const action = await screen.findByRole ('button', { name: '左操作' })
+    fireEvent.click (action)
+
+    expect (await screen.findByText ('変更をリセットしますか?')).toBeInTheDocument ()
+    fireEvent.click (screen.getByRole ('button', { name: 'リセット' }))
+    await waitFor (() => {
+      expect (screen.queryByText ('変更をリセットしますか?')).not.toBeInTheDocument ()
+    })
+    expect (screen.getByText ('投稿を編輯')).toBeInTheDocument ()
+  })
+})

frontend/src/components/dialogues/DialogueProvider.tsx

@@ -1,4 +1,4 @@
-import { createContext, useCallback, useContext, useMemo, useState } from 'react'
+import { useCallback, useMemo, useRef, useState } from 'react'
 
 import { Button } from '@/components/ui/button'
 import { Dialog,
@@ -7,29 +7,16 @@ import { Dialog,
 	 DialogFooter,
 	 DialogHeader,
 	 DialogTitle } from '@/components/ui/dialog'
+import { DialogueContext } from '@/lib/dialogues/useDialogue'
 
 import type { FC, ReactNode } from 'react'
-
+import type { AlertOptions,
-type DialogueVariant = 'default' | 'danger'
+	      ChoiceOptions,
-
+	      ConfirmOptions,
-type ConfirmOptions = { title:        string
+	      DialogueAPI,
-			description?: ReactNode
+	      DialogueFormAction,
-			confirmText?: string
+	      DialogueFormControls,
-			cancelText?:  string
+	      DialogueFormOptions } from '@/lib/dialogues/useDialogue'
-			variant?:     DialogueVariant }
-
-type AlertOptions = { title:        string
-		      description?: ReactNode
-		      okText?:      string }
-
-type Choice<T extends string> = { value:    T
-				  label:    string
-				  variant?: DialogueVariant }
-
-type ChoiceOptions<T extends string> = { title:         string
-					 description?:  ReactNode
-					 choices:       Choice<T>[]
-					 cancelText?:   string }
 
 type DialogueRequest =
     | { id:       number
@@ -44,13 +31,10 @@ type DialogueRequest =
 	kind:     'choice'
 	options:  ChoiceOptions<string>
 	resolve:  (value: string | null) => void }
-
+    | { id:       number
-type DialogueAPI =
+	kind:     'form'
-    { confirm:  (options: ConfirmOptions) => Promise<boolean>
+	options:  DialogueFormOptions
-      alert:    (options: AlertOptions) => Promise<void>
+	resolve:  () => void }
-      choice:   <T extends string> (options: ChoiceOptions<T>) => Promise<T | null> }
-
-const DialogueContext = createContext<DialogueAPI | null> (null)
 
 let nextDialogueId = 1
 
@@ -59,20 +43,27 @@ type Props = { children: ReactNode }
 
 const DialogueProvider: FC<Props> = ({ children }) => {
   const [queue, setQueue] = useState<DialogueRequest[]> ([])
+  const [pendingIds, setPendingIds] = useState<number[]> ([])
+  const [formActions, setFormActions] = useState<Record<number, DialogueFormAction[]>> ({ })
+  const formControls = useRef<Record<number, DialogueFormControls>> ({ })
+  const [nestedConfirm, setNestedConfirm] = useState<{
+      parentId: number
+      options:  ConfirmOptions
+      resolve:  (value: boolean) => void } | null> (null)
 
   const push = useCallback ((request: Omit<DialogueRequest, 'id'>) => {
     const id = nextDialogueId
     ++nextDialogueId
 
-    setQueue (q => [...q, { ...request, id } as DialogueRequest])
+    setQueue (current => [...current, { ...request, id } as DialogueRequest])
   }, [])
 
-  const closeActive = useCallback ((result?: unknown) => {
+  const closeRequest = useCallback ((id: number, result?: unknown) => {
-    setQueue (q => {
+    setQueue (current => {
-      const [active, ...rest] = q
+      const active = current.find (request => request.id === id)
 
-      if (!(active))
+      if (active == null)
-	return rest
+	return current
 
       switch (active.kind)
       {
@@ -87,9 +78,42 @@ const DialogueProvider: FC<Props> = ({ children }) => {
       case 'choice':
 	active.resolve ((result ?? null) as string | null)
 	break
+
+      case 'form':
+	active.resolve ()
+	break
       }
 
-      return rest
+      return current.filter (request => request.id !== id)
+    })
+    setPendingIds (current => current.filter (_1 => _1 !== id))
+    setFormActions (current => {
+	const { [id]: _, ...rest } = current
+	return rest
+    })
+    delete formControls.current[id]
+  }, [])
+
+  const setRequestActions = useCallback (
+      (id: number, actions: DialogueFormAction[]) => {
+	setFormActions (current => ({ ...current, [id]: actions }))
+      },
+      [])
+
+  const openNestedConfirm = useCallback (
+      (parentId: number, options: ConfirmOptions) =>
+	  new Promise<boolean> (resolve => {
+	    setNestedConfirm ({ parentId, options, resolve })
+	  }),
+      [])
+
+  const closeNestedConfirm = useCallback ((result: boolean) => {
+    setNestedConfirm (current => {
+      if (current == null)
+	return current
+
+      current.resolve (result)
+      return null
     })
   }, [])
 
@@ -103,86 +127,229 @@ const DialogueProvider: FC<Props> = ({ children }) => {
       choice: options => new Promise (resolve => {
 	push ({ kind: 'choice',
 		options: options as ChoiceOptions<string>,
-		resolve: resolve as (value: string | null) => void })}) }), [push])
+		resolve: resolve as (value: string | null) => void })
+      }),
+      form: options => new Promise<void> (resolve => {
+	push ({ kind: 'form', options, resolve })
+      }) }), [push])
+
+  const handleFormAction = useCallback (
+      async (id: number, action: DialogueFormAction) => {
+	if (pendingIds.includes (id))
+	  return
+
+	setPendingIds (current => [...current, id])
+	try
+	  {
+	    const shouldClose = await action.onSelect ()
+	    if (shouldClose !== false)
+	      closeRequest (id)
+	  }
+	finally
+	  {
+	    setPendingIds (current => current.filter (_1 => _1 !== id))
+	  }
+      },
+      [closeRequest, pendingIds])
 
   const active = queue[0]
+  const startActions =
+      active?.kind === 'form'
+      ? (formActions[active.id] ?? []).filter (action => action.placement === 'start')
+      : []
+  const endActions =
+      active?.kind === 'form'
+      ? (formActions[active.id] ?? []).filter (action =>
+	  action.placement == null || action.placement === 'end')
+      : []
 
   return (
       <DialogueContext.Provider value={api}>
 	{children}
 
-	<Dialog
+	{active && (
-	    open={Boolean (active)}
+	    <Dialog
-	    onOpenChange={open => {
+		open
-	      if (!(open))
+		onOpenChange={open => {
-		closeActive (active?.kind !== 'confirm' && null)
+		  const blocked =
-	    }}>
+		      nestedConfirm?.parentId === active.id
-	  {active && (
+		      || pendingIds.includes (active.id)
+		  if (!(open) && !(blocked))
+		    closeRequest (active.id, active.kind !== 'confirm' && null)
+		}}>
+	      <DialogContent
+		  className={
+		      active.kind === 'form'
+		      ? `flex max-h-[calc(100dvh-1rem)] ${ active.options.size === 'large'
+			  ? 'max-w-3xl'
+			  : 'max-w-lg' } flex-col overflow-hidden gap-0`
+		      : 'px-6 pb-6 pt-7'
+		  }
+		  onEscapeKeyDown={event => {
+		    if (nestedConfirm?.parentId === active.id || pendingIds.includes (active.id))
+		      event.preventDefault ()
+		  }}
+		  onPointerDownOutside={event => {
+		    if (nestedConfirm?.parentId === active.id || pendingIds.includes (active.id))
+		      event.preventDefault ()
+		  }}>
+		{active.kind === 'form'
+		 ? (
+		     <>
+		       <DialogHeader className="shrink-0 pb-4 pl-8 pr-0 pt-1 text-left">
+			 <DialogTitle>{active.options.title}</DialogTitle>
+
+			 {active.options.description && (
+			     <DialogDescription asChild>
+			       <div>{active.options.description}</div>
+			     </DialogDescription>)}
+		       </DialogHeader>
+
+		       <div className="min-h-0 flex-1 overflow-y-auto overscroll-contain">
+			 {active.options.body (
+			     formControls.current[active.id] ??= {
+				 close: () => closeRequest (active.id),
+				 setActions: actions => setRequestActions (active.id, actions),
+				 confirm: options => openNestedConfirm (active.id, options) })}
+		       </div>
+
+		       <DialogFooter
+			   className="shrink-0 flex-col gap-2 pt-4
+				      sm:flex-row sm:justify-between sm:gap-0 sm:space-x-0">
+			 <div className="flex w-full flex-col gap-2 sm:w-auto sm:flex-row">
+			   {startActions.map (action => (
+			       <Button
+				   key={action.label}
+				   className="w-full sm:w-auto"
+				   variant={action.variant === 'danger'
+				       ? 'destructive'
+				       : 'default'}
+				   onClick={() => void handleFormAction (active.id, action)}
+				   disabled={pendingIds.includes (active.id)
+				       || nestedConfirm?.parentId === active.id
+				       || action.disabled}>
+				 {action.label}
+			       </Button>))}
+			 </div>
+
+			 <div className="flex w-full flex-col gap-2 sm:w-auto sm:flex-row">
+			   <Button
+			       className="w-full sm:w-auto"
+			       variant="outline"
+			       onClick={() => closeRequest (active.id)}
+			       disabled={pendingIds.includes (active.id)
+				   || nestedConfirm?.parentId === active.id}>
+			     {active.options.cancelText ?? '取消'}
+			   </Button>
+
+			   {endActions.map (action => (
+			       <Button
+				   key={action.label}
+				   className="w-full sm:w-auto"
+				   variant={action.variant === 'danger'
+				       ? 'destructive'
+				       : 'default'}
+				   onClick={() => void handleFormAction (active.id, action)}
+				   disabled={pendingIds.includes (active.id)
+				       || nestedConfirm?.parentId === active.id
+				       || action.disabled}>
+				 {action.label}
+			       </Button>))}
+			 </div>
+		       </DialogFooter>
+		     </>)
+		 : (
+		     <>
+		       <DialogHeader className="pl-8">
+			 <DialogTitle>{active.options.title}</DialogTitle>
+
+			 {active.options.description && (
+			     <DialogDescription asChild>
+			       <div>{active.options.description}</div>
+			     </DialogDescription>)}
+		       </DialogHeader>
+
+		       <DialogFooter>
+			 {active.kind === 'confirm' && (
+			     <>
+			       <Button
+				   variant="outline"
+				   onClick={() => closeRequest (active.id, false)}>
+				 {active.options.cancelText ?? '取消'}
+			       </Button>
+
+			       <Button
+				   variant={(active.options.variant === 'danger')
+					    ? 'destructive'
+					    : 'default'}
+				   onClick={() => closeRequest (active.id, true)}>
+				 {active.options.confirmText ?? '確定'}
+			       </Button>
+			     </>)}
+
+			 {active.kind === 'alert' && (
+			     <Button onClick={() => closeRequest (active.id)}>
+			       {active.options.okText ?? '確定'}
+			     </Button>)}
+
+			 {active.kind === 'choice' && (
+			     <>
+			       <Button
+				   variant="outline"
+				   onClick={() => closeRequest (active.id, null)}>
+				 {active.options.cancelText ?? '取消'}
+			       </Button>
+
+			       {active.options.choices.map (choice => (
+				   <Button
+				       key={choice.value}
+				       variant={(choice.variant === 'danger')
+						? 'destructive'
+						: 'default'}
+				       onClick={() => closeRequest (active.id, choice.value)}>
+				     {choice.label}
+				   </Button>))}
+			     </>)}
+		       </DialogFooter>
+		     </>)}
+	      </DialogContent>
+	    </Dialog>)}
+
+	{nestedConfirm && (
+	    <Dialog
+		open
+		onOpenChange={open => {
+		  if (!(open))
+		    closeNestedConfirm (false)
+		}}>
 	      <DialogContent className="px-6 pb-6 pt-7">
 		<DialogHeader className="pl-8">
-		  <DialogTitle>{active.options.title}</DialogTitle>
+		  <DialogTitle>{nestedConfirm.options.title}</DialogTitle>
 
-		  {active.options.description && (
+		  {nestedConfirm.options.description && (
 		      <DialogDescription asChild>
-			<div>{active.options.description}</div>
+			<div>{nestedConfirm.options.description}</div>
 		      </DialogDescription>)}
 		</DialogHeader>
 
 		<DialogFooter>
-		  {active.kind === 'confirm' && (
+		  <Button
-		      <>
+		      variant="outline"
-			<Button
+		      onClick={() => closeNestedConfirm (false)}>
-			    variant="outline"
+		    {nestedConfirm.options.cancelText ?? '取消'}
-			    onClick={() => closeActive (false)}>
+		  </Button>
-			  {active.options.cancelText ?? '取消'}
-			</Button>
 
-			<Button
+		  <Button
-			    variant={(active.options.variant === 'danger')
+		      variant={nestedConfirm.options.variant === 'danger'
-				     ? 'destructive'
+			  ? 'destructive'
-				     : 'default'}
+			  : 'default'}
-			    onClick={() => closeActive (true)}>
+		      onClick={() => closeNestedConfirm (true)}>
-			  {active.options.confirmText ?? '確定'}
+		    {nestedConfirm.options.confirmText ?? '確定'}
-			</Button>
+		  </Button>
-		      </>)}
-
-		  {active.kind === 'alert' && (
-		      <Button onClick={() => closeActive ()}>
-			{active.options.okText ?? '確定'}
-		      </Button>)}
-
-		  {active.kind === 'choice' && (
-		      <>
-			<Button
-			    variant="outline"
-			    onClick={() => closeActive (null)}>
-			  {active.options.cancelText ?? '取消'}
-			</Button>
-
-			{active.options.choices.map (choice => (
-			    <Button
-				key={choice.value}
-				variant={(choice.variant === 'danger')
-					 ? 'destructive'
-					 : 'default'}
-				onClick={() => closeActive (choice.value)}>
-			      {choice.label}
-			    </Button>))}
-		      </>)}
 		</DialogFooter>
-	      </DialogContent>)}
+	      </DialogContent>
-	</Dialog>
+	    </Dialog>)}
       </DialogueContext.Provider>)
 }
-
+export { useDialogue } from '@/lib/dialogues/useDialogue'
-
-export const useDialogue = () => {
-  const dialogue = useContext (DialogueContext)
-
-  if (!(dialogue))
-    throw new Error ('useDialogue must be used inside DialogueProvider')
-
-  return dialogue
-}
-
 export default DialogueProvider

frontend/src/components/posts/import/PostImportRowForm.test.tsx

@@ -0,0 +1,91 @@
+import { act, render, screen, waitFor } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+import PostImportRowForm from '@/components/posts/import/PostImportRowForm'
+import { buildPostImportRow } from '@/test/postImportFactories'
+
+import type { DialogueFormAction, DialogueFormControls } from '@/lib/dialogues/useDialogue'
+
+describe ('PostImportRowForm', () => {
+  it ('resets only the draft, then saves with resetRequested', async () => {
+    const row = buildPostImportRow ()
+    row.attributes.title = 'manual title'
+    row.provenance.title = 'manual'
+    const actions: DialogueFormAction[][] = []
+    const controls: DialogueFormControls = {
+      close: vi.fn (),
+      confirm: vi.fn ().mockResolvedValue (true),
+      setActions: next => actions.push (next) }
+    const invalidRow = buildPostImportRow ({
+      validationErrors: { title: ['タイトルを確認してください．'] } })
+    const onSave = vi.fn ().mockResolvedValue ({ saved: false, row: invalidRow })
+
+    render (<PostImportRowForm row={row} controls={controls} onSave={onSave}/>)
+    const titleInput = screen.getByDisplayValue ('manual title')
+
+    await waitFor (() => expect (actions.at (-1)?.length).toBe (2))
+    const reset = actions.at (-1)?.find (_1 => _1.label === '変更をリセット')
+    expect (reset).toMatchObject ({ placement: 'start', variant: 'danger', disabled: false })
+    await act (async () => {
+      await reset?.onSelect ()
+    })
+
+    expect (controls.confirm).toHaveBeenCalled ()
+    expect (titleInput).toHaveValue ('')
+    expect (onSave).not.toHaveBeenCalled ()
+
+    const save = actions.at (-1)?.find (_1 => _1.label === '編輯内容を保存')
+    await act (async () => {
+      await save?.onSelect ()
+    })
+
+    expect (onSave).toHaveBeenCalledWith ({
+      draft: expect.objectContaining ({ title: '' }),
+      resetRequested: true })
+    expect (screen.getByText ('タイトルを確認してください．')).toBeInTheDocument ()
+  })
+
+  it ('does not reset the draft when confirmation is cancelled', async () => {
+    const row = buildPostImportRow ({ attributes: { title: 'manual title' } })
+    let actions: DialogueFormAction[] = []
+    const controls: DialogueFormControls = {
+      close: vi.fn (),
+      confirm: vi.fn ().mockResolvedValue (false),
+      setActions: next => {
+	actions = next
+      } }
+
+    render (
+	<PostImportRowForm
+	    row={row}
+	    controls={controls}
+	    onSave={vi.fn ()}/>)
+    await waitFor (() => expect (actions.length).toBe (2))
+
+    await act (async () => {
+      await actions.find (_1 => _1.label === '変更をリセット')?.onSelect ()
+    })
+
+    expect (screen.getByDisplayValue ('manual title')).toBeInTheDocument ()
+  })
+
+  it ('marks edited fields and areas invalid from field errors', () => {
+    const row = buildPostImportRow ({
+      validationErrors: { url: ['URL error'], tags: ['tag error'] },
+      importErrors: { duration: ['duration error'] },
+      fieldWarnings: { title: ['title warning'] } })
+
+    render (
+	<PostImportRowForm
+	    row={row}
+	    controls={{ close: vi.fn (), confirm: vi.fn (), setActions: vi.fn () }}
+	    onSave={vi.fn ()}/>)
+
+    expect (screen.getByText ('URL error')).toBeInTheDocument ()
+    expect (screen.getByText ('tag error')).toBeInTheDocument ()
+    expect (screen.getByText ('duration error')).toBeInTheDocument ()
+    expect (screen.getByText ('title warning')).toBeInTheDocument ()
+    expect (screen.getAllByRole ('textbox').filter (
+	_1 => _1.getAttribute ('aria-invalid') === 'true')).toHaveLength (3)
+  })
+})

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

@@ -0,0 +1,277 @@
+import { useCallback, useEffect, useMemo, useState } from 'react'
+
+import PostOriginalCreatedTimeField from '@/components/PostOriginalCreatedTimeField'
+import FieldError from '@/components/common/FieldError'
+import FieldWarning from '@/components/common/FieldWarning'
+import FormField from '@/components/common/FormField'
+import TextArea from '@/components/common/TextArea'
+import ThumbnailPreview from '@/components/posts/import/ThumbnailPreview'
+import { inputClass } from '@/lib/utils'
+
+import type { FC } from 'react'
+
+import type { PostImportRow } from '@/lib/postImportSession'
+import type { DialogueFormControls } from '@/lib/dialogues/useDialogue'
+
+type Draft = {
+  url:                   string
+  title:                 string
+  thumbnailBase:         string
+  originalCreatedFrom:   string
+  originalCreatedBefore: string
+  duration:              string
+  tags:                  string
+  parentPostIds:         string }
+
+type Props = {
+  row:          PostImportRow
+  controls:     DialogueFormControls
+  onSave:       (args: { draft:          Draft
+			 resetRequested: boolean }) => Promise<{
+			     saved: boolean
+			     row:   PostImportRow | null }> }
+
+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 buildResetDraft = (row: PostImportRow): Draft => ({
+    url: row.resetSnapshot.url,
+    title: String (row.resetSnapshot.attributes.title ?? ''),
+    thumbnailBase: String (row.resetSnapshot.attributes.thumbnailBase ?? ''),
+    originalCreatedFrom: String (row.resetSnapshot.attributes.originalCreatedFrom ?? ''),
+    originalCreatedBefore: String (row.resetSnapshot.attributes.originalCreatedBefore ?? ''),
+    duration: String (row.resetSnapshot.attributes.duration ?? ''),
+    tags: String (row.resetSnapshot.attributes.tags ?? ''),
+    parentPostIds: String (row.resetSnapshot.attributes.parentPostIds ?? '') })
+
+const groupedMessages = (...values: (string[] | undefined)[]): string[] =>
+    values.flatMap (value => value ?? [])
+
+const sameDraft = (left:  Draft, right: Draft): boolean =>
+    left.url === right.url
+    && left.title === right.title
+    && left.thumbnailBase === right.thumbnailBase
+    && left.originalCreatedFrom === right.originalCreatedFrom
+    && left.originalCreatedBefore === right.originalCreatedBefore
+    && left.duration === right.duration
+    && left.tags === right.tags
+    && left.parentPostIds === right.parentPostIds
+
+
+const PostImportRowForm: FC<Props> = (
+    { row,
+      controls,
+      onSave },
+) => {
+  const [draft, setDraft] = useState<Draft> (() => buildDraft (row))
+  const [messageRow, setMessageRow] = useState<PostImportRow | null> (null)
+  const [saving, setSaving] = useState (false)
+  const [resetRequested, setResetRequested] = useState (false)
+
+  useEffect (() => {
+    const nextDraft = buildDraft (row)
+    setDraft (nextDraft)
+    setMessageRow (null)
+    setResetRequested (false)
+  }, [row])
+
+  const displayRow = messageRow ?? row
+  const resetDraft = useMemo (
+      () => buildResetDraft (row),
+      [row])
+  const resetDisabled = saving || sameDraft (draft, resetDraft)
+
+  const update = <Key extends keyof Draft,> (
+      key:   Key,
+      value: Draft[Key],
+  ) => {
+    if (messageRow != null)
+      setMessageRow (null)
+    setDraft (current => ({ ...current, [key]: value }))
+  }
+
+  const reset = useCallback (async (): Promise<boolean> => {
+    if (resetDisabled)
+      return false
+
+    const confirmed = await controls.confirm ({
+	title: '変更をリセットしますか?',
+	description: '現在の URL に対する自動取得直後の内容へ戻します．',
+	confirmText: 'リセット',
+	cancelText: '取消',
+	variant: 'danger' })
+    if (!(confirmed))
+      return false
+
+    setDraft (resetDraft)
+    setResetRequested (true)
+    setMessageRow (null)
+    return false
+  }, [controls, resetDisabled, resetDraft])
+
+  const save = useCallback (async (): Promise<boolean> => {
+    setSaving (true)
+    try
+      {
+	const result = await onSave ({ draft, resetRequested })
+	if (result.saved)
+	  return true
+
+	if (result.row != null)
+	  setMessageRow (result.row)
+	return false
+      }
+    finally
+      {
+	setSaving (false)
+      }
+  }, [draft, onSave, resetRequested])
+
+  useEffect (() => {
+    controls.setActions ([{
+	label: '変更をリセット',
+	placement: 'start',
+	variant: 'danger',
+	disabled: resetDisabled,
+	onSelect: reset },
+	{
+	  label: '編輯内容を保存',
+	  disabled: saving,
+	  onSelect: save }])
+  }, [controls, resetDisabled, reset, save, saving])
+
+  return (
+      <>
+	<div className="px-6 pb-6">
+	  <div className="space-y-4">
+	    <div className="grid gap-6 md:grid-cols-[7rem_minmax(0,1fr)]">
+	      <div className="space-y-3 md:sticky md:top-0 md:self-start">
+		<ThumbnailPreview
+		    url={draft.thumbnailBase}
+		    className="h-28 w-28"/>
+	      </div>
+
+	      <div className="space-y-4">
+		<PostImportTextField
+		    label="URL"
+		    value={draft.url}
+		    warnings={displayRow.fieldWarnings.url}
+		    errors={groupedMessages (
+			displayRow.validationErrors.url,
+			displayRow.importErrors?.url)}
+		    onChange={value => update ('url', value)}/>
+		<PostImportTextField
+		    label="タイトル"
+		    value={draft.title}
+		    warnings={displayRow.fieldWarnings.title}
+		    errors={groupedMessages (
+			displayRow.validationErrors.title,
+			displayRow.importErrors?.title)}
+		    onChange={value => update ('title', value)}/>
+		<PostImportTextField
+		    label="サムネール基底 URL"
+		    value={draft.thumbnailBase}
+		    warnings={displayRow.fieldWarnings.thumbnailBase}
+		    errors={groupedMessages (
+			displayRow.validationErrors.thumbnailBase,
+			displayRow.importErrors?.thumbnailBase)}
+		    onChange={value => update ('thumbnailBase', value)}/>
+		<PostOriginalCreatedTimeField
+		    originalCreatedFrom={draft.originalCreatedFrom || null}
+		    setOriginalCreatedFrom={value => update ('originalCreatedFrom', value ?? '')}
+		    originalCreatedBefore={draft.originalCreatedBefore || null}
+		    setOriginalCreatedBefore={value => update ('originalCreatedBefore', value ?? '')}
+		    errors={groupedMessages (
+			displayRow.validationErrors.originalCreatedAt,
+			displayRow.validationErrors.originalCreatedFrom,
+			displayRow.validationErrors.originalCreatedBefore,
+			displayRow.importErrors?.originalCreatedAt,
+			displayRow.importErrors?.originalCreatedFrom,
+			displayRow.importErrors?.originalCreatedBefore)}/>
+		<PostImportTextField
+		    label="動画時間"
+		    value={draft.duration}
+		    errors={groupedMessages (
+			displayRow.validationErrors.duration,
+			displayRow.validationErrors.videoMs,
+			displayRow.importErrors?.duration,
+			displayRow.importErrors?.videoMs)}
+		    onChange={value => update ('duration', value)}/>
+		<PostImportAreaField
+		    label="タグ"
+		    value={draft.tags}
+		    warnings={displayRow.fieldWarnings.tags}
+		    errors={groupedMessages (
+			displayRow.validationErrors.tags,
+			displayRow.importErrors?.tags)}
+		    onChange={value => update ('tags', value)}/>
+		<PostImportTextField
+		    label="親投稿"
+		    value={draft.parentPostIds}
+		    errors={groupedMessages (
+			displayRow.validationErrors.parentPostIds,
+			displayRow.importErrors?.parentPostIds)}
+		    onChange={value => update ('parentPostIds', value)}/>
+		<FieldWarning messages={displayRow.baseWarnings}/>
+		<FieldError messages={displayRow.validationErrors.base}/>
+		<FieldError messages={displayRow.importErrors?.base}/>
+	      </div>
+	    </div>
+	  </div>
+	</div>
+      </>)
+}
+
+const PostImportTextField = (
+    { label, value, warnings, errors, onChange }: {
+	label:    string
+	value:    string
+	warnings?: string[]
+	errors?:  string[]
+	onChange: (value: string) => void },
+) => (
+    <FormField label={label} messages={errors}>
+      {({ describedBy, invalid }) => (
+	  <>
+	    <input
+		value={value}
+		onChange={ev => onChange (ev.target.value)}
+		aria-describedby={describedBy}
+		aria-invalid={invalid}
+		className={inputClass (invalid)}/>
+	    <FieldWarning messages={warnings}/>
+	  </>)}
+    </FormField>)
+
+const PostImportAreaField = (
+    { label, value, warnings, errors, onChange }: {
+	label:    string
+	value:    string
+	warnings?: string[]
+	errors?:  string[]
+	onChange: (value: string) => void },
+) => (
+    <FormField label={label} messages={errors}>
+      {({ describedBy, invalid }) => (
+	  <>
+	    <TextArea
+		value={value}
+		rows={4}
+		onChange={ev => onChange (ev.target.value)}
+		aria-describedby={describedBy}
+		invalid={invalid}
+		className="h-auto"/>
+	    <FieldWarning messages={warnings}/>
+	  </>)}
+    </FormField>)
+
+export default PostImportRowForm
+export { buildDraft }
+export type { Draft as PostImportRowDraft }

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

@@ -0,0 +1,112 @@
+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 { displayPostImportStatus } from '@/components/posts/import/postImportRowStatus'
+
+import type { FC } from 'react'
+
+import type { PostImportRow } from '@/lib/postImportSession'
+
+type Props = {
+    row:     PostImportRow
+    onEdit:  () => void }
+
+const summaryWarning = (row: PostImportRow): string | null =>
+    Object.values (row.fieldWarnings ?? { }).flat ()[0]
+    ?? row.baseWarnings?.[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 warning = summaryWarning (row)
+    const displayStatus = displayPostImportStatus (row)
+
+    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]',
+		  'transition-shadow hover:shadow-sm')}>
+	    <div className="space-y-1">
+	      <div className="text-sm font-medium">#{row.sourceRow}</div>
+	    </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>
+	      {warning && (
+		  <div className="text-xs text-amber-700 dark:text-amber-200">
+		    {warning}
+		  </div>)}
+	    </div>
+	    <div className="space-y-1">
+	      {displayStatus != null && <PostImportStatusBadge value={displayStatus}/>}
+	    </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',
+		  'transition-shadow hover:shadow-sm')}>
+	    <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">
+		  {displayStatus != null && <PostImportStatusBadge value={displayStatus}/>}
+		</div>
+		{warning && (
+		    <div className="text-xs text-amber-700 dark:text-amber-200">
+		      {warning}
+		    </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,27 @@
+import StatusBadge from '@/components/common/StatusBadge'
+
+import type { FC } from 'react'
+
+import type { StatusBadgeTone } from '@/components/common/StatusBadge'
+import type { PostImportBadgeValue } from '@/components/posts/import/postImportRowStatus'
+
+type Props = {
+    value: PostImportBadgeValue }
+
+const LABELS: Record<PostImportBadgeValue, string> = {
+    ready: '登録可能',
+    warning: '警告',
+    skipped: 'スキップ' }
+
+const TONES: Record<PostImportBadgeValue, StatusBadgeTone> = {
+    ready: 'success',
+    warning: 'warning',
+    skipped: 'neutral' }
+
+
+const PostImportStatusBadge: FC<Props> = ({ value }) => (
+    <StatusBadge tone={TONES[value]}>
+      {LABELS[value]}
+    </StatusBadge>)
+
+export default PostImportStatusBadge

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

@@ -0,0 +1,49 @@
+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-amber-300 bg-amber-50 p-2 text-center text-xs
+			    text-amber-700 dark:border-amber-900 dark:bg-amber-950
+			    dark:text-amber-200`}>
+	      サムネールを表示できません
+	    </div>)
+      }
+
+    return (
+	<img
+	    src={url}
+	    alt={alt}
+	    className={`${ className } rounded border border-border object-cover`}
+	    onError={() => setFailed (true)}/>)
+}
+
+export default ThumbnailPreview

frontend/src/components/posts/import/postImportRowStatus.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+
+import { displayPostImportStatus } from '@/components/posts/import/postImportRowStatus'
+import { buildPostImportRow } from '@/test/postImportFactories'
+
+describe ('displayPostImportStatus', () => {
+  it ('shows only ready, warning, and skipped states', () => {
+    expect (displayPostImportStatus (buildPostImportRow ())).toBe ('ready')
+    expect (displayPostImportStatus (buildPostImportRow ({
+      status: 'warning',
+      fieldWarnings: { title: ['warning'] } }))).toBe ('warning')
+    expect (displayPostImportStatus (buildPostImportRow ({
+      skipReason: 'existing',
+      existingPostId: 2 }))).toBe ('skipped')
+  })
+
+  it ('does not expose validation, failure, or created states as badges', () => {
+    expect (displayPostImportStatus (buildPostImportRow ({
+      status: 'error',
+      validationErrors: { title: ['invalid'] } }))).toBeNull ()
+    expect (displayPostImportStatus (buildPostImportRow ({
+      importStatus: 'failed' }))).toBeNull ()
+    expect (displayPostImportStatus (buildPostImportRow ({
+      importStatus: 'created',
+      createdPostId: 3 }))).toBeNull ()
+  })
+})

frontend/src/components/posts/import/postImportRowStatus.ts

@@ -0,0 +1,22 @@
+import type { PostImportRow } from '@/lib/postImportSession'
+
+export type PostImportDisplayStatus = 'ready' | 'skipped' | 'warning'
+
+export type PostImportBadgeValue = PostImportDisplayStatus
+
+const hasWarnings = (row: PostImportRow): boolean =>
+    Object.values (row.fieldWarnings ?? { }).some (_1 => _1.length > 0)
+    || row.baseWarnings.length > 0
+
+export const displayPostImportStatus = (
+    row: PostImportRow,
+): PostImportDisplayStatus | null =>
+    (row.skipReason === 'existing' || row.importStatus === 'skipped')
+    ? 'skipped'
+    : ((Object.keys (row.validationErrors ?? { }).length > 0
+	|| row.importStatus === 'failed'
+	|| row.importStatus === 'created')
+       ? null
+       : ((hasWarnings (row) || row.status === 'warning')
+	  ? 'warning'
+	  : 'ready'))

frontend/src/lib/dialogues/useDialogue.ts

@@ -0,0 +1,72 @@
+import { createContext, useContext } from 'react'
+
+import type { ReactNode } from 'react'
+
+type DialogueVariant = 'default' | 'danger'
+
+type ConfirmOptions = { title:        string
+			description?: ReactNode
+			confirmText?: string
+			cancelText?:  string
+			variant?:     DialogueVariant }
+
+type AlertOptions = { title:        string
+		      description?: ReactNode
+		      okText?:      string }
+
+type Choice<T extends string> = { value:    T
+				  label:    string
+				  variant?: DialogueVariant }
+
+type ChoiceOptions<T extends string> = { title:         string
+					 description?:  ReactNode
+					 choices:       Choice<T>[]
+					 cancelText?:   string }
+
+type DialogueFormAction = {
+  label:      string
+  placement?: 'start' | 'end'
+  variant?:   DialogueVariant
+  disabled?:  boolean
+  onSelect:   () => Promise<boolean | void> | boolean | void }
+
+type DialogueFormControls = {
+  close:      () => void
+  setActions: (actions: DialogueFormAction[]) => void
+  confirm:    (options: ConfirmOptions) => Promise<boolean> }
+
+type DialogueFormOptions = { title:         string
+			     description?:  ReactNode
+			     body:          (controls: DialogueFormControls) => ReactNode
+			     cancelText?:   string
+			     size?:         'default' | 'large' }
+
+type DialogueAPI =
+    { confirm:  (options: ConfirmOptions) => Promise<boolean>
+      alert:    (options: AlertOptions) => Promise<void>
+      choice:   <T extends string> (options: ChoiceOptions<T>) => Promise<T | null>
+      form:     (options: DialogueFormOptions) => Promise<void> }
+
+const DialogueContext = createContext<DialogueAPI | null> (null)
+
+const useDialogue = () => {
+  const dialogue = useContext (DialogueContext)
+
+  if (dialogue == null)
+    throw new Error ('useDialogue must be used inside DialogueProvider')
+
+  return dialogue
+}
+
+export { DialogueContext, useDialogue }
+export default useDialogue
+export type {
+    AlertOptions,
+    Choice,
+    ChoiceOptions,
+    ConfirmOptions,
+    DialogueAPI,
+    DialogueFormAction,
+    DialogueFormControls,
+    DialogueFormOptions,
+    DialogueVariant }

frontend/src/lib/postImportRows.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest'
+
+import { creatableImportRows,
+	 initialisePreviewRows,
+	 mergeImportResults,
+	 mergeValidatedImportRows,
+	 processableImportRows,
+	 resultSummaryCounts,
+	 retryImportRow,
+	 reviewSummaryCounts } from '@/lib/postImportSession'
+import { buildPostImportRow } from '@/test/postImportFactories'
+
+describe ('post import row state', () => {
+  it ('separates processable existing rows from creatable rows', () => {
+    const ready = buildPostImportRow ({ sourceRow: 1 })
+    const existing = buildPostImportRow ({
+      sourceRow: 2,
+      skipReason: 'existing',
+      existingPostId: 20 })
+    const invalid = buildPostImportRow ({
+      sourceRow: 3,
+      status: 'error',
+      validationErrors: { url: ['invalid'] } })
+    const created = buildPostImportRow ({
+      sourceRow: 4,
+      importStatus: 'created',
+      createdPostId: 40 })
+    const rows = [ready, existing, invalid, created]
+
+    expect (processableImportRows (rows)).toEqual ([ready, existing])
+    expect (creatableImportRows (rows)).toEqual ([ready])
+    expect (reviewSummaryCounts (rows)).toEqual ({
+      total: 4,
+      submittable: 1,
+      skipPlanned: 1 })
+  })
+
+  it ('preserves terminal rows while merging validation results', () => {
+    const created = buildPostImportRow ({
+      sourceRow: 1,
+      importStatus: 'created',
+      createdPostId: 10,
+      attributes: { title: 'created title' } })
+    const pending = buildPostImportRow ({
+      sourceRow: 2,
+      fieldWarnings: { title: ['old warning'] },
+      provenance: { title: 'manual' },
+      attributes: { title: 'manual title' } })
+    const validated = [
+      buildPostImportRow ({ sourceRow: 1, attributes: { title: 'changed' } }),
+      buildPostImportRow ({
+	sourceRow: 2,
+	fieldWarnings: { title: ['fetch warning'], tags: ['tag warning'] },
+	provenance: { title: 'manual' },
+	attributes: { title: 'manual title' } })]
+
+    const result = mergeValidatedImportRows ([created, pending], validated)
+
+    expect (result[0]).toBe (created)
+    expect (result[1]?.fieldWarnings).toEqual ({ tags: ['tag warning'] })
+  })
+
+  it ('updates the reset snapshot only after metadata URL changes', () => {
+    const current = buildPostImportRow ({
+      attributes: { title: 'manual title' },
+      metadataUrl: 'https://example.com/old' })
+    const validated = buildPostImportRow ({
+      attributes: { title: 'new metadata title' },
+      metadataUrl: 'https://example.com/new',
+      fieldWarnings: { title: ['warning'] },
+      baseWarnings: ['base warning'] })
+
+    const result = mergeValidatedImportRows ([current], [validated])[0]
+
+    expect (result?.resetSnapshot).toMatchObject ({
+      attributes: { title: 'new metadata title' },
+      fieldWarnings: { title: ['warning'] },
+      baseWarnings: ['base warning'],
+      metadataUrl: 'https://example.com/new' })
+  })
+
+  it ('merges result states and clears incompatible post identifiers', () => {
+    const created = mergeImportResults ([buildPostImportRow ({
+      skipReason: 'existing',
+      existingPostId: 2 })], [{
+      sourceRow: 1,
+      status: 'created',
+      post: { id: 3 } }])[0]
+    const skipped = mergeImportResults ([buildPostImportRow ({
+      createdPostId: 3,
+      importStatus: 'created' })], [{
+      sourceRow: 1,
+      status: 'skipped',
+      existingPostId: 4 }])[0]
+    const failed = mergeImportResults ([buildPostImportRow ({
+      skipReason: 'existing',
+      existingPostId: 4 })], [{
+      sourceRow: 1,
+      status: 'failed',
+      errors: { base: ['failure'] } }])[0]
+
+    expect (created).toMatchObject ({
+      importStatus: 'created',
+      createdPostId: 3,
+      existingPostId: undefined,
+      skipReason: undefined })
+    expect (skipped).toMatchObject ({
+      importStatus: 'skipped',
+      existingPostId: 4,
+      createdPostId: undefined,
+      skipReason: 'existing' })
+    expect (failed).toMatchObject ({
+      importStatus: 'failed',
+      createdPostId: undefined,
+      existingPostId: undefined,
+      skipReason: undefined,
+      importErrors: { base: ['failure'] } })
+  })
+
+  it ('retries only the selected failed row and counts results exclusively', () => {
+    const rows = [
+      buildPostImportRow ({ sourceRow: 1, importStatus: 'created', createdPostId: 1 }),
+      buildPostImportRow ({ sourceRow: 2, importStatus: 'skipped',
+	existingPostId: 2, skipReason: 'existing' }),
+      buildPostImportRow ({ sourceRow: 3, importStatus: 'failed',
+	importErrors: { base: ['failed'] } })]
+
+    expect (resultSummaryCounts (rows)).toEqual ({ created: 1, skipped: 1, failed: 1 })
+    expect (retryImportRow (rows, 3)[2]).toMatchObject ({
+      importStatus: 'pending',
+      importErrors: undefined })
+  })
+
+  it ('copies reset snapshot values instead of sharing mutable records', () => {
+    const row = buildPostImportRow ({ fieldWarnings: { title: ['warning'] } })
+    const initialised = initialisePreviewRows ([row])[0]
+    expect (initialised).toBeDefined ()
+    if (initialised == null)
+      return
+
+    initialised.attributes.title = 'changed'
+    initialised.fieldWarnings.title?.push ('another')
+
+    expect (initialised.resetSnapshot.attributes.title).toBe ('')
+    expect (initialised.resetSnapshot.fieldWarnings.title).toEqual (['warning'])
+  })
+})

frontend/src/lib/postImportRows.ts

@@ -0,0 +1,173 @@
+import type { PostImportResultRow,
+	      PostImportRow } from '@/lib/postImportTypes'
+
+const hasSkipReason = (row: PostImportRow): boolean =>
+    row.skipReason === 'existing'
+
+const hasValidationErrors = (row: PostImportRow): boolean =>
+    Object.keys (row.validationErrors ?? { }).length > 0
+
+const buildResetSnapshot = (row: PostImportRow) => ({
+    url: row.url,
+    attributes: { ...row.attributes },
+    provenance: { ...row.provenance },
+    tagSources: {
+	automatic: row.tagSources?.automatic ?? '',
+	manual: row.tagSources?.manual ?? '' },
+    fieldWarnings: Object.fromEntries (
+	Object.entries (row.fieldWarnings).map (([key, values]) => [key, [...values]])),
+    baseWarnings: [...row.baseWarnings],
+    metadataUrl: row.metadataUrl })
+
+
+export const processableImportRows = (rows: PostImportRow[]): PostImportRow[] =>
+    rows.filter (row => {
+	if (row.importStatus === 'created')
+	  return false
+	if (row.importStatus === 'skipped')
+	  return false
+	if (row.importStatus === 'failed')
+	  return false
+	if (hasValidationErrors (row))
+	  return false
+	return row.importStatus == null || row.importStatus === 'pending'
+    })
+
+export const creatableImportRows = (rows: PostImportRow[]): PostImportRow[] =>
+    processableImportRows (rows).filter (row => !(hasSkipReason (row)))
+
+
+export const reviewSummaryCounts = (rows: PostImportRow[]) => ({
+    total: rows.length,
+    submittable: rows.filter (row =>
+	creatableImportRows ([row]).length > 0
+	&& !(hasValidationErrors (row))).length,
+    skipPlanned: rows.filter (row =>
+	processableImportRows ([row]).length > 0
+	&& hasSkipReason (row)).length })
+
+
+export const resultSummaryCounts = (rows: PostImportRow[]) =>
+    rows.reduce (
+	(counts, row) => {
+	    if (row.importStatus === 'created')
+	      {
+		++counts.created
+		return counts
+	      }
+	    if (row.importStatus === 'skipped')
+	      {
+		++counts.skipped
+		return counts
+	      }
+	    if (row.importStatus === 'failed')
+	      ++counts.failed
+	    return counts
+	},
+	{ created: 0, skipped: 0, failed: 0 })
+
+
+export const mergeValidatedImportRows = (
+    current:   PostImportRow[],
+    validated: PostImportRow[],
+): PostImportRow[] => {
+    const validatedMap = new Map (validated.map (row => [row.sourceRow, row]))
+    return current.map (previous => {
+	if (
+	    previous.importStatus === 'created'
+	    || previous.importStatus === 'skipped'
+	    || previous.importStatus === 'failed')
+	  return previous
+
+	const row = validatedMap.get (previous.sourceRow)
+	if (row == null)
+	  return previous
+
+	const fieldWarnings =
+	    Object.keys (row.fieldWarnings).length > 0 || row.metadataUrl !== previous.metadataUrl
+	    ? { ...row.fieldWarnings }
+	    : { ...previous.fieldWarnings }
+	for (const [field, origin] of Object.entries (row.provenance))
+	  {
+	    if (origin === 'manual')
+	      delete fieldWarnings[field]
+	  }
+
+	return {
+	    ...previous,
+	    url: row.url,
+	    attributes: row.attributes,
+	    provenance: row.provenance,
+	    tagSources: row.tagSources,
+	    skipReason: row.skipReason,
+	    existingPostId: row.existingPostId,
+	    fieldWarnings,
+	    baseWarnings:
+		row.baseWarnings.length > 0 || row.metadataUrl !== previous.metadataUrl
+		? row.baseWarnings
+		: previous.baseWarnings,
+	    validationErrors: row.validationErrors,
+	    status: row.status,
+	    metadataUrl: row.metadataUrl,
+	    resetSnapshot:
+		row.metadataUrl !== previous.metadataUrl
+		? buildResetSnapshot (row)
+		: previous.resetSnapshot }
+    })
+}
+
+
+export const mergeImportResults = (
+    rows:    PostImportRow[],
+    results: PostImportResultRow[],
+): PostImportRow[] => {
+    const resultMap = new Map (results.map (row => [row.sourceRow, row]))
+    return rows.map (row => {
+	const result = resultMap.get (row.sourceRow)
+	if (result == null)
+	  return row
+
+	switch (result.status)
+	  {
+	  case 'created':
+	    return {
+		...row,
+		importStatus: 'created',
+		skipReason: undefined,
+		createdPostId: result.post.id,
+		existingPostId: undefined,
+		importErrors: result.errors }
+	  case 'skipped':
+	    return {
+		...row,
+		importStatus: 'skipped',
+		skipReason: 'existing',
+		createdPostId: undefined,
+		existingPostId: result.existingPostId,
+		importErrors: result.errors }
+	  case 'failed':
+	    return {
+		...row,
+		importStatus: 'failed',
+		skipReason: undefined,
+		createdPostId: undefined,
+		existingPostId: undefined,
+		importErrors: result.errors }
+	  }
+    })
+}
+
+
+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 initialisePreviewRows = (rows: PostImportRow[]): PostImportRow[] =>
+    rows.map (row => ({
+	...row,
+	resetSnapshot: buildResetSnapshot (row) }))

frontend/src/lib/postImportSession.ts

@@ -0,0 +1,4 @@
+export * from '@/lib/postImportTypes'
+export * from '@/lib/postImportStorage'
+export * from '@/lib/postImportSourceValidation'
+export * from '@/lib/postImportRows'

frontend/src/lib/postImportSourceValidation.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest'
+
+import { countImportSourceLines, validateImportSource } from '@/lib/postImportSession'
+
+describe ('post import source validation', () => {
+  it ('counts trimmed non-empty CRLF and LF rows', () => {
+    expect (countImportSourceLines (' one \r\n\r\n two\n')).toBe (2)
+  })
+
+  it ('reports invalid protocols and malformed URLs with original line numbers', () => {
+    const issues = validateImportSource (
+        '\nftp://example.com/file\nhttps://exa mple.com/path')
+
+    expect (issues).toEqual ([
+      {
+	sourceRow: 2,
+	message: 'HTTP または HTTPS の URL ではありません．',
+	url: 'ftp://example.com/file' },
+      {
+	sourceRow: 3,
+	message: 'URL の形式が不正です．',
+	url: 'https://exa mple.com/path' }])
+  })
+
+  it ('detects duplicates after frontend URL normalisation', () => {
+    const issues = validateImportSource (
+        'https://EXAMPLE.com/path/\nhttps://example.com/path')
+
+    expect (issues).toEqual ([{
+      sourceRow: 2,
+      message: '1 行目と同じ URL です．',
+      url: 'https://example.com/path' }])
+  })
+
+  it ('rejects oversized URLs and rows beyond the maximum count', () => {
+    const oversized = `https://example.com/${ 'a'.repeat (20 * 1024) }`
+    const tooMany = Array.from (
+        { length: 101 },
+        (_, index) => `https://example.com/${ index }`).join ('\n')
+
+    expect (validateImportSource (oversized)[0]).toMatchObject ({
+      sourceRow: 1,
+      message: 'URL が長すぎます．' })
+    expect (validateImportSource (tooMany).at (-1)).toEqual ({
+      sourceRow: 101,
+      message: '取込件数は 100 件までです．',
+      url: 'https://example.com/100' })
+  })
+})

frontend/src/lib/postImportSourceValidation.ts

@@ -0,0 +1,110 @@
+import type { PostImportSourceIssue } from '@/lib/postImportTypes'
+
+const MAX_ROWS = 100
+const MAX_URL_BYTES = 20 * 1024
+
+
+const truncateUrl = (value: string): string =>
+    value.length > 120 ? `${ value.slice (0, 117) }…` : value
+
+
+const bytesize = (value: string): number =>
+    new TextEncoder ().encode (value).length
+
+
+const normaliseImportUrl = (value: string): string | null => {
+    const trimmed = value.trim ()
+    if (!(trimmed))
+      return null
+
+    try
+    {
+	const url = new URL (trimmed)
+	if (!(url.protocol === 'http:' || url.protocol === 'https:'))
+	  return null
+	if (!(url.host))
+	  return null
+
+	url.hostname = url.hostname.toLowerCase ()
+	if (url.pathname.endsWith ('/'))
+	  url.pathname = url.pathname.replace (/\/+$/, '')
+	return url.toString ()
+    }
+    catch
+    {
+	return null
+    }
+}
+
+
+export const countImportSourceLines = (source: string): number =>
+    source
+	.split (/\r\n|\n|\r/)
+	.map (_1 => _1.trim ())
+	.filter (_1 => _1 !== '')
+	.length
+
+
+export const validateImportSource = (
+    source: string,
+): PostImportSourceIssue[] => {
+    const lines = source.split (/\r\n|\n|\r/)
+    const issues: PostImportSourceIssue[] = []
+    const seen = new Map<string, number> ()
+    let count = 0
+
+    lines.forEach ((rawLine, index) => {
+	const value = rawLine.trim ()
+	if (!(value))
+	  return
+
+	++count
+	const sourceRow = index + 1
+	const displayUrl = truncateUrl (value)
+	const normalised = normaliseImportUrl (value)
+	if (count > MAX_ROWS)
+	  {
+	    issues.push ({
+		sourceRow,
+		message: `取込件数は ${ MAX_ROWS } 件までです．`,
+		url: displayUrl })
+	    return
+	  }
+	if (!(value.startsWith ('http://') || value.startsWith ('https://')))
+	  {
+	    issues.push ({
+		sourceRow,
+		message: 'HTTP または HTTPS の URL ではありません．',
+		url: displayUrl })
+	    return
+	  }
+	if (bytesize (value) > MAX_URL_BYTES)
+	  {
+	    issues.push ({
+		sourceRow,
+		message: 'URL が長すぎます．',
+		url: displayUrl })
+	    return
+	  }
+	if (normalised == null)
+	  {
+	    issues.push ({
+		sourceRow,
+		message: 'URL の形式が不正です．',
+		url: displayUrl })
+	    return
+	  }
+	const duplicateRow = seen.get (normalised)
+	if (duplicateRow != null)
+	  {
+	    issues.push ({
+		sourceRow,
+		message: `${ duplicateRow } 行目と同じ URL です．`,
+		url: displayUrl })
+	    return
+	  }
+	seen.set (normalised, sourceRow)
+    })
+
+    return issues
+}

frontend/src/lib/postImportStorage.test.ts

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { cleanupExpiredPostImportSessions,
+	 clearPostImportSourceDraft,
+	 loadPostImportSession,
+	 loadPostImportSourceDraft,
+	 savePostImportSession,
+	 savePostImportSourceDraft } from '@/lib/postImportSession'
+import { buildPostImportRow } from '@/test/postImportFactories'
+
+describe ('post import storage', () => {
+  beforeEach (() => {
+    sessionStorage.clear ()
+    vi.useRealTimers ()
+  })
+
+  it ('round-trips a valid session and source draft', () => {
+    const row = buildPostImportRow ({
+      importStatus: 'skipped',
+      skipReason: 'existing',
+      existingPostId: 10 })
+
+    expect (savePostImportSession ('session', {
+      source: row.url,
+      rows: [row],
+      repairMode: 'all' })).toBe (true)
+    expect (loadPostImportSession ('session')).toMatchObject ({
+      version: 2,
+      source: row.url,
+      rows: [{
+	importStatus: 'skipped',
+	skipReason: 'existing',
+	existingPostId: 10 }] })
+
+    expect (savePostImportSourceDraft ('https://example.com')).toBe (true)
+    expect (loadPostImportSourceDraft ()).toEqual ({ source: 'https://example.com' })
+    clearPostImportSourceDraft ()
+    expect (loadPostImportSourceDraft ()).toEqual ({ source: '' })
+  })
+
+  it ('rejects inconsistent post IDs and terminal statuses', () => {
+    const session = {
+      version: 2,
+      savedAt: new Date ().toISOString (),
+      source: '',
+      repairMode: 'all',
+      rows: [buildPostImportRow ()] }
+    const invalidRows = [
+      { ...session.rows[0], skipReason: 'existing', existingPostId: undefined },
+      { ...session.rows[0], existingPostId: 2, skipReason: undefined },
+      { ...session.rows[0], importStatus: 'created', createdPostId: undefined },
+      { ...session.rows[0], importStatus: 'failed', createdPostId: 3 }]
+
+    for (const [index, row] of invalidRows.entries ())
+      {
+	sessionStorage.setItem (`post-import-session:invalid-${ index }`, JSON.stringify ({
+	  ...session,
+	  rows: [row] }))
+	expect (loadPostImportSession (`invalid-${ index }`)).toBeNull ()
+      }
+  })
+
+  it ('rejects invalid attribute, provenance, tag-source, and snapshot data', () => {
+    const row = buildPostImportRow ()
+    const invalidRows = [
+      { ...row, attributes: { title: [] } },
+      { ...row, attributes: { unknown: 'value' } },
+      { ...row, provenance: { title: 'mapped' } },
+      { ...row, tagSources: { mapped: 'tag' } },
+      { ...row, resetSnapshot: { ...row.resetSnapshot,
+	fieldWarnings: { title: 'warning' } } }]
+
+    invalidRows.forEach ((invalidRow, index) => {
+      sessionStorage.setItem (`post-import-session:shape-${ index }`, JSON.stringify ({
+	version: 2,
+	savedAt: new Date ().toISOString (),
+	source: '',
+	rows: [invalidRow],
+	repairMode: 'all' }))
+      expect (loadPostImportSession (`shape-${ index }`)).toBeNull ()
+    })
+  })
+
+  it ('removes expired and malformed sessions without touching current sessions', () => {
+    const current = {
+      version: 2,
+      savedAt: new Date ().toISOString (),
+      source: '',
+      rows: [buildPostImportRow ()],
+      repairMode: 'all' }
+    const expired = {
+      ...current,
+      savedAt: new Date (Date.now () - 25 * 60 * 60 * 1000).toISOString () }
+    sessionStorage.setItem ('post-import-session:current', JSON.stringify (current))
+    sessionStorage.setItem ('post-import-session:expired', JSON.stringify (expired))
+    sessionStorage.setItem ('post-import-session:malformed', '{')
+
+    cleanupExpiredPostImportSessions ()
+
+    expect (sessionStorage.getItem ('post-import-session:current')).not.toBeNull ()
+    expect (sessionStorage.getItem ('post-import-session:expired')).toBeNull ()
+    expect (sessionStorage.getItem ('post-import-session:malformed')).toBeNull ()
+  })
+
+  it ('reports storage access failures without throwing', () => {
+    const onError = vi.fn ()
+    vi.spyOn (Storage.prototype, 'setItem').mockImplementation (() => {
+      throw new DOMException ('quota')
+    })
+
+    expect (savePostImportSourceDraft ('source', onError)).toBe (false)
+    expect (onError).toHaveBeenCalledWith ('ブラウザへ保存できませんでした．')
+  })
+})

frontend/src/lib/postImportStorage.ts

@@ -0,0 +1,408 @@
+import type { PostImportOrigin,
+	      PostImportResetSnapshot,
+	      PostImportRow,
+	      PostImportSession,
+	      PostImportStatus,
+	      PostImportSkipReason,
+	      StorageErrorHandler } from '@/lib/postImportTypes'
+
+const SESSION_VERSION = 2
+const SESSION_PREFIX = 'post-import-session:'
+const SOURCE_DRAFT_KEY = 'post-import-source-draft'
+const SESSION_MAX_AGE_MS = 24 * 60 * 60 * 1000
+const ATTRIBUTE_KEYS = [
+    'title',
+    'thumbnailBase',
+    'originalCreatedFrom',
+    'originalCreatedBefore',
+    'duration',
+    'videoMs',
+    'tags',
+    'parentPostIds'] as const
+const PROVENANCE_KEYS = [...ATTRIBUTE_KEYS, 'url'] as const
+const TAG_SOURCE_KEYS = ['automatic', 'manual'] as const
+const WARNING_KEYS = [...ATTRIBUTE_KEYS, 'url'] as const
+
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+    typeof value === 'object' && value != null && !(Array.isArray (value))
+
+
+const sessionKey = (sessionId: string): string => `${ SESSION_PREFIX }${ sessionId }`
+
+
+const readStorage = (
+    key:       string,
+    onError?:  StorageErrorHandler,
+): string | null => {
+    if (typeof window === 'undefined')
+      return null
+
+    try
+    {
+	return sessionStorage.getItem (key)
+    }
+    catch
+    {
+	onError?.('保存済みデータを読み込めませんでした．')
+	return null
+    }
+}
+
+
+const writeStorage = (
+    key:       string,
+    value:     string,
+    onError?:  StorageErrorHandler,
+): boolean => {
+    if (typeof window === 'undefined')
+      return false
+
+    try
+    {
+	sessionStorage.setItem (key, value)
+	return true
+    }
+    catch
+    {
+	onError?.('ブラウザへ保存できませんでした．')
+	return false
+    }
+}
+
+
+const removeStorage = (
+    key:       string,
+    onError?:  StorageErrorHandler,
+) => {
+    if (typeof window === 'undefined')
+      return
+
+    try
+    {
+	sessionStorage.removeItem (key)
+    }
+    catch
+    {
+	onError?.('保存済みデータを削除できませんでした．')
+    }
+}
+
+
+const ensureStringListRecord = (value: unknown): Record<string, string[]> | null => {
+    if (!(isPlainObject (value)))
+      return null
+
+    const result: Record<string, string[]> = { }
+    for (const [key, entry] of Object.entries (value))
+      {
+	if (!(Array.isArray (entry)) || !(entry.every (_1 => typeof _1 === 'string')))
+	  return null
+	result[key] = entry
+      }
+    return result
+}
+
+
+const isValidStatus = (
+    value: unknown,
+): value is PostImportRow['status'] =>
+    value === 'ready' || value === 'warning' || value === 'error'
+
+
+const isValidImportStatus = (
+    value: unknown,
+): value is PostImportStatus =>
+    value === 'pending'
+    || value === 'created'
+    || value === 'skipped'
+    || value === 'failed'
+
+
+const isValidOrigin = (
+    value: unknown,
+): value is PostImportOrigin =>
+    value === 'automatic' || value === 'manual'
+
+
+const isValidSkipReason = (
+    value: unknown,
+): value is PostImportSkipReason =>
+    value === 'existing'
+
+const isPositiveInteger = (value: unknown): value is number =>
+    Number.isInteger (value) && Number (value) > 0
+
+const hasOnlyKeys = (
+    value:        Record<string, unknown>,
+    allowedKeys:  readonly string[],
+): boolean =>
+    Object.keys (value).every (key => allowedKeys.includes (key))
+
+const sanitiseResetSnapshot = (value: unknown): PostImportResetSnapshot | null => {
+    if (!(isPlainObject (value)))
+      return null
+    if (typeof value.url !== 'string')
+      return null
+    if (!(isPlainObject (value.attributes)))
+      return null
+    if (!(hasOnlyKeys (value.attributes, ATTRIBUTE_KEYS)))
+      return null
+    if (!(Object.values (value.attributes).every (entry =>
+	typeof entry === 'string' || typeof entry === 'number')))
+      return null
+    if (!(isPlainObject (value.provenance)))
+      return null
+    if (!(hasOnlyKeys (value.provenance, PROVENANCE_KEYS)))
+      return null
+    if (!(Object.values (value.provenance).every (origin => isValidOrigin (origin))))
+      return null
+    if (!(isPlainObject (value.tagSources)))
+      return null
+    if (!(hasOnlyKeys (value.tagSources, TAG_SOURCE_KEYS)))
+      return null
+    if (!(Object.values (value.tagSources).every (_1 => typeof _1 === 'string')))
+      return null
+    const fieldWarnings = ensureStringListRecord (value.fieldWarnings)
+    if (fieldWarnings == null)
+      return null
+    if (!(hasOnlyKeys (fieldWarnings, WARNING_KEYS)))
+      return null
+    if (!(Array.isArray (value.baseWarnings))
+	|| !(value.baseWarnings.every (_1 => typeof _1 === 'string')))
+      return null
+    if (value.metadataUrl != null && typeof value.metadataUrl !== 'string')
+      return null
+
+    return {
+	url: value.url,
+	attributes: value.attributes as Record<string, string | number>,
+	provenance: value.provenance as Record<string, PostImportOrigin>,
+	tagSources: value.tagSources as Record<PostImportOrigin, string>,
+	fieldWarnings,
+	baseWarnings: value.baseWarnings,
+	metadataUrl: value.metadataUrl as string | undefined }
+}
+
+
+const sanitiseRow = (value: unknown): PostImportRow | null => {
+    if (!(isPlainObject (value)))
+      return null
+    if (!(Number.isInteger (value.sourceRow)) || Number (value.sourceRow) <= 0)
+      return null
+    if (typeof value.url !== 'string')
+      return null
+    if (!(isPlainObject (value.attributes)))
+      return null
+    if (!(isPlainObject (value.provenance)))
+      return null
+    if (!(isValidStatus (value.status)))
+      return null
+    if (value.importStatus != null && !(isValidImportStatus (value.importStatus)))
+      return null
+    if (value.skipReason != null && !(isValidSkipReason (value.skipReason)))
+      return null
+    if (value.skipReason === 'existing' && !(isPositiveInteger (value.existingPostId)))
+      return null
+    if (value.skipReason !== 'existing' && value.existingPostId != null)
+      return null
+    if (value.importStatus === 'created' && !(isPositiveInteger (value.createdPostId)))
+      return null
+    if (value.importStatus !== 'created' && value.createdPostId != null)
+      return null
+
+    const validationErrors = ensureStringListRecord (value.validationErrors)
+    const fieldWarnings = ensureStringListRecord (value.fieldWarnings)
+    const resetSnapshot = sanitiseResetSnapshot (value.resetSnapshot)
+    if (validationErrors == null || fieldWarnings == null)
+      return null
+    if (resetSnapshot == null)
+      return null
+
+    const importErrors =
+	value.importErrors == null
+	? undefined
+	: ensureStringListRecord (value.importErrors)
+    if (importErrors === null)
+      return null
+    if (!(Array.isArray (value.baseWarnings))
+	|| !(value.baseWarnings.every (_1 => typeof _1 === 'string')))
+      return null
+
+    const provenanceEntries = Object.entries (value.provenance)
+    if (!(hasOnlyKeys (value.attributes, ATTRIBUTE_KEYS)))
+      return null
+    if (!(Object.values (value.attributes).every (entry =>
+	typeof entry === 'string' || typeof entry === 'number')))
+      return null
+    if (!(hasOnlyKeys (value.provenance, PROVENANCE_KEYS)))
+      return null
+    if (!(provenanceEntries.every (([, origin]) => isValidOrigin (origin))))
+      return null
+
+    if (value.tagSources != null)
+      {
+	if (!(isPlainObject (value.tagSources)))
+	  return null
+	if (!(hasOnlyKeys (value.tagSources, TAG_SOURCE_KEYS)))
+	  return null
+	if (!(Object.values (value.tagSources).every (_1 => typeof _1 === 'string')))
+	  return null
+      }
+
+    return {
+	sourceRow: Number (value.sourceRow),
+	url: value.url,
+	attributes: value.attributes as Record<string, string | number>,
+	fieldWarnings,
+	baseWarnings: value.baseWarnings,
+	validationErrors,
+	importErrors,
+	provenance: value.provenance as Record<string, PostImportOrigin>,
+	tagSources: value.tagSources as Record<PostImportOrigin, string> | undefined,
+	status: value.status,
+	skipReason: value.skipReason ?? undefined,
+	existingPostId:
+	    isPositiveInteger (value.existingPostId) ? Number (value.existingPostId) : undefined,
+	metadataUrl: typeof value.metadataUrl === 'string' ? value.metadataUrl : undefined,
+	resetSnapshot,
+	createdPostId:
+	    isPositiveInteger (value.createdPostId) ? Number (value.createdPostId) : undefined,
+	importStatus: value.importStatus ?? undefined }
+}
+
+
+const isExpiredSession = (savedAt: string): boolean => {
+    const value = Date.parse (savedAt)
+    return Number.isNaN (value) || Date.now () - value > SESSION_MAX_AGE_MS
+}
+
+
+export const createPostImportSessionId = (): string =>
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+    ? crypto.randomUUID ()
+    : `${ Date.now () }-${ Math.random ().toString (36).slice (2) }`
+
+
+export const cleanupExpiredPostImportSessions = (
+    onError?: StorageErrorHandler,
+) => {
+    if (typeof window === 'undefined')
+      return
+
+    try
+    {
+	for (let i = 0; i < sessionStorage.length; ++i)
+	  {
+	    const key = sessionStorage.key (i)
+	    if (key == null || !(key.startsWith (SESSION_PREFIX)))
+	      continue
+
+	    const raw = sessionStorage.getItem (key)
+	    if (raw == null)
+	      continue
+	    try
+	    {
+		const value = JSON.parse (raw) as { savedAt?: string }
+		if (typeof value.savedAt !== 'string' || isExpiredSession (value.savedAt))
+		  {
+		    sessionStorage.removeItem (key)
+		    --i
+		  }
+	    }
+	    catch
+	    {
+		sessionStorage.removeItem (key)
+		--i
+	    }
+	  }
+    }
+    catch
+    {
+	onError?.('保存済みデータを整理できませんでした．')
+    }
+}
+
+
+export const loadPostImportSourceDraft = (
+    onError?: StorageErrorHandler,
+): { source: string } => {
+    const raw = readStorage (SOURCE_DRAFT_KEY, onError)
+    if (raw == null)
+      return { source: '' }
+
+    try
+    {
+	const value = JSON.parse (raw) as { source?: string }
+	return { source: typeof value.source === 'string' ? value.source : '' }
+    }
+    catch
+    {
+	return { source: '' }
+    }
+}
+
+
+export const savePostImportSourceDraft = (
+    source:    string,
+    onError?:  StorageErrorHandler,
+): boolean =>
+    writeStorage (SOURCE_DRAFT_KEY, JSON.stringify ({ source }), onError)
+
+
+export const clearPostImportSourceDraft = (
+    onError?: StorageErrorHandler,
+) => {
+    removeStorage (SOURCE_DRAFT_KEY, onError)
+}
+
+
+export const savePostImportSession = (
+    sessionId: string,
+    session:   Omit<PostImportSession, 'version' | 'savedAt'>,
+    onError?:  StorageErrorHandler,
+): boolean =>
+    writeStorage (
+	sessionKey (sessionId),
+	JSON.stringify ({
+	    ...session,
+	    version: SESSION_VERSION,
+	    savedAt: new Date ().toISOString () }),
+	onError)
+
+
+export const loadPostImportSession = (
+    sessionId: string,
+    onError?: StorageErrorHandler,
+): PostImportSession | null => {
+    const raw = readStorage (sessionKey (sessionId), onError)
+    if (raw == null)
+      return null
+
+    try
+    {
+	const value = JSON.parse (raw) as Partial<PostImportSession>
+	if (value.version !== SESSION_VERSION || !(Array.isArray (value.rows)))
+	  return null
+	if (typeof value.savedAt !== 'string' || isExpiredSession (value.savedAt))
+	  {
+	    removeStorage (sessionKey (sessionId), onError)
+	    return null
+	  }
+
+	const rows = value.rows.map (sanitiseRow)
+	if (rows.some (_1 => _1 == null))
+	  return null
+
+	return {
+	    version: SESSION_VERSION,
+	    savedAt: value.savedAt,
+	    source: typeof value.source === 'string' ? value.source : '',
+	    rows: rows as PostImportRow[],
+	    repairMode: value.repairMode === 'failed' ? 'failed' : 'all' }
+    }
+    catch
+    {
+	return null
+    }
+}

frontend/src/lib/postImportTypes.ts

@@ -0,0 +1,68 @@
+export type PostImportOrigin = 'automatic' | 'manual'
+export type PostImportRepairMode = 'all' | 'failed'
+export type PostImportStatus =
+    'pending'
+    | 'created'
+    | 'skipped'
+    | 'failed'
+export type PostImportSkipReason = 'existing'
+export type PostImportResultStatus = 'created' | 'skipped' | 'failed'
+export type PostImportAttributeValue = string | number
+
+export type PostImportResetSnapshot = {
+    url:         string
+    attributes:  Record<string, PostImportAttributeValue>
+    provenance:  Record<string, PostImportOrigin>
+    tagSources:  Record<PostImportOrigin, string>
+    fieldWarnings: Record<string, string[]>
+    baseWarnings: string[]
+    metadataUrl?: string }
+
+export type PostImportRow = {
+    sourceRow:         number
+    url:               string
+    attributes:        Record<string, PostImportAttributeValue>
+    fieldWarnings:     Record<string, string[]>
+    baseWarnings:      string[]
+    validationErrors:  Record<string, string[]>
+    importErrors?:     Record<string, string[]>
+    provenance:        Record<string, PostImportOrigin>
+    tagSources?:       Record<PostImportOrigin, string>
+    status:            'ready' | 'warning' | 'error'
+    skipReason?:       PostImportSkipReason
+    existingPostId?:   number
+    metadataUrl?:      string
+    resetSnapshot:     PostImportResetSnapshot
+    createdPostId?:    number
+    importStatus?:     PostImportStatus }
+
+export type PostImportResultRow =
+    | {
+	sourceRow: number
+	status:    'created'
+	post:      { id: number }
+	errors?:   Record<string, string[]> }
+    | {
+	sourceRow:      number
+	status:         'skipped'
+	existingPostId: number
+	errors?:        Record<string, string[]> }
+    | {
+	sourceRow: number
+	status:    'failed'
+	errors?:   Record<string, string[]>
+	recoverable?: boolean }
+
+export type PostImportSession = {
+    version:    number
+    savedAt:    string
+    source:     string
+    rows:       PostImportRow[]
+    repairMode: PostImportRepairMode }
+
+export type PostImportSourceIssue = {
+    sourceRow: number
+    message:   string
+    url:       string }
+
+export type StorageErrorHandler = (message: string) => void

frontend/src/pages/posts/PostImportResultPage.test.tsx

@@ -0,0 +1,82 @@
+import { fireEvent, screen } from '@testing-library/react'
+import { Route, Routes, useLocation } from 'react-router-dom'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { savePostImportSession } from '@/lib/postImportSession'
+import PostImportResultPage from '@/pages/posts/PostImportResultPage'
+import { buildUser } from '@/test/factories'
+import { buildPostImportRow } from '@/test/postImportFactories'
+import { renderWithProviders } from '@/test/render'
+
+const api = vi.hoisted (() => ({ apiPost: vi.fn () }))
+const toastApi = vi.hoisted (() => ({ toast: vi.fn () }))
+
+vi.mock ('@/lib/api', () => api)
+vi.mock ('@/components/ui/use-toast', () => toastApi)
+
+const ReviewLocation = () => {
+  const location = useLocation ()
+  return <div>{`review route ${ location.search }`}</div>
+}
+
+const renderPage = () => renderWithProviders (
+    <Routes>
+      <Route
+	  path="/posts/import/:sessionId/result"
+	  element={<PostImportResultPage user={buildUser ()}/>}/>
+      <Route path="/posts/import/:sessionId/review" element={<ReviewLocation/>}/>
+    </Routes>,
+    { route: '/posts/import/session/result' })
+
+describe ('PostImportResultPage', () => {
+  beforeEach (() => {
+    sessionStorage.clear ()
+    vi.clearAllMocks ()
+  })
+
+  it ('shows exclusive result counts, post links, and failed-row actions', async () => {
+    const rows = [
+      buildPostImportRow ({ sourceRow: 1, importStatus: 'created', createdPostId: 11 }),
+      buildPostImportRow ({ sourceRow: 2, importStatus: 'skipped',
+	skipReason: 'existing', existingPostId: 22 }),
+      buildPostImportRow ({ sourceRow: 3, importStatus: 'failed',
+	importErrors: { base: ['登録中に失敗しました．'] } })]
+    savePostImportSession ('session', { source: '', rows, repairMode: 'all' })
+
+    renderPage ()
+
+    expect (await screen.findByText (
+	/登録成功\s*1件.*スキップ\s*1件.*失敗\s*1件/)).toBeInTheDocument ()
+    expect (screen.getAllByRole ('link', { name: '投稿を開く' })
+	.map (_1 => _1.getAttribute ('href'))).toEqual (['/posts/11', '/posts/22'])
+    expect (screen.getByText ('登録中に失敗しました．')).toBeInTheDocument ()
+    expect (screen.getByRole ('button', { name: '編輯' })).toBeInTheDocument ()
+    expect (screen.getByRole ('button', { name: '再試行' })).toBeInTheDocument ()
+  })
+
+  it ('returns a retry validation error to the review dialogue route', async () => {
+    const failed = buildPostImportRow ({
+      importStatus: 'failed',
+      importErrors: { base: ['old error'] } })
+    const invalid = buildPostImportRow ({
+      importStatus: 'pending',
+      status: 'error',
+      validationErrors: { title: ['タイトルを確認してください．'] } })
+    savePostImportSession ('session', {
+      source: failed.url,
+      rows: [failed],
+      repairMode: 'all' })
+    api.apiPost.mockResolvedValue ({ rows: [invalid] })
+
+    renderPage ()
+    fireEvent.click (await screen.findByRole ('button', { name: '再試行' }))
+
+    expect (await screen.findByText ('review route ?edit=1')).toBeInTheDocument ()
+    expect (api.apiPost).toHaveBeenCalledTimes (1)
+    const saved = JSON.parse (
+	sessionStorage.getItem ('post-import-session:session') ?? '{}')
+    expect (saved.rows[0]).toMatchObject ({
+      importStatus: 'pending',
+      validationErrors: { title: ['タイトルを確認してください．'] } })
+  })
+})

frontend/src/pages/posts/PostImportResultPage.tsx

@@ -0,0 +1,290 @@
+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 { displayPostImportStatus } from '@/components/posts/import/postImportRowStatus'
+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 { clearPostImportSourceDraft,
+	 initialisePreviewRows,
+	 loadPostImportSession,
+	 mergeImportResults,
+	 mergeValidatedImportRows,
+	 resultSummaryCounts,
+	 retryImportRow,
+	 savePostImportSession } from '@/lib/postImportSession'
+import Forbidden from '@/pages/Forbidden'
+
+import type { FC } from 'react'
+
+import type { PostImportResultRow, PostImportRow } from '@/lib/postImportSession'
+import type { PostImportSession } from '@/lib/postImportSession'
+import type { User } from '@/types'
+
+type Props = { user: User | null }
+
+const rowMessages = (row: PostImportRow): string[] =>
+    Object.values (row.importErrors ?? { }).flat ()
+
+
+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 == null)
+      return
+
+    const loaded = loadPostImportSession (sessionId, message =>
+	toast ({ title: '取込状態を復元できませんでした', description: message }))
+    setSession (loaded)
+    setMissing (loaded == null)
+  }, [sessionId])
+
+  useEffect (() => {
+    if (sessionId == null || session == null)
+      return
+
+    savePostImportSession (sessionId, session, message =>
+	toast ({ title: '取込状態を保存できませんでした', description: message }))
+  }, [session, sessionId])
+
+  const counts = useMemo (
+      () => resultSummaryCounts (session?.rows ?? []),
+      [session])
+
+  const retry = async (sourceRow: number) => {
+    if (session == null || sessionId == null)
+      return
+
+    setLoadingRow (sourceRow)
+    try
+      {
+	const pendingRows = retryImportRow (session.rows, sourceRow)
+	setSession ({ ...session, rows: pendingRows })
+	const validated = await apiPost<{ rows: PostImportRow[] }> ('/posts/import/validate', {
+	    rows: pendingRows
+		.filter (row => row.importStatus !== 'created')
+		.map (row => ({
+		    sourceRow: row.sourceRow,
+		    url: row.url,
+		    attributes: row.attributes,
+		    provenance: row.provenance,
+		    tagSources: row.tagSources,
+		    metadataUrl: row.metadataUrl })),
+	    changed_row: -1 })
+	const validatedRows = mergeValidatedImportRows (
+	    pendingRows,
+	    initialisePreviewRows (validated.rows))
+	const nextSession = {
+	    ...session,
+	    rows: validatedRows,
+	    repairMode: 'failed' as const }
+	setSession (nextSession)
+	const target = validatedRows.find (_1 => _1.sourceRow === sourceRow)
+	if (target == null)
+	  return
+	if (Object.keys (target.validationErrors ?? { }).length > 0)
+	  {
+	    const saved = savePostImportSession (sessionId, nextSession, message =>
+		toast ({ title: '取込状態を保存できませんでした', description: message }))
+	    if (saved)
+	      navigate (`/posts/import/${ sessionId }/review?edit=${ sourceRow }`)
+	    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 }] })
+	const mergedRows = mergeImportResults (nextSession.rows, result.rows)
+	const recoverableRows = result.rows.filter (row =>
+	    row.status === 'failed'
+	    && row.recoverable
+	    && Object.keys (row.errors ?? { }).length > 0)
+	const nextRows = mergedRows.map ((row): PostImportRow => {
+	  const recoverable = recoverableRows.find (_1 => _1.sourceRow === row.sourceRow)
+	  if (recoverable == null)
+	    return row
+	  return {
+	      ...row,
+	      importStatus: 'pending',
+	      validationErrors: recoverable.errors ?? { },
+	      importErrors: undefined }
+	})
+	const recoverableTarget = nextRows.find (_1 => _1.sourceRow === sourceRow)
+	const resultSession = {
+	    ...nextSession,
+	    rows: nextRows,
+	    repairMode: recoverableTarget == null ? 'all' as const : 'failed' as const }
+	setSession (resultSession)
+	if (recoverableTarget != null
+	    && Object.keys (recoverableTarget.validationErrors).length > 0)
+	  {
+	    const saved = savePostImportSession (sessionId, resultSession, message =>
+		toast ({ title: '取込状態を保存できませんでした', description: message }))
+	    if (saved)
+	      navigate (`/posts/import/${ sessionId }/review?edit=${ sourceRow }`)
+	    return
+	  }
+      }
+    catch
+      {
+	setSession (session)
+	toast ({ title: '再試行に失敗しました' })
+      }
+    finally
+      {
+	setLoadingRow (null)
+      }
+  }
+
+  const openRepair = (sourceRow: number) => {
+    if (session == null || sessionId == null)
+      return
+
+    const nextSession = { ...session, repairMode: 'failed' as const }
+    setSession (nextSession)
+    const saved = savePostImportSession (sessionId, nextSession, message =>
+	toast ({ title: '取込状態を保存できませんでした', description: message }))
+    if (!(saved))
+      return
+    navigate (`/posts/import/${ sessionId }/review?edit=${ sourceRow }`)
+  }
+
+  if (!(editable))
+    return <Forbidden/>
+
+  if (missing || sessionId == null || session == null)
+    {
+      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="text-sm text-neutral-700 dark:text-neutral-200">
+	    登録成功 {counts.created}件　スキップ {counts.skipped}件　失敗 {counts.failed}件
+	  </div>
+
+	  <div className="space-y-3">
+	    {session.rows.map (row => {
+	      const displayStatus = displayPostImportStatus (row)
+	      const canEdit = row.importStatus === 'failed'
+	      const canRetry =
+		  row.importStatus === 'failed'
+		  && Object.keys (row.validationErrors).length === 0
+	      return (
+		  <div
+		      key={row.sourceRow}
+		      className="rounded-lg border p-4 transition-shadow hover:shadow-sm">
+		    <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>
+			  {displayStatus != null && <PostImportStatusBadge value={displayStatus}/>}
+			</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={rowMessages (row)}/>
+		      </div>
+
+		      <div className="flex flex-col gap-2 sm:flex-row">
+			{(row.createdPostId != null || row.existingPostId != null) && (
+			    <Button type="button" variant="outline" asChild>
+			      <PrefetchLink
+				  to={`/posts/${ row.createdPostId ?? row.existingPostId }`}>
+				投稿を開く
+			      </PrefetchLink>
+			    </Button>)}
+			{canEdit && (
+			    <Button
+				type="button"
+				variant="outline"
+				onClick={() => openRepair (row.sourceRow)}>
+			      編輯
+			    </Button>)}
+			{canRetry && (
+			    <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)
+		      const saved = savePostImportSession (sessionId, nextSession, message =>
+			  toast ({ title: '取込状態を保存できませんでした', description: message }))
+		      if (!(saved))
+			return
+		      navigate (`/posts/import/${ sessionId }/review`)
+		  }}>
+		確認画面へ戻る
+	      </Button>
+	      <Button
+		  type="button"
+		  variant="outline"
+		  onClick={() => {
+		      clearPostImportSourceDraft (message =>
+			  toast ({ title: '入力内容を削除できませんでした', description: message }))
+		      navigate ('/posts/import')
+		  }}>
+		新しい URL リストを入力
+	      </Button>
+	    </div>
+	  </div>
+	</MainArea>)
+}
+
+export default PostImportResultPage

frontend/src/pages/posts/PostImportReviewPage.test.tsx

@@ -0,0 +1,78 @@
+import { fireEvent, screen, waitFor } from '@testing-library/react'
+import { Route, Routes } from 'react-router-dom'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { savePostImportSession } from '@/lib/postImportSession'
+import PostImportReviewPage from '@/pages/posts/PostImportReviewPage'
+import { buildUser } from '@/test/factories'
+import { buildPostImportRow } from '@/test/postImportFactories'
+import { renderWithProviders } from '@/test/render'
+
+const api = vi.hoisted (() => ({ apiPost: vi.fn () }))
+const toastApi = vi.hoisted (() => ({ toast: vi.fn () }))
+
+vi.mock ('@/lib/api', () => api)
+vi.mock ('@/components/ui/use-toast', () => toastApi)
+
+const renderPage = () => renderWithProviders (
+    <Routes>
+      <Route
+	  path="/posts/import/:sessionId/review"
+	  element={<PostImportReviewPage user={buildUser ()}/>}/>
+      <Route path="/posts/import/:sessionId/result" element={<div>result route</div>}/>
+    </Routes>,
+    { route: '/posts/import/session/review' })
+
+describe ('PostImportReviewPage', () => {
+  beforeEach (() => {
+    sessionStorage.clear ()
+    vi.clearAllMocks ()
+  })
+
+  it ('keeps the review route and opens the first invalid row dialogue', async () => {
+    const row = buildPostImportRow ({ attributes: { title: 'title' } })
+    savePostImportSession ('session', { source: row.url, rows: [row], repairMode: 'all' })
+    api.apiPost.mockResolvedValue ({ rows: [buildPostImportRow ({
+      attributes: { title: 'title' },
+      status: 'error',
+      validationErrors: { title: ['タイトルを確認してください．'] } })] })
+
+    renderPage ()
+    fireEvent.click (await screen.findByRole ('button', { name: '取込実行' }))
+
+    expect (await screen.findByText ('投稿を編輯')).toBeInTheDocument ()
+    expect (screen.getByText ('タイトルを確認してください．')).toBeInTheDocument ()
+    expect (api.apiPost).toHaveBeenCalledTimes (1)
+    expect (screen.queryByText ('result route')).not.toBeInTheDocument ()
+  })
+
+  it ('submits existing rows for a formal skipped result and opens result route', async () => {
+    const row = buildPostImportRow ({
+      skipReason: 'existing',
+      existingPostId: 10 })
+    savePostImportSession ('session', { source: row.url, rows: [row], repairMode: 'all' })
+    api.apiPost
+	.mockResolvedValueOnce ({ rows: [row] })
+	.mockResolvedValueOnce ({
+	  created: 0,
+	  skipped: 1,
+	  failed: 0,
+	  rows: [{ sourceRow: 1, status: 'skipped', existingPostId: 10 }] })
+
+    renderPage ()
+    fireEvent.click (await screen.findByRole ('button', { name: '取込実行' }))
+
+    expect (await screen.findByText ('result route')).toBeInTheDocument ()
+    expect (api.apiPost).toHaveBeenCalledTimes (2)
+    expect (api.apiPost.mock.calls[1]?.[1]).toMatchObject ({
+      rows: [expect.objectContaining ({ sourceRow: 1, url: row.url })] })
+    await waitFor (() => {
+      const saved = JSON.parse (
+	  sessionStorage.getItem ('post-import-session:session') ?? '{}')
+      expect (saved.rows[0]).toMatchObject ({
+	importStatus: 'skipped',
+	existingPostId: 10,
+	skipReason: 'existing' })
+    })
+  })
+})

frontend/src/pages/posts/PostImportReviewPage.tsx

@@ -0,0 +1,415 @@
+import { useEffect, useMemo, useState } from 'react'
+import { Helmet } from 'react-helmet-async'
+import { useNavigate, useParams, useSearchParams } from 'react-router-dom'
+
+import PageTitle from '@/components/common/PageTitle'
+import MainArea from '@/components/layout/MainArea'
+import PostImportRowForm from '@/components/posts/import/PostImportRowForm'
+import PostImportRowSummary from '@/components/posts/import/PostImportRowSummary'
+import { Button } from '@/components/ui/button'
+import { toast } from '@/components/ui/use-toast'
+import { SITE_TITLE } from '@/config'
+import { apiPost } from '@/lib/api'
+import useDialogue from '@/lib/dialogues/useDialogue'
+import { canEditContent } from '@/lib/users'
+import { loadPostImportSession,
+	 creatableImportRows,
+	 initialisePreviewRows,
+	 mergeImportResults,
+	 mergeValidatedImportRows,
+	 processableImportRows,
+	 reviewSummaryCounts,
+	 savePostImportSession } from '@/lib/postImportSession'
+import Forbidden from '@/pages/Forbidden'
+
+import type { FC } from 'react'
+
+import type { PostImportRowDraft } from '@/components/posts/import/PostImportRowForm'
+import type { PostImportResultRow,
+	      PostImportRow,
+	      PostImportSession } from '@/lib/postImportSession'
+import type { User } from '@/types'
+
+type Props = { user: User | null }
+
+
+const PostImportReviewPage: FC<Props> = ({ user }) => {
+  const editable = canEditContent (user)
+  const dialogue = useDialogue ()
+  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)
+
+  useEffect (() => {
+    if (sessionId == null)
+      return
+
+    const loaded = loadPostImportSession (sessionId, message =>
+	toast ({ title: '取込状態を復元できませんでした', description: message }))
+    setSession (loaded)
+    setMissing (loaded == null)
+  }, [sessionId])
+
+  useEffect (() => {
+    if (sessionId == null || session == null)
+      return
+
+    savePostImportSession (sessionId, session, message =>
+	toast ({ title: '取込状態を保存できませんでした', description: message }))
+  }, [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 processable = useMemo (
+      () => processableImportRows (rows),
+      [rows])
+  const creatable = useMemo (
+      () => creatableImportRows (rows),
+      [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', behavior: 'smooth' })
+  }, [editingRow, session?.repairMode])
+
+  const updateSessionRows = (nextRows: PostImportRow[]) =>
+      setSession (current =>
+	  current != null ? { ...current, rows: nextRows } : current)
+
+  const saveDraft = async (
+      { draft, resetRequested, resetSnapshot }: {
+	  draft:            PostImportRowDraft
+	  resetRequested:   boolean
+	  resetSnapshot:    PostImportRow['resetSnapshot'] },
+  ): Promise<{ saved: boolean
+	       row:   PostImportRow | null }> => {
+    if (session == null)
+      return { saved: false, row: null }
+
+    if (editingRow == null)
+      return { saved: false, row: null }
+
+    const baseRow =
+	resetRequested
+	? { ...editingRow,
+	    url: resetSnapshot.url,
+	    attributes: { ...resetSnapshot.attributes },
+	    provenance: { ...resetSnapshot.provenance },
+	    tagSources: { ...resetSnapshot.tagSources },
+	    fieldWarnings: Object.fromEntries (
+		Object.entries (resetSnapshot.fieldWarnings)
+		    .map (([key, values]) => [key, [...values]])),
+	    baseWarnings: [...resetSnapshot.baseWarnings],
+	    metadataUrl: resetSnapshot.metadataUrl }
+	: editingRow
+    const urlChanged = draft.url !== baseRow.url
+    const nextRow = buildNextEditedRow (baseRow, draft, urlChanged)
+
+    const nextRows = session.rows.map (row =>
+		row.sourceRow === editingRow.sourceRow
+		? nextRow
+		: row)
+    try
+    {
+      const validated = await apiPost<{ rows: PostImportRow[] }> ('/posts/import/validate', {
+	  rows:
+	      nextRows
+	      .filter (row => row.importStatus !== 'created')
+	      .map (row => ({ sourceRow: row.sourceRow,
+			      url: row.url,
+			      attributes: row.attributes,
+			      provenance: row.provenance,
+			      tagSources: row.tagSources,
+			      metadataUrl: row.metadataUrl })),
+	  changed_row: urlChanged ? editingRow.sourceRow : -1 })
+      const validatedRows = initialisePreviewRows (validated.rows)
+      const target = validatedRows.find (row => row.sourceRow === editingRow.sourceRow)
+      if (target != null && Object.keys (target.validationErrors).length > 0)
+	return { saved: false, row: target }
+      updateSessionRows (mergeValidatedImportRows (nextRows, validatedRows))
+      setSearchParams ({ })
+      return { saved: true, row: null }
+    }
+    catch
+    {
+      toast ({ title: '行の再検証に失敗しました' })
+      return { saved: false, row: null }
+    }
+  }
+
+  const openEditingDialogue = async (row: PostImportRow) => {
+    const saveRowDraft = (
+	{ draft, resetRequested }: {
+	    draft:          PostImportRowDraft
+	    resetRequested: boolean },
+    ) =>
+	saveDraft ({
+	    draft,
+	    resetRequested,
+	    resetSnapshot: row.resetSnapshot })
+
+    await dialogue.form ({
+	title: '投稿を編輯',
+	description: `投稿 ${ row.sourceRow } の内容を確認し、必要な項目を編輯してください．`,
+	cancelText: '取消',
+	size: 'large',
+	body: controls => (
+	    <PostImportRowForm
+		row={row}
+		controls={controls}
+		onSave={saveRowDraft}/>) })
+    setSearchParams ({ })
+  }
+
+  useEffect (() => {
+    if (editingRow == null)
+      return
+
+    void openEditingDialogue (editingRow)
+  }, [editingRow])
+
+  const submit = async () => {
+    if (sessionId == null || session == null || processable.length === 0)
+      return
+
+    setLoading (true)
+    try
+    {
+      const validated = await apiPost<{ rows: PostImportRow[] }> ('/posts/import/validate', {
+	  rows:
+	      session.rows
+	      .filter (row => row.importStatus !== 'created')
+	      .map (row => ({ sourceRow: row.sourceRow,
+			      url: row.url,
+			      attributes: row.attributes,
+			      provenance: row.provenance,
+			      tagSources: row.tagSources,
+			      metadataUrl: row.metadataUrl })),
+	  changed_row: -1 })
+      const validatedRows = initialisePreviewRows (validated.rows)
+      const mergedRows = mergeValidatedImportRows (session.rows, validatedRows)
+      const firstInvalid = mergedRows.find (row => Object.keys (row.validationErrors).length > 0)
+      if (firstInvalid != null)
+	{
+	  setSession ({ ...session, rows: mergedRows })
+	  setSearchParams ({ edit: String (firstInvalid.sourceRow) })
+	  return
+	}
+
+      const result = await apiPost<{
+	  created: number
+	  skipped: number
+	  failed:  number
+	  rows:    PostImportResultRow[] }> ('/posts/import', {
+	      rows: processableImportRows (mergedRows).map (row => ({
+		  sourceRow: row.sourceRow,
+		  url: row.url,
+		  attributes: row.attributes,
+		  provenance: row.provenance,
+		  tagSources: row.tagSources,
+		  metadataUrl: row.metadataUrl })) })
+      const mergedResults = mergeImportResults (mergedRows, result.rows)
+      const recoverableRows = result.rows.filter (row =>
+	  row.status === 'failed'
+	  && row.recoverable
+	  && Object.keys (row.errors ?? { }).length > 0)
+      const nextRows = mergedResults.map ((row): PostImportRow => {
+	const recoverable = recoverableRows.find (rr => rr.sourceRow === row.sourceRow)
+	if (recoverable == null)
+	  return row
+	return {
+	    ...row,
+	    importStatus: 'pending',
+	    validationErrors: recoverable.errors ?? { },
+	    importErrors: undefined }
+      })
+      const firstRecoverable = nextRows.find (row =>
+	  Object.keys (row.validationErrors).length > 0
+	  && row.importStatus !== 'created')
+      if (firstRecoverable != null)
+	{
+	  const repairSession = { ...session,
+				  rows: nextRows,
+				  repairMode: 'failed' as const }
+	  setSession (repairSession)
+	  const saved = savePostImportSession (sessionId, repairSession, message =>
+	      toast ({ title: '取込状態を保存できませんでした', description: message }))
+	  if (saved)
+	    setSearchParams ({ edit: String (firstRecoverable.sourceRow) })
+	  return
+	}
+      const nextSession = { ...session, rows: nextRows, repairMode: 'all' as const }
+      setSession (nextSession)
+      const saved = savePostImportSession (sessionId, nextSession, message =>
+	  toast ({ title: '取込状態を保存できませんでした', description: message }))
+      if (!(saved))
+	return
+      navigate (`/posts/import/${ sessionId }/result`)
+    }
+    catch
+    {
+      toast ({ title: '登録に失敗しました' })
+    }
+    finally
+    {
+      setLoading (false)
+    }
+  }
+
+  if (!(editable))
+    return <Forbidden/>
+
+  if (missing || sessionId == null || session == null)
+    {
+      return (
+	  <MainArea>
+	    <div className="mx-auto max-w-4xl space-y-4 p-4">
+	      <PageTitle>投稿インポート</PageTitle>
+	      <div className="text-red-700 dark:text-red-300">取込状態が見つかりません．</div>
+	      <Button type="button" onClick={() => navigate ('/posts/import')}>
+		URL リスト入力へ戻る
+	      </Button>
+	    </div>
+	  </MainArea>)
+    }
+
+  return (
+      <>
+	<Helmet>
+	  <title>{`投稿インポート確認 | ${ SITE_TITLE }`}</title>
+	</Helmet>
+
+	<MainArea className="min-h-0">
+	  <div className="mx-auto max-w-6xl space-y-4 p-4">
+	    <PageTitle>投稿情報の確認</PageTitle>
+
+	    <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) })
+			}}/>
+		  </div>))}
+	    </div>
+	  </div>
+	</MainArea>
+
+	<PostImportFooter
+	    loading={loading}
+	    processableCount={processable.length}
+	    creatableCount={creatable.length}
+	    skipPlannedCount={counts.skipPlanned}
+	    onBack={() => navigate ('/posts/import')}
+	    onSubmit={submit}/>
+      </>)
+}
+
+const PostImportFooter = (
+    { loading,
+      processableCount,
+      creatableCount,
+      skipPlannedCount,
+      onBack,
+      onSubmit }: { loading:            boolean
+		    processableCount:   number
+		    creatableCount:     number
+		    skipPlannedCount:   number
+		    onBack:             () => void
+		    onSubmit:           () => void },
+) => (
+    <div
+	className="shrink-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">
+	  <span>処理対象 {processableCount}件</span>
+	  <span>登録対象 {creatableCount}件</span>
+	  <span>スキップ予定 {skipPlannedCount}件</span>
+	</div>
+	<div className="flex flex-col gap-2 sm:flex-row">
+	  <Button type="button" variant="outline" onClick={onBack}>
+	    URL リスト入力へ戻る
+	  </Button>
+	  <Button
+	      type="button"
+	      onClick={onSubmit}
+	      disabled={loading || processableCount === 0}>
+	    取込実行
+	  </Button>
+	</div>
+      </div>
+    </div>)
+
+const buildNextEditedRow = (
+    editingRow:  PostImportRow,
+    draft:       PostImportRowDraft,
+    urlChanged:  boolean,
+): PostImportRow => {
+    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 ?? ''
+      }
+
+    return {
+	...editingRow,
+	url: draft.url,
+	attributes: nextAttributes,
+	provenance: {
+	    ...nextProvenance,
+	    url: urlChanged ? 'manual' : (editingRow.provenance.url ?? 'manual') },
+	tagSources: nextTagSources,
+	importStatus: editingRow.importStatus === 'created' ? 'created' : 'pending',
+	importErrors: undefined }
+}
+
+export default PostImportReviewPage

frontend/src/pages/posts/PostImportSourcePage.test.tsx

@@ -0,0 +1,92 @@
+import { fireEvent, screen, waitFor } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import PostImportSourcePage from '@/pages/posts/PostImportSourcePage'
+import { buildUser } from '@/test/factories'
+import { buildPostImportRow } from '@/test/postImportFactories'
+import { renderWithProviders } from '@/test/render'
+
+const api = vi.hoisted (() => ({
+  apiPost: vi.fn (),
+  isApiError: vi.fn () }))
+
+const router = vi.hoisted (() => ({ navigate: vi.fn () }))
+
+const toastApi = vi.hoisted (() => ({ toast: vi.fn () }))
+
+vi.mock ('@/lib/api', () => api)
+vi.mock ('@/components/ui/use-toast', () => toastApi)
+vi.mock ('react-router-dom', async importOriginal => ({
+  ...await importOriginal<typeof import('react-router-dom')> (),
+  useNavigate: () => router.navigate }))
+
+describe ('PostImportSourcePage', () => {
+  beforeEach (() => {
+    sessionStorage.clear ()
+    vi.clearAllMocks ()
+    api.isApiError.mockReturnValue (false)
+  })
+
+  it ('shows no empty error initially and validates only after Next is pressed', () => {
+    renderWithProviders (<PostImportSourcePage user={buildUser ()}/>)
+
+    expect (screen.queryByText ('URL を入力してください．')).not.toBeInTheDocument ()
+    fireEvent.click (screen.getByRole ('button', { name: '次へ' }))
+    expect (screen.getByText ('URL を入力してください．')).toBeInTheDocument ()
+    expect (api.apiPost).not.toHaveBeenCalled ()
+  })
+
+  it ('shows frontend URL issues with line numbers without requesting preview', () => {
+    renderWithProviders (<PostImportSourcePage user={buildUser ()}/>)
+    const input = screen.getByRole ('textbox', { name: '' })
+
+    fireEvent.change (input, {
+      target: { value: '\nftp://example.com/file\nhttps://example.com/valid' } })
+    expect (screen.queryByText (/2 行目/)).not.toBeInTheDocument ()
+    fireEvent.click (screen.getByRole ('button', { name: '次へ' }))
+
+    expect (screen.getByText (/2 行目: HTTP または HTTPS/)).toBeInTheDocument ()
+    expect (screen.getByText ('ftp://example.com/file')).toBeInTheDocument ()
+    expect (input).toHaveAttribute ('aria-invalid', 'true')
+    expect (input.getAttribute ('aria-describedby')).toContain ('post-import-source-issues')
+    expect (api.apiPost).not.toHaveBeenCalled ()
+  })
+
+  it ('shows backend URL errors against original input without a session', async () => {
+    api.apiPost.mockResolvedValue ({
+      rows: [buildPostImportRow ({
+	sourceRow: 2,
+	url: 'https://example.com/canonical',
+	status: 'error',
+	validationErrors: { url: ['URL が重複しています．'] } })] })
+    renderWithProviders (<PostImportSourcePage user={buildUser ()}/>)
+
+    fireEvent.change (screen.getByRole ('textbox', { name: '' }), {
+      target: { value: '\nhttps://example.com/original' } })
+    fireEvent.click (screen.getByRole ('button', { name: '次へ' }))
+
+    expect (await screen.findByText ('2 行目: URL が重複しています．')).toBeInTheDocument ()
+    expect (screen.getAllByText ('https://example.com/original')).toHaveLength (2)
+    expect (router.navigate).not.toHaveBeenCalled ()
+    expect (Array.from ({ length: sessionStorage.length }, (_, index) =>
+	sessionStorage.key (index))).not.toContainEqual(
+	    expect.stringMatching (/^post-import-session:/))
+  })
+
+  it ('stores a successful preview before navigating to the review route', async () => {
+    api.apiPost.mockResolvedValue ({ rows: [buildPostImportRow ()] })
+    renderWithProviders (<PostImportSourcePage user={buildUser ()}/>)
+
+    fireEvent.change (screen.getByRole ('textbox', { name: '' }), {
+      target: { value: 'https://example.com/post' } })
+    fireEvent.click (screen.getByRole ('button', { name: '次へ' }))
+
+    await waitFor (() => {
+      expect (router.navigate).toHaveBeenCalledWith (
+	  expect.stringMatching (/^\/posts\/import\/[^/]+\/review$/))
+    })
+    const sessionKeys = Array.from ({ length: sessionStorage.length }, (_, index) =>
+	sessionStorage.key (index)).filter (_1 => _1?.startsWith ('post-import-session:'))
+    expect (sessionKeys).toHaveLength (1)
+  })
+})

frontend/src/pages/posts/PostImportSourcePage.tsx

@@ -0,0 +1,208 @@
+import { useEffect, useRef, useState } from 'react'
+import { Helmet } from 'react-helmet-async'
+import { useNavigate } from 'react-router-dom'
+
+import FieldError from '@/components/common/FieldError'
+import Form from '@/components/common/Form'
+import FormField from '@/components/common/FormField'
+import PageTitle from '@/components/common/PageTitle'
+import TextArea from '@/components/common/TextArea'
+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 { countImportSourceLines,
+	 cleanupExpiredPostImportSessions,
+	 createPostImportSessionId,
+	 initialisePreviewRows,
+	 loadPostImportSourceDraft,
+	 savePostImportSession,
+	 savePostImportSourceDraft,
+	 validateImportSource } from '@/lib/postImportSession'
+import Forbidden from '@/pages/Forbidden'
+
+import type { FC } from 'react'
+
+import type { PostImportRow } from '@/lib/postImportSession'
+import type { User } from '@/types'
+
+type Props = { user: User | null }
+
+const MAX_ROWS = 100
+const SOURCE_ERROR_ID = 'post-import-source-error'
+const SOURCE_ISSUES_ID = 'post-import-source-issues'
+
+const urlIssuesFromRows = (rows: PostImportRow[], source: string) => {
+  const sourceLines = source.split (/\r\n|\n|\r/)
+
+  return rows.flatMap (row =>
+      (row.validationErrors.url ?? []).map (message => ({
+	  sourceRow: row.sourceRow,
+	  message,
+	  url: sourceLines[row.sourceRow - 1]?.trim () ?? row.url })))
+}
+
+
+const PostImportSourcePage: FC<Props> = ({ user }) => {
+  const editable = canEditContent (user)
+  const navigate = useNavigate ()
+  const [source, setSource] = useState ('')
+  const [loading, setLoading] = useState (false)
+  const [sourceIssues, setSourceIssues] = useState<ReturnType<typeof validateImportSource>> ([])
+  const [sourceError, setSourceError] = useState<string | null> (null)
+  const saveTimer = useRef<number | null> (null)
+  const editedRef = useRef (false)
+
+  const lineCount = countImportSourceLines (source)
+  const messages = sourceError != null ? [sourceError] : []
+  const sourceDescribedBy =
+      [sourceError != null ? SOURCE_ERROR_ID : null,
+       sourceIssues.length > 0 ? SOURCE_ISSUES_ID : null]
+      .filter (_1 => _1 != null)
+      .join (' ')
+
+  useEffect (() => {
+    cleanupExpiredPostImportSessions (message =>
+	toast ({ title: '保存済みデータを整理できませんでした', description: message }))
+
+    const draft = loadPostImportSourceDraft (message =>
+	toast ({ title: '保存済み入力を復元できませんでした', description: message }))
+
+    if (!(editedRef.current))
+      setSource (current => current === '' ? draft.source : current)
+  }, [])
+
+  useEffect (() => {
+    if (saveTimer.current != null)
+      window.clearTimeout (saveTimer.current)
+
+    saveTimer.current = window.setTimeout (() => {
+      savePostImportSourceDraft (source, message =>
+	  toast ({ title: '入力内容を保存できませんでした', description: message }))
+    }, 300)
+
+    return () => {
+      if (saveTimer.current != null)
+	window.clearTimeout (saveTimer.current)
+    }
+  }, [source])
+
+  const preview = async () => {
+    if (lineCount === 0)
+      {
+	setSourceIssues ([])
+	setSourceError ('URL を入力してください．')
+	return
+      }
+
+    const issues = validateImportSource (source)
+    if (issues.length > 0)
+      {
+	setSourceIssues (issues)
+	setSourceError (null)
+	return
+      }
+
+    setLoading (true)
+    setSourceIssues ([])
+    setSourceError (null)
+    try
+    {
+      const data = await apiPost<{ rows: PostImportRow[] }> ('/posts/import/preview', { source })
+      const urlIssues = urlIssuesFromRows (data.rows, source)
+      if (urlIssues.length > 0)
+	{
+	  setSourceIssues (urlIssues)
+	  return
+	}
+      const sessionId = createPostImportSessionId ()
+      const saved = savePostImportSession (
+	  sessionId,
+	  { source,
+	    rows: initialisePreviewRows (data.rows),
+	    repairMode: 'all' },
+	  message => toast ({ title: '取込状態を保存できませんでした', description: message }))
+      if (!(saved))
+	return
+      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
+      setSourceError (message ?? '入力を確認してください．')
+      toast ({ title: '投稿情報の取得に失敗しました',
+	       description: message ?? '入力を確認してください．' })
+    }
+    finally
+    {
+      setLoading (false)
+    }
+  }
+
+  if (!(editable))
+    return <Forbidden/>
+
+  return (
+      <MainArea>
+	<Helmet>
+	  <title>{`投稿インポート | ${ SITE_TITLE }`}</title>
+	</Helmet>
+
+	<Form className="max-w-4xl">
+	  <PageTitle>投稿インポート</PageTitle>
+	  <FormField label="URL リスト">
+	    {() => (
+		<TextArea
+		    value={source}
+		    rows={14}
+		    invalid={messages.length > 0 || sourceIssues.length > 0}
+		    aria-describedby={sourceDescribedBy || undefined}
+		    className="h-80 font-mono text-sm"
+		    onBlur={() => {
+		      savePostImportSourceDraft (source, message =>
+			  toast ({ title: '入力内容を保存できませんでした',
+				   description: message }))
+		    }}
+		    onChange={ev => {
+		      editedRef.current = true
+		      setSource (ev.target.value)
+		      setSourceError (null)
+		      setSourceIssues ([])
+		    }}/>)}
+	  </FormField>
+	  <div id={messages.length > 0 ? SOURCE_ERROR_ID : undefined}>
+	    <FieldError messages={messages}/>
+	  </div>
+	  <ul
+	      id={SOURCE_ISSUES_ID}
+	      className="space-y-2 text-sm text-red-700 dark:text-red-300">
+	    {sourceIssues.map (issue => (
+		<li key={`${ issue.sourceRow }-${ issue.message }-${ issue.url }`}>
+		  <div>{issue.sourceRow} 行目: {issue.message}</div>
+		  <div className="break-all font-mono text-xs">{issue.url}</div>
+		</li>))}
+	  </ul>
+
+	  <div className="flex items-center justify-between gap-3">
+	    <div className="text-sm text-neutral-600 dark:text-neutral-300">
+	      入力行数 {lineCount} / {MAX_ROWS}
+	    </div>
+	    <Button
+		type="button"
+		className="shrink-0"
+		onClick={preview}
+		disabled={loading}>
+	      次へ
+	    </Button>
+	  </div>
+	</Form>
+      </MainArea>)
+}
+
+export default PostImportSourcePage

frontend/src/pages/posts/PostNewPage.tsx

@@ -25,7 +25,8 @@ 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 +37,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 ('')
@@ -51,7 +54,7 @@ const PostNewPage: FC<Props> = ({ user }) => {
   const thumbnailPreviewRef = useRef ('')
   const videoFlg =
       useMemo (() => tags.split (/\s+/).some (tag => tag.replace (/\[.*\]$/, '') === '動画'),
-               [tags])
+	       [tags])
 
   const handleSubmit = async () => {
     clearValidationErrors ()
@@ -79,7 +82,7 @@ const PostNewPage: FC<Props> = ({ user }) => {
     catch (e)
     {
       applyValidationError (e)
-      toast ({ title: '投稿失敗', description: '入力を確認してください。' })
+      toast ({ title: '投稿失敗', description: '入力を確認してください．' })
     }
   }
 
@@ -105,7 +108,8 @@ 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)
       setThumbnailPreview (imageURL)
       setThumbnailFile (new File ([data],

frontend/src/test/postImportFactories.ts

@@ -0,0 +1,52 @@
+import type { PostImportRow } from '@/lib/postImportSession'
+
+export const buildPostImportRow = (
+    overrides: Partial<PostImportRow> = {},
+): PostImportRow => {
+  const attributes = {
+    title: '',
+    thumbnailBase: '',
+    originalCreatedFrom: '',
+    originalCreatedBefore: '',
+    duration: '',
+    tags: '',
+    parentPostIds: '',
+    ...overrides.attributes }
+  const provenance = {
+    url: 'manual' as const,
+    title: 'automatic' as const,
+    thumbnailBase: 'automatic' as const,
+    originalCreatedFrom: 'automatic' as const,
+    originalCreatedBefore: 'automatic' as const,
+    duration: 'automatic' as const,
+    tags: 'automatic' as const,
+    parentPostIds: 'automatic' as const,
+    ...overrides.provenance }
+  const fieldWarnings = { ...overrides.fieldWarnings }
+  const baseWarnings = [...(overrides.baseWarnings ?? [])]
+  const tagSources = {
+    automatic: overrides.tagSources?.automatic ?? '',
+    manual: overrides.tagSources?.manual ?? '' }
+  const url = overrides.url ?? 'https://example.com/post'
+
+  return {
+    ...overrides,
+    sourceRow: overrides.sourceRow ?? 1,
+    url,
+    attributes,
+    fieldWarnings,
+    baseWarnings,
+    validationErrors: overrides.validationErrors ?? {},
+    provenance,
+    tagSources,
+    status: overrides.status ?? 'ready',
+    resetSnapshot: overrides.resetSnapshot ?? {
+	url,
+	attributes: { ...attributes },
+	provenance: { ...provenance },
+	tagSources: { ...tagSources },
+	fieldWarnings: Object.fromEntries (
+	    Object.entries (fieldWarnings).map (([key, values]) => [key, [...values]])),
+	baseWarnings: [...baseWarnings],
+	metadataUrl: overrides.metadataUrl } }
+}