#398

AGENTS.md

@@ -114,142 +114,28 @@ 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 hash / block / call delimiter の詳細は、下の
-  `Ruby delimiter and wrapping rules` を正本として扱ふこと。
+- Ruby hashes are not blocks; keep `}` on the same line as the final pair.
+- Ruby hashes keep the first pair on the same line as `{` unless line length
+  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.
-- In TypeScript and TSX, use 2-space block indentation.
-- In TypeScript and TSX, block bodies for components, functions, callbacks,
-  `if`, `try`, `catch`, `finally`, loops, and JSX nesting use 2 spaces per
-  level.
-- In TypeScript and TSX, put the opening brace of `try`, `catch`, and
-  `finally` blocks on the next line at the same indentation as the keyword.
-- Do not indent the opening `{` one level deeper than `try`, `catch`, or
-  `finally`.
-- Indent the block body 2 spaces deeper than the keyword and opening brace.
-- Put the closing `}` on its own line at the same indentation as the keyword.
-- Do not write `try {`, `catch {`, or `finally {`.
-- 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 use 4-space logical indentation.
+- In TypeScript and TSX only, replace every leading run of 8 spaces with a tab.
+- Tabs are only for leading indentation, never for spaces after non-space text.
 - 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,
@@ -281,17 +167,6 @@ case 'no':
 - In TypeScript and TSX, use `value == null` and `value != null` as the
   default nullish checks. Do not use `=== null`, `=== undefined`,
   `!== null`, or `!== undefined`.
-- In JavaScript, JSX, TypeScript, and TSX, never use `_1`, `_2`, or similar
-  Ruby-style numbered parameter names. Reserve numbered parameters for Ruby.
-  Use a meaningful callback parameter name such as `row`, `item`, `value`,
-  `entry`, or `result`.
-- In JavaScript, JSX, TypeScript, and TSX, use `cn` from `@/lib/utils`
-  whenever `className` combines multiple values, conditional classes, or a
-  caller-provided `className` prop.
-- Do not construct `className` with template literals, `${ ... }`, string
-  concatenation, arrays joined with spaces, or feature-local class-merging
-  helpers.
-- A static `className="..."` containing only fixed classes does not need `cn`.
 - If code appears to need a distinction between `null` and `undefined`, treat
   that as a design smell and revise the logic to avoid the distinction.
   External library APIs that explicitly require distinguishing the two are the
@@ -315,151 +190,6 @@ 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.
@@ -467,12 +197,6 @@ and layout reuse, follow `frontend/AGENTS.md`.
   structure, control flow, or variable mutability unless the requested style
   explicitly requires it.
 - Do not add production dependencies without explicit approval.
-- Do not add user-facing copy, helper text, descriptions, notes, tooltips,
-  placeholders, empty-state messages, loading messages, or explanatory text
-  unless the user explicitly specified the wording.
-- When new user-facing wording appears necessary, ask the user for the exact
-  wording and placement before implementing it.
-- Do not invent replacement copy when removing unrequested wording.
 - Do not create, modify, or run tests unless the user explicitly asks for
   test work. When the user asks for tests, keep working and rerun them until
   they pass or the remaining failure is clearly blocked.
@@ -529,11 +253,6 @@ and layout reuse, follow `frontend/AGENTS.md`.
 - Mobile UI must be checked as a first-class layout. Avoid wide fixed content,
   make dense controls wrap or scroll intentionally, and keep tag/filter
   controls usable without horizontal page overflow.
-- Frontend のスマホ／PC表示境界は原則 `md` とする。
-- button stack、footer action、dialogue action は `md` 未満で縦並び、
-  `md` 以上で横並びとする。
-- 同じ画面内で `sm` と `md` を混在させて中間 layout を作らない。
-- 明確に別の responsive 要件がある component だけを例外とする。
 - For mobile horizontal scrollers, make the scroll direction and item sizing
   explicit, and ensure chip text remains readable in both light and dark modes.
 - In TypeScript and TSX, prefer direct comparison operators such as `===` and
@@ -546,20 +265,6 @@ and layout reuse, follow `frontend/AGENTS.md`.
 - 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
 
@@ -598,24 +303,14 @@ and layout reuse, follow `frontend/AGENTS.md`.
   beginning of a line.
 - The TSX-specific self-review must confirm JSX closing markers and closing
   parentheses keep the surrounding compact style.
-- The TypeScript/TSX self-review must confirm leading block indentation uses
-  2 spaces per level, wrapped continuations use the repository's 4-space
-  continuation alignment, and complete leading runs of 8 spaces may be
-  compressed to tabs.
+- The TypeScript/TSX self-review must confirm leading indentation follows
+  4-space logical indentation with tabs only as leading 8-space compression.
 - 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, use 2-space block indentation and 4-space continuation
-  indentation.
-- In TypeScript and TSX, put the opening brace of `try`, `catch`, and
-  `finally` blocks on the next line at the same indentation as the keyword.
-- Do not indent the opening `{` one level deeper than `try`, `catch`, or
-  `finally`.
-- Indent the block body 2 spaces deeper than the keyword and opening brace.
-- Put the closing `}` on its own line at the same indentation as the keyword.
-- Do not write `try {`, `catch {`, or `finally {`.
-- In TypeScript and TSX, convert every complete leading run of 8 spaces to a
-  tab character.
+- In TSX, indent with 4-space logical indentation.
+- In TypeScript and TSX, convert every 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
@@ -664,22 +359,6 @@ and layout reuse, follow `frontend/AGENTS.md`.
   single physical line.
 - Always add braces around `if`, `else`, or `for` bodies when the body spans
   two or more physical lines, even if it is one statement.
-- `try` / `catch` / `finally` brace placement example:
-
-```ts
-try
-{
-  doWork ()
-}
-catch
-{
-  recover ()
-}
-finally
-{
-  cleanUp ()
-}
-```
 - Do not use a leading semicolon for expression statements such as
   `;([...]).forEach(...)`; rewrite the expression to avoid ASI hazards
   explicitly, for example with `void`.
@@ -1259,9 +938,8 @@ 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 block indentation uses 2 spaces per level, wrapped continuations
-   use the repository's 4-space continuation alignment, and complete leading
-   runs of 8 spaces may be compressed to tabs.
+9. Leading indentation is 4-space logical indentation with tabs used only as
+   leading 8-space compression.
 10. No line has trailing whitespace.
 
 Preferred:

backend/AGENTS.md

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

backend/app/controllers/posts_controller.rb

@@ -1,6 +1,5 @@
 class PostsController < ApplicationController
   Event = Struct.new(:post, :tag, :user, :change_type, :timestamp, keyword_init: true)
-  MAX_BULK_REQUEST_BYTES = 40 * 1024 * 1024
 
   class VideoMsParseError < ArgumentError
     ;
@@ -115,77 +114,6 @@ class PostsController < ApplicationController
     render json: PostRepr.base(post, current_user)
   end
 
-  def metadata
-    return head :unauthorized unless current_user
-    return head :forbidden unless current_user.gte_member?
-    return render_bad_request('URL は必須です．') if params[:url].blank?
-
-    normal_url = PostUrlNormaliser.normalise(params[:url].to_s)
-    return render_validation_error(fields: { url: ['URL が不正です．'] }) if normal_url.blank?
-
-    Preview::UrlSafety.validate(normal_url)
-    existing_post = Post.with_attached_thumbnail.find_by(url: normal_url)
-    if existing_post.present?
-      return render json: {
-          url: normal_url,
-          title: nil,
-          thumbnail_base: nil,
-          tags: nil,
-          display_tags: [],
-          original_created_from: nil,
-          original_created_before: nil,
-          duration: nil,
-          video_ms: nil,
-          field_warnings: { },
-          base_warnings: [],
-          existing_post_id: existing_post.id,
-          existing_post: compact_post(existing_post.id) }
-    end
-
-    metadata = PostMetadataFetcher.fetch(normal_url)
-    field_warnings = { }
-    field_warnings[:title] = ['タイトルを取得できませんでした．'] if metadata[:title].blank?
-    if metadata[:thumbnail_base].blank?
-      field_warnings[:thumbnail_base] = ['サムネールを取得できませんでした．']
-    end
-
-    render json: {
-        url: normal_url,
-        title: metadata[:title],
-        thumbnail_base: metadata[:thumbnail_base],
-        tags: metadata[:tags],
-        display_tags: metadata[:display_tags],
-        original_created_from: metadata[:original_created_from],
-        original_created_before: metadata[:original_created_before],
-        duration: metadata[:duration],
-        video_ms: metadata[:video_ms],
-        field_warnings: field_warnings,
-        base_warnings: [],
-        existing_post_id: nil,
-        existing_post: nil }
-  rescue ArgumentError => e
-    render_bad_request e.message
-  rescue Preview::UrlSafety::UnsafeUrl => e
-    render_validation_error fields: { url: [e.message] }
-  rescue Preview::HttpFetcher::FetchFailed,
-         Preview::HttpFetcher::FetchTimeout,
-         Preview::HttpFetcher::ResponseTooLarge
-    render json: {
-        url: normal_url,
-        title: nil,
-        thumbnail_base: nil,
-        tags: nil,
-        display_tags: [],
-        original_created_from: nil,
-        original_created_before: nil,
-        duration: nil,
-        video_ms: nil,
-        field_warnings: { url: ['自動取得に失敗しました．'] },
-        base_warnings: [],
-        existing_post_id: nil,
-        existing_post: nil }
-  end
-
   def show
     post =
         Post
@@ -214,51 +142,48 @@ class PostsController < ApplicationController
     return head :unauthorized unless current_user
     return head :forbidden unless current_user.gte_member?
 
-    preflight = PostCreatePreflight.new(
-        attributes: post_create_attributes,
-        thumbnail: params[:thumbnail],
-        host: request.base_url).run
-    return render json: dry_run_json(preflight) if bool?(:dry)
-    if preflight[:existing_post_id].present?
-      post = Post.new(url: preflight[:url])
-      post.errors.add :url, :taken
-      return render_post_form_record_invalid post
-    end
+    # TODO: サイトに応じて thumbnail_base 設定
+    title = params[:title].presence
+    url = params[:url]
+    thumbnail = params[:thumbnail]
+    tag_names = params[:tags].to_s.split
+    original_created_from = params[:original_created_from]
+    original_created_before = params[:original_created_before]
+    parent_post_ids = parse_parent_post_ids
+    resized_thumbnail = thumbnail.present? ? Post.resized_thumbnail_attachment(thumbnail) : nil
 
-    post = PostCreator.new(actor: current_user,
-                           attributes: post_create_attributes.merge(
-                               preflight.slice(
-                                   :url,
-                                   :title,
-                                   :thumbnail_base,
-                                   :tags,
-                                   :parent_post_ids,
-                                   :original_created_from,
-                                   :original_created_before,
-                                   :duration,
-                                   :video_ms,
-                                   :direct_tag_specs,
-                                   :default_tag_specs,
-                                   :snapshot_tag_specs,
-                                   :post_tag_specs,
-                                   :tag_sections,
-                                   :normalised_parent_post_ids).symbolize_keys).merge(
-                               thumbnail: params[:thumbnail])).create!
+    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
-  rescue PostCreatePreflight::ValidationFailed => e
-    render_validation_error fields: e.fields, base: e.base_errors
   rescue Tag::NicoTagNormalisationError
     render_validation_error fields: { tags: 'ニコニコ・タグは直接指定できません．' }
   rescue Tag::DeprecatedTagNormalisationError
     render_unprocessable_entity '廃止済みタグは付与できません．', field: :tags
   rescue Tag::SectionLiteralParseError
     render_validation_error fields: { tags: ['タグ区間の記法が不正です．'] }
-  rescue PostCreator::VideoMsParseError
+  rescue VideoMsParseError
     render_validation_error fields: { video_ms: ['動画時間の記法が不正です．'] }
-  rescue Post::RemoteThumbnailFetchFailed
-    render_validation_error fields: { thumbnail_base: ['サムネイル画像の取得に失敗しました．'] }
   rescue MiniMagick::Error
     render_validation_error fields: { thumbnail: ['サムネイル画像の変換に失敗しました．'] }
   rescue ArgumentError => e
@@ -267,25 +192,6 @@ class PostsController < ApplicationController
     render_post_form_record_invalid e.record
   end
 
-  def bulk
-    return head :unauthorized unless current_user
-    return head :forbidden unless current_user.gte_member?
-    return head :unsupported_media_type unless request.content_mime_type == Mime[:multipart_form]
-    return head :payload_too_large if request.content_length.to_i > MAX_BULK_REQUEST_BYTES
-    posts = parse_bulk_posts_manifest
-    thumbnails = parse_bulk_thumbnails(posts.length)
-    result = PostBulkCreator.new(
-        actor: current_user,
-        posts:,
-        thumbnails:,
-        host: request.base_url).run
-    render json: result
-  rescue JSON::ParserError
-    render_bad_request 'posts manifest の JSON が不正です．'
-  rescue ArgumentError => e
-    render_validation_error base: [e.message]
-  end
-
   def viewed
     return head :unauthorized unless current_user
 
@@ -580,79 +486,6 @@ class PostsController < ApplicationController
     }.uniq
   end
 
-  def post_create_attributes
-    { title: params[:title],
-      url: params[:url],
-      thumbnail_base: params[:thumbnail_base],
-      tags: params[:tags],
-      original_created_from: params[:original_created_from],
-      original_created_before: params[:original_created_before],
-      parent_post_ids: parse_parent_post_ids,
-      video_ms: params[:video_ms],
-      duration: params[:duration] }
-  end
-
-  def parse_bulk_posts_manifest
-    manifest = params[:posts]
-    raise ArgumentError, 'posts は必須です．' if manifest.blank?
-    raise ArgumentError, 'posts は JSON 文字列で指定してください．' unless manifest.is_a?(String)
-
-    posts = JSON.parse(manifest)
-    raise ArgumentError, 'posts は配列で指定してください．' unless posts.is_a?(Array)
-    raise ArgumentError, '投稿件数は 1 件以上必要です．' if posts.empty?
-    raise ArgumentError, '投稿件数が多すぎます．' if posts.length > 100
-    raise ArgumentError, 'posts 要素の形式が不正です．' unless posts.all? { _1.is_a?(Hash) }
-
-    posts
-  end
-
-  def parse_bulk_thumbnails post_count
-    thumbnails = { }
-    raw = params[:thumbnails]
-    return thumbnails if raw.blank?
-    raise ArgumentError, 'thumbnail key が不正です．' unless raw.respond_to?(:to_unsafe_h)
-
-    raw.to_unsafe_h.each do |key, value|
-      raise ArgumentError, 'thumbnail key が不正です．' unless key.to_s.match?(/\A\d+\z/)
-
-      index = Integer(key, 10)
-      raise ArgumentError, 'thumbnail index が範囲外です．' if index.negative? || index >= post_count
-      raise ArgumentError, 'thumbnail index が重複しています．' if thumbnails.key?(index)
-      unless value.is_a?(ActionDispatch::Http::UploadedFile)
-        raise ArgumentError, 'thumbnail upload が不正です．'
-      end
-
-      thumbnails[index] = value
-    end
-
-    thumbnails
-  end
-
-  def compact_post post_id
-    return nil if post_id.blank?
-
-    post = Post.with_attached_thumbnail.find_by(id: post_id)
-    PostCompactRepr.base(post, host: request.base_url)
-  end
-
-  def dry_run_json preflight
-    preflight.slice(
-        :url,
-        :title,
-        :thumbnail_base,
-        :tags,
-        :display_tags,
-        :parent_post_ids,
-        :original_created_from,
-        :original_created_before,
-        :duration,
-        :video_ms,
-        :field_warnings,
-        :base_warnings,
-        :existing_post_id,
-        :existing_post)
-  end
-
   def sync_parent_posts! post, parent_post_ids
     if parent_post_ids.include?(post.id)
       post.errors.add :parent_post_ids, '自分自身を親投稿にはできません．'
@@ -732,7 +565,6 @@ class PostsController < ApplicationController
 
   def post_incoming_snapshot title:, original_created_from:, original_created_before:,
                              tag_names:, video_ms_param:, duration_param:, parent_post_ids:
-    validate_original_created_values!(original_created_from, original_created_before)
     Tag.normalise_tags!(tag_names, with_tagme: false, deny_deprecated: true,
                                         with_sections: true) =>
         { tags:, sections: }
@@ -770,23 +602,6 @@ class PostsController < ApplicationController
     value.to_s
   end
 
-  def validate_original_created_values! original_created_from, original_created_before
-    candidate = Post.new(
-        url: 'https://example.invalid/original-created-validation',
-        original_created_from:,
-        original_created_before:)
-    candidate.valid?
-    fields = [:original_created_from, :original_created_before, :original_created_at]
-    relevant_errors = candidate.errors.select { fields.include?(_1.attribute) }
-    return if relevant_errors.empty?
-
-    invalid_post = Post.new
-    relevant_errors.each { |error|
-      invalid_post.errors.add(error.attribute, error.message)
-    }
-    raise ActiveRecord::RecordInvalid, invalid_post
-  end
-
   def section_literal section
     "[#{ Post.ms_to_time(section[0]) }-#{ section[1] ? Post.ms_to_time(section[1]) : '' }]"
   end

backend/app/controllers/preview_controller.rb

@@ -18,12 +18,14 @@ class PreviewController < ApplicationController
   def thumbnail
     return render_bad_request('URL は必須です．') if params[:url].blank?
 
-    attachment =
-        Post.resized_thumbnail_attachment(
-            StringIO.new(Preview::ThumbnailFetcher.fetch(params[:url])))
-    send_data attachment[:io].read,
-              type: attachment[:content_type],
-              disposition: 'inline'
+    image = MiniMagick::Image.read(Preview::ThumbnailFetcher.fetch(params[:url]))
+    image.auto_orient
+    image.resize '180x180>'
+    image.format 'png'
+    width, height = image.dimensions
+    raise Preview::ThumbnailFetcher::GenerationFailed, 'サムネール画像の変換に失敗しました．' if width > 180 || height > 180
+
+    send_data image.to_blob, type: 'image/png', disposition: 'inline'
   rescue Preview::UrlSafety::UnsafeUrl => e
     render_bad_request(e.message)
   rescue Preview::HttpFetcher::FetchTimeout => e

backend/app/models/post.rb

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

backend/app/models/post_url_sanitisation_rule.rb

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

backend/app/representations/post_compact_repr.rb

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

backend/app/representations/post_repr.rb

@@ -17,13 +17,8 @@ module PostRepr
 
   module_function
 
-  def base post, current_user = nil, host: nil
-    json =
-        if host.present?
-          common(post, host:)
-        else
-          common(post)
-        end
+  def base post, current_user = nil
+    json = common(post)
     json['tags'] = tag_json(post)
     json['uploaded_user'] = post.uploaded_user && UserRepr.base(post.uploaded_user)
     json['viewed'] = current_user ? current_user.viewed?(post) : false
@@ -31,16 +26,7 @@ module PostRepr
   end
 
   def detail post, current_user = nil, parent_posts: [], child_posts: [],
-             sibling_posts: { }, related: [], host: nil
-    if host.present?
-      base(post, current_user, host:).merge(
-          'parent_posts' => cards(parent_posts, host:),
-          'child_posts' => cards(child_posts, host:),
-          'sibling_posts' => sibling_posts.transform_keys(&:to_s).transform_values { |posts|
-            cards(posts, host:)
-          },
-          'related' => cards(related, host:))
-    else
+             sibling_posts: { }, related: []
     base(post, current_user).merge(
         'parent_posts' => cards(parent_posts),
         'child_posts' => cards(child_posts),
@@ -49,41 +35,22 @@ module PostRepr
         },
         'related' => cards(related))
   end
-  end
 
-  def card post, host: nil
-    if host.present?
-      common(post, host:).merge('parent_posts' => [], 'child_posts' => [])
-    else
+  def card post
     common(post).merge('parent_posts' => [], 'child_posts' => [])
   end
-  end
 
-  def cards posts, host: nil
-    if host.present?
-      posts.map { |post| card(post, host:) }
-    else
+  def cards posts
     posts.map { |post| card(post) }
   end
-  end
 
-  def many posts, current_user = nil, host: nil
-    if host.present?
-      posts.map { |p| base(p, current_user, host:) }
-    else
+  def many posts, current_user = nil
     posts.map { |p| base(p, current_user) }
   end
-  end
 
-  def common post, host: nil
+  def common post
     BASE_FIELDS.to_h { |field| [field.to_s, post.public_send(field)] }
-               .merge(
-                   'thumbnail' =>
-                       if host.present?
-                         thumbnail_url(post, host:)
-                       else
-                         thumbnail_url(post)
-                       end)
+               .merge('thumbnail' => thumbnail_url(post))
   end
 
   def tag_json post
@@ -98,19 +65,11 @@ module PostRepr
     }
   end
 
-  def thumbnail_url post, host: nil
+  def thumbnail_url post
     return nil unless post.thumbnail.attached?
 
-    options = { only_path: false }
-    options[:host] = host if host.present?
-
-    Rails.application.routes.url_helpers.rails_storage_proxy_url(post.thumbnail, **options)
-  rescue ActionController::UrlGenerationError, ArgumentError, URI::InvalidURIError => e
-    Rails.logger.warn(
-        "PostRepr.thumbnail_url failed post_id=#{post.id} " \
-        "attachment_id=#{post.thumbnail.attachment&.id} " \
-        "blob_id=#{post.thumbnail.blob&.id} " \
-        "error_class=#{e.class} message=#{e.message}")
+    Rails.application.routes.url_helpers.rails_blob_url(post.thumbnail, only_path: false)
+  rescue
     nil
   end
 end

backend/app/services/post_bulk_creator.rb

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

backend/app/services/post_create_plan.rb

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

backend/app/services/post_create_preflight.rb

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

backend/app/services/post_creator.rb

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

backend/app/services/post_import_previewer.rb

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

backend/app/services/post_metadata_fetcher.rb

