@preventive/triage 1.0.0-alpha.45 → 1.0.0-alpha.47

package/server-managed/npm-packages.ts

@@ -31,11 +31,12 @@ const PACKUMENT_BYTES = 64 * 1024 * 1024
 // limit until it is read and parsed: four packuments, or 32 version documents.
 const MAX_DOCUMENT_BYTES = 4 * PACKUMENT_BYTES
 // What a package may unpack to: the files' bytes and their count; the tar
-// stream holding them is bounded in npm-loads.ts.
+// stream holding them is bounded in npm-loads.ts. A repository directory's
+// are its own (repository-code.ts).
 export const MAX_NPM_PACKAGE_BYTES = 64 * 1024 * 1024
 export const MAX_NPM_PACKAGE_FILES = 20_000
 // The entries its tar stream may hold, read before any is counted as a file:
-// a directory's too, as a GitHub tree's tarball has one for each, npm's none.
+// a directory's too, though npm packs none.
 export const MAX_NPM_TAR_ENTRIES = 2 * MAX_NPM_PACKAGE_FILES
 // What the files may take as the viewer's JSON. Escaping grows a text up to
 // six times (a control character becomes `\u0001`), so it is counted before
@@ -153,14 +154,60 @@ async function publicWholeDocument(name: string, url: string, { limit, signal }:
   return json
 }
 
+// Whole documents being asked of npm as anyone asks, by URL and limit:
+// readers asking for one meanwhile share it, as opening a version asks for
+// its package's for its versions, its advisories and its risk at once; each
+// gives up on it alone once its own signal aborts, and it is given up on once
+// they all have. None is asked with the token. Read alike by every reader,
+// none changing it.
+const wholeAsks = new Map<string, { asked: Promise<Record<string, unknown> | null>; controller: AbortController; readers: number }>()
+
+function sharedWholeDocument(name: string, url: string, { limit, signal }: { limit: number; signal: AbortSignal }): Promise<Record<string, unknown> | null> {
+  if (signal.aborted) return Promise.reject(signal.reason)
+  const key = `${url} ${limit}`
+  let ask = wholeAsks.get(key)
+  if (!ask) {
+    const controller = new AbortController()
+    const created = { asked: publicWholeDocument(name, url, { limit, signal: controller.signal }), controller, readers: 0 }
+    const settle = () => { if (wholeAsks.get(key) === created) wholeAsks.delete(key) }
+    created.asked.then(settle, settle)
+    wholeAsks.set(key, ask = created)
+  }
+  const held = ask
+  held.readers++
+  return new Promise((answer, fail) => {
+    let left = false
+    const leave = () => {
+      if (left) return false
+      left = true
+      held.readers--
+      signal.removeEventListener('abort', onAbort)
+      return true
+    }
+    const onAbort = () => {
+      if (!leave()) return
+      if (held.readers === 0) {
+        if (wholeAsks.get(key) === held) wholeAsks.delete(key)
+        held.controller.abort(signal.reason)
+      }
+      fail(signal.reason)
+    }
+    const answered = (json: Record<string, unknown> | null) => { if (leave()) answer(json) }
+    const failed = (err: unknown) => { if (leave()) fail(err) }
+    signal.addEventListener('abort', onAbort, { once: true })
+    held.asked.then(answered, failed)
+  })
+}
+
 // Asked anonymously first, unless its caller knows npm has none for anyone
 // (`anonymous` false): a reader without private access stops there. One
 // with it asks again with the token where npmTokenReads says so, and the
 // answer is private. A whole document (`whole`) anyone may read is kept
-// (publicWholeDocument).
+// (publicWholeDocument), and asked once for those asking at once
+// (sharedWholeDocument).
 async function readDocument(name: string, url: string, privileged: boolean,
   { whole = false, anonymous = true, ...options }: { accept: string; limit: number; signal: AbortSignal; whole?: boolean; anonymous?: boolean }) {
-  const open = anonymous ? whole ? await publicWholeDocument(name, url, options) : await registryDocument(url, { ...options, token: null }) : null
+  const open = anonymous ? whole ? await sharedWholeDocument(name, url, options) : await registryDocument(url, { ...options, token: null }) : null
   if (open) return { json: open, private: false }
   if (!npmTokenReads(name, privileged)) return null
   const json = await registryDocument(url, { ...options, token: npmToken() })
@@ -203,6 +250,8 @@ function versionDocument(name: string, json: Record<string, unknown>, isPrivate:
 // (npm-manifest.ts npmVersionFields), as the database keeps them (npm-kept.ts).
 export interface NpmVersionStore {
   read(name: string, version: string): Promise<{ at: number; json: Record<string, unknown> } | null>
+  // Those of `versions` kept, by `name@version`, in one read.
+  readMany?(versions: { name: string; version: string }[]): Promise<Map<string, { at: number; json: Record<string, unknown> }>>
   write(name: string, version: string, json: Record<string, unknown>): Promise<void>
 }
 
@@ -228,6 +277,20 @@ export function readNpmVersion(name: string, spec: string, privileged: boolean,
   })
 }
 
