Keep binaries until inspected; seeding writes binaries only for inspection

Par2 naming needs the fingerprint inspection stores on a binary, and the
GC deleted seeded binaries (6 h unfingerprinted, 48 h stale) long before
the inspection queue reached them. binaries.awaiting_inspection protects
them for up to 7 days; the GC deletes use partial indexes so they don't
read past waiting rows. Seeding no longer creates binaries for files that
aren't inspected (~85% of a.b.ath), which only churned the table.

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

app/services/BinaryFileService.ts

@@ -99,6 +99,7 @@ class BinaryFileService {
       const id = insertedByKey.get(b.file_key) ?? byKey.get(b.file_key)
       if (id) fileIdOf.set(Number(b.id), id)
     }
+    const fresher = new Map(fresh.map((b) => [b.file_key, b]))
     result.saved = inserted.length
     result.existing = fileIdOf.size - inserted.length
 
@@ -110,9 +111,12 @@ class BinaryFileService {
           `SELECT id FROM binaries WHERE id IN (SELECT unnest(?::bigint[])) ORDER BY file_key FOR UPDATE`,
           [linked.map((b) => b.id)]
         )
+        // Files queued for inspection below keep their binary until it has its fingerprint (par2 naming, D16).
+        const queued = new Set(inserted.filter((row) => row.file_key && ContentService.isCandidate(String(fresher.get(row.file_key)?.name ?? ''))).map((row) => row.id))
         await trx.rawQuery(
-          `UPDATE binaries b SET file_id = v.file_id FROM unnest(?::bigint[], ?::bigint[]) AS v(id, file_id) WHERE b.id = v.id`,
-          [linked.map((b) => b.id), linked.map((b) => fileIdOf.get(Number(b.id))!)]
+          `UPDATE binaries b SET file_id = v.file_id, awaiting_inspection = CASE WHEN v.queued THEN true ELSE b.awaiting_inspection END
+           FROM unnest(?::bigint[], ?::bigint[], ?::boolean[]) AS v(id, file_id, queued) WHERE b.id = v.id`,
+          [linked.map((b) => b.id), linked.map((b) => fileIdOf.get(Number(b.id))!), linked.map((b) => queued.has(fileIdOf.get(Number(b.id))!))]
         )
       })
       // Header-derived parts are in the file's segment list now; body-derived ones (with a CRC) stay for split checks (D20).
@@ -120,7 +124,6 @@ class BinaryFileService {
     }
 
     // As for one file before: an SFV posted earlier may list them (D34), then inspection.
-    const fresher = new Map(fresh.map((b) => [b.file_key, b]))
     const added = inserted.flatMap((row) => {
       const b = row.file_key ? fresher.get(row.file_key) : undefined
       return b

app/services/ContentService.ts

@@ -165,6 +165,8 @@ class ContentService {
         .update({
           size: db.raw('coalesce(size, ?)', [probe.size]),
           md5_16k: db.raw('coalesce(md5_16k, ?)', [probe.md5_16k]),
+          // Inspected: the GC may delete it again by its usual rules (LOG.md 2026-10-06 (11)).
+          awaiting_inspection: null,
         })
     }
 

app/services/SeedService.ts

@@ -62,27 +62,38 @@ class SeedService {
     for (const row of await db.from('files').whereIn('file_key', rows.map((r) => r.file_key)).select('id', 'file_key')) {
       fileIds.set(row.file_key, Number(row.id))
     }
-    // The completed binary worker:file would have left behind; an existing one just learns its file.
-    const binaries = files.map((file, i) => ({
-      file_key: file.fileKey,
-      poster: file.poster,
-      subject: file.subject,
-      name: file.name,
-      total_parts: file.totalParts,
-      groups: rows[i].groups,
-      posted_at: postedOf(file) ?? null,
-      first_seen_at: now,
-      last_seen_at: now,
-      completed_at: now,
-      release_id: rows[i].release_id,
-      file_id: fileIds.get(file.fileKey) ?? null,
-    }))
+    // A completed binary, as worker:file would have left behind, only for files queued for content
+    // inspection: par2 naming (D16) needs the fingerprint inspection stores on it. For the others
+    // (~85% in a.b.ath) it was only GC churn: 1.6M rows an hour inserted and deleted (LOG.md 2026-10-06 (11)).
+    const insertedKeys = new Set(inserted.map((row) => row.file_key))
+    const binaries = files.flatMap((file, i) => {
+      if (!ContentService.isCandidate(file.name)) return []
+      return [{
+        file_key: file.fileKey,
+        poster: file.poster,
+        subject: file.subject,
+        name: file.name,
+        total_parts: file.totalParts,
+        groups: rows[i].groups,
+        posted_at: postedOf(file) ?? null,
+        first_seen_at: now,
+        last_seen_at: now,
+        completed_at: now,
+        release_id: rows[i].release_id,
+        file_id: fileIds.get(file.fileKey) ?? null,
+        // New files are queued for inspection below; an existing file was queued when it was added.
+        awaiting_inspection: insertedKeys.has(file.fileKey) ? true : null,
+      }]
+    })
     binaries.sort((a, b) => a.file_key.localeCompare(b.file_key))
     for (let i = 0; i < binaries.length; i += insertLimits.rows) {
       await knex('binaries')
         .insert(binaries.slice(i, i + insertLimits.rows))
         .onConflict('file_key')
-        .merge({ file_id: knex.raw('coalesce(binaries.file_id, excluded.file_id)') as any })
+        .merge({
+          file_id: knex.raw('coalesce(binaries.file_id, excluded.file_id)') as any,
+          awaiting_inspection: knex.raw('coalesce(binaries.awaiting_inspection, excluded.awaiting_inspection)') as any,
+        })
     }
 
     // As worker:file does for a new file: an SFV posted earlier may list it (D34), then inspection.