@@ -1,199 +0,0 @@
-require 'time'
-require 'date'
-
-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: serialise_duration(duration),
-      display_tags: display_tags(platform_tags),
-      tags: platform_tags.join(' ') }
-  end
-
-  def self.platform_tags uri
-    return ['動画', 'YouTube'] if Preview::KnownSiteExtractor.youtube_video_id(uri)
-    return ['動画', 'ニコニコ'] if Preview::KnownSiteExtractor.niconico_video_id(uri)
-
-    []
-  end
-
-  def self.display_tags names
-    return [] if names.blank?
-
-    existing_tags =
-        Tag
-        .joins(:tag_name)
-        .where(tag_names: { name: names })
-        .index_by(&:name)
-
-    names.map { |name|
-      tag = existing_tags[name]
-      {
-          name: name,
-          category: (tag&.category || 'meta'),
-          section_literals: [] }
-    }
-  end
-
-  def self.original_created_range value
-    return nil if value.blank?
-
-    raw = value.to_s.strip
-    from, before =
-        case raw
-        when /\A(\d{4})\z/
-          year = Regexp.last_match(1).to_i
-          from = Time.zone.local(year, 1, 1)
-          [from, from + 1.year]
-        when /\A(\d{4})-(\d{2})\z/
-          year = Regexp.last_match(1).to_i
-          month = Regexp.last_match(2).to_i
-          return nil unless month.between?(1, 12)
-
-          from = Time.zone.local(year, month, 1)
-          [from, from + 1.month]
-        when /\A(\d{4})-(\d{2})-(\d{2})\z/
-          year = Regexp.last_match(1).to_i
-          month = Regexp.last_match(2).to_i
-          day = Regexp.last_match(3).to_i
-          return nil unless Date.valid_date?(year, month, day)
-
-          from = Time.zone.local(year, month, day)
-          [from, from + 1.day]
-        else
-          parse_timestamp_range(raw)
-        end
-    return nil if from.nil? || before.nil?
-
-    [from, before]
-  rescue ArgumentError, TypeError
-    nil
-  end
-
-  def self.parse_timestamp_range raw
-    match = raw.match(TIMESTAMP_PATTERN)
-    return nil unless match
-
-    year = match[1].to_i
-    month = match[2].to_i
-    day = match[3].to_i
-    hour = match[4].to_i
-    minute = match[5]&.to_i || 0
-    second = match[6]&.to_i || 0
-    fraction = match[7]
-    offset = match[8]
-    return nil unless valid_timestamp_components?(year, month, day, hour, minute, second)
-    return nil unless valid_offset?(offset)
-
-    nanoseconds = parse_nanoseconds(fraction)
-    timestamp =
-        if offset.present?
-          Time.new(
-              year,
-              month,
-              day,
-              hour,
-              minute,
-              second + Rational(nanoseconds, 1_000_000_000),
-              parse_offset(offset)).in_time_zone
-        else
-          Time.zone.local(year, month, day, hour, minute, second).change(nsec: nanoseconds)
-        end
-
-    from = timestamp.change(sec: 0, nsec: 0)
-    before =
-        if match[5].nil?
-          from + 1.hour
-        else
-          from + 1.minute
-        end
-    [from, before]
-  end
-
-  def self.parse_nanoseconds value
-    return 0 if value.blank?
-
-    digits = value[0, 9].ljust(9, '0')
-    Integer(digits, 10)
-  end
-
-  def self.parse_offset value
-    return '+00:00' if value == 'Z'
-
-    value.match?(/\A[+-]\d{2}:\d{2}\z/) ? value : "#{ value[0, 3] }:#{ value[3, 2] }"
-  end
-
-  def self.serialise_duration value
-    seconds = Float(value)
-    return nil unless seconds.positive?
-
-    milliseconds = (seconds * 1_000).round
-    seconds_string = (milliseconds / 1_000.0).to_s
-    seconds_string.end_with?('.0') ? seconds_string.delete_suffix('.0') : seconds_string
-  rescue ArgumentError, TypeError
-    nil
-  end
-
-  def self.valid_timestamp_components? year, month, day, hour, minute, second
-    return false unless Date.valid_date?(year, month, day)
-    return false unless hour.between?(0, 23)
-    return false unless minute.between?(0, 59)
-    return false unless second.between?(0, 59)
-
-    true
-  end
-
-  def self.valid_offset? value
-    return true if value.nil? || value == 'Z'
-
-    match = value.match(/\A([+-])(\d{2}):?(\d{2})\z/)
-    return false if match.nil?
-
-    hours = match[2].to_i
-    minutes = match[3].to_i
-    hours.between?(0, 23) && minutes.between?(0, 59)
-  end
-
-  def self.serialise_time value
-    return nil if value.nil?
-
-    value.nsec.zero? ? value.iso8601 : value.iso8601(9)
-  end
-
-  private_class_method :platform_tags,
-                       :display_tags,
-                       :original_created_range,
-                       :parse_timestamp_range,
-                       :parse_nanoseconds,
-                       :parse_offset,
-                       :serialise_duration,
-                       :valid_timestamp_components?,
-                       :valid_offset?,
-                       :serialise_time
-end

backend/app/services/post_thumbnail_attachment_builder.rb

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

backend/app/services/post_thumbnail_upload_validator.rb

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

backend/app/services/post_url_normaliser.rb

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

backend/app/services/preview/http_fetcher.rb

@@ -67,8 +67,7 @@ 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,15 +4,6 @@ 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'
@@ -23,8 +14,14 @@ module Preview
     end
 
     def self.youtube_thumbnail(uri)
-      id = youtube_video_id(uri)
-      return unless id
+      id =
+          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
+      return unless id&.match?(/\A[A-Za-z0-9_-]{6,20}\z/)
 
       "https://i.ytimg.com/vi/#{ id }/hqdefault.jpg"
     end

backend/app/services/preview/thumbnail_fetcher.rb

@@ -1,7 +1,7 @@
 module Preview
   class ThumbnailFetcher
     class GenerationFailed < StandardError; end
-    RASTER_IMAGE_CONTENT_TYPES = [
+    ALLOWED_IMAGE_CONTENT_TYPES = [
       'image/jpeg', 'image/png', 'image/gif', 'image/webp'
     ].freeze
     HTML_MAX_BYTES = 1.megabyte
@@ -25,24 +25,6 @@ module Preview
       fetch_image!(metadata[:image_url])
     end
 
-    def self.fetch_image_response(raw_url)
-      uri, = UrlSafety.validate(raw_url)
-      response = HttpFetcher.fetch(uri.to_s)
-      unless Post.remote_thumbnail_image_bytes?(
-                 response.body,
-                 content_type: response.content_type)
-        raise GenerationFailed, 'サムネール画像が見つかりませんでした．'
-      end
-
-      response
-    rescue HttpFetcher::FetchTimeout
-      raise
-    rescue HttpFetcher::ResponseTooLarge
-      raise
-    rescue HttpFetcher::FetchFailed
-      raise GenerationFailed, 'サムネール画像を取得できませんでした．'
-    end
-
     def self.title(raw_url)
       uri, = UrlSafety.validate(raw_url)
       HtmlMetadataExtractor.extract(
@@ -53,9 +35,7 @@ module Preview
       return nil if url.blank?
 
       response = HttpFetcher.fetch(url)
-      return nil unless Post.remote_thumbnail_image_bytes?(
-                            response.body,
-                            content_type: response.content_type)
+      return nil unless allowed_image_content_type?(response.content_type)
 
       response.body
     rescue HttpFetcher::FetchTimeout
@@ -65,7 +45,18 @@ module Preview
     end
 
     def self.fetch_image!(url)
-      fetch_image_response(url).body
+      response = HttpFetcher.fetch(url)
+      unless allowed_image_content_type?(response.content_type)
+        raise GenerationFailed, 'サムネール画像が見つかりませんでした．'
+      end
+
+      response.body
+    rescue HttpFetcher::FetchTimeout
+      raise
+    rescue HttpFetcher::ResponseTooLarge
+      raise
+    rescue HttpFetcher::FetchFailed
+      raise GenerationFailed, 'サムネール画像を取得できませんでした．'
     end
 
     def self.niconico_thumbnail_url(uri)
@@ -79,24 +70,26 @@ module Preview
 
       xml.at_xpath('//thumbnail_url')&.text&.strip.presence
     rescue HttpFetcher::FetchFailed, HttpFetcher::FetchTimeout => e
-      payload = {
-          url: uri.to_s,
+      Rails.logger.info("preview_niconico_getthumbinfo_fallback #{ { url: uri.to_s,
                                                                      video_id:,
                                                                      error: e.class.name,
-          message: e.message }
-      Rails.logger.info("preview_niconico_getthumbinfo_fallback #{ payload.to_json }")
+                                                                     message: e.message }.to_json }")
       nil
     rescue Nokogiri::XML::SyntaxError => e
-      payload = {
-          url: uri.to_s,
+      Rails.logger.info("preview_niconico_getthumbinfo_fallback #{ { url: uri.to_s,
                                                                      video_id:,
                                                                      error: e.class.name,
-          message: e.message }
-      Rails.logger.info("preview_niconico_getthumbinfo_fallback #{ payload.to_json }")
+                                                                     message: e.message }.to_json }")
       nil
     end
 
+    def self.allowed_image_content_type?(content_type)
+      mime_type = content_type.to_s.split(';', 2).first.downcase.strip
+      ALLOWED_IMAGE_CONTENT_TYPES.include?(mime_type)
+    end
+
     private_class_method :fetch_image_or_nil, :fetch_image!,
-                         :niconico_thumbnail_url
+                         :niconico_thumbnail_url,
+                         :allowed_image_content_type?
   end
 end

backend/app/services/youtube/sync.rb

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

backend/config/environments/development.rb

@@ -36,11 +36,7 @@ Rails.application.configure do
   config.action_mailer.perform_caching = false
 
   # Set localhost to be used by links generated in mailer templates.
-  config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }
-  Rails.application.routes.default_url_options.merge!(
-      host: 'localhost',
-      port: 3002,
-      protocol: 'http')
+  config.action_mailer.default_url_options = { host: "localhost", port: 3000 }
 
   # Print deprecation notices to the Rails logger.
   config.active_support.deprecation = :log

backend/config/routes.rb

@@ -52,8 +52,6 @@ Rails.application.routes.draw do
 
   resources :posts, only: [:index, :show, :create, :update] do
     collection do
-      get :metadata
-      post :bulk
       get :random
       get :changes
       get :versions, to: 'post_versions#index'

backend/db/migrate/20260713000000_create_post_url_sanitisation_rules.rb

@@ -1,61 +0,0 @@
-class CreatePostUrlSanitisationRules < ActiveRecord::Migration[8.0]
-  class PostUrlSanitisationRule < ActiveRecord::Base
-    self.table_name = 'post_url_sanitisation_rules'
-  end
-
-  def up
-    create_table :post_url_sanitisation_rules, id: :integer, primary_key: :priority do |t|
-      t.string :source_pattern, null: false
-      t.string :replacement, null: false
-      t.timestamps
-      t.datetime :discarded_at
-
-      t.index :source_pattern, unique: true
-      t.index :discarded_at
-    end
-
-    now = Time.current
-
-    PostUrlSanitisationRule.insert_all!([
-        { priority: 10,
-          source_pattern: '\Ahttps?://youtu\.be/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 20,
-          source_pattern: '\Ahttps?://(?:www\.|m\.)?youtube\.com/live/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 30,
-          source_pattern: '\Ahttps?://(?:www\.|m\.)?youtube\.com/shorts/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 40,
-          source_pattern: '\Ahttps?://(?:www\.|m\.)?youtube\.com/embed/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 50,
-          source_pattern:
-              '\Ahttps?://(?:www\.|m\.)?youtube\.com/watch\?(?:[^#&]+&)*v=([^&#]+)(?:[&#].*)?\z',
-          replacement: 'https://www.youtube.com/watch?v=\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 60,
-          source_pattern: '\Ahttps?://nico\.ms/([^/?#]+)(?:[?#].*)?\z',
-          replacement: 'https://www.nicovideo.jp/watch/\1',
-          created_at: now,
-          updated_at: now },
-        { priority: 70,
-          source_pattern: '\Ahttps?://(?:www\.)?nicovideo\.jp/watch/([^?#/]+)(?:[?#].*)?\z',
-          replacement: 'https://www.nicovideo.jp/watch/\1',
-          created_at: now,
-          updated_at: now }])
-  end
-
-  def down
-    drop_table :post_url_sanitisation_rules
-  end
-end

backend/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
+ActiveRecord::Schema[8.0].define(version: 2026_07_05_000000) do
   create_table "active_storage_attachments", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.string "name", null: false
     t.string "record_type", null: false
@@ -331,16 +331,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
     t.index ["tag_id"], name: "index_post_tags_on_tag_id"
   end
 
-  create_table "post_url_sanitisation_rules", primary_key: "priority", id: :integer, charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    t.string "source_pattern", null: false
-    t.string "replacement", null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.datetime "discarded_at"
-    t.index ["discarded_at"], name: "index_post_url_sanitisation_rules_on_discarded_at"
-    t.index ["source_pattern"], name: "index_post_url_sanitisation_rules_on_source_pattern", unique: true
-  end
-
   create_table "post_versions", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.bigint "post_id", null: false
     t.integer "version_no", null: false

backend/db/seeds.rb

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

backend/lib/tasks/sync_nico.rake

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

backend/spec/db/seeds_spec.rb

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

backend/spec/models/post_spec.rb

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

backend/spec/models/post_url_sanitisation_rule_spec.rb

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

backend/spec/requests/posts_spec.rb

@@ -9,11 +9,11 @@ RSpec.describe 'Posts API', type: :request do
   # resized_thumbnail! が MiniMagick 依存でコケやすいので request spec ではスタブしとくのが無難。
   before do
     allow_any_instance_of(Post).to receive(:resized_thumbnail!).and_return(true)
-    allow(Post).to receive(:resized_thumbnail_attachment) do
-      { io: StringIO.new('dummy'),
+    allow(Post).to receive(:resized_thumbnail_attachment).and_return(
+      io: StringIO.new('dummy'),
       filename: 'resized_thumbnail.jpg',
-        content_type: 'image/jpeg' }
-    end
+      content_type: 'image/jpeg'
+    )
   end
 
   def create_nico_tag!(name)
@@ -21,7 +21,8 @@ RSpec.describe 'Posts API', type: :request do
   end
 
   def dummy_upload
-    real_thumbnail_upload
+    # 中身は何でもいい（加工処理はスタブしてる）
+    Rack::Test::UploadedFile.new(StringIO.new('dummy'), 'image/jpeg', original_filename: 'dummy.jpg')
   end
 
   def real_thumbnail_upload
@@ -692,73 +693,6 @@ RSpec.describe 'Posts API', type: :request do
     end
   end
 
-  describe 'GET /posts/metadata' do
-    let(:member) { create(:user, :member) }
-
-    it 'returns compact existing post data without fetching external metadata' do
-      sign_in_as(member)
-      existing = create(
-          :post,
-          title: 'existing post',
-          url: 'https://example.com/existing')
-      existing.thumbnail.attach(
-          io: StringIO.new('thumbnail'),
-          filename: 'thumbnail.jpg',
-          content_type: 'image/jpeg')
-      expect(PostMetadataFetcher).not_to receive(:fetch)
-
-      get '/posts/metadata', params: { url: 'https://example.com/existing' }
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include(
-          'url' => existing.url,
-          'existing_post_id' => existing.id,
-          'field_warnings' => { })
-      expect(json.fetch('existing_post')).to include(
-          'id' => existing.id,
-          'title' => existing.title,
-          'url' => existing.url,
-          'thumbnail_base' => existing.thumbnail_base)
-      expect(json.dig('existing_post', 'thumbnail'))
-          .to include('/rails/active_storage/blobs/proxy/')
-    end
-
-    it 'returns fetched metadata and structured display tags' do
-      sign_in_as(member)
-      allow(Preview::UrlSafety).to receive(:validate)
-      allow(PostMetadataFetcher).to receive(:fetch).and_return(
-          title: 'fetched title',
-          thumbnail_base: 'https://example.com/thumbnail.jpg',
-          tags: 'character:虹夏',
-          display_tags: [{ name: '虹夏', category: 'character' }],
-          original_created_from: nil,
-          original_created_before: nil,
-          duration: '1:00',
-          video_ms: 60_000)
-
-      get '/posts/metadata', params: { url: 'https://example.com/new' }
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include(
-          'url' => 'https://example.com/new',
-          'title' => 'fetched title',
-          'duration' => '1:00',
-          'video_ms' => 60_000,
-          'field_warnings' => { })
-      expect(json.fetch('display_tags')).to eq(
-          [{ 'name' => '虹夏', 'category' => 'character' }])
-    end
-
-    it 'returns URL validation errors as 422' do
-      sign_in_as(member)
-
-      get '/posts/metadata', params: { url: 'file:///etc/passwd' }
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to have_key('url')
-    end
-  end
-
   describe 'POST /posts' do
     let(:member) { create(:user, :member) }
     let!(:alias_tag_name) { TagName.create!(name: 'manko', canonical: tag_name) }
@@ -778,46 +712,6 @@ RSpec.describe 'Posts API', type: :request do
       expect(response).to have_http_status(:forbidden)
     end
 
-    it 'dry-runs without persisting posts or new tags' do
-      sign_in_as(member)
-      counts = [Post.count, Tag.count, TagName.count]
-
-      post '/posts?dry=1', params: post_write_params(
-          title: 'dry-run post',
-          url: 'https://example.com/dry-run',
-          tags: 'character:new_dry_run_tag')
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include(
-          'url' => 'https://example.com/dry-run',
-          'tags' => 'new_dry_run_tag',
-          'existing_post_id' => nil)
-      expect(json.fetch('display_tags')).to eq(
-          [{ 'name' => 'new_dry_run_tag',
-             'category' => 'character',
-             'section_literals' => [] }])
-      expect([Post.count, Tag.count, TagName.count]).to eq(counts)
-    end
-
-    it 'dry-runs an existing URL without validating its upload' do
-      sign_in_as(member)
-      existing = create(:post, url: 'https://example.com/dry-existing')
-      invalid_upload = Rack::Test::UploadedFile.new(
-          StringIO.new('<svg></svg>'),
-          'image/png',
-          original_filename: 'thumbnail.png')
-
-      post '/posts?dry=1', params: post_write_params(
-          title: '',
-          url: existing.url,
-          tags: '',
-          thumbnail: invalid_upload)
-
-      expect(response).to have_http_status(:ok)
-      expect(json).to include('existing_post_id' => existing.id)
-      expect(json.fetch('field_warnings')).not_to have_key('thumbnail_base')
-    end
-
     it '201 and creates post + tags when member' do
       sign_in_as(member)
 
@@ -875,8 +769,7 @@ RSpec.describe 'Posts API', type: :request do
       )
 
       expect(response).to have_http_status(:created)
-      expect(open_transactions).to eq(
-          [baseline_open_transactions, baseline_open_transactions])
+      expect(open_transactions).to eq([baseline_open_transactions])
     end
 
     it 'returns 422 and does not create a post when thumbnail resize fails' do
@@ -934,7 +827,7 @@ RSpec.describe 'Posts API', type: :request do
 
       expect(response).to have_http_status(:unprocessable_entity)
       expect(json.fetch('errors')).to include(
-        'tags' => ['廃止済みタグがあります: deprecated_direct_tag']
+        'tags' => ['廃止済みタグは付与できません．']
       )
     end
 
@@ -1358,47 +1251,6 @@ RSpec.describe 'Posts API', type: :request do
     end
   end
 
-  describe 'POST /posts/bulk' do
-    let(:member) { create(:user, :member) }
-
-    it 'parses the manifest and indexed thumbnail parts' do
-      sign_in_as(member)
-      manifest = [{ 'url' => 'https://example.com/bulk',
-                    'title' => 'bulk post',
-                    'tags' => 'spec_tag',
-                    'parent_post_ids' => '' }]
-      creator = instance_double(
-          PostBulkCreator,
-          run: { results: [{ status: 'created', post: { id: 123 } }] })
-      allow(PostBulkCreator).to receive(:new).and_return(creator)
-
-      post '/posts/bulk', params: {
-          posts: JSON.generate(manifest),
-          thumbnails: { '0' => real_thumbnail_upload } }
-
-      expect(response).to have_http_status(:ok)
-      expect(json.fetch('results')).to eq(
-          [{ 'status' => 'created', 'post' => { 'id' => 123 } }])
-      expect(PostBulkCreator).to have_received(:new) do |arguments|
-        expect(arguments[:actor]).to eq(member)
-        expect(arguments[:posts]).to eq(manifest)
-        expect(arguments[:thumbnails].keys).to eq([0])
-        expect(arguments[:host]).to eq('http://www.example.com')
-      end
-    end
-
-    it 'rejects malformed manifests as a request-level error' do
-      sign_in_as(member)
-
-      post '/posts/bulk', params: {
-          posts: '{',
-          thumbnails: { '0' => real_thumbnail_upload } }
-
-      expect(response).to have_http_status(:bad_request)
-      expect(json.fetch('message')).to eq('posts manifest の JSON が不正です．')
-    end
-  end
-
   describe 'PUT /posts/:id' do
     let(:member) { create(:user, :member) }
 
@@ -2354,91 +2206,6 @@ RSpec.describe 'Posts API', type: :request do
 
       expect(response).to have_http_status(:unprocessable_entity)
     end
