Content type and archive listing move from files to file_details

Every probe rewrote its file's row on the HDD (content_type, archive):
a new row version on a random page and an entry in each of the five
indexes. They now live in file_details on the NVMe; files rows are
inserted once. files:move-details copies the existing values after
the deploy; a later migration drops the old columns.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

app/services/ArchiveService.ts

@@ -1,5 +1,6 @@
 import db from '@adonisjs/lucid/services/db'
 import logger from '@adonisjs/core/services/logger'
+import FileStore from '#services/FileStore'
 import IngestService from '#services/IngestService'
 import type { RarInfo } from '#lib/rar/index'
 import { fileStem, isGenericName, rarReleaseIdentity } from '#lib/release/index'
@@ -24,7 +25,7 @@ class ArchiveService {
   async record(file: any, binary: any, info: RarInfo): Promise<ArchiveResult> {
     const { next: _next, ...listing } = info
     const stored = { ...listing, entries: info.entries.slice(0, MAX_ENTRIES).map(({ stored: _s, dataOffset: _d, ...entry }) => entry) }
-    await db.from('files').where('id', file.id).update({ archive: JSON.stringify(stored) })
+    await FileStore.setDetails(Number(file.id), { archive: stored })
 
     let releaseId = file.release_id ?? binary?.release_id ?? null
     let grouped = false

app/services/ContentService.ts

@@ -24,7 +24,7 @@ import { sevenZipVolume } from '#lib/sevenzip/index'
 import SevenZipService from '#services/SevenZipService'
 import SfvService from '#services/SfvService'
 import ArchiveWalkService from '#services/ArchiveWalkService'
-import { segmentsOf } from '#services/FileStore'
+import FileStore, { segmentsOf } from '#services/FileStore'
 import GarbageFilter from '#services/GarbageFilter'
 
 /**
@@ -136,7 +136,7 @@ class ContentService {
     if (await GarbageFilter.skipProbe(file)) return null
     if ((sevenZipVolume(String(file.real_name ?? file.filename)) ?? 0) > 1) {
       const volumes = await SevenZipService.volumes(file)
-      if (!volumes || volumes[0].archive) return null
+      if (!volumes || (await FileStore.details(Number(volumes[0].id))).archive) return null
       return this.prepare(Number(volumes[0].id))
     }
     const segments = segmentsOf(file)
@@ -185,7 +185,7 @@ class ContentService {
     if (!file) return result
     const binary = await db.from('binaries').where('file_id', task.fileId).first()
     const { contentType } = probe
-    await db.from('files').where('id', file.id).update({ content_type: contentType })
+    await FileStore.setDetails(Number(file.id), { content_type: contentType })
     if (contentType === 'missing') {
       // Nothing to read; the binary needn't wait for inspection any more.
       if (binary) await db.from('binaries').where('id', binary.id).update({ awaiting_inspection: null })

app/services/FileStore.ts

@@ -37,10 +37,35 @@ export function loadedSegments(stored: Buffer | null): Segment[] {
   return stored ? unpackSegments(stored) : []
 }
 
+/** What inspection learns about a file, kept beside `files` (LOG.md 2026-10-08 (14)). */
+export interface FileDetails {
+  content_type?: string | null
+  archive?: unknown
+}
+
+const DETAIL_COLUMNS = ['content_type', 'archive'] as const
+
 /** Rows per INSERT, well below Postgres' 65,535 bind parameters (tests lower it). */
 export const insertLimits = { rows: 2000 }
 
 class FileStore {
+  /** Sets some of a file's details, leaving the others as they are. */
+  async setDetails(fileId: number, details: FileDetails, client: Pick<QueryClientContract, 'rawQuery'> = db) {
+    const columns = DETAIL_COLUMNS.filter((c) => details[c] !== undefined)
+    if (columns.length === 0) return
+    const values = columns.map((c) => (c === 'archive' && details[c] !== null ? JSON.stringify(details[c]) : details[c]))
+    await client.rawQuery(
+      `INSERT INTO file_details (file_id, ${columns.join(', ')}) VALUES (?, ${columns.map(() => '?').join(', ')})
+       ON CONFLICT (file_id) DO UPDATE SET ${columns.map((c) => `${c} = excluded.${c}`).join(', ')}`,
+      [fileId, ...(values as any[])]
+    )
+  }
+
+  /** A file's details (empty when it has none). */
+  async details(fileId: number): Promise<FileDetails> {
+    return (await db.from('file_details').where('file_id', fileId).select('content_type', 'archive').first()) ?? {}
+  }
+
   /**
    * Inserts files, skipping those whose `file_key` exists. Returns the rows
    * that were inserted (id, filename, file_key). `files` is partitioned by id
@@ -88,12 +113,24 @@ class FileStore {
         return { ...file, segments: packSegments(sorted), first_message_id: sorted[0]?.id ?? null }
       })
     if (rows.length === 0) return []
+    // Details given with a new file (e.g. a known content type) go to file_details.
+    const details = rows.map((row: Record<string, unknown>) => {
+      const d: FileDetails = {}
+      for (const c of DETAIL_COLUMNS) if (c in row) (d as any)[c] = row[c]
+      for (const c of DETAIL_COLUMNS) delete row[c]
+      return d
+    })
     // A statement takes at most 65,535 parameters: ~5,400 rows of 12 columns.
     const inserted: { id: number; filename: string; file_key: string | null }[] = []
     for (let i = 0; i < rows.length; i += insertLimits.rows) {
       const chunk = await client.knexQuery().table('files').insert(rows.slice(i, i + insertLimits.rows)).onConflict().ignore().returning(['id', 'filename', 'file_key'])
       for (const row of chunk) inserted.push({ id: Number(row.id), filename: row.filename, file_key: row.file_key ?? null })
     }
+    const detailsByKey = new Map(rows.map((row: Record<string, unknown>, i: number) => [row.file_key ?? row.filename, details[i]]))
+    for (const row of inserted) {
+      const d = detailsByKey.get(row.file_key ?? row.filename)
+      if (d && Object.keys(d).length > 0) await this.setDetails(row.id, d, client)
+    }
     return inserted
   }
 }

app/services/GarbageFilter.ts

@@ -196,8 +196,8 @@ class GarbageFilter {
   async seed(percent: number): Promise<number> {
     const { rows } = await db.rawQuery(
       `SELECT DISTINCT ON (f.release_id) f.release_id, f.first_message_id, f.groups
-       FROM files f TABLESAMPLE SYSTEM (?)
-       WHERE f.content_type IS NOT NULL AND f.release_id IS NOT NULL AND NOT is_readable_name(f.filename)`,
+       FROM files f TABLESAMPLE SYSTEM (?) JOIN file_details d ON d.file_id = f.id
+       WHERE d.content_type IS NOT NULL AND f.release_id IS NOT NULL AND NOT is_readable_name(f.filename)`,
       [percent]
     )
     let added = 0

app/services/SearchService.ts

@@ -70,8 +70,8 @@ const VISIBLE_SQL = `(r.file_count > 0 OR r.source = 'spot')`
 
 /** Incomplete, and every file is a par2 file: nothing to download but repair data. */
 const PAR2_ONLY_SQL = `(r.file_count > 0 AND NOT r.complete AND NOT EXISTS (
-  SELECT 1 FROM files f WHERE f.release_id = r.id
-    AND f.content_type IS DISTINCT FROM 'par2' AND f.filename !~* '\\.par2$'))`
+  SELECT 1 FROM files f LEFT JOIN file_details d ON d.file_id = f.id WHERE f.release_id = r.id
+    AND d.content_type IS DISTINCT FROM 'par2' AND f.filename !~* '\\.par2$'))`
 
 /** A search word as an ILIKE pattern; dots, underscores, dashes and spaces are interchangeable. */
 function pattern(word: string): string {

app/services/SfvService.ts

@@ -1,5 +1,6 @@
 import db from '@adonisjs/lucid/services/db'
 import logger from '@adonisjs/core/services/logger'
+import FileStore from '#services/FileStore'
 import { parseSfv, sfvReleaseName } from '#lib/content/index'
 
 /** Releases made by name rules alone; an SFV's listing outranks them. */
@@ -30,7 +31,7 @@ class SfvService {
       .insert(entries.map((e) => ({ release_id: releaseId, name: e.name, crc: e.crc, poster: sfvFile.poster, posted_at: postedAt })))
       .onConflict(['release_id', 'name'])
       .ignore()
-    await db.from('files').where('id', sfvFile.id).update({ content_type: 'sfv' })
+    await FileStore.setDetails(Number(sfvFile.id), { content_type: 'sfv' })
 
     const candidates = await db
       .from('files as f')