Probe 7z listings and ZIP starts

7z keeps its file list at the end of the archive, so the 7z-tail
candidates (the last segment of the highest volume) were queued but
never probed, and the .7z.001 start only gave the type. The prober now
claims 7z-tail candidates after the archives; lib/sevenzip finds the end
header in the article, decodes the LZMA-packed header (a TypeScript port
of the LZMA SDK's reference decoder) and lists the files with their
sizes. An AES-encrypted header means passworded without names. Names
feed the inner name and the judge's fake rule.

An unsplit .7z of several segments now also gets a tail candidate, and
.zip files an archive candidate: their first segment's local headers
give the first entries and whether they are encrypted. Both in the Rust
edge and the TypeScript indexer.

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

tests/unit/probe/inspect.spec.ts

@@ -1,5 +1,6 @@
 import { test } from '@japa/runner'
 import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
 import { crc32 } from 'node:zlib'
 import yencode from 'yencode'
 import { crc32Hex } from '#lib/yenc/index'
@@ -148,4 +149,45 @@ test.group('probe / innerName', () => {
     // Nor does packaging: a lone par2 volume.
     assert.isNull(innerName([{ kind: 'lone', result: { yencName: 'a1b2.vol007+08.par2', size: 1, type: 'par2' } }], 'x9y8'))
   })
+
+  test("a 7z-tail: the listing from the last segment of the last volume; one that isn't the last segment: none", ({ assert }) => {
+    const tail = readFileSync(new URL('../../fixtures/sevenzip/split-last-volume.tail', import.meta.url))
+    // The volume's last 8,000 bytes as its third part, of a volume 1,000,000 bytes long.
+    const last = tail.subarray(tail.length - 8000)
+    const part = (data: Buffer, begin: number) =>
+      Buffer.from(
+        [`=ybegin part=3 total=3 line=128 size=1000000 name=x.7z.004`, `=ypart begin=${begin} end=${begin + data.length - 1}`, yencode.encode(data).toString('latin1'), `=yend size=${data.length} part=3 pcrc32=${crc32Hex(data)}`].join('\r\n'),
+        'latin1'
+      )
+    const result = inspect(part(last, 1_000_000 - 8000 + 1), '7z-tail')
+    assert.equal(result.entries, 4)
+    assert.deepEqual(result.names?.[0], 'Some.Movie.2020.1080p.BluRay.x264-GRP/some.movie.2020.1080p.bluray.x264-grp.mkv')
+    assert.isFalse(result.passworded)
+    assert.isUndefined(inspect(part(last, 1), '7z-tail').names)
+    const encrypted = readFileSync(new URL('../../fixtures/sevenzip/header-encrypted.tail', import.meta.url))
+    const hidden = inspect(part(encrypted.subarray(encrypted.length - 8000), 1_000_000 - 8000 + 1), '7z-tail')
+    assert.isTrue(hidden.passworded)
+    assert.equal(hidden.entries, 0)
+    assert.isUndefined(hidden.names)
+    // A small 7z whole in one article, probed as an archive start.
+    assert.deepEqual(inspect(article(readFileSync(new URL('../../fixtures/sevenzip/tiny.7z', import.meta.url)), 'x.7z'), 'archive').names, ['b.nfo', 'a.txt'])
+  })
+
+  test('a ZIP start: the names of its first entries, and whether they are encrypted', ({ assert }) => {
+    const local = (name: string, data: Buffer, flags = 0) => {
+      const header = Buffer.alloc(30)
+      header.writeUInt32LE(0x04034b50, 0)
+      header.writeUInt16LE(flags, 6)
+      header.writeUInt32LE(data.length, 18)
+      header.writeUInt32LE(data.length, 22)
+      header.writeUInt16LE(Buffer.byteLength(name), 26)
+      return Buffer.concat([header, Buffer.from(name), data])
+    }
+    const zip = Buffer.concat([local('Album/', Buffer.alloc(0)), local('Album/01 - Track.flac', Buffer.alloc(3000, 1)), local('Album/cover.jpg', Buffer.alloc(500, 2))])
+    const plain = inspect(article(zip, 'album.zip'))
+    assert.equal(plain.type, 'zip')
+    assert.deepEqual(plain.names, ['Album/01 - Track.flac', 'Album/cover.jpg'])
+    assert.isFalse(plain.passworded)
+    assert.isTrue(inspect(article(local('secret.mkv', Buffer.alloc(100), 0x1), 'x.zip')).passworded)
+  })
 })