-
-    it 'rejects second-bearing original created timestamps on POST /posts' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-          title: 'invalid original created from',
-          url: 'https://example.com/invalid-original-created-from',
-          tags: 'spec_tag',
-          thumbnail: dummy_upload,
-          original_created_from: '2020-01-01T00:00:01Z')
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'original_created_from' => ['オリジナルの作成日時は分単位で入力してください．']
-      )
-      expect(json.fetch('errors')).not_to have_key('original_created_at')
-    end
-
-    it 'rejects fractional-second original created timestamps on POST /posts' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-          title: 'invalid original created before',
-          url: 'https://example.com/invalid-original-created-before',
-          tags: 'spec_tag',
-          thumbnail: dummy_upload,
-          original_created_before: '2020-01-01T00:00:00.123Z')
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'original_created_before' => ['オリジナルの作成日時は分単位で入力してください．']
-      )
-      expect(json.fetch('errors')).not_to have_key('original_created_at')
-    end
-
-    it 'rejects non-increasing original created ranges on POST /posts' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-          title: 'non-increasing original created range',
-          url: 'https://example.com/non-increasing-original-created-range',
-          tags: 'spec_tag',
-          thumbnail: dummy_upload,
-          original_created_from: '2020-01-01T00:00Z',
-          original_created_before: '2020-01-01T00:00Z')
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'original_created_at' => ['オリジナルの作成日時の順番がをかしぃです．']
-      )
-    end
-
-    it 'accepts original created ranges that are exactly one minute on POST /posts' do
-      sign_in_as(member)
-
-      post '/posts', params: post_write_params(
-          title: 'valid original created range',
-          url: 'https://example.com/valid-original-created-range',
-          tags: 'spec_tag',
-          thumbnail: dummy_upload,
-          original_created_from: '2020-01-01T00:00Z',
-          original_created_before: '2020-01-01T00:01Z')
-
-      expect(response).to have_http_status(:created)
-      expect(Time.iso8601(json.fetch('original_created_from')))
-          .to eq(Time.utc(2020, 1, 1, 0, 0))
-      expect(Time.iso8601(json.fetch('original_created_before')))
-          .to eq(Time.utc(2020, 1, 1, 0, 1))
-    end
-
-    it 'rejects unparseable original created timestamps on PUT /posts/:id' do
-      sign_in_as(member)
-      base_version = create_post_version_for!(post_record)
-
-      put "/posts/#{post_record.id}", params: post_write_params(
-          base_version_no: base_version.version_no,
-          title: 'updated title',
-          tags: 'spec_tag',
-          original_created_from: 'not-a-time')
-
-      expect(response).to have_http_status(:unprocessable_entity)
-      expect(json.fetch('errors')).to include(
-        'original_created_from' => ['オリジナルの作成日時の形式が不正です．']
-      )
-    end
   end
 
   describe 'tag versioning from post write actions' do

backend/spec/services/post_bulk_creator_spec.rb

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

backend/spec/services/post_create_plan_spec.rb

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

backend/spec/services/post_creator_spec.rb

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

backend/spec/services/post_import_previewer_spec.rb

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

backend/spec/services/post_metadata_fetcher_spec.rb

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

backend/spec/services/post_thumbnail_upload_validator_spec.rb

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

backend/spec/services/post_url_normaliser_spec.rb

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

backend/spec/services/preview/thumbnail_fetcher_spec.rb

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

backend/spec/services/youtube/sync_spec.rb

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

backend/spec/tasks/nico_export_spec.rb

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

backend/spec/tasks/nico_sync_spec.rb

@@ -18,11 +18,7 @@ RSpec.describe "nico:sync" do
 
   it "既存 post を見つけて、nico tag と linked tag を追加し、差分が出たら bot を付ける" do
     # 既存 post（正規表現で拾われるURL）
-    post = Post.create!(
-      title: "old",
-      url: "https://www.nicovideo.jp/watch/sm9",
-      uploaded_user: nil
-    )
+    post = Post.create!(title: "old", url: "https://www.nicovideo.jp/watch/sm9", uploaded_user: nil)
 
     # 既存の非nicoタグ（kept_non_nico_ids）
     kept_general = create_tag!("spec_kept", category: "general")
@@ -64,56 +60,8 @@ RSpec.describe "nico:sync" do
     expect(active_tag_names).to include("bot操作")
   end
 
-  it '既存 post のサムネール取得に共通 attach 経路を使ふ' do
-    post = Post.create!(
-        title: 'old',
-        url: 'https://www.nicovideo.jp/watch/sm9',
-        uploaded_user: nil)
-    Tag.bot
-    Tag.tagme
-
-    stub_python([{ 'code' => 'sm9', 'title' => 't', 'tags' => [] }])
-    allow(URI).to receive(:open) do
-      StringIO.new(
-          '<meta name="thumbnail" content="https://example.com/thumb.jpg">')
-    end
-    expect_any_instance_of(Post).to receive(:attach_thumbnail_from_url!)
-        .with('https://example.com/thumb.jpg')
-
-    run_rake_task('nico:sync')
-  end
-
-  it 'サムネール取得失敗後も次回同期で再試行できる' do
-    post = Post.create!(
-        title: 'old',
-        url: 'https://www.nicovideo.jp/watch/sm9',
-        uploaded_user: nil)
-    Tag.bot
-    Tag.tagme
-
-    stub_python([{ 'code' => 'sm9', 'title' => 't', 'tags' => [] }])
-    allow(URI).to receive(:open) do
-      StringIO.new(
-          '<meta name="thumbnail" content="https://example.com/thumb.jpg">')
-    end
-    calls = 0
-    allow_any_instance_of(Post).to receive(:attach_thumbnail_from_url!) do
-      calls += 1
-      raise Post::RemoteThumbnailFetchFailed, 'failed'
-    end
-
-    2.times do
-      run_rake_task('nico:sync')
-    end
-    expect(calls).to eq(2)
-  end
-
   it "既存 post にあった古い nico tag は active から外され、履歴として discard される" do
-    post = Post.create!(
-      title: "old",
-      url: "https://www.nicovideo.jp/watch/sm9",
-      uploaded_user: nil
-    )
+    post = Post.create!(title: "old", url: "https://www.nicovideo.jp/watch/sm9", uploaded_user: nil)
 
     # 旧nicoタグ（今回の同期結果に含まれない）
     old_nico = create_tag!("nico:OLD", category: "nico")

frontend/AGENTS.md

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

frontend/src/App.tsx

@@ -1,9 +1,8 @@
 import { AnimatePresence, LayoutGroup, MotionConfig, motion } from 'framer-motion'
 import { Fragment, useEffect, useMemo, useState } from 'react'