+// `store`, where it reads many at once, with the exact ones of `versions`
+// read from it in one read, for readNpmVersion to read each of those from as
+// it asks: a version and the one it is compared with, read together.
+export function readTogether(store: NpmVersionStore, versions: { name: string; version: string }[]): NpmVersionStore {
+  const exact = versions.filter(({ version }) => isExactVersion(version))
+  if (!store.readMany || exact.length < 2) return store
+  const keys = new Set(exact.map(({ name, version }) => `${name}@${version}`))
+  const kept = store.readMany(exact)
+  return { ...store, async read(name, version) {
+    const key = `${name}@${version}`
+    return keys.has(key) ? (await kept).get(key) ?? null : store.read(name, version)
+  } }
+}
+
 // The package's dist-tags and versions, newest published first, from its
 // abbreviated document; with `times`, from its whole one, which alone has
 // when each was published, `times` by version (ISO dates), and `created`,
@@ -277,22 +340,51 @@ const isPublishTime = (value: string | undefined) => typeof value === 'string' &
 const PUBLISH_TIMES = 100_000
 const publishTimes = new Map<string, string>()
 
-export const npmPublishTime = (name: string, version: string): string | null => publishTimes.get(`${name}@${version}`) ?? null
+// Where public versions' publish times are kept beyond the instance, as the
+// database keeps them (npm-kept.ts npmPublishTimeStore).
+export interface NpmPublishTimeStore {
+  read(name: string, version: string): Promise<string | null>
+  write(name: string, version: string, at: string): Promise<void>
+}
+
+// When `doc` was published: as noted here, else as `store` keeps a public
+// version's, so that another instance, or this one restarted, has it before
+// it reads the whole document again. The store is read once, at once, beside
+// whatever its caller reads meanwhile, a failure read as none; `read` looks
+// here again as it is asked, as the whole document read meanwhile may have
+// noted it by then, and `keep` keeps there the time noted here where it read
+// none.
+export function npmPublishTime(doc: Pick<NpmVersionDocument, 'name' | 'version' | 'private'>, store?: NpmPublishTimeStore) {
+  const noted = () => publishTimes.get(`${doc.name}@${doc.version}`) ?? null
+  const kept = store && !doc.private ? store.read(doc.name, doc.version).catch(() => null) : Promise.resolve(null)
+  return {
+    read: async (): Promise<string | null> => noted() ?? await kept ?? noted(),
+    async keep() {
+      const at = noted()
+      if (at !== null && store && !doc.private && await kept === null) await store.write(doc.name, doc.version, at)
+    },
+  }
+}
 
 export interface NpmPackageFile { path: string; bytes: Uint8Array }
 
+// How a tar stream is read (readNpmTar): how far its symlinks may climb above
+// it, and the entries, files and bytes it may hold, a package's unless given.
+export interface TarReading { symlinksAbove?: number; maxEntries?: number; maxFiles?: number; maxBytes?: number }
+
 // The regular files of a tar stream, by package path: npm drops the first
 // component (`package/`, or whatever the archive used), and a file at the top
 // is not extracted. The stream is read by @preventive/archive, which refuses
 // one malformed, a name or a symlink that would climb out of it -- a symlink
 // past `symlinksAbove` levels above it, none unless given -- and a name
-// repeated as another entry, and gives up past MAX_NPM_TAR_ENTRIES before
-// reading on; a file under another top directory at the same path replaces
-// an earlier one, as extraction would. Directories, links and devices hold no
+// repeated as another entry, and gives up past `maxEntries` before reading
+// on; a file under another top directory at the same path replaces an
+// earlier one, as extraction would. Directories, links and devices hold no
 // file content and are skipped.