-import { createBrowserRouter,
+import { BrowserRouter,
 	 Navigate,
 	 Route,
-	 RouterProvider,
 	 Routes,
 	 useLocation } from 'react-router-dom'
 
@@ -42,8 +41,8 @@ import NotFound from '@/pages/NotFound'
 import TOSPage from '@/pages/TOSPage.mdx'
 import PostDetailPage from '@/pages/posts/PostDetailPage'
 import PostHistoryPage from '@/pages/posts/PostHistoryPage'
-import PostNewPage from '@/pages/posts/PostNewPage'
 import PostListPage from '@/pages/posts/PostListPage'
+import PostNewPage from '@/pages/posts/PostNewPage'
 import PostSearchPage from '@/pages/posts/PostSearchPage'
 import ServiceUnavailable from '@/pages/ServiceUnavailable'
 import SettingPage from '@/pages/users/SettingPage'
@@ -155,7 +154,7 @@ const PostDetailRoute = ({ user }: { user: User | null }) => {
 }
 
 
-const RoutedApp: FC = () => {
+const App: FC = () => {
   const [user, setUser] = useState<User | null> (null)
   const [status, setStatus] = useState (200)
   const behaviourSettings = useClientBehaviourSettings ()
@@ -254,6 +253,11 @@ const RoutedApp: FC = () => {
   }
 
   return (
+      <>
+	<RouteBlockerOverlay/>
+	{import.meta.env.DEV && <DevModeWatermark/>}
+
+	<BrowserRouter>
 	  <DialogueProvider>
 	    <UnsavedChangesGuardProvider>
 	      <KeyboardShortcutsProvider>
@@ -269,7 +273,7 @@ const RoutedApp: FC = () => {
 		  <motion.div
 		      layout={animationMode === 'off' ? false : 'position'}
 		      transition={{ layout: appLayoutTransition }}
-		  className="relative flex h-dvh w-full flex-col overflow-y-hidden">
+		      className="relative flex flex-col h-dvh w-full overflow-y-hidden">
 		    <TopNav user={user}/>
 		    <RouteTransitionWrapper
 			animationMode={animationMode}
@@ -282,18 +286,9 @@ const RoutedApp: FC = () => {
 	      <Toaster/>
 	      </KeyboardShortcutsProvider>
 	    </UnsavedChangesGuardProvider>
-      </DialogueProvider>)
+	  </DialogueProvider>
+	</BrowserRouter>
+      </>)
 }
 
-const router = createBrowserRouter ([{
-    path: '*',
-    element: <RoutedApp/> }])
-
-const App: FC = () => (
-    <>
-      <RouteBlockerOverlay/>
-      {import.meta.env.DEV && <DevModeWatermark/>}
-      <RouterProvider router={router}/>
-    </>)
-
 export default App

frontend/src/components/PostEditForm.test.tsx

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

frontend/src/components/PostEditForm.tsx

@@ -1,16 +1,15 @@
 import { useEffect, useMemo, useState } from 'react'
 
+import PostFormTagsArea from '@/components/PostFormTagsArea'
 import PostOriginalCreatedTimeField from '@/components/PostOriginalCreatedTimeField'
 import FieldError from '@/components/common/FieldError'
-import PostDurationField from '@/components/posts/PostDurationField'
-import PostTagsField from '@/components/posts/PostTagsField'
-import PostTextField from '@/components/posts/PostTextField'
+import FormField from '@/components/common/FormField'
+import { useDialogue } from '@/components/dialogues/DialogueProvider'
 import { Button } from '@/components/ui/button'
 import { toast } from '@/components/ui/use-toast'
 import { isApiError } from '@/lib/api'
-import useDialogue from '@/lib/dialogues/useDialogue'
 import { updatePost } from '@/lib/posts'
-import { msToTime } from '@/lib/utils'
+import { inputClass, msToTime } from '@/lib/utils'
 import { useValidationErrors } from '@/lib/useValidationErrors'
 
 import type { FC, FormEvent } from 'react'
@@ -18,11 +17,7 @@ import type { FC, FormEvent } from 'react'
 import type { Post, TagWithSections } from '@/types'
 
 type PostFormField =
-    'parentPostIds' | 'tags' | 'videoMs'
-    | 'originalCreatedAt' | 'originalCreatedFrom' | 'originalCreatedBefore'
-
-const groupedMessages = (...values: (string[] | undefined)[]): string[] =>
-    [...new Set (values.flatMap (value => value ?? []))]
+    'parentPostIds' | 'tags' | 'videoMs' | 'originalCreatedAt'
 
 const videoMsToDurationValue = (videoMs: number | null): string =>
     videoMs == null ? '' : String (videoMs / 1_000)
@@ -162,20 +157,32 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
       <form onSubmit={handleSubmit} className="max-w-xl pt-2 space-y-4">
 	<FieldError messages={baseErrors}/>
 
-	<PostTextField
-	    label="タイトル"
+	{/* タイトル */}
+	<FormField label="タイトル">
+	  {({ invalid }) => (
+	      <input
+		  type="text"
+		  disabled={disabled}
+		  className={inputClass (invalid)}
 		  value={title ?? ''}
-	    disabled={disabled}
-	    onChange={setTitle}/>
+		  onChange={e => setTitle (e.target.value)}/>)}
+	</FormField>
 
-	<PostTextField
-	    label="親投稿"
+	{/* 親投稿 */}
+	<FormField label="親投稿" messages={fieldErrors.parentPostIds}>
+	  {({ describedBy, invalid }) => (
+	      <input
+		  type="text"
+		  disabled={disabled}
 		  value={parentPostIds}
-	    disabled={disabled}
-	    errors={fieldErrors.parentPostIds}
-	    onChange={setParentPostIds}/>
+		  onChange={e => setParentPostIds (e.target.value)}
+		  aria-describedby={describedBy}
+		  aria-invalid={invalid}
+		  className={inputClass (invalid)}/>)}
+	</FormField>
 
-	<PostTagsField
+	{/* タグ */}
+	<PostFormTagsArea
 	    disabled={disabled}
 	    tags={tags}
 	    setTags={setTags}
@@ -188,17 +195,21 @@ const PostEditForm: FC<Props> = ({ post, onSave }) => {
 	    setOriginalCreatedFrom={setOriginalCreatedFrom}
 	    originalCreatedBefore={originalCreatedBefore}
 	    setOriginalCreatedBefore={setOriginalCreatedBefore}
-	    errors={groupedMessages (
-		fieldErrors.originalCreatedAt,
-		fieldErrors.originalCreatedFrom,
-		fieldErrors.originalCreatedBefore)}/>
+	    errors={fieldErrors.originalCreatedAt}/>
 
+	{/* 動画時間 */}
 	{videoFlg && (
-	    <PostDurationField
-		value={duration}
+	    <FormField label="動画時間" messages={fieldErrors.videoMs}>
+	      {({ invalid }) => (
+		  <input
+		      type="number"
+		      min="0.001"
+		      step="0.001"
 		      disabled={disabled}
-		errors={fieldErrors.videoMs}
-		onChange={setDuration}/>)}
+		      className={inputClass (invalid)}
+		      value={duration}
+		      onChange={e => setDuration (e.target.value)}/>)}
+	    </FormField>)}
 
 	{/* 送信 */}
 	<Button type="submit" disabled={disabled}>

frontend/src/components/PostOriginalCreatedTimeField.test.tsx

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

frontend/src/components/PostOriginalCreatedTimeField.tsx

@@ -1,4 +1,4 @@
-import DateTimeField, { toMinutePrecisionIsoUtc } from '@/components/common/DateTimeField'
+import DateTimeField from '@/components/common/DateTimeField'
 import FormField from '@/components/common/FormField'
 import { Button } from '@/components/ui/button'
 
@@ -19,8 +19,7 @@ const PostOriginalCreatedTimeField: FC<Props> = (
       setOriginalCreatedFrom,
       originalCreatedBefore,
       setOriginalCreatedBefore,
-      errors }: Props) => {
-  return (
+      errors }: Props) => (
     <FormField label="オリジナルの作成日時" messages={errors}>
       {({ describedBy, invalid }) => (
 	  <>
@@ -44,13 +43,12 @@ const PostOriginalCreatedTimeField: FC<Props> = (
 			d.setDate (d.getDate () + 1)
 		      else
 			d.setMinutes (d.getMinutes () + 1)
-			  setOriginalCreatedBefore (toMinutePrecisionIsoUtc (d.toISOString ()))
+		      setOriginalCreatedBefore (d.toISOString ())
 		    }}/>
 		以降
 	      </div>
 	      <div>
 		<Button
-			type="button"
 		    className="bg-gray-600 text-white rounded"
 		    disabled={disabled}
 		    onClick={() => {
@@ -75,7 +73,6 @@ const PostOriginalCreatedTimeField: FC<Props> = (
 	      </div>
 	      <div>
 		<Button
-			type="button"
 		    className="bg-gray-600 text-white rounded"
 		    disabled={disabled}
 		    onClick={() => {
@@ -87,6 +84,5 @@ const PostOriginalCreatedTimeField: FC<Props> = (
 	    </div>
 	  </>)}
     </FormField>)
-}
 
 export default PostOriginalCreatedTimeField

frontend/src/components/PrefetchLink.tsx

@@ -6,6 +6,7 @@ import { createPath, useNavigate } from 'react-router-dom'
 import { useOverlayStore } from '@/components/RouteBlockerOverlay'
 import { prefetchForURL } from '@/lib/prefetchers'
 import { useClientBehaviourSettings } from '@/lib/useClientBehaviourSettings'
+import { useUnsavedChangesGuard } from '@/lib/useUnsavedChangesGuard'
 import { cn } from '@/lib/utils'
 
 import type { AnchorHTMLAttributes, MouseEvent, TouchEvent } from 'react'
@@ -35,6 +36,7 @@ export default forwardRef<HTMLAnchorElement, Props> (({
   const navigate = useNavigate ()
   const qc = useQueryClient ()
   const behaviourSettings = useClientBehaviourSettings ()
+  const { confirmDiscardNavigation } = useUnsavedChangesGuard ()
   const linkPreloadMode = behaviourSettings.linkPreload ?? 'intent'
   const path = useMemo (
       () => typeof to === 'string' ? to : createPath (to),
@@ -43,6 +45,10 @@ export default forwardRef<HTMLAnchorElement, Props> (({
   const url = useMemo (() => {
     return (new URL (path, window.location.origin)).toString ()
   }, [path])
+  const nextPathname = useMemo (
+      () => (new URL (path, window.location.origin)).pathname,
+      [path],
+  )
   const setOverlay = useOverlayStore (s => s.setActive)
 
   const doPrefetch = async () => {
@@ -87,6 +93,13 @@ export default forwardRef<HTMLAnchorElement, Props> (({
 
       ev.preventDefault ()
 
+      if (nextPathname !== window.location.pathname)
+	{
+	  const confirmed = await confirmDiscardNavigation ()
+	  if (!(confirmed))
+	    return
+	}
+
       flushSync (() => {
 	setOverlay (true)
       })

frontend/src/components/TagLink.tsx

@@ -4,13 +4,9 @@ import { cn } from '@/lib/utils'
 
 import type { ComponentProps, CSSProperties, FC, HTMLAttributes } from 'react'
 
-import type { Category, Tag } from '@/types'
+import type { Tag } from '@/types'
 
-type LightweightTag = {
-    name:     string
-    category: Category }
-
-type FullCommonProps = {
+type CommonProps = { 
     tag:        Tag
     nestLevel?: number
     truncateOnMobile?: boolean
@@ -18,43 +14,18 @@ type FullCommonProps = {
     withCount?: boolean }
 
 type PropsWithLink =
-    & FullCommonProps
+    & CommonProps
     & { linkFlg?: true }
     & Partial<ComponentProps<typeof PrefetchLink>>
 
 type PropsWithoutLink =
-    & FullCommonProps
+    & CommonProps
     & { linkFlg: false }
     & Partial<HTMLAttributes<HTMLSpanElement>>
 
-type LightweightPropsWithLink =
-    & {
-	tag:              LightweightTag
-	nestLevel?:       number
-	truncateOnMobile?: boolean
-	withWiki:         false
-	withCount:        false
-	linkFlg?:         true }
-    & Partial<ComponentProps<typeof PrefetchLink>>
-
-type LightweightPropsWithoutLink =
-    & {
-	tag:              LightweightTag
-	nestLevel?:       number
-	truncateOnMobile?: boolean
-	withWiki:         false
-	withCount:        false
-	linkFlg:          false }
-    & Partial<HTMLAttributes<HTMLSpanElement>>
-
 type Props =
     | PropsWithLink
     | PropsWithoutLink
-    | LightweightPropsWithLink
-    | LightweightPropsWithoutLink
-
-const isFullTag = (tag: Tag | LightweightTag): tag is Tag =>
-    'id' in tag
 
 
 const TagLink: FC<Props> = ({ tag,
@@ -79,13 +50,12 @@ const TagLink: FC<Props> = ({ tag,
       'inline-flex min-w-0 max-w-full flex-nowrap items-stretch align-baseline gap-x-1 md:items-baseline'
   const markerWrapClass = 'shrink-0 self-start md:self-auto'
   const countClass = 'shrink-0 self-end md:self-auto'
-  const matchedAlias = isFullTag (tag) ? tag.matchedAlias : null
   const textTitle = title
-      ?? (matchedAlias == null ? tag.name : `${ matchedAlias } → ${ tag.name }`)
+      ?? (tag.matchedAlias == null ? tag.name : `${ tag.matchedAlias } → ${ tag.name }`)
 
   return (
       <span className={rootClass}>
-	{(linkFlg && withWiki && isFullTag (tag)) && (
+	{(linkFlg && withWiki) && (
 	    <span className={markerWrapClass}>
 	      {(tag.materialId != null || tag.hasWiki || tag.hasDeerjikists)
 	       ? (
@@ -148,7 +118,7 @@ const TagLink: FC<Props> = ({ tag,
 		style={{ paddingLeft: `${ (nestLevel - 1) }rem` }}>
 	      ↳
 	    </span>)}
-	{matchedAlias != null && (
+	{tag.matchedAlias != null && (
 	    <>
 	      <span
 		  title={textTitle}
@@ -156,7 +126,7 @@ const TagLink: FC<Props> = ({ tag,
 		  style={colourStyle}
 		  {...props}>
 		<ResponsiveMarqueeText
-		    text={matchedAlias}
+		    text={tag.matchedAlias}
 		    title={textTitle}
 		    truncateOnMobile={truncateOnMobile}/>
 	      </span>
@@ -186,7 +156,7 @@ const TagLink: FC<Props> = ({ tag,
 		  title={textTitle}
 		  truncateOnMobile={truncateOnMobile}/>
 	    </span>)}
-	{(withCount && isFullTag (tag)) && (
+	{withCount && (
 	    <span className={countClass}>{tag.postCount}</span>)}
       </span>)
 }

frontend/src/components/TopNav.test.tsx

@@ -1,39 +0,0 @@
-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 (entry => entry.name === section)?.subMenu.find (
-      subMenuItem => subMenuItem.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, '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', 'Wiki', '新規')?.visible).toBe (false)
-    expect (submenuItem ('guest', 'Wiki', '編輯')?.visible).toBe (false)
-  })
-
-  it ('uses /posts/new as the post creation entrypoint', () => {
-    expect (submenuItem ('member', '広場', '追加')?.to).toBe ('/posts/new')
-  })
-
-  it ('keeps material suppression admin-only', () => {
-    expect (submenuItem ('member', '素材', '抑止')?.visible).toBe (false)
-    expect (submenuItem ('admin', '素材', '抑止')?.visible).toBe (true)
-  })
-})

frontend/src/components/TopNav.tsx

@@ -9,7 +9,6 @@ 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'
@@ -27,11 +26,10 @@ 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] ?? ''
@@ -44,7 +42,7 @@ export const menuOutline = (
       { name: '広場', to: '/posts', subMenu: [
 	  { name: '一覧', to: '/posts' },
 	  { name: '検索', to: '/posts/search' },
-	  { name: '追加', to: '/posts/new', visible: editable },
+	  { name: '追加', to: '/posts/new' },
 	  { name: '全体履歴', to: '/posts/changes' },
 	  { name: 'ヘルプ', to: '/wiki/ヘルプ:広場' }] },
       { name: 'タグ', to: '/tags', subMenu: [
@@ -60,9 +58,8 @@ export const menuOutline = (
 	    visible: tagFlg && tag?.category !== 'nico' }] },
       { name: '素材', to: '/materials', visible: true, subMenu: [
 	  { name: '一覧', to: '/materials' },
-	  { name: '追加', to: '/materials/new', visible: editable },
-	  { name: '抑止', to: '/materials/suppressions',
-	    visible: user?.role === 'admin' },
+	  { name: '追加', to: '/materials/new' },
+	  { name: '抑止', to: '/materials/suppressions' },
 	  { name: '全体履歴', to: '/materials/changes' },
 	  { name: 'ヘルプ', to: '/wiki/ヘルプ:素材管理' },
 	  { component: <Separator/>, visible: materialFlg },
@@ -73,15 +70,14 @@ export const menuOutline = (
 	    visible: materialFlg }] },
       { name: 'Wiki', to: '/wiki/ヘルプ:ホーム', base: '/wiki', subMenu: [
 	  { name: '検索', to: '/wiki' },
-	  { name: '新規', to: '/wiki/new', visible: editable },
+	  { name: '新規', to: '/wiki/new' },
 	  { 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 && editable }] },
+	  { name: '編輯', to: `/wiki/${ wikiId || wikiTitle }/edit`, visible: wikiPageFlg }] },
       { name: 'おたのしみ', visible: false, subMenu: [
 	  { name: '上映会 (β)', to: '/theatres/1' },
 	  { name: 'グカネータ (β)', to: '/gekanator' }] },

frontend/src/components/common/DateTimeField.test.tsx

@@ -21,8 +21,7 @@ describe ('DateTimeField', () => {
     fireEvent.change (input, { target: { value: '' } })
 
     const first = handleChange.mock.calls[0]?.[0]
-    expect (first).toMatch (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/)
-    expect (new Date (first).getUTCSeconds ()).toBe (0)
+    expect (new Date (first).getFullYear ()).toBe (2026)
     expect (handleChange).toHaveBeenLastCalledWith (null)
   })
 })

frontend/src/components/common/DateTimeField.tsx

@@ -8,27 +8,13 @@ import type { ComponentPropsWithoutRef, FC, FocusEvent } from 'react'
 const pad = (n: number): string => n.toString ().padStart (2, '0')
 
 
-const toDateTimeLocalValue = (value: Date) => {
-  const y = value.getFullYear ()
-  const m = pad (value.getMonth () + 1)
-  const day = pad (value.getDate ())
-  const h = pad (value.getHours ())
-  const min = pad (value.getMinutes ())
-  return `${ y }-${ m }-${ day }T${ h }:${ min }`
-}
-
-
-const toMinutePrecisionIsoUtc = (value: string) => {
-  const date = new Date (value)
-  if (Number.isNaN (date.getTime ()))
-    return value
-
-  const y = date.getUTCFullYear ()
-  const m = pad (date.getUTCMonth () + 1)
-  const day = pad (date.getUTCDate ())
-  const h = pad (date.getUTCHours ())
-  const min = pad (date.getUTCMinutes ())
-  return `${ y }-${ m }-${ day }T${ h }:${ min }Z`
+const toDateTimeLocalValue = (d: Date) => {
+  const y = d.getFullYear ()
+  const m = pad (d.getMonth () + 1)
+  const day = pad (d.getDate ())
+  const h = pad (d.getHours ())
+  const min = pad (d.getMinutes ())
+  return `${ y }-${ m }-${ day }T${ h }:${ min }:00`
 }
 
 
@@ -61,16 +47,14 @@ const DateTimeField: FC<Props> = ({ value, onChange, className, onBlur, invalid,
 			     'focus:ring-2 focus:ring-blue-200']),
 			 className)}
 	  type="datetime-local"
-	  step={60}
 	  value={local}
 	  aria-invalid={invalid}
 	  onChange={ev => {
 	    const v = ev.target.value
 	    setLocal (v)
-	    onChange?.(v ? toMinutePrecisionIsoUtc (v) : null)
+	    onChange?.(v ? (new Date (v)).toISOString () : null)
 	  }}
 	  onBlur={onBlur}/>)
 }
 
 export default DateTimeField
-export { toMinutePrecisionIsoUtc }

frontend/src/components/common/FieldWarning.tsx

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

frontend/src/components/common/StatusBadge.tsx

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

@@ -1,116 +0,0 @@
-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',
-	'md: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 { useCallback, useMemo, useRef, useState } from 'react'
+import { createContext, useCallback, useContext, useMemo, useState } from 'react'
 
 import { Button } from '@/components/ui/button'
 import { Dialog,
@@ -7,16 +7,29 @@ import { Dialog,
 	 DialogFooter,
 	 DialogHeader,
 	 DialogTitle } from '@/components/ui/dialog'
-import { DialogueContext } from '@/lib/dialogues/useDialogue'
 
 import type { FC, ReactNode } from 'react'
-import type { AlertOptions,
-	      ChoiceOptions,
-	      ConfirmOptions,
-	      DialogueAPI,
-	      DialogueFormAction,
-	      DialogueFormControls,
-	      DialogueFormOptions } from '@/lib/dialogues/useDialogue'
+
+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 DialogueRequest =
     | { id:       number
@@ -31,10 +44,13 @@ type DialogueRequest =
 	kind:     'choice'
 	options:  ChoiceOptions<string>
 	resolve:  (value: string | null) => void }
-    | { id:       number
-	kind:     'form'
-	options:  DialogueFormOptions
-	resolve:  () => void }
+
+type DialogueAPI =
+    { confirm:  (options: ConfirmOptions) => Promise<boolean>
+      alert:    (options: AlertOptions) => Promise<void>
+      choice:   <T extends string> (options: ChoiceOptions<T>) => Promise<T | null> }
+
+const DialogueContext = createContext<DialogueAPI | null> (null)
 
 let nextDialogueId = 1
 
@@ -43,27 +59,20 @@ 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 (current => [...current, { ...request, id } as DialogueRequest])
+    setQueue (q => [...q, { ...request, id } as DialogueRequest])
   }, [])
 
-  const closeRequest = useCallback ((id: number, result?: unknown) => {
-    setQueue (current => {
-      const active = current.find (request => request.id === id)
+  const closeActive = useCallback ((result?: unknown) => {
+    setQueue (q => {
+      const [active, ...rest] = q
 
-      if (active == null)
-	return current
+      if (!(active))
+	return rest
 
       switch (active.kind)
       {
@@ -78,43 +87,10 @@ const DialogueProvider: FC<Props> = ({ children }) => {
       case 'choice':
 	active.resolve ((result ?? null) as string | null)
 	break
-
-      case 'form':
-	active.resolve ()
-	break
       }
 
-      return current.filter (request => request.id !== id)
-    })
-    setPendingIds (current => current.filter (pendingId => pendingId !== 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
-    })
   }, [])
 
   const api = useMemo<DialogueAPI> (() => ({
@@ -127,139 +103,22 @@ 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 })
-      }),
-      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 (pendingId => pendingId !== id))
-	}
-      },
-      [closeRequest, pendingIds])
+		resolve: resolve as (value: string | null) => void })}) }), [push])
 
   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}
 
-	{active && (
 	<Dialog
-		open
+	    open={Boolean (active)}
 	    onOpenChange={open => {
-		  const blocked =
-		      nestedConfirm?.parentId === active.id
-		      || pendingIds.includes (active.id)
-		  if (!(open) && !(blocked))
-		    closeRequest (active.id, active.kind !== 'confirm' && null)
+	      if (!(open))
+		closeActive (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
-				      md:flex-row md:justify-between md:gap-0 md:space-x-0">
-			 <div className="flex w-full flex-col gap-2 md:w-auto md:flex-row">
-			   {startActions.map (action => (
-			       <Button
-				   key={action.label}
-				   className="w-full md: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 md:w-auto md:flex-row">
-			   <Button
-			       className="w-full md: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 md: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>
-		     </>)
-		 : (
-		     <>
+	  {active && (
+	      <DialogContent className="px-6 pb-6 pt-7">
 		<DialogHeader className="pl-8">
 		  <DialogTitle>{active.options.title}</DialogTitle>
 
@@ -274,7 +133,7 @@ const DialogueProvider: FC<Props> = ({ children }) => {
 		      <>
 			<Button
 			    variant="outline"
-				   onClick={() => closeRequest (active.id, false)}>
+			    onClick={() => closeActive (false)}>
 			  {active.options.cancelText ?? '取消'}
 			</Button>
 
@@ -282,13 +141,13 @@ const DialogueProvider: FC<Props> = ({ children }) => {
 			    variant={(active.options.variant === 'danger')
 				     ? 'destructive'
 				     : 'default'}
-				   onClick={() => closeRequest (active.id, true)}>
+			    onClick={() => closeActive (true)}>
 			  {active.options.confirmText ?? '確定'}
 			</Button>
 		      </>)}
 
 		  {active.kind === 'alert' && (
-			     <Button onClick={() => closeRequest (active.id)}>
+		      <Button onClick={() => closeActive ()}>
 			{active.options.okText ?? '確定'}
 		      </Button>)}
 
@@ -296,7 +155,7 @@ const DialogueProvider: FC<Props> = ({ children }) => {
 		      <>
 			<Button
 			    variant="outline"
-				   onClick={() => closeRequest (active.id, null)}>
+			    onClick={() => closeActive (null)}>
 			  {active.options.cancelText ?? '取消'}
 			</Button>
 
@@ -306,50 +165,24 @@ const DialogueProvider: FC<Props> = ({ children }) => {
 				variant={(choice.variant === 'danger')
 					 ? 'destructive'
 					 : 'default'}
-				       onClick={() => closeRequest (active.id, choice.value)}>
+				onClick={() => closeActive (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>{nestedConfirm.options.title}</DialogTitle>
-
-		  {nestedConfirm.options.description && (
-		      <DialogDescription asChild>
-			<div>{nestedConfirm.options.description}</div>
-		      </DialogDescription>)}
-		</DialogHeader>
-
-		<DialogFooter>
-		  <Button
-		      variant="outline"
-		      onClick={() => closeNestedConfirm (false)}>
-		    {nestedConfirm.options.cancelText ?? '取消'}
-		  </Button>
-
-		  <Button
-		      variant={nestedConfirm.options.variant === 'danger'
-			  ? 'destructive'
-			  : 'default'}
-		      onClick={() => closeNestedConfirm (true)}>
-		    {nestedConfirm.options.confirmText ?? '確定'}
-		  </Button>
-		</DialogFooter>
-	      </DialogContent>
-	    </Dialog>)}
+	      </DialogContent>)}
+	</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/PostCoreDataFields.tsx

@@ -1,94 +0,0 @@
-import PostOriginalCreatedTimeField from '@/components/PostOriginalCreatedTimeField'
-import PostTagsField from '@/components/posts/PostTagsField'
-import PostTextField from '@/components/posts/PostTextField'
-
-import type { FC, ReactNode } from 'react'
-
-type TextMessages = string[] | undefined
-
-type CoreField = {
-  value:    string
-  onChange: (value: string) => void
-  errors?:  TextMessages
-  warnings?: TextMessages
-  disabled?: boolean }
-
-type OriginalCreatedField = {
-  originalCreatedAt?:     TextMessages
-  originalCreatedFrom?:   TextMessages
-  originalCreatedBefore?: TextMessages }
-
-type PostCoreDataFieldsProps = {
-  title: {
-    value:     string
-    onChange:  (value: string) => void
-    errors?:   TextMessages
-    warnings?: TextMessages
-    disabled?: boolean
-    after?:    ReactNode }
-  originalCreated: {
-    disabled?:                boolean
-    originalCreatedFrom:      string | null
-    setOriginalCreatedFrom:   (value: string | null) => void
-    originalCreatedBefore:    string | null
-    setOriginalCreatedBefore: (value: string | null) => void
-    errors?:                  OriginalCreatedField }
-  tags: {
-    value:     string
-    onChange:  (value: string) => void
-    errors?:   TextMessages
-    warnings?: TextMessages
-    disabled?: boolean
-    rows?:     number }
-  parentPostIds: CoreField }
-
-const groupedMessages = (...values: (TextMessages | null | undefined)[]): string[] =>
-    [...new Set (values.flatMap (value => value ?? []))]
-
-
-const PostCoreDataFields: FC<PostCoreDataFieldsProps> = (
-    { title,
-      originalCreated,
-      tags,
-      parentPostIds },
-) => (
-    <>
-      <PostTextField
-          label="タイトル"
-          value={title.value}
-          disabled={title.disabled}
-          warnings={title.warnings}
-          errors={title.errors}
-          after={title.after}
-          onChange={title.onChange}/>
-
-      <PostOriginalCreatedTimeField
-          disabled={originalCreated.disabled}
-          originalCreatedFrom={originalCreated.originalCreatedFrom}
-          setOriginalCreatedFrom={originalCreated.setOriginalCreatedFrom}
-          originalCreatedBefore={originalCreated.originalCreatedBefore}
-          setOriginalCreatedBefore={originalCreated.setOriginalCreatedBefore}
-          errors={groupedMessages (
-              originalCreated.errors?.originalCreatedAt,
-              originalCreated.errors?.originalCreatedFrom,
-              originalCreated.errors?.originalCreatedBefore)}/>
-
-      <PostTagsField
-          tags={tags.value}
-          disabled={tags.disabled}
-          setTags={tags.onChange}
-          warnings={tags.warnings}
-          errors={tags.errors}
-          rows={tags.rows}/>
-
-      <PostTextField
-          label="親投稿"
-          value={parentPostIds.value}
-          disabled={parentPostIds.disabled}
-          warnings={parentPostIds.warnings}
-          errors={parentPostIds.errors}
-          onChange={parentPostIds.onChange}/>
-    </>)
-
-export default PostCoreDataFields
-export type { PostCoreDataFieldsProps }

frontend/src/components/posts/PostCreationDataFields.tsx

@@ -1,48 +0,0 @@
-import PostCoreDataFields from '@/components/posts/PostCoreDataFields'
-import PostTextField from '@/components/posts/PostTextField'
-
-import type { FC, ReactNode } from 'react'
-
-import type { PostCoreDataFieldsProps } from '@/components/posts/PostCoreDataFields'
-
-type TextMessages = string[] | undefined
-
-type Props = {
-  url: {
-    value:       string
-    onChange:    (value: string) => void
-    errors?:     TextMessages
-    warnings?:   TextMessages
-    disabled?:   boolean
-    type?:       string
-    placeholder?: string }
-  thumbnailField: ReactNode
-  core:           PostCoreDataFieldsProps
-  extraFields?:   ReactNode }
-
-
-const PostCreationDataFields: FC<Props> = (
-    { url,
-      thumbnailField,
-      core,
-      extraFields },
-) => (
-    <>
-      <PostTextField
-          label="URL"
-          type={url.type}
-          value={url.value}
-          disabled={url.disabled}
-          warnings={url.warnings}
-          errors={url.errors}
-          placeholder={url.placeholder}
-          onChange={url.onChange}/>
-
-      {thumbnailField}
-
-      <PostCoreDataFields {...core}/>
-
-      {extraFields}
-    </>)
-
-export default PostCreationDataFields

frontend/src/components/posts/PostCreationDataFieldsUsage.test.tsx

@@ -1,31 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import { describe, expect, it, vi } from 'vitest'
-
-import { buildPostImportRow } from '@/test/postImportFactories'
-
-import type { DialogueFormControls } from '@/lib/dialogues/useDialogue'
-
-const sharedFieldsSpy = vi.hoisted (() => vi.fn (() => <div data-testid="shared-fields"/>))
-
-vi.mock ('@/components/posts/PostCreationDataFields', () => ({
-  default: sharedFieldsSpy,
-}))
-
-describe ('PostCreationDataFields usage', () => {
-  it ('is used by PostImportRowForm', async () => {
-    const { default: PostImportRowForm } = await import (
-        '@/components/posts/import/PostImportRowForm')
-
-    render (
-        <PostImportRowForm
-            row={buildPostImportRow ()}
-            controls={{
-              close: vi.fn (),
-              confirm: vi.fn (),
-              setActions: vi.fn (),
-            } as DialogueFormControls}
-            onSave={vi.fn ()}/>)
-
-    expect (screen.getByTestId ('shared-fields')).toBeInTheDocument ()
-  })
-})

frontend/src/components/posts/PostDurationField.tsx

@@ -1,27 +0,0 @@
-import PostTextField from '@/components/posts/PostTextField'
-
-import type { FC } from 'react'
-
-type Props = {
-  value:     string
-  onChange:  (value: string) => void
-  errors?:   string[]
-  disabled?: boolean }
-
-
-const PostDurationField: FC<Props> = (
-    { value,
-      onChange,
-      errors,
-      disabled },
-) => (
-    <PostTextField
-        label="動画時間"
-        value={value}
-        onChange={onChange}
-        errors={errors}
-        disabled={disabled}
-        type="text"/>
-)
-
-export default PostDurationField

frontend/src/components/posts/PostTagsField.tsx

@@ -1,29 +0,0 @@
-import PostFormTagsArea from '@/components/PostFormTagsArea'
-import FieldWarning from '@/components/common/FieldWarning'
-
-import type { ComponentPropsWithoutRef, FC } from 'react'
-
-type Props = Omit<ComponentPropsWithoutRef<'textarea'>, 'value' | 'onChange'> & {
-  tags:      string
-  setTags:   (tags: string) => void
-  warnings?: string[]
-  errors?:   string[] }
-
-
-const PostTagsField: FC<Props> = (
-    { tags,
-      setTags,
-      warnings,
-      errors,
-      ...rest },
-) => (
-    <div className="space-y-2">
-      <PostFormTagsArea
-          {...rest}
-          tags={tags}
-          setTags={setTags}
-          errors={errors}/>
-      <FieldWarning messages={warnings}/>
-    </div>)
-
-export default PostTagsField

frontend/src/components/posts/PostTextField.tsx

@@ -1,52 +0,0 @@
-import FieldWarning from '@/components/common/FieldWarning'
-import FormField from '@/components/common/FormField'
-import { inputClass } from '@/lib/utils'
-
-import type { FC, ReactNode } from 'react'
-
-type Props = {
-  label:        string
-  value:        string
-  onChange:     (value: string) => void
-  warnings?:    string[]
-  errors?:      string[]
-  disabled?:    boolean
-  type?:        string
-  placeholder?: string
-  className?:   string
-  after?:       ReactNode
-  onBlur?:      () => void }
-
-
-const PostTextField: FC<Props> = (
-    { label,
-      value,
-      onChange,
-      warnings,
-      errors,
-      disabled,
-      type = 'text',
-      placeholder,
-      className,
-      after,
-      onBlur },
-) => (
-    <FormField label={label} messages={errors}>
-      {({ describedBy, invalid }) => (
-          <>
-            <input
-                type={type}
-                value={value}
-                disabled={disabled}
-                placeholder={placeholder}
-                onBlur={onBlur}
-                onChange={ev => onChange (ev.target.value)}
-                aria-describedby={describedBy}
-                aria-invalid={invalid}
-                className={inputClass (invalid, className)}/>
-            <FieldWarning messages={warnings}/>
-            {after}
-          </>)}
-    </FormField>)
-
-export default PostTextField

frontend/src/components/posts/PostThumbnailPreview.test.tsx

@@ -1,36 +0,0 @@
-import { fireEvent, render, screen } from '@testing-library/react'
-import { describe, expect, it } from 'vitest'
-
-import PostThumbnailPreview from '@/components/posts/PostThumbnailPreview'
-
-describe ('PostThumbnailPreview', () => {
-  it ('keeps an existing blob preview URL unchanged for normal post forms', () => {
-    render (<PostThumbnailPreview url="blob:preview" className="h-10 w-10"/>)
-
-    expect (screen.getByRole ('img')).toHaveAttribute ('src', 'blob:preview')
-  })
-
-  it ('renders an empty thumbnail frame without text when the URL is empty', () => {
-    const { container } = render (
-        <PostThumbnailPreview url="" className="h-10 w-10"/>)
-
-    expect (screen.queryByRole ('img')).toBeNull ()
-    expect (screen.queryByText ('サムネールを表示できません')).toBeNull ()
-    expect (screen.queryByText ('なし')).toBeNull ()
-    expect (container.querySelector ('div.rounded.border.bg-muted')).not.toBeNull ()
-    expect (container.textContent).toBe ('')
-  })
-
-  it ('renders an empty thumbnail frame without text when image loading fails', () => {
-    const { container } = render (
-        <PostThumbnailPreview url="blob:preview" className="h-10 w-10"/>)
-
-    fireEvent.error (screen.getByRole ('img'))
-
-    expect (screen.queryByRole ('img')).toBeNull ()
-    expect (screen.queryByText ('サムネールを表示できません')).toBeNull ()
-    expect (screen.queryByText ('なし')).toBeNull ()
-    expect (container.querySelector ('div.rounded.border.bg-muted')).not.toBeNull ()
-    expect (container.textContent).toBe ('')
-  })
-})

frontend/src/components/posts/PostThumbnailPreview.tsx

@@ -1,64 +0,0 @@
-import { useEffect, useState } from 'react'
-
-import { cn } from '@/lib/utils'
-
-import type { FC } from 'react'
-
-type Props = {
-  url:        string
-  file?:      File
-  alt?:       string
-  className?: string
-  referrerPolicy?: 'no-referrer' }
-
-
-const PostThumbnailPreview: FC<Props> = (
-    { url,
-      file,
-      alt = 'サムネール',
-      className = 'h-16 w-16',
-      referrerPolicy },
-) => {
-  const [failed, setFailed] = useState (false)
-  const [fileUrl, setFileUrl] = useState<string | null> (null)
-
-  useEffect (() => {
-    setFailed (false)
-  }, [file, url])
-
-  useEffect (() => {
-    if (file == null)
-      {
-        setFileUrl (null)
-        return
-      }
-
-    const nextUrl = URL.createObjectURL (file)
-    setFileUrl (nextUrl)
-
-    return () => {
-      URL.revokeObjectURL (nextUrl)
-    }
-  }, [file])
-
-  const resolvedUrl = url.trim () !== '' ? url : (fileUrl ?? '')
-
-  if (resolvedUrl === '' || failed)
-    {
-      return (
-          <div
-              className={cn (
-                  className,
-                  'rounded border border-border bg-muted')}/>)
-    }
-
-  return (
-      <img
-          src={resolvedUrl}
-          alt={alt}
-          referrerPolicy={referrerPolicy}
-          className={cn (className, 'rounded border border-border object-cover')}
-          onError={() => setFailed (true)}/>)
-}
-
-export default PostThumbnailPreview

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

@@ -1,278 +0,0 @@
-import { act, render, screen, waitFor } from '@testing-library/react'
-import { beforeEach, 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'
-
-const api = vi.hoisted (() => ({
-  apiGet: vi.fn (),
-}))
-
-vi.mock ('@/lib/api', () => api)
-
-describe ('PostImportRowForm', () => {
-  beforeEach (() => {
-    vi.clearAllMocks ()
-    globalThis.URL.createObjectURL = vi.fn (() => 'blob:preview')
-    globalThis.URL.revokeObjectURL = vi.fn ()
-    api.apiGet.mockResolvedValue (new Blob (['img'], { type: 'image/png' }))
-  })
-
-  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 (action => action.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 (action => action.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 (action => action.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: { title: ['title 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 ('title error')).toBeInTheDocument ()
-    expect (screen.getByText ('title warning')).toBeInTheDocument ()
-    expect (screen.getAllByRole ('textbox').filter (
-	textbox => textbox.getAttribute ('aria-invalid') === 'true')).toHaveLength (3)
-  })
-
-  it ('keeps untouched original created values unchanged in the save payload', async () => {
-    let actions: DialogueFormAction[] = []
-    const row = buildPostImportRow ({
-      attributes: {
-        originalCreatedFrom: '2024-01-01T12:34+09:00',
-        originalCreatedBefore: '2024-01-01T12:35+09:00' } })
-    const controls: DialogueFormControls = {
-      close: vi.fn (),
-      confirm: vi.fn (),
-      setActions: next => {
-        actions = next
-      } }
-    const onSave = vi.fn ().mockResolvedValue ({ saved: true, row: null })
-
-    render (
-        <PostImportRowForm
-            row={row}
-            controls={controls}
-            onSave={onSave}/>)
-    await waitFor (() => expect (actions.length).toBe (2))
-
-    await act (async () => {
-      void actions.find (action => action.label === '編輯内容を保存')?.onSelect ()
-    })
-
-    expect (onSave).toHaveBeenCalledWith ({
-      draft: expect.objectContaining ({
-        originalCreatedFrom: '2024-01-01T12:34+09:00',
-        originalCreatedBefore: '2024-01-01T12:35+09:00' }),
-      resetRequested: false })
-  })
-
-  it (
-      'shows upload input only when the thumbnail URL is blank',
-      async () => {
-    let actions: DialogueFormAction[] = []
-    const controls: DialogueFormControls = {
-      close: vi.fn (),
-      confirm: vi.fn (),
-      setActions: next => {
-        actions = next
-      } }
-    const onSave = vi.fn ().mockResolvedValue ({ saved: true, row: null })
-
-    const { container } = render (
-        <PostImportRowForm
-            row={buildPostImportRow ({
-              attributes: { duration: '2', tags: 'tag1' } })}
-            controls={controls}
-            onSave={onSave}/>)
-    await waitFor (() => expect (actions.length).toBe (2))
-
-    const labels = Array.from (container.querySelectorAll ('label'))
-        .map (node => node.textContent?.trim ())
-
-    expect (labels.slice (0, 6)).toEqual ([
-      'URL',
-      'サムネール',
-      'タイトル',
-      'オリジナルの作成日時',
-      'タグ',
-      '親投稿'])
-    expect (container.querySelector ('input[type="file"]')).toHaveAttribute (
-	'accept',
-	'image/*')
-    expect (screen.queryByPlaceholderText ('例: 2 / 2.5 / 1:23')).not.toBeInTheDocument ()
-    expect (screen.getByDisplayValue ('tag1')).toBeInTheDocument ()
-
-    await act (async () => {
-      await actions.find (action => action.label === '編輯内容を保存')?.onSelect ()
-    })
-
-    expect (onSave).toHaveBeenCalledWith ({
-      draft: expect.objectContaining ({
-        tags: 'tag1' }),
-      resetRequested: false })
-      })
-
-  it ('keeps reset enabled when the value matches but provenance still differs', async () => {
-    const row = buildPostImportRow ({
-      attributes: { title: 'same title' },
-      provenance: { title: 'manual' },
-      resetSnapshot: {
-        url: 'https://example.com/post',
-        attributes: {
-          title: 'same title',
-          thumbnailBase: '',
-          originalCreatedFrom: '',
-          originalCreatedBefore: '',
-          tags: '',
-          parentPostIds: '' },
-        provenance: {
-          url: 'manual',
-          title: 'automatic',
-          thumbnailBase: 'automatic',
-          originalCreatedFrom: 'automatic',
-          originalCreatedBefore: 'automatic',
-          tags: 'automatic',
-          parentPostIds: 'automatic' },
-        tagSources: { automatic: '', manual: '' },
-        fieldWarnings: { },
-        baseWarnings: [] } })
-    let actions: DialogueFormAction[] = []
-
-    render (
-        <PostImportRowForm
-            row={row}
-            controls={{
-              close: vi.fn (),
-              confirm: vi.fn (),
-              setActions: next => {
-                actions = next
-              } }}
-            onSave={vi.fn ()}/>)
-    await waitFor (() => expect (actions.length).toBe (2))
-
-    expect (actions.find (action => action.label === '変更をリセット')?.disabled).toBe (false)
-  })
-
-  it (
-      'disables every field while save validation is pending and re-enables them afterwards',
-      async () => {
-    let actions: DialogueFormAction[] = []
-    let resolveSave:
-        ((value: { saved: boolean
-		   row:   ReturnType<typeof buildPostImportRow> | null }) => void) | null
-        = null
-    const onSave = vi.fn (() =>
-        new Promise<{ saved: boolean
-		      row:   ReturnType<typeof buildPostImportRow> | null }> (resolve => {
-          resolveSave = resolve
-        }))
-
-    render (
-        <PostImportRowForm
-            row={buildPostImportRow ({ attributes: { title: 'draft title' } })}
-            controls={{
-              close: vi.fn (),
-              confirm: vi.fn (),
-              setActions: next => {
-                actions = next
-              } }}
-            onSave={onSave}/>)
-    await waitFor (() => expect (actions.length).toBe (2))
-
-    let savePromise: Promise<boolean | void> | undefined
-    await act (async () => {
-      savePromise = actions.find (action => action.label === '編輯内容を保存')?.onSelect ()
-    })
-
-    await waitFor (() => {
-      screen.getAllByRole ('textbox').forEach (textbox => {
-        expect (textbox).toBeDisabled ()
-      })
-    })
-
-    resolveSave?.({
-      saved: false,
-      row: buildPostImportRow ({
-        attributes: { title: 'draft title' },
-        validationErrors: { title: ['タイトルを確認してください．'] } }) })
-    await act (async () => {
-      await savePromise
-    })
-
-    await waitFor (() => {
-      screen.getAllByRole ('textbox').forEach (textbox => {
-        expect (textbox).not.toBeDisabled ()
-      })
-    })
-    expect (screen.getByDisplayValue ('draft title')).toBeInTheDocument ()
-    expect (screen.getByText ('タイトルを確認してください．')).toBeInTheDocument ()
-      })
-})

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

@@ -1,308 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
-
-import FieldError from '@/components/common/FieldError'
-import FieldWarning from '@/components/common/FieldWarning'
-import PostCreationDataFields from '@/components/posts/PostCreationDataFields'
-import PostDurationField from '@/components/posts/PostDurationField'
-import PostTextField from '@/components/posts/PostTextField'
-import PostImportThumbnailPreview from '@/components/posts/import/PostImportThumbnailPreview'
-import { hasThumbnailBaseValue, hasVideoTag } from '@/lib/postImportRows'
-
-import type { FC } from 'react'
-
-import type { DialogueFormControls } from '@/lib/dialogues/useDialogue'
-import type { PostImportEditableDraft, PostImportRow } from '@/lib/postImportTypes'
-
-type Draft = PostImportEditableDraft
-
-type Props = {
-  row:          PostImportRow
-  controls:     DialogueFormControls
-  onSave:       (args: { draft:          Draft
-			 resetRequested: boolean }) => Promise<{
-			     saved: boolean
-			     row:   PostImportRow | null }> }
-
-const THUMBNAIL_MISSING_WARNING = 'サムネールなし'
-
-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 ?? ''),
-    tags: String (row.attributes.tags ?? ''),
-    parentPostIds: String (row.attributes.parentPostIds ?? ''),
-    duration: String (row.attributes.duration ?? ''),
-    thumbnailFile: row.thumbnailFile })
-
-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 ?? ''),
-    tags: String (row.resetSnapshot.attributes.tags ?? ''),
-    parentPostIds: String (row.resetSnapshot.attributes.parentPostIds ?? ''),
-    duration: String (row.resetSnapshot.attributes.duration ?? ''),
-    thumbnailFile: undefined })
-
-const groupedMessages = (...values: (string[] | undefined)[]): string[] =>
-    [...new Set (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.tags === right.tags
-    && left.parentPostIds === right.parentPostIds
-    && left.duration === right.duration
-    && left.thumbnailFile === right.thumbnailFile
-
-const sameProvenance = (
-    current: PostImportRow['provenance'],
-    reset:   PostImportRow['resetSnapshot']['provenance'],
-): boolean =>
-    Object.keys (reset).every (field => current[field] === reset[field])
-
-const sameTagSources = (
-    current: PostImportRow['tagSources'],
-    reset:   PostImportRow['resetSnapshot']['tagSources'],
-): boolean =>
-    (current?.automatic ?? '') === reset.automatic
-    && (current?.manual ?? '') === reset.manual
-
-const sameWarnings = (
-    current: PostImportRow,
-    reset:   PostImportRow['resetSnapshot'],
-): boolean =>
-    JSON.stringify (current.fieldWarnings) === JSON.stringify (reset.fieldWarnings)
-    && JSON.stringify (current.baseWarnings) === JSON.stringify (reset.baseWarnings)
-
-const thumbnailWarnings = (
-    messages:       string[] | undefined,
-    thumbnailBase:  string,
-    thumbnailFile:  File | undefined,
-): string[] => {
-  const others = (messages ?? []).filter (message => message !== THUMBNAIL_MISSING_WARNING)
-  return hasThumbnailBaseValue (thumbnailBase) || thumbnailFile != null
-      ? others
-      : [...new Set ([...others, THUMBNAIL_MISSING_WARNING])]
-}
-
-
-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)
-  const [committedThumbnailBase, setCommittedThumbnailBase] = useState (
-      () => String (row.attributes.thumbnailBase ?? ''))
-
-  useEffect (() => {
-    const nextDraft = buildDraft (row)
-    setDraft (nextDraft)
-    setMessageRow (null)
-    setResetRequested (false)
-    setCommittedThumbnailBase (String (row.attributes.thumbnailBase ?? ''))
-  }, [row])
-
-  const displayRow = messageRow ?? row
-  const resetDraft = useMemo (
-      () => buildResetDraft (row),
-      [row])
-  const durationVisible = hasVideoTag (draft.tags)
-  const currentThumbnailWarnings = thumbnailWarnings (
-      displayRow.fieldWarnings.thumbnailBase,
-      draft.thumbnailBase,
-      draft.thumbnailFile)
-  const resetDisabled =
-      saving
-      || (sameDraft (draft, resetDraft)
-          && sameProvenance (row.provenance, row.resetSnapshot.provenance)
-          && sameTagSources (row.tagSources, row.resetSnapshot.tagSources)
-          && row.metadataUrl === row.resetSnapshot.metadataUrl
-          && sameWarnings (displayRow, row.resetSnapshot))
-
-  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: '変更をリセットしますか?',
-	confirmText: 'リセット',
-	cancelText: '取消',
-	variant: 'danger' })
-    if (!(confirmed))
-      return false
-
-    setDraft (resetDraft)
-    setResetRequested (true)
-    setMessageRow (null)
-    setCommittedThumbnailBase (resetDraft.thumbnailBase)
-    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">
-		<PostImportThumbnailPreview
-		    url={committedThumbnailBase}
-		    file={
-			hasThumbnailBaseValue (committedThumbnailBase)
-			? undefined
-			: draft.thumbnailFile}
-		    className="h-28 w-28"/>
-	      </div>
-
-	      <div className="space-y-4">
-		<PostCreationDataFields
-		    url={{
-			value: draft.url,
-			onChange: value => update ('url', value),
-			disabled: saving,
-			warnings: displayRow.fieldWarnings.url,
-			errors: groupedMessages (
-			    displayRow.validationErrors.url,
-			    displayRow.importErrors?.url) }}
-		    thumbnailField={
-			<>
-			  <PostTextField
-			      label="サムネール"
-			      value={draft.thumbnailBase}
-			      disabled={saving}
-			      warnings={currentThumbnailWarnings}
-			      errors={groupedMessages (
-				  displayRow.validationErrors.thumbnailBase,
-				  displayRow.importErrors?.thumbnailBase)}
-			      onBlur={() => {
-				if (draft.thumbnailBase.trim () !== committedThumbnailBase.trim ())
-				  setCommittedThumbnailBase (draft.thumbnailBase)
-			      }}
-			      onChange={value => update ('thumbnailBase', value)}/>
-			  {!(hasThumbnailBaseValue (draft.thumbnailBase)) && (
-			      <input
-				  type="file"
-				  accept="image/*"
-				  disabled={saving}
-				  onChange={event => {
-				    const file = event.target.files?.[0]
-				    update ('thumbnailFile', file)
-				  }}/>)}
-			</>}
-		    core={{
-			title: {
-			    value: draft.title,
-			    onChange: value => update ('title', value),
-			    disabled: saving,
-			    warnings: displayRow.fieldWarnings.title,
-			    errors: groupedMessages (
-				displayRow.validationErrors.title,
-				displayRow.importErrors?.title) },
-			originalCreated: {
-			    disabled: saving,
-			    originalCreatedFrom: draft.originalCreatedFrom || null,
-			    setOriginalCreatedFrom: value =>
-				update ('originalCreatedFrom', value ?? ''),
-			    originalCreatedBefore: draft.originalCreatedBefore || null,
-			    setOriginalCreatedBefore: value =>
-				update ('originalCreatedBefore', value ?? ''),
-			    errors: {
-				originalCreatedAt: groupedMessages (
-				    displayRow.validationErrors.originalCreatedAt,
-				    displayRow.importErrors?.originalCreatedAt),
-				originalCreatedFrom: groupedMessages (
-				    displayRow.validationErrors.originalCreatedFrom,
-				    displayRow.importErrors?.originalCreatedFrom),
-				originalCreatedBefore: groupedMessages (
-				    displayRow.validationErrors.originalCreatedBefore,
-				    displayRow.importErrors?.originalCreatedBefore) } },
-			tags: {
-			    value: draft.tags,
-			    onChange: value => update ('tags', value),
-			    disabled: saving,
-			    warnings: displayRow.fieldWarnings.tags,
-			    errors: groupedMessages (
-				displayRow.validationErrors.tags,
-				displayRow.importErrors?.tags),
-			    rows: 4 },
-			parentPostIds: {
-			    value: draft.parentPostIds,
-			    onChange: value => update ('parentPostIds', value),
-			    disabled: saving,
-			    errors: groupedMessages (
-				displayRow.validationErrors.parentPostIds,
-				displayRow.importErrors?.parentPostIds) } }}
-		    extraFields={
-			durationVisible
-			? (
-			    <PostDurationField
-				value={draft.duration}
-				onChange={value => update ('duration', value)}
-				disabled={saving}
-				errors={groupedMessages (
-				    displayRow.validationErrors.videoMs,
-				    displayRow.importErrors?.videoMs)}/>)
-			: null}/>
-		<FieldWarning messages={displayRow.baseWarnings}/>
-		<FieldError messages={displayRow.validationErrors.base}/>
-		<FieldError messages={displayRow.importErrors?.base}/>
-	      </div>
-	    </div>
-	  </div>
-	</div>
-      </>)
-}
-
-export default PostImportRowForm
-export { buildDraft }
-export type { Draft as PostImportRowDraft }

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

@@ -1,198 +0,0 @@
-import FieldError from '@/components/common/FieldError'
-import PostImportTagLinks from '@/components/posts/import/PostImportTagLinks'
-import { Button } from '@/components/ui/button'
-import PostImportThumbnailPreview from '@/components/posts/import/PostImportThumbnailPreview'
-import PostImportStatusBadge from '@/components/posts/import/PostImportStatusBadge'
-import { displayPostImportStatus } from '@/components/posts/import/postImportRowStatus'
-import {
-    canEditReviewRow,
-    canRetryResultRow,
-    hasVideoTag,
-} from '@/lib/postImportRows'
-import { cn, originalCreatedAtString } from '@/lib/utils'
-
-import type { FC } from 'react'
-
-import type { PostImportRow } from '@/lib/postImportTypes'
-
-type Props = {
-    row:	      PostImportRow
-    displayNumber?:   number
-    onEdit?:	      () => void
-    onRetry?:	      () => void
-    onToggleSkip?:    (checked: boolean) => void
-    rowMessages?:     string[]
-    editDisabled?:    boolean
-    retryDisabled?:   boolean
-    skipDisabled?:    boolean
-    showActions?:     boolean
-    showSkipToggle?:  boolean }
-
-const summaryWarning = (row: PostImportRow): string | null =>
-    Object.values (row.fieldWarnings ?? { }).flat ()[0]
-    ?? row.baseWarnings?.[0]
-    ?? null
-
-const summaryDate = (row: PostImportRow): string =>
-    originalCreatedAtString (
-	row.attributes.originalCreatedFrom?.toString () ?? null,
-	row.attributes.originalCreatedBefore?.toString () ?? null)
-
-
-const PostImportRowSummary: FC<Props> = (
-    { row,
-      displayNumber,
-      onEdit,
-      onRetry,
-      onToggleSkip,
-      rowMessages,
-      editDisabled,
-      retryDisabled,
-      skipDisabled,
-      showActions = true,
-      showSkipToggle = false },
-) => {
-  const warning = summaryWarning (row)
-  const displayStatus = displayPostImportStatus (row)
-  const editVisible = onEdit != null
-  const editAllowed = editVisible && canEditReviewRow (row)
-  const retryAllowed = onRetry != null && canRetryResultRow (row)
-  const skipChecked = row.skipReason === 'manual'
-  const rowNumber = displayNumber ?? row.sourceRow
-  const duration = String (row.attributes.duration ?? '')
-  const showDuration = hasVideoTag (row.attributes.tags) && duration !== ''
-  const skipControl = showSkipToggle
-      ? (
-	  <label className="flex items-center gap-2 text-sm">
-	    <input
-		type="checkbox"
-		checked={skipChecked}
-		onChange={event => onToggleSkip?.(event.target.checked)}
-		disabled={skipDisabled === true}/>
-	    <span>スキップ</span>
-	  </label>)
-      : null
-
-  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">#{rowNumber}</div>
-	  </div>
-	  <PostImportThumbnailPreview
-	      url={String (row.attributes.thumbnailBase ?? '')}
-	      file={row.thumbnailFile}
-	      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>
-	    <PostImportTagLinks tags={row.displayTags}/>
-	    <div className="text-xs text-neutral-500 dark:text-neutral-400">
-	      {summaryDate (row)}
-	    </div>
-	    {showDuration && (
-		<div className="text-xs text-neutral-500 dark:text-neutral-400">
-		  動画時間 {duration}
-		</div>)}
-	    {warning && (
-		<div className="text-xs text-amber-700 dark:text-amber-200">
-		  {warning}
-		</div>)}
-	    <FieldError messages={rowMessages}/>
-	  </div>
-	  <div className="space-y-1">
-	    {displayStatus != null && <PostImportStatusBadge value={displayStatus}/>}
-	  </div>
-	  <div className="flex justify-end">
-	    <div className="flex items-center gap-2">
-	      {skipControl}
-	      {showActions && editVisible && (
-		  <Button
-		      type="button"
-		      variant="outline"
-		      onClick={onEdit}
-		      disabled={editDisabled === true || !(editAllowed)}>
-		    編輯
-		  </Button>)}
-	      {showActions && retryAllowed && (
-		  <Button
-		      type="button"
-		      variant="outline"
-		      onClick={onRetry}
-		      disabled={retryDisabled === true}>
-		    再試行
-		  </Button>)}
-	    </div>
-	  </div>
-	</div>
-
-	<div
-	    className={cn (
-		'space-y-3 rounded-lg border p-4 md:hidden',
-		'transition-shadow hover:shadow-sm')}>
-	  <div className="text-sm font-medium">#{rowNumber}</div>
-	  <div className="flex items-start gap-3">
-	    <PostImportThumbnailPreview
-		url={String (row.attributes.thumbnailBase ?? '')}
-		file={row.thumbnailFile}
-		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>
-	      <PostImportTagLinks tags={row.displayTags}/>
-	      <div className="text-xs text-neutral-500 dark:text-neutral-400">
-		{summaryDate (row)}
-	      </div>
-	      {showDuration && (
-		  <div className="text-xs text-neutral-500 dark:text-neutral-400">
-		    動画時間 {duration}
-		  </div>)}
-	      {warning && (
-		  <div className="text-xs text-amber-700 dark:text-amber-200">
-		    {warning}
-		  </div>)}
-	      <FieldError messages={rowMessages}/>
-	      {skipControl}
-	    </div>
-	  </div>
-	  {showActions && (editVisible || retryAllowed) && (
-	      <div className="flex flex-col gap-2 md:flex-row">
-		{editVisible && (
-		    <Button
-			type="button"
-			className="w-full md:w-auto"
-			variant="outline"
-			onClick={onEdit}
-			disabled={editDisabled === true || !(editAllowed)}>
-		      編輯
-		    </Button>)}
-		{retryAllowed && (
-		    <Button
-			type="button"
-			className="w-full md:w-auto"
-			variant="outline"
-			onClick={onRetry}
-			disabled={retryDisabled === true}>
-		      再試行
-		    </Button>)}
-	      </div>)}
-	</div>
-      </>)
-}
-
-export default PostImportRowSummary

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

@@ -1,33 +0,0 @@
-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: '登録可能',
-    error: '登録不可',
-    warning: '警告',
-    skipped: 'スキップ',
-    created: '登録済み',
-    failed: '登録失敗' }
-
-const TONES: Record<PostImportBadgeValue, StatusBadgeTone> = {
-    ready: 'success',
-    error: 'warning',
-    warning: 'warning',
-    skipped: 'neutral',
-    created: 'success',
-    failed: 'warning' }
-
-
-const PostImportStatusBadge: FC<Props> = ({ value }) => (
-    <StatusBadge tone={TONES[value]}>
-      {LABELS[value]}
-    </StatusBadge>)
-
-export default PostImportStatusBadge

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

@@ -1,36 +0,0 @@
-import TagLink from '@/components/TagLink'
-
-import type { FC } from 'react'
-
-import type { PostImportDisplayTag } from '@/lib/postImportTypes'
-
-type Props = {
-  tags: PostImportDisplayTag[] | undefined }
-
-const PostImportTagLinks: FC<Props> = ({ tags }) => {
-  if (tags == null || tags.length === 0)
-    return null
-
-  return (
-      <div className="flex flex-wrap text-xs gap-x-1">
-	{tags.map (tag => {
-	  const key = `${ tag.category }:${ tag.name }:${ tag.sectionLiterals?.join ('|') ?? '' }`
-	  return (
-	      <span key={key} className="inline-flex flex-nowrap items-baseline gap-1">
-		<TagLink
-		    tag={{
-			name: tag.name,
-			category: tag.category }}
-		    linkFlg={false}
-		    withWiki={false}
-		    withCount={false}/>
-		{tag.sectionLiterals?.map (literal => (
-		    <span key={literal} className="text-xs text-neutral-500 dark:text-neutral-400">
-		      {literal}
-		    </span>))}
-	      </span>)
-	})}
-      </div>)
-}
-
-export default PostImportTagLinks

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

@@ -1,59 +0,0 @@
-import { fireEvent, render, screen } from '@testing-library/react'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import PostImportThumbnailPreview from '@/components/posts/import/PostImportThumbnailPreview'
-
-describe ('PostImportThumbnailPreview', () => {
-  beforeEach (() => {
-    vi.clearAllMocks ()
-    globalThis.URL.createObjectURL = vi.fn (() => 'blob:preview')
-    globalThis.URL.revokeObjectURL = vi.fn ()
-  })
-
-  it ('renders the remote URL directly without a backend proxy', () => {
-    render (
-	<PostImportThumbnailPreview
-	    url="https://example.com/thumbnail.jpg"
-	    className="h-10 w-10"/>)
-
-    expect (screen.getByRole ('img')).toHaveAttribute (
-	'src',
-	'https://example.com/thumbnail.jpg')
-    expect (screen.getByRole ('img')).toHaveAttribute (
-	'referrerpolicy',
-	'no-referrer')
-  })
-
-  it ('shows the empty frame after the remote image fails', () => {
-    const { container } = render (
-	<PostImportThumbnailPreview
-	    url="https://example.com/missing.jpg"
-	    className="h-10 w-10"/>)
-
-    fireEvent.error (screen.getByRole ('img'))
-
-    expect (screen.queryByRole ('img')).toBeNull ()
-    expect (container.querySelector ('div.rounded.border.bg-muted')).not.toBeNull ()
-    expect (container.textContent).toBe ('')
-  })
-
-  it ('uses and revokes an object URL only when the remote URL is blank', () => {
-    const file = new File (['image'], 'thumbnail.png', { type: 'image/png' })
-    const { rerender, unmount } = render (
-	<PostImportThumbnailPreview url="" file={file} className="h-10 w-10"/>)
-
-    expect (screen.getByRole ('img')).toHaveAttribute ('src', 'blob:preview')
-
-    rerender (
-	<PostImportThumbnailPreview
-	    url="https://example.com/remote.jpg"
-	    file={file}
-	    className="h-10 w-10"/>)
-    expect (screen.getByRole ('img')).toHaveAttribute (
-	'src',
-	'https://example.com/remote.jpg')
-
-    unmount ()
-    expect (globalThis.URL.revokeObjectURL).toHaveBeenCalledWith ('blob:preview')
-  })
-})

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

@@ -1,25 +0,0 @@
-import PostThumbnailPreview from '@/components/posts/PostThumbnailPreview'
-
-import type { FC } from 'react'
-
-type Props = {
-  url:        string
-  file?:      File
-  alt?:       string
-  className?: string }
-
-
-const PostImportThumbnailPreview: FC<Props> = (
-    { url,
-      file,
-      alt = 'サムネール',
-      className = 'h-16 w-16' },
-) => (
-    <PostThumbnailPreview
-        url={url}
-        file={file}
-        alt={alt}
-        className={className}
-        referrerPolicy="no-referrer"/>)
-
-export default PostImportThumbnailPreview

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

@@ -1,29 +0,0 @@
-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')
-    expect (displayPostImportStatus (buildPostImportRow ({
-      skipReason: 'manual' }))).toBe ('skipped')
-  })
-
-  it ('distinguishes validation, failure, and created states', () => {
-    expect (displayPostImportStatus (buildPostImportRow ({
-      status: 'error',
-      validationErrors: { title: ['invalid'] } }))).toBe ('error')
-    expect (displayPostImportStatus (buildPostImportRow ({
-      importStatus: 'failed' }))).toBe ('failed')
-    expect (displayPostImportStatus (buildPostImportRow ({
-      importStatus: 'created',
-      createdPostId: 3 }))).toBe ('created')
-  })
-})

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

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

frontend/src/components/ui/dialog.tsx

@@ -69,7 +69,7 @@ const DialogHeader = ({
 }: React.HTMLAttributes<HTMLDivElement>) => (
   <div
     className={cn(
-      "flex flex-col space-y-1.5 text-center md:text-left",
+      "flex flex-col space-y-1.5 text-center sm:text-left",
       className)}
     {...props}
   />)
@@ -81,7 +81,7 @@ const DialogFooter = ({
 }: React.HTMLAttributes<HTMLDivElement>) => (
   <div
     className={cn(
-      "flex flex-col-reverse md:flex-row md:justify-end md:space-x-2",
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
       className)}
     {...props}
   />)

frontend/src/index.css

@@ -239,11 +239,6 @@ body
   background: var(--top-nav-submenu-bg);
 }
 
-.top-nav-mobile-menu .top-nav-submenu
-{
-  background: var(--top-nav-mobile-active-bg);
-}
-
 .top-nav-mobile-menu
 {
   background: var(--top-nav-mobile-menu-bg);

frontend/src/index.test.ts

@@ -1,22 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-import { describe, expect, it } from 'vitest'
-
-
-const indexCss = readFileSync (
-    resolve (process.cwd (), 'src/index.css'),
-    'utf8')
-const compactIndexCss = indexCss.replace (/\s+/g, ' ')
-const mobileActiveRule = '.top-nav-mobile-active {'
-    + ' background: var(--top-nav-mobile-active-bg); }'
-const mobileSubmenuRule = '.top-nav-mobile-menu .top-nav-submenu {'
-    + ' background: var(--top-nav-mobile-active-bg); }'
-
-
-describe ('TopNav mobile menu colours', () => {
-  it ('uses one background variable for active rows and expanded submenus', () => {
-    expect (compactIndexCss).toContain (mobileActiveRule)
-    expect (compactIndexCss).toContain (mobileSubmenuRule)
-  })
-})

frontend/src/lib/api.ts

@@ -8,7 +8,6 @@ import type { AxiosError, AxiosRequestConfig } from 'axios'
 type Opt = {
     params?:        AxiosRequestConfig['params']
     headers?:       Record<string, string>
-    signal?:        AbortSignal
     responseType?:  'blob' }
 
 const client = axios.create ({ baseURL: API_BASE_URL })

frontend/src/lib/dialogues/useDialogue.ts

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

@@ -1,292 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { creatableImportRows,
-	 buildNextEditedRow,
-	 canEditResultRow,
-	 canEditReviewRow,
-	 canRetryResultRow,
-	 hasExactSourceRows,
-	 initialisePreviewRows,
-	 mergeImportResults,
-	 mergeValidatedImportRow,
-	 mergeValidatedImportRows,
-	 processableImportRows,
-	 replaceImportRow,
-	 resultRepairMode,
-	 resultRowMessages,
-	 resultSummaryCounts,
-	 retryImportRow,
-	 reviewSummaryCounts } from '@/lib/postImportRows'
-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 manual = buildPostImportRow ({
-      sourceRow: 3,
-      skipReason: 'manual' })
-    const invalid = buildPostImportRow ({
-      sourceRow: 4,
-      status: 'error',
-      validationErrors: { url: ['invalid'] } })
-    const created = buildPostImportRow ({
-      sourceRow: 5,
-      importStatus: 'created',
-      createdPostId: 40 })
-    const rows = [ready, existing, manual, invalid, created]
-
-    expect (processableImportRows (rows)).toEqual ([ready])
-    expect (creatableImportRows (rows)).toEqual ([ready])
-    expect (reviewSummaryCounts (rows)).toEqual ({
-      creatable: 1,
-      manualSkipped: 1,
-      existingSkipped: 1,
-      pendingOrError: 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,
-      recoverable: true,
-      importStatus: 'pending' })], [{
-      sourceRow: 1,
-      status: 'created',
-      post: { id: 3 } }])[0]
-    const skipped = mergeImportResults ([buildPostImportRow ({
-      createdPostId: 3,
-      importStatus: 'created',
-      recoverable: true })], [{
-      sourceRow: 1,
-      status: 'skipped',
-      existingPostId: 4 }])[0]
-    const failed = mergeImportResults ([buildPostImportRow ({
-      skipReason: 'existing',
-      existingPostId: 4 })], [{
-      sourceRow: 1,
-      status: 'failed',
-      recoverable: true,
-      errors: { base: ['failure'] } }])[0]
-
-    expect (created).toMatchObject ({
-      importStatus: 'created',
-      createdPostId: 3,
-      existingPostId: undefined,
-      recoverable: undefined,
-      skipReason: undefined })
-    expect (skipped).toMatchObject ({
-      importStatus: 'skipped',
-      existingPostId: 4,
-      createdPostId: undefined,
-      recoverable: undefined,
-      skipReason: 'existing' })
-    expect (failed).toMatchObject ({
-      importStatus: 'failed',
-      recoverable: true,
-      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',
-	recoverable: true, importErrors: { base: ['failed'] } }),
-      buildPostImportRow ({ sourceRow: 4, importStatus: 'pending',
-	recoverable: true, validationErrors: { base: ['failed'] } })]
-
-    expect (resultSummaryCounts (rows)).toEqual ({ created: 1, skipped: 1, failed: 2 })
-    expect (retryImportRow (rows, 3)[2]).toMatchObject ({
-      importStatus: 'pending',
-      importErrors: undefined })
-    expect (retryImportRow (rows, 4)[3]).toBe (rows[3])
-  })
-
-  it ('deduplicates messages and keeps repair mode only for repairable rows', () => {
-    const repairable = buildPostImportRow ({
-      sourceRow: 1,
-      importStatus: 'pending',
-      validationErrors: { title: ['invalid'], base: ['duplicate'] },
-      importErrors: { base: ['duplicate'], url: ['network'] } })
-    const complete = buildPostImportRow ({
-      sourceRow: 2,
-      importStatus: 'created',
-      createdPostId: 2 })
-
-    expect (resultRowMessages (repairable)).toEqual (['invalid', 'duplicate', 'network'])
-    expect (resultRepairMode ([repairable, complete])).toBe ('failed')
-    expect (resultRepairMode ([complete])).toBe ('all')
-  })
-
-  it ('classifies editable and retryable rows by terminal and recoverable state', () => {
-    const ready = buildPostImportRow ()
-    const skipped = buildPostImportRow ({
-      importStatus: 'skipped',
-      skipReason: 'existing',
-      existingPostId: 2 })
-    const hardFailed = buildPostImportRow ({
-      importStatus: 'failed',
-      importErrors: { base: ['failed'] } })
-    const pendingInvalid = buildPostImportRow ({
-      importStatus: 'pending',
-      recoverable: true,
-      validationErrors: { title: ['invalid'] } })
-    const pendingValid = buildPostImportRow ({
-      importStatus: 'pending',
-      recoverable: true })
-
-    expect (canEditReviewRow (ready)).toBe (true)
-    expect (canEditReviewRow (skipped)).toBe (false)
-    expect (canEditReviewRow (hardFailed)).toBe (false)
-    expect (canEditResultRow (pendingInvalid)).toBe (true)
-    expect (canRetryResultRow (pendingInvalid)).toBe (false)
-    expect (canRetryResultRow (pendingValid)).toBe (true)
-  })
-
-  it ('detects missing, duplicate, and extra source rows exactly', () => {
-    expect (hasExactSourceRows ([1, 2], [{ sourceRow: 1 }, { sourceRow: 2 }])).toBe (true)
-    expect (hasExactSourceRows ([1, 2], [{ sourceRow: 1 }])).toBe (false)
-    expect (hasExactSourceRows ([1, 2], [{ sourceRow: 1 }, { sourceRow: 1 }])).toBe (false)
-    expect (hasExactSourceRows ([1, 2], [{ sourceRow: 1 }, { sourceRow: 3 }])).toBe (false)
-  })
-
-  it ('merges only the validated source row and preserves other row edits', () => {
-    const edited = buildPostImportRow ({
-      sourceRow: 1,
-      attributes: { title: 'edited row' },
-      provenance: { title: 'manual' } })
-    const other = buildPostImportRow ({
-      sourceRow: 2,
-      attributes: { title: 'keep me' },
-      provenance: { title: 'manual' } })
-    const validated = buildPostImportRow ({
-      sourceRow: 1,
-      attributes: { title: 'validated row' } })
-
-    const result = mergeValidatedImportRow ([edited, other], validated)
-
-    expect (result[0]?.attributes.title).toBe ('validated row')
-    expect (result[1]?.attributes.title).toBe ('keep me')
-  })
-
-  it ('replaces only the targeted source row and preserves the others', () => {
-    const original = buildPostImportRow ({
-      sourceRow: 1,
-      importStatus: 'failed',
-      recoverable: true,
-      importErrors: { base: ['failed'] } })
-    const other = buildPostImportRow ({
-      sourceRow: 2,
-      attributes: { title: 'keep edited row' } })
-    const restored = buildPostImportRow ({
-      sourceRow: 1,
-      importStatus: 'failed',
-      recoverable: true,
-      importErrors: { base: ['failed'] } })
-
-    const result = replaceImportRow ([original, other], restored)
-
-    expect (result[0]).toEqual (restored)
-    expect (result[1]?.attributes.title).toBe ('keep edited row')
-  })
-
-  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'])
-  })
-
-  it ('builds the next edited row with shared repair semantics', () => {
-    const row = buildPostImportRow ({
-      url: 'https://example.com/original',
-      importStatus: 'failed',
-      recoverable: true,
-      importErrors: { base: ['failed'] },
-      attributes: { title: 'old title', tags: 'old-tag', duration: '2' },
-      provenance: { title: 'automatic', tags: 'automatic', url: 'manual' },
-      tagSources: { automatic: 'old-tag', manual: '' } })
-
-    const nextRow = buildNextEditedRow (
-        row,
-        {
-          url: 'https://example.com/edited',
-          title: 'edited title',
-          thumbnailBase: '',
-          originalCreatedFrom: '',
-          originalCreatedBefore: '',
-          duration: '2',
-          tags: 'edited-tag',
-          parentPostIds: '' },
-        true)
-
-    expect (nextRow.importStatus).toBe ('pending')
-    expect (nextRow.importErrors).toBeUndefined ()
-    expect (nextRow.url).toBe ('https://example.com/edited')
-    expect (nextRow.attributes.title).toBe ('edited title')
-    expect (nextRow.attributes.duration).toBe ('2')
-    expect (nextRow.attributes.tags).toBe ('edited-tag')
-    expect (nextRow.provenance.title).toBe ('manual')
-    expect (nextRow.provenance.url).toBe ('manual')
-    expect (nextRow.tagSources?.manual).toBe ('edited-tag')
-  })
-})

frontend/src/lib/postImportRows.ts

@@ -1,421 +0,0 @@
-import type { PostImportEditableDraft,
-	      PostImportResultRow,
-	      PostImportRow } from '@/lib/postImportTypes'
-
-const THUMBNAIL_MISSING_WARNING = 'サムネールなし'
-
-export const hasThumbnailBaseValue = (value: unknown): boolean =>
-    typeof value === 'string' && value.trim () !== ''
-
-export const hasVideoTag = (value: unknown): boolean =>
-    typeof value === 'string'
-    && value.split (/\s+/).includes ('動画')
-
-export const isExistingSkipRow = (row: PostImportRow): boolean =>
-    row.skipReason === 'existing'
-
-
-export const isManualSkipRow = (row: PostImportRow): boolean =>
-    row.skipReason === 'manual'
-
-
-const hasSkipReason = (row: PostImportRow): boolean =>
-    row.skipReason != null
-
-export const compactMessageRecord = (
-    messages: Record<string, string[]>,
-): Record<string, string[]> =>
-    Object.fromEntries (
-	Object.entries (messages).filter (([, values]) => values.length > 0))
-
-
-export const hasErrorMessages = (
-    messages: Record<string, string[]>,
-): boolean =>
-    Object.values (messages).some (values => values.length > 0)
-
-
-const hasValidationErrors = (row: PostImportRow): boolean =>
-    hasErrorMessages (row.validationErrors ?? { })
-
-const isRecoverableRow = (row: PostImportRow): boolean =>
-    row.recoverable === true
-
-const isRepairableImportStatus = (row: PostImportRow): boolean =>
-    isRecoverableRow (row)
-    && (row.importStatus === 'failed' || row.importStatus === 'pending')
-
-
-export const isNonRecoverableFailedRow = (row: PostImportRow): boolean =>
-    row.importStatus === 'failed' && row.recoverable !== true
-
-
-export const isTerminalRow = (row: PostImportRow): boolean =>
-    row.importStatus === 'created'
-    || row.importStatus === 'skipped'
-    || isNonRecoverableFailedRow (row)
-
-
-export const isCompletedReviewRow = (row: PostImportRow): boolean =>
-    row.importStatus === 'created'
-    || row.importStatus === 'skipped'
-    || hasSkipReason (row)
-
-
-export const validatableImportRows = (rows: PostImportRow[]): PostImportRow[] =>
-    rows.filter (row => !(hasSkipReason (row)) && !(isTerminalRow (row)))
-
-const buildResetSnapshot = (row: PostImportRow) => ({
-    url: row.url,
-    attributes: { ...row.attributes },
-    displayTags: row.displayTags?.map (tag => ({
-	name: tag.name,
-	category: tag.category,
-	sectionLiterals: tag.sectionLiterals == null ? undefined : [...tag.sectionLiterals] })) ?? [],
-    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 })
-
-const deduped = (values: string[]): string[] =>
-    [...new Set (values)]
-
-
-const thumbnailWarnings = (row: PostImportRow): string[] => {
-    const current = row.fieldWarnings.thumbnailBase ?? []
-    const others = current.filter (message => message !== THUMBNAIL_MISSING_WARNING)
-    return hasThumbnailBaseValue (row.attributes.thumbnailBase) || row.thumbnailFile != null
-        ? others
-        : deduped ([...others, THUMBNAIL_MISSING_WARNING])
-}
-
-
-export const applyThumbnailWarning = (row: PostImportRow): PostImportRow => ({
-    ...row,
-    fieldWarnings: compactMessageRecord ({
-	...row.fieldWarnings,
-	thumbnailBase: thumbnailWarnings (row) }) })
-
-
-export const applyThumbnailWarnings = (rows: PostImportRow[]): PostImportRow[] =>
-    rows.map (row => applyThumbnailWarning (row))
-
-
-export const processableImportRows = (rows: PostImportRow[]): PostImportRow[] =>
-    validatableImportRows (rows).filter (row => {
-      if (row.status === 'pending')
-        return false
-      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[]) => ({
-    creatable: rows.filter (row => creatableImportRows ([row]).length > 0).length,
-    manualSkipped: rows.filter (row => isManualSkipRow (row)).length,
-    existingSkipped: rows.filter (row => isExistingSkipRow (row)).length,
-    pendingOrError: rows.filter (row =>
-        !(isCompletedReviewRow (row))
-        && creatableImportRows ([row]).length === 0).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'
-              || (row.recoverable === true && row.importStatus === 'pending'))
-            ++counts.failed
-          return counts
-        },
-        { created: 0, skipped: 0, failed: 0 })
-
-
-export const resultRepairMode = (
-    rows: PostImportRow[],
-): 'all' | 'failed' =>
-    rows.some (row => hasValidationErrors (row) || isRepairableImportStatus (row))
-    ? 'failed'
-    : 'all'
-
-
-export const canEditReviewRow = (row: PostImportRow): boolean =>
-    !(hasSkipReason (row)
-      || row.importStatus === 'created'
-      || row.importStatus === 'skipped'
-      || (row.importStatus === 'failed' && row.recoverable !== true))
-
-
-export const canEditResultRow = (row: PostImportRow): boolean =>
-    row.skipReason == null
-    && row.recoverable === true
-    && (row.importStatus === 'failed'
-        || (row.importStatus === 'pending' && hasValidationErrors (row)))
-
-
-export const canRetryResultRow = (row: PostImportRow): boolean =>
-    row.skipReason == null
-    && row.recoverable === true
-    && (row.importStatus === 'failed'
-        || (row.importStatus === 'pending' && !(hasValidationErrors (row))))
-
-
-export const resultRowMessages = (row: PostImportRow): string[] =>
-    [...new Set ([
-        ...Object.values (row.validationErrors ?? { }).flat (),
-        ...Object.values (row.importErrors ?? { }).flat ()])]
-
-
-export const resultRowWarnings = (row: PostImportRow): string[] =>
-    [...new Set ([
-        ...Object.values (row.fieldWarnings ?? { }).flat (),
-        ...row.baseWarnings])]
-
-
-const isManualChange = (
-    current: unknown,
-    next:    string,
-): boolean =>
-    next !== String (current ?? '')
-
-
-export const buildNextEditedRow = (
-    editingRow:  PostImportRow,
-    draft:       PostImportEditableDraft,
-    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] =
-	    isManualChange (editingRow.attributes[field], value)
-	    ? 'manual'
-	    : (editingRow.provenance[field] ?? 'automatic')
-    })
-    nextAttributes.tags = draft.tags
-    if (isManualChange (editingRow.attributes.tags, draft.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,
-	displayTags:
-	    editingRow.displayTags?.map (tag => ({
-		name: tag.name,
-		category: tag.category,
-		sectionLiterals: tag.sectionLiterals == null ? undefined : [...tag.sectionLiterals] })),
-	thumbnailFile: draft.thumbnailFile,
-	provenance: {
-	    ...nextProvenance,
-	    url: urlChanged ? 'manual' : (editingRow.provenance.url ?? 'manual') },
-	tagSources: nextTagSources,
-	importStatus: editingRow.importStatus === 'created' ? 'created' : 'pending',
-	importErrors: undefined }
-}
-
-
-export const hasExactSourceRows = (
-    expected: number[],
-    actual:   Array<{ sourceRow: number }>,
-): boolean => {
-    if (expected.length !== actual.length)
-      return false
-
-    const expectedSorted = [...expected].sort ((a, b) => a - b)
-    const actualSorted = actual.map (row => row.sourceRow).sort ((a, b) => a - b)
-    return expectedSorted.every ((value, index) => value === actualSorted[index])
-}
-
-
-export const replaceImportRow = (
-    rows:      PostImportRow[],
-    nextRow:   PostImportRow,
-): PostImportRow[] =>
-    rows.map (row => row.sourceRow === nextRow.sourceRow ? nextRow : row)
-
-
-export const mergeValidatedImportRow = (
-    rows:      PostImportRow[],
-    validated: PostImportRow,
-): PostImportRow[] => {
-    const current = rows.find (row => row.sourceRow === validated.sourceRow)
-    if (current == null)
-      return rows
-
-    const [merged] = mergeValidatedImportRows ([current], [validated])
-    return merged == null ? rows : replaceImportRow (rows, merged)
-}
-
-
-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 =
-          hasErrorMessages (row.fieldWarnings) || 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,
-          displayTags:
-              row.displayTags?.map (tag => ({
-                  name: tag.name,
-                  category: tag.category,
-                  sectionLiterals:
-                      tag.sectionLiterals == null ? undefined : [...tag.sectionLiterals] })),
-          provenance: row.provenance,
-          tagSources: row.tagSources,
-          skipReason: row.skipReason,
-          existingPostId: row.existingPostId,
-          existingPost: row.existingPost,
-          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',
-              recoverable: undefined,
-              skipReason: undefined,
-              createdPostId: result.post.id,
-              existingPostId: undefined,
-              existingPost: undefined,
-              fieldWarnings: compactMessageRecord (
-		  result.fieldWarnings ?? row.fieldWarnings),
-              baseWarnings: result.baseWarnings ?? row.baseWarnings,
-              importErrors: compactMessageRecord (result.errors ?? { }) }
-        case 'skipped':
-          return {
-              ...row,
-              importStatus: 'skipped',
-              recoverable: undefined,
-              skipReason: 'existing',
-              createdPostId: undefined,
-              existingPostId: result.existingPostId,
-              existingPost: result.existingPost ?? row.existingPost,
-              fieldWarnings: compactMessageRecord (
-		  result.fieldWarnings ?? row.fieldWarnings),
-              baseWarnings: result.baseWarnings ?? row.baseWarnings,
-              importErrors: compactMessageRecord (result.errors ?? { }) }
-        case 'failed':
-          return {
-              ...row,
-              importStatus: 'failed',
-              recoverable: result.recoverable === true ? true : undefined,
-              skipReason: undefined,
-              createdPostId: undefined,
-              existingPostId: undefined,
-              existingPost: undefined,
-              fieldWarnings: compactMessageRecord (
-		  result.fieldWarnings ?? row.fieldWarnings),
-              baseWarnings: result.baseWarnings ?? row.baseWarnings,
-              importErrors: compactMessageRecord (result.errors ?? { }) }
-        }
-    })
-}
-
-
-export const retryImportRow = (
-    rows:      PostImportRow[],
-    sourceRow: number,
-): PostImportRow[] =>
-    rows.map (row =>
-        row.sourceRow === sourceRow
-        && row.importStatus === 'failed'
-        && row.recoverable === true
-        ? { ...row, importStatus: 'pending', importErrors: undefined }
-        : row)
-
-export const initialisePreviewRows = (rows: PostImportRow[]): PostImportRow[] =>
-    applyThumbnailWarnings (
-	rows.map (row => ({
-	    ...row,
-	    resetSnapshot: buildResetSnapshot (row) })))

frontend/src/lib/postImportSourceValidation.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-    countImportSourceLines,
-    validateImportSource,
-} from '@/lib/postImportSourceValidation'
-
-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

@@ -1,121 +0,0 @@
-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 parseImportUrl = (value: string): URL | null => {
-    const trimmed = value.trim ()
-    if (!(trimmed))
-      return null
-
-    try
-    {
-      return new URL (trimmed)
-    }
-    catch
-    {
-      return null
-    }
-}
-
-
-const normaliseImportUrl = (url: URL): string => {
-  url.hostname = url.hostname.toLowerCase ()
-  if (url.pathname.endsWith ('/'))
-    url.pathname = url.pathname.replace (/\/+$/, '')
-  return url.toString ()
-}
-
-
-export const extractImportSourceUrls = (source: string): string[] =>
-    source
-        .split (/\r\n|\n|\r/)
-        .map (line => line.trim ())
-        .filter (line => line !== '')
-
-
-export const countImportSourceLines = (source: string): number =>
-    extractImportSourceUrls (source).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)
-      if (count > MAX_ROWS)
-        {
-          issues.push ({
-              sourceRow,
-              message: `取込件数は ${ MAX_ROWS } 件までです．`,
-              url: displayUrl })
-          return
-        }
-      if (bytesize (value) > MAX_URL_BYTES)
-        {
-          issues.push ({
-              sourceRow,
-              message: 'URL が長すぎます．',
-              url: displayUrl })
-          return
-        }
-      const parsed = parseImportUrl (value)
-      if (parsed == null)
-        {
-          issues.push ({
-              sourceRow,
-              message: 'URL の形式が不正です．',
-              url: displayUrl })
-          return
-        }
-      if (!(parsed.protocol === 'http:' || parsed.protocol === 'https:'))
-        {
-          issues.push ({
-              sourceRow,
-              message: 'HTTP または HTTPS の URL ではありません．',
-              url: displayUrl })
-          return
-        }
-      if (!(parsed.host))
-        {
-          issues.push ({
-              sourceRow,
-              message: 'URL の形式が不正です．',
-              url: displayUrl })
-          return
-        }
-      const normalised = normaliseImportUrl (parsed)
-      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