-export function readNpmTar(tar: Uint8Array, { symlinksAbove = 0 }: { symlinksAbove?: number } = {}): NpmPackageFile[] {
+export function readNpmTar(tar: Uint8Array, { symlinksAbove = 0, maxEntries = MAX_NPM_TAR_ENTRIES, maxFiles = MAX_NPM_PACKAGE_FILES,
+  maxBytes = MAX_NPM_PACKAGE_BYTES }: TarReading = {}): NpmPackageFile[] {
   let entries: Entry[]
-  try { entries = unpack(tar, { maxEntries: MAX_NPM_TAR_ENTRIES, symlinksAbove }) }
+  try { entries = unpack(tar, { maxEntries, symlinksAbove }) }
   catch (err) {
     if (err instanceof ArchiveError) throw err.limited ? new NpmPackageError(413, 'package-too-large') : new NpmPackageError(422, 'bad-tarball')
     throw err
@@ -305,7 +397,7 @@ export function readNpmTar(tar: Uint8Array, { symlinksAbove = 0 }: { symlinksAbo
     const path = name.slice(slash + 1)
     total += data.length - (files.get(path)?.length ?? 0)
     files.set(path, data)
-    if (files.size > MAX_NPM_PACKAGE_FILES || total > MAX_NPM_PACKAGE_BYTES) throw new NpmPackageError(413, 'package-too-large')
+    if (files.size > maxFiles || total > maxBytes) throw new NpmPackageError(413, 'package-too-large')
   }
   return [...files].map(([path, bytes]) => ({ path, bytes })).toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)
 }
@@ -335,13 +427,14 @@ const ROW_LENGTH = 80
 
 // The files as the viewer gets them: `[path, bytes, text]`, text null for a
 // file that is not UTF-8, which instead carries its bytes' sha256, so a
-// comparison of two versions tells a changed one from an unchanged one.
-export function npmFileRows(files: NpmPackageFile[]): ([string, number, string] | [string, number, null, string])[] {
+// comparison of two versions tells a changed one from an unchanged one. They
+// may take `maxLength` characters of JSON, a package's unless given.
+export function npmFileRows(files: NpmPackageFile[], maxLength = MAX_NPM_JSON_LENGTH): ([string, number, string] | [string, number, null, string])[] {
   let length = 0
   return files.map(({ path, bytes }) => {
     const text = npmFileText(bytes)
     length += ROW_LENGTH + jsonLength(path) + (text === null ? 0 : jsonLength(text))
-    if (length > MAX_NPM_JSON_LENGTH) throw new NpmPackageError(413, 'package-too-large')
+    if (length > maxLength) throw new NpmPackageError(413, 'package-too-large')
     return text === null ? [path, bytes.byteLength, null, `sha256-${createHash('sha256').update(bytes).digest('base64')}`] : [path, bytes.byteLength, text]
   })
 }

package/server-managed/npm-risk.ts

@@ -14,8 +14,15 @@
 //   instance, or this one restarted, asks npm's downloads API, which answers
 //   some 40 lookups a minute, none of them again that week, each removed a
 //   day past it (npm-kept.ts pruneKept); a private one's in memory.
-// - `risk/npm/packages`, `risk/npm/public` and `risk/npm/advisories`, kept an
-//   hour or a day by risk itself: in memory.
+// - `risk/npm/packages`, `risk/npm/old-versions`, `risk/npm/public` and
+//   `risk/npm/advisories`, which risk asks again after an hour: a public
+//   package's in memory and in the database too, read from memory first, so
+//   that a cold instance, as a serverless one starts, reads no whole document
+//   of npm's again that one before it read within the hour; by a hash of
+//   their type and key, as a dependency's spec runs to any length, each
+//   removed a day on, and one past 256 KiB as JSON (a package's deprecated
+//   versions, its messages and all, run long) in memory alone. A private
+//   one's in memory.
 // - `npm/tarballs`: none asked, as tarballs are read as the viewer's loads
 //   read them, kept where they keep them (npm-loads.ts loadNpmTarball), and
 //   an assessment kept needs none.
@@ -35,6 +42,7 @@ import { buffer } from 'node:stream/consumers'
 import type { CacheStore } from '@preventive/upstream/npm.js'
 import { DEFAULT_MINIMUM_RELEASE_AGE, type NpmAssessment, assessNpm, npmReadyDownload, npmReadyDownloads } from '../risk/index.js'
 import { CacheMissError, type CacheStorage } from './cache-storage.ts'
+import { npmVersionStore } from './npm-kept.ts'
 import { loadNpmTarball } from './npm-loads.ts'
 import { NpmPackageError, type NpmVersionDocument, npmTokenReads, readNpmPackument, readNpmVersion } from './npm-packages.ts'
 import { npmPackageScope } from '../common/managed/npm-packages.js'
@@ -68,11 +76,20 @@ function remember(key: string, value: unknown) {
   while (memory.size > MEMORY_ENTRIES || memoryLength > MEMORY_LENGTH) forget(memory.keys().next().value!)
 }
 
-const hashed = (type: string, key: string) => `risk/${createHash('sha256').update(`${type}\0${key}`).digest('hex')}`
-// What of a public package is kept in the database, and for how long its
-// downloads are: risk's week, and a day more.
+const digest = (type: string, key: string) => createHash('sha256').update(`${type}\0${key}`).digest('hex')
+const hashed = (type: string, key: string) => `risk/${digest(type, key)}`
+// What of a public package is kept in the database by its key, and for how
+// long its downloads are: risk's week, and a day more.
 const IN_DATABASE = new Set(['risk/npm/versions', 'risk/npm/downloads'])
 const DOWNLOADS_KEPT_MS = 8 * 24 * 60 * 60_000
+// What of a public package risk asks again after an hour, kept in memory and
+// in the database (HOURLY_PREFIX), each a day, none past HOURLY_LENGTH as
+// JSON there.
+const HOURLY = new Set(['risk/npm/packages', 'risk/npm/old-versions', 'risk/npm/public', 'risk/npm/advisories'])
+const HOURLY_PREFIX = 'risk/hourly/'
+const HOURLY_KEPT_MS = 24 * 60 * 60_000
+const HOURLY_LENGTH = 256 * 1024
+const databaseKey = (type: string, key: string) => HOURLY.has(type) ? `${HOURLY_PREFIX}${digest(type, key)}` : `${type}/${key}`
 
 export interface NpmRiskStores {
   db: UpstreamCacheStore
@@ -81,10 +98,13 @@ export interface NpmRiskStores {
 }
 
 // A cache that reads and writes many of a type at once too, as risk's
-// readying of downloads asks (npmReadyDownloads): one read and one write of
-// the database each, not one a key, as a request's queries take turns on its
-// connection (db-neon.ts).
+// readying of downloads asks (npmReadyDownloads), and reads records of any
+// types at once, as risk reads a package's record and its versions'
+// (registry.js npmPackageFacts): one read and one write of the database each,
+// not one a key, as a request's queries take turns on its connection
+// (db-neon.ts).
 export interface NpmRiskCache extends CacheStore {
+  readEach(entries: [type: string, key: string][]): Promise<unknown[]>
   readMany(type: string, keys: string[]): Promise<Map<string, unknown>>
   writeMany(type: string, entries: [key: string, value: unknown][]): Promise<void>
 }
@@ -93,13 +113,32 @@ export interface NpmRiskCache extends CacheStore {
 // that what is kept of it can be shared.
 export function npmRiskCache({ db, npmCache, debug }: NpmRiskStores, isPublic: boolean): NpmRiskCache {
   const warn = (what: string, error: unknown) => { if (debug) console.warn(`managed: risk cache ${what} failed:`, error) }
+  const memoryKey = (type: string, key: string) => `${isPublic ? '' : 'private\0'}${type}\0${key}`
+  // Whether a record of `type` is read of the database: unless it is one
+  // kept in memory too (HOURLY) and there.
+  const ofDatabase = (type: string, key: string) => isPublic && (IN_DATABASE.has(type) || HOURLY.has(type) && !memory.has(memoryKey(type, key)))
+  // A record as the database keeps it, read: an hourly one kept in memory
+  // too, for the next to ask.
+  const readOf = (type: string, key: string, row: string | null | undefined) => {
+    const value: unknown = row == null ? null : JSON.parse(row)
+    if (value !== null && HOURLY.has(type)) remember(memoryKey(type, key), value)
+    return value
+  }
   const cache: NpmRiskCache = {
+    async readEach(entries) {
+      const asked = new Set(entries.flatMap(([type, key], i) => ofDatabase(type, key) ? [i] : []))
+      let rows = new Map<string, string>()
+      if (asked.size > 0) {
+        try { rows = await db.getUpstreamCacheEntries([...asked].map(i => databaseKey(...entries[i]!))) } catch (error) { warn('read', error) }
+      }
+      return Promise.all(entries.map(([type, key], i) => {
+        if (!asked.has(i)) return cache.read(type, key)
+        try { return readOf(type, key, rows.get(databaseKey(type, key))) } catch (error) { warn('read', error); return null }
+      }))
+    },
     async readMany(type, keys) {
-      if (!isPublic || !IN_DATABASE.has(type)) return new Map(await Promise.all(keys.map(async key => [key, await cache.read(type, key)] as const)))
-      try {
-        const found = await db.getUpstreamCacheEntries(keys.map(key => `${type}/${key}`))
-        return new Map(keys.map(key => { const value = found.get(`${type}/${key}`); return [key, value === undefined ? null : JSON.parse(value)] }))
-      } catch (error) { warn('read', error); return new Map() }
+      const values = await cache.readEach(keys.map(key => [type, key]))
+      return new Map(keys.map((key, i) => [key, values[i]]))
     },
     async writeMany(type, entries) {
       if (!isPublic || !IN_DATABASE.has(type)) { for (const [key, value] of entries) await cache.write(type, key, value); return }
@@ -111,22 +150,31 @@ export function npmRiskCache({ db, npmCache, debug }: NpmRiskStores, isPublic: b
       if (type === 'npm/tarballs') return null
       try {
         if (isPublic && type === 'risk/npm/assessments' && npmCache) return JSON.parse((await buffer((await npmCache.open(hashed(type, key))).stream)).toString('utf8'))
-        if (isPublic && IN_DATABASE.has(type)) { const value = await db.getUpstreamCacheEntry(`${type}/${key}`); return value === null ? null : JSON.parse(value) }
+        if (ofDatabase(type, key)) return readOf(type, key, await db.getUpstreamCacheEntry(databaseKey(type, key)))
       } catch (error) { if (!(error instanceof CacheMissError)) warn('read', error); return null }
-      return memory.get(`${isPublic ? '' : 'private\0'}${type}\0${key}`)?.value ?? null
+      return memory.get(memoryKey(type, key))?.value ?? null
     },
     async write(type, key, value) {
       if (type === 'npm/tarballs') return
+      if (isPublic && HOURLY.has(type)) remember(memoryKey(type, key), value)
       try {
         if (isPublic && type === 'risk/npm/assessments' && npmCache) { await npmCache.put(hashed(type, key), Buffer.from(JSON.stringify(value))); return }
         if (isPublic && IN_DATABASE.has(type)) {
           const at = Date.now()
-          await db.setUpstreamCacheEntry(`${type}/${key}`, JSON.stringify(value), at)
+          await db.setUpstreamCacheEntry(databaseKey(type, key), JSON.stringify(value), at)
           if (type === 'risk/npm/downloads') await pruneKept(db, `${type}/`, DOWNLOADS_KEPT_MS, at, error => { warn('prune', error) })
           return
         }
+        if (isPublic && HOURLY.has(type)) {
+          const json = JSON.stringify(value)
+          if (json.length > HOURLY_LENGTH) return
+          const at = Date.now()
+          await db.setUpstreamCacheEntry(databaseKey(type, key), json, at)
+          await pruneKept(db, HOURLY_PREFIX, HOURLY_KEPT_MS, at, error => { warn('prune', error) })
+          return
+        }
       } catch (error) { warn('write', error); return }
-      remember(`${isPublic ? '' : 'private\0'}${type}\0${key}`, value)
+      remember(memoryKey(type, key), value)
     },
   }
   return cache
@@ -176,7 +224,9 @@ export function npmRisk(doc: NpmVersionDocument, old: NpmVersionDocument | 'pick
     return scopes.get(scope)!
   }
   const given = old === 'pick' ? null : old
-  const documentOf = async (version: string) => [doc, given].find(read => read?.version === version) ?? await readNpmVersion(doc.name, version, privileged, signal) ?? undefined
+  // The one picked, read as the viewer reads a version, kept a day where public.
+  const documentOf = async (version: string) => [doc, given].find(read => read?.version === version)
+    ?? await readNpmVersion(doc.name, version, privileged, signal, npmVersionStore(stores.db, stores.debug)) ?? undefined
   return bounded(spare, () => assessNpm(doc.name, doc.version, { oldVersion: old === 'pick' ? true : old?.version ?? null, fromEmpty,
     minimumReleaseAge: teamScoped ? 0 : DEFAULT_MINIMUM_RELEASE_AGE,
     popularity: !teamScoped, cache: npmRiskCache(stores, !doc.private && !given?.private), signal, dependencies: !spare, advisories: !spare, osv: !doc.private, owned,

package/server-managed/pretty-print.ts

@@ -12,16 +12,17 @@ import { promisify } from 'node:util'
 import { brotliDecompress } from 'node:zlib'
 import { format } from '@preventive/compare/pretty.js'
 import { computeFileHash } from '@preventive/report'
-import { FILE_HASH } from '../common/bundle-metadata.js'
+import { FILE_HASH, computeBundleFileHashes } from '../common/bundle-metadata.js'
 import { bundleCompareFiles } from '../common/bundle-compare-inputs.js'
 import { bundlePackageDirs, bundleSourcesAsMap } from '../common/bundle-sources.js'
 import { MAX_PRETTY_BYTES, needsPrettyPrint, prettyExtension } from '../common/pretty-print.js'
 import type { OpenedBlob } from './blob-store.ts'
-import { type BundleCacheStorage, readBundleDetails } from './bundle-cache.ts'
+import { type BundleCacheStorage, readSizedBundleDetails } from './bundle-cache.ts'
 import type { BundleStore } from './bundle-store.ts'
 import { encodeBrotli } from './brotli.ts'
 import { CacheMissError, type CacheStorage } from './cache-storage.ts'
 import type { ManagedBundle, ManagedDb } from './db.ts'
+import { keptBriefly } from './kept-briefly.ts'
 import { loadNpmFiles } from './npm-loads.ts'
 import { type NpmVersionDocument, npmFileText } from './npm-packages.ts'
 
@@ -34,6 +35,20 @@ const PRETTY_VERSION = 4
 // after another, beside other readers'), any more refused.
 const MAX_ACTIVE_FORMATS = 2
 const MAX_WAITING_FORMATS = 16
+// How long a bundle's details are kept once read, and what the two last read
+// may have decoded from between them, the least lately read going first past
+// it: Compare's requests for a pair of bundles come one after another, each
+// reading both, and the Code tab's for one, each reading it.
+const DETAILS_KEPT_MS = 60_000
+const MAX_KEPT_DETAILS = 2
+const MAX_KEPT_DETAILS_BYTES = 256 * 1024 * 1024
+// Files hashed at once: one at a time, each waits its own round trip to the
+// thread pool; all at once, every one's job is held together.
+const HASHES_AT_ONCE = 32
+// Kept copies a stream reads ahead of the line it is sending (readAhead):
+// one at a time, each waits its own storage round trip; each read whole, as
+// its line will send it.
+const KEPT_AHEAD = 8
 
 export class PrettyError extends Error {
   status: number
@@ -108,6 +123,18 @@ export async function prettyBody(text: string, extension: string): Promise<Buffe
 
 const opened = (body: Buffer): OpenedBlob => ({ size: body.byteLength, stream: Readable.from([body]) })
 
+// A version's file's hash, by its bytes: those of a version's files loaded
+// a little while since are the same bytes (npm-loads.ts), hashed once.
+const fileHashes = new WeakMap<Uint8Array, Promise<string>>()
+function npmFileHash(bytes: Uint8Array): Promise<string> {
+  let hash = fileHashes.get(bytes)
+  if (!hash) {
+    fileHashes.set(bytes, hash = computeFileHash(bytes))
+    hash.catch(() => { fileHashes.delete(bytes) })
+  }
+  return hash
+}
+
 const decompress = promisify(brotliDecompress)
 
 // A pretty-printed copy's text, from its Brotli-encoded bytes.
@@ -127,7 +154,7 @@ async function npmPrintable(doc: NpmVersionDocument): Promise<Array<PrettyReques
       const extension = prettyExtension(path)
       if (extension === null || bytes.byteLength > MAX_PRETTY_BYTES) continue
       const text = npmFileText(bytes)
-      if (text !== null && needsPrettyPrint(path, text)) files.push({ path, hash: await computeFileHash(bytes), extension, text })
+      if (text !== null && needsPrettyPrint(path, text)) files.push({ path, hash: await npmFileHash(bytes), extension, text })
     }
   } finally { load.release() }
   return files.toSorted((a, b) => (a.path < b.path ? -1 : 1))
@@ -143,6 +170,29 @@ async function prettyLine({ path, hash }: PrettyRequest, copy: () => Promise<Ope
   }
 }
 
+// A file's line from its kept copy, `open` opening it, or null where none is
+// kept.
+async function keptLine(request: PrettyRequest, open: () => Promise<OpenedBlob | null>): Promise<PrettyLine | null> {
+  const copy = await open()
+  return copy && prettyLine(request, () => Promise.resolve(copy))
+}
+
+// Each of `items` with what `read` reads of it, in their order, up to
+// KEPT_AHEAD of them read at once ahead of the one iterated, each answered
+// (or failing) in its turn. One iterated no further starts no more; those
+// under way settle unread.
+async function* readAhead<T, R>(items: readonly T[], read: (item: T) => Promise<R>): AsyncGenerator<[T, R]> {
+  const reads: Promise<R>[] = []
+  for (const [i, item] of items.entries()) {
+    while (reads.length < Math.min(items.length, i + KEPT_AHEAD)) {
+      const reading = read(items[reads.length]!)
+      reading.catch(() => {})
+      reads.push(reading)
+    }
+    yield [item, await reads[i]!]
+  }
+}
+
 // The files that changed between two sides, pretty-printed: each side's
 // formattable files the other has another text at the path of, or, where it
 // has none there, none of their text at a path of its own (a file renamed, or
@@ -151,8 +201,9 @@ async function prettyLine({ path, hash }: PrettyRequest, copy: () => Promise<Ope
 // the viewer diffs but where it pairs files otherwise (among copies of one
 // text, across packages), whose copies it asks for alone. As they are
 // iterated, in path order, the base's first where both have one: those kept,
-// at once; then the rest, formatted one after another, the minified before
-// the others (needsPrettyPrint), as the viewer prints those unasked.
+// at once, a few read ahead (readAhead); then the rest, formatted one after
+// another, the minified before the others (needsPrettyPrint), as the viewer
+// prints those unasked.
 export function compared(sides: readonly [ComparedSide, ComparedSide]): AsyncGenerator<ComparedLine> {
   // Each side's texts at the paths the other hasn't: where a file moved has its own.
   const moved = sides.map((own, i) => new Set([...own.hashes].filter(([path]) => !sides[1 - i]!.hashes.has(path)).map(([, hash]) => hash)))
@@ -162,9 +213,8 @@ export function compared(sides: readonly [ComparedSide, ComparedSide]): AsyncGen
   }).toSorted((a, b) => (a.file.path < b.file.path ? -1 : a.file.path > b.file.path ? 1 : 0))
   return (async function* () {
     const unkept: typeof changed = []
-    for (const { own, file } of changed) {
-      const copy = await own.kept(file)
-      if (copy) yield { side: own.side, ...await prettyLine(file, () => Promise.resolve(copy)) }
+    for await (const [{ own, file }, line] of readAhead(changed, item => keptLine(item.file, () => item.own.kept(item.file)))) {
+      if (line) yield { side: own.side, ...line }
       else unkept.push({ own, file })
     }
     const minified = new Map(unkept.map(({ file }) => [file, needsPrettyPrint(file.path, file.text)]))
@@ -206,26 +256,35 @@ async function kept(open: () => Promise<OpenedBlob>): Promise<OpenedBlob | null>
 
 // A side's files that can be formatted, with their texts, and every one of
 // its files' hashes by path, from their paths and contents: texts, or bytes,
-// read as text where they are.
-async function sideFiles(entries: Iterable<[string, string | Uint8Array]>): Promise<Pick<ComparedSide, 'files' | 'hashes'>> {
+// read as text where they are; hashed by `hashOf`, a few at once.
+async function sideFiles<T extends string | Uint8Array>(entries: Array<[string, T]>, hashOf: (file: string, content: T) => Promise<string>): Promise<Pick<ComparedSide, 'files' | 'hashes'>> {
   const files: ComparedSide['files'] = [], hashes = new Map<string, string>()
+  for (let i = 0; i < entries.length; i += HASHES_AT_ONCE) {
+    const chunk = entries.slice(i, i + HASHES_AT_ONCE)
+    const hashed = await Promise.all(chunk.map(async ([path, content]) => [path, await hashOf(path, content)] as const))
+    for (const [path, hash] of hashed) hashes.set(path, hash)
+  }
   for (const [path, content] of entries) {
-    const hash = await computeFileHash(content)
-    hashes.set(path, hash)
     const extension = prettyExtension(path)
     if (extension === null || (typeof content === 'string' ? Buffer.byteLength(content) : content.byteLength) > MAX_PRETTY_BYTES) continue
     const text = typeof content === 'string' ? content : npmFileText(content)
-    if (text !== null) files.push({ path, hash, extension, text })
+    if (text !== null) files.push({ path, hash: hashes.get(path)!, extension, text })
   }
   return { files, hashes }
 }
 
 // A bundle's side, from its details: its files, as sideFiles reads them,
 // within a reason `scope` as Compare reads them there (bundleCompareFiles),
-// and its packages' directories.
+// and its packages' directories; hashed once for its details, as long as
+// they are kept (computeBundleFileHashes).
 async function bundleSide(details: Parameters<typeof bundlePackageDirs>[0], scope: string): Promise<Pick<ComparedSide, 'files' | 'hashes' | 'packageDirs'>> {
   const scoped = scope ? new Set(bundleCompareFiles(details, scope).keys()) : null, sources = bundleSourcesAsMap(details)
-  return { ...await sideFiles(scoped ? [...sources].filter(([path]) => scoped.has(path)) : sources), packageDirs: bundlePackageDirs(details) }
+  const hashed: Map<string, string> = await computeBundleFileHashes(details)
+  return { ...await sideFiles(scoped ? [...sources].filter(([path]) => scoped.has(path)) : [...sources], (path, content) => {
+    const hash = hashed.get(path)
+    return hash === undefined ? computeFileHash(content) : Promise.resolve(hash)
+  }),
+    packageDirs: bundlePackageDirs(details) }
 }
 
 // A version's files by path, from one load of them.
@@ -251,14 +310,25 @@ export function stalePrettyRemover(npm: CacheStorage): (signal?: AbortSignal) =>
 }
 
 // A bundle's details, from its bytes in `store`: bundles are read one at a
-// time, as reading one decodes all of it.
+// time, as reading one decodes all of it, readers asking for one waiting its
+// turn or being read sharing it; and kept a little while once read
+// (DETAILS_KEPT_MS), each reader's access to the bundle the caller's to check
+// as ever.
 function detailsReader(store: BundleStore) {
-  const enqueue = serial()
-  return (record: ManagedBundle) => enqueue(async () => {
-    const details = await readBundleDetails(record, store)
-    if (!details) throw new PrettyError(422, 'bundle-unavailable')
-    return details
-  })
+  type Details = NonNullable<Awaited<ReturnType<typeof readSizedBundleDetails>>>['details']
+  const enqueue = serial(), share = sharing<Details>()
+  const held = keptBriefly<Details>({ keptMs: DETAILS_KEPT_MS, maxBytes: MAX_KEPT_DETAILS_BYTES, maxEntries: MAX_KEPT_DETAILS })
+  return (record: ManagedBundle): Promise<Details> => {
+    const key = `${record.id} ${record.integrity}`
+    const hit = held.get(key)
+    if (hit) return Promise.resolve(hit)
+    return share(key, () => enqueue(async () => {
+      const read = await readSizedBundleDetails(record, store)
+      if (!read) throw new PrettyError(422, 'bundle-unavailable')
+      held.keep(key, read.details, read.decodedBytes)
+      return read.details
+    }))
+  }
 }
 
 export function createPrettyCache(bundles: BundleCacheStorage, npm: CacheStorage, db: Pick<ManagedDb, 'getBundle'>, store: BundleStore) {
@@ -282,15 +352,18 @@ export function createPrettyCache(bundles: BundleCacheStorage, npm: CacheStorage
       return body
     })
   }
+  // The copy kept for a public version's file, or null where none is (and
+  // for a private version's, which none is kept for).
+  const npmKept = (doc: NpmVersionDocument, request: PrettyRequest) => (doc.private ? Promise.resolve(null) : kept(() => npm.open(prettyFile(request))))
   // A version's file pretty-printed, `read` reading its text (and checking
   // it is the file named): from the copy kept for a public version, else
   // made, and kept for a public one.
   async function npmCopy(doc: NpmVersionDocument, request: PrettyRequest, read: () => Promise<string>): Promise<OpenedBlob> {
+    return await npmKept(doc, request) ?? npmMade(doc, request, read)
+  }
+  // The file pretty-printed from the text `read` reads, kept for a public version.
+  async function npmMade(doc: NpmVersionDocument, request: PrettyRequest, read: () => Promise<string>): Promise<OpenedBlob> {
     const file = prettyFile(request)
-    if (!doc.private) {
-      try { return await npm.open(file) }
-      catch (err) { if (!(err instanceof CacheMissError)) throw err }
-    }
     return opened(await shared(doc.private ? `npm ${doc.dist.integrity} ${file}` : `npm ${file}`, async () => {
       const body = await prettyBody(await read(), request.extension)
       if (!doc.private) await keep(() => npm.put(file, body))
@@ -317,7 +390,7 @@ export function createPrettyCache(bundles: BundleCacheStorage, npm: CacheStorage
         try {
           const bytes = (await load.result).find(entry => entry.path === request.path)?.bytes
           if (!bytes) throw new PrettyError(404, 'no-file')
-          if (await computeFileHash(bytes) !== request.hash) throw new PrettyError(409, 'hash-mismatch')
+          if (await npmFileHash(bytes) !== request.hash) throw new PrettyError(409, 'hash-mismatch')
           text = npmFileText(bytes)
         } finally { load.release() }
         if (text === null) throw new PrettyError(422, 'unformattable')
@@ -326,11 +399,14 @@ export function createPrettyCache(bundles: BundleCacheStorage, npm: CacheStorage
     },
     // Every file of the version that needs pretty-printing (npmPrintable),
     // read before this resolves; then, as they are iterated, each
-    // pretty-printed as `npm` has it, one after another.
+    // pretty-printed as `npm` has it, one after another, those kept a few
+    // read ahead (readAhead).
     async npmAll(doc: NpmVersionDocument): Promise<AsyncGenerator<PrettyLine>> {
       const files = await npmPrintable(doc)
       return (async function* () {
-        for (const { text, ...request } of files) yield await prettyLine(request, () => npmCopy(doc, request, () => Promise.resolve(text)))
+        for await (const [file, line] of readAhead(files, request => keptLine(request, () => npmKept(doc, request)))) {
+          yield line ?? await prettyLine(file, () => npmMade(doc, file, () => Promise.resolve(file.text)))
+        }
       })()
     },
     // Two bundles' sides, or two versions', as a comparison reads them, read
@@ -338,19 +414,20 @@ export function createPrettyCache(bundles: BundleCacheStorage, npm: CacheStorage
     // pretty-printed (compared), and their diffs with renamed names hidden
     // (rename-diff.ts renamedPairs); a bundle's within a reason `scope`
     // where one is asked for, as Compare reads it then.
-    async bundleSides(base: ManagedBundle, other: ManagedBundle, scope = ''): Promise<[ComparedSide, ComparedSide]> {
+    bundleSides(base: ManagedBundle, other: ManagedBundle, scope = ''): Promise<[ComparedSide, ComparedSide]> {
       const sideOf = async (record: ManagedBundle, side: Side): Promise<ComparedSide> => ({ side, ...await bundleSide(await bundleDetails(record), scope),
         kept: request => kept(() => bundles.open(record.id, prettyFile(request))),
         made: async (request, text) => opened(await bundleCopy(record, request, () => Promise.resolve(text))) })
-      return [await sideOf(base, 'base'), await sideOf(other, 'other')]
+      return Promise.all([sideOf(base, 'base'), sideOf(other, 'other')])
     },
     // A bundle's details, read in its turn, as Compare pairs them (comparison.ts).
     bundleDetails,
-    async npmSides(base: NpmVersionDocument, other: NpmVersionDocument): Promise<[ComparedSide, ComparedSide]> {
-      const sideOf = async (doc: NpmVersionDocument, side: Side): Promise<ComparedSide> => ({ side, ...await sideFiles(await npmFiles(doc)), packageDirs: null,
-        kept: request => (doc.private ? Promise.resolve(null) : kept(() => npm.open(prettyFile(request)))),
+    npmSides(base: NpmVersionDocument, other: NpmVersionDocument): Promise<[ComparedSide, ComparedSide]> {
+      const sideOf = async (doc: NpmVersionDocument, side: Side): Promise<ComparedSide> => ({ side, ...await sideFiles(await npmFiles(doc), (_, bytes) => npmFileHash(bytes)),
+        packageDirs: null,
+        kept: request => npmKept(doc, request),
         made: (request, text) => npmCopy(doc, request, () => Promise.resolve(text)) })
-      return [await sideOf(base, 'base'), await sideOf(other, 'other')]
+      return Promise.all([sideOf(base, 'base'), sideOf(other, 'other')])
     },
   }
 }