@@ -1,40 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import {
-    clearPostImportSourceDraft,
-    loadPostImportSourceDraft,
-    savePostImportSourceDraft,
-} from '@/lib/postImportStorage'
-
-describe ('post import source draft storage', () => {
-  beforeEach (() => {
-    sessionStorage.clear ()
-    vi.restoreAllMocks ()
-  })
-
-  it ('round-trips and clears the URL list source draft', () => {
-    expect (savePostImportSourceDraft ('https://example.com')).toBe (true)
-    expect (loadPostImportSourceDraft ()).toEqual ({
-	source: 'https://example.com' })
-
-    clearPostImportSourceDraft ()
-
-    expect (loadPostImportSourceDraft ()).toEqual ({ source: '' })
-  })
-
-  it ('ignores malformed stored drafts', () => {
-    sessionStorage.setItem ('post-import-source-draft', '{')
-
-    expect (loadPostImportSourceDraft ()).toEqual ({ source: '' })
-  })
-
-  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

@@ -1,94 +0,0 @@
-import type { StorageErrorHandler } from '@/lib/postImportTypes'
-
-const SOURCE_DRAFT_KEY = 'post-import-source-draft'
-
-
-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?.('保存済みデータを削除できませんでした．')
-  }
-}
-
-
-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)
-}

frontend/src/lib/postImportTypes.ts

@@ -1,98 +0,0 @@
-import type { Category } from '@/types'
-
-export type PostImportOrigin = 'automatic' | 'manual'
-export type PostImportRepairMode = 'all' | 'failed'
-export type PostImportStatus =
-    'pending'
-    | 'created'
-    | 'skipped'
-    | 'failed'
-export type PostImportSkipReason = 'existing' | 'manual'
-export type PostImportResultStatus = 'created' | 'skipped' | 'failed'
-export type PostImportAttributeValue = string | number
-
-export type PostImportDisplayTag = {
-    name:            string
-    category:        Category
-    sectionLiterals?: string[] }
-
-export type PostImportResetSnapshot = {
-    url:         string
-    attributes:  Record<string, PostImportAttributeValue>
-    displayTags: PostImportDisplayTag[]
-    provenance:  Record<string, PostImportOrigin>
-    tagSources:  Record<PostImportOrigin, string>
-    fieldWarnings: Record<string, string[]>
-    baseWarnings: string[]
-    metadataUrl?: string }
-
-export type PostImportExistingPost = {
-    id:            number
-    title:         string
-    url:           string
-    thumbnail?:    string | null
-    thumbnailBase?: string | null }
-
-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:            'pending' | 'ready' | 'warning' | 'error'
-    skipReason?:       PostImportSkipReason
-    existingPostId?:   number
-    existingPost?:     PostImportExistingPost
-    metadataUrl?:      string
-    displayTags?:      PostImportDisplayTag[]
-    resetSnapshot:     PostImportResetSnapshot
-    createdPostId?:    number
-    importStatus?:     PostImportStatus
-    recoverable?:      boolean
-    thumbnailFile?:    File }
-
-export type PostImportResultRow =
-    | {
-	sourceRow: number
-	status:    'created'
-	post:      { id: number }
-	fieldWarnings?: Record<string, string[]>
-	baseWarnings?:  string[]
-	errors?:   Record<string, string[]> }
-    | {
-	sourceRow:      number
-	status:         'skipped'
-	existingPostId: number
-	existingPost?:  PostImportExistingPost
-	fieldWarnings?: Record<string, string[]>
-	baseWarnings?:  string[]
-	errors?:        Record<string, string[]> }
-    | {
-	sourceRow: number
-	status:    'failed'
-	fieldWarnings?: Record<string, string[]>
-	baseWarnings?:  string[]
-	errors?:   Record<string, string[]>
-	recoverable?: boolean }
-
-export type PostImportSourceIssue = {
-    sourceRow: number
-    message:   string
-    url:       string }
-
-export type PostImportEditableDraft = {
-    url:                   string
-    title:                 string
-    thumbnailBase:         string
-    originalCreatedFrom:   string
-    originalCreatedBefore: string
-    duration:              string
-    tags:                  string
-    parentPostIds:         string
-    thumbnailFile?:        File }
-
-export type StorageErrorHandler = (message: string) => void

frontend/src/lib/postNewQueryState.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-    buildPostNewReviewPath,
-    hasPostNewReviewState,
-    isPostNewReviewPathWithinLimit,
-    parsePostNewReviewUrls,
-    postNewReviewPathByteLength,
-} from '@/lib/postNewQueryState'
-
-describe ('post new review URL state', () => {
-  it ('encodes each URL separately and preserves literal plus signs', () => {
-    const urls = [
-	'https://example.com/one+a',
-	'https://example.com/two?value=b+c']
-
-    const path = buildPostNewReviewPath (urls)
-
-    expect (path).toBe (
-	'/posts/new?urls=https%3A%2F%2Fexample.com%2Fone%2Ba'
-	+ '+https%3A%2F%2Fexample.com%2Ftwo%3Fvalue%3Db%2Bc')
-    expect (parsePostNewReviewUrls (path.slice ('/posts/new'.length))).toEqual (urls)
-  })
-
-  it ('uses only the raw urls parameter as review state', () => {
-    expect (hasPostNewReviewState ('?session_id=old&meta=old')).toBe (false)
-    expect (hasPostNewReviewState ('?unknown=value&urls=')).toBe (true)
-    expect (parsePostNewReviewUrls ('?unknown=value&urls=one+two&meta=old'))
-	.toEqual (['one', 'two'])
-  })
-
-  it ('allows at most a 4095-byte request target', () => {
-    const baseUrl = 'https://example.com/'
-    const baseLength = postNewReviewPathByteLength ([baseUrl])
-    const allowed = `${ baseUrl }${ 'a'.repeat (4_095 - baseLength) }`
-    const denied = `${ allowed }a`
-
-    expect (postNewReviewPathByteLength ([allowed])).toBe (4_095)
-    expect (isPostNewReviewPathWithinLimit ([allowed])).toBe (true)
-    expect (postNewReviewPathByteLength ([denied])).toBe (4_096)
-    expect (isPostNewReviewPathWithinLimit ([denied])).toBe (false)
-  })
-})

frontend/src/lib/postNewQueryState.ts

@@ -1,58 +0,0 @@
-const POST_NEW_REVIEW_PATH_PREFIX = '/posts/new?urls='
-const MAX_POST_NEW_REVIEW_TARGET_BYTES = 4_096
-
-const textEncoder = new TextEncoder ()
-
-
-const rawUrlsParam = (search: string): string | null => {
-  const query = search.startsWith ('?') ? search.slice (1) : search
-  if (query === '')
-    return null
-
-  for (const segment of query.split ('&'))
-    {
-      if (segment === 'urls')
-        return ''
-      if (segment.startsWith ('urls='))
-        return segment.slice ('urls='.length)
-    }
-
-  return null
-}
-
-
-export const buildPostNewReviewPath = (urls: string[]): string =>
-    `${ POST_NEW_REVIEW_PATH_PREFIX }${ urls.map (url => encodeURIComponent (url)).join ('+') }`
-
-
-export const postNewReviewPathByteLength = (urls: string[]): number =>
-    textEncoder.encode (buildPostNewReviewPath (urls)).byteLength
-
-
-export const isPostNewReviewPathWithinLimit = (urls: string[]): boolean =>
-    postNewReviewPathByteLength (urls) < MAX_POST_NEW_REVIEW_TARGET_BYTES
-
-
-export const parsePostNewReviewUrls = (search: string): string[] => {
-  const raw = rawUrlsParam (search)
-  if (raw == null)
-    return []
-
-  return raw
-      .split ('+')
-      .filter (segment => segment !== '')
-      .map (segment => {
-        try
-        {
-          return decodeURIComponent (segment)
-        }
-        catch
-        {
-          return segment
-        }
-      })
-}
-
-
-export const hasPostNewReviewState = (search: string): boolean =>
-    rawUrlsParam (search) != null

frontend/src/lib/settings.test.ts

@@ -89,12 +89,8 @@ describe ('settings', () => {
   })
 
   it ('derives TopNav colours without mixing mobile active backgrounds', () => {
-    const tokens = buildThemeTokens ('light', { })
-
-    expect (tokens.topNavMobileActiveBackground).toBe (
+    expect (buildThemeTokens ('light', { }).topNavMobileActiveBackground).toBe (
 	LIGHT_THEME_TOKENS.topNavRootBackgroundDesktop)
-    expect (tokens.topNavMobileActiveBackground).not.toBe (
-	tokens.topNavRootBackgroundMobile)
     expect (buildThemeTokens ('dark', { }).topNavMobileActiveBackground).toBe (
 	DARK_THEME_TOKENS.topNavActiveBackground)
   })

frontend/src/lib/useKeyboardShortcuts.tsx

@@ -25,6 +25,7 @@ import {
     getEffectiveKeyBindings,
     setClientKeyboardSettings,
 } from '@/lib/settings'
+import { useUnsavedChangesGuard } from '@/lib/useUnsavedChangesGuard'
 
 import type {
     KeyBinding,
@@ -96,6 +97,7 @@ const focusSearchTarget = (): void => {
 export const KeyboardShortcutsProvider = ({ children }: PropsWithChildren) => {
   const location = useLocation ()
   const navigate = useNavigate ()
+  const { confirmDiscardNavigation } = useUnsavedChangesGuard ()
 
   const [keyboardSettings, setKeyboardSettingsState] =
       useState<ClientKeyboardSettings> (() => getClientKeyboardSettings ())
@@ -147,8 +149,11 @@ export const KeyboardShortcutsProvider = ({ children }: PropsWithChildren) => {
   }, [])
 
   const guardedNavigate = useCallback ((path: string) => {
+    confirmDiscardNavigation ().then (confirmed => {
+      if (confirmed)
 	navigate (path)
-  }, [navigate])
+    })
+  }, [confirmDiscardNavigation, navigate])
 
   const builtinHandlers = useMemo<ShortcutHandlers> (
       () => ({

frontend/src/lib/useUnsavedChangesGuard.test.tsx

@@ -1,77 +0,0 @@
-import { fireEvent, screen, waitFor, within } from '@testing-library/react'
-import { useState } from 'react'
-import { useLocation, useNavigate } from 'react-router-dom'
-import { describe, expect, it, vi } from 'vitest'
-
-import { useUnsavedChangesGuard } from '@/lib/useUnsavedChangesGuard'
-import { renderWithProviders } from '@/test/render'
-
-const GuardHarness = () => {
-  const [dirty, setDirty] = useState (true)
-  const location = useLocation ()
-  const navigate = useNavigate ()
-  const discard = vi.fn (() => setDirty (false))
-  const { allowNextNavigation } = useUnsavedChangesGuard ({
-    dirty,
-    onDiscard: discard })
-
-  return (
-      <>
-	<output aria-label="location">{location.pathname}{location.search}</output>
-	<button type="button" onClick={() => navigate ('/next?tab=one')}>move</button>
-	<button
-	    type="button"
-	    onClick={() => {
-	      allowNextNavigation ()
-	      navigate ('/allowed')
-	    }}>
-	  allowed move
-	</button>
-      </>)
-}
-
-describe ('useUnsavedChangesGuard', () => {
-  it ('blocks route changes and resets a cancelled transition', async () => {
-    renderWithProviders (<GuardHarness/>, { route: '/current' })
-
-    fireEvent.click (screen.getByRole ('button', { name: 'move' }))
-
-    expect (within (await screen.findByRole ('dialog')).getByText (
-	'変更が破棄してページ移動しますか?')).toBeInTheDocument ()
-    expect (screen.getByLabelText ('location')).toHaveTextContent ('/current')
-
-    fireEvent.click (screen.getByRole ('button', { name: '取消' }))
-
-    await waitFor (() => {
-      expect (screen.queryByRole ('dialog')).not.toBeInTheDocument ()
-    })
-    expect (screen.getByLabelText ('location')).toHaveTextContent ('/current')
-  })
-
-  it ('proceeds with the blocked transition after discard is confirmed', async () => {
-    renderWithProviders (<GuardHarness/>, { route: '/current' })
-
-    fireEvent.click (screen.getByRole ('button', { name: 'move' }))
-    fireEvent.click (await screen.findByRole ('button', {
-      name: '変更を破棄して移動' }))
-
-    await waitFor (() => {
-      expect (screen.getByLabelText ('location')).toHaveTextContent ('/next?tab=one')
-    })
-  })
-
-  it ('allows only the next navigation without leaving a bypass token', async () => {
-    renderWithProviders (<GuardHarness/>, { route: '/current' })
-
-    fireEvent.click (screen.getByRole ('button', { name: 'allowed move' }))
-    await waitFor (() => {
-      expect (screen.getByLabelText ('location')).toHaveTextContent ('/allowed')
-    })
-
-    fireEvent.click (screen.getByRole ('button', { name: 'move' }))
-
-    expect (within (await screen.findByRole ('dialog')).getByText (
-	'変更が破棄してページ移動しますか?')).toBeInTheDocument ()
-    expect (screen.getByLabelText ('location')).toHaveTextContent ('/allowed')
-  })
-})

frontend/src/lib/useUnsavedChangesGuard.tsx

@@ -1,15 +1,6 @@
-import {
-    createContext,
-    useCallback,
-    useContext,
-    useEffect,
-    useMemo,
-    useRef,
-    useState,
-} from 'react'
-import { useBlocker } from 'react-router-dom'
+import { createContext, useCallback, useContext, useMemo, useState } from 'react'
 
-import { useDialogue } from '@/lib/dialogues/useDialogue'
+import { useDialogue } from '@/components/dialogues/DialogueProvider'
 
 import type { FC, PropsWithChildren } from 'react'
 
@@ -17,16 +8,12 @@ type UnsavedChangesSource = {
     dirty:    boolean
     discard:  () => void | Promise<void> }
 
-type UseUnsavedChangesGuardOptions = {
-    dirty:      boolean
-    onDiscard?: () => void | Promise<void> }
-
 type UnsavedChangesGuardContextValue = {
     hasUnsavedChanges:             boolean
     registerUnsavedChangesSource:  (
-        source: UnsavedChangesSource,
-    ) => () => void
-    allowNextNavigation:          () => void }
+	source: UnsavedChangesSource | null,
+    ) => void
+    confirmDiscardNavigation:      () => Promise<boolean> }
 
 const UnsavedChangesGuardContext =
     createContext<UnsavedChangesGuardContextValue | null> (null)
@@ -34,145 +21,36 @@ const UnsavedChangesGuardContext =
 
 export const UnsavedChangesGuardProvider: FC<PropsWithChildren> = ({ children }) => {
   const dialogue = useDialogue ()
-  const sourcesRef = useRef (new Map<symbol, UnsavedChangesSource> ())
-  const bypassNextNavigationRef = useRef<symbol | null> (null)
-  const [revision, setRevision] = useState (0)
-  const dialogueOpenRef = useRef (false)
-  const handlingBlockedTransitionRef = useRef (false)
+  const [source, setSource] = useState<UnsavedChangesSource | null> (null)
 
   const registerUnsavedChangesSource = useCallback ((
-      source: UnsavedChangesSource,
-  ): (() => void) => {
-    const sourceId = Symbol ('unsaved-changes-source')
-    sourcesRef.current.set (sourceId, source)
-    setRevision (current => current + 1)
-
-    return () => {
-      if (!(sourcesRef.current.delete (sourceId)))
-        return
-
-      setRevision (current => current + 1)
-    }
+      nextSource: UnsavedChangesSource | null,
+  ) => {
+    setSource (nextSource)
   }, [])
 
-  const allowNextNavigation = useCallback (() => {
-    const token = Symbol ('allowed-navigation')
-    bypassNextNavigationRef.current = token
-
-    queueMicrotask (() => {
-      if (bypassNextNavigationRef.current === token)
-        bypassNextNavigationRef.current = null
-    })
-  }, [])
-
-  const sources = useMemo (
-      () => [...sourcesRef.current.values ()],
-      [revision],
-  )
-  const dirtySources = useMemo (
-      () => sources.filter (source => source.dirty),
-      [sources],
-  )
-  const hasUnsavedChanges = dirtySources.length > 0
-  const hasUnsavedChangesRef = useRef (hasUnsavedChanges)
-  hasUnsavedChangesRef.current = hasUnsavedChanges
-  const shouldBlock = useCallback (() => {
-    if (bypassNextNavigationRef.current != null)
-      {
-        bypassNextNavigationRef.current = null
-        return false
-      }
-
-    return hasUnsavedChangesRef.current
-  }, [])
-  const blocker = useBlocker (shouldBlock)
-
-  const confirmDiscardChanges = useCallback (async (): Promise<boolean> => {
-    if (!(hasUnsavedChanges))
+  const confirmDiscardNavigation = useCallback (async (): Promise<boolean> => {
+    if (!(source?.dirty))
       return true
 
-    if (dialogueOpenRef.current)
-      return false
-
-    dialogueOpenRef.current = true
-
-    try
-    {
     const confirmed = await dialogue.confirm ({
-          title: '変更が破棄してページ移動しますか?',
+	title: '未保存の変更があります',
+	description: 'このまま移動すると、保存していない変更は失われます。',
+	cancelText: 'このページに残る',
 	confirmText: '変更を破棄して移動',
 	variant: 'danger' })
     if (!(confirmed))
       return false
 
+    await source.discard ()
     return true
-    }
-    finally
-    {
-      dialogueOpenRef.current = false
-    }
-  }, [dialogue, hasUnsavedChanges])
-
-  useEffect (() => {
-    if (blocker.state !== 'blocked' || handlingBlockedTransitionRef.current)
-      return
-
-    handlingBlockedTransitionRef.current = true
-    void (async () => {
-      try
-      {
-        const confirmed = await confirmDiscardChanges ()
-        if (!(confirmed))
-          {
-            blocker.reset ()
-            return
-          }
-
-        let discardResults: Array<void | Promise<void>>
-        try
-        {
-	  discardResults = dirtySources.map (source => source.discard ())
-        }
-        catch
-        {
-	  blocker.reset ()
-	  return
-        }
-
-        blocker.proceed ()
-        await Promise.allSettled (discardResults)
-      }
-      finally
-      {
-        handlingBlockedTransitionRef.current = false
-      }
-    }) ()
-  }, [blocker, confirmDiscardChanges, dirtySources])
-
-  useEffect (() => {
-    if (!(hasUnsavedChanges))
-      return
-
-    const handleBeforeUnload = (event: BeforeUnloadEvent) => {
-      event.preventDefault ()
-      event.returnValue = ''
-    }
-
-    window.addEventListener ('beforeunload', handleBeforeUnload)
-    return () => {
-      window.removeEventListener ('beforeunload', handleBeforeUnload)
-    }
-  }, [hasUnsavedChanges])
+  }, [dialogue, source])
 
   const value = useMemo<UnsavedChangesGuardContextValue> (() => ({
-      hasUnsavedChanges,
+      hasUnsavedChanges: source?.dirty === true,
       registerUnsavedChangesSource,
-      allowNextNavigation,
-  }), [
-      allowNextNavigation,
-      hasUnsavedChanges,
-      registerUnsavedChangesSource,
-  ])
+      confirmDiscardNavigation,
+  }), [confirmDiscardNavigation, registerUnsavedChangesSource, source?.dirty])
 
   return (
       <UnsavedChangesGuardContext.Provider value={value}>
@@ -181,24 +59,11 @@ export const UnsavedChangesGuardProvider: FC<PropsWithChildren> = ({ children })
 }
 
 
-export const useUnsavedChangesGuard = (
-    options?: UseUnsavedChangesGuardOptions,
-): UnsavedChangesGuardContextValue => {
+export const useUnsavedChangesGuard = (): UnsavedChangesGuardContextValue => {
   const context = useContext (UnsavedChangesGuardContext)
 
   if (context == null)
     throw new Error ('UnsavedChangesGuardProvider が必要です．')
 
-  const { registerUnsavedChangesSource } = context
-
-  useEffect (() => {
-    if (options == null)
-      return
-
-    return registerUnsavedChangesSource ({
-        dirty: options.dirty,
-        discard: options.onDiscard ?? (() => undefined) })
-  }, [options?.dirty, options?.onDiscard, registerUnsavedChangesSource])
-
   return context
 }

frontend/src/pages/materials/MaterialListPage.tsx

@@ -482,7 +482,7 @@ const MaterialListPage: FC = () => {
 			className={inputClass (invalid)}>
 		      <option value="all">すべて</option>
 		      <option value="tagged">タグあり</option>
-		      <option value="untagged"></option>
+		      <option value="untagged">タグなし</option>
 		    </select>)}
 	      </FormField>
 

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

@@ -1,157 +0,0 @@
-import { fireEvent, screen, waitFor } from '@testing-library/react'
-import { useLocation } from 'react-router-dom'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import PostImportReviewPage from '@/pages/posts/PostImportReviewPage'
-import { buildUser } from '@/test/factories'
-import { renderWithProviders } from '@/test/render'
-
-import type { ReactNode } from 'react'
-
-const api = vi.hoisted (() => ({
-  apiGet: vi.fn (),
-  apiPost: vi.fn (),
-  isApiError: vi.fn (() => false) }))
-
-vi.mock ('@/lib/api', () => api)
-vi.mock ('framer-motion', () => ({
-  AnimatePresence: ({ children }: { children?: ReactNode }) => <>{children}</>,
-  motion: {
-    div: ({ children }: { children?: ReactNode }) => <div>{children}</div>,
-    main: ({ children }: { children?: ReactNode }) => <main>{children}</main> } }))
-
-const metadata = (url: string, title: string) => ({
-  url,
-  title,
-  thumbnailBase: 'https://example.com/thumbnail.jpg',
-  originalCreatedFrom: '',
-  originalCreatedBefore: '',
-  duration: '',
-  tags: '',
-  parentPostIds: [],
-  fieldWarnings: { },
-  baseWarnings: [],
-  displayTags: [] })
-
-
-const LocationProbe = () => {
-  const location = useLocation ()
-  return <output aria-label="current-location">{location.pathname}{location.search}</output>
-}
-
-
-const renderReviewPage = (urls: string[]) => {
-  const search = urls.map (url => encodeURIComponent (url)).join ('+')
-  return renderWithProviders (
-      <>
-	<PostImportReviewPage user={buildUser ()}/>
-	<LocationProbe/>
-      </>,
-      { route: `/posts/new?urls=${ search }` })
-}
-
-describe ('PostImportReviewPage', () => {
-  beforeEach (() => {
-    vi.clearAllMocks ()
-    api.isApiError.mockReturnValue (false)
-  })
-
-  it ('fetches metadata with at most four concurrent requests', async () => {
-    const resolvers: Array<(value: ReturnType<typeof metadata>) => void> = []
-    api.apiGet.mockImplementation ((_path, options) =>
-	new Promise (resolve => {
-	  resolvers.push (resolve)
-	  const url = String (options.params.url)
-	  void url
-	}))
-    const urls = Array.from (
-	{ length: 6 },
-	(_, index) => `https://example.com/${ index + 1 }`)
-
-    renderReviewPage (urls)
-
-    await waitFor (() => expect (api.apiGet).toHaveBeenCalledTimes (4))
-
-    resolvers[0]?.(metadata (urls[0]!, 'first'))
-
-    expect (await screen.findAllByText ('first')).toHaveLength (2)
-    await waitFor (() => expect (api.apiGet).toHaveBeenCalledTimes (5))
-    expect (screen.getByRole ('button', { name: '追加' })).toBeDisabled ()
-
-    for (let index = 1; index < resolvers.length; ++index)
-      resolvers[index]?.(metadata (urls[index]!, `post ${ index + 1 }`))
-  })
-
-  it ('keeps successful rows when another metadata request fails', async () => {
-    api.apiGet
-	.mockResolvedValueOnce (metadata ('https://example.com/one', 'first'))
-	.mockRejectedValueOnce (new TypeError ('network'))
-
-    renderReviewPage (['https://example.com/one', 'https://example.com/two'])
-
-    expect (await screen.findAllByText ('first')).toHaveLength (2)
-    await waitFor (() => {
-      expect (screen.getAllByText ('登録不可')).toHaveLength (2)
-    })
-    expect (screen.getAllByRole ('button', { name: '編輯' })[0]).toBeEnabled ()
-  })
-
-  it ('shows existing posts with Active Storage thumbnail precedence', async () => {
-    api.apiGet.mockResolvedValue ({
-      ...metadata ('https://example.com/post', ''),
-      existingPostId: 24,
-      existingPost: {
-	id: 24,
-	title: 'existing post',
-	url: 'https://example.com/post',
-	thumbnail: 'https://example.com/storage.jpg',
-	thumbnailBase: 'https://example.com/base.jpg' } })
-
-    renderReviewPage (['https://example.com/post'])
-
-    const disclosure = await screen.findByRole ('button', {
-      name: '既存投稿による自動スキップ 1件' })
-    expect (screen.getByRole ('button', { name: '追加' })).toBeDisabled ()
-
-    fireEvent.click (disclosure)
-
-    expect ((await screen.findAllByRole ('img', { name: 'サムネール' }))[0])
-	.toHaveAttribute ('src', 'https://example.com/storage.jpg')
-  })
-
-  it ('keeps a recoverable bulk failure on the review screen', async () => {
-    api.apiGet.mockResolvedValue (
-	metadata ('https://example.com/post', 'new post'))
-    api.apiPost.mockResolvedValue ({
-      results: [{
-	status: 'failed',
-	recoverable: true,
-	errors: { title: ['invalid title'] } }] })
-
-    renderReviewPage (['https://example.com/post'])
-
-    fireEvent.click (await screen.findByRole ('button', { name: '追加' }))
-
-    expect (await screen.findAllByText ('登録失敗')).toHaveLength (2)
-    expect (screen.getAllByText ('invalid title')).toHaveLength (2)
-    expect (screen.getAllByRole ('button', { name: '編輯' })[0]).toBeEnabled ()
-    expect (screen.getAllByRole ('button', { name: '再試行' })[0]).toBeEnabled ()
-    expect (screen.getByLabelText ('current-location')).toHaveTextContent ('/posts/new?')
-  })
-
-  it ('navigates to /posts after every submitted row is created', async () => {
-    api.apiGet.mockResolvedValue (
-	metadata ('https://example.com/post', 'new post'))
-    api.apiPost.mockResolvedValue ({
-      results: [{ status: 'created', post: { id: 42 } }] })
-
-    renderReviewPage (['https://example.com/post'])
-
-    fireEvent.click (await screen.findByRole ('button', { name: '追加' }))
-
-    await waitFor (() => {
-      expect (screen.getByLabelText ('current-location')).toHaveTextContent ('/posts')
-    })
-    expect (api.apiPost).toHaveBeenCalledWith ('/posts/bulk', expect.any (FormData))
-  })
-})

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

@@ -1,67 +0,0 @@
-import { fireEvent, screen } from '@testing-library/react'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import PostImportSourcePage from '@/pages/posts/PostImportSourcePage'
-import { buildUser } from '@/test/factories'
-import { renderWithProviders } from '@/test/render'
-
-const router = vi.hoisted (() => ({ navigate: vi.fn () }))
-
-vi.mock ('react-router-dom', async importOriginal => ({
-  ...await importOriginal<typeof import('react-router-dom')> (),
-  useNavigate: () => router.navigate }))
-
-describe ('PostImportSourcePage', () => {
-  beforeEach (() => {
-    sessionStorage.clear ()
-    vi.clearAllMocks ()
-  })
-
-  it ('validates an empty source 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 (router.navigate).not.toHaveBeenCalled ()
-  })
-
-  it ('reports frontend URL issues with original line numbers', () => {
-    renderWithProviders (<PostImportSourcePage user={buildUser ()}/>)
-    const input = screen.getByRole ('textbox', { name: '' })
-
-    fireEvent.change (input, {
-      target: { value: '\nftp://example.com/file\nhttps://example.com/valid' } })
-    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 (router.navigate).not.toHaveBeenCalled ()
-  })
-
-  it ('navigates with individually encoded URLs without calling an API', () => {
-    renderWithProviders (<PostImportSourcePage user={buildUser ()}/>)
-
-    fireEvent.change (screen.getByRole ('textbox', { name: '' }), {
-      target: {
-	value: 'https://example.com/one+a\nhttps://example.com/two?value=b+c' } })
-    fireEvent.click (screen.getByRole ('button', { name: '次へ' }))
-
-    expect (router.navigate).toHaveBeenCalledWith (
-	'/posts/new?urls=https%3A%2F%2Fexample.com%2Fone%2Ba'
-	+ '+https%3A%2F%2Fexample.com%2Ftwo%3Fvalue%3Db%2Bc')
-  })
-
-  it ('disables Next when the encoded request target reaches 4096 bytes', () => {
-    renderWithProviders (<PostImportSourcePage user={buildUser ()}/>)
-    const input = screen.getByRole ('textbox', { name: '' })
-
-    fireEvent.change (input, {
-      target: { value: `https://example.com/${ 'a'.repeat (4_100) }` } })
-
-    expect (screen.getByRole ('button', { name: '次へ' })).toBeDisabled ()
-  })
-})

frontend/src/pages/posts/PostImportSourcePage.tsx

@@ -1,181 +0,0 @@
-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 {
-    buildPostNewReviewPath,
-    isPostNewReviewPathWithinLimit,
-} from '@/lib/postNewQueryState'
-import {
-    countImportSourceLines,
-    extractImportSourceUrls,
-    validateImportSource,
-} from '@/lib/postImportSourceValidation'
-import {
-    loadPostImportSourceDraft,
-    savePostImportSourceDraft,
-} from '@/lib/postImportStorage'
-import { canEditContent } from '@/lib/users'
-import Forbidden from '@/pages/Forbidden'
-
-import type { FC } from 'react'
-
-import type { User } from '@/types'
-
-type Props = { user: User | null }
-
-const MAX_ROWS = 100
-const SOURCE_ERROR_ID = 'post-import-source-error'
-const SOURCE_ISSUES_ID = 'post-import-source-issues'
-
-
-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 sourceUrls = extractImportSourceUrls (source)
-  const withinPathLimit = isPostNewReviewPathWithinLimit (sourceUrls)
-  const messages = sourceError != null ? [sourceError] : []
-  const sourceDescribedBy =
-      [sourceError != null ? SOURCE_ERROR_ID : null,
-       sourceIssues.length > 0 ? SOURCE_ISSUES_ID : null]
-      .filter (value => value != null)
-      .join (' ')
-
-  useEffect (() => {
-    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
-      }
-    if (!(withinPathLimit))
-      return
-
-    setLoading (true)
-    setSourceIssues ([])
-    setSourceError (null)
-    try
-    {
-      navigate (buildPostNewReviewPath (sourceUrls))
-    }
-    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 リスト（1 行 1 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="relative z-10 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="pointer-events-auto shrink-0"
-		onClick={preview}
-		disabled={loading || !(withinPathLimit)}>
-	      次へ
-	    </Button>
-	  </div>
-	</Form>
-      </MainArea>)
-}
-
-export default PostImportSourcePage

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

@@ -1,4 +1,4 @@
-import { screen } from '@testing-library/react'
+import { fireEvent, screen, waitFor } from '@testing-library/react'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import PostNewPage from '@/pages/posts/PostNewPage'
@@ -8,33 +8,99 @@ import { renderWithProviders } from '@/test/render'
 const api = vi.hoisted (() => ({
   apiGet:     vi.fn (),
   apiPost:    vi.fn (),
-  isApiError: vi.fn () }))
+  isApiError: vi.fn (),
+}))
+
+const toastApi = vi.hoisted (() => ({
+  toast: vi.fn (),
+}))
 
 vi.mock ('@/lib/api', () => api)
+vi.mock ('@/components/ui/use-toast', () => toastApi)
 
 describe ('PostNewPage', () => {
   beforeEach (() => {
     vi.clearAllMocks ()
     api.isApiError.mockReturnValue (false)
-    api.apiGet.mockResolvedValue ({
-      url: 'https://example.com/post',
-      title: 'post',
-      tags: '' })
-    sessionStorage.clear ()
   })
 
-  it ('shows the source page on /posts/new', () => {
-    renderWithProviders (<PostNewPage user={buildUser ()}/>, {
-      route: '/posts/new' })
+  it ('blocks guests', () => {
+    renderWithProviders (<PostNewPage user={buildUser ({ role: 'guest' })}/>)
 
-    expect (screen.getByRole ('heading', { name: '広場に投稿を追加' })).toBeInTheDocument ()
+    expect (screen.getByText ('403')).toBeInTheDocument ()
   })
 
-  it ('shows the review page when query state is present', () => {
-    renderWithProviders (<PostNewPage user={buildUser ()}/>, {
-      route: '/posts/new?urls=https%3A%2F%2Fexample.com%2Fpost' })
+  it ('submits a new post with manual title and thumbnail fetch UI', async () => {
+    api.apiPost.mockResolvedValueOnce ({})
+    api.apiGet.mockResolvedValue ([])
 
-    expect (screen.getByRole ('heading', { name: '追加内容確認' })).toBeInTheDocument ()
-    expect (screen.queryByText ('広場に投稿を追加')).not.toBeInTheDocument ()
+    renderWithProviders (<PostNewPage user={buildUser ({ role: 'member' })}/>)
+
+    const textboxes = screen.getAllByRole ('textbox')
+    fireEvent.change (textboxes[0], { target: { value: 'https://example.com/post' } })
+    fireEvent.change (textboxes[1], { target: { value: '投稿タイトル' } })
+    fireEvent.change (textboxes[2], { target: { value: '1 2' } })
+    fireEvent.change (textboxes[3], { target: { value: 'tag1 tag2' } })
+    fireEvent.click (screen.getByRole ('button', { name: '追加' }))
+
+    await waitFor (() => {
+      expect (api.apiPost).toHaveBeenCalledWith (
+          '/posts',
+          expect.any (FormData),
+          { headers: { 'Content-Type': 'multipart/form-data' } },
+      )
+    })
+    const formData = api.apiPost.mock.calls[0]?.[1] as FormData
+    expect (formData.get ('url')).toBe ('https://example.com/post')
+    expect (formData.get ('title')).toBe ('投稿タイトル')
+    expect (formData.get ('parent_post_ids')).toBe ('1 2')
+    expect (formData.get ('tags')).toBe ('tag1 tag2')
+    expect (toastApi.toast).toHaveBeenCalledWith ({ title: '投稿成功!' })
+  })
+
+  it ('preserves duration while the video tag is temporarily removed', () => {
+    api.apiGet.mockResolvedValue ([])
+
+    renderWithProviders (<PostNewPage user={buildUser ({ role: 'member' })}/>)
+
+    const tags = screen.getAllByRole ('textbox')[3]
+    fireEvent.change (tags, { target: { value: '動画' } })
+    fireEvent.change (screen.getByRole ('spinbutton'), { target: { value: '180.5' } })
+
+    fireEvent.change (tags, { target: { value: 'general-tag' } })
+    expect (screen.queryByRole ('spinbutton')).not.toBeInTheDocument ()
+
+    fireEvent.change (tags, {
+      target: { value: '動画 general-tag' },
+    })
+    expect (screen.getByRole ('spinbutton')).toHaveValue (180.5)
+  })
+
+  it ('shows 422 validation errors for post fields', async () => {
+    api.apiGet.mockResolvedValue ([])
+    api.isApiError.mockReturnValue (true)
+    api.apiPost.mockRejectedValueOnce ({
+      response: {
+        status: 422,
+        data:   {
+          type:        'validation_error',
+          message:     '入力内容を確認してください．',
+          errors:      { tags: ['ニコニコ・タグは直接指定できません．'] },
+          base_errors: ['投稿内容を確認してください．'],
+        },
+      },
+    })
+
+    renderWithProviders (<PostNewPage user={buildUser ({ role: 'member' })}/>)
+
+    const textboxes = screen.getAllByRole ('textbox')
+    fireEvent.change (textboxes[0], { target: { value: 'https://example.com/post' } })
+    fireEvent.change (textboxes[1], { target: { value: '投稿タイトル' } })
+    fireEvent.change (textboxes[3], { target: { value: 'nico:nico_tag' } })
+    fireEvent.click (screen.getByRole ('button', { name: '追加' }))
+
+    expect (await screen.findByText ('投稿内容を確認してください．')).toBeInTheDocument ()
+    expect (screen.getByText ('ニコニコ・タグは直接指定できません．')).toBeInTheDocument ()
+    expect (screen.getAllByRole ('textbox')[3]).toHaveAttribute ('aria-invalid', 'true')
   })